fiber

Lightweight JavaScript inheritance library

Fiber.js: Lightweight, fast, JavaScript inheritance model

Take a look at the performance tests to see how it compares against commonly used inheritance libraries.

[[constructor]].extend( function )

// Animal base class 
var Animal = Fiber.extend(function() {
    return {
        // The `init` method serves as the constructor. 
        initfunction() {
            // Private 
            function private1(){}
            function private2(){}
 
            // Privileged 
            this.privileged1 = function(){}
            this.privileged2 = function(){}
        },
        // Public 
        method1function(){}
    }
});

The init method acts as the constructor, which is invoked when an instance is created:

var animal = new Animal(); // Create a new Animal instance 

init is invoked automatically.

// Extend the Animal class. 
var Dog = Animal.extend(function() {
    return {
        // Override base class `method1` 
        method1function(){
            console.log('dog::method1');
        },
        scarefunction(){
            console.log('Dog::I scare you');
        }
    }
});

Create an instance of Dog:

var husky = new Dog();
husky.scare(); // "Dog::I scare you'" 

Every class definition has access to the parent's prototype via the first argument passed into the function:

// Extend the Animal class. 
var Dog = Animal.extend(function( base ) {
    return {
        // Override base class `method1` 
        method1function(){
            // Call the parent method 
            base.method1.call(this);
        },
        scarefunction(){
            console.log('Dog::I scare you');
        }
    }
});

Mixins are a way to add functionality to a Fiber definition. Basically, they address the problem of "multiple inheritance". Read more.

Fiber.mixin( object, function1, function2, ... )

var Foo = Fiber.extend(function(base) {
    return {
        method1function(){}
    }
});
 
var f = new Foo();
f.method1();
 
var mix1 = function(base) {
    return  {
        method2function() {}
    }
}
 
Fiber.mixin(Foo, mix1);
 
f.method2();

With decorators you can dynamically attach additional properties to an instance. Read more.

Fiber.decorate( instance, decorator_1, ... , decorator_n )

function CarWithPowerWindows(base) {
    return {
        rollfunction() {}
    }
}
 
Fiber.decorate(myCar, CarWithPowerWindows);

Fiber.proxy( base, instance )

// Extend the Animal class; 
var Dog = Animal.extend(function(base) {
    return {
        initfunction() {
            this.base = Fiber.proxy(base, this);
            this.base.init();
        }
    }
});

Fiber.noConflict()

Returns a reference to the Fiber object, and sets the Fiber variable to its previous owner.