var container = new Nodeject();
 
container.define({ name : "module1", type : require("module1") })
         .define({ name : "module2", type : require("module2"), deps: ["module1"] });
 
 var module2Impl = container.resolve("module2");

//Uses the options pattern to configure an entity.
function define(options) { ... };
 
container.define({
        name : "module1",           // Must be a unique name in the container.
        type : MyType,              // Can be a Prototype, Power Constructor, String, or Array
        deps : ["module2", "m2"],   // Array of modules configured or to be configured in the container.
        singleton : false           // If a singleton is needed, pass true, default is false.
    });
 

// Resolves with a single module name.
function resolve(moduleName) { ... };
 
var module1 = container.resolve("moduleName");

// Wrapping a global or other entity
container.define({ name : '$',
    wrap : {
        resolve : jQuery
    }
});
var $ = container.resolve('$');
 
// Binding a field to a resolvable name
container.define({ name : "app",
    type : function (){
        return {
            bus : {
                on : function (){ "..."; }
            }
        };
    }
});
container.define({ name : 'bus',
    wrap : {
        resolve : 'bus',
        context : 'app'
    }
});
var bus = container.resolve('bus');
 

// Configure the container with entities having a common category
container
  .define({
    name : "module1",
    type : MyType,
    category : "category1"
  })
  .define({
    name : "module2",
    type : MyOtherType,
    category : "category1"
  });
 
var entities = container.resolve({ category : "category1" });
assert.ok (entities[0] instanceof MyType);          // asserts true
assert.ok (entities[1] instanceof MyOtherType);     // asserts true
 
var entities = container.resolve({ category : "category1", format : "literal" });
assert.ok ("module1" in entities);                  // asserts true
assert.ok ("module2" in entities);                  // asserts true

// In order to enable compound keys feature you have to specify compoundKeys/delimiter option
var container = new Nodeject({
  singleton: true,
  compoundKeys: {
    delimiter: '::'
  }
});
 
// Configure the container with two identical names in two different categories
container
  .define({
    name : "main",
    category : "moduleOne",
    type : MyType
  })
  .define({
    name : "main",
    category : "moduleTwo",
    type : MyOtherType
  });
 
var moduleOneMain = container.resolve('moduleOne::main');
// what is the same as
moduleOneMain = container.resolve({ category: 'moduleOne', name: 'main' });
// and now you can use compound keys when you define deps
container.define({
  name: 'aggr',
  type: AggrType,
  deps: ['moduleOne::main', 'moduleTwo::main']
});