axoid/index.js

/*
   Copyright 2014+ Aliaksandr Litskevich, github.com/alitskevich

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 */


/*

AXOID. A general-purpose micro-framework that just organizes code as a composition of Entities.
 */

(function() {
  "use strict";

  /*
  
      Calls `fn` in next loop tick.
      
      @param [int] ms delay in millisec. Optional. Default is 5ms.
      @param [Object] ctx function context object. Optional. Default is null.
      @param [Function] fn function to call. Required.
      
      @example
          Function.nextTick(100, @, -> doing())
   */
  var __hasProp = {}.hasOwnProperty,
    __slice = [].slice;

  Function.nextTick = function(ms, ctx, fn) {
    if (arguments.length === 1) {
      (fn = ms) && (ms = null) && (ctx = null);
    }
    if (arguments.length === 2) {
      (fn = ctx) && (ctx = ms) && (ms = null);
    }
    return setTimeout((function() {
      return fn.call(ctx);
    }), ms || 5);
  };


  /*
  
      Manages execution of sequence of functions allowing async and parallel flow.    
  
      @param [Object] ctx function context object. Optional. Default is null.
      @param [Function] factory function to return operations list. Required.
      
      @example
          Function.perform(@, (flow)-> [
              -> 
                  r= doSome1()
                   *next op
                  flow.next(null, r)
              
              (err, r)-> 
                   *async with callback
                  doSomeAsync(r, flow.next)
              
              (err, data)-> 
                   *parallel flow
                  doSome1(d, flow.cb()) for d in data
                   * next op
                  flow.next(null, 1)
                  
              (err, p1, results...)->
                   *done
                  
              ]
   */

  Function.perform = function(ctx, factory) {
    var flow, locked, newCb, results, tick;
    locked = 1;
    results = [null, void 0];
    tick = function() {
      var ex, op, _args;
      if (!--locked && (op = flow.operations.shift())) {
        locked = 1;
        _args = [].concat(results);
        results = [null, void 0];
        try {
          return op.apply(flow.context, _args);
        } catch (_error) {
          ex = _error;
          return Object.error(('perform: ' + op).slice(0, 151).replace(/\s+/g, ' ')).addDetails(ex).log();
        }
      }
    };
    newCb = function(pos) {
      return function(err, v) {
        if (!(results[pos] === void 0)) {
          return;
        }
        if (err) {
          results[0] = Object.error(err).log();
        }
        results[pos] = v;
        return tick();
      };
    };
    flow = {
      context: ctx,
      _error: new Error(),
      next: newCb(1),
      wait: function() {
        var pos;
        pos = results.length;
        results[pos] = void 0;
        locked += 1;
        return newCb(pos);
      }
    };
    flow.operations = factory.call(ctx, flow);
    return tick();
  };

  Function.create = function(code, params) {
    if (code) {
      return Object.parse("function (" + (params ? params.join(', ') : '') + "){ return " + code + "; }");
    } else {
      return null;
    }
  };

  Function.iterate = function(fn, obj, ctx, opts) {
    var i, ln, n, x, _i, _len;
    if (obj) {
      ln = obj.length;
      if (ln === +ln) {
        for (i = _i = 0, _len = obj.length; _i < _len; i = ++_i) {
          x = obj[i];
          fn.call(ctx, x, i, opts);
        }
      } else {
        for (n in obj) {
          if (!__hasProp.call(obj, n)) continue;
          x = obj[n];
          fn.call(ctx, x, n, opts);
        }
      }
    }
    return ctx;
  };


  /*
  Objects.
   */

  Object.update = function(obj, extra) {
    var n;
    if (obj && extra) {
      for (n in extra) {
        if (!__hasProp.call(extra, n)) continue;
        obj[n] = extra[n];
      }
    }
    return obj;
  };

  Object.prop = function(obj, key, val) {
    var k, p, p1;
    if (!obj) {
      return null;
    }
    p = -1;
    if (arguments.length > 2) {
      while ((p = key.indexOf(".", p1 = p + 1)) > -1) {
        obj = obj[k = key.slice(p1, +(p - 1) + 1 || 9e9)] || (obj[k] = {});
      }
      return obj[key.slice(p1)] = val;
    } else {
      while (obj && (p = key.indexOf(".", p1 = p + 1)) > -1) {
        obj = obj[key.slice(p1, +(p - 1) + 1 || 9e9)];
      }
      return obj != null ? obj[key.slice(p1)] : void 0;
    }
  };

  Object.clone = function(obj, delta) {
    var n, r;
    if (!obj) {
      return null;
    }
    r = new obj.constructor();
    for (n in obj) {
      if (!__hasProp.call(obj, n)) continue;
      r[n] = obj[n];
    }
    if (delta) {
      for (n in delta) {
        if (!__hasProp.call(delta, n)) continue;
        r[n] = delta[n];
      }
    }
    return r;
  };

  Object.parse = function(s, opts) {
    var ex;
    if (!s) {
      return null;
    }
    try {
      return Function.call(Function, "return " + s).call(opts != null ? opts.ctx : void 0);
    } catch (_error) {
      ex = _error;
      return Object.error("bad-code: Object.parse: " + ex.message).addDetails(s).log().end(null);
    }
  };

  Object.update.mixin = function() {
    var T, args, fn, m, n, _ref, _super;
    T = arguments[0], fn = arguments[1], args = 3 <= arguments.length ? __slice.call(arguments, 2) : [];
    if (!fn) {
      return T;
    }
    _ref = fn.apply(null, [_super = {}].concat(args));
    for (n in _ref) {
      if (!__hasProp.call(_ref, n)) continue;
      m = _ref[n];
      _super[n] = T[n] || function() {};
      T[n] = m;
    }
    return T;
  };


  /*
  Strings.
   */

  String.LANGUAGE = 'en';

  String.capitalize = function(s) {
    if (s != null ? s.length : void 0) {
      return s[0].toUpperCase() + s.slice(1);
    } else {
      return "";
    }
  };

  String.camelize = function(s, sep) {
    var i, t;
    if (sep == null) {
      sep = '_';
    }
    if (s != null ? s.length : void 0) {
      return ((function() {
        var _i, _len, _ref, _results;
        _ref = s.split(sep);
        _results = [];
        for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
          t = _ref[i];
          _results.push(i ? String.capitalize(t) : t);
        }
        return _results;
      })()).join('');
    } else {
      return '';
    }
  };

  String.format = function() {
    var args, s;
    s = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
    if (s) {
      return s.replace(/\{(\d+)\}/g, (function(s, d) {
        return args[+d] || '';
      }));
    } else {
      return '';
    }
  };

  String.localize = (function(_cache) {
    var $;
    $ = function(s, l) {
      var _ref;
      if (l == null) {
        l = String.LANGUAGE;
      }
      if (s) {
        return ((_ref = _cache[l]) != null ? _ref[s] : void 0) || String.capitalize(String.camelize(s));
      } else {
        return "";
      }
    };
    $.get = function(s, l) {
      var _ref;
      if (l == null) {
        l = String.LANGUAGE;
      }
      if (s) {
        return ((_ref = _cache[l]) != null ? _ref[s] : void 0) || null;
      } else {
        return null;
      }
    };
    $.add = function(l, delta) {
      if (arguments.length === 1) {
        (delta = l) && (l = null);
      }
      if (!l) {
        l = String.LANGUAGE;
      }
      return Object.update(_cache[l] || (_cache[l] = {}), delta);
    };
    $.asEnum = function(s, l) {
      var id, k, r, v, _results;
      if (!(r = this.get(s, l))) {
        return null;
      }
      _results = [];
      for (k in r) {
        v = r[k];
        if (id = +k || k) {
          if (typeof v === 'object') {
            v.id = id;
            _results.push(v);
          } else {
            _results.push({
              id: id,
              name: '' + v
            });
          }
        }
      }
      return _results;
    };
    return $;
  })({});

  String.tokenize = function(s, re, op) {
    var e, pastLastIndex, text;
    if (s == null) {
      s = '';
    }
    if (re == null) {
      re = /\W/g;
    }
    pastLastIndex = 0;
    while (e = re.exec(s)) {
      if (e.index && (text = s.slice(pastLastIndex, +(e.index - 1) + 1 || 9e9))) {
        op(text);
      }
      op(e[0], true);
      pastLastIndex = re.lastIndex;
    }
    if ((text = s.slice(pastLastIndex))) {
      return op(text);
    }
  };


  /*
  
      Uri class represents Uri as structure parsed from string.
  
      Uri grammar: [type:]//host[/path...][?{(key=value)...}][#hash]
      
      @example usage
      
          uri = Object.Uri.parse "db://update/doc1?force=true#version2"
   */

  Object.Uri = (function() {
    function Uri(params) {
      this.params = params != null ? params : {};
    }

    Uri.prototype.isUri = true;

    Uri.prototype.setParams = function(all) {
      this.params = all;
      return this;
    };

    Uri.prototype.updateParams = function(delta) {
      Object.update(this.params, delta);
      return this;
    };

    Uri.prototype.toString = function() {
      var n, r, sep, v, _ref;
      r = (this.host ? (this.type ? "" + this.type + "://" + this.host + "/" : "//" + this.host + "/") : '') + this.path.join('/');
      sep = '?';
      _ref = this.params;
      for (n in _ref) {
        if (!__hasProp.call(_ref, n)) continue;
        v = _ref[n];
        r += sep + n + "=" + encodeURIComponent(v);
        if (sep === '?') {
          sep = '&';
        }
      }
      if (this.hash) {
        r += "#" + this.hash;
      }
      return r;
    };

    Uri.parse = function(s, params) {
      var p, r, v, _i, _len, _ref, _ref1;
      if (s != null ? s.isUri : void 0) {
        return s;
      }
      r = new Uri(params);
      if (!s) {
        return r;
      }
      if (!s.split) {
        s = "" + s;
      }
      if ((p = s.indexOf("://")) > -1) {
        r.type = s.slice(0, +(p - 1) + 1 || 9e9);
        s = s.slice(p + 1);
      }
      if ((p = s.indexOf("#")) > -1) {
        r.hash = s.slice(p + 1);
        s = s.slice(0, +(p - 1) + 1 || 9e9);
      }
      _ref = s.split("?"), s = _ref[0], r.query = _ref[1];
      if (r.query) {
        _ref1 = r.query.split("&");
        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
          v = _ref1[_i];
          if ((p = v.split("=")).length > 1) {
            r.params[p[0]] = decodeURIComponent(p[1]);
          }
        }
      }
      r.id = s;
      p = s.split("/");
      if (p[0] === "") {
        p.shift();
        if (p[0] === "") {
          p.shift();
          r.host = p.shift();
        }
      }
      r.path = p;
      return r;
    };

    return Uri;

  })();

  Object.error = (function() {
    var Err;
    Err = (function() {
      function Err(e) {
        this.details = [];
        if (typeof e === 'string') {
          if (e) {
            this.reason = e.split(':')[0];
          }
          if (e) {
            this.message = e;
          }
        } else {
          if (e.reason) {
            this.reason = e.reason;
          }
          if (e.message) {
            this.message = e.message;
          }
        }
      }

      Err.prototype.reason = 'unknown';

      Err.prototype.message = '';

      Err.prototype.isError = true;

      Err.prototype.addDetails = function() {
        var det, _i, _len;
        for (_i = 0, _len = arguments.length; _i < _len; _i++) {
          det = arguments[_i];
          if (!(det)) {
            continue;
          }
          this.details.unshift(det);
          if (det.stack) {
            this.stack = det.stack;
          }
        }
        return this;
      };

      Err.prototype.addPrefix = function(p) {
        if (p) {
          this.prefix = '' + p;
        }
        return this;
      };

      Err.prototype.log = function() {
        Object.log(this);
        return this;
      };

      Err.prototype.end = function(x) {
        return x;
      };

      Err.prototype.toString = function() {
        return "" + (this.prefix || '') + " " + this.message;
      };

      Err.prototype.printIntoLog = function(c) {
        var details, stack;
        details = (typeof this.details === "function" ? this.details(length === 1) : void 0) ? this.details[0] : this.details;
        stack = this.stack || (new Error).stack;
        return c.error(this.toString(), details, stack);
      };

      return Err;

    })();
    return function(err, details) {
      return ((err != null ? err.isError : void 0) ? err : new Err(err)).addDetails(details);
    };
  })();

  Object.log = function(x) {
    return x;
  };

}).call(this);

