object-mix

Mixture

An object composition library

Mixture provides an easy, lightweight, declarative way to compose modules and mixins in your code to reduce boilerplate and improve readability. This method of prototypal object composition is not intended for classical usage, which enforcess a tree-like inheritance model, but rather a web-like model common to multiple inheritance models. Classical inheritance is both inappropriate and constraining in a dynamic, prototypal language such as JavaScript.

Mixins prefer last-in priority with regard to conflicting methods and properties. Usage of duck typing is the preferred way (by me, at least) to get around the diamond problem.

By composing your mixable modules in small, specific parts, you can completely get around the familiar gorilla/banana problem imposed by classical inheritance.

I created this mostly for myself to make mixins more easily read. If there are other use cases you think should be in this utility, let me know.

Installation

Currently available via npm as the object-mix package:

$ npm install object-mix --save

Usage

Composable types:

• Constructors: defined as using the Constructor Pattern
• Objects (of any kind)

Composing modules

function moduleA(injectedState) {
    // private members
    var a = 'a';
    var state = injectedState;
    
    // public members
    this.getA = function getA() {
        return a;
    }
    this.getState = function getState() {
        return state.state1;
    }
}
 
function moduleB(injectedState) {
    // private members
    var a = 'b';
    var state = injectedState;
    
    // public members
    this.getB = function getA() {
        return a;
    }
    this.getState = function getState() {
        return state.state2;
    }
}
 
var moduleC = mix( moduleA, moduleB )
             .using( {state1: 'foo', state2: 'bar'} )
             .into( { } ); // or some other module or object
             
 
console.log( moduleC.getA() ); // 'a'
console.log( moduleC.getB() ); // 'b'
console.log( moduleC.getState() ); // 'bar' - last-in

Composing modules into a constructor

function ModuleA(injectedState) {
    // private members
    var a = injectedState.a;
    
    // public members
    this.getA = function getA() {
        return a;
    }
}
 
function ModuleB(injectedState) {
    
    mix( moduleA )
        .using( injectedState )
        .into( this )
    
    // private members
    var a = injectedState.b;
    
    // public members
    this.getB = function getA() {
        return a;
    }
}
 
var instanceB = new ModuleB( {a: 'a', b: 'b'} );
             
 
console.log( instanceB.getA() ); // 'a'
console.log( instanceB.getB() ); // 'b'