ldc

loading js component/action framework.

API

• ldc.register(name, dep-list, (({dep-list}) ->)): register a component
  • while name ignored the module will be an anonymous module and be treated as an app directly.
  • return the registered ldc object.
• ldc.app(name, ...): set main entry point of component
• ldc.init(opt, ...): force init components
  • opt is either:
    • a string: name for specific ldc component.
    • an object: a ldc object ( returned by ldc.register )
    • an array of either string or objects as above
• ldc.on(name, ((...opts)->): listen to a ldc event
• ldc.fire(name, ...opts): fire a ldc event
• ldc.action(opt1, opt2): register an action handler. there are three different cases of usage

  1. opt1 = name, opt2 = object register an set of action handler under the namespace with opt1 as its name.

  2. opt1 = object, opt2 is omitted similar to 1. while use module name as the action name.

  3. opt1 = name, opt2 = function (deprecated) register ldc action. deprecated since we can use on/fire to replace this.

Module

ldc helps us to maintain the dependency of modules. Define a module as follow:

ldc.regsiter "module1", <[]>, -> return {foo: -> \bar}

A newly created this context can be used in this module:

ldc.regsiter "module1", <[]>, -> return @ <<< {foo: -> \bar}

Declare dependency and load another module:

ldc.regsiter "module2", <[module1]>, ({module1}) ->

the module1 object sent to module2 handler will be the returned value in the module1 handler:

ldc.regsiter "module2", <[module1]>, ({module1}) ->
  assert module1.foo! == \bar

Each module function will be called at most once. The returned object in the first call will be used then.

ldc.regsiter "module1", <[]>, ->
  console.log "this line runs only once."
  @foo = (@foo or 0) + 1
  return @
ldc.regsiter "module2", <[module1]>, ({module1}) ->
  assert module.foo == 1
ldc.regsiter "module3", <[module1]>, ({module1}) ->
  assert module.foo == 1

main entry module can be defined by ldc.app or by omitting the module name:

ldc.regsiter <[module1 module2]>, ({module1, module2}) -> ...

Action

One can use lda to access the actions registered via ldc.action. For example, following code registers a set of actions:

ldc.register "mymodule", [], ->
  ldc.action do
    open: ->
    close: ->

Once registered, we can use ldc.mymodule to access them:

ldc.mymodule.open!

License

MIT