(function() {
  var $, Entity, Property, STUB, TOTAL, TYPES,
    __slice = [].slice,
    __hasProp = {}.hasOwnProperty,
    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };

  STUB = function() {};

  TOTAL = 0;

  TYPES = (function(ALL) {
    var r;
    r = function(id) {
      return ALL[id];
    };
    r.define = function(meta) {
      return ALL[meta.id] = meta;
    };
    r.findUnresolved = function(typeId) {
      var type;
      if (!(type = ALL[typeId])) {
        return typeId;
      } else {
        if (type._resolved || !type.superId) {
          return null;
        } else {
          return r.findUnresolved(type.superId);
        }
      }
    };
    r.resolve = function(typeId, cb) {
      return Object.fire({
        uri: 'axoid://require',
        dependencies: "entity://" + typeId,
        callback: function(err) {
          var type, utypeId;
          if (!(type = ALL[typeId])) {
            throw new Error("Can't resolve type " + typeId);
          }
          if ((utypeId = r.findUnresolved(typeId))) {
            return r.resolve(utypeId, cb);
          }
          type._resolved = true;
          return cb();
        }
      });
    };
    return r;
  })({});

  $ = (function(ALL) {
    var Perceptor, r;
    Perceptor = (function() {
      var PropHandler;

      PropHandler = (function() {
        function PropHandler(parent, propId, fn) {
          var reg;
          this.parent = parent;
          this.propId = propId;
          this.fn = fn;
          reg = this.parent.handlers || (this.parent.handlers = {});
          (reg[propId] || (reg[propId] = [])).push(this);
        }

        PropHandler.prototype.handle = function(ev) {
          var ex;
          try {
            return this.fn.call(null, ev);
          } catch (_error) {
            ex = _error;
            return Object.error('notify: ' + ex.message).addDetails(Object.update(ex, {
              op: ('' + this.fn).replace(/\n+/g, '').slice(9, 151)
            })).log();
          }
        };

        PropHandler.prototype.done = function() {
          var a, index;
          if ((a = this.parent.handlers[this.propId]) && ((index = a.indexOf(this)) > -1)) {
            a.splice(index, 1);
          }
          if (!a.length) {
            delete this.parent.handlers[this.propId];
          }
          return this.parent = this.fn = null;
        };

        return PropHandler;

      })();

      function Perceptor(id) {
        this.id = id;
      }

      Perceptor.prototype.startListen = function(handler) {
        var dfrd, ev, _i, _len, _results;
        this.handler = handler;
        if (dfrd = this.defered) {
          delete this.defered;
          Object.log("!!! Fire " + dfrd.length + " defered for [" + this.id + "] ");
          _results = [];
          for (_i = 0, _len = dfrd.length; _i < _len; _i++) {
            ev = dfrd[_i];
            _results.push(this.handler(ev));
          }
          return _results;
        }
      };

      Perceptor.prototype.fire = function(ev) {
        if (this.handler) {
          return this.handler(ev);
        }
        (this.defered || (this.defered = [])).push(ev);
        return Object.log("!!! Defer fire for [" + this.id + "]");
      };

      Perceptor.prototype.addIncomingHandler = function(h) {
        return (this.incomings || (this.incomings = [])).push(h);
      };

      Perceptor.prototype.addPropertyChangedHandler = function(propId, fn, targetId) {
        var h;
        h = new PropHandler(this, propId, fn);
        return $.instance(targetId).addIncomingHandler(h);
      };

      Perceptor.prototype.notifyPropertyChanged = function(propId, ev) {
        var h, hh, _i, _len, _ref, _results;
        if (hh = (_ref = this.handlers) != null ? _ref[propId] : void 0) {
          _results = [];
          for (_i = 0, _len = hh.length; _i < _len; _i++) {
            h = hh[_i];
            _results.push(h.handle(ev));
          }
          return _results;
        }
      };

      Perceptor.prototype.done = function() {
        var h, _i, _len, _ref, _results;
        this.handler = this.entity = null;
        if (this.incomings) {
          _ref = this.incomings;
          _results = [];
          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
            h = _ref[_i];
            _results.push(h.done());
          }
          return _results;
        }
      };

      return Perceptor;

    })();
    r = function(id) {
      return ALL[id];
    };
    r.instance = function(id) {
      return ALL[id] || (ALL[id] = new Perceptor(id));
    };
    r.release = function(id) {
      var e;
      if (e = ALL[id]) {
        delete ALL[id];
        e.done();
      }
      return e;
    };
    return r;
  })({});


  /*
  
      Property class represents logic to access/manipulate a property value of a entity.
  
      @example  [number] property
      
          Object.fire
              uri: "axoid://define/Property/Number"
      
              methods : ->
                   * value comparator
                  comparator: (a, b) -> Number(a) is Number(b)
                  
                   * value setter
                  setter: (T, v, ev) -> T[@id] = Number(v)
                  
               *It can also mix in entity type attached to.
              mixin:  (_super, prop) ->
                  r = {}
                  
                  propid = prop.id
                  
                   * add method that increments value of this property
                  r['increment'+String.capitalize(propid)] = (delta=1) ->
      
                       * use _super
                      _super.log.call @, "increment #{propid}"
                      
                      @prop propid, ((@prop propid) or 0)+delta
                  
                  r
   */

  Property = (function() {
    var ALL, PTYPES;

    ALL = {};

    PTYPES = {};

    Property.Expression = (function() {
      function Expression() {}

      Expression.prototype.compile = function(message) {
        var reg, src;
        this.message = message;
        reg = {};
        src = this.sources = [];
        this.body = this.message.replace(/<(@?[\w\.$ ]+?)>/gm, function(s, path) {
          var flag, id, prop, _ref, _ref1;
          _ref = path.split(' '), path = _ref[0], flag = _ref[1];
          _ref1 = path[0] === '@' ? ['@', path.slice(1)] : path.split("."), id = _ref1[0], prop = _ref1[1];
          if (!prop) {
            prop = "value";
          }
          path = id + "." + prop;
          if (!id) {
            throw new Error("No id for binding source in " + s);
          }
          if (!reg[path]) {
            reg[path] = 1;
            src.push({
              id: path,
              flag: flag,
              entityId: id,
              propId: prop
            });
          }
          return "$[\"" + path + "\"]";
        });
        this.expression = (Function.create(this.body, ['$'])) || (function() {
          return Object.error("bad-code: Wrong binding expression: " + this.body).log();
        });
        return this;
      };

      Expression.instance = function(expr) {
        return (new Expression()).compile(expr);
      };

      return Expression;

    })();

    function Property(id) {
      var ftor, k, methods, typeId, v, _ref, _super;
      this.id = id;
      _ref = this.id.split(':'), this.id = _ref[0], typeId = _ref[1];
      if (this.id.slice(-3) === "Uri") {
        this.asyncTarget = this.id.slice(0, -3);
      }
      if (typeId) {
        if (!(this.type = PTYPES[typeId])) {
          throw new Error("ERROR: No such property type: " + typeId);
        }
        if ((ftor = this.type.methods) && (methods = ftor(_super = {}))) {
          for (k in methods) {
            v = methods[k];
            if (typeof v === "function") {
              _super[k] = this[k] || STUB;
            }
            this[k] = v;
          }
        }
      }
    }

    Property.prototype.attachToEntityCtor = function(ctor) {
      var _ref;
      if ((_ref = this.type) != null ? _ref.mixin : void 0) {
        return Object.update.mixin(ctor.prototype, this.type.mixin, this);
      }
    };

    Property.prototype.extractDefaults = function(T, defaults) {
      var n;
      if (T[n = this.id] && (defaults[n] = T[n])) {
        T[n] = void 0;
      }
      if (T[n = this.id + 'Expression'] && (defaults[n] = T[n])) {
        T[n] = void 0;
      }
      if (T[n = this.id + 'Binding'] && (defaults[n] = T[n])) {
        T[n] = void 0;
      }
      if (!this.asyncTarget) {
        if (T[n = this.id + 'Uri'] && (defaults[n] = T[n])) {
          T[n] = void 0;
        }
        if (T[n = this.id + 'UriExpression'] && (defaults[n] = T[n])) {
          T[n] = void 0;
        }
      }
      return defaults;
    };

    Property.prototype.init = function(T, defs) {
      var expr, monitor, v;
      monitor = {
        locked: false
      };
      if ((expr = defs["" + this.id + "Binding"])) {
        Property.bind(T.id, this.id, expr, monitor);
      }
      if ((expr = defs["" + this.id + "Expression"])) {
        Property.bindWithExpression(T, this.id, expr, monitor);
      }
      if (!(((v = defs[this.id]) === void 0) || monitor.bound)) {
        T.prop(this.id, v, {
          force: true
        });
      }
      if (defs["" + this.id + "Uri"] || defs["" + this.id + "UriExpression"]) {
        return Property.instance("" + this.id + "Uri").init(T, defs);
      }
    };

    Property.prototype.done = function(T) {
      return T[this.id] = null;
    };

    Property.prototype.getter = function(T) {
      return T[this.id];
    };

    Property.prototype.setter = function(T, v, ev) {
      return T[this.id] = v;
    };

    Property.prototype.comparator = function(v1, v2) {
      return v1 === v2;
    };

    Property.prototype.asyncAdapter = function(err, value) {
      if (err) {
        this.prop('asyncError', err);
      }
      return value || null;
    };

    Property.prototype.createAsyncValueCallback = function(T) {
      var uuid;
      if (T._monitor == null) {
        T._monitor = {};
      }
      uuid = T._monitor[this.id] = Object.math.uuid();
      return (function(_this) {
        return function(err, value) {
          if (T.isDone) {
            T.log("!!! obsolete result at asyncValueCallback for property " + T + "." + _this.id);
            delete T._monitor[_this.id];
            return;
          }
          if (uuid !== T._monitor[_this.id]) {
            T.log("!!! out of monitor at asyncValueCallback for property " + T + "." + _this.id);
            return;
          }
          T.prop(_this.id, (T["" + _this.id + "AsyncAdapter"] || _this.asyncAdapter).call(T, err, value));
          delete T._monitor[_this.id];
        };
      })(this);
    };

    Property.prototype.setValue = function(T, value, opts) {
      var ev, uri, v;
      ev = Object.update({
        value: value
      }, opts);
      ev.propId = this.id;
      ev.entity = T;
      ev.oldValue = this.getter(T);
      if (ev.uri) {
        uri = ev.uri;
        ev.uri = null;
      }
      if (((v = ev.value) !== void 0) && (ev.force || !this.comparator(v, ev.oldValue))) {
        this.setter(T, v, ev);
        if (this.asyncTarget && v) {
          T.prop(this.asyncTarget, null, {
            uri: v,
            force: true
          });
        }
        T.propertyChanged(ev);
      }
      if (uri) {
        Object.fire({
          uri: uri,
          callback: this.createAsyncValueCallback(T)
        });
      }
      return ev;
    };

    Property.define = function(meta) {
      return PTYPES[meta.id] = meta;
    };

    Property.instance = function(id) {
      return ALL[id] || (ALL[id] = new Property(id));
    };


    /*
        binds property value with expression.
    
        It parses and compiles from given CoffeeScript `expr` containing placeholders in <> brackets.
        
        Placeholder is a source property reference and an optional triggering modifier.
        
        Placeholder grammar:  "<" (entityId|"@") ["." propertyId] [required|optional] ">"
        
        Use "@" to refer taget entity itself
        
        By default, propertyId is "value".
        
        By default, an expression triggers when all sources are defined.
        
        Use `required` modifier to triger only for non-empty source value.
        
        Use `optional` modifier to triger even for undefined source value.
        
        @example hello world
        
             * will trigger only if user.name is defined and not empty
            greetingExpresssion: "'Hello, '+<user.name required>"
            
        @example readyForEvents
        
             * will trigger only if both its own property `dataLoaded` and `other.value` are true
            readyForEventsExpresssion: "<@dataLoaded required> and <other required>"
            
        @example get users list
        
             * will trigger even if search value is undefined yet.
            dataUriExpresssion: "'db://query/users?q='+(<search.value optional> or '')"
     */

    Property.bindWithExpression = function(T, propId, value, monitor) {
      var expr, ps, _bind, _i, _len, _log, _ref;
      expr = Property.Expression.instance(value);
      monitor.locked = false;
      _log = function(s) {
        if (Object.DEBUG) {
          return Object.log("binding: " + T + "[" + propId + "] " + s);
        }
      };
      _bind = function(ev) {
        var e, p, val, values, _i, _len, _ref;
        if (monitor.locked) {
          return;
        }
        values = {};
        _ref = expr.sources;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          p = _ref[_i];
          if (!(e = (p.entityId === '@' ? T : $(p.entityId).entity))) {
            return _log("No source of " + p.id);
          }
          if (!(val = e.prop(p.propId)) && ((val === void 0 && p.flag !== 'optional') || (p.flag === 'required'))) {
            return _log("No value from " + p.id);
          }
          values[p.id] = val;
        }
        monitor.locked = true;
        try {
          value = expr.expression.call(T, values);
          if (Object.LOG_LEVEL > 4) {
            _log("= [" + expr.message + "] (" + (('' + value).replace('\n', ' ').slice(0, 31)) + ")");
          }
          return T.prop(propId, value);
        } finally {
          monitor.locked = false;
        }
      };
      _ref = expr.sources;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        ps = _ref[_i];
        $.instance(ps.entityId === '@' ? T.id : ps.entityId).addPropertyChangedHandler(ps.propId, _bind, T.id);
      }
      if (!monitor.bound) {
        return _bind();
      }
    };


    /*
        
        double binds property.
        
        Placeholder grammar:  (entityId|"@") ["." propertyId]
        
        Use "@" to refer taget entity itself
        
        By default, propertyId is "value".
        
        Binding triggers when source is defined.
        
        @example hello world
        
             * will trigger when storage.name is defined
            valueBinding: "storage.name"
     */

    Property.bind = function(tId, tProp, path, monitor) {
      var s0, sId, sProp, val, _bind, _log, _ref, _ref1;
      _ref = path.split('.'), sId = _ref[0], sProp = _ref[1];
      if (!sProp) {
        sProp = 'value';
      }
      _log = function(s) {
        if (Object.DEBUG) {
          return Object.log("duplex: " + tId + "[" + tProp + "] " + s);
        }
      };
      _bind = function(ev) {
        var e, _ref1;
        if (monitor.locked) {
          return;
        }
        monitor.locked = true;
        if (Object.LOG_LEVEL > 4) {
          _log("= [" + sId + "." + sProp + "] (" + (('' + ev.value).replace('\n', ' ').slice(0, 31)) + ")");
        }
        try {
          if (!tId) {
            throw new Error("Binding target has no id");
          }
          if (!(e = (_ref1 = $(tId)) != null ? _ref1.entity : void 0)) {
            throw new Error("Lack of binding target with id [" + tId + "]");
          }
          return e.prop(tProp, ev.value);
        } finally {
          monitor.locked = false;
        }
      };
      $.instance(sId).addPropertyChangedHandler(sProp, _bind, tId);
      if (!monitor.reverse) {
        if ((s0 = (_ref1 = $(sId)) != null ? _ref1.entity : void 0) && ((val = s0.prop(sProp)) !== void 0)) {
          _bind({
            entity: s0,
            value: val
          });
          monitor.bound = true;
        }
        monitor.reverse = true;
        this.bind(sId, sProp, tId + "." + tProp, monitor);
      }
      return true;
    };

    return Property;

  })();


  /*
      Entity class
      
      @example custom list view
  
          Object.fire
          
               * extends `D3List`
              uri: "axoid://define/D3List/couch.DbList"
              
               *add property `totalCount` of type `Number`
              properties:['collection','totalCount:Number']
              
               * set totalCount from length of data
              totalCountExpression: '<@data required>.length'
              
               *bind data Uri with expression using `collection` property of itself
              dataUriExpression: "'db://getAll/'+<@collection>"
              
               * methods factory:
              methods:(_super)->
              
                  init: ()->
                  
                       *use _super
                      _super.init.apply @, arguments
                      ...
  
                  totalCountChanged: (count, event)->
                      ...
          
                  dataAsyncAdapter:(err, value)->
                       * try to get data from `items` attribute        
                      value?.items or value or null
   */

  Entity = (function() {
    function Entity() {}

    Entity.prototype.launch = function(cb) {
      this.init();
      return typeof cb === "function" ? cb(null, this) : void 0;
    };

    Entity.prototype.init = function() {
      var defs, n, p, _ref, _ref1;
      defs = {};
      _ref = this.constructor.properties;
      for (n in _ref) {
        p = _ref[n];
        p.extractDefaults(this, defs);
      }
      _ref1 = this.constructor.properties;
      for (n in _ref1) {
        p = _ref1[n];
        p.init(this, defs);
      }
      if (this.onEvent) {
        this.listenEvents();
      }
      return typeof this.onInited === "function" ? this.onInited(this) : void 0;
    };

    Entity.prototype.done = function() {
      var n, p, _ref;
      this.isDone = true;
      _ref = this.constructor.properties;
      for (n in _ref) {
        p = _ref[n];
        p.done(this);
      }
      return $.release(this.id);
    };

    Entity.prototype.prop = function(key, value, opts) {
      var p;
      if (this.isDone) {
        return null;
      }
      p = this.constructor.properties;
      if (arguments.length === 1) {
        return (p[key] ? p[key].getter(this) : this[key]);
      }
      (p[key] || Property.instance(key)).setValue(this, value, opts);
      return value;
    };

    Entity.prototype.propertyChanged = function(ev) {
      var _ref, _ref1;
      if ((_ref = this["" + ev.propId + "Changed"]) != null) {
        _ref.call(this, ev.value, ev);
      }
      return (_ref1 = $(this.id)) != null ? _ref1.notifyPropertyChanged(ev.propId, ev) : void 0;
    };

    Entity.prototype.listenEvents = function() {
      if (this.id[0] === '#') {
        throw new Error("" + this + " attempts to listen events, but has no explicit id");
      }
      return $.instance(this.id).startListen((function(_this) {
        return function(ev) {
          return _this.onEvent(ev);
        };
      })(this));
    };

    Entity.prototype.error = function(e, details) {
      return Object.error(e).addPrefix(this).addDetails(details).log();
    };

    Entity.prototype.log = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      if (!(Object.LOG_LEVEL > 4)) {
        return args[0];
      }
      args.unshift(this.toString());
      Object.log.apply(Object, args);
      return args[1];
    };

    Entity.prototype.toString = function() {
      if (this.id[0] === '#') {
        return "[" + this.constructor.typeId + ":" + this.id + "]";
      } else {
        return "[" + this.id + "]";
      }
    };

    Entity.getCtor = function(meta) {
      var t;
      if (meta.properties || meta.methods) {
        return this.createCtor(Object.clone(meta, {
          id: "T" + (TOTAL++),
          superId: meta.type,
          properties: meta.properties || [],
          methods: meta.methods
        }));
      } else {
        if ((t = TYPES(meta.type))) {
          return t.ctor || (t.ctor = this.createCtor(t));
        }
      }
    };

    Entity.createCtor = (function() {
      var PKEYS, _applyType;
      PKEYS = ['id', 'superId', 'type', 'properties', 'methods', 'callback', 'uri'];
      _applyType = function(t, defaults) {
        var k, p, pId, v, _i, _len, _ref;
        if (t.superId) {
          _applyType.call(this, TYPES(t.superId), defaults);
        }
        if (t.properties) {
          _ref = t.properties;
          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
            pId = _ref[_i];
            if (this.properties[pId]) {
              throw Object.error("bad-code: Duplicate property " + pId + " in type " + t.id).log();
            } else {
              (this.properties[(p = Property.instance(pId)).id] = p).attachToEntityCtor(this);
            }
          }
        }
        for (k in t) {
          if (!__hasProp.call(t, k)) continue;
          v = t[k];
          if (__indexOf.call(PKEYS, k) < 0) {
            defaults[k] = v;
          }
        }
        Object.update.mixin(this.prototype, t.methods);
        return this;
      };
      return function(type) {
        var ctor, defaults, k, v, _ref;
        ctor = function(meta) {
          var id, k, v, _ref;
          if (id = meta != null ? meta.id : void 0) {
            if ((_ref = $(id)) != null ? _ref.entity : void 0) {
              throw new Error("Duplicate entity id " + id);
            }
            this.id = id;
            $.instance(this.id).entity = this;
          } else {
            this.id = "#" + (TOTAL++);
          }
          if (meta) {
            for (k in meta) {
              if (!__hasProp.call(meta, k)) continue;
              v = meta[k];
              if (__indexOf.call(PKEYS, k) < 0) {
                this[k] = v;
              }
            }
          }
          return this;
        };
        _ref = Entity.prototype;
        for (k in _ref) {
          if (!__hasProp.call(_ref, k)) continue;
          v = _ref[k];
          ctor.prototype[k] = v;
        }
        ctor.typeId = type.id;
        ctor.properties = {};
        _applyType.call(ctor, type, defaults = {});
        for (k in defaults) {
          if (!__hasProp.call(defaults, k)) continue;
          v = defaults[k];
          ctor.prototype[k] = v;
        }
        return ctor;
      };
    })();

    Entity.create = function(meta) {
      var Ctor, obj, type, utype, _ref;
      if (meta.id) {
        _ref = meta.id.split(':'), meta.id = _ref[0], type = _ref[1];
      }
      if (type) {
        meta.type = type;
      }
      if ((utype = TYPES.findUnresolved(meta.type))) {
        return TYPES.resolve(utype, ((function(_this) {
          return function(err) {
            if (!err) {
              return _this.create(meta);
            }
          };
        })(this)));
      }
      Ctor = this.getCtor(meta);
      obj = new Ctor(meta);
      obj.launch(meta.callback);
      return obj;
    };

    return Entity;

  })();

  TYPES.define({
    id: 'Axoid',
    methods: function(_super) {
      return {
        onEvent: function(ev) {
          return this[ev.uri.host](ev);
        },
        define: function(ev, u) {
          var p;
          if (u == null) {
            u = ev.uri;
          }
          if (p = u.path[0]) {
            ev.id = p;
          }
          if (p = u.path[1]) {
            ev.superId = ev.id;
            ev.id = p;
          }
          if (ev.superId === 'Property') {
            Property.define(ev);
          } else {
            TYPES.define(ev);
          }
          return ev.callback();
        },
        create: function(ev, u) {
          var p;
          if (u == null) {
            u = ev.uri;
          }
          if (p = u.hash) {
            ev.id = p;
          }
          if (p = u.path[0]) {
            ev.type = p;
          }
          return Entity.create(ev);
        },
        require: (function(_cache) {
          var createCb, performRequire;
          if (_cache == null) {
            _cache = {};
          }
          createCb = function(ctx) {
            return function(err, r) {
              var cb;
              if (err) {
                Object.error(err).log();
              }
              if (!err) {
                ctx.isDone = 1;
              }
              while ((cb = ctx.q.shift())) {
                cb(err, r);
              }
              return 1;
            };
          };
          return performRequire = function(ev) {
            var dependencies;
            dependencies = ev.dependencies;
            if (typeof dependencies === 'string') {
              dependencies = [dependencies];
            }
            if (!(dependencies != null ? dependencies.length : void 0)) {
              return ev.callback(null, 0);
            }
            return Function.perform(ev, function(flow) {
              return [
                function() {
                  var ctx, x, _i, _len;
                  for (_i = 0, _len = dependencies.length; _i < _len; _i++) {
                    x = dependencies[_i];
                    if (x && (ctx = _cache[x] || (_cache[x] = {
                      q: [],
                      x: x
                    })) && !ctx.isDone) {
                      ctx.q.push(flow.wait());
                      if (ctx.q.length === 1) {
                        Object.fire({
                          uri: x,
                          callback: createCb(ctx)
                        });
                      }
                    }
                  }
                  return flow.next(null, dependencies.length);
                }, ev.callback
              ];
            });
          };
        })()
      };
    }
  });

  Entity.create({
    id: 'axoid',
    type: 'Axoid'
  });


  /*
      Fires an event.
      
      @param [Object] event event object. Required.
      
      @option event uri [Object.Uri] uri referring target entity (which `entity.id` equals to `uri.type`). Required.
      @option event callback [Function] callback to be invoked from target. Optional. Stub by default.
  
      @example
      
          Object.emit
               * "db" is id of database entity. Rest of url adresses operation and its parameters:
              uri: "db://changes?include_docs=true&since=#{since}"
              callback: (err, result)->
                   * handle with results unless errror
                  doSome(result) unless err
   */

  Object.emit = Object.fire = function(event) {
    if (!event.uri) {
      throw new Error("No uri specified");
    }
    event.uri = Object.Uri.parse(event.uri);
    if (event.callback == null) {
      event.callback = STUB;
    }
    return $.instance(event.uri.type).fire(event);
  };

}).call(this);


