as-model 0.1.9 → 0.1.11

package/esm/store/index.js

@@ -1,20 +1,39 @@
-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 { createUpdater } from "../updater";
 import { isModelKey, isModelUsage } from "../validation";
 import { modelKeyIdentifier, modelStoreIdentifier } 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) {
+import {
+  extractInstance,
+  createField as createInstanceField,
+  createMethod as createInstanceMethod
+} from "./instance";
+function createPrimaryKey(modelFn, config = {}) {
+  var _a;
+  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) {
     return i();
   };
-  var wrapModel = function wrapModel2(state) {
+  const wrapModel = function wrapModel2(state) {
     return model(state);
   };
   wrapModel.source = model;
@@ -25,64 +44,61 @@ function createPrimaryKey(modelFn) {
   }
   return wrapModel;
 }
-function createStore(modelLike) {
-  var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-  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;
+function createStore(modelLike, config = {}) {
+  const ifModelKey = isModelKey(modelLike);
+  const model = ifModelKey ? modelLike.source : modelLike;
+  const modelKey = ifModelKey ? modelLike : void 0;
+  const conf = function computeConfig() {
+    const hasConfigState = "state" in config;
+    const hasKeyState = !!modelKey && "defaultState" in modelKey;
     if (hasConfigState) {
       return config;
     }
     if (hasKeyState) {
-      return _object_spread_props(_object_spread({}, config), {
-        state: modelKey === null || modelKey === void 0 ? void 0 : modelKey.defaultState
-      });
+      return __spreadProps(__spreadValues({}, config), { state: modelKey == null ? void 0 : modelKey.defaultState });
     }
     return config;
   }();
-  var combinedMiddleWare = function combinedMiddleWare2(s) {
+  const combinedMiddleWare = function combinedMiddleWare2(s) {
     return function updaterMiddleWare(next) {
-      var middleWares = conf.middleWares;
+      const { middleWares } = conf;
       if (middleWares == null) {
         return next;
       }
-      var updateMiddleWares = _to_consumable_array(middleWares).reverse().map(function(middleWare) {
+      const updateMiddleWares = [...middleWares].reverse().map((middleWare) => {
         return middleWare(s);
       });
-      return updateMiddleWares.reduce(function(finalDispatcher, um) {
+      return updateMiddleWares.reduce((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() {
+  const updater = createUpdater(model, combinedMiddleWare, conf);
+  const key = modelKey != null ? modelKey : createPrimaryKey(model, config);
+  const getInstance = function getInstance2() {
     return extractInstance(updater);
   };
-  var store = {
+  const store = {
     key,
-    subscribe: function subscribe(dispatcher) {
-      var _updater_createTunnel = updater.createTunnel(dispatcher), connect = _updater_createTunnel.connect, disconnect = _updater_createTunnel.disconnect;
+    subscribe(dispatcher) {
+      const { connect, disconnect } = updater.createTunnel(dispatcher);
       connect();
       return disconnect;
     },
     getInstance,
-    update: function update(args) {
+    update(args) {
       updater.update(args);
     },
-    destroy: function destroy() {
+    destroy() {
       updater.destroy();
     },
-    payload: function payload(callback) {
+    payload(callback) {
       return updater.payload(callback);
     },
-    isDestroyed: function isDestroyed() {
+    isDestroyed() {
       return updater.isDestroyed;
     },
-    extends: function _extends(e) {
+    extends(e) {
       return Object.assign(store, e);
     },
     updater,
@@ -90,8 +106,8 @@ function createStore(modelLike) {
   };
   return store;
 }
-var createField = createInstanceField;
-var createMethod = createInstanceMethod;
+const createField = createInstanceField;
+const createMethod = createInstanceMethod;
 import { createSignal, createSelector } from "./enhance";
 export {
   createField,

package/esm/store/instance.js

@@ -1,81 +1,71 @@
-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";
-var cacheIdentify = {
-  field: function field(d) {
+const cacheIdentify = {
+  field(d) {
     if (!d) {
       return false;
     }
-    var f = d;
+    const f = d;
     return f.identifier === cacheIdentify.field;
   },
-  method: function method(d) {
+  method(d) {
     if (typeof d !== "function") {
       return false;
     }
-    var m = d;
+    const m = d;
     return m.identifier === cacheIdentify.method;
   }
 };
 function createField(callback, deps) {
-  var currentDeps = function computeDeps() {
+  const currentDeps = function computeDeps() {
     if (deps == null) {
       return deps;
     }
-    if (deps.some(function(d) {
-      return cacheIdentify.field(d) && d.deps == null;
-    })) {
+    if (deps.some((d) => cacheIdentify.field(d) && d.deps == null)) {
       return void 0;
     }
-    return deps.flatMap(function(d) {
+    return deps.flatMap((d) => {
       if (cacheIdentify.field(d)) {
         return d.deps;
       }
       return d;
     });
   }();
-  var value = callback();
+  const value = callback();
   return {
     callback,
     deps: currentDeps,
     identifier: cacheIdentify.field,
     value,
-    get: function get() {
+    get() {
       return value;
     }
   };
 }
-function createMethod(method2) {
-  var replace = function replace2() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return method2.apply(void 0, _to_consumable_array(args));
+function createMethod(method) {
+  const replace = function replace2(...args) {
+    return method(...args);
   };
-  Object.assign(replace, method2());
+  Object.assign(replace, method());
   replace.identifier = cacheIdentify.method;
   return replace;
 }
 function wrapToActionMethod(updater, methodName) {
-  var cacheMethods = updater.cacheMethods;
-  var cachedMethod = cacheMethods[methodName];
+  const { cacheMethods } = updater;
+  const 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 instance = updater.instance;
-    var method2 = instance[methodName];
-    if (typeof method2 !== "function") {
+  const actionMethod = function actionMethod2(...args) {
+    const { instance } = updater;
+    const method = instance[methodName];
+    if (typeof method !== "function") {
       throw new Error("Can not change methods in runtime.");
     }
-    if (cacheIdentify.method(method2)) {
-      return method2.apply(void 0, _to_consumable_array(args));
+    if (cacheIdentify.method(method)) {
+      return method(...args);
     }
-    var state = method2.apply(void 0, _to_consumable_array(args));
-    var action = {
+    const state = method(...args);
+    const action = {
       type: methodName,
       state,
       prevState: updater.state,
@@ -90,26 +80,26 @@ function wrapToActionMethod(updater, methodName) {
   return actionMethod;
 }
 function wrapToField(updater, propertyName, value, onGot) {
-  var cacheFields = updater.cacheFields;
+  const { cacheFields } = updater;
   if (!cacheIdentify.field(value)) {
     if (onGot) {
       onGot(propertyName, value);
     }
     return value;
   }
-  var field2 = value;
-  var cachedField = cacheFields[propertyName];
+  const field = value;
+  const cachedField = cacheFields[propertyName];
   if (cachedField) {
     return cachedField.getter;
   }
-  var getter = {
-    get: function get() {
-      var currentField = updater.instance[propertyName];
+  const getter = {
+    get() {
+      const currentField = updater.instance[propertyName];
       if (!cacheIdentify.field(currentField)) {
         throw new Error("Field should always be field.");
       }
-      var current = currentField.get();
-      var fieldInCache = updater.cacheFields[propertyName];
+      const current = currentField.get();
+      const fieldInCache = updater.cacheFields[propertyName];
       if (!currentField.deps || fieldInCache == null) {
         cacheFields[propertyName] = {
           getter,
@@ -129,37 +119,33 @@ function wrapToField(updater, propertyName, value, onGot) {
       return current;
     }
   };
-  cacheFields[propertyName] = {
-    getter,
-    value: field2.value,
-    deps: field2.deps
-  };
+  cacheFields[propertyName] = { getter, value: field.value, deps: field.deps };
   return getter;
 }
 function extractInstance(updater, onGet) {
-  var instance = updater.instance;
-  if ((typeof instance === "undefined" ? "undefined" : _type_of(instance)) !== "object" || !instance) {
+  const { instance } = updater;
+  if (typeof instance !== "object" || !instance) {
     throw new Error("The instance should be an object or array.");
   }
-  var properties = Object.getOwnPropertyNames(instance);
-  var handleGetter = function handleGetter2(key, value) {
+  const properties = Object.getOwnPropertyNames(instance);
+  const handleGetter = function handleGetter2(key, value) {
     if (!onGet) {
       return;
     }
     onGet(key, value);
   };
   return createProxy(instance, {
-    get: function get(target, p) {
-      var value = target[p];
+    get(target, p) {
+      const value = target[p];
       if (typeof value === "function" && properties.indexOf(p) >= 0) {
-        var actionMethod = wrapToActionMethod(updater, p);
+        const actionMethod = wrapToActionMethod(updater, p);
         Object.assign(actionMethod, value);
         handleGetter(p, actionMethod);
         return actionMethod;
       }
       return wrapToField(updater, p, value, handleGetter);
     },
-    set: function set() {
+    set() {
       return false;
     }
   });

package/esm/tools/proxy.js

@@ -1,37 +1,57 @@
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+var __defProp = Object.defineProperty;
+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;
+};
 function getDescriptors(target, receiver, ownOrPrototype, handler) {
-  var it = Object.keys(ownOrPrototype);
-  var result = {};
-  it.forEach(function(key) {
+  const it = Object.keys(ownOrPrototype);
+  const result = {};
+  it.forEach((key) => {
     result[key] = {
-      get: function() {
+      get: () => {
         if (!handler.get) {
           return target[key];
         }
         return handler.get(target, key, receiver);
       },
-      set: function(v) {
+      set: (v) => {
         if (!handler.set) {
           target[key] = v;
           return;
         }
-        var valid = handler.set(target, key, v, receiver);
+        const valid = handler.set(target, key, v, receiver);
         if (!valid) {
-          throw new Error("".concat(key, " in proxy target is not mutable"));
+          throw new Error(`${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));
+const createSimpleProxy = (target, handler) => {
+  const proxy = {};
+  const own = getDescriptors(target, proxy, target, handler);
+  const prototype = getDescriptors(
+    target,
+    proxy,
+    Object.getPrototypeOf(target),
+    handler
+  );
+  Object.defineProperties(proxy, __spreadValues(__spreadValues({}, prototype), own));
   return proxy;
 };
-var createProxy = function(target, handler) {
+const createProxy = (target, handler) => {
   if (typeof Proxy !== "function") {
     return createSimpleProxy(target, handler);
   }

package/esm/tools/shallowEqual.js

@@ -1,6 +1,5 @@
-import { _ as _type_of } from "@swc/helpers/_/_type_of";
 function isObject(data) {
-  return data && (typeof data === "undefined" ? "undefined" : _type_of(data)) === "object";
+  return data && typeof data === "object";
 }
 function shallowEqual(prev, current) {
   if (Object.is(prev, current)) {
@@ -9,22 +8,22 @@ function shallowEqual(prev, current) {
   if (!isObject(prev) || !isObject(current)) {
     return false;
   }
-  var prevKeys = Object.keys(prev);
-  var currentKeys = Object.keys(current);
+  const prevKeys = Object.keys(prev);
+  const 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);
-  });
+  const pre = prev;
+  const curr = current;
+  const hasDiffKey = prevKeys.some(
+    (key) => !Object.prototype.hasOwnProperty.call(curr, key)
+  );
   if (hasDiffKey) {
     return false;
   }
-  var hasDiffValue = currentKeys.some(function(key) {
-    var currentValue = curr[key];
-    var prevValue = pre[key];
+  const hasDiffValue = currentKeys.some((key) => {
+    const currentValue = curr[key];
+    const prevValue = pre[key];
     return !Object.is(currentValue, prevValue);
   });
   return !hasDiffValue;

package/esm/updater/index.js

@@ -1,30 +1,46 @@
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+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 { createNoStateModel } from "../validation";
 import { generateNotifier } from "./notifier";
-import { generateTunnelCreator, createUnInitializedUpdater, destroy } from "./tunnel";
+import {
+  generateTunnelCreator,
+  createUnInitializedUpdater,
+  destroy
+} from "./tunnel";
 function createInitializedUpdater(updater, middleWare) {
-  var createTunnel = generateTunnelCreator(updater);
+  const createTunnel = generateTunnelCreator(updater);
   return {
     notify: generateNotifier(updater, middleWare),
     createTunnel
   };
 }
 function createUpdateFn(updater, middleWare) {
-  return function update() {
-    var args = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    updater.mutate(function(u, effect) {
-      var _args_model;
-      var model = (_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;
+  return function update(args = {}) {
+    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) {
-        var instance = model(state);
-        return _object_spread_props(_object_spread({}, u), {
-          state,
-          instance,
-          model
-        });
+        const instance2 = model(state);
+        return __spreadProps(__spreadValues({}, u), { state, instance: instance2, model });
       }
       if (u.isDestroyed) {
         return u;
@@ -33,46 +49,45 @@ function createUpdateFn(updater, middleWare) {
         throw new Error("Should update initialState first.");
       }
       if (!u.initialized) {
-        var instance1 = model(initialState);
-        var initializedUpdater = createInitializedUpdater(u, middleWare);
-        return _object_spread(_object_spread_props(_object_spread({}, u), {
+        const instance2 = model(initialState);
+        const initializedUpdater = createInitializedUpdater(u, middleWare);
+        return __spreadValues(__spreadProps(__spreadValues({}, u), {
           model,
           state: initialState,
-          instance: instance1,
+          instance: instance2,
           initialized: true
         }), initializedUpdater);
       }
       if (Object.is(u.model, model) && Object.is(u.state, state)) {
         return u;
       }
-      var instance2 = model(state);
-      effect(function(up) {
+      const instance = model(state);
+      effect((up) => {
         up.notify({
           type: null,
           method: null,
           prevInstance: u.instance,
-          instance: instance2,
+          instance,
           prevState: u.state,
           state
         });
       });
-      return _object_spread_props(_object_spread({}, u), {
+      return __spreadProps(__spreadValues({}, u), {
         state,
         model,
-        instance: instance2,
+        instance,
         initialized: true
       });
     });
   };
 }
-var lazyModel = createNoStateModel();
-function createUpdater(model, middleWare) {
-  var config = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-  var hasDefaultState = "state" in config;
-  var controlled = config.controlled, defaultState = config.state;
-  var defaultInstance = hasDefaultState ? model(defaultState) : lazyModel(void 0);
-  var unInitializedUpdater = createUnInitializedUpdater();
-  var updater = _object_spread({
+const lazyModel = createNoStateModel();
+function createUpdater(model, middleWare, config = {}) {
+  const hasDefaultState = "state" in config;
+  const { controlled, state: defaultState } = config;
+  const defaultInstance = hasDefaultState ? model(defaultState) : lazyModel(void 0);
+  const unInitializedUpdater = createUnInitializedUpdater();
+  const updater = __spreadValues({
     sidePayload: void 0,
     version: 0,
     isDestroyed: false,
@@ -88,22 +103,21 @@ function createUpdater(model, middleWare) {
     controlled: !!controlled,
     isSubscribing: false,
     config,
-    payload: function payload(setter) {
+    payload(setter) {
       if (typeof setter === "function") {
         updater.sidePayload = setter(updater.sidePayload);
       }
       return updater.sidePayload;
     },
-    mutate: function mutate(callback) {
-      var effects = [];
-      var runEffects = function runEffects2(u) {
-        effects.forEach(function(e) {
-          return e(u);
-        });
+    mutate(callback) {
+      const effects = [];
+      const runEffects = function runEffects2(u) {
+        effects.forEach((e) => e(u));
       };
-      var result = callback(updater, function(effectFn) {
-        return effects.push(effectFn);
-      });
+      const result = callback(
+        updater,
+        (effectFn) => effects.push(effectFn)
+      );
       if (updater === result) {
         runEffects(result);
         return updater;
@@ -112,13 +126,13 @@ function createUpdater(model, middleWare) {
       runEffects(updater);
       return updater;
     },
-    update: function(args) {
+    update: (args) => {
     },
-    destroy: function destroy1() {
+    destroy() {
       destroy(updater);
     }
   }, unInitializedUpdater);
-  var initialized = createInitializedUpdater(updater, middleWare);
+  const initialized = createInitializedUpdater(updater, middleWare);
   Object.assign(updater, initialized, {
     update: createUpdateFn(updater, middleWare)
   });