as-model 0.1.0 → 0.1.1

package/dist/index.js

@@ -55,33 +55,6 @@
     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;
@@ -121,13 +94,60 @@
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
   }
 
+  // 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/identifiers/index.ts
+  function modelKeyIdentifier() {
+    return true;
+  }
+  function modelUsageIdentifier() {
+    return true;
+  }
+
+  // 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
+  };
+  function isModelKey(data) {
+    if (!data) {
+      return false;
+    }
+    return data.modelKeyIdentifier === modelKeyIdentifier && data.modelKeyIdentifier();
+  }
+  function isModelUsage(data) {
+    if (!data) {
+      return false;
+    }
+    return data.modelUsageIdentifier === modelUsageIdentifier && data.modelUsageIdentifier();
+  }
+
   // src/updater/notifier.ts
   function defaultNotifyImplement(dispatches, action) {
     dispatches.forEach(function(callback) {
       callback(action);
     });
   }
-  function generateNotifier(updater) {
+  function generateNotifier(updater, middleWare) {
     function pendAction(value) {
       updater.mutate(function(u) {
         var dispatching = u.dispatching;
@@ -196,9 +216,37 @@
         call(initializedAction);
       });
     }
-    var config2 = updater.config;
+    var config2 = updater.config, model2 = updater.model;
+    var dispatch = function dispatch2(action) {
+      var dispatches = updater.dispatches, controlled = updater.controlled;
+      var dispatchCallbacks = _to_consumable_array(dispatches);
+      var state = action.state;
+      if (!controlled) {
+        updater.mutate(function(u) {
+          return _object_spread_props(_object_spread({}, u), {
+            state,
+            instance: model2(state),
+            version: u.version + 1
+          });
+        });
+      }
+      try {
+        if (typeof config2.batchNotify === "function") {
+          config2.batchNotify(dispatchCallbacks, action);
+        } else {
+          defaultNotifyImplement(dispatchCallbacks, action);
+        }
+      } catch (e) {
+        updater.mutate(function(u) {
+          return _object_spread_props(_object_spread({}, u), {
+            dispatching: void 0
+          });
+        });
+        throw e;
+      }
+    };
     return function notify(action) {
-      if (action == null) {
+      if (action == null || updater.isDestroyed) {
         return;
       }
       var dispatching = updater.dispatching;
@@ -209,22 +257,15 @@
       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;
-          }
+          middleWare({
+            getState: function getState() {
+              return {
+                state: updater.state,
+                instance: updater.instance
+              };
+            },
+            dispatch: notify
+          })(dispatch)(wrap.value);
           unshiftAction();
         } else {
           updater.mutate(function(u) {
@@ -238,7 +279,7 @@
     };
   }
 
-  // src/tools.ts
+  // src/tools/proxy.ts
   function getDescriptors(target, receiver, ownOrPrototype, handler) {
     var it = Object.keys(ownOrPrototype);
     var result = {};
@@ -277,6 +318,8 @@
     }
     return new Proxy(target, handler);
   };
+
+  // src/tools/shallowEqual.ts
   function isObject(data) {
     return data && (typeof data === "undefined" ? "undefined" : _type_of(data)) === "object";
   }
@@ -307,6 +350,8 @@
     });
     return !hasDiffValue;
   }
+
+  // src/tools/index.ts
   function noop() {
   }
 
@@ -442,14 +487,14 @@
   }
 
   // src/updater/index.ts
-  function createInitializedUpdater(updater) {
+  function createInitializedUpdater(updater, middleWare) {
     var createTunnel = generateTunnelCreator(updater);
     return {
-      notify: generateNotifier(updater),
+      notify: generateNotifier(updater, middleWare),
       createTunnel
     };
   }
-  function createUpdateFn(updater) {
+  function createUpdateFn(updater, middleWare) {
     return function update() {
       var args = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
       updater.mutate(function(u, effect) {
@@ -473,7 +518,7 @@
         }
         if (!u.initialized) {
           var instance1 = model2(initialState);
-          var initializedUpdater = createInitializedUpdater(u);
+          var initializedUpdater = createInitializedUpdater(u, middleWare);
           return _object_spread(_object_spread_props(_object_spread({}, u), {
             model: model2,
             state: initialState,
@@ -505,8 +550,8 @@
     };
   }
   var lazyModel = createNoStateModel();
-  function createUpdater(model2) {
-    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  function createUpdater(model2, middleWare) {
+    var config2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
     var hasDefaultState = "state" in config2;
     var controlled = config2.controlled, defaultState = config2.state;
     var defaultInstance = hasDefaultState ? model2(defaultState) : lazyModel(void 0);
@@ -557,9 +602,9 @@
         destroy(updater);
       }
     }, unInitializedUpdater);
-    var initialized = createInitializedUpdater(updater);
+    var initialized = createInitializedUpdater(updater, middleWare);
     Object.assign(updater, initialized, {
-      update: createUpdateFn(updater)
+      update: createUpdateFn(updater, middleWare)
     });
     return updater;
   }
@@ -630,7 +675,7 @@
       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 instance = updater.instance, model2 = updater.model;
       var method2 = instance[methodName];
       if (typeof method2 !== "function") {
         throw new Error("Can not change methods in runtime.");
@@ -639,9 +684,6 @@
         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,
@@ -650,30 +692,7 @@
         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
-        });
-      });
+      updater.notify(action);
       return state;
     };
     cacheMethods[methodName] = actionMethod;
@@ -755,87 +774,22 @@
     });
   }
 
