as-model 0.1.16 → 0.1.18

package/dist/index.js

@@ -55,6 +55,37 @@
     return target;
   }
 
+  // node_modules/@swc/helpers/esm/_object_without_properties_loose.js
+  function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+    return target;
+  }
+
+  // node_modules/@swc/helpers/esm/_object_without_properties.js
+  function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+      }
+    }
+    return target;
+  }
+
   // 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;
@@ -153,6 +184,96 @@
     isModelUsage
   };
 
+  // src/tools/proxy.ts
+  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);
+  };
+
+  // src/tools/shallowEqual.ts
+  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;
+  }
+
+  // src/tools/index.ts
+  function noop() {
+  }
+  function simpleErrorProcess(errors) {
+    return function wrap(callback) {
+      return function replaced() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        try {
+          return callback.apply(void 0, _to_consumable_array(args));
+        } catch (e) {
+          errors.push(e);
+        }
+      };
+    };
+  }
+
   // src/updater/notifier.ts
   function defaultNotifyImplement(dispatches, action) {
     dispatches.forEach(function(callback) {
@@ -228,10 +349,8 @@
         call(initializedAction);
       });
     }
-    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 dispatches = updater.dispatches, controlled = updater.controlled, model2 = updater.model, config2 = updater.config;
       var state = action.state;
       var nextInstance = model2(state);
       var nextAction = _object_spread_props(_object_spread({}, action), {
@@ -246,11 +365,31 @@
           });
         });
       }
+      var notifyAction = function notifyAction2(act) {
+        var errors = [];
+        var dispatchCallbacks = dispatches.map(simpleErrorProcess(errors));
+        defaultNotifyImplement(dispatchCallbacks, act);
+        if (!errors.length) {
+          return {
+            errors: void 0
+          };
+        }
+        return {
+          errors
+        };
+      };
+      var notifyActionWithErrorThrow = function notifyActionWithErrorThrow2(act) {
+        var errors = notifyAction(act).errors;
+        if (!errors || !errors.length) {
+          return;
+        }
+        throw errors[0];
+      };
       try {
-        if (typeof config2.batchNotify === "function") {
-          config2.batchNotify(dispatchCallbacks, nextAction);
+        if (typeof config2.notify === "function") {
+          config2.notify(notifyAction, nextAction);
         } else {
-          defaultNotifyImplement(dispatchCallbacks, nextAction);
+          notifyActionWithErrorThrow(nextAction);
         }
       } catch (e) {
         updater.mutate(function(u) {
@@ -295,82 +434,6 @@
     };
   }
 
-  // src/tools/proxy.ts
-  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);
-  };
-
-  // src/tools/shallowEqual.ts
-  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;
-  }
-
-  // src/tools/index.ts
-  function noop() {
-  }
-
   // src/updater/tunnel.ts
   function createUnInitializedUpdater() {
     return {
@@ -516,7 +579,6 @@
       updater.mutate(function(u, effect) {
         var _args_model;
         var model2 = (_args_model = args.model) !== null && _args_model !== void 0 ? _args_model : u.model;
-        var initialState = "initialState" in args ? args.initialState : u.state;
         var state = "state" in args ? args.state : u.state;
         if (u.controlled) {
           var instance = model2(state);
@@ -529,15 +591,15 @@
         if (u.isDestroyed) {
           return u;
         }
-        if (!u.initialized && !("initialState" in args)) {
-          throw new Error("Should update initialState first.");
+        if (!u.initialized && !("state" in args)) {
+          throw new Error("The updater has not been initialized, it should be updated with a state for initializing.");
         }
         if (!u.initialized) {
-          var instance1 = model2(initialState);
+          var instance1 = model2(state);
           var initializedUpdater = createInitializedUpdater(u, middleWare);
           return _object_spread(_object_spread_props(_object_spread({}, u), {
             model: model2,
-            state: initialState,
+            state,
             instance: instance1,
             initialized: true
           }), initializedUpdater);
@@ -560,7 +622,9 @@
           state,
           model: model2,
           instance: instance2,
-          initialized: true
+          initialized: true,
+          cacheFields: {},
+          cacheMethods: {}
         });
       });
     };
@@ -1095,6 +1159,29 @@
       },
       getInstance,
       update: function update(args) {
+        var updateArgs = args !== null && args !== void 0 ? args : {};
+        if ("key" in updateArgs && updateArgs.key) {
+          var updatingKey = updateArgs.key, updatingModel = updateArgs.model, rest = _object_without_properties(updateArgs, [
+            "key",
+            "model"
+          ]);
+          updater.update(_object_spread_props(_object_spread({}, rest), {
+            model: updatingKey.source
+          }));
+          store.key = updatingKey;
+          return;
+        }
+        if ("model" in updateArgs && updateArgs.model) {
+          var updatingKey1 = updateArgs.key, updatingModel1 = updateArgs.model, rest1 = _object_without_properties(updateArgs, [
+            "key",
+            "model"
+          ]);
+          updater.update(_object_spread_props(_object_spread({}, rest1), {
+            model: updatingModel1
+          }));
+          store.key = createPrimaryKey(updatingModel1, config2);
+          return;
+        }
         updater.update(args);
       },
       destroy: function destroy2() {
@@ -1172,11 +1259,8 @@
           }
           var ifIsModelKey = validations.isModelKey(keyLike);
           var key = ifIsModelKey ? keyLike : keyLike.key;
-          Object.assign(un, {
-            key
-          });
           un.update({
-            model: ifIsModelKey ? keyLike.source : keyLike.key.source
+            key
           });
         });
       },

package/esm/key/index.js

@@ -66,9 +66,8 @@ function createStores(modelKeys, config = {}) {
         }
         const ifIsModelKey = validations.isModelKey(keyLike);
         const key = ifIsModelKey ? keyLike : keyLike.key;
-        Object.assign(un, { key });
         un.update({
-          model: ifIsModelKey ? keyLike.source : keyLike.key.source
+          key
         });
       });
     },

package/esm/store/index.js

@@ -17,6 +17,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 import { createUpdater } from "../updater";
 import { isModelKey, isModelUsage } from "../validation";
 import { modelKeyIdentifier, modelStoreIdentifier } from "../identifiers";
@@ -87,6 +99,19 @@ function createStore(modelLike, config = {}) {
     },
     getInstance,
     update(args) {
+      const updateArgs = args != null ? args : {};
+      if ("key" in updateArgs && updateArgs.key) {
+        const _a = updateArgs, { key: updatingKey, model: updatingModel } = _a, rest = __objRest(_a, ["key", "model"]);
+        updater.update(__spreadProps(__spreadValues({}, rest), { model: updatingKey.source }));
+        store.key = updatingKey;
+        return;
+      }
+      if ("model" in updateArgs && updateArgs.model) {
+        const _b = updateArgs, { key: updatingKey, model: updatingModel } = _b, rest = __objRest(_b, ["key", "model"]);
+        updater.update(__spreadProps(__spreadValues({}, rest), { model: updatingModel }));
+        store.key = createPrimaryKey(updatingModel, config);
+        return;
+      }
       updater.update(args);
     },
     destroy() {

package/esm/tools/index.js

@@ -1,10 +1,22 @@
 function noop() {
 }
+function simpleErrorProcess(errors) {
+  return function wrap(callback) {
+    return function replaced(...args) {
+      try {
+        return callback(...args);
+      } catch (e) {
+        errors.push(e);
+      }
+    };
+  };
+}
 import { createSimpleProxy, createProxy } from "./proxy";
 import { shallowEqual } from "./shallowEqual";
 export {
   createProxy,
   createSimpleProxy,
   noop,
-  shallowEqual
+  shallowEqual,
+  simpleErrorProcess
 };

package/esm/updater/index.js

@@ -36,7 +36,6 @@ function createUpdateFn(updater, middleWare) {
     updater.mutate((u, effect) => {
       var _a;
       const model = (_a = args.model) != null ? _a : u.model;
-      const initialState = "initialState" in args ? args.initialState : u.state;
       const state = "state" in args ? args.state : u.state;
       if (u.controlled) {
         const instance2 = model(state);
@@ -45,15 +44,17 @@ function createUpdateFn(updater, middleWare) {
       if (u.isDestroyed) {
         return u;
       }
-      if (!u.initialized && !("initialState" in args)) {
-        throw new Error("Should update initialState first.");
+      if (!u.initialized && !("state" in args)) {
+        throw new Error(
+          "The updater has not been initialized, it should be updated with a state for initializing."
+        );
       }
       if (!u.initialized) {
-        const instance2 = model(initialState);
+        const instance2 = model(state);
         const initializedUpdater = createInitializedUpdater(u, middleWare);
         return __spreadValues(__spreadProps(__spreadValues({}, u), {
           model,
-          state: initialState,
+          state,
           instance: instance2,
           initialized: true
         }), initializedUpdater);
@@ -76,7 +77,9 @@ function createUpdateFn(updater, middleWare) {
         state,
         model,
         instance,
-        initialized: true
+        initialized: true,
+        cacheFields: {},
+        cacheMethods: {}
       });
     });
   };

package/esm/updater/notifier.js

@@ -17,6 +17,7 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { simpleErrorProcess } from "../tools";
 function defaultNotifyImplement(dispatches, action) {
   dispatches.forEach((callback) => {
     callback(action);
@@ -78,10 +79,8 @@ function generateNotifier(updater, middleWare) {
       call(initializedAction);
     });
   }
-  const { config, model } = updater;
   const dispatch = function dispatch2(action) {
-    const { dispatches, controlled } = updater;
-    const dispatchCallbacks = [...dispatches];
+    const { dispatches, controlled, model, config } = updater;
     const { state } = action;
     const nextInstance = model(state);
     const nextAction = __spreadProps(__spreadValues({}, action), { instance: nextInstance });
@@ -92,11 +91,27 @@ function generateNotifier(updater, middleWare) {
         version: u.version + 1
       }));
     }
+    const notifyAction = function notifyAction2(act) {
+      const errors = [];
+      const dispatchCallbacks = dispatches.map(simpleErrorProcess(errors));
+      defaultNotifyImplement(dispatchCallbacks, act);
+      if (!errors.length) {
+        return { errors: void 0 };
+      }
+      return { errors };
+    };
+    const notifyActionWithErrorThrow = function notifyActionWithErrorThrow2(act) {
+      const { errors } = notifyAction(act);
+      if (!errors || !errors.length) {
+        return;
+      }
+      throw errors[0];
+    };
     try {
-      if (typeof config.batchNotify === "function") {
-        config.batchNotify(dispatchCallbacks, nextAction);
+      if (typeof config.notify === "function") {
+        config.notify(notifyAction, nextAction);
       } else {
-        defaultNotifyImplement(dispatchCallbacks, nextAction);
+        notifyActionWithErrorThrow(nextAction);
       }
     } catch (e) {
       updater.mutate((u) => __spreadProps(__spreadValues({}, u), { dispatching: void 0 }));

package/esm/validation/index.js

@@ -1,4 +1,8 @@
-import { modelKeyIdentifier, modelStoreIdentifier, modelUsageIdentifier } from "../identifiers";
+import {
+  modelKeyIdentifier,
+  modelStoreIdentifier,
+  modelUsageIdentifier
+} from "../identifiers";
 const noStateAModelKey = "no-state-a-model-key";
 function createNoStateModel() {
   return function noStateModel(state) {