as-model 0.1.28 → 0.2.1

package/dist/index.js

@@ -747,7 +747,7 @@
     return updater;
   }
 
-  // src/store/instance.ts
+  // src/store/cache.ts
   var cacheIdentify = {
     field: function field(d) {
       if (!d) {
@@ -764,6 +764,102 @@
       return m.identifier === cacheIdentify.method;
     }
   };
+  function wrapToField(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 wrapToActionMethod(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 = wrapToActionMethod(cache, p);
+            Object.assign(actionMethod, value);
+            handleGetter(p, actionMethod);
+            return actionMethod;
+          }
+          return wrapToField(cache, p, value, handleGetter);
+        },
+        set: function set() {
+          return false;
+        }
+      });
+    };
+  };
+
+  // src/store/instance.ts
   function createField(callback, deps) {
     var currentDeps = function computeDeps() {
       if (deps == null) {
@@ -802,7 +898,7 @@
     replace.identifier = cacheIdentify.method;
     return replace;
   }
-  function wrapToActionMethod(updater, methodName) {
+  function wrapToActionMethod2(updater, methodName) {
     var cacheMethods = updater.cacheMethods;
     var cachedMethod = cacheMethods[methodName];
     if (typeof cachedMethod === "function") {
@@ -835,7 +931,7 @@
     cacheMethods[methodName] = actionMethod;
     return actionMethod;
   }
-  function wrapToField(updater, propertyName, value, onGot) {
+  function wrapToField2(updater, propertyName, value, onGot) {
     function collect(pName, v) {
       if (onGot) {
         onGot(pName, v);
@@ -888,33 +984,43 @@
     collect(propertyName, getter);
     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);
+  function extractInstance(updater, wrapper, cache, opts) {
+    var onGet = (opts || {}).onGet;
     var handleGetter = function handleGetter2(key, value) {
       if (!onGet) {
         return;
       }
       onGet(key, value);
     };
-    return createProxy(instance, {
+    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 proxiedInstance = createProxy(instance, {
       get: function get(target, p) {
         var value = target[p];
         if (typeof value === "function" && properties.indexOf(p) >= 0) {
-          var actionMethod = wrapToActionMethod(updater, p);
+          var actionMethod = wrapToActionMethod2(updater, p);
           Object.assign(actionMethod, value);
-          handleGetter(p, actionMethod);
           return actionMethod;
         }
-        return wrapToField(updater, p, value, handleGetter);
+        return wrapToField2(updater, p, value);
       },
       set: function set() {
         return false;
       }
     });
+    function generateInstance() {
+      return proxiedInstance;
+    }
+    var wrapped = wrapper(generateInstance);
+    if ((typeof wrapped === "undefined" ? "undefined" : _type_of(wrapped)) === "object" && wrapped != null) {
+      return cacheProperties(_object_spread_props(_object_spread({}, cache), {
+        target: wrapped
+      }), handleGetter)();
+    }
+    return wrapped;
   }
 
   // src/store/enhance/signal.ts
@@ -924,6 +1030,11 @@
       started: false,
       enabled: false
     };
+    var propertiesCache = {
+      target: store.getInstance(),
+      cacheFields: {},
+      cacheMethods: {}
+    };
     var enhance = function(dispatcher) {
       return function(action) {
         if (!signalStore.enabled) {
@@ -934,7 +1045,7 @@
         if (collection == null) {
           return;
         }
-        var storeInstance = extractInstance(store.updater);
+        var storeInstance = extractInstance(store.updater, store.key.wrapper, propertiesCache);
         var keys = Object.keys(collection);
         if (!keys.length) {
           return;
@@ -970,7 +1081,9 @@
         };
         var getInstance = function getInstance2(options) {
           var cutOff = (options !== null && options !== void 0 ? options : {}).cutOff;
-          return extractInstance(store.updater, cutOff ? void 0 : collectUsedFields);
+          return extractInstance(store.updater, store.key.wrapper, propertiesCache, {
+            onGet: cutOff ? void 0 : collectUsedFields
+          });
         };
         var signal = function signal2(options) {
           return getInstance(options);
@@ -994,100 +1107,6 @@
   }
 
   // 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 = {
@@ -1108,25 +1127,11 @@
         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)();
+      return getInstance();
     };
     selectStore.selectedInstance = generateSelectedInstance(store.getInstance);
     var enhance = function(dispatcher) {
@@ -1165,15 +1170,15 @@
     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) {
+    var _config_wrapper;
+    var wrapper = (_config_wrapper = config2.wrapper) !== null && _config_wrapper !== void 0 ? _config_wrapper : ifModelKey || ifModelUsage ? modelFn.wrapper : function defaultSelector(i) {
       return i();
     };
     var wrapModel = function wrapModel2(state) {
       return model2(state);
     };
     wrapModel.source = model2;
-    wrapModel.selector = selector;
+    wrapModel.wrapper = wrapper;
     wrapModel.modelKeyIdentifier = modelKeyIdentifier;
     if ("state" in config2) {
       wrapModel.defaultState = config2.state;
@@ -1214,8 +1219,10 @@
     };
     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 propertiesCache = {
+      target: updater.instance,
+      cacheFields: {},
+      cacheMethods: {}
     };
     var store = {
       key,
@@ -1223,11 +1230,13 @@
         return updater.token;
       },
       subscribe: function subscribe(dispatcher) {
-        var _updater_createTunnel = updater.createTunnel(dispatcher), connect = _updater_createTunnel.connect, disconnect = _updater_createTunnel.disconnect;
+        var _updater_createTunnel = updater.createTunnel(dispatcher || noop), connect = _updater_createTunnel.connect, disconnect = _updater_createTunnel.disconnect;
         connect();
         return disconnect;
       },
-      getInstance,
+      getInstance: function getInstance() {
+        return extractInstance(updater, key.wrapper, propertiesCache);
+      },
       update: function update(args) {
         var updateArgs = args !== null && args !== void 0 ? args : {};
         if (updateArgs.key) {
@@ -1351,36 +1360,36 @@
 
   // src/model/index.ts
   function configModel(config2) {
-    var model2 = function model3(modelFn, selector) {
-      var currentSelector = selector !== null && selector !== void 0 ? selector : function defaultSelector(i) {
+    var model2 = function model3(modelFn, wrapper) {
+      var currentSelector = wrapper !== null && wrapper !== void 0 ? wrapper : function defaultSelector(i) {
         return i();
       };
       var modelWrapper = function modelWrapper2(state) {
         return modelFn(state);
       };
-      modelWrapper.select = function select(s) {
+      modelWrapper.pipe = function pipe(s) {
         return model3(modelFn, s);
       };
       modelWrapper.createKey = function createModelKey(state) {
         return createKey(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config2), {
           state,
-          selector: currentSelector
+          wrapper: currentSelector
         }) : _object_spread_props(_object_spread({}, config2), {
-          selector: currentSelector
+          wrapper: currentSelector
         }));
       };
       modelWrapper.createStore = function createModelStore(state) {
         return createStore(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config2), {
           state,
-          selector: currentSelector
+          wrapper: currentSelector
         }) : _object_spread_props(_object_spread({}, config2), {
-          selector: currentSelector
+          wrapper: currentSelector
         }));
       };
       modelWrapper.extends = function extendsModelUsage(e) {
         return Object.assign(modelWrapper, e);
       };
-      modelWrapper.selector = currentSelector;
+      modelWrapper.wrapper = currentSelector;
       modelWrapper.modelUsageIdentifier = modelUsageIdentifier;
       return modelWrapper;
     };

package/esm/model/index.js

@@ -21,32 +21,32 @@ import { createStore, createField, createMethod } from "../store";
 import { createKey } from "../key";
 import { modelUsageIdentifier } from "../identifiers";
 function configModel(config) {
-  const model = function model2(modelFn, selector) {
-    const currentSelector = selector != null ? selector : function defaultSelector(i) {
+  const model = function model2(modelFn, wrapper) {
+    const currentSelector = wrapper != null ? wrapper : function defaultSelector(i) {
       return i();
     };
     const modelWrapper = function modelWrapper2(state) {
       return modelFn(state);
     };
-    modelWrapper.select = function select(s) {
+    modelWrapper.pipe = function pipe(s) {
       return model2(modelFn, s);
     };
     modelWrapper.createKey = function createModelKey(state) {
       return createKey(
         modelFn,
-        arguments.length ? __spreadProps(__spreadValues({}, config), { state, selector: currentSelector }) : __spreadProps(__spreadValues({}, config), { selector: currentSelector })
+        arguments.length ? __spreadProps(__spreadValues({}, config), { state, wrapper: currentSelector }) : __spreadProps(__spreadValues({}, config), { wrapper: currentSelector })
       );
     };
     modelWrapper.createStore = function createModelStore(state) {
       return createStore(
         modelFn,
-        arguments.length ? __spreadProps(__spreadValues({}, config), { state, selector: currentSelector }) : __spreadProps(__spreadValues({}, config), { selector: currentSelector })
+        arguments.length ? __spreadProps(__spreadValues({}, config), { state, wrapper: currentSelector }) : __spreadProps(__spreadValues({}, config), { wrapper: currentSelector })
       );
     };
     modelWrapper.extends = function extendsModelUsage(e) {
       return Object.assign(modelWrapper, e);
     };
-    modelWrapper.selector = currentSelector;
+    modelWrapper.wrapper = currentSelector;
     modelWrapper.modelUsageIdentifier = modelUsageIdentifier;
     return modelWrapper;
   };

package/esm/store/cache.js

@@ -0,0 +1,108 @@
+import { createProxy, shallowEqual } from "../tools";
+const cacheIdentify = {
+  field(d) {
+    if (!d) {
+      return false;
+    }
+    const f = d;
+    return f.identifier === cacheIdentify.field;
+  },
+  method(d) {
+    if (typeof d !== "function") {
+      return false;
+    }
+    const m = d;
+    return m.identifier === cacheIdentify.method;
+  }
+};
+function wrapToField(cache, propertyName, value, onGot) {
+  const { cacheFields } = cache;
+  if (!cacheIdentify.field(value)) {
+    if (onGot) {
+      onGot(propertyName, value);
+    }
+    return value;
+  }
+  const field = value;
+  const cachedField = cacheFields[propertyName];
+  if (cachedField) {
+    return cachedField.getter;
+  }
+  const getter = {
+    get() {
+      const currentField = cache.target[propertyName];
+      if (!cacheIdentify.field(currentField)) {
+        throw new Error("Field should always be field.");
+      }
+      const current = currentField.get();
+      const 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: field.value, deps: field.deps };
+  return getter;
+}
+function wrapToActionMethod(cache, methodName) {
+  const { cacheMethods } = cache;
+  const cachedMethod = cacheMethods[methodName];
+  if (typeof cachedMethod === "function") {
+    return cachedMethod;
+  }
+  const actionMethod = function actionMethod2(...args) {
+    const { target } = cache;
+    const method = target[methodName];
+    if (typeof method !== "function") {
+      throw new Error("Can not change methods in runtime.");
+    }
+    return method(...args);
+  };
+  cacheMethods[methodName] = actionMethod;
+  return actionMethod;
+}
+const cacheProperties = (cache, onGet) => {
+  return function createCachePropertiesProxy() {
+    const instance = cache.target;
+    const properties = Object.getOwnPropertyNames(instance);
+    const handleGetter = function handleGetter2(key, value) {
+      if (!onGet) {
+        return;
+      }
+      onGet(key, value);
+    };
+    return createProxy(instance, {
+      get(target, p) {
+        const value = target[p];
+        if (typeof value === "function" && properties.indexOf(p) >= 0) {
+          const actionMethod = wrapToActionMethod(cache, p);
+          Object.assign(actionMethod, value);
+          handleGetter(p, actionMethod);
+          return actionMethod;
+        }
+        return wrapToField(cache, p, value, handleGetter);
+      },
+      set() {
+        return false;
+      }
+    });
+  };
+};
+export {
+  cacheIdentify,
+  cacheProperties
+};