as-model 0.1.28 → 0.2.0

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;
+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 f = d;
-    return f.identifier === cacheIdentify.field;
-  },
-  method(d) {
-    if (typeof d !== "function") {
-      return false;
-    }
-    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) {
@@ -127,36 +131,43 @@ function wrapToField(updater, propertyName, value, onGot) {
   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