as-model 0.1.27 → 0.2.0

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,18 +931,23 @@
     cacheMethods[methodName] = actionMethod;
     return actionMethod;
   }
-  function wrapToField(updater, propertyName, value, onGot) {
-    var cacheFields = updater.cacheFields;
-    if (!cacheIdentify.field(value)) {
+  function wrapToField2(updater, propertyName, value, onGot) {
+    function collect(pName, v) {
       if (onGot) {
-        onGot(propertyName, value);
+        onGot(pName, v);
       }
+    }
+    var cacheFields = updater.cacheFields;
+    if (!cacheIdentify.field(value)) {
+      collect(propertyName, value);
       return value;
     }
     var field2 = value;
     var cachedField = cacheFields[propertyName];
-    if (cachedField) {
-      return cachedField.getter;
+    if (cachedField && (field2.deps && shallowEqual(cachedField.deps, field2.deps) || !field2.deps && cachedField.value === field2.value)) {
+      var cacheFieldGetter = cachedField.getter;
+      collect(propertyName, cacheFieldGetter);
+      return cacheFieldGetter;
     }
     var getter = {
       get: function get() {
@@ -880,35 +981,46 @@
       value: field2.value,
       deps: field2.deps
     };
+    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
@@ -918,6 +1030,11 @@
       started: false,
       enabled: false
     };
+    var propertiesCache = {
+      target: store.getInstance(),
+      cacheFields: {},
+      cacheMethods: {}
+    };
     var enhance = function(dispatcher) {
       return function(action) {
         if (!signalStore.enabled) {
@@ -928,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;
@@ -964,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);
@@ -988,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 = {
@@ -1102,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) {
@@ -1159,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;
@@ -1208,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,
@@ -1217,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) {
@@ -1345,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
+};

package/esm/store/enhance/selector.js

@@ -1,92 +1,3 @@
-import { cacheIdentify } from "../instance";
-import { createProxy, shallowEqual } from "../../tools";
-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;
-      }
-    });
-  };
-};
 function createSelector(store, opts) {
   const { equality } = opts != null ? opts : {};
   const selectStore = {
@@ -107,27 +18,11 @@ function createSelector(store, opts) {
       selectStore.selectedInstance = nextSelectedInstance;
     }
   };
-  const propertiesCache = {
-    target: store.getInstance(),
-    cacheFields: {},
-    cacheMethods: {}
-  };
   const generateSelectedInstance = function generateSelectedInstance2(getInstance) {
-    const { key: storeKey } = store;
     if (cache.selector) {
       return cache.selector(getInstance);
     }
-    if (!(storeKey == null ? void 0 : storeKey.selector)) {
-      return getInstance();
-    }
-    const result = storeKey == null ? void 0 : storeKey.selector(getInstance);
-    if (result == null || typeof 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);
   const enhance = (dispatcher) => {
@@ -160,6 +55,5 @@ function createSelector(store, opts) {
   };
 }
 export {
-  cacheProperties,
   createSelector
 };

package/esm/store/enhance/signal.js

@@ -1,10 +1,16 @@
-import { cacheIdentify, extractInstance } from "../instance";
+import { extractInstance } from "../instance";
+import { cacheIdentify } from "../cache";
 function createSignal(store) {
   const signalStore = {
     collection: {},
     started: false,
     enabled: false
   };
+  const propertiesCache = {
+    target: store.getInstance(),
+    cacheFields: {},
+    cacheMethods: {}
+  };
   const enhance = (dispatcher) => {
     return (action) => {
       if (!signalStore.enabled) {
@@ -15,7 +21,11 @@ function createSignal(store) {
       if (collection == null) {
         return;
       }
-      const storeInstance = extractInstance(store.updater);
+      const storeInstance = extractInstance(
+        store.updater,
+        store.key.wrapper,
+        propertiesCache
+      );
       const keys = Object.keys(collection);
       if (!keys.length) {
         return;
@@ -53,7 +63,9 @@ function createSignal(store) {
         const { cutOff } = options != null ? options : {};
         return extractInstance(
           store.updater,
-          cutOff ? void 0 : collectUsedFields
+          store.key.wrapper,
+          propertiesCache,
+          { onGet: cutOff ? void 0 : collectUsedFields }
         );
       };
       const signal = function signal2(options) {

package/esm/store/index.js

@@ -32,6 +32,7 @@ var __objRest = (source, exclude) => {
 import { createUpdater } from "../updater";
 import { isModelKey, isModelUsage } from "../validation";
 import { modelKeyIdentifier, modelStoreIdentifier } from "../identifiers";
+import { noop } from "../tools";
 import {
   extractInstance,
   createField as createInstanceField,
@@ -42,14 +43,14 @@ function createPrimaryKey(modelFn, config = {}) {
   const ifModelKey = isModelKey(modelFn);
   const ifModelUsage = isModelUsage(modelFn);
   const model = ifModelKey ? modelFn.source : modelFn;
-  const selector = (_a = config.selector) != null ? _a : ifModelKey || ifModelUsage ? modelFn.selector : function defaultSelector(i) {
+  const wrapper = (_a = config.wrapper) != null ? _a : ifModelKey || ifModelUsage ? modelFn.wrapper : function defaultSelector(i) {
     return i();
   };
   const wrapModel = function wrapModel2(state) {
     return model(state);
   };
   wrapModel.source = model;
-  wrapModel.selector = selector;
+  wrapModel.wrapper = wrapper;
   wrapModel.modelKeyIdentifier = modelKeyIdentifier;
   if ("state" in config) {
     wrapModel.defaultState = config.state;
@@ -87,8 +88,10 @@ function createStore(modelLike, config = {}) {
   };
   const updater = createUpdater(model, combinedMiddleWare, conf);
   const key = modelKey != null ? modelKey : createPrimaryKey(model, config);
-  const getInstance = function getInstance2() {
-    return extractInstance(updater);
+  const propertiesCache = {
+    target: updater.instance,
+    cacheFields: {},
+    cacheMethods: {}
   };
   const store = {
     key,
@@ -96,11 +99,13 @@ function createStore(modelLike, config = {}) {
       return updater.token;
     },
     subscribe(dispatcher) {
-      const { connect, disconnect } = updater.createTunnel(dispatcher);
+      const { connect, disconnect } = updater.createTunnel(dispatcher || noop);
       connect();
       return disconnect;
     },
-    getInstance,
+    getInstance() {
+      return extractInstance(updater, key.wrapper, propertiesCache);
+    },
     update(args) {
       const updateArgs = args != null ? args : {};
       if (updateArgs.key) {

package/esm/store/instance.js

@@ -1,20 +1,24 @@
-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;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
     }
-    const m = d;
-    return m.identifier === cacheIdentify.method;
-  }
+  return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { createProxy, shallowEqual } from "../tools";
+import { cacheIdentify, cacheProperties } from "./cache";
 function createField(callback, deps) {
   const currentDeps = function computeDeps() {
     if (deps == null) {
@@ -79,17 +83,22 @@ function wrapToActionMethod(updater, methodName) {
   return actionMethod;
 }
 function wrapToField(updater, propertyName, value, onGot) {
-  const { cacheFields } = updater;
-  if (!cacheIdentify.field(value)) {
+  function collect(pName, v) {
     if (onGot) {
-      onGot(propertyName, value);
+      onGot(pName, v);
     }
+  }
+  const { cacheFields } = updater;
+  if (!cacheIdentify.field(value)) {
+    collect(propertyName, value);
     return value;
   }
   const field = value;
   const cachedField = cacheFields[propertyName];
-  if (cachedField) {
-    return cachedField.getter;
+  if (cachedField && (field.deps && shallowEqual(cachedField.deps, field.deps) || !field.deps && cachedField.value === field.value)) {
+    const cacheFieldGetter = cachedField.getter;
+    collect(propertyName, cacheFieldGetter);
+    return cacheFieldGetter;
   }
   const getter = {
     get() {
@@ -119,38 +128,46 @@ function wrapToField(updater, propertyName, value, onGot) {
     }
   };
   cacheFields[propertyName] = { getter, value: field.value, deps: field.deps };
+  collect(propertyName, getter);
   return getter;
 }
-function extractInstance(updater, onGet) {
-  const { instance } = updater;
-  if (typeof instance !== "object" || !instance) {
-    throw new Error("The instance should be an object or array.");
-  }
-  const properties = Object.getOwnPropertyNames(instance);
+function extractInstance(updater, wrapper, cache, opts) {
+  const { onGet } = opts || {};
   const handleGetter = function handleGetter2(key, value) {
     if (!onGet) {
       return;
     }
     onGet(key, value);
   };
-  return createProxy(instance, {
+  const { instance } = updater;
+  if (typeof instance !== "object" || !instance) {
+    throw new Error("The instance should be an object or array.");
+  }
+  const properties = Object.getOwnPropertyNames(instance);
+  const proxiedInstance = createProxy(instance, {
     get(target, p) {
       const value = target[p];
       if (typeof value === "function" && properties.indexOf(p) >= 0) {
         const actionMethod = wrapToActionMethod(updater, p);
         Object.assign(actionMethod, value);
-        handleGetter(p, actionMethod);
         return actionMethod;
       }
-      return wrapToField(updater, p, value, handleGetter);
+      return wrapToField(updater, p, value);
     },
     set() {
       return false;
     }
   });
+  function generateInstance() {
+    return proxiedInstance;
+  }
+  const wrapped = wrapper(generateInstance);
+  if (typeof wrapped === "object" && wrapped != null) {
+    return cacheProperties(__spreadProps(__spreadValues({}, cache), { target: wrapped }), handleGetter)();
+  }
+  return wrapped;
 }
 export {
-  cacheIdentify,
   createField,
   createMethod,
   extractInstance

package/index.d.ts

@@ -99,7 +99,7 @@ export declare interface Store<
 > extends StoreIndex<S, T, R> {
   subscribe: (dispatcher: Dispatch) => () => void;
   getToken: () => Token;
-  getInstance: () => T;
+  getInstance: () => ReturnType<R>;
   update: (args?: {
     model?: Model<S, T>;
     key?: Key<S, T, R>;
@@ -172,10 +172,10 @@ export declare interface ModelUsage<
   (s: S): ValidInstance<S, T>;
   createKey: <D extends S>(state?: D) => ModelKey<S, T, R>;
   createStore: <D extends S>(state?: D) => Store<S, T, R>;
-  select: <C extends (instance: () => T) => any = (instance: () => T) => T>(
+  pipe: <C extends (instance: () => T) => any = (instance: () => T) => T>(
     s: C
   ) => ModelUsage<S, T, C>;
-  selector: R;
+  wrapper: R;
   extends: <E extends Record<string, any>>(e: E) => ModelUsage<S, T, R> & E;
 }
 
@@ -213,7 +213,7 @@ declare interface SignalStore<
   getToken: () => Token;
   subscribe: (dispatcher: Dispatch) => () => void;
   getSignal: () => {
-    (options?: SignalOptions): T;
+    (options?: SignalOptions): ReturnType<R>;
     startStatistics: () => void;
     stopStatistics: () => void;
     subscribe: (dispatcher: Dispatch) => () => void;
@@ -224,14 +224,14 @@ declare interface SignalStore<
 export declare function createSignal<
   S,
   T extends ModelInstance,
-  R extends (instance: () => T) => any = (instance: () => T) => any
+  R extends (instance: () => T) => any = (instance: () => T) => T
 >(store: Store<S, T, R>): SignalStore<S, T, R>;
 
 /** createSelector * */
 
 declare type SelectMethod<
   T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => any
+  R extends (instance: () => T) => any = (instance: () => T) => T
 > = {
   (): ReturnType<R>;
   <C extends (instance: () => T) => any>(selector: C): ReturnType<C>;
@@ -244,7 +244,7 @@ declare type SelectMethod<
 declare interface SelectorStore<
   S = any,
   T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => any
+  R extends (instance: () => T) => any = (instance: () => T) => T
 > extends StoreIndex<S, T, R> {
   getToken: () => Token;
   subscribe: (dispatcher: Dispatch) => () => void;
@@ -258,7 +258,7 @@ declare interface SelectorOption<T = any> {
 export declare function createSelector<
   S,
   T extends ModelInstance,
-  R extends (instance: () => T) => any = (instance: () => T) => any
+  R extends (instance: () => T) => any = (instance: () => T) => T
 >(store: Store<S, T, R>, opts?: SelectorOption): SelectorStore<S, T, R>;
 
 /** config * */

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "as-model",
-  "version": "0.1.27",
+  "version": "0.2.0",
   "description": "This is a model state management tool",
   "license": "MIT",
   "author": "Jimmy.Harding",