as-model 0.1.9 → 0.1.11

package/esm/updater/notifier.js

@@ -1,69 +1,72 @@
-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";
+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]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 function defaultNotifyImplement(dispatches, action) {
-  dispatches.forEach(function(callback) {
+  dispatches.forEach((callback) => {
     callback(action);
   });
 }
 function generateNotifier(updater, middleWare) {
   function pendAction(value) {
-    updater.mutate(function(u) {
-      var dispatching = u.dispatching;
+    updater.mutate((u) => {
+      const { dispatching } = u;
       if (!dispatching) {
-        var wrap = {
-          value
-        };
+        const wrap = { value };
         wrap.tail = wrap;
-        return _object_spread_props(_object_spread({}, u), {
-          dispatching: wrap
-        });
+        return __spreadProps(__spreadValues({}, u), { dispatching: wrap });
       }
-      var tail = dispatching.tail;
+      const { tail } = dispatching;
       if (!tail) {
         return u;
       }
-      var current = {
-        prev: tail,
-        value
-      };
+      const current = { prev: tail, value };
       tail.next = current;
       dispatching.tail = current;
-      return _object_spread_props(_object_spread({}, u), {
-        dispatching
-      });
+      return __spreadProps(__spreadValues({}, u), { dispatching });
     });
   }
   function unshiftAction() {
-    return updater.mutate(function(u) {
-      var dispatching = updater.dispatching;
+    return updater.mutate((u) => {
+      const { dispatching } = updater;
       if (!dispatching) {
         return u;
       }
-      var next = dispatching.next, tail = dispatching.tail;
+      const { next, tail } = dispatching;
       if (tail === dispatching || !next) {
         dispatching.tail = void 0;
-        return _object_spread_props(_object_spread({}, u), {
-          dispatching: void 0
-        });
+        return __spreadProps(__spreadValues({}, u), { dispatching: void 0 });
       }
       next.prev = void 0;
-      var newFirst = next;
+      const newFirst = next;
       newFirst.tail = tail;
-      return _object_spread_props(_object_spread({}, u), {
-        dispatching: newFirst
-      });
+      return __spreadProps(__spreadValues({}, u), { dispatching: newFirst });
     }).dispatching;
   }
   function consumeTemporaries() {
-    var temporaryDispatches = updater.temporaryDispatches;
-    updater.mutate(function(u) {
-      return u.temporaryDispatches.length ? _object_spread_props(_object_spread({}, u), {
-        dispatches: _to_consumable_array(u.dispatches).concat(_to_consumable_array(u.temporaryDispatches)),
+    const { temporaryDispatches } = updater;
+    updater.mutate(
+      (u) => u.temporaryDispatches.length ? __spreadProps(__spreadValues({}, u), {
+        dispatches: [...u.dispatches, ...u.temporaryDispatches],
         temporaryDispatches: []
-      }) : u;
-    });
-    var initializedAction = {
+      }) : u
+    );
+    const initializedAction = {
       state: updater.state,
       prevState: updater.state,
       instance: updater.instance,
@@ -71,27 +74,23 @@ function generateNotifier(updater, middleWare) {
       type: null,
       method: null
     };
-    temporaryDispatches.forEach(function(call) {
+    temporaryDispatches.forEach((call) => {
       call(initializedAction);
     });
   }
-  var config = updater.config, model = updater.model;
-  var dispatch = function dispatch2(action) {
-    var dispatches = updater.dispatches, controlled = updater.controlled;
-    var dispatchCallbacks = _to_consumable_array(dispatches);
-    var state = action.state;
-    var nextInstance = model(state);
-    var nextAction = _object_spread_props(_object_spread({}, action), {
-      instance: nextInstance
-    });
+  const { config, model } = updater;
+  const dispatch = function dispatch2(action) {
+    const { dispatches, controlled } = updater;
+    const dispatchCallbacks = [...dispatches];
+    const { state } = action;
+    const nextInstance = model(state);
+    const nextAction = __spreadProps(__spreadValues({}, action), { instance: nextInstance });
     if (!controlled) {
-      updater.mutate(function(u) {
-        return _object_spread_props(_object_spread({}, u), {
-          state,
-          instance: nextInstance,
-          version: u.version + 1
-        });
-      });
+      updater.mutate((u) => __spreadProps(__spreadValues({}, u), {
+        state,
+        instance: nextInstance,
+        version: u.version + 1
+      }));
     }
     try {
       if (typeof config.batchNotify === "function") {
@@ -100,11 +99,7 @@ function generateNotifier(updater, middleWare) {
         defaultNotifyImplement(dispatchCallbacks, nextAction);
       }
     } catch (e) {
-      updater.mutate(function(u) {
-        return _object_spread_props(_object_spread({}, u), {
-          dispatching: void 0
-        });
-      });
+      updater.mutate((u) => __spreadProps(__spreadValues({}, u), { dispatching: void 0 }));
       throw e;
     }
   };
@@ -112,30 +107,23 @@ function generateNotifier(updater, middleWare) {
     if (action == null || updater.isDestroyed) {
       return;
     }
-    var dispatching = updater.dispatching;
+    const { dispatching } = updater;
     pendAction(action);
     if (dispatching) {
       return;
     }
     while (updater.dispatching) {
-      var wrap = updater.dispatching;
+      const wrap = updater.dispatching;
       if (wrap) {
         middleWare({
-          getState: function getState() {
-            return {
-              state: updater.state,
-              instance: updater.instance
-            };
+          getState() {
+            return { state: updater.state, instance: updater.instance };
           },
           dispatch: notify
         })(dispatch)(wrap.value);
         unshiftAction();
       } else {
-        updater.mutate(function(u) {
-          return _object_spread_props(_object_spread({}, u), {
-            dispatching: void 0
-          });
-        });
+        updater.mutate((u) => __spreadProps(__spreadValues({}, u), { dispatching: void 0 }));
       }
     }
     consumeTemporaries();

package/esm/updater/tunnel.js

@@ -1,29 +1,43 @@
-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";
+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]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { noop } from "../tools";
 function createUnInitializedUpdater() {
   return {
-    notify: function(a) {
+    notify: (a) => {
     },
-    createTunnel: function(dispatcher) {
-      return {
-        connect: noop,
-        disconnect: noop
-      };
-    }
+    createTunnel: (dispatcher) => ({
+      connect: noop,
+      disconnect: noop
+    })
   };
 }
 function destroy(updater) {
   function destroyDispatching() {
-    updater.mutate(function(u) {
-      var dispatching = u.dispatching;
+    updater.mutate((u) => {
+      const { dispatching } = u;
       if (!dispatching) {
         return u;
       }
-      var wrapper = dispatching;
+      let wrapper = dispatching;
       while (wrapper) {
-        var next = wrapper.next;
+        const { next } = wrapper;
         wrapper.next = void 0;
         wrapper.prev = void 0;
         if (next) {
@@ -32,58 +46,46 @@ function destroy(updater) {
         wrapper = next;
       }
       dispatching.tail = void 0;
-      return _object_spread_props(_object_spread({}, u), {
-        dispatching: void 0,
-        initialized: false
-      });
+      return __spreadProps(__spreadValues({}, u), { dispatching: void 0, initialized: false });
     });
   }
-  updater.mutate(function(u, effect) {
-    var destroyed = createUnInitializedUpdater();
-    effect(function() {
+  updater.mutate((u, effect) => {
+    const destroyed = createUnInitializedUpdater();
+    effect(() => {
       destroyDispatching();
     });
-    return _object_spread_props(_object_spread({}, u, destroyed), {
-      sidePayload: void 0,
-      isDestroyed: true
-    });
+    return __spreadProps(__spreadValues(__spreadValues({}, u), destroyed), { sidePayload: void 0, isDestroyed: true });
   });
 }
 function generateTunnelCreator(updater) {
   function subscribe(dispatchFn) {
-    var dispatches = updater.dispatches, temporaryDispatches = updater.temporaryDispatches, isControlled = updater.controlled;
-    var copied = _to_consumable_array(dispatches).concat(_to_consumable_array(temporaryDispatches));
-    var exist = copied.indexOf(dispatchFn) >= 0;
+    const {
+      dispatches,
+      temporaryDispatches,
+      controlled: isControlled
+    } = updater;
+    const copied = [...dispatches, ...temporaryDispatches];
+    const exist = copied.indexOf(dispatchFn) >= 0;
     if (exist) {
-      return updater.mutate(function(u) {
-        return _object_spread_props(_object_spread({}, u), {
-          isDestroyed: false
-        });
-      });
+      return updater.mutate((u) => __spreadProps(__spreadValues({}, u), { isDestroyed: false }));
     }
     if (isControlled) {
-      return updater.mutate(function(u) {
-        return _object_spread_props(_object_spread({}, u), {
-          dispatches: [
-            dispatchFn
-          ],
-          isDestroyed: false
-        });
-      });
+      return updater.mutate((u) => __spreadProps(__spreadValues({}, u), {
+        dispatches: [dispatchFn],
+        isDestroyed: false
+      }));
     }
-    return updater.mutate(function(u, effect) {
-      var tds = u.temporaryDispatches, ds = u.dispatches;
-      var nextTds = _to_consumable_array(tds).concat([
-        dispatchFn
-      ]);
+    return updater.mutate((u, effect) => {
+      const { temporaryDispatches: tds, dispatches: ds } = u;
+      const nextTds = [...tds, dispatchFn];
       if (u.dispatching) {
-        return _object_spread_props(_object_spread({}, u), {
+        return __spreadProps(__spreadValues({}, u), {
           temporaryDispatches: nextTds,
           isDestroyed: false
         });
       }
-      effect(function(up) {
-        var initializedAction = {
+      effect((up) => {
+        const initializedAction = {
           state: up.state,
           prevState: up.state,
           instance: up.instance,
@@ -91,41 +93,37 @@ function generateTunnelCreator(updater) {
           type: null,
           method: null
         };
-        nextTds.forEach(function(td) {
+        nextTds.forEach((td) => {
           td(initializedAction);
         });
       });
-      return _object_spread_props(_object_spread({}, u), {
+      return __spreadProps(__spreadValues({}, u), {
         temporaryDispatches: [],
-        dispatches: _to_consumable_array(ds).concat(_to_consumable_array(nextTds)),
+        dispatches: [...ds, ...nextTds],
         isDestroyed: false
       });
     });
   }
   return function tunnel(dispatcher) {
     function disconnect() {
-      updater.mutate(function(u) {
-        var ds = u.dispatches, tds = u.temporaryDispatches;
-        var nextDs = ds.filter(function(d) {
-          return d !== dispatcher;
-        });
-        var nextTds = tds.filter(function(d) {
-          return d !== dispatcher;
-        });
+      updater.mutate((u) => {
+        const { dispatches: ds, temporaryDispatches: tds } = u;
+        const nextDs = ds.filter((d) => d !== dispatcher);
+        const nextTds = tds.filter((d) => d !== dispatcher);
         if (ds.length === nextDs.length && tds.length === nextTds.length) {
           return u;
         }
-        return _object_spread_props(_object_spread({}, u), {
+        return __spreadProps(__spreadValues({}, u), {
           dispatches: nextDs,
           temporaryDispatches: nextTds
         });
       });
     }
     return {
-      connect: function connect() {
+      connect() {
         subscribe(dispatcher);
       },
-      disconnect: function disconnect1() {
+      disconnect() {
         disconnect();
       }
     };

package/esm/validation/index.js

@@ -1,20 +1,20 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { _ as _type_of } from "@swc/helpers/_/_type_of";
 import { modelKeyIdentifier, modelStoreIdentifier, modelUsageIdentifier } from "../identifiers";
-var noStateAModelKey = "no-state-a-model-key";
+const noStateAModelKey = "no-state-a-model-key";
 function createNoStateModel() {
   return function noStateModel(state) {
-    return _define_property({}, noStateAModelKey, true);
+    return {
+      [noStateAModelKey]: true
+    };
   };
 }
 function isInstanceFromNoStateModel(instance) {
   if (instance == null) {
     return false;
   }
-  if ((typeof instance === "undefined" ? "undefined" : _type_of(instance)) !== "object") {
+  if (typeof instance !== "object") {
     return false;
   }
-  var ins = instance;
+  const ins = instance;
   return !!ins[noStateAModelKey];
 }
 function isModelKey(data) {
@@ -35,7 +35,7 @@ function isModelStore(data) {
   }
   return data.modelStoreIdentifier === modelStoreIdentifier && data.modelStoreIdentifier();
 }
-var validations = {
+const validations = {
   isInstanceFromNoStateModel,
   isModelKey,
   isModelStore,

package/index.d.ts

@@ -199,9 +199,7 @@ declare interface SignalStore<
     startStatistics: () => void;
     stopStatistics: () => void;
     subscribe: (dispatcher: Dispatch) => () => void;
-    payload: <P>(
-      callback?: (payload: P | undefined) => P | undefined
-    ) => P | undefined;
+    store: Store<S, T, R>;
   };
 }
 

package/package.json

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

package/esm/tools.js

@@ -1,78 +0,0 @@
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _type_of } from "@swc/helpers/_/_type_of";
-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);
-};
-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;
-}
-function noop() {
-}
-export {
-  createProxy,
-  createSimpleProxy,
-  noop,
-  shallowEqual
-};