-  // 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;
-  }
+  // src/store/enhance/signal.ts
   function createSignal(store) {
     var signalStore = {
       collection: null,
       started: false,
       enabled: false
     };
-    var middleWare = function(dispatcher) {
+    var enhance = function(dispatcher) {
       return function(action) {
         if (!signalStore.enabled) {
-          dispatcher(action);
+          dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
           return;
         }
         var collection = signalStore.collection;
         if (collection == null) {
-          dispatcher(action);
+          dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
           return;
         }
         var current = extractInstance(store.updater);
@@ -855,14 +809,15 @@
         });
         var currentCollection = Object.fromEntries(currentCollectionEntries);
         if (!shallowEqual(collection, currentCollection)) {
-          dispatcher(action);
+          dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
         }
       };
     };
+    var storeKey = store.key;
     return {
-      key: store.key,
+      key: storeKey,
       subscribe: function subscribe(dispatcher) {
-        return store.subscribe(middleWare(dispatcher));
+        return store.subscribe(enhance(dispatcher));
       },
       getSignal: function getSignal() {
         var collectUsedFields = function collectUsedFields2(key, val) {
@@ -872,9 +827,12 @@
           signalStore.collection = signalStore.collection || {};
           signalStore.collection[key] = val;
         };
-        var signal = function signal2() {
+        var getInstance = function getInstance2() {
           return extractInstance(store.updater, collectUsedFields);
         };
+        var signal = function signal2() {
+          return getInstance();
+        };
         signal.startStatistics = function startStatistics() {
           signalStore.started = true;
         };
@@ -893,14 +851,259 @@
       }
     };
   }
