structure.js

'use strict';

var Immutable = require('immutable');
var Cursor = require('immutable/contrib/cursor');
var EventEmitter = require('eventemitter3').EventEmitter;
var inherits = require('inherits');
var utils = require('./utils');

/************************************
 *
 * ## Public API.
 *   Constructor({ history: bool, key: string, data: structure|object })
 *   .cursor(path)
 *   .reference(path)
 *   .forceHasSwapped(newData, oldData, keyPath)
 *   .undo(steps)
 *   .redo(steps)
 *   .undoUntil(structure)
 *
 ************************************/
function Structure (options) {
  var self = this;

  options = options || {};
  if (!(this instanceof Structure)) {
    return new Structure(options);
  }

  this.key = options.key || utils.generateRandomKey();

  this.current = options.data;
  if (!isImmutableStructure(this.current) || !this.current) {
    this.current = Immutable.fromJS(this.current || {});
  }

  if (!!options.history) {
    this.history = Immutable.List.of(this.current);
    this._currentRevision = 0;
  }

  this._pathListeners = [];
  this.on('swap', function (newData, oldData, keyPath) {
    listListenerMatching(self._pathListeners, pathString(keyPath)).forEach(function (fns) {
      fns.forEach(function (fn) {
        if (typeof fn !== 'function') return;
        fn(newData, oldData, keyPath);
      });
    });
  });

  EventEmitter.call(this, arguments);
}
inherits(Structure, EventEmitter);
module.exports = Structure;

Structure.prototype.cursor = function (path) {
  var self = this;
  path = path || [];

  if (!this.current) {
    throw new Error('No structure loaded.');
  }

  var changeListener = function (newRoot, oldRoot, path) {
    if(self.current === oldRoot) {
      self.current = newRoot;
    } else if(!hasIn(newRoot, path)) {
      // Othewise an out-of-sync change occured. We ignore `oldRoot`, and focus on
      // changes at path `path`, and sync this to `self.current`.
      self.current = self.current.removeIn(path);
    } else {
      // Update an existing path or add a new path within the current map.
      self.current = self.current.setIn(path, newRoot.getIn(path));
    }

    return self.current;
  };

  changeListener = handleHistory(this, changeListener);
  changeListener = handleSwap(this, changeListener);
  changeListener = handlePersisting(this, changeListener);
  return Cursor.from(self.current, path, changeListener);
};

Structure.prototype.reference = function (path) {
  if (isCursor(path) && path._keyPath) {
    path = path._keyPath;
  }
  var self = this, pathId = pathString(path);
  var listenerNs = self._pathListeners[pathId];
  var cursor = this.cursor(path);

  var changeListener = function (newRoot, oldRoot, changedPath) { cursor = self.cursor(path); };
  var referenceListeners = [changeListener];
  this._pathListeners[pathId] = !listenerNs ? referenceListeners : listenerNs.concat(changeListener);

  return {
    observe: function (eventName, newFn) {
      if (typeof eventName === 'function') {
        newFn = eventName;
        eventName = void 0;
      }
      if (this._dead || typeof newFn !== 'function') return;
      if (eventName && eventName !== 'swap') {
        newFn = onlyOnEvent(eventName, newFn);
      }

      self._pathListeners[pathId] = self._pathListeners[pathId].concat(newFn);
      referenceListeners = referenceListeners.concat(newFn);

      return function unobserve () {
        var fnIndex = self._pathListeners[pathId].indexOf(newFn);
        var localListenerIndex = referenceListeners.indexOf(newFn);

        if (referenceListeners[localListenerIndex] === newFn) {
          referenceListeners.splice(localListenerIndex, 1);
        }

        if (!self._pathListeners[pathId]) return;
        if (self._pathListeners[pathId][fnIndex] !== newFn) return;
        self._pathListeners[pathId].splice(fnIndex, 1);
      };
    },
    cursor: function (subPath) {
      if (subPath) return cursor.cursor(subPath);
      return cursor;
    },
    unobserveAll: function () {
      removeAllListenersBut(self, pathId, referenceListeners, changeListener);
      referenceListeners = [changeListener];
    },
    destroy: function () {
      removeAllListenersBut(self, pathId, referenceListeners);
      referenceListeners = void 0;
      cursor = void 0;

      this._dead = true;
      this.observe = void 0;
      this.unobserveAll = void 0;
      this.cursor = void 0;
      this.destroy = void 0;
    }
  };
};

Structure.prototype.forceHasSwapped = function (newData, oldData, keyPath) {
  this.emit('swap', newData || this.current, oldData, keyPath);
  possiblyEmitAnimationFrameEvent(this, newData || this.current, oldData, keyPath);
};

Structure.prototype.undo = function(back) {
  this._currentRevision -= back || 1;
  if (this._currentRevision < 0) {
    this._currentRevision = 0;
  }

  this.current = this.history.get(this._currentRevision);
  return this.current;
};

