@aboutweb/proxyclass
v2.0.6
Published
A seemless way for organizing multi inheritance.
Downloads
23
Maintainers
Readme
proxy-class
A seemless way to organize multi inheritance.
Caution this function uses ES6 Proxies, Sets and Symbols. Use Ring.js or similar libaries, if you want an ES5 approach.
You should always prefer other patterns like decorators or annotions if you can, because javascript does not support this for good reasons:
- must have the same arguments signiture
- hard to isolate instances
- overhead
ProxyClass(...mixins
)
Uses ProxyScope to reflects all changes to prototype
of all mixins
.
ProxyClass.hasInstance(...mixins
)
Allows the use of instanceof
by overwriting all Subclass[Symbols.hasInstance]
.
Caution: this will make instanceof more expensive.
Examples
const EventEmitter = require('events');
const listen = ["on", "once"];
class ArrayEmitter extends ProxyClass.hasInstance(Array, EventEmitter) {
constructor(options) {
let { data } = options;
super(...data);
listen.forEach((property) => {
let type = options[property];
if(type) {
for(let event in type) {
let listeners = type[event];
if(!Array.isArray(listeners)) {
listeners = [listeners];
}
listeners.forEach((listener) => {
this[property](event, listener)
});
}
}
});
this.emit("push", data);
}
push(...args) {
super.push(...args);
this.emit("push", args);
}
}
let input = ["fubar", "haha"];
let ae = new ArrayEmitter({
data : input,
on : {
push(...args) {
console.log("every push", args);
}
},
once : {
push(...args) {
console.log("inital push", args);
}
}
});
ae.push("last");
//will be true
na instanceof ArrayEmitter;
na instanceof Array;
na instanceof EventEmitter;
Deep Classes
class A {
constructor() {
this.aProp = true;
this.shared = "sharedA";
}
get isA() {
return true;
}
get sharedA() {
return this.shared;
}
sharedAFn() {
return this.shared;
}
}
class B { get isB() { return true; } }
class C extends ProxyClass.hasInstance(A, B) {
get isC() { return true; }
}
class D {
get isD() { return true; }
}
class E extends ProxyClass.hasInstance(C, D) {
constructor() {
super();
this.eProp = true;
}
get isE() { return true; }
};
//You can also inline your class
var F = ProxyClass.hasInstance(class {
constructor(someArg) {
this.someArg = someArg;
this.fProp = true;
}
get isF() {
return true;
}
}, E);
var e = new E();
//all of this will return true
e instanceof Object;
e instanceof A;
e instanceof B;
e instanceof C;
e instanceof D;
e instanceof E;
e.isA;
e.isB;
e.isC;
e.isD;
e.isE;
e.aProp;
e.eProp;
var f = new F("fubar");
//same as e plus
f instanceof F;
f.isF;
f.fProp;
f.someArg == "fubar";
Isolation
All class member function will get called with their own isolated context.
expect(e.shared).toEqual("sharedE");
expect(e.sharedA).toEqual("sharedA");
expect(e.sharedAFn()).toEqual("sharedA");
Dependancies
Licence
ISC