+
+  // src/store/enhance/selector.ts
+  function wrapToField2(cache, propertyName, value, onGot) {
+    var cacheFields = cache.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 = cache.target[propertyName];
+        if (!cacheIdentify.field(currentField)) {
+          throw new Error("Field should always be field.");
+        }
+        var current = currentField.get();
+        var fieldInCache = cache.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 wrapToActionMethod2(cache, methodName) {
+    var cacheMethods = cache.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 target = cache.target;
+      var method2 = target[methodName];
+      if (typeof method2 !== "function") {
+        throw new Error("Can not change methods in runtime.");
+      }
+      return method2.apply(void 0, _to_consumable_array(args));
+    };
+    cacheMethods[methodName] = actionMethod;
+    return actionMethod;
+  }
+  var cacheProperties = function(cache, onGet) {
+    return function createCachePropertiesProxy() {
+      var instance = cache.target;
+      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) {
+          var value = target[p];
+          if (typeof value === "function" && properties.indexOf(p) >= 0) {
+            var actionMethod = wrapToActionMethod2(cache, p);
+            Object.assign(actionMethod, value);
+            handleGetter(p, actionMethod);
+            return actionMethod;
+          }
+          return wrapToField2(cache, p, value, handleGetter);
+        },
+        set: function set() {
+          return false;
+        }
+      });
+    };
+  };
+  function createSelector(store, opts) {
+    var equality = (opts !== null && opts !== void 0 ? opts : {}).equality;
+    var selectStore = {
+      selectedInstance: store.getInstance()
+    };
+    var cache = {
+      equality,
+      setSelect: function setSelect(selector) {
+        cache.selector = selector;
+        if (!selector) {
+          return;
+        }
+        var currentSelectedInstance = selectStore.selectedInstance;
+        var nextSelectedInstance = selector(store.getInstance);
+        if (currentSelectedInstance === nextSelectedInstance || equality && equality(currentSelectedInstance, nextSelectedInstance)) {
+          return;
+        }
+        selectStore.selectedInstance = nextSelectedInstance;
+      }
+    };
+    var propertiesCache = {
+      target: store.getInstance(),
+      cacheFields: {},
+      cacheMethods: {}
+    };
+    var generateSelectedInstance = function generateSelectedInstance2(getInstance) {
+      var storeKey = store.key;
+      if (cache.selector) {
+        return cache.selector(getInstance);
+      }
+      if (!(storeKey === null || storeKey === void 0 ? void 0 : storeKey.selector)) {
+        return getInstance();
+      }
+      var result = storeKey === null || storeKey === void 0 ? void 0 : storeKey.selector(getInstance);
+      if (result == null || (typeof result === "undefined" ? "undefined" : _type_of(result)) !== "object") {
+        throw new Error("The default selector result should be an object or array");
+      }
+      propertiesCache.target = result;
+      return cacheProperties(propertiesCache)();
+    };
+    selectStore.selectedInstance = generateSelectedInstance(store.getInstance);
+    var enhance = function(dispatcher) {
+      return function(action) {
+        var currentSelectedInstance = selectStore.selectedInstance;
+        var nextSelectedInstance = generateSelectedInstance(store.getInstance);
+        if (currentSelectedInstance === nextSelectedInstance || cache.equality && cache.equality(currentSelectedInstance, nextSelectedInstance)) {
+          return;
+        }
+        selectStore.selectedInstance = nextSelectedInstance;
+        if (dispatcher == null) {
+          return;
+        }
+        dispatcher(action);
+      };
+    };
+    function select(selector) {
+      cache.setSelect(selector);
+      return selectStore.selectedInstance;
+    }
+    return {
+      key: store.key,
+      subscribe: function subscribe(dispatcher) {
+        return store.subscribe(enhance(dispatcher));
+      },
+      select
+    };
+  }
+
+  // src/store/index.ts
+  function createPrimaryKey(modelFn) {
+    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var ifModelKey = isModelKey(modelFn);
+    var ifModelUsage = isModelUsage(modelFn);
+    var model2 = ifModelKey ? modelFn.source : modelFn;
+    var _config_selector;
+    var selector = (_config_selector = config2.selector) !== null && _config_selector !== void 0 ? _config_selector : ifModelKey || ifModelUsage ? modelFn.selector : function defaultSelector(i) {
+      return i();
+    };
+    var wrapModel = function wrapModel2(state) {
+      return model2(state);
+    };
+    wrapModel.source = model2;
+    wrapModel.selector = selector;
+    wrapModel.modelKeyIdentifier = modelKeyIdentifier;
+    if ("state" in config2) {
+      wrapModel.defaultState = config2.state;
+    }
+    return wrapModel;
+  }
+  function createStore(modelLike) {
+    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var ifModelKey = isModelKey(modelLike);
+    var model2 = ifModelKey ? modelLike.source : modelLike;
+    var modelKey = ifModelKey ? 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 combinedMiddleWare = function combinedMiddleWare2(s) {
+      return function updaterMiddleWare(next) {
+        var middleWares = conf.middleWares;
+        if (middleWares == null) {
+          return next;
+        }
+        var updateMiddleWares = _to_consumable_array(middleWares).reverse().map(function(middleWare) {
+          return middleWare(s);
+        });
+        return updateMiddleWares.reduce(function(finalDispatcher, um) {
+          return um(finalDispatcher);
+        }, next);
+      };
+    };
+    var updater = createUpdater(model2, combinedMiddleWare, conf);
+    var key = modelKey !== null && modelKey !== void 0 ? modelKey : createPrimaryKey(model2, config2);
+    var getInstance = function getInstance2() {
+      return extractInstance(updater);
+    };
+    var store = {
+      key,
+      subscribe: function subscribe(dispatcher) {
+        var _updater_createTunnel = updater.createTunnel(dispatcher), connect = _updater_createTunnel.connect, disconnect = _updater_createTunnel.disconnect;
+        connect();
+        return disconnect;
+      },
+      getInstance,
+      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;
+  }
   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);
+    var wrapModel = createPrimaryKey(model2, config2);
     wrapModel.createStore = function createKeyStore() {
       var storeConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
       return createStore(wrapModel, _object_spread({}, config2, storeConfig));
@@ -966,20 +1169,34 @@
 
   // src/model/index.ts
   function configModel(config2) {
-    var model2 = function model3(modelFn) {
+    var model2 = function model3(modelFn, selector) {
+      var currentSelector = selector !== null && selector !== void 0 ? selector : function defaultSelector(i) {
+        return i();
+      };
       var modelWrapper = function modelWrapper2(state) {
         return modelFn(state);
       };
+      modelWrapper.select = function select(s) {
+        return model3(modelFn, s);
+      };
       modelWrapper.createKey = function createModelKey(state) {
-        return createKey(modelWrapper, arguments.length ? _object_spread_props(_object_spread({}, config2), {
-          state
-        }) : config2);
+        return createKey(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config2), {
+          state,
+          selector: currentSelector
+        }) : _object_spread_props(_object_spread({}, config2), {
+          selector: currentSelector
+        }));
       };
       modelWrapper.createStore = function createModelStore(state) {
-        return createStore(modelWrapper, arguments.length ? _object_spread_props(_object_spread({}, config2), {
-          state
-        }) : config2);
+        return createStore(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config2), {
+          state,
+          selector: currentSelector
+        }) : _object_spread_props(_object_spread({}, config2), {
+          selector: currentSelector
+        }));
       };
+      modelWrapper.selector = currentSelector;
+      modelWrapper.modelUsageIdentifier = modelUsageIdentifier;
       return modelWrapper;
     };
     model2.createField = createField2;