@startupjs/react-sharedb/lib/patchRacer.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

exports.default = dummyNoTreeShaking;

var _racer = require('racer');

var _racer2 = _interopRequireDefault(_racer);

var _LocalDoc = require('racer/lib/Model/LocalDoc');

var _LocalDoc2 = _interopRequireDefault(_LocalDoc);

var _RemoteDoc = require('racer/lib/Model/RemoteDoc');

var _RemoteDoc2 = _interopRequireDefault(_RemoteDoc);

var _util = require('racer/lib/util');

var _util2 = _interopRequireDefault(_util);

var _Query = require('racer/lib/Model/Query');

var _Query2 = _interopRequireDefault(_Query);

var _doc = require('sharedb/lib/client/doc');

var _doc2 = _interopRequireDefault(_doc);

var _observerUtil = require('@nx-js/observer-util');

var _batching = require('../batching');

var _batching2 = _interopRequireDefault(_batching);

var _semaphore = require('./semaphore');

var _semaphore2 = _interopRequireDefault(_semaphore);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var STORE = 'store';
var $STORE = '$' + STORE;
var DEFAULT_COLLECTION = '$components';

var BATCH_SETTERS = ['_mutate', '_setEach', '_setDiff', '_setDiffDeep'];
var WARNING_SETTERS = ['_set', '_setDiff', '_setNull', '_del'];

// Export a dummy function to prevent tree shaking from getting rid of this module
function dummyNoTreeShaking() {}

// ----------------------------------------------
//   Monkey patches of ShareDB and Racer
// ----------------------------------------------

// Patch applying sharedb operations to prevent extra rerender from triggering
var oldHandleOp = _doc2.default.prototype._handleOp;
_doc2.default.prototype._handleOp = function () {
  var _this = this,
      _arguments = arguments;

  var value = void 0;
  _batching2.default.batch(function () {
    value = oldHandleOp.apply(_this, _arguments);
  });
  return value;
};

// Patch racer setters to batch them from extra rerenders
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;

try {
  var _loop = function _loop() {
    var methodName = _step.value;

    var oldMethod = _racer2.default.Model.prototype[methodName];
    _racer2.default.Model.prototype[methodName] = function () {
      var _this2 = this,
          _arguments2 = arguments;

      var value = void 0;
      _batching2.default.batch(function () {
        value = oldMethod.apply(_this2, _arguments2);
      });
      return value;
    };
  };

  for (var _iterator = (0, _getIterator3.default)(BATCH_SETTERS), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
    _loop();
  }

  // Warn when trying to set the full document instead of doing setEach
} catch (err) {
  _didIteratorError = true;
  _iteratorError = err;
} finally {
  try {
    if (!_iteratorNormalCompletion && _iterator.return) {
      _iterator.return();
    }
  } finally {
    if (_didIteratorError) {
      throw _iteratorError;
    }
  }
}

var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;

try {
  var _loop2 = function _loop2() {
    var methodName = _step2.value;

    var oldMethod = _racer2.default.Model.prototype[methodName];
    _racer2.default.Model.prototype[methodName] = function (segments) {
      if (segments.length === 2 && segments[0] === DEFAULT_COLLECTION && !_semaphore2.default.allowComponentSetter) {
        throw new Error('You can\'t use \'' + methodName.replace(/^_/, '') + '\' on component\'s ' + ($STORE + ' root path. Use \'setEach\' instead.'));
      }
      return oldMethod.apply(this, arguments);
    };
  };

  for (var _iterator2 = (0, _getIterator3.default)(WARNING_SETTERS), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
    _loop2();
  }

  // Monkey patch racer's local documents to be observable
} catch (err) {
  _didIteratorError2 = true;
  _iteratorError2 = err;
} finally {
  try {
    if (!_iteratorNormalCompletion2 && _iterator2.return) {
      _iterator2.return();
    }
  } finally {
    if (_didIteratorError2) {
      throw _iteratorError2;
    }
  }
}

var oldUpdateCollectionData = _LocalDoc2.default.prototype._updateCollectionData;
_LocalDoc2.default.prototype._updateCollectionData = function () {
  // Only objects and arrays can be made observable (both are typeof 'object')
  if (this.data && (0, _typeof3.default)(this.data) === 'object') {
    this.data = (0, _observerUtil.observable)(this.data);
  }
  if (!_semaphore2.default.ignoreCollectionObservableWarning && !(0, _observerUtil.isObservable)(this.collectionData) && this.collectionName !== '$connection') {
    console.warn('[react-sharedb] Local collection "' + this.collectionName + '" is not initialized to be observable. ' + ('Run require("react-sharedb").initLocalCollection("' + this.collectionName + '") before using it anywhere. ') + ('You must also do it right after cleaning it up with model.silent().destroy("' + this.collectionName + '")'));
  }
  return oldUpdateCollectionData.apply(this, arguments);
};

