Is a factory of classes a valid javascript pattern?

Some time ago I learnt a lot of design-patters, specially creational ones. After some time, I found myself using a patter that I though existed, but when I tried to search about it I didn't found any reference. Basically it is a small modification of a factory which takes advantages of the closures to resolve dependencies of a class. Actually, it is a factory of classes. Let's me illustrate this with a bit of code:

function Factory(depA,depB){

    function MyClass(something){
        this.something = something;
    }

    MyClass.prototype.methodA(){ // use depA}
    MyClass.prototype.methodB(){ // use depB}

   return myClass
}

Let's assume that depA is a database and depB is a logger. Then you can use the factory like this

BindedClass = Factory(database,logger);
instance = new BindedClass(something);

I find this patter very useful for injecting common dependencies, without loosing the control of how the class is actually instantiated.

However, this has some problems. For example, one of the things that made me realize that this is not so common is that JSDoc does not have support at all for this kind of pattern.

Is it a bad pattern? I can't find any disadvantage on it apart from less modularization and non-working documentation tools.