seqda 1.0.1 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seqda",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Sequential Data Store",
   "main": "src/index.js",
   "type": "commonjs",

package/src/index.js

@@ -6,15 +6,65 @@ const EventEmitter  = require('events');
 const QUEUE_CHANGE_EVENT  = Symbol.for('__seqdaQueueChangeEvent');
 const QUEUE_CHANGE_INFO   = Symbol.for('__seqdaQueueChangeInfo');
 const INTERNAL_STATE      = Symbol.for('__seqdaInternalState');
+const UNBOUND_METHOD      = Symbol.for('__seqdaUnboundMethod');
+const DISALLOW_WRITE      = Symbol.for('__seqdaDisallowWrite');
+
+function cloneStore(store, readyOnly) {
+  const cloneScope = (scope, _newStore) => {
+    let keys      = Object.keys(scope);
+    let newScope  = (!_newStore) ? new EventEmitter() : {};
+    let newStore  = _newStore || newScope;
+
+    if (!_newStore)
+      newStore.setMaxListeners(Infinity);
+
+    for (let i = 0, il = keys.length; i < il; i++) {
+      let key   = keys[i];
+      if (key === '_events' || key === '_eventsCount' || key === '_maxListeners')
+        continue;
+
+      let value = scope[key];
+      if (typeof value === 'function')
+        newScope[key] = storeUnboundMethod(value[UNBOUND_METHOD].bind(newStore), value[UNBOUND_METHOD]);
+      else
+        newScope[key] = cloneScope(value, newStore);
+    }
+
+    return newScope;
+  };
+
+  let clonedStore         = cloneScope(store);
+  let clonedInternalState = Object.assign({}, store[INTERNAL_STATE]);
+
+  Object.defineProperties(clonedStore, {
+    [INTERNAL_STATE]: {
+      writable:     (readyOnly !== true) ? true : false,
+      enumberable:  false,
+      configurable: false,
+      value:        (readyOnly !== true) ? clonedInternalState : Object.freeze(clonedInternalState),
+    },
+  });
+
+  return initializeStore(clonedStore, readyOnly);
+}
 
 function queueChangeEvent(path) {
   let info = this[QUEUE_CHANGE_INFO];
   if (!info.promise) {
     info.promise = Promise.resolve();
     info.promise.then(() => {
-      this.emit('update', { store: this, modified: Array.from(Object.keys(info.eventQueue)) });
+      let modified      = Array.from(Object.keys(info.eventQueue));
+      let previousStore = info.previousStore;
+
       info.eventQueue = {};
       info.promise = null;
+      info.previousStore = cloneStore(this, true);
+
+      this.emit('update', {
+        store: this,
+        previousStore,
+        modified,
+      });
     });
   }
 
@@ -92,8 +142,22 @@ function getPath(...parts) {
   return parts.filter(Boolean).join('.');
 }
 
-function createStoreSubsection(store, sectionTemplate, path) {
-  const isCacheInvalid = (scopeName, args) => {
+function storeUnboundMethod(boundMethod, method) {
+  Object.defineProperty(boundMethod, UNBOUND_METHOD, {
+    writable:     false,
+    enumerable:   false,
+    configurable: false,
+    value:        method,
+  });
+
+  return boundMethod;
+}
+
+function createStoreSubsection(options, sectionTemplate, path) {
+  function isCacheInvalid(scopeName, args) {
+    if (this[DISALLOW_WRITE])
+      return true;
+
     let thisCache = cache[scopeName];
     if (!thisCache)
       return true;
@@ -108,59 +172,75 @@ function createStoreSubsection(store, sectionTemplate, path) {
     }
 
     return false;
-  };
+  }
+
+  function setCache(scopeName, args, result) {
+    if (this[DISALLOW_WRITE])
+      return;
 
-  const setCache = (scopeName, args, result) => {
     cache[scopeName] = {
       args,
       result,
     };
-  };
+  }
 
   const createScopeMethod = (scopeName, func) => {
-    return (...args) => {
-      if (isCacheInvalid(scopeName, args)) {
-        let result = func({ get, set, store }, ...args);
-        setCache(scopeName, args, result);
+    let method = function(...args) {
+      if (isCacheInvalid.call(this, scopeName, args)) {
+        let result = func({
+          get:    getState.bind(this),
+          set:    setState.bind(this),
+          store:  this,
+        }, ...args);
+
+        setCache.call(this, scopeName, args, result);
+
         return result;
       } else {
         return cache[scopeName].result;
       }
     };
+
+    return storeUnboundMethod(method.bind(this), method);
   };
 
-  const get = () => {
-    store.emit('fetchScope', { store, scopeName: path });
-    let currentState = Nife.get(store[INTERNAL_STATE], path);
+  function getState() {
+    if (options.emitOnFetch === true)
+      this.emit('fetchScope', { store: this, scopeName: path });
+
+    let currentState = Nife.get(this[INTERNAL_STATE], path);
     return currentState;
-  };
+  }
 
-  const set = (value) => {
-    let currentState = Nife.get(store[INTERNAL_STATE], path);
+  function setState(value) {
+    if (this[DISALLOW_WRITE])
+      return;
+
+    let currentState = Nife.get(this[INTERNAL_STATE], path);
     if (value && typeof value === 'object' && value === currentState)
       throw new Error(`Error: "${getPath(path)}" the state value is the same, but it is required to be different.`);
 
     let previousState = currentState;
-    store[INTERNAL_STATE] = setPath(store[INTERNAL_STATE], path, value);
+    this[INTERNAL_STATE] = setPath(this[INTERNAL_STATE], path, value);
 
     cache = {};
 
-    if (store[QUEUE_CHANGE_EVENT])
-      store[QUEUE_CHANGE_EVENT](path, value, previousState);
+    if (this[QUEUE_CHANGE_EVENT])
+      this[QUEUE_CHANGE_EVENT](path, value, previousState);
 
     return value;
-  };
+  }
 
   if (path && !Object.prototype.hasOwnProperty.call(sectionTemplate, '_'))
     throw new Error(`Error: "${getPath}._" default value must be defined.`);
 
-  const scope   = (!path) ? store : {};
+  const scope   = (!path) ? this : {};
   let keys      = Object.keys(sectionTemplate || {});
   let subScopes = [];
   let cache     = {};
 
   if (path)
-    set(clone(sectionTemplate._));
+    setState.call(this, clone(sectionTemplate._));
 
   for (let i = 0, il = keys.length; i < il; i++) {
     let key = keys[i];
@@ -169,7 +249,7 @@ function createStoreSubsection(store, sectionTemplate, path) {
 
     let value = sectionTemplate[key];
     if (Nife.instanceOf(value, 'object')) {
-      scope[key] = createStoreSubsection(store, value, getPath(path, key));
+      scope[key] = createStoreSubsection.call(this, options, value, getPath(path, key));
       subScopes.push(key);
       continue;
     }
@@ -181,59 +261,82 @@ function createStoreSubsection(store, sectionTemplate, path) {
   }
 
   if (!path)
-    return scope; // We can't freeze the store
+    return this; // We can't freeze the store
   else
     return Object.freeze(scope);
 }
 
-function createStore(template) {
+function initializeStore(store, readyOnly) {
+  Object.defineProperties(store, {
+    'getState': {
+      writable:     false,
+      enumberable:  false,
+      configurable: false,
+      value:        () => store[INTERNAL_STATE],
+    },
+  });
+
+  if (readyOnly !== true) {
+    Object.defineProperties(store, {
+      'hydrate': {
+        writable:     false,
+        enumberable:  false,
+        configurable: false,
+        value:        (value) => {
+          store[INTERNAL_STATE] = Object.freeze(clone(value));
+          queueChangeEvent.call(store, '*');
+        },
+      },
+      [QUEUE_CHANGE_EVENT]: {
+        writable:     false,
+        enumberable:  false,
+        configurable: false,
+        value:        queueChangeEvent.bind(store),
+      },
+      [QUEUE_CHANGE_INFO]: {
+        writable:     true,
+        enumberable:  false,
+        configurable: false,
+        value:        {
+          previousStore: cloneStore(store, true),
+        },
+      },
+    });
+  } else {
+    Object.defineProperties(store, {
+      [DISALLOW_WRITE]: {
+        writable:     false,
+        enumberable:  false,
+        configurable: false,
+        value:        true,
+      },
+    });
+  }
+
+  return store;
+}
+
+function createStore(template, _options) {
   if (!Nife.instanceOf(template, 'object'))
     throw new TypeError('createStore: provided "template" must be an object.');
 
+  const options = _options || {};
   const store = new EventEmitter();
 
+  store.setMaxListeners(Infinity);
+
   Object.defineProperty(store, INTERNAL_STATE, {
     writable:     true,
     enumerable:   false,
-    configurable: true,
+    configurable: false,
     value:        {},
   });
 
-  let constructedStore = createStoreSubsection(store, template);
-
-  Object.defineProperties(constructedStore, {
-    'getState': {
-      writable:     false,
-      enumberable:  false,
-      configurable: false,
-      value:        () => constructedStore[INTERNAL_STATE],
-    },
-    'hydrate': {
-      writable:     false,
-      enumberable:  false,
-      configurable: false,
-      value:        (value) => {
-        constructedStore[INTERNAL_STATE] = Object.freeze(clone(value));
-        queueChangeEvent.call(constructedStore, '*');
-      },
-    },
-    [QUEUE_CHANGE_EVENT]: {
-      writable:     false,
-      enumberable:  false,
-      configurable: false,
-      value:        queueChangeEvent.bind(constructedStore),
-    },
-    [QUEUE_CHANGE_INFO]: {
-      writable:     true,
-      enumberable:  false,
-      configurable: false,
-      value:        {},
-    },
-  });
-
-  return constructedStore;
+  let constructedStore = createStoreSubsection.call(store, options, template);
+  return initializeStore(constructedStore);
 }
 
 module.exports = {
+  cloneStore,
   createStore,
 };