// Monkey patch racer remote doc to make document observable when it's created locally
var oldRemoteDocUpdateCollectionData = _RemoteDoc2.default.prototype._updateCollectionData;
_RemoteDoc2.default.prototype._updateCollectionData = function () {
  if (this.shareDoc.data) this.shareDoc.data = (0, _observerUtil.observable)(this.shareDoc.data);
  return oldRemoteDocUpdateCollectionData.apply(this, arguments);
};

// Add additional `sync` variant of fetch, which will sync return data if it already exists in cache
_racer2.default.Model.prototype.fetchSync = function () {
  var _resolve;
  var promise = new _promise2.default(function (resolve) {
    _resolve = resolve;
  });
  this._forSubscribable(arguments, 'fetch', _resolve, promise);
  return promise;
};

// Add additional `sync` variant of subscribe, which will sync return data if it already exists in cache
_racer2.default.Model.prototype.subscribeSync = function () {
  var _resolve;
  var promise = new _promise2.default(function (resolve) {
    _resolve = resolve;
  });
  this._forSubscribable(arguments, 'subscribe', _resolve, promise);
  return promise;
};

// resolve is used for SYNC mode.
// In this mode the subscribeSync function returns a promise
// which is gonna be either:
//   - resolved, if we are already subscribed to all data (it's in racer model)
//   - pending, if at least one subscription needs to be executed
_racer2.default.Model.prototype._forSubscribable = function (argumentsObject, method, resolve, promise) {
  var args, cb;
  if (!argumentsObject.length) {
    // Use this model's scope if no arguments
    args = [null];
  } else if (typeof argumentsObject[0] === 'function') {
    // Use this model's scope if the first argument is a callback
    args = [null];
    cb = argumentsObject[0];
  } else if (Array.isArray(argumentsObject[0])) {
    // Items can be passed in as an array
    args = argumentsObject[0];
    cb = argumentsObject[1];
  } else {
    // Or as multiple arguments
    args = Array.prototype.slice.call(argumentsObject);
    var last = args[args.length - 1];
    if (typeof last === 'function') cb = args.pop();
  }

  // [SYNC MODE] For sync usage of subscribe
  if (resolve) {
    cb = function cb() {
      promise.sync = true;
      resolve();
    };
  }

  var group = _util2.default.asyncGroup(this.wrapCallback(cb));
  var finished = group();
  var docMethod = method + 'Doc';

  this.root.connection.startBulk();
  for (var i = 0; i < args.length; i++) {
    var item = args[i];
    if (item instanceof _Query2.default) {
      item[method](group());
    } else {
      var segments = this._dereference(this._splitPath(item));
      if (segments.length === 2) {
        // Do the appropriate method for a single document.
        this[docMethod](segments[0], segments[1], group());
      } else {
        var message = 'Cannot ' + method + ' to path: ' + segments.join('.');
        group()(new Error(message));
      }
    }
  }
  this.root.connection.endBulk();

  // [SYNC MODE] Don't force async execution if we are in sync mode
  if (resolve) return finished();

  process.nextTick(finished);
};

// Monkey patch query subscribe to return data synchronously if it's in cache
_Query2.default.prototype.subscribe = function (cb) {
  cb = this.model.wrapCallback(cb);
  this.model._context.subscribeQuery(this);

  if (this.subscribeCount++) {
    var query = this;
    // Synchronously return data if it's already in cache
    // process.nextTick(function() {
    var data = query.model._get(query.segments);
    if (data) {
      cb();
    } else {
      query._pendingSubscribeCallbacks.push(cb);
    }
    // })
    return this;
  }

  if (!this.created) this.create();

  var options = this.options ? _util2.default.copy(this.options) : {};
  options.results = this._getShareResults();

  // When doing server-side rendering, we actually do a fetch the first time
  // that subscribe is called, but keep track of the state as if subscribe
  // were called for proper initialization in the client
  if (this.model.root.fetchOnly) {
    this._shareFetchedSubscribe(options, cb);
  } else {
    this._shareSubscribe(options, cb);
  }

  return this;
};
module.exports = exports['default'];