jsynchronous 0.9.3 → 0.9.6

package/README.md

@@ -52,6 +52,8 @@ Jsynchronous can also handle server->server sync, or (experimentally) browser->s
 
 # Setting up
 
+Follow the [example code snippets](https://github.com/siriusastrebe/jsynchronous/tree/master/examples) for easy integration.
+
 Jsynchronous does not lock you into a transportation medium you use whether it be [socket.io](https://socket.io/) [ws](https://www.npmjs.com/package/ws) [Primus](https://www.npmjs.com/package/primus), [EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource), or [webRTC](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API). Any protocol with eventual in-order delivery works. We will be using [ws](https://www.npmjs.com/package/ws) in this example.
 
 The server side setup consists of 3 required steps:
@@ -255,7 +257,7 @@ $orientation.i = 0; // Will synchronize
 $orientation.j = 1; // Will synchronize
 ```
 
-We recommended you use the prefix ‘$’ or some other convention when you reference a synchronized variable to indicate that assignments to that variable will be sent over the network.
+We recommended you use the prefix ‘$’ or some other convention when you reference a synchronized variable to indicate that the variable is reactive and assignments to that variable will be sent over the network.
 
 # Documentation Reference
 

package/jsynchronous-client.d.ts

@@ -0,0 +1,40 @@
+type Stand_In = 'object' | 'array';
+type Event = 'changes' | 'snapshot';
+type Event_Changes_Callback = (data: any) => void;
+
+export type Synchronized_Variable<Variable_Type> = Variable_Type & {
+  $on: (event: Event, callback: Event_Changes_Callback) => void;
+  $info: () => {
+    client_history: boolean
+    counter: number
+    handshake: true
+    history_length: number
+    name: string
+    one_way: boolean
+    resyncs : number
+    rewind : boolean
+    rewound : boolean
+    snapshots : string[]
+    standIn : boolean
+  };
+  $tart: () => void;
+  $listeners: () => any[];
+  $napshot: (name: string) => void;
+  $rewind: (name: string, counter?: number) => void;
+  list: () => string[];
+  variables: () => { [key]: string, value: Synchronized_Variable<Variable_Type> };
+}
+
+declare function jsynchronous<Variable_Type>(standInType: Stand_In, name?: string): Synchronized_Variable<Variable_Type>;
+
+declare namespace jsynchronous {
+    export let send: (websocket: any, data: any) => void;
+    export const onmessage: (data: any) => void;
+}
+
+export default jsynchronous;
+
+// export interface jsynchronous {
+//   <Synchronized_Variable>(standInType: Stand_In, name: string) => Synchronized_Type;
+//   send: (data: any) => void;
+// }

package/jsynchronous-client.js

@@ -1,6 +1,8 @@
 var jsynchronous;
 
 function jsynchronousSetup() {
+  var ENCODE = false;
+
   var TYPE_ENCODINGS = [
     'array',
     'object',
@@ -11,7 +13,8 @@ function jsynchronousSetup() {
     'null',
     'empty',
     'bigint',
-    'function'
+    'function',
+    'date'
   ]
 
   var OP_ENCODINGS = [
@@ -40,7 +43,7 @@ function jsynchronousSetup() {
 
   function onmessage(data) {
     var json = JSON.parse(data);
-    var op = OP_ENCODINGS[json[0]]; 
+    var op = decodeOp(json[0]); 
     var name = json[1];
 
     if (op === 'initial') {
@@ -62,7 +65,7 @@ function jsynchronousSetup() {
         if (jsynchronous.send) {
           var uniqueId = 'initial' + name;
           communicateWithBackoff(uniqueId, ['initial', name], function () {
-console.log('Unknown jsynchronous variable, requesting initial' + name);
+            console.warn('Unknown jsynchronous variable, requesting initial' + name);
             return jsyncs[name] === undefined;
           }, 2000);
         } else {
@@ -140,7 +143,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
   }
 
   function newJsynchronous(name, counter, settings, data) {
-    var rootType = TYPE_ENCODINGS[data[0][1]];
+    var rootType = decodeType(data[0][1]);
     var jsync = jsyncObject(name, counter, settings);
     var reserved;
     if (settings) reserved = settings.reserved;
@@ -152,7 +155,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
     for (var i=0; i<data.length; i++) {
       var d = data[i];
       var hash = d[0];
-      var type = TYPE_ENCODINGS[d[1]];
+      var type = decodeType(d[1]);
       var each = d[2];
       var description = createSyncedVariable(hash, type, each, jsync, (i === 0)); 
 
@@ -249,9 +252,6 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
       hash: hash,
       type: type,
       variable: undefined,
-      descendants: {}, // key->value corresponds to descendant.hash->[properties]. Follow properties to find descendant
-      parents: {},     // key->value corresponds to parentHash->{details: parent, props: []}
-      children: {}     // key->value corresponds to childHash->{details: child, props: []}
     }
 
     if (existing && detailedType(existing.variable) === type) {
@@ -266,7 +266,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
     jsync.objects[hash] = details;
 
     enumerate(each, type, function (prop, encoded) {
-      var t = TYPE_ENCODINGS[encoded[0]]
+      var t = decodeType(encoded[0])
       var v = encoded[1];
 
       if (isPrimitive(t)) {
@@ -320,7 +320,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
 
       if (change === null) { continue }
 
-      var op = OP_ENCODINGS[change[0]];
+      var op = decodeOp(change[0]);
       var hash = change[1];
       var details;
       var pt;
@@ -347,7 +347,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
       } else if (op === 'new') {
         var type = change[2];
         var each = change[3];
-        createSyncedVariable(hash, TYPE_ENCODINGS[type], each, jsync); 
+        createSyncedVariable(hash, decodeType(type), each, jsync); 
       } else if (op === 'end') {
         endObject(details, jsync);
       } else if (op === 'snapshot') {
@@ -389,7 +389,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
   }
   function set(details, prop, newDetails, oldDetails, jsync) {
     var object = details.variable;
-    var type = TYPE_ENCODINGS[newDetails[0]];
+    var type = decodeType(newDetails[0]);
     var value;
 
     if (isPrimitive(type)) {
@@ -400,7 +400,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
       value = childDetails.variable;
     }
 
-    var oldType = TYPE_ENCODINGS[oldDetails[0]];
+    var oldType = decodeType(oldDetails[0]);
     var oldValue;
 
     if (isPrimitive(oldType)) {
@@ -414,7 +414,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
   }
   function del(details, prop, oldDetails, jsync) {
     var object = details.variable;
-    var oldType = TYPE_ENCODINGS[oldDetails[0]];
+    var oldType = decodeType(oldDetails[0]);
     var oldValue = oldDetails[1];
 
     if (isPrimitive(oldType)) {
@@ -557,6 +557,8 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
       return null;
     } else if (type === 'function') {
       return undefined;  // Functions are, for now, read-only
+    } else if (type === 'date') {
+      return new Date(value);
     }
   }
   function detailedType(value) {
@@ -596,7 +598,8 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
         type === 'null'      ||
         type === 'empty'     ||
         type === 'bigint'    ||
-        type === 'function') {  // Functions are, for now, read-only
+        type === 'function'  || // Functions are, for now, read-only
+        type === 'date') {
       return true
     } else {
       return false
@@ -662,15 +665,25 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
       return mirror;
     }
   }
+  function decodeOp(number) {
+    if (ENCODE) {
+      return OP_ENCODINGS[number]
+    } else {
+      return number
+    }
+  }
+  function decodeType(number) {
+    if (ENCODE) {
+      return TYPE_ENCODINGS[number];
+    } else {
+      return number;
+    }
+  }
+
 
 
   function addSynchronizedVariableMethods(jsync, targetVariable, reservedWords) {
     // targetVariable will be details.variable if it's synced. Otherwise it should be a stand-in variable
-    for (var key in clientReservedWords) {
-      if (typeof targetVariable[key] === 'function') {
-        delete targetVariable[key];
-      }
-    }
     if (reservedWords === undefined) reservedWords = {}
     for (var key in clientReservedWords) { 
       if (!reservedWords[key]) {
@@ -754,7 +767,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
       });
     }
   }
-  function triggerChanges(jsync, callback) {
+  function triggerChanges(jsync) {
     for (var j=0; j<jsync.changesEvents.length; j++) {
       var e = jsync.changesEvents[j];
       var variable = jsync.root.variable;
@@ -767,7 +780,7 @@ console.log('Unknown jsynchronous variable, requesting initial' + name);
   // ----------------------------------------------------------------
   function communicate(op, a, b, c, d) {
     var payload = []
-    payload.push(OP_ENCODINGS.indexOf(op));
+    payload.push(ENCODE ? OP_ENCODINGS.indexOf(op) : op);
     if (a !== undefined) payload.push(a);
     if (b !== undefined) payload.push(b);
     if (c !== undefined) payload.push(c);

package/jsynchronous.d.ts

@@ -0,0 +1,41 @@
+type Event_Changes_Callback = (data: any) => void;
+
+export type Synchronized_Variable<Variable_Type> = Variable_Type & {
+  $on: (event: Event, callback: Event_Changes_Callback) => void;
+  $ync: (websocket: any) => void;
+  $unsync: (websocket: any) => void;
+}
+
+export type JysnchronousOptions = {
+  rewind?: boolean;
+  one_way?: boolean;
+  send?: (websocket: any, data: any) => void;
+  buffer_time?: number;
+  client_history?: number;
+  history_limit?: number;
+  wait?: boolean;
+  $ync?: string;
+  $unsync?: string;
+  $on?: string;
+  $tart?: string;
+  $listeners?: string;
+  $info?: string;
+  $napshot?: string;
+  $rewind?: string;
+  $copy?: string;
+}
+
+export type Jsynchronous = {
+  <Variable_Type>(initialVariable: Variable_Type, name?: string, options?: JsynchronousOptions): Synchronized_Variable<Variable_Type>;
+  send: (websocket: any, data: any) => void;
+  onmessage: (websocket: any, data: any) => void;
+  list: () => string[];
+  variables: () => { [key: string]: Synchronized_Variable<Variable_Type> };
+  pausegc: () => void;
+  resumegc: () => void;
+  rungc: () => void;
+}
+
+declare const jsynchronous: Jsynchronous;
+
+export default jsynchronous;

package/jsynchronous.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const ENCODE = false;
+
 const TYPE_ENCODINGS = {
   'array': 0,
   'object': 1,
@@ -10,7 +12,8 @@ const TYPE_ENCODINGS = {
   'null': 6,
   'empty': 7,
   'bigint': 8,
-  'function': 9
+  'function': 9,
+  'date': 10
 }
 
 const OP_ENCODINGS = {
@@ -60,7 +63,7 @@ class Change {
   }
   encode() {
     const change = [
-      OP_ENCODINGS[this.operation],
+      encodeOp(this.operation),
       this.hash,
       this.prop,
       encode(this.value, this.type),
@@ -82,7 +85,7 @@ class Creation {
   }
   encode() {
     const creation = [
-      OP_ENCODINGS[this.operation],
+      encodeOp(this.operation),
       this.description[0],
       this.description[1],
       this.description[2]
@@ -106,7 +109,7 @@ class Deletion {
   }
   encode() {
     const deletion = [
-      OP_ENCODINGS[this.operation],
+      encodeOp(this.operation),
       this.hash
     ]
     return deletion;
@@ -132,7 +135,7 @@ class Snapshot {
   } 
   encode() {
     const snapshot = [
-       OP_ENCODINGS[this.operation],
+       encodeOp(this.operation),
        this.id,
        this.name
     ]
@@ -272,7 +275,7 @@ class SyncedObject {
   describe() {
     const state = [
       this.hash,
-      TYPE_ENCODINGS[this.type],
+      encodeOp(this.type),
       newCollection(this.type, this.proxy)
     ]
 
@@ -435,7 +438,7 @@ class JSynchronous {
     }
 
     for (let [websocket, listener] of this.listeners) {
-      this.send(websocket, JSON.stringify([OP_ENCODINGS['changes'], this.name, min, max, changes]));
+      this.send(websocket, JSON.stringify([encodeOp('changes'), this.name, min, max, changes]));
     }
 
     // Now that it's sent, the rest is history
@@ -470,7 +473,7 @@ class JSynchronous {
           return c.encode();
         });
 
-        this.send(websocket, JSON.stringify([OP_ENCODINGS['changes'], this.name, min, max, changes]));
+        this.send(websocket, JSON.stringify([encodeOp('changes'), this.name, min, max, changes]));
       }
     }
   }
@@ -557,7 +560,7 @@ class JSynchronous {
     } catch (e) {
       listener.penalty += 5;  // Penalize clients heavily if they trigger errors
       console.error("Jsynchronous client->server onmessage error", e);
-      jsynchronous.send(websocket, JSON.stringify([OP_ENCODINGS['error'], e.toString()]));
+      jsynchronous.send(websocket, JSON.stringify([encodeOp('error'), e.toString()]));
     }
   }
   handshake(websocket, listener, rootHash) {
@@ -567,7 +570,7 @@ class JSynchronous {
 
     let secret = listener.secret || randomHash();  // no need to worry about collisions. Secrets aren't shared.
     listener.secret = secret;
-    this.send(websocket, JSON.stringify([OP_ENCODINGS['handshake'], this.name, secret]));
+    this.send(websocket, JSON.stringify([encodeOp('handshake'), this.name, secret]));
   }
   resync(websocket, listener, json) {
     let secret = json[2];
@@ -578,17 +581,17 @@ class JSynchronous {
       let historyMax = historyMin + (max-min);
       if (historyMin === -1 || historyMax >= this.history.length) {
         // TODO: Hard reset on client
-        let payload = [OP_ENCODINGS['error'], 'Unable to resync'];
+        let payload = [encodeOp('error'), 'Unable to resync'];
         jsynchronous.send(websocket, JSON.stringify(payload));
       } else {
         let slice = this.history.slice(historyMin, historyMax);
         let encoded = slice.map((h) => h.encode());
-        let payload = [OP_ENCODINGS['changes'], this.name, min, max-1, encoded];
+        let payload = [encodeOp('changes'), this.name, min, max-1, encoded];
         this.send(websocket, JSON.stringify(payload));
       }
     } else {
       // TODO: Tear this out, we don't need to be polite to clients that fail the secret check
-      let payload = [OP_ENCODINGS['error'], 'Secret check failed'];
+      let payload = [encodeOp('error'), 'Secret check failed'];
       jsynchronous.send(websocket, JSON.stringify(payload));
     }
   }
@@ -712,7 +715,7 @@ class JSynchronous {
     }
 
     const fullState = [
-      OP_ENCODINGS['initial'],
+      encodeOp('initial'),
       this.name,
       this.counter,
       settings
@@ -880,7 +883,8 @@ function isPrimitive(detailed) {
       detailed === 'bigint'    ||
       detailed === 'null'      ||  // Although null is in ECMA an object, we'll consider it a primitive for simplicity
       detailed === 'undefined' || 
-      detailed === 'function') {   // For now, functions are just values as far as jsynchronous is concerned
+      detailed === 'function'  ||  // For now, functions are just values as far as jsynchronous is concerned
+      detailed === 'date') {
     return true;
   } else {
     return false;
@@ -1020,15 +1024,15 @@ function labelEmpty(source, target) {
     if (value === undefined) {
       allKeys = allKeys || Object.keys(source).map(k => Number(k));
       if (binarySearch(allKeys, ((a) => a - i)) === -1) { 
-        target[i] = [TYPE_ENCODINGS['empty']];
+        target[i] = [encodeOp('empty')];
       }
     }
   }
 }
 
 function encode(value, type) {
-  // Expects value to be either be a primitive or a syncedObject Proxy
-  const encoded = [TYPE_ENCODINGS[type]];
+  // Expects value to be either be a primitive, a date or a syncedObject Proxy
+  const encoded = [encodeOp(type)];
 
   if (isPrimitive(type)) {
     const p = encodePrimitive(value, type)
@@ -1051,6 +1055,7 @@ function encodePrimitive(value, type) {
   if (type === 'boolean')   return !!value ? 1 : 0;
   if (type === 'bigint')    return String(value);
   if (type === 'function')  return undefined;
+  if (type === 'date')      return value.getTime();
   throw `Jsynchronous sanity error - Primitive is unserializable ${type}, ${value}`;
 }
 function encodeEnumerable(value) {
@@ -1061,8 +1066,26 @@ function encodeEnumerable(value) {
   return syncedObject.hash;
 }
 function getOp(number) {
-  for (const [key, value] of Object.entries(OP_ENCODINGS)) {
-    if (value === number) return key;
+  if (ENCODE) {
+    for (const [key, value] of Object.entries(OP_ENCODINGS)) {
+      if (value === number) return key;
+    }
+    return false;
+  } else {
+    return number;
+  }
+}
+function encodeType(type) {
+  if (encode) {
+    return TYPE_ENCODINGS[type];
+  } else {
+    return type;
+  }
+}
+function encodeOp(op) {
+  if (ENCODE) {
+    return OP_ENCODINGS[op];
+  } else {
+    return op;
   }
-  return false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsynchronous",
-  "version": "0.9.3",
+  "version": "0.9.6",
   "author": "Sirius Strebe <siriusastrebe@gmail.com> (http://asksiri.us)",
   "repository": {
     "type": "git",

package/tests/selenium/test.js

@@ -67,7 +67,7 @@ app.get('/jsynchronous-client.js', (req, res) => {
 // ----------------------------------------------------------------
 // Selenium Test
 // ----------------------------------------------------------------
-const browsers = ['firefox', 'chrome'];
+const browsers = ['firefox'];
 let drivers = [];
 const runTests = (async () => {
   drivers = await Promise.all(browsers.map((browser) => new Builder().forBrowser(browser).build()));