as-model 0.1.0 → 0.1.1

package/esm/identifiers/index.js

@@ -0,0 +1,10 @@
+function modelKeyIdentifier() {
+  return true;
+}
+function modelUsageIdentifier() {
+  return true;
+}
+export {
+  modelKeyIdentifier,
+  modelUsageIdentifier
+};

package/esm/index.js

@@ -36,11 +36,12 @@ function config() {
   };
 }
 var _config = config(), createStore = _config.createStore, createKey = _config.createKey, createStores = _config.createStores, model = _config.model;
-import { createSignal } from "./store";
+import { createSignal, createSelector } from "./store";
 import { validations } from "./validation";
 export {
   config,
   createKey,
+  createSelector,
   createSignal,
   createStore,
   createStores,

package/esm/key/index.js

@@ -1,10 +1,10 @@
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
-import { createStore, createPrimaryKey, isModelKey } from "../store";
+import { createStore, createPrimaryKey } from "../store";
+import { isModelKey } from "../validation";
 function createKey(model) {
   var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-  var hasDefaultState = "state" in config;
-  var wrapModel = hasDefaultState ? createPrimaryKey(model, config.state) : createPrimaryKey(model);
+  var wrapModel = createPrimaryKey(model, config);
   wrapModel.createStore = function createKeyStore() {
     var storeConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     return createStore(wrapModel, _object_spread({}, config, storeConfig));

package/esm/model/index.js

@@ -2,21 +2,36 @@ import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { createStore, createField, createMethod } from "../store";
 import { createKey } from "../key";
+import { modelUsageIdentifier } from "../identifiers";
 function configModel(config) {
-  var model = function model2(modelFn) {
+  var model = function model2(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 model2(modelFn, s);
+    };
     modelWrapper.createKey = function createModelKey(state) {
-      return createKey(modelWrapper, arguments.length ? _object_spread_props(_object_spread({}, config), {
-        state
-      }) : config);
+      return createKey(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config), {
+        state,
+        selector: currentSelector
+      }) : _object_spread_props(_object_spread({}, config), {
+        selector: currentSelector
+      }));
     };
     modelWrapper.createStore = function createModelStore(state) {
-      return createStore(modelWrapper, arguments.length ? _object_spread_props(_object_spread({}, config), {
-        state
-      }) : config);
+      return createStore(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config), {
+        state,
+        selector: currentSelector
+      }) : _object_spread_props(_object_spread({}, config), {
+        selector: currentSelector
+      }));
     };
+    modelWrapper.selector = currentSelector;
+    modelWrapper.modelUsageIdentifier = modelUsageIdentifier;
     return modelWrapper;
   };
   model.createField = createField;

package/esm/store/enhance/index.js

@@ -0,0 +1,6 @@
+import { createSignal } from "./signal";
+import { createSelector } from "./selector";
+export {
+  createSelector,
+  createSignal
+};

package/esm/store/enhance/selector.js

@@ -0,0 +1,169 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { cacheIdentify } from "../instance";
+import { createProxy, shallowEqual } from "../../tools";
+function wrapToField(cache, propertyName, value, onGot) {
+  var cacheFields = cache.cacheFields;
+  if (!cacheIdentify.field(value)) {
+    if (onGot) {
+      onGot(propertyName, value);
+    }
+    return value;
+  }
+  var field = 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: field.value,
+    deps: field.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 method = target[methodName];
+    if (typeof method !== "function") {
+      throw new Error("Can not change methods in runtime.");
+    }
+    return method.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;
+      }
+    });
+  };
+};
+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
+  };
+}
+export {
+  cacheProperties,
+  createSelector
+};

package/esm/store/enhance/signal.js

@@ -0,0 +1,81 @@
+import { cacheIdentify, extractInstance } from "../instance";
+import { shallowEqual } from "../../tools";
+function createSignal(store) {
+  var signalStore = {
+    collection: null,
+    started: false,
+    enabled: false
+  };
+  var enhance = function(dispatcher) {
+    return function(action) {
+      if (!signalStore.enabled) {
+        dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
+        return;
+      }
+      var collection = signalStore.collection;
+      if (collection == null) {
+        dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
+        return;
+      }
+      var current = extractInstance(store.updater);
+      var keys = Object.keys(collection);
+      var currentCollectionEntries = keys.map(function(key) {
+        var field = current[key];
+        if (cacheIdentify.field(field)) {
+          return [
+            key,
+            field.get()
+          ];
+        }
+        return [
+          key,
+          field
+        ];
+      });
+      var currentCollection = Object.fromEntries(currentCollectionEntries);
+      if (!shallowEqual(collection, currentCollection)) {
+        dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
+      }
+    };
+  };
+  var storeKey = store.key;
+  return {
+    key: storeKey,
+    subscribe: function subscribe(dispatcher) {
+      return store.subscribe(enhance(dispatcher));
+    },
+    getSignal: function getSignal() {
+      var collectUsedFields = function collectUsedFields2(key, val) {
+        if (!signalStore.started) {
+          return;
+        }
+        signalStore.collection = signalStore.collection || {};
+        signalStore.collection[key] = val;
+      };
+      var getInstance = function getInstance2() {
+        return extractInstance(store.updater, collectUsedFields);
+      };
+      var signal = function signal2() {
+        return getInstance();
+      };
+      signal.startStatistics = function startStatistics() {
+        signalStore.started = true;
+      };
+      signal.stopStatistics = function stopStatistics() {
+        signalStore.started = false;
+      };
+      signal.subscribe = function subscribe(dispatchCallback) {
+        return store.subscribe(dispatchCallback);
+      };
+      signal.payload = function payload(callback) {
+        return store.payload(callback);
+      };
+      signalStore.enabled = true;
+      signalStore.started = true;
+      return signal;
+    }
+  };
+}
+export {
+  createSignal
+};

package/esm/store/index.js

@@ -1,33 +1,35 @@
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { createUpdater } from "../updater";
-import { shallowEqual } from "../tools";
-import { cacheIdentify, extractInstance, createField as createInstanceField, createMethod as createInstanceMethod } from "./instance";
-function modelKeyIdentifier() {
-  return true;
-}
-function isModelKey(data) {
-  if (!data) {
-    return false;
-  }
-  return data.modelKeyIdentifier === modelKeyIdentifier;
-}
-function createPrimaryKey(modelFn, defaultState) {
-  var model = isModelKey(modelFn) ? modelFn.source : modelFn;
+import { isModelKey, isModelUsage } from "../validation";
+import { modelKeyIdentifier } from "../identifiers";
+import { extractInstance, createField as createInstanceField, createMethod as createInstanceMethod } from "./instance";
+function createPrimaryKey(modelFn) {
+  var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var ifModelKey = isModelKey(modelFn);
+  var ifModelUsage = isModelUsage(modelFn);
+  var model = ifModelKey ? modelFn.source : modelFn;
+  var _config_selector;
+  var selector = (_config_selector = config.selector) !== null && _config_selector !== void 0 ? _config_selector : ifModelKey || ifModelUsage ? modelFn.selector : function defaultSelector(i) {
+    return i();
+  };
   var wrapModel = function wrapModel2(state) {
     return model(state);
   };
   wrapModel.source = model;
+  wrapModel.selector = selector;
   wrapModel.modelKeyIdentifier = modelKeyIdentifier;
-  if (arguments.length > 1) {
-    wrapModel.defaultState = defaultState;
+  if ("state" in config) {
+    wrapModel.defaultState = config.state;
   }
   return wrapModel;
 }
 function createStore(modelLike) {
   var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-  var model = isModelKey(modelLike) ? modelLike.source : modelLike;
-  var modelKey = isModelKey(modelLike) ? modelLike : void 0;
+  var ifModelKey = isModelKey(modelLike);
+  var model = ifModelKey ? modelLike.source : modelLike;
+  var modelKey = ifModelKey ? modelLike : void 0;
   var conf = function computeConfig() {
     var hasConfigState = "state" in config;
     var hasKeyState = !!modelKey && "defaultState" in modelKey;
@@ -41,17 +43,33 @@ function createStore(modelLike) {
     }
     return config;
   }();
-  var updater = createUpdater(model, conf);
+  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(model, combinedMiddleWare, conf);
+  var key = modelKey !== null && modelKey !== void 0 ? modelKey : createPrimaryKey(model, config);
+  var getInstance = function getInstance2() {
+    return extractInstance(updater);
+  };
   var store = {
-    key: modelKey !== null && modelKey !== void 0 ? modelKey : "state" in config ? createPrimaryKey(model, config.state) : createPrimaryKey(model),
+    key,
     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);
-    },
+    getInstance,
     update: function update(args) {
       updater.update(args);
     },
@@ -68,86 +86,14 @@ function createStore(modelLike) {
   };
   return store;
 }
-function createSignal(store) {
-  var signalStore = {
-    collection: null,
-    started: false,
-    enabled: false
-  };
-  var middleWare = function(dispatcher) {
-    return function(action) {
-      if (!signalStore.enabled) {
-        dispatcher(action);
-        return;
-      }
-      var collection = signalStore.collection;
-      if (collection == null) {
-        dispatcher(action);
-        return;
-      }
-      var current = extractInstance(store.updater);
-      var keys = Object.keys(collection);
-      var currentCollectionEntries = keys.map(function(key) {
-        var field = current[key];
-        if (cacheIdentify.field(field)) {
-          return [
-            key,
-            field.get()
-          ];
-        }
-        return [
-          key,
-          field
-        ];
-      });
-      var currentCollection = Object.fromEntries(currentCollectionEntries);
-      if (!shallowEqual(collection, currentCollection)) {
-        dispatcher(action);
-      }
-    };
-  };
-  return {
-    key: store.key,
-    subscribe: function subscribe(dispatcher) {
-      return store.subscribe(middleWare(dispatcher));
-    },
-    getSignal: function getSignal() {
-      var collectUsedFields = function collectUsedFields2(key, val) {
-        if (!signalStore.started) {
-          return;
-        }
-        signalStore.collection = signalStore.collection || {};
-        signalStore.collection[key] = val;
-      };
-      var signal = function signal2() {
-        return extractInstance(store.updater, collectUsedFields);
-      };
-      signal.startStatistics = function startStatistics() {
-        signalStore.started = true;
-      };
-      signal.stopStatistics = function stopStatistics() {
-        signalStore.started = false;
-      };
-      signal.subscribe = function subscribe(dispatchCallback) {
-        return store.subscribe(dispatchCallback);
-      };
-      signal.payload = function payload(callback) {
-        return store.payload(callback);
-      };
-      signalStore.enabled = true;
-      signalStore.started = true;
-      return signal;
-    }
-  };
-}
 var createField = createInstanceField;
 var createMethod = createInstanceMethod;
+import { createSignal, createSelector } from "./enhance";
 export {
   createField,
   createMethod,
   createPrimaryKey,
+  createSelector,
   createSignal,
-  createStore,
-  isModelKey,
-  modelKeyIdentifier
+  createStore
 };

package/esm/store/instance.js

@@ -1,5 +1,3 @@
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _type_of } from "@swc/helpers/_/_type_of";
 import { createProxy, shallowEqual } from "../tools";
@@ -68,7 +66,7 @@ function wrapToActionMethod(updater, methodName) {
     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, model = updater.model;
+    var instance = updater.instance, model = updater.model;
     var method2 = instance[methodName];
     if (typeof method2 !== "function") {
       throw new Error("Can not change methods in runtime.");
@@ -77,9 +75,6 @@ function wrapToActionMethod(updater, methodName) {
       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,
@@ -88,30 +83,7 @@ function wrapToActionMethod(updater, methodName) {
       prevInstance: updater.instance,
       method: actionMethod2
     };
-    if (controlled) {
-      updater.notify(action);
-      return state;
-    }
-    var prevState = updater.state;
-    var prevInstance = updater.instance;
-    var newestInstance = model(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;

package/esm/tools/index.js

@@ -0,0 +1,10 @@
+function noop() {
+}
+import { createSimpleProxy, createProxy } from "./proxy";
+import { shallowEqual } from "./shallowEqual";
+export {
+  createProxy,
+  createSimpleProxy,
+  noop,
+  shallowEqual
+};

package/esm/tools/proxy.js

@@ -0,0 +1,43 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+function getDescriptors(target, receiver, ownOrPrototype, handler) {
+  var it = Object.keys(ownOrPrototype);
+  var result = {};
+  it.forEach(function(key) {
+    result[key] = {
+      get: function() {
+        if (!handler.get) {
+          return target[key];
+        }
+        return handler.get(target, key, receiver);
+      },
+      set: function(v) {
+        if (!handler.set) {
+          target[key] = v;
+          return;
+        }
+        var valid = handler.set(target, key, v, receiver);
+        if (!valid) {
+          throw new Error("".concat(key, " in proxy target is not mutable"));
+        }
+      }
+    };
+  });
+  return result;
+}
+var createSimpleProxy = function(target, handler) {
+  var proxy = {};
+  var own = getDescriptors(target, proxy, target, handler);
+  var prototype = getDescriptors(target, proxy, Object.getPrototypeOf(target), handler);
+  Object.defineProperties(proxy, _object_spread({}, prototype, own));
+  return proxy;
+};
+var createProxy = function(target, handler) {
+  if (typeof Proxy !== "function") {
+    return createSimpleProxy(target, handler);
+  }
+  return new Proxy(target, handler);
+};
+export {
+  createProxy,
+  createSimpleProxy
+};

package/esm/tools/shallowEqual.js

@@ -0,0 +1,34 @@
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+function isObject(data) {
+  return data && (typeof data === "undefined" ? "undefined" : _type_of(data)) === "object";
+}
+function shallowEqual(prev, current) {
+  if (Object.is(prev, current)) {
+    return true;
+  }
+  if (!isObject(prev) || !isObject(current)) {
+    return false;
+  }
+  var prevKeys = Object.keys(prev);
+  var currentKeys = Object.keys(current);
+  if (prevKeys.length !== currentKeys.length) {
+    return false;
+  }
+  var pre = prev;
+  var curr = current;
+  var hasDiffKey = prevKeys.some(function(key) {
+    return !Object.prototype.hasOwnProperty.call(curr, key);
+  });
+  if (hasDiffKey) {
+    return false;
+  }
+  var hasDiffValue = currentKeys.some(function(key) {
+    var currentValue = curr[key];
+    var prevValue = pre[key];
+    return !Object.is(currentValue, prevValue);
+  });
+  return !hasDiffValue;
+}
+export {
+  shallowEqual
+};