Structure.prototype.redo = function(head) {
  this._currentRevision += head || 1;
  if (this._currentRevision > this.history.count() - 1) {
    this._currentRevision = this.history.count() - 1;
  }

  this.current = this.history.get(this._currentRevision);
  return this.current;
};

Structure.prototype.undoUntil = function(structure) {
  this._currentRevision = this.history.indexOf(structure);
  this.current = structure;

  return structure;
};


/************************************
 * Private decorators.
 ***********************************/

// Update history if history is active
function handleHistory (emitter, fn) {
  return function (newData, oldData, path) {
    var newStructure = fn.apply(fn, arguments);
    if (!emitter.history || (newData === oldData)) return newStructure;

    emitter.history = emitter.history
      .take(++emitter._currentRevision)
      .push(emitter.current);

    return newStructure;
  };
}

// Update history if history is active
var possiblyEmitAnimationFrameEvent = (function () {
  var queuedChange = false;
  if (typeof requestAnimationFrame !== 'function') {
    return function () {};
  }

  return function requestAnimationFrameEmitter (emitter, newStructure, oldData) {
    if (queuedChange) return;
    queuedChange = true;

    requestAnimationFrame(function () {
      queuedChange = false;
      emitter.emit('next-animation-frame', newStructure, oldData);
    });
  };
}());

// Emit swap event on values are swapped
function handleSwap (emitter, fn) {
  return function (newData, oldData, keyPath) {
    var newStructure = fn.apply(fn, arguments);
    if(newData === oldData) return newStructure;

    emitter.emit('swap', newStructure, oldData, keyPath);
    possiblyEmitAnimationFrameEvent(emitter, newStructure, oldData, keyPath);

    return newStructure;
  };
}

// Map changes to update events (delete/change/add).
function handlePersisting (emitter, fn) {
  return function (newData, oldData, path) {
    var newStructure = fn.apply(fn, arguments);
    if(newData === oldData) return newStructure;
    var info = analyze(newData, oldData, path);

    if (info.eventName) {
      emitter.emit.apply(emitter, [info.eventName].concat(info.args));
    }
    return newStructure;
  };
}

/************************************
 * Private helpers.
 ***********************************/

function removeAllListenersBut(self, pathId, listeners, except) {
  if (!listeners) return;
  listeners.forEach(function (fn) {
    if (except && fn === except) return;
    var index = self._pathListeners[pathId].indexOf(fn);
    self._pathListeners[pathId].splice(index, 1);
  });
}

function analyze (newData, oldData, path) {
  var oldObject = oldData && oldData.getIn(path);
  var newObject = newData && newData.getIn(path);

  var inOld = oldData && hasIn(oldData, path);
  var inNew = newData && hasIn(newData, path);

  var args, eventName;

  if (inOld && !inNew) {
    eventName = 'delete';
    args = [path, oldObject];
  } else if (inOld && inNew) {
    eventName = 'change';
    args = [path, newObject, oldObject];
  } else if (!inOld && inNew) {
    eventName = 'add';
    args = [path, newObject];
  }

  return {
    eventName: eventName,
    args: args
  };
}


// Check if path exists.
var NOT_SET = {};
function hasIn(cursor, path) {
  if(cursor.hasIn) return cursor.hasIn(path);
  return cursor.getIn(path, NOT_SET) !== NOT_SET;
}

function pathString(path) {
  var topLevel = 'global';
  if (!path || !path.length) return topLevel;
  return [topLevel].concat(path).join('|');
}

function listListenerMatching (listeners, basePath) {
  var newListeners = [];
  for (var key in listeners) {
    if (!listeners.hasOwnProperty(key)) continue;
    if (basePath.indexOf(key) !== 0) continue;
    newListeners.push(listeners[key]);
  }

  return newListeners;
}

function onlyOnEvent(eventName, fn) {
  return function (newData, oldData, keyPath) {
    var info = analyze(newData, oldData, keyPath);
    if (info.eventName !== eventName) return;
    return fn(newData, oldData, keyPath);
  };
}

function isCursor (potential) {
  return potential && typeof potential.deref === 'function';
}

// Check if passed structure is existing immutable structure.
// From https://github.com/facebook/immutable-js/wiki/Upgrading-to-Immutable-v3#additional-changes
function isImmutableStructure (data) {
  return immutableSafeCheck('Iterable', 'isIterable', data) ||
          immutableSafeCheck('Seq', 'isSeq', data) ||
          immutableSafeCheck('Map', 'isMap', data) ||
          immutableSafeCheck('OrderedMap', 'isOrderedMap', data) ||
          immutableSafeCheck('List', 'isList', data) ||
          immutableSafeCheck('Stack', 'isStack', data) ||
          immutableSafeCheck('Set', 'isSet', data);
}

function immutableSafeCheck (ns, method, data) {
  return Immutable[ns] && Immutable[ns][method] && Immutable[ns][method](data);
}