base-domain/dist/util.js

'use strict';
var Util, clone, deepEqual;

deepEqual = require('deep-eql');

clone = require('clone');


/**
@method Util
 */

Util = (function() {
  function Util() {}


  /**
  get __proto__ of the given object
  
  @method getProto
  @static
  @param {Object} obj
  @return {Object} __proto__
   */

  Util.getProto = function(obj) {
    if (Object.getPrototypeOf != null) {
      return Object.getPrototypeOf(obj);
    } else {
      return obj.__proto__;
    }
  };


  /**
  converts hyphenation to camel case
  
      'shinout-no-macbook-pro' => 'ShinoutNoMacbookPro'
      'shinout-no-macbook-pro' => 'shinoutNoMacbookPro' # if lowerFirst = true
  
  @method camelize
  @static
  @param {String} hyphened
  @param {Boolean} [lowerFirst=false] make capital char lower
  @return {String} cameled
   */

  Util.camelize = function(hyphened, lowerFirst) {
    var i, substr;
    if (lowerFirst == null) {
      lowerFirst = false;
    }
    return ((function() {
      var j, len, ref, results;
      ref = hyphened.split('-');
      results = [];
      for (i = j = 0, len = ref.length; j < len; i = ++j) {
        substr = ref[i];
        if (i === 0 && lowerFirst) {
          results.push(substr);
        } else {
          results.push(substr.charAt(0).toUpperCase() + substr.slice(1));
        }
      }
      return results;
    })()).join('');
  };


  /**
  converts hyphenation to camel case
  
      'ShinoutNoMacbookPro' => 'shinout-no-macbook-pro'
      'ABC' => 'a-b-c' # current implementation... FIXME ?
  
  @method hyphenize
  @static
  @param {String} hyphened
  @return {String} cameled
   */

  Util.hyphenize = function(cameled) {
    cameled = cameled.charAt(0).toUpperCase() + cameled.slice(1);
    return cameled.replace(/([A-Z])/g, function(st) {
      return '-' + st.charAt(0).toLowerCase();
    }).slice(1);
  };

  Util.serialize = function(v) {
    var attachClassName;
    return JSON.stringify((attachClassName = function(val, inModel) {
      var isModel, item, ret;
      if ((val == null) || typeof val !== 'object') {
        return val;
      }
      if (Array.isArray(val)) {
        return (function() {
          var j, len, results;
          results = [];
          for (j = 0, len = val.length; j < len; j++) {
            item = val[j];
            results.push(attachClassName(item, inModel));
          }
          return results;
        })();
      }
      ret = {};
      isModel = val.constructor.className != null;
      Object.keys(val).forEach(function(key) {
        return ret[key] = attachClassName(val[key], isModel || inModel);
      });
      if (val instanceof Error) {
        ret.stack = val.stack;
        ret.__errorMessage__ = val.message;
      } else if (isModel && !inModel) {
        ret.__className__ = val.constructor.className;
      }
      return ret;
    })(v, false));
  };

  Util.deserialize = function(str, facade) {
    var restore;
    if (str == null) {
      return str;
    }
    return (restore = function(val) {
      var className, item, key, ret, value;
      if ((val == null) || typeof val !== 'object') {
        return val;
      }
      if (Array.isArray(val)) {
        return (function() {
          var j, len, results;
          results = [];
          for (j = 0, len = val.length; j < len; j++) {
            item = val[j];
            results.push(restore(item));
          }
          return results;
        })();
      }
      if (val.__errorMessage__) {
        ret = new Error(val.__errorMessage__);
        for (key in val) {
          value = val[key];
          ret[key] = value;
        }
        delete ret.__errorMessage__;
        return ret;
      } else if (val.__className__) {
        className = val.__className__;
        delete val.__className__;
        return facade.createModel(className, val);
      } else {
        ret = {};
        for (key in val) {
          value = val[key];
          ret[key] = restore(value);
        }
        return ret;
      }
    })(JSON.parse(str));
  };


  /**
  in Titanium, "A instanceof B" sometimes fails.
  this is the alternative.
  
  @method isInstance
  @static
  @param {Object} instance
  @param {Function} class
  @return {Boolean} A is instance of B
   */

  Util.isInstance = function(instance, Class) {
    var className;
    if (typeof Ti === "undefined" || Ti === null) {
      return instance instanceof Class;
    }
    if (!(instance != null ? instance.constructor : void 0)) {
      return false;
    }
    if (Class === Object) {
      return true;
    }
    className = Class.name;
    while (instance.constructor !== Object) {
      if (instance.constructor.name === className) {
        return true;
      }
      instance = Object.getPrototypeOf(instance);
    }
    return false;
  };

  Util.deepEqual = function(a, b) {
    return deepEqual(a, b);
  };

  Util.clone = function(v) {
    return clone(v);
  };


  /**
  Check if the given value is instanceof Promise.
  
  "val instanceof Promise" fails when native Promise and its polyfill are mixed
   */

  Util.isPromise = function(val) {
    return typeof (val != null ? val.then : void 0) === 'function';
  };

  return Util;

})();

module.exports = Util;