/*
 * Defines [Cache] entity type that provides caching feature.
 * @options
 *   version
 *   uriPatterm
 *   storage
 */

(function() {
  Object.emit({
    uri: "axoid://define/EventHandler/Cache",
    uriPattern: 'remote://{{host}}/{{path}}?_ver={{version}}',
    methods: function(_super) {
      var CACHE;
      CACHE = {};
      return {
        resolveUri: function(u) {
          u = Object.clone(u, u.params);
          u.path = u.path.join('/');
          if (!u.version) {
            u.version = this.getVersion();
          }
          return Object.Uri.parse(String.template(this.uriPattern, u));
        },
        cacheDeserializer: function(s) {
          if (!s) {
            return null;
          }
          if (typeof s === "object") {
            return s;
          } else {
            return Object.parse(s);
          }
        },
        cacheSerializer: function(s) {
          if (!s) {
            return null;
          }
          s = typeof s === "object" ? JSON.stringify(s) : s;
          if (s && s !== "{}") {
            return s;
          } else {
            return null;
          }
        },
        getVersion: function() {
          return '' + (this.version || 1);
        },
        fetch: function(uri, cb) {
          return Object.emit({
            uri: this.resolveUri(uri),
            callback: cb,
            unmarshaller: this.fetchUnmarshaller
          });
        },
        restore: function(key) {
          var s, ver, _ref;
          if (!(s = (_ref = this.storage) != null ? _ref[key] : void 0)) {
            return null;
          }
          ver = this.getVersion();
          if (ver === s.slice(0, +(ver.length - 1) + 1 || 9e9)) {
            return s.slice(ver.length + 1);
          } else {
            return null;
          }
        },
        store: function(key, s) {
          var _ref;
          try {
            return (_ref = this.storage) != null ? _ref.setItem(key, this.getVersion() + ":" + s) : void 0;
          } catch (_error) {}
        },
        onEvent: function(ev) {
          var key, r, u;
          u = ev.uri;
          key = this.id + ':' + u.id;
          if ((r = CACHE[key] || (CACHE[key] = this.cacheDeserializer(this.restore(key))))) {
            return ev.callback(null, r);
          }
          return this.fetch(u, (function(_this) {
            return function(err, data) {
              var s;
              if ((err = (typeof s !== "undefined" && s !== null ? s.error : void 0) || err)) {
                err = _this.error(err, "fetch data for versioned cache");
              }
              if (!err && (s = _this.cacheSerializer(data))) {
                CACHE[key] = data = _this.cacheDeserializer(s);
                _this.store(key, s);
              }
              return ev.callback(err, data);
            };
          })(this));
        }
      };
    }
  });

}).call(this);


/*
Dates.
 */

(function() {
  (function(MAXD, CURR) {
    var _nn;
    _nn = function(s) {
      return s && (s = "" + s) && (s.length < 2 ? "0" + s : s) || "00";
    };
    Date.PATTERN_PARSE = "yyyy-MM-dd";
    Date.PATTERN_FORMAT = "dd MMM yyyy";
    Date.daysInMonth = function(m, y) {
      return ((m === 1) && ((y % 4) === 0) ? 1 : 0) + MAXD[m];
    };
    Date.getTimeZone = function() {
      var l, m, t;
      l = -CURR.getTimezoneOffset();
      t = "" + Math.abs(l / 60);
      m = "" + Math.abs(l % 60);
      return "GMT" + (((l === 0) && "") || ("%2" + (l > 0 ? "B" : "D") + _nn(t) + ":" + _nn(m)));
    };
    Date.parse = function(s, pattern) {
      var d, p, r;
      if (pattern == null) {
        pattern = Date.PATTERN_PARSE;
      }
      if (!s) {
        return null;
      }
      if (s instanceof Date) {
        return s;
      }
      d = new Date();
      d.setDate(1);
      d.setHours(12);
      d.setMinutes(0);
      d.setSeconds(0);
      r = "" + pattern;
      if ((p = r.indexOf("yyyy")) > -1) {
        d.setFullYear(s.substr(p, 4));
      } else {
        if ((p = r.indexOf("yy")) > -1) {
          d.setFullYear(2000 + s.substr(p, 2));
        }
      }
      if ((p = r.indexOf("MM")) > -1) {
        d.setMonth(+s.substr(p, 2) - 1);
      }
      if ((p = r.indexOf("dd")) > -1) {
        d.setDate(+s.substr(p, 2));
      }
      if ((p = r.indexOf("HH")) > -1) {
        d.setHours(+s.substr(p, 2));
        if ((p = r.indexOf("mm")) > -1) {
          d.setMinutes(+s.substr(p, 2));
        }
        if ((p = r.indexOf("ss")) > -1) {
          d.setSeconds(+s.substr(p, 2));
        }
      }
      return d;
    };
    Date.shift = function(d, lag) {
      var r;
      r = new Date();
      r.setTime((d || r).getTime() + ((lag || 0) * 86400000));
      return r;
    };
    Date.days = function(d) {
      if (!(d && d.getTime)) {
        return 0;
      }
      d = d.getTime();
      return (d - d % 86400000) / 86400000;
    };
    Date.compare = function(x, y) {
      if (x && y) {
        if (x.getTime && y.getTime) {
          if (x.getTime() > y.getTime()) {
            return 1;
          } else {
            return -1;
          }
        } else {
          return 0;
        }
      } else {
        if (!x && !y) {
          return 0;
        } else {
          if (!!x) {
            return 1;
          } else {
            return -1;
          }
        }
      }
    };
    Date.monthName = function(m, lang, key) {
      var _ref;
      if (key == null) {
        key = "MONTH";
      }
      return (_ref = String.localize.get(key, lang)) != null ? _ref[_nn(m + 1)] : void 0;
    };
    Date.format = function(d, pattern, lng) {
      var r;
      if (pattern == null) {
        pattern = Date.PATTERN_FORMAT;
      }
      r = "";
      if (d && d.getFullYear) {
        r += pattern || Date.PATTERN_FORMAT;
        r = r.replace("yyyy", "" + d.getFullYear());
        r = r.replace("yy", "" + d.getFullYear());
        r = r.replace("MMMM", Date.monthName(d.getMonth(), lng));
        r = r.replace("MMM", Date.monthName(d.getMonth(), lng, "MONTH_SHORT"));
        r = r.replace("MM", _nn(d.getMonth() + 1));
        r = r.replace("dd", _nn(d.getDate()));
        r = r.replace("hh", _nn(d.getHours()));
        r = r.replace("mm", _nn(d.getMinutes()));
        r = r.replace("ss", _nn(d.getSeconds()));
      }
      return r;
    };
    return String.localize.add("en", {
      "DOW": {
        '1': "Su",
        '2': "Mo",
        '3': "Tu",
        '4': "We",
        '5': "Th",
        '6': "Fr",
        '7': "Sa"
      },
      "MONTH_SHORT": {
        '01': "Jan",
        '02': "Feb",
        '03': "Mar",
        '04': "Apr",
        '05': "May",
        '06': "Jun",
        '07': "Jul",
        '08': "Aug",
        '09': "Sep",
        '10': "Oct",
        '11': "Nov",
        '12': "Dec"
      },
      "MONTH": {
        '01': "January",
        '02': "February",
        '03': "March",
        '04': "April",
        '05': "May",
        '06': "June",
        '07': "July",
        '08': "August",
        '09': "September",
        '10': "October",
        '11': "November",
        '12': "December"
      }
    });
  })([31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31], new Date());

}).call(this);


/*
 * Defines [EventHandler] entity type that provides featured event handlig.
 * @param readyForEventsExpression [Expression]
 */

(function() {
  Object.emit({
    uri: "axoid://define/EventHandler",
    properties: ['readyForEvents'],
    readyForEventsExpression: 'true',
    methods: function(_super) {
      return {
        listenEvents: function() {},
        readyForEventsChanged: function(ready) {
          if (ready) {
            return _super.listenEvents.call(this);
          }
        },
        onEvent: function(ev) {
          return this.dispatchEvent(ev);
        },
        resolveOperationId: function(ev) {
          return (ev.method || 'get') + String.capitalize(ev.uri.path[0] || 'default');
        },
        dispatchEvent: function(ev) {
          var ex, op, opId;
          opId = this.resolveOperationId(ev);
          if (!(op = this[opId])) {
            return typeof ev.callback === "function" ? ev.callback(this.error("not-found: Operation not found: " + opId).log()) : void 0;
          }
          try {
            return op.call(this, ev);
          } catch (_error) {
            ex = _error;
            return typeof ev.callback === "function" ? ev.callback(this.error("Error in " + opId + " ").addDetails(ex).log()) : void 0;
          }
        }
      };
    }
  });

}).call(this);

(function() {
  Object.emit({
    uri: "axoid://define/L10nService/EnumService",
    methods: function(_super) {
      var CACHE;
      CACHE = {};
      return {
        onEvent: function(ev, u, key) {
          var r;
          if (u == null) {
            u = ev.uri;
          }
          if (key == null) {
            key = u.host;
          }
          if (r = CACHE[key]) {
            return ev.callback(null, r);
          }
          if (!(r = String.localize.asEnum(key))) {
            return ev.callback("not-found: enum [" + key + "]");
          }
          return ev.callback(null, CACHE[key] = r);
        }
      };
    }
  });

  Object.emit({
    uri: "axoid://define/L10nService",
    properties: ["requires:Requires"],
    methods: function(_super) {
      return {
        onRequiredLoaded: function(err) {
          var b, _i, _len, _results;
          if (err) {
            return;
          }
          _results = [];
          for (_i = 0, _len = arguments.length; _i < _len; _i++) {
            b = arguments[_i];
            if (b) {
              _results.push(String.localize.add(b));
            }
          }
          return _results;
        },
        onEvent: function(ev) {
          return ev.callback(null, String.localize(ev.uri.host));
        }
      };
    }
  });

}).call(this);

(function() {
  Object.log = (function(c) {
    if (c == null) {
      c = {
        log: function() {}
      };
    }
    if (!c.log.apply) {
      c._log = c.log;
      c.log = function() {
        var s;
        return c._log(((function() {
          var _i, _len, _results;
          _results = [];
          for (_i = 0, _len = arguments.length; _i < _len; _i++) {
            s = arguments[_i];
            _results.push(s);
          }
          return _results;
        }).apply(this, arguments)).join(", "));
      };
    }
    if (!c.error) {
      c.error = function() {
        var s;
        return c.log.apply(c, ['ERROR: '].concat((function() {
          var _i, _len, _results;
          _results = [];
          for (_i = 0, _len = arguments.length; _i < _len; _i++) {
            s = arguments[_i];
            _results.push(s);
          }
          return _results;
        }).apply(this, arguments)));
      };
    }
    return function(x) {
      var e;
      if (x != null ? x.printIntoLog : void 0) {
        x.printIntoLog(c);
      } else {
        c.log.apply(c, (function() {
          var _i, _len, _results;
          _results = [];
          for (_i = 0, _len = arguments.length; _i < _len; _i++) {
            e = arguments[_i];
            _results.push(e);
          }
          return _results;
        }).apply(this, arguments));
      }
      return x;
    };
  })((typeof window === 'object' ? window : this).console);

}).call(this);


/*
Math.
@mixin
 */

(function() {
  Object.math = {
    decimalAdjust: function(type, value, exp) {
      if (typeof exp === "undefined" || +exp === 0) {
        return Math[type](value);
      }
      value = +value;
      exp = +exp;
      if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
        return NaN;
      }
      value = value.toString().split("e");
      value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
      value = value.toString().split("e");
      return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
    },
    round: function(value, exp) {
      if (exp == null) {
        exp = 0;
      }
      return this.decimalAdjust("round", value, exp);
    },
    uuid: function() {
      var d;
      d = Date.now();
      return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        var r;
        r = (d + Math.random() * 16) % 16 | 0;
        d = Math.floor(d / 16);
        return (c === 'x' ? r : r & 0x7 | 0x8).toString(16);
      });
    },
    sort: function(a, key, dir) {
      var getter, rdir;
      if (!dir) {
        dir = 1;
      }
      rdir = dir * -1;
      getter = typeof key === "string" ? function(s) {
        return s != null ? s[key] : void 0;
      } : key || function(s) {
        return s;
      };
      return a.sort(function(s1, s2) {
        var v1, v2;
        if ((v1 = getter(s1)) > (v2 = getter(s2))) {
          return dir;
        } else {
          if (v1 < v2) {
            return rdir;
          } else {
            return 0;
          }
        }
      });
    }
  };

}).call(this);


/*
 Very common properties.
 */

(function() {
  Object.emit({
    uri: "axoid://define/Property/Liquid",
    methods: function() {
      return {
        comparator: function() {
          return false;
        }
      };
    }
  });

  Object.emit({
    uri: "axoid://define/Property/Boolean",
    methods: function() {
      return {
        comparator: function(a, b) {
          return (!a) === (!b);
        },
        setter: function(T, v, ev) {
          return T[this.id] = !!v;
        }
      };
    }
  });

  Object.emit({
    uri: "axoid://define/Property/Uri",
    methods: function() {
      return {
        comparator: function(a, b) {
          return ('' + a) === ('' + b);
        },
        setter: function(T, v, ev) {
          return T[this.id] = Object.Uri.parse(v);
        }
      };
    }
  });

  Object.emit({
    uri: "axoid://define/Property/Number",
    methods: function() {
      return {
        comparator: function(a, b) {
          return Number(a) === Number(b);
        },
        setter: function(T, v, ev) {
          return T[this.id] = Number(v);
        }
      };
    },
    mixin: function(_super, prop) {
      var propid, r;
      r = {};
      propid = prop.id;
      r['increment' + String.capitalize(propid)] = function(delta) {
        if (delta == null) {
          delta = 1;
        }
        return this.prop(propid, ((this.prop(propid)) || 0) + delta);
      };
      return r;
    }
  });

  Object.emit({
    uri: "axoid://define/Property/Date",
    methods: function() {
      return {
        comparator: function(a, b) {
          return Date.compare(a, b) === 0;
        }
      };
    }
  });

}).call(this);

(function() {
  Object.emit({
    uri: "axoid://define/Property/Plugins",
    mixin: function(_super) {
      return {
        launch: function(cb) {
          return Function.perform(this, function(flow) {
            return [
              function() {
                var meta, _i, _len, _ref;
                if (this.plugins) {
                  _ref = this.plugins;
                  for (_i = 0, _len = _ref.length; _i < _len; _i++) {
                    meta = _ref[_i];
                    Object.emit(Object.clone(meta, {
                      _parent: this,
                      uri: "axoid://create",
                      callback: flow.wait()
                    }));
                  }
                }
                return flow.next();
              }, function(err, plugins) {
                var e, i, id, p, _i, _len, _ref;
                if (err) {
                  this.error(err, "" + this + ".onPluginsInitializing");
                }
                this.plugins = (function() {
                  var _i, _len, _results;
                  _results = [];
                  for (i = _i = 0, _len = arguments.length; _i < _len; i = ++_i) {
                    e = arguments[i];
                    if (i > 1) {
                      _results.push(e);
                    }
                  }
                  return _results;
                }).apply(this, arguments);
                _ref = this.plugins;
                for (_i = 0, _len = _ref.length; _i < _len; _i++) {
                  p = _ref[_i];
                  if (id = p.id) {
                    this[id] = p;
                  }
                }
                return _super.launch.call(this, cb);
              }
            ];
          });
        },
        done: function() {
          var p, _i, _len, _ref, _results;
          _super.done.call(this);
          if (this.plugins) {
            _ref = this.plugins;
            _results = [];
            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
              p = _ref[_i];
              p.done();
              p._parent = null;
              if (p.id) {
                _results.push(this[p.id] = null);
              } else {
                _results.push(void 0);
              }
            }
            return _results;
          }
        }
      };
    }
  });

}).call(this);

(function() {
  Object.emit({
    uri: 'axoid://define/Property/Requires',
    mixin: function(_super) {
      return {
        launch: function(cb) {
          return Object.emit({
            uri: 'axoid://require',
            dependencies: this.requires,
            callback: (function(_this) {
              return function(err) {
                var e;
                if (err) {
                  Object.error(err, "" + _this + ".onRequires").log();
                }
                if (typeof _this.onRequiredLoaded === "function") {
                  _this.onRequiredLoaded.apply(_this, (function() {
                    var _i, _len, _results;
                    _results = [];
                    for (_i = 0, _len = arguments.length; _i < _len; _i++) {
                      e = arguments[_i];
                      _results.push(e);
                    }
                    return _results;
                  }).apply(_this, arguments));
                }
                return _super.launch.call(_this, cb);
              };
            })(this)
          });
        }
      };
    }
  });

}).call(this);

(function() {
  String.template = (function() {
    var $, encoder, fn, parse;
    parse = function(s, x) {
      var RE, e, lastIndex, r, r0, stack, tag, text;
      r = {
        tag: 'top',
        children: []
      };
      stack = [];
      lastIndex = 0;
      RE = /{{([?\/:#]?)([a-zA-Z0-9\._]+)(\|[a-z]+)?}}/g;
      while (e = RE.exec(s)) {
        if (e.index && (text = s.slice(lastIndex, +(e.index - 1) + 1 || 9e9))) {
          r.children.push({
            tag: '_',
            value: text
          });
        }
        tag = e[2];
        if ((e[1] === '?') || (e[1] === '#')) {
          stack.unshift(r);
          r.children.push(r0 = {
            tag: tag,
            children: [],
            flag: e[1]
          });
          r = r0;
        } else if (e[1] === '/') {
          r = stack.shift();
        } else if (e[1] === ':') {
          r = r['_' + tag] = {
            children: []
          };
        } else {
          r.children.push({
            tag: tag,
            opts: e[3]
          });
        }
        lastIndex = RE.lastIndex;
      }
      if (s = s.slice(lastIndex)) {
        r.children.push({
          tag: '_',
          value: s
        });
      }
      return r;
    };
    fn = function(node, obj) {
      var e, k0, n, r, tag, v, v0, _i, _j, _k, _len, _len1, _len2, _ref;
      r = [];
      if (node.children) {
        _ref = node.children;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          n = _ref[_i];
          if ((tag = n.tag) === '_') {
            r.push(n.value);
          } else {
            if ((v = tag === '.' ? obj : Object.prop(obj, tag))) {
              if (Array.isArray(v)) {
                if (v.length) {
                  if (n.flag === '?') {
                    r.push(fn(n, obj));
                  } else {
                    for (_j = 0, _len1 = v.length; _j < _len1; _j++) {
                      e = v[_j];
                      if (e) {
                        r.push(fn(n, e));
                      }
                    }
                  }
                } else {
                  if (n._else) {
                    r.push(fn(n._else, n.flag === '?' ? obj : v));
                  }
                }
              } else {
                r.push(fn(n, n.flag === '?' ? obj : v));
              }
            } else {
              if (n.flag === '#') {
                if (v) {
                  for (v0 = _k = 0, _len2 = v.length; _k < _len2; v0 = ++_k) {
                    k0 = v[v0];
                    if (v0) {
                      r.push(fn(n, {
                        id: k0,
                        value: v0
                      }));
                    }
                  }
                }
              } else {
                if (n._else) {
                  r.push(fn(n._else, n.flag === '?' ? obj : v));
                }
              }
            }
          }
        }
      } else {
        r.push($.writeValue(obj, r, node.opts));
      }
      return r.join('');
    };
    $ = function(s, obj) {
      return fn(parse(s), obj);
    };
    $.filters = {
      t: function(t) {
        return String.localize(t);
      },
      d: function(d) {
        return Date.format(d);
      }
    };
    encoder = function(i) {
      return '&#' + i.charCodeAt(0) + ';';
    };
    $.writeValue = function(obj, r, opts) {
      var f, fn0, _i, _len;
      if (opts) {
        for (_i = 0, _len = opts.length; _i < _len; _i++) {
          f = opts[_i];
          if (fn0 = this.filters[f]) {
            obj = fn0(obj);
          }
        }
      }
      r = '' + obj;
      if (!(opts && opts.indexOf('u'))) {
        r = r.replace(/[\u00A0-\u9999<>\&]/g, encoder);
      }
      return r;
    };
    return $;
  })();

}).call(this);

(function() {
  var __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
    __hasProp = {}.hasOwnProperty;

  Object.emit({
    uri: "axoid://define/Property/Value",
    mixin: function(_super) {
      return {
        getValue: function() {
          return this.prop("value");
        },
        setValue: function(v) {
          return this.prop("value", v);
        },
        isEmptyValue: function(e) {
          return !this.getValue();
        },
        equalsToValue: function(v) {
          return v && (this.getValue() === ("" + v));
        }
      };
    }
  });

  Object.emit({
    uri: "axoid://define/Property/MultiValue",
    mixin: function(_super) {
      return {
        valueChanged: function(v) {
          this.prop("mvalue", (v ? (v.split && v.length ? v.split(this.mvalueSeparator || ",") : ["" + v]) : []));
          _super.valueChanged.apply(this, arguments);
        },
        getMultiValue: function() {
          return this.mvalue || [];
        },
        equalsValue: function(v) {
          var _ref;
          return v && (_ref = "" + v, __indexOf.call(this.getMultiValue(), _ref) >= 0);
        },
        putIntoMultiValue: function(pk, v) {
          var changed, contained, i, mv, _i, _len;
          if (!pk) {
            return;
          }
          mv = this.getMultiValue();
          pk = "" + pk;
          contained = __indexOf.call(mv, pk) >= 0;
          changed = false;
          if (v === -1) {
            v = (contained ? 0 : 1);
          }
          if (v && !contained) {
            mv.push(pk);
            changed = true;
          }
          if ((!v) && contained) {
            for (i = _i = 0, _len = mv.length; _i < _len; i = ++_i) {
              pk = mv[i];
              if (pk === mv[i]) {
                mv.splice(i, 1);
                changed = true;
                break;
              }
            }
          }
          return changed && this.setValue(mv.sort().join(this.mvalueSeparator));
        }
      };
    }
  });


  /*
   * Defines [Values] property that is a values bundle.
   */

  Object.emit({
    uri: "axoid://define/Property/Values",
    methods: function() {
      return {
        comparator: function() {
          return false;
        }
      };
    },
    mixin: function(_super, property) {
      return {
        prop: function(key, value, opts) {
          var isRegisteredProperty, _ref;
          if (this.isDone) {
            return null;
          }
          isRegisteredProperty = this.constructor.properties[key.slice(-3) === 'Uri' ? key.slice(0, -3) : key];
          if (arguments.length === 1) {
            return (isRegisteredProperty ? _super.prop.call(this, key) : (_ref = this.value) != null ? _ref[key] : void 0);
          }
          if (isRegisteredProperty) {
            return _super.prop.call(this, key, (key === 'value' ? Object.clone(value) : value), opts);
          } else {
            if (!this.value) {
              this.value = {};
            }
            if (this.value[key] !== value) {
              this.value[key] = value;
              return this.propertyChanged.call(this, {
                entity: this,
                propId: key,
                value: value,
                oldValue: this.value[key]
              });
            }
          }
        },
        propertyChanged: function(ev) {
          var isRegisteredProperty, key, olds, p, v, _ref, _ref1;
          _super.propertyChanged.call(this, ev);
          key = ev.propId;
          if (key === 'valueUri') {
            return;
          }
          if (key === 'value') {
            olds = ev.oldValue;
            if (olds) {
              for (p in olds) {
                if (!__hasProp.call(olds, p)) continue;
                v = olds[p];
                if (((_ref = ev.value) != null ? _ref[p] : void 0) === void 0) {
                  _super.propertyChanged.call(this, {
                    entity: this,
                    propId: p,
                    value: null,
                    oldValue: v
                  });
                }
              }
            }
            if (ev.value) {
              _ref1 = ev.value;
              for (p in _ref1) {
                if (!__hasProp.call(_ref1, p)) continue;
                v = _ref1[p];
                if (v !== (olds != null ? olds[p] : void 0)) {
                  _super.propertyChanged.call(this, {
                    entity: this,
                    propId: p,
                    value: v,
                    oldValue: olds != null ? olds[p] : void 0
                  });
                }
              }
            }
          } else {
            if (!(isRegisteredProperty = this.constructor.properties[key.slice(-3) === 'Uri' ? key.slice(0, -3) : key])) {
              _super.propertyChanged.call(this, {
                entity: this,
                propId: 'value',
                value: this.value,
                oldValue: this.value
              });
            }
          }
          return ev;
        }
      };
    }
  });

}).call(this);