StarShine.js

Interstellar Object/Factory Creation Made Surreal

Check out the presentation here: [http://slid.es/jtenner/starshinefactories](StarShine Factories: Javascript Object and Function Composition)

Data Exposure Definitions

1. Exposed Data

• Attached to Object Directly

2. Private Data

• Declared in closure
• Exposed via methods/properties

3. Private Shared Data

• Set as property to this
• Can be accessed across closures
• Exposed via methods/properties

Note that every Data Exposure type is incredibly useful.

Closures Defined

In StarShine, closures are defined like this:

function _closurePart (/*API Parameters: See Below*/) {
   //this is a private namespace that can be shared between other closures: see below
   var private = this;
   
   //a is now exposed to every other closure
   this.a = "a";
   
   //closures hold private data that cannot be accessed anywhere else.
   var b = "b";
   
   //anything returned is attached to the returned object
   return {
      getA: function(){
        //function scope allows you to access private data... but it has to be cached
        return private.a;
      },
      getB: function(){
        //private non shared variables are useful too!
        return b;
      }
   };
}

Starhshine Factories

These factories are composed of closure parts like _closurePart defined above.

To create a factory, simply use the StarShine method exposed to you via require, define, or as a global.

var Factory = StarShine(_closurePart, ...);

//now you have a factory

var myObject = Factory();

myObject.getA();
//"a"

Imagine the possibilities with private shared variables! A fun thing to do would be to turn this into an event emitter and handle events inside the object. Then expose the event emitter for API usage.

Factory Parameters

Any parameters passed to the Factory will also be passed to each closure.

function _setA(a) {
    return {
        getA: function (){
            return a;
        }
    };
}

var AFactory = StarShine(_setA);

var myA = AFactory("a");

myA.getA();
//"a"

Prototype? (meh?)

Pass Factory.proto() any number of objects and it will mix the members into it's own prototype.

Another method would be to do something like this:

/*no parameters returns the prototype*/
StarShine.mixIn(Factory.proto(),{
   //define your prototype here
});

This is useful for the instanceof operator.

Type checking can also happen here on the returnedObject._type property.

It can be set using the Factory.type method.

FactoryTest = StarShine(/*arbitrary closures here*/);
FactoryTest.type("FactoryTest");
var myObject = FactoryTest();
myObject._type;
//'FactoryTest'

Not so elegant Error Handling

Just push a bunch of functions to Factory.error like this:

function _handleThatError(err) {
    //do something with err
}

Factory.error(_handleThatError, _anotherClosure, ...);

It's not perfect, but it works. Any error that occurs within your closures will be passed to EVERY error function. (unless it errors inside your error function...

Don't chomp at the bit! Just get started. I will be publishing my module to NPM in a week when I think it's ready to be exposed to the wild.