ym

Async modular system

Modular system

по-русски

What? Why and what for? How to use? (ru)

####Requirements####

  1. Asynchronous require for modules
  2. Asynchronous provide for modules
  3. Extending and redefining a module

####Why not CommonJS?#### See #1, #2 and #3 in the list of requirements.

####Why not AMD?#### See #2 and #3 in the list of requirements.

####Module declaration####

void modules.define(
    String moduleName,
    [String[] dependencies],
    Function(
        Function([Object objectToProvide], [Error error]) provide,
        [Object resolvedDependency, ...],
        [Object previousDeclaration]
    ) declarationFunction
)

####Module usage####

void modules.require(
    String[] dependencies,
    Function([Object resolvedDependency, ...]) successCallbackFunction,
    [Function(Error error) errorCallbackFunction]
)

####Modules storage configuration####

void setOptions(Object options)

#####Available options#####

  • trackCircularDependencies - if set to false doesn't track circular dependencies. true by default
  • allowMultipleDeclarations - if set to false denies module overloading and provides an error. true by default

####Get current state of module in storage####

String getState(String name)

#####Possible states#####

  • NOT_DEFINED - module wasn't defined
  • NOT_RESOLVED - module was defined, but it hasn't started resolving
  • IN_RESOLVING - resolving is in progress
  • RESOLVED - module is already resolved

####Check for module existence in storage####

Boolean isDefined(String moduleName)

####Create yet another modules storage####

Modules modules.create()

####Example####

modules.define(
    'A',
    ['B', 'C'],
    function(providebcprev) {
        var a = {};
        provide(a);
    });
 
modules.define(
    'B',
    function(provide) {
        var b = {};
        provide(b);
    });
 
modules.define(
    'C',
    ['B'],
    function(provideb) {
        var c = {};
        provide(c);
    });
 
modules.define(
    'C',
    function(provideprevC) {
        var nextC = {};
        provide(nextC);
    });
 
modules.require(
  ['A'],
  function(a) {
    // module 'A' now resolved to a 
  });