as-model 0.0.1

package/dist/index.js

@@ -0,0 +1,1025 @@
+"use strict";
+(() => {
+  // node_modules/@swc/helpers/esm/_define_property.js
+  function _define_property(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else obj[key] = value;
+    return obj;
+  }
+
+  // node_modules/@swc/helpers/esm/_object_spread.js
+  function _object_spread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i] != null ? arguments[i] : {};
+      var ownKeys2 = Object.keys(source);
+      if (typeof Object.getOwnPropertySymbols === "function") {
+        ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+      }
+      ownKeys2.forEach(function(key) {
+        _define_property(target, key, source[key]);
+      });
+    }
+    return target;
+  }
+
+  // node_modules/@swc/helpers/esm/_object_spread_props.js
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      if (enumerableOnly) {
+        symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+      }
+      keys.push.apply(keys, symbols);
+    }
+    return keys;
+  }
+  function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+    return target;
+  }
+
+  // node_modules/@swc/helpers/esm/_type_of.js
+  function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+  }
+
+  // src/validation/index.ts
+  var noStateAModelKey = "no-state-a-model-key";
+  function createNoStateModel() {
+    return function noStateModel(state) {
+      return _define_property({}, noStateAModelKey, true);
+    };
+  }
+  function isInstanceFromNoStateModel(instance) {
+    if (instance == null) {
+      return false;
+    }
+    if ((typeof instance === "undefined" ? "undefined" : _type_of(instance)) !== "object") {
+      return false;
+    }
+    var ins = instance;
+    return !!ins[noStateAModelKey];
+  }
+  var validations = {
+    isInstanceFromNoStateModel
+  };
+
+  // node_modules/@swc/helpers/esm/_array_like_to_array.js
+  function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+
+  // node_modules/@swc/helpers/esm/_array_without_holes.js
+  function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+  }
+
+  // node_modules/@swc/helpers/esm/_iterable_to_array.js
+  function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+      return Array.from(iter);
+    }
+  }
+
+  // node_modules/@swc/helpers/esm/_non_iterable_spread.js
+  function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  // node_modules/@swc/helpers/esm/_unsupported_iterable_to_array.js
+  function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+  }
+
+  // node_modules/@swc/helpers/esm/_to_consumable_array.js
+  function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+  }
+
+  // src/updater/notifier.ts
+  function defaultNotifyImplement(dispatches, action) {
+    dispatches.forEach(function(callback) {
+      callback(action);
+    });
+  }
+  function generateNotifier(updater) {
+    function pendAction(value) {
+      updater.mutate(function(u) {
+        var dispatching = u.dispatching;
+        if (!dispatching) {
+          var wrap = {
+            value
+          };
+          wrap.tail = wrap;
+          return _object_spread_props(_object_spread({}, u), {
+            dispatching: wrap
+          });
+        }
+        var tail = dispatching.tail;
+        if (!tail) {
+          return u;
+        }
+        var current = {
+          prev: tail,
+          value
+        };
+        tail.next = current;
+        dispatching.tail = current;
+        return _object_spread_props(_object_spread({}, u), {
+          dispatching
+        });
+      });
+    }
+    function unshiftAction() {
+      return updater.mutate(function(u) {
+        var dispatching = updater.dispatching;
+        if (!dispatching) {
+          return u;
+        }
+        var next = dispatching.next, tail = dispatching.tail;
+        if (tail === dispatching || !next) {
+          dispatching.tail = void 0;
+          return _object_spread_props(_object_spread({}, u), {
+            dispatching: void 0
+          });
+        }
+        next.prev = void 0;
+        var newFirst = next;
+        newFirst.tail = tail;
+        return _object_spread_props(_object_spread({}, u), {
+          dispatching: newFirst
+        });
+      }).dispatching;
+    }
+    function consumeTemporaries() {
+      var temporaryDispatches = updater.temporaryDispatches;
+      updater.mutate(function(u) {
+        return u.temporaryDispatches.length ? _object_spread_props(_object_spread({}, u), {
+          dispatches: _to_consumable_array(u.dispatches).concat(_to_consumable_array(u.temporaryDispatches)),
+          temporaryDispatches: []
+        }) : u;
+      });
+      var initializedAction = {
+        state: updater.state,
+        prevState: updater.state,
+        instance: updater.instance,
+        prevInstance: updater.instance,
+        type: null,
+        method: null
+      };
+      temporaryDispatches.forEach(function(call) {
+        call(initializedAction);
+      });
+    }
+    var config2 = updater.config;
+    return function notify(action) {
+      if (action == null) {
+        return;
+      }
+      var dispatching = updater.dispatching;
+      pendAction(action);
+      if (dispatching) {
+        return;
+      }
+      while (updater.dispatching) {
+        var wrap = updater.dispatching;
+        if (wrap) {
+          var dispatches = updater.dispatches;
+          var dispatchCallbacks = _to_consumable_array(dispatches);
+          try {
+            if (typeof config2.batchNotify === "function" && dispatchCallbacks.length) {
+              config2.batchNotify(dispatchCallbacks, wrap.value);
+            } else {
+              defaultNotifyImplement(dispatchCallbacks, wrap.value);
+            }
+          } catch (e) {
+            updater.mutate(function(u) {
+              return _object_spread_props(_object_spread({}, u), {
+                dispatching: void 0
+              });
+            });
+            throw e;
+          }
+          unshiftAction();
+        } else {
+          updater.mutate(function(u) {
+            return _object_spread_props(_object_spread({}, u), {
+              dispatching: void 0
+            });
+          });
+        }
+      }
+      consumeTemporaries();
+    };
+  }
+
+  // src/tools.ts
+  function getDescriptors(target, receiver, ownOrPrototype, handler) {
+    var it = Object.keys(ownOrPrototype);
+    var result = {};
+    it.forEach(function(key) {
+      result[key] = {
+        get: function() {
+          if (!handler.get) {
+            return target[key];
+          }
+          return handler.get(target, key, receiver);
+        },
+        set: function(v) {
+          if (!handler.set) {
+            target[key] = v;
+            return;
+          }
+          var valid = handler.set(target, key, v, receiver);
+          if (!valid) {
+            throw new Error("".concat(key, " in proxy target is not mutable"));
+          }
+        }
+      };
+    });
+    return result;
+  }
+  var createSimpleProxy = function(target, handler) {
+    var proxy = {};
+    var own = getDescriptors(target, proxy, target, handler);
+    var prototype = getDescriptors(target, proxy, Object.getPrototypeOf(target), handler);
+    Object.defineProperties(proxy, _object_spread({}, prototype, own));
+    return proxy;
+  };
+  var createProxy = function(target, handler) {
+    if (typeof Proxy !== "function") {
+      return createSimpleProxy(target, handler);
+    }
+    return new Proxy(target, handler);
+  };
+  function isObject(data) {
+    return data && (typeof data === "undefined" ? "undefined" : _type_of(data)) === "object";
+  }
+  function shallowEqual(prev, current) {
+    if (Object.is(prev, current)) {
+      return true;
+    }
+    if (!isObject(prev) || !isObject(current)) {
+      return false;
+    }
+    var prevKeys = Object.keys(prev);
+    var currentKeys = Object.keys(current);
+    if (prevKeys.length !== currentKeys.length) {
+      return false;
+    }
+    var pre = prev;
+    var curr = current;
+    var hasDiffKey = prevKeys.some(function(key) {
+      return !Object.prototype.hasOwnProperty.call(curr, key);
+    });
+    if (hasDiffKey) {
+      return false;
+    }
+    var hasDiffValue = currentKeys.some(function(key) {
+      var currentValue = curr[key];
+      var prevValue = pre[key];
+      return !Object.is(currentValue, prevValue);
+    });
+    return !hasDiffValue;
+  }
+  function noop() {
+  }
+
+  // src/updater/tunnel.ts
+  function createUnInitializedUpdater() {
+    return {
+      notify: function(a) {
+      },
+      createTunnel: function(dispatcher) {
+        return {
+          connect: noop,
+          disconnect: noop
+        };
+      }
+    };
+  }
+  function destroy(updater) {
+    function destroyDispatching() {
+      updater.mutate(function(u) {
+        var dispatching = u.dispatching;
+        if (!dispatching) {
+          return u;
+        }
+        var wrapper = dispatching;
+        while (wrapper) {
+          var next = wrapper.next;
+          wrapper.next = void 0;
+          wrapper.prev = void 0;
+          if (next) {
+            next.prev = void 0;
+          }
+          wrapper = next;
+        }
+        dispatching.tail = void 0;
+        return _object_spread_props(_object_spread({}, u), {
+          dispatching: void 0,
+          initialized: false
+        });
+      });
+    }
+    updater.mutate(function(u, effect) {
+      var destroyed = createUnInitializedUpdater();
+      effect(function() {
+        destroyDispatching();
+      });
+      return _object_spread_props(_object_spread({}, u, destroyed), {
+        sidePayload: void 0,
+        isDestroyed: true
+      });
+    });
+  }
+  function generateTunnelCreator(updater) {
+    function subscribe(dispatchFn) {
+      var dispatches = updater.dispatches, temporaryDispatches = updater.temporaryDispatches, isControlled = updater.controlled;
+      var copied = _to_consumable_array(dispatches).concat(_to_consumable_array(temporaryDispatches));
+      var exist = copied.indexOf(dispatchFn) >= 0;
+      if (exist) {
+        return updater.mutate(function(u) {
+          return _object_spread_props(_object_spread({}, u), {
+            isDestroyed: false
+          });
+        });
+      }
+      if (isControlled) {
+        return updater.mutate(function(u) {
+          return _object_spread_props(_object_spread({}, u), {
+            dispatches: [
+              dispatchFn
+            ],
+            isDestroyed: false
+          });
+        });
+      }
+      return updater.mutate(function(u, effect) {
+        var tds = u.temporaryDispatches, ds = u.dispatches;
+        var nextTds = _to_consumable_array(tds).concat([
+          dispatchFn
+        ]);
+        if (u.dispatching) {
+          return _object_spread_props(_object_spread({}, u), {
+            temporaryDispatches: nextTds,
+            isDestroyed: false
+          });
+        }
+        effect(function(up) {
+          var initializedAction = {
+            state: up.state,
+            prevState: up.state,
+            instance: up.instance,
+            prevInstance: up.instance,
+            type: null,
+            method: null
+          };
+          nextTds.forEach(function(td) {
+            td(initializedAction);
+          });
+        });
+        return _object_spread_props(_object_spread({}, u), {
+          temporaryDispatches: [],
+          dispatches: _to_consumable_array(ds).concat(_to_consumable_array(nextTds)),
+          isDestroyed: false
+        });
+      });
+    }
+    return function tunnel(dispatcher) {
+      function disconnect() {
+        updater.mutate(function(u) {
+          var ds = u.dispatches, tds = u.temporaryDispatches;
+          var nextDs = ds.filter(function(d) {
+            return d !== dispatcher;
+          });
+          var nextTds = tds.filter(function(d) {
+            return d !== dispatcher;
+          });
+          if (ds.length === nextDs.length && tds.length === nextTds.length) {
+            return u;
+          }
+          return _object_spread_props(_object_spread({}, u), {
+            dispatches: nextDs,
+            temporaryDispatches: nextTds
+          });
+        });
+      }
+      return {
+        connect: function connect() {
+          subscribe(dispatcher);
+        },
+        disconnect: function disconnect1() {
+          disconnect();
+        }
+      };
+    };
+  }
+
+  // src/updater/index.ts
+  function createInitializedUpdater(updater) {
+    var createTunnel = generateTunnelCreator(updater);
+    return {
+      notify: generateNotifier(updater),
+      createTunnel
+    };
+  }
+  function createUpdateFn(updater) {
+    return function update() {
+      var args = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      updater.mutate(function(u, effect) {
+        var _args_model;
+        var model2 = (_args_model = args.model) !== null && _args_model !== void 0 ? _args_model : u.model;
+        var initialState = "initialState" in args ? args.initialState : u.state;
+        var state = "state" in args ? args.state : u.state;
+        if (u.controlled) {
+          var instance = model2(state);
+          return _object_spread_props(_object_spread({}, u), {
+            state,
+            instance,
+            model: model2
+          });
+        }
+        if (u.isDestroyed) {
+          return u;
+        }
+        if (!u.initialized && !("initialState" in args)) {
+          throw new Error("Should update initialState first.");
+        }
+        if (!u.initialized) {
+          var instance1 = model2(initialState);
+          var initializedUpdater = createInitializedUpdater(u);
+          return _object_spread(_object_spread_props(_object_spread({}, u), {
+            model: model2,
+            state: initialState,
+            instance: instance1,
+            initialized: true
+          }), initializedUpdater);
+        }
+        if (Object.is(u.model, model2) && Object.is(u.state, state)) {
+          return u;
+        }
+        var instance2 = model2(state);
+        effect(function(up) {
+          up.notify({
+            type: null,
+            method: null,
+            prevInstance: u.instance,
+            instance: instance2,
+            prevState: u.state,
+            state
+          });
+        });
+        return _object_spread_props(_object_spread({}, u), {
+          state,
+          model: model2,
+          instance: instance2,
+          initialized: true
+        });
+      });
+    };
+  }
+  var lazyModel = createNoStateModel();
+  function createUpdater(model2) {
+    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var hasDefaultState = "state" in config2;
+    var controlled = config2.controlled, defaultState = config2.state;
+    var defaultInstance = hasDefaultState ? model2(defaultState) : lazyModel(void 0);
+    var unInitializedUpdater = createUnInitializedUpdater();
+    var updater = _object_spread({
+      sidePayload: void 0,
+      version: 0,
+      isDestroyed: false,
+      model: model2,
+      instance: defaultInstance,
+      dispatch: null,
+      dispatches: [],
+      temporaryDispatches: [],
+      cacheMethods: {},
+      cacheFields: {},
+      state: defaultState,
+      initialized: hasDefaultState,
+      controlled: !!controlled,
+      isSubscribing: false,
+      config: config2,
+      payload: function payload(setter) {
+        if (typeof setter === "function") {
+          updater.sidePayload = setter(updater.sidePayload);
+        }
+        return updater.sidePayload;
+      },
+      mutate: function mutate(callback) {
+        var effects = [];
+        var runEffects = function runEffects2(u) {
+          effects.forEach(function(e) {
+            return e(u);
+          });
+        };
+        var result = callback(updater, function(effectFn) {
+          return effects.push(effectFn);
+        });
+        if (updater === result) {
+          runEffects(result);
+          return updater;
+        }
+        Object.assign(updater, result);
+        runEffects(updater);
+        return updater;
+      },
+      update: function(args) {
+      },
+      destroy: function destroy1() {
+        destroy(updater);
+      }
+    }, unInitializedUpdater);
+    var initialized = createInitializedUpdater(updater);
+    Object.assign(updater, initialized, {
+      update: createUpdateFn(updater)
+    });
+    return updater;
+  }
+
+  // src/store/instance.ts
+  var cacheIdentify = {
+    field: function field(d) {
+      if (!d) {
+        return false;
+      }
+      var f = d;
+      return f.identifier === cacheIdentify.field;
+    },
+    method: function method(d) {
+      if (typeof d !== "function") {
+        return false;
+      }
+      var m = d;
+      return m.identifier === cacheIdentify.method;
+    }
+  };
+  function createField(callback, deps) {
+    var currentDeps = function computeDeps() {
+      if (deps == null) {
+        return deps;
+      }
+      if (deps.some(function(d) {
+        return cacheIdentify.field(d) && d.deps == null;
+      })) {
+        return void 0;
+      }
+      return deps.flatMap(function(d) {
+        if (cacheIdentify.field(d)) {
+          return d.deps;
+        }
+        return d;
+      });
+    }();
+    var value = callback();
+    return {
+      callback,
+      deps: currentDeps,
+      identifier: cacheIdentify.field,
+      value,
+      get: function get() {
+        return value;
+      }
+    };
+  }
+  function createMethod(method2) {
+    var replace = function replace2() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return method2.apply(void 0, _to_consumable_array(args));
+    };
+    Object.assign(replace, method2());
+    replace.identifier = cacheIdentify.method;
+    return replace;
+  }
+  function wrapToActionMethod(updater, methodName) {
+    var cacheMethods = updater.cacheMethods;
+    var cachedMethod = cacheMethods[methodName];
+    if (typeof cachedMethod === "function") {
+      return cachedMethod;
+    }
+    var actionMethod = function actionMethod2() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var instance = updater.instance, isDestroyed = updater.isDestroyed, controlled = updater.controlled, model2 = updater.model;
+      var method2 = instance[methodName];
+      if (typeof method2 !== "function") {
+        throw new Error("Can not change methods in runtime.");
+      }
+      if (cacheIdentify.method(method2)) {
+        return method2.apply(void 0, _to_consumable_array(args));
+      }
+      var state = method2.apply(void 0, _to_consumable_array(args));
+      if (isDestroyed) {
+        return state;
+      }
+      var action = {
+        type: methodName,
+        state,
+        prevState: updater.state,
+        instance: updater.instance,
+        prevInstance: updater.instance,
+        method: actionMethod2
+      };
+      if (controlled) {
+        updater.notify(action);
+        return state;
+      }
+      var prevState = updater.state;
+      var prevInstance = updater.instance;
+      var newestInstance = model2(state);
+      updater.mutate(function(up, effect) {
+        effect(function(u) {
+          u.notify({
+            type: methodName,
+            state,
+            prevState,
+            instance: newestInstance,
+            prevInstance,
+            method: actionMethod2
+          });
+        });
+        return _object_spread_props(_object_spread({}, up), {
+          instance: newestInstance,
+          state,
+          version: up.version + 1
+        });
+      });
+      return state;
+    };
+    cacheMethods[methodName] = actionMethod;
+    return actionMethod;
+  }
+  function wrapToField(updater, propertyName, value, onGot) {
+    var cacheFields = updater.cacheFields;
+    if (!cacheIdentify.field(value)) {
+      if (onGot) {
+        onGot(propertyName, value);
+      }
+      return value;
+    }
+    var field2 = value;
+    var cachedField = cacheFields[propertyName];
+    if (cachedField) {
+      return cachedField.getter;
+    }
+    var getter = {
+      get: function get() {
+        var currentField = updater.instance[propertyName];
+        if (!cacheIdentify.field(currentField)) {
+          throw new Error("Field should always be field.");
+        }
+        var current = currentField.get();
+        var fieldInCache = updater.cacheFields[propertyName];
+        if (!currentField.deps || fieldInCache == null) {
+          cacheFields[propertyName] = {
+            getter,
+            value: current,
+            deps: currentField.deps
+          };
+          return current;
+        }
+        if (shallowEqual(currentField.deps, fieldInCache.deps)) {
+          return fieldInCache.value;
+        }
+        cacheFields[propertyName] = {
+          getter,
+          value: current,
+          deps: currentField.deps
+        };
+        return current;
+      }
+    };
+    cacheFields[propertyName] = {
+      getter,
+      value: field2.value,
+      deps: field2.deps
+    };
+    return getter;
+  }
+  function extractInstance(updater, onGet) {
+    var instance = updater.instance;
+    if ((typeof instance === "undefined" ? "undefined" : _type_of(instance)) !== "object" || !instance) {
+      throw new Error("The instance should be an object or array.");
+    }
+    var properties = Object.getOwnPropertyNames(instance);
+    var handleGetter = function handleGetter2(key, value) {
+      if (!onGet) {
+        return;
+      }
+      onGet(key, value);
+    };
+    return createProxy(instance, {
+      get: function get(target, p, receiver) {
+        var value = target[p];
+        if (typeof value === "function" && properties.indexOf(p) >= 0) {
+          var actionMethod = wrapToActionMethod(updater, p);
+          Object.assign(actionMethod, value);
+          handleGetter(p, actionMethod);
+          return actionMethod;
+        }
+        return wrapToField(updater, p, value, handleGetter);
+      }
+    });
+  }
+
+  // src/store/index.ts
+  function modelKeyIdentifier() {
+    return true;
+  }
+  function isModelKey(data) {
+    if (!data) {
+      return false;
+    }
+    return data.modelKeyIdentifier === modelKeyIdentifier;
+  }
+  function createPrimaryKey(modelFn, defaultState) {
+    var model2 = isModelKey(modelFn) ? modelFn.source : modelFn;
+    var wrapModel = function wrapModel2(state) {
+      return model2(state);
+    };
+    wrapModel.source = model2;
+    wrapModel.modelKeyIdentifier = modelKeyIdentifier;
+    if (arguments.length > 1) {
+      wrapModel.defaultState = defaultState;
+    }
+    return wrapModel;
+  }
+  function createStore(modelLike) {
+    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var model2 = isModelKey(modelLike) ? modelLike.source : modelLike;
+    var modelKey = isModelKey(modelLike) ? modelLike : void 0;
+    var conf = function computeConfig() {
+      var hasConfigState = "state" in config2;
+      var hasKeyState = !!modelKey && "defaultState" in modelKey;
+      if (hasConfigState) {
+        return config2;
+      }
+      if (hasKeyState) {
+        return _object_spread_props(_object_spread({}, config2), {
+          state: modelKey === null || modelKey === void 0 ? void 0 : modelKey.defaultState
+        });
+      }
+      return config2;
+    }();
+    var updater = createUpdater(model2, conf);
+    var store = {
+      key: modelKey !== null && modelKey !== void 0 ? modelKey : "state" in config2 ? createPrimaryKey(model2, config2.state) : createPrimaryKey(model2),
+      subscribe: function subscribe(dispatcher) {
+        var _updater_createTunnel = updater.createTunnel(dispatcher), connect = _updater_createTunnel.connect, disconnect = _updater_createTunnel.disconnect;
+        connect();
+        return disconnect;
+      },
+      getInstance: function getInstance() {
+        return extractInstance(updater);
+      },
+      update: function update(args) {
+        updater.update(args);
+      },
+      destroy: function destroy2() {
+        updater.destroy();
+      },
+      payload: function payload(callback) {
+        return updater.payload(callback);
+      },
+      isDestroyed: function isDestroyed() {
+        return updater.isDestroyed;
+      },
+      updater
+    };
+    return store;
+  }
+  function createSignal(store) {
+    var signalStore = {
+      collection: null,
+      started: false,
+      enabled: false
+    };
+    var middleWare = function(dispatcher) {
+      return function(action) {
+        if (!signalStore.enabled) {
+          dispatcher(action);
+          return;
+        }
+        var collection = signalStore.collection;
+        if (collection == null) {
+          dispatcher(action);
+          return;
+        }
+        var current = extractInstance(store.updater);
+        var keys = Object.keys(collection);
+        var currentCollectionEntries = keys.map(function(key) {
+          var field2 = current[key];
+          if (cacheIdentify.field(field2)) {
+            return [
+              key,
+              field2.get()
+            ];
+          }
+          return [
+            key,
+            field2
+          ];
+        });
+        var currentCollection = Object.fromEntries(currentCollectionEntries);
+        if (!shallowEqual(collection, currentCollection)) {
+          dispatcher(action);
+        }
+      };
+    };
+    return {
+      key: store.key,
+      subscribe: function subscribe(dispatcher) {
+        return store.subscribe(middleWare(dispatcher));
+      },
+      getSignal: function getSignal() {
+        var collectUsedFields = function collectUsedFields2(key, val) {
+          if (!signalStore.started) {
+            return;
+          }
+          signalStore.collection = signalStore.collection || {};
+          signalStore.collection[key] = val;
+        };
+        var signal = function signal2() {
+          return extractInstance(store.updater, collectUsedFields);
+        };
+        signal.startStatistics = function startStatistics() {
+          signalStore.started = true;
+        };
+        signal.stopStatistics = function stopStatistics() {
+          signalStore.started = false;
+        };
+        signal.subscribe = function subscribe(dispatchCallback) {
+          return store.subscribe(dispatchCallback);
+        };
+        signal.payload = function payload(callback) {
+          return store.payload(callback);
+        };
+        signalStore.enabled = true;
+        signalStore.started = true;
+        return signal;
+      }
+    };
+  }
+  var createField2 = createField;
+  var createMethod2 = createMethod;
+
+  // src/key/index.ts
+  function createKey(model2) {
+    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var hasDefaultState = "state" in config2;
+    var wrapModel = hasDefaultState ? createPrimaryKey(model2, config2.state) : createPrimaryKey(model2);
+    wrapModel.createStore = function createKeyStore() {
+      var storeConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      return createStore(wrapModel, _object_spread({}, config2, storeConfig));
+    };
+    return wrapModel;
+  }
+  createKey.isModelKey = isModelKey;
+  function createStores(modelKeys) {
+    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var state = {
+      destroyed: false
+    };
+    var storeUnits = modelKeys.map(function(modelKey) {
+      if (typeof modelKey === "function") {
+        return modelKey.createStore();
+      }
+      var k = modelKey.key;
+      return createStore(k, "defaultState" in k ? _object_spread_props(_object_spread({}, config2), {
+        state: k.defaultState
+      }) : config2);
+    });
+    return {
+      find: function find(key) {
+        var found = storeUnits.find(function(c) {
+          if (typeof key === "function") {
+            return c.key === key;
+          }
+          return c.key === key.key;
+        });
+        if (!found) {
+          return null;
+        }
+        return found;
+      },
+      update: function update() {
+        for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
+          keys[_key] = arguments[_key];
+        }
+        if (state.destroyed) {
+          return;
+        }
+        storeUnits.forEach(function(un, i) {
+          var key = keys[i];
+          if (!key) {
+            return;
+          }
+          Object.assign(un, {
+            key
+          });
+          un.update({
+            model: typeof key === "function" ? key.source : key.key.source
+          });
+        });
+      },
+      destroy: function destroy2() {
+        storeUnits.forEach(function(unit) {
+          unit.destroy();
+        });
+        state.destroyed = true;
+      }
+    };
+  }
+
+  // src/model/index.ts
+  function configModel(config2) {
+    var model2 = function model3(modelFn) {
+      var modelWrapper = function modelWrapper2(state) {
+        return modelFn(state);
+      };
+      modelWrapper.createKey = function createModelKey(state) {
+        return createKey(modelWrapper, arguments.length ? _object_spread_props(_object_spread({}, config2), {
+          state
+        }) : config2);
+      };
+      modelWrapper.createStore = function createModelStore(state) {
+        return createStore(modelWrapper, arguments.length ? _object_spread_props(_object_spread({}, config2), {
+          state
+        }) : config2);
+      };
+      return modelWrapper;
+    };
+    model2.createField = createField2;
+    model2.createMethod = createMethod2;
+    return model2;
+  }
+
+  // src/index.ts
+  function config() {
+    var configuration = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var createStore3 = function createStore4(modelLike, state) {
+      return createStore(modelLike, arguments.length > 1 ? _object_spread_props(_object_spread({}, configuration), {
+        state
+      }) : configuration);
+    };
+    var createKey3 = function createKey4(model3, state) {
+      var isKeySetState = arguments.length > 1;
+      var key = createKey(model3, isKeySetState ? _object_spread_props(_object_spread({}, configuration), {
+        state
+      }) : configuration);
+      key.createStore = function createKeyStore(s) {
+        return arguments.length > 0 ? createStore3(key, s) : createStore3(key);
+      };
+      return key;
+    };
+    createKey3.isModelKey = createKey.isModelKey;
+    var createStores3 = function createStores4() {
+      for (var _len = arguments.length, modelKeys = new Array(_len), _key = 0; _key < _len; _key++) {
+        modelKeys[_key] = arguments[_key];
+      }
+      return createStores(modelKeys, configuration);
+    };
+    var model2 = configModel(configuration);
+    return {
+      createStore: createStore3,
+      createKey: createKey3,
+      createStores: createStores3,
+      model: model2
+    };
+  }
+  var _config = config();
+  var createStore2 = _config.createStore;
+  var createKey2 = _config.createKey;
+  var createStores2 = _config.createStores;
+  var model = _config.model;
+})();