https://github.com/ziflex/compose-class
Utility function that allows you to compose a class using mixins and decorators
https://github.com/ziflex/compose-class
Last synced: 3 months ago
JSON representation
Utility function that allows you to compose a class using mixins and decorators
- Host: GitHub
- URL: https://github.com/ziflex/compose-class
- Owner: ziflex
- License: mit
- Created: 2016-10-30T05:01:42.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2018-01-14T20:35:06.000Z (over 7 years ago)
- Last Synced: 2025-02-24T05:18:54.129Z (3 months ago)
- Language: JavaScript
- Homepage:
- Size: 10.7 KB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
# compose-class
> Composition over inheritance
Utility function that allows you to compose a class using mixins and decorators
[](https://www.npmjs.com/package/compose-class)
[](http://travis-ci.org/ziflex/compose-class)
[](https://coveralls.io/github/ziflex/compose-class)
````sh
npm install --save compose-class
````
## Motivation
The idea behind this package is to use mixins and decorators as buildings blocks and use them across an aplication code base.
## Usage
## Quick start
````javascript
import composeClass from 'compose-class';
const Class = composeClass({
constructor(name) {
this._name = name;
},
getName() {
return this._name;
}
});
const instance = new Class('Tom');
console.log(instance.getName()); // 'Tom'
````
## Using mixins
This is the main motivaton of writing this package.
````javascript
import composeClass from 'compose-class';
const WalkMixin = {
walk() {
console.log(this._name, 'is walking');
}
};
const TalkMixin = {
talk() {
console.log(this._name, 'is talking');
}
};
const Class = composeClass({
mixins: [
WalkMixin,
TalkMixin
],
constructor(name) {
this._name = name;
}
});
const tom = new Class('Tom');
tom.walk(); // 'Tom is walking'
tom.talk(); // 'Tom is talking'
````
### With mixin initialization
If mixin has defined ``constructor`` it will be invoked before main class constructor.
````javascript
// entity-mixin.js
import Symbol from 'es6-symbol';
const ID = Symbol('id');
let counter = 0;
export default {
constructor() {
counter += 1;
this[ID] = counter;
},
getId() {
return this[ID];
}
};
````
````javascript
// user.js
import composeClass from 'compose-class';
import EntityMixin from './entity-mixin';
import Symbol from 'es6-symbol';
const FIELDS = {
name: Symbol('name')
};
const User = composeClass({
mixins: [
EntityMixin
],
consturctor(name) {
this[FIELDS.name] = name;
console.log(this.getId()); // counter value
},
getName() {
return this[FIELDS.name];
},
setName(name) {
this[FIELDS.name] = name;
return this;
}
});
const u1 = new User('Tom');
console.log(u1.getId()); // '1';
console.log(u1.getName()); // 'Tom'
const u2 = new User('Jerry');
console.log(u1.getId()); // '2';
console.log(u1.getName()); // 'Jerry'
````
## Decorators
Sometimes using mixins is not enough to build a complex type wtih many rules. In order to execute pre/post conditions against type methods we need to wrap them. Decorators is the best tool for it.
In order to apply decorator to an instance, it needs to pass decorator factory to ``decorators`` array which accepts 2 arguments: name and function.
````javascript
// assert-decorator.js
export default function AssertDecorator(name, method) {
if (name.indexOf('set') < 0) {
return method;
}
return function checkInput(value) {
if (!value) {
throw new Error('Value is missed');
}
return method.apply(this, value);
};
}
````
````javascript
// user.js
import composeClass from 'compose-class';
import EntityMixin from './entity-mixin';
import AssertInputDecorator from './assert-decorator';
import Symbol from 'es6-symbol';
const FIELDS = {
name: Symbol('name')
};
const User = composeClass({
mixins: [
EntityMixin
],
decorators: [
AssertInputDecorator
],
consturctor(name) {
this[FIELDS.name] = name;
console.log(this.getId()); // counter value
},
getName() {
return this[FIELDS.name];
},
setName(name) {
this[FIELDS.name] = name;
return this;
}
});
const u1 = new User('Tom');
console.log(u1.getId()); // '1';
console.log(u1.getName()); // 'Tom'
u1.setName(); // exception
````
## Statics
Using ``statics`` object it's possible to define static methods of a type.
````javascript
import composeClass from 'compose-class';
import fetch from 'isomorphic-fetch';
const User = composeClass({
statics: {
getAll() {
return fetch('/users').then((response) => {
if (response.status >= 400) {
throw new Error("Bad response from server");
}
return response.json().map((name) => new User(name));
});
}
},
constructor(name) {
this._name = name;
},
getName() {
return this._name;
}
});
User.getAll().then((users) => {
users.map((u) => console.log('Fetched', u.getName()));
});
````