@tacky/store/lib/core/store.js

State management framework based on react

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createStore = createStore;
exports.store = void 0;

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _interfaces = require("../interfaces");

var _error = require("../utils/error");

var _collector = require("./collector");

var _common = require("../utils/common");

var ReactDOM = _interopRequireWildcard(require("react-dom"));

var _config = require("../const/config");

var _domain = require("./domain");

var store;
exports.store = store;

function createStore(enhancer) {
  if (enhancer !== void 0) {
    exports.store = store = enhancer(createStore);
    return store;
  }

  var componentUUIDToListeners = new WeakMap();
  var isUpdating = false;

  function subscribe(listener, uuid) {
    var isSubscribed = true;
    var listeners = componentUUIDToListeners.get(uuid);

    if (listeners === void 0) {
      componentUUIDToListeners.set(uuid, [listener]);
    } else {
      if (!(0, _common.includes)(listeners, listener)) {
        componentUUIDToListeners.set(uuid, listeners.concat(listener));
      }
    }

    return function unsubscribe() {
      if (!isSubscribed) {
        return;
      }

      isSubscribed = false;

      if (componentUUIDToListeners.has(uuid)) {
        componentUUIDToListeners["delete"](uuid);
      }
    };
  }

  var isInBatch = false;
  var dirtyJob;
  var needCreateRestSyncJobTrigger = true;

  function dispatch(action) {
    var name = action.name,
        payload = action.payload,
        type = action.type,
        domain = action.domain,
        original = action.original,
        isAtom = action.isAtom,
        _action$isInner = action.isInner,
        isInner = _action$isInner === void 0 ? false : _action$isInner;
    (0, _error.invariant)(!isUpdating, 'Cannot trigger other mutation while the current mutation is executing.');

    var callback = function callback() {
      if (_collector.historyCollector.waitTriggerComponentIds.length > 0) {
        var ids = (0, _common.deduplicate)(_collector.historyCollector.waitTriggerComponentIds);
        var pendingListeners = [];

        for (var index = 0; index < ids.length; index++) {
          var cid = ids[index];
          var listeners = componentUUIDToListeners.get(cid) || [];
          pendingListeners.push.apply(pendingListeners, (0, _toConsumableArray2["default"])(listeners));
        }

        ReactDOM.unstable_batchedUpdates(function () {
          for (var _index = 0; _index < pendingListeners.length; _index++) {
            var listener = pendingListeners[_index];
            listener();
          }
        });
      }

      isInBatch = false;
      dirtyJob = void 0;

      if (_config.ctx.timeTravel.isActive && (0, _common.includes)(_domain.materialCallStack, _interfaces.EMaterialType.EFFECT)) {
        _collector.historyCollector.endBatch(false);

        return;
      }

      if (_config.ctx.timeTravel.isActive && !isInner) {
        _collector.historyCollector.save();
      }

      _collector.historyCollector.endBatch();
    };

    if (!isInBatch && dirtyJob === void 0) {
      dirtyJob = callback;
    }

    if (isAtom) {
      if (_collector.historyCollector.waitTriggerComponentIds.length > 0) {
        // flush previous job
        dirtyJob && dirtyJob();
      }
    }

    try {
      isUpdating = true;

      if (!isInner && type !== _interfaces.EMaterialType.MUTATION && type !== _interfaces.EMaterialType.UPDATE) {
        return;
      }

      var currentMutation = original;
      currentMutation.apply(void 0, (0, _toConsumableArray2["default"])(payload));
    } finally {
      isUpdating = false;
    }

    if (!isInBatch) {
      isInBatch = true;

      if (isAtom) {
        // immediately execute
        callback();
      }

      if (needCreateRestSyncJobTrigger) {
        (0, _common.nextTick)(function () {
          dirtyJob && dirtyJob();
          needCreateRestSyncJobTrigger = true;
        });
        needCreateRestSyncJobTrigger = false;
      }
    }

    return action;
  }

  return {
    dispatch: dispatch,
    subscribe: subscribe
  };
}