@bigtyphoon/melo 1.7.6

package/template/web-server/public/js/lib/component.json

@@ -0,0 +1,6 @@
+{
+  "name": "melo-client",
+  "description": "melo-client",
+  "local": [ "boot" ],
+  "paths": [ "local"]
+}

package/template/web-server/public/js/lib/local/boot/component.json

@@ -0,0 +1,11 @@
+{
+  "name": "boot",
+  "description": "Main app boot component",
+  "dependencies": {
+    "component/emitter":"master",
+    "node-melo/melo-protocol": "master",
+    "melonode/melo-protobuf": "*",
+    "pinusnode/pinus-jsclient-websocket": "master"
+  },
+  "scripts": ["index.js"]
+}

package/template/web-server/public/js/lib/local/boot/index.js

@@ -0,0 +1,11 @@
+  var Emitter = require('emitter');
+  window.EventEmitter = Emitter;
+
+  var protocol = require('@bigtyphoon/melo-protocol');
+  window.Protocol = protocol;
+  
+  var protobuf = require('@bigtyphoon/melo-protobuf');
+  window.protobuf = protobuf;
+  
+  var melo = require('pinus-jsclient-websocket');
+  window.melo = melo;

package/template/web-server/public/js/lib/meloclient.js

@@ -0,0 +1,456 @@
+(function() {
+  var isArray = Array.isArray;
+
+  var root = this;
+
+  function EventEmitter() {
+  }
+
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports.EventEmitter = EventEmitter;
+  }
+  else {
+    root = window;
+    root.EventEmitter = EventEmitter;
+  }
+
+  // By default EventEmitters will print a warning if more than
+  // 10 listeners are added to it. This is a useful default which
+  // helps finding memory leaks.
+  //
+  // Obviously not all Emitters should be limited to 10. This function allows
+  // that to be increased. Set to zero for unlimited.
+  var defaultMaxListeners = 10;
+  EventEmitter.prototype.setMaxListeners = function(n) {
+    if (!this._events) this._events = {};
+    this._maxListeners = n;
+  };
+
+
+  EventEmitter.prototype.emit = function() {
+    var type = arguments[0];
+    // If there is no 'error' event listener then throw.
+    if (type === 'error') {
+      if (!this._events || !this._events.error ||
+          (isArray(this._events.error) && !this._events.error.length))
+        {
+          if (this.domain) {
+            var er = arguments[1];
+            er.domain_emitter = this;
+            er.domain = this.domain;
+            er.domain_thrown = false;
+            this.domain.emit('error', er);
+            return false;
+          }
+
+          if (arguments[1] instanceof Error) {
+            throw arguments[1]; // Unhandled 'error' event
+          } else {
+            throw new Error("Uncaught, unspecified 'error' event.");
+          }
+          return false;
+        }
+    }
+
+    if (!this._events) return false;
+    var handler = this._events[type];
+    if (!handler) return false;
+
+    if (typeof handler == 'function') {
+      if (this.domain) {
+        this.domain.enter();
+      }
+      switch (arguments.length) {
+        // fast cases
+        case 1:
+          handler.call(this);
+        break;
+        case 2:
+          handler.call(this, arguments[1]);
+        break;
+        case 3:
+          handler.call(this, arguments[1], arguments[2]);
+        break;
+        // slower
+        default:
+          var l = arguments.length;
+        var args = new Array(l - 1);
+        for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
+        handler.apply(this, args);
+      }
+      if (this.domain) {
+        this.domain.exit();
+      }
+      return true;
+
+    } else if (isArray(handler)) {
+      if (this.domain) {
+        this.domain.enter();
+      }
+      var l = arguments.length;
+      var args = new Array(l - 1);
+      for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
+
+      var listeners = handler.slice();
+      for (var i = 0, l = listeners.length; i < l; i++) {
+        listeners[i].apply(this, args);
+      }
+      if (this.domain) {
+        this.domain.exit();
+      }
+      return true;
+
+    } else {
+      return false;
+    }
+  };
+
+  EventEmitter.prototype.addListener = function(type, listener) {
+    if ('function' !== typeof listener) {
+      throw new Error('addListener only takes instances of Function');
+    }
+
+    if (!this._events) this._events = {};
+
+    // To avoid recursion in the case that type == "newListeners"! Before
+    // adding it to the listeners, first emit "newListeners".
+    this.emit('newListener', type, typeof listener.listener === 'function' ?
+              listener.listener : listener);
+
+    if (!this._events[type]) {
+      // Optimize the case of one listener. Don't need the extra array object.
+      this._events[type] = listener;
+    } else if (isArray(this._events[type])) {
+
+      // If we've already got an array, just append.
+      this._events[type].push(listener);
+
+    } else {
+      // Adding the second element, need to change to array.
+      this._events[type] = [this._events[type], listener];
+
+    }
+
+    // Check for listener leak
+    if (isArray(this._events[type]) && !this._events[type].warned) {
+      var m;
+      if (this._maxListeners !== undefined) {
+        m = this._maxListeners;
+      } else {
+        m = defaultMaxListeners;
+      }
+
+      if (m && m > 0 && this._events[type].length > m) {
+        this._events[type].warned = true;
+        console.error('(node) warning: possible EventEmitter memory ' +
+                      'leak detected. %d listeners added. ' +
+                      'Use emitter.setMaxListeners() to increase limit.',
+        this._events[type].length);
+        console.trace();
+      }
+    }
+
+    return this;
+  };
+
+  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+  EventEmitter.prototype.once = function(type, listener) {
+    if ('function' !== typeof listener) {
+      throw new Error('.once only takes instances of Function');
+    }
+
+    var self = this;
+    function g() {
+      self.removeListener(type, g);
+      listener.apply(this, arguments);
+    };
+
+    g.listener = listener;
+    self.on(type, g);
+
+    return this;
+  };
+
+  EventEmitter.prototype.removeListener = function(type, listener) {
+    if ('function' !== typeof listener) {
+      throw new Error('removeListener only takes instances of Function');
+    }
+
+    // does not use listeners(), so no side effect of creating _events[type]
+    if (!this._events || !this._events[type]) return this;
+
+    var list = this._events[type];
+
+    if (isArray(list)) {
+      var position = -1;
+      for (var i = 0, length = list.length; i < length; i++) {
+        if (list[i] === listener ||
+            (list[i].listener && list[i].listener === listener))
+          {
+            position = i;
+            break;
+          }
+      }
+
+      if (position < 0) return this;
+      list.splice(position, 1);
+    } else if (list === listener ||
+               (list.listener && list.listener === listener))
+      {
+        delete this._events[type];
+      }
+
+      return this;
+  };
+
+  EventEmitter.prototype.removeAllListeners = function(type) {
+    if (arguments.length === 0) {
+      this._events = {};
+      return this;
+    }
+
+    var events = this._events && this._events[type];
+    if (!events) return this;
+
+    if (isArray(events)) {
+      events.splice(0);
+    } else {
+      this._events[type] = null;
+    }
+
+    return this;
+  };
+
+  EventEmitter.prototype.listeners = function(type) {
+    if (!this._events) this._events = {};
+    if (!this._events[type]) this._events[type] = [];
+    if (!isArray(this._events[type])) {
+      this._events[type] = [this._events[type]];
+    }
+    return this._events[type];
+  }
+})();
+
+(function (exports, global) {
+
+  var Protocol = exports;
+ 
+  var HEADER = 5;
+
+  var Message = function(id,route,body){
+      this.id = id;
+      this.route = route;
+      this.body = body;
+  };
+
+/**
+ *
+ *pomele client encode
+ * id message id;
+ * route message route
+ * msg message body
+ * socketio current support string
+ *
+ */
+Protocol.encode = function(id,route,msg){
+    var msgStr = JSON.stringify(msg);
+    if (route.length>255) { throw new Error('route maxlength is overflow'); }
+    var byteArray = new Uint16Array(HEADER + route.length + msgStr.length);
+    var index = 0;
+    byteArray[index++] = (id>>24) & 0xFF;
+    byteArray[index++] = (id>>16) & 0xFF;
+    byteArray[index++] = (id>>8) & 0xFF;
+    byteArray[index++] = id & 0xFF;
+    byteArray[index++] = route.length & 0xFF;
+    for(var i = 0;i<route.length;i++){
+        byteArray[index++] = route.charCodeAt(i);
+    }
+    for (var i = 0; i < msgStr.length; i++) {
+        byteArray[index++] = msgStr.charCodeAt(i);
+    }
+    return bt2Str(byteArray,0,byteArray.length);
+};
+
+
+
+
+/**
+ *
+ *client decode
+ *msg String data
+ *return Message Object
+ */
+Protocol.decode = function(msg){
+    var idx, len = msg.length, arr = new Array( len );
+    for ( idx = 0 ; idx < len ; ++idx ) {
+        arr[idx] = msg.charCodeAt(idx);
+    }
+    var index = 0;
+    var buf = new Uint16Array(arr);
+    var id = ((buf[index++] <<24) | (buf[index++])  << 16  |  (buf[index++]) << 8 | buf[index++]) >>>0; 
+    var routeLen = buf[HEADER-1];
+    var route = bt2Str(buf,HEADER, routeLen+HEADER);
+    var body = bt2Str(buf,routeLen+HEADER,buf.length);  
+    return new Message(id,route,body);
+};
+
+var bt2Str = function(byteArray,start,end) {
+    var result = "";
+    for(var i = start; i < byteArray.length && i<end; i++) {
+        result = result + String.fromCharCode(byteArray[i]);
+    };
+    return result;
+}
+
+})('object' === typeof module ? module.exports : (this.Protocol = {}), this);
+
+(function() {
+  if (typeof Object.create !== 'function') {
+    Object.create = function (o) {
+      function F() {}
+      F.prototype = o;
+      return new F();
+    };
+  }
+
+  var root = window;
+  var melo = Object.create(EventEmitter.prototype); // object extend from object
+  root.melo = melo;
+  var socket = null;
+  var id = 1;
+  var callbacks = {};
+
+  melo.init = function(params, cb){
+    melo.params = params;
+    params.debug = true;
+    var host = params.host;
+    var port = params.port;
+
+    var url = 'ws://' + host;
+    if(port) {
+      url +=  ':' + port;
+    }
+
+    socket = io(url, {'force new connection': true, reconnect: false});
+
+    socket.on('connect', function(){
+      console.log('[meloclient.init] websocket connected!');
+      if (cb) {
+        cb(socket);
+      }
+    });
+
+    socket.on('reconnect', function() {
+      console.log('reconnect');
+    });
+
+    socket.on('message', function(data){
+      if(typeof data === 'string') {
+        data = JSON.parse(data);
+      }
+      if(data instanceof Array) {
+        processMessageBatch(melo, data);
+      } else {
+        processMessage(melo, data);
+      }
+    });
+
+    socket.on('error', function(err) {
+      console.log(err);
+    });
+
+    socket.on('disconnect', function(reason) {
+      melo.emit('disconnect', reason);
+    });
+  };
+
+  melo.disconnect = function() {
+    if(socket) {
+      socket.disconnect();
+      socket = null;
+    }
+  };
+
+  melo.request = function(route) {
+    if(!route) {
+      return;
+    }
+    var msg = {};
+    var cb;
+    arguments = Array.prototype.slice.apply(arguments);
+    if(arguments.length === 2){
+      if(typeof arguments[1] === 'function'){
+        cb = arguments[1];
+      }else if(typeof arguments[1] === 'object'){
+        msg = arguments[1];
+      }
+    }else if(arguments.length === 3){
+      msg = arguments[1];
+      cb = arguments[2];
+    }
+    msg = filter(msg,route);
+  id++; 
+  callbacks[id] = cb;
+  var sg = Protocol.encode(id,route,msg);
+    socket.send(sg);
+  };
+
+  melo.notify = function(route,msg) {
+    this.request(route, msg);
+  };
+
+  var processMessage = function(melo, msg) {
+    var route;
+    if(msg.id) {
+      //if have a id then find the callback function with the request
+      var cb = callbacks[msg.id];
+      
+      delete callbacks[msg.id];
+      if(typeof cb !== 'function') {
+        console.log('[meloclient.processMessage] cb is not a function for request ' + msg.id);
+        return;
+      }
+
+      cb(msg.body);
+      return;
+    }
+
+    // server push message or old format message
+    processCall(msg);
+
+    //if no id then it should be a server push message
+    function processCall(msg) {
+      var route = msg.route;
+      if(!!route) {
+        if (!!msg.body) {
+          var body = msg.body.body;
+          if (!body) {body = msg.body;}
+          melo.emit(route, body);
+        } else {
+          melo.emit(route,msg);
+        }
+      } else {
+          melo.emit(msg.body.route,msg.body);
+      }
+    }
+  };
+
+  var processMessageBatch = function(melo, msgs) {
+    for(var i=0, l=msgs.length; i<l; i++) {
+      processMessage(melo, msgs[i]);
+    }
+  };
+
+  function filter(msg,route){
+    if(route.indexOf('area.') === 0){
+      msg.areaId = melo.areaId;
+    }
+
+    msg.timestamp = Date.now();
+    return msg;
+  }
+
+  
+})();