as-model 0.1.17 → 0.1.19

package/dist/index.js

@@ -141,6 +141,9 @@
   function modelStoreIdentifier() {
     return true;
   }
+  function tokenIdentifier() {
+    return true;
+  }
 
   // src/validation/index.ts
   var noStateAModelKey = "no-state-a-model-key";
@@ -177,13 +180,124 @@
     }
     return data.modelStoreIdentifier === modelStoreIdentifier && data.modelStoreIdentifier();
   }
+  function isToken(data) {
+    if (!data) {
+      return false;
+    }
+    return data.tokenIdentifier === tokenIdentifier && data.tokenIdentifier();
+  }
   var validations = {
     isInstanceFromNoStateModel,
     isModelKey,
     isModelStore,
-    isModelUsage
+    isModelUsage,
+    isToken
+  };
+
+  // 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/token.ts
+  function createToken() {
+    var value = {};
+    return {
+      isDifferent: function isDifferent(token) {
+        if (!isToken(token)) {
+          return true;
+        }
+        return token.value !== value;
+      },
+      value
+    };
+  }
+
   // src/updater/notifier.ts
   function defaultNotifyImplement(dispatches, action) {
     dispatches.forEach(function(callback) {
@@ -261,7 +375,6 @@
     }
     var dispatch = function dispatch2(action) {
       var dispatches = updater.dispatches, controlled = updater.controlled, model2 = updater.model, config2 = updater.config;
-      var dispatchCallbacks = _to_consumable_array(dispatches);
       var state = action.state;
       var nextInstance = model2(state);
       var nextAction = _object_spread_props(_object_spread({}, action), {
@@ -272,15 +385,36 @@
           return _object_spread_props(_object_spread({}, u), {
             state,
             instance: nextInstance,
-            version: u.version + 1
+            version: u.version + 1,
+            token: createToken()
           });
         });
       }
+      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) {
@@ -325,82 +459,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 {
@@ -546,8 +604,8 @@
       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;
+        var token = createToken();
         if (u.controlled) {
           var instance = model2(state);
           return _object_spread_props(_object_spread({}, u), {
@@ -559,17 +617,18 @@
         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
+            initialized: true,
+            token
           }), initializedUpdater);
         }
         if (Object.is(u.model, model2) && Object.is(u.state, state)) {
@@ -590,6 +649,7 @@
           state,
           model: model2,
           instance: instance2,
+          token,
           initialized: true,
           cacheFields: {},
           cacheMethods: {}
@@ -607,6 +667,7 @@
     var updater = _object_spread({
       sidePayload: void 0,
       version: 0,
+      token: createToken(),
       isDestroyed: false,
       model: model2,
       instance: defaultInstance,
@@ -863,6 +924,9 @@
     var storeKey = store.key;
     return {
       key: storeKey,
+      getToken: function getToken() {
+        return store.getToken();
+      },
       subscribe: function subscribe(dispatcher) {
         return store.subscribe(enhance(dispatcher));
       },
@@ -1053,6 +1117,9 @@
     }
     return {
       key: store.key,
+      getToken: function getToken() {
+        return store.getToken();
+      },
       subscribe: function subscribe(dispatcher) {
         return store.subscribe(enhance(dispatcher));
       },
@@ -1120,6 +1187,9 @@
     };
     var store = {
       key,
+      getToken: function getToken() {
+        return updater.token;
+      },
       subscribe: function subscribe(dispatcher) {
         var _updater_createTunnel = updater.createTunnel(dispatcher), connect = _updater_createTunnel.connect, disconnect = _updater_createTunnel.disconnect;
         connect();

package/esm/identifiers/index.js

@@ -7,8 +7,12 @@ function modelUsageIdentifier() {
 function modelStoreIdentifier() {
   return true;
 }
+function tokenIdentifier() {
+  return true;
+}
 export {
   modelKeyIdentifier,
   modelStoreIdentifier,
-  modelUsageIdentifier
+  modelUsageIdentifier,
+  tokenIdentifier
 };

package/esm/store/enhance/selector.js

@@ -150,6 +150,9 @@ function createSelector(store, opts) {
   }
   return {
     key: store.key,
+    getToken() {
+      return store.getToken();
+    },
     subscribe(dispatcher) {
       return store.subscribe(enhance(dispatcher));
     },

package/esm/store/enhance/signal.js

@@ -35,6 +35,9 @@ function createSignal(store) {
   const { key: storeKey } = store;
   return {
     key: storeKey,
+    getToken() {
+      return store.getToken();
+    },
     subscribe(dispatcher) {
       return store.subscribe(enhance(dispatcher));
     },

package/esm/store/index.js

@@ -92,6 +92,9 @@ function createStore(modelLike, config = {}) {
   };
   const store = {
     key,
+    getToken() {
+      return updater.token;
+    },
     subscribe(dispatcher) {
       const { connect, disconnect } = updater.createTunnel(dispatcher);
       connect();

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

@@ -24,6 +24,7 @@ import {
   createUnInitializedUpdater,
   destroy
 } from "./tunnel";
+import { createToken } from "./token";
 function createInitializedUpdater(updater, middleWare) {
   const createTunnel = generateTunnelCreator(updater);
   return {
@@ -36,8 +37,8 @@ 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;
+      const token = createToken();
       if (u.controlled) {
         const instance2 = model(state);
         return __spreadProps(__spreadValues({}, u), { state, instance: instance2, model });
@@ -45,17 +46,20 @@ 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
+          initialized: true,
+          token
         }), initializedUpdater);
       }
       if (Object.is(u.model, model) && Object.is(u.state, state)) {
@@ -76,6 +80,7 @@ function createUpdateFn(updater, middleWare) {
         state,
         model,
         instance,
+        token,
         initialized: true,
         cacheFields: {},
         cacheMethods: {}
@@ -92,6 +97,7 @@ function createUpdater(model, middleWare, config = {}) {
   const updater = __spreadValues({
     sidePayload: void 0,
     version: 0,
+    token: createToken(),
     isDestroyed: false,
     model,
     instance: defaultInstance,

package/esm/updater/notifier.js

@@ -17,6 +17,8 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { simpleErrorProcess } from "../tools";
+import { createToken } from "./token";
 function defaultNotifyImplement(dispatches, action) {
   dispatches.forEach((callback) => {
     callback(action);
@@ -80,7 +82,6 @@ function generateNotifier(updater, middleWare) {
   }
   const dispatch = function dispatch2(action) {
     const { dispatches, controlled, model, config } = updater;
-    const dispatchCallbacks = [...dispatches];
     const { state } = action;
     const nextInstance = model(state);
     const nextAction = __spreadProps(__spreadValues({}, action), { instance: nextInstance });
@@ -88,14 +89,31 @@ function generateNotifier(updater, middleWare) {
       updater.mutate((u) => __spreadProps(__spreadValues({}, u), {
         state,
         instance: nextInstance,
-        version: u.version + 1
+        version: u.version + 1,
+        token: createToken()
       }));
     }
+    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/updater/token.js

@@ -0,0 +1,16 @@
+import { isToken } from "../validation";
+function createToken() {
+  const value = {};
+  return {
+    isDifferent(token) {
+      if (!isToken(token)) {
+        return true;
+      }
+      return token.value !== value;
+    },
+    value
+  };
+}
+export {
+  createToken
+};

package/esm/validation/index.js

@@ -1,7 +1,8 @@
 import {
   modelKeyIdentifier,
   modelStoreIdentifier,
-  modelUsageIdentifier
+  modelUsageIdentifier,
+  tokenIdentifier
 } from "../identifiers";
 const noStateAModelKey = "no-state-a-model-key";
 function createNoStateModel() {
@@ -39,16 +40,24 @@ function isModelStore(data) {
   }
   return data.modelStoreIdentifier === modelStoreIdentifier && data.modelStoreIdentifier();
 }
+function isToken(data) {
+  if (!data) {
+    return false;
+  }
+  return data.tokenIdentifier === tokenIdentifier && data.tokenIdentifier();
+}
 const validations = {
   isInstanceFromNoStateModel,
   isModelKey,
   isModelStore,
-  isModelUsage
+  isModelUsage,
+  isToken
 };
 export {
   createNoStateModel,
   isModelKey,
   isModelStore,
   isModelUsage,
+  isToken,
   validations
 };

package/index.d.ts

@@ -3,7 +3,7 @@ declare interface ModelInstance {
   [key: number]: any;
 }
 
-declare type FieldStructure<R = any> = {
+export declare type FieldStructure<R = any> = {
   callback: () => R;
   deps: any[] | undefined;
   identifier: (d: any) => d is FieldStructure<R>;
@@ -11,7 +11,7 @@ declare type FieldStructure<R = any> = {
   get: () => R;
 };
 
-declare type MethodStructure<
+export declare type MethodStructure<
   R extends (...args: any[]) => any = (...args: any[]) => any
 > = R & {
   identifier: (d: any) => d is MethodStructure;
@@ -41,7 +41,12 @@ export declare type Action<S = any, T extends ModelInstance = ModelInstance> = {
   prevInstance?: T;
 };
 
-declare type Dispatch = (action: Action) => any;
+export interface Token {
+  isDifferent: (token: Token) => boolean;
+  value: unknown;
+}
+
+export declare type Dispatch = (action: Action) => any;
 
 export declare interface Key<
   S = any,
@@ -71,10 +76,10 @@ export declare type MiddleWare = (
 export declare interface Config {
   middleWares?: MiddleWare[];
   controlled?: boolean;
-  batchNotify?: (
-    listeners: ((action: Action) => void)[],
+  notify?: (
+    notifier: (action: Action) => { errors: any[] | undefined },
     action: Action
-  ) => void;
+  ) => any;
 }
 
 /** createStore * */
@@ -93,6 +98,7 @@ export declare interface Store<
   R extends (instance: () => T) => any = (instance: () => T) => T
 > extends StoreIndex<S, T, R> {
   subscribe: (dispatcher: Dispatch) => () => void;
+  getToken: () => Token;
   getInstance: () => T;
   update: (args?: { model?: Model<S, T>; initialState?: S; state?: S }) => void;
   destroy: () => void;
@@ -195,6 +201,7 @@ declare interface SignalStore<
   T extends ModelInstance = any,
   R extends (instance: () => T) => any = (instance: () => T) => any
 > extends StoreIndex<S, T, R> {
+  getToken: () => Token;
   subscribe: (dispatcher: Dispatch) => () => void;
   getSignal: () => {
     (): T;
@@ -230,6 +237,7 @@ declare interface SelectorStore<
   T extends ModelInstance = any,
   R extends (instance: () => T) => any = (instance: () => T) => any
 > extends StoreIndex<S, T, R> {
+  getToken: () => Token;
   subscribe: (dispatcher: Dispatch) => () => void;
   select: SelectMethod<T, R>;
 }

package/package.json

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