KayClass
Copyright © Kay Framework Team KayClass may be freely distributed under the MIT license. For all details and documentation: http://github.com/kay-framework/kayclass
KayClass is a simple Class implementation inspired by and built to mimic the ES6 class definition. It supports getter/setter prototype properties and static properties are included in much the same way as with a Backbone.JS class.
Prototype and static properties are inherited from the parent class, as well as property values such as enumerability and writability.
Named classes can be extended, and named classes with a prototype argument return the default constructor or the custom constructor - if provided - which references the parent via Class.super.
Usage
Class
Public: When a Class constructor is invoked with a name, proptotype and optional static properties, it returns a Constructor with the static properties, whose prototype is a composite of the prototype properties argument and any prototype properties of the parent.
Examples
var Class = require('kayclass');
var MyClass = Class('MyClass', {
protoFn: function () {},
get thing() {},
set thing(athing) {
this.athing = thing;
}
}, {
staticFn: function () {}
});
var myClassInstance = new MyClass();
// inheritance
assert(myClassInstance instanceof MyClass); // true
assert(myClassInstance instanceof Class); // false
assert(MyClass.prototype.protoFn === myClassInstance.protoFn); // trueClass.extends
Public: When given only a name argument, Class returns an object with an extends function. The extends function takes another class, a prototype properties object, and an optional static properties object.
Examples
var AnotherClass = Class('AnotherClass', {
protoFn: function fn1() {},
anotherProtoFn: function () {}
get thing() {},
set thing(athing) {
this.athing = thing;
}
}, {
staticFn: function () {}
});
var MyClass = Class('MyClass').extends(AnotherClass, {
protoFn: fn2() {},
myProtoFn: function () {}
});
var myClassInstance = new MyClass();
// inheritance
assert(myClassInstance instanceof MyClass); // true
assert(myClassInstance instanceof AnotherClass); // true
assert(myClassInstance instanceof Class); // false
// child properties override parent properties of the same name
assert(myClassInstance.protoFn === '[Function: fn2]'); // true
// parent prototype properties are copied to the child prototype
assert(myClassInstance.anotherProtoFn === AnotherClass.prototype.anotherProtoFn); // true
// parent static properties are copied to the child
assert(MyClass.staticFn === AnotherClass.staticFn); // true
// Constructor/instance has a reference to its immediate parent via Class.super()
assert(Class.super(myClassInstance) === AnotherClass.prototype); // true