as-model 0.0.1

package/esm/index.js

@@ -0,0 +1,49 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { createStore as cs } from "./store";
+import { createKey as ck, createStores as css } from "./key";
+import { configModel } from "./model";
+function config() {
+  var configuration = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var createStore2 = function createStore3(modelLike, state) {
+    return cs(modelLike, arguments.length > 1 ? _object_spread_props(_object_spread({}, configuration), {
+      state
+    }) : configuration);
+  };
+  var createKey2 = function createKey3(model3, state) {
+    var isKeySetState = arguments.length > 1;
+    var key = ck(model3, isKeySetState ? _object_spread_props(_object_spread({}, configuration), {
+      state
+    }) : configuration);
+    key.createStore = function createKeyStore(s) {
+      return arguments.length > 0 ? createStore2(key, s) : createStore2(key);
+    };
+    return key;
+  };
+  createKey2.isModelKey = ck.isModelKey;
+  var createStores2 = function createStores3() {
+    for (var _len = arguments.length, modelKeys = new Array(_len), _key = 0; _key < _len; _key++) {
+      modelKeys[_key] = arguments[_key];
+    }
+    return css(modelKeys, configuration);
+  };
+  var model2 = configModel(configuration);
+  return {
+    createStore: createStore2,
+    createKey: createKey2,
+    createStores: createStores2,
+    model: model2
+  };
+}
+var _config = config(), createStore = _config.createStore, createKey = _config.createKey, createStores = _config.createStores, model = _config.model;
+import { createSignal } from "./store";
+import { validations } from "./validation";
+export {
+  config,
+  createKey,
+  createSignal,
+  createStore,
+  createStores,
+  model,
+  validations
+};

package/esm/key/index.js

@@ -0,0 +1,73 @@
+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";
+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);
+  wrapModel.createStore = function createKeyStore() {
+    var storeConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    return createStore(wrapModel, _object_spread({}, config, storeConfig));
+  };
+  return wrapModel;
+}
+createKey.isModelKey = isModelKey;
+function createStores(modelKeys) {
+  var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var state = {
+    destroyed: false
+  };
+  var storeUnits = modelKeys.map(function(modelKey) {
+    if (typeof modelKey === "function") {
+      return modelKey.createStore();
+    }
+    var k = modelKey.key;
+    return createStore(k, "defaultState" in k ? _object_spread_props(_object_spread({}, config), {
+      state: k.defaultState
+    }) : config);
+  });
+  return {
+    find: function find(key) {
+      var found = storeUnits.find(function(c) {
+        if (typeof key === "function") {
+          return c.key === key;
+        }
+        return c.key === key.key;
+      });
+      if (!found) {
+        return null;
+      }
+      return found;
+    },
+    update: function update() {
+      for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
+        keys[_key] = arguments[_key];
+      }
+      if (state.destroyed) {
+        return;
+      }
+      storeUnits.forEach(function(un, i) {
+        var key = keys[i];
+        if (!key) {
+          return;
+        }
+        Object.assign(un, {
+          key
+        });
+        un.update({
+          model: typeof key === "function" ? key.source : key.key.source
+        });
+      });
+    },
+    destroy: function destroy() {
+      storeUnits.forEach(function(unit) {
+        unit.destroy();
+      });
+      state.destroyed = true;
+    }
+  };
+}
+export {
+  createKey,
+  createStores
+};

package/esm/model/index.js

@@ -0,0 +1,28 @@
+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";
+function configModel(config) {
+  var model = function model2(modelFn) {
+    var modelWrapper = function modelWrapper2(state) {
+      return modelFn(state);
+    };
+    modelWrapper.createKey = function createModelKey(state) {
+      return createKey(modelWrapper, arguments.length ? _object_spread_props(_object_spread({}, config), {
+        state
+      }) : config);
+    };
+    modelWrapper.createStore = function createModelStore(state) {
+      return createStore(modelWrapper, arguments.length ? _object_spread_props(_object_spread({}, config), {
+        state
+      }) : config);
+    };
+    return modelWrapper;
+  };
+  model.createField = createField;
+  model.createMethod = createMethod;
+  return model;
+}
+export {
+  configModel
+};

package/esm/store/index.js

@@ -0,0 +1,153 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+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;
+  var wrapModel = function wrapModel2(state) {
+    return model(state);
+  };
+  wrapModel.source = model;
+  wrapModel.modelKeyIdentifier = modelKeyIdentifier;
+  if (arguments.length > 1) {
+    wrapModel.defaultState = defaultState;
+  }
+  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 conf = function computeConfig() {
+    var hasConfigState = "state" in config;
+    var 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 config;
+  }();
+  var updater = createUpdater(model, conf);
+  var store = {
+    key: modelKey !== null && modelKey !== void 0 ? modelKey : "state" in config ? createPrimaryKey(model, config.state) : createPrimaryKey(model),
+    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);
+    },
+    update: function update(args) {
+      updater.update(args);
+    },
+    destroy: function destroy() {
+      updater.destroy();
+    },
+    payload: function payload(callback) {
+      return updater.payload(callback);
+    },
+    isDestroyed: function isDestroyed() {
+      return updater.isDestroyed;
+    },
+    updater
+  };
+  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;
+export {
+  createField,
+  createMethod,
+  createPrimaryKey,
+  createSignal,
+  createStore,
+  isModelKey,
+  modelKeyIdentifier
+};

package/esm/store/instance.js

@@ -0,0 +1,197 @@
+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";
+var cacheIdentify = {
+  field: function field(d) {
+    if (!d) {
+      return false;
+    }
+    var f = d;
+    return f.identifier === cacheIdentify.field;
+  },
+  method: function method(d) {
+    if (typeof d !== "function") {
+      return false;
+    }
+    var m = d;
+    return m.identifier === cacheIdentify.method;
+  }
+};
+function createField(callback, deps) {
+  var currentDeps = function computeDeps() {
+    if (deps == null) {
+      return deps;
+    }
+    if (deps.some(function(d) {
+      return cacheIdentify.field(d) && d.deps == null;
+    })) {
+      return void 0;
+    }
+    return deps.flatMap(function(d) {
+      if (cacheIdentify.field(d)) {
+        return d.deps;
+      }
+      return d;
+    });
+  }();
+  var value = callback();
+  return {
+    callback,
+    deps: currentDeps,
+    identifier: cacheIdentify.field,
+    value,
+    get: function 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));
+  };
+  Object.assign(replace, method2());
+  replace.identifier = cacheIdentify.method;
+  return replace;
+}
+function wrapToActionMethod(updater, methodName) {
+  var cacheMethods = updater.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 instance = updater.instance, isDestroyed = updater.isDestroyed, controlled = updater.controlled, model = updater.model;
+    var method2 = instance[methodName];
+    if (typeof method2 !== "function") {
+      throw new Error("Can not change methods in runtime.");
+    }
+    if (cacheIdentify.method(method2)) {
+      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,
+      prevState: updater.state,
+      instance: updater.instance,
+      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
+      });
+    });
+    return state;
+  };
+  cacheMethods[methodName] = actionMethod;
+  return actionMethod;
+}
+function wrapToField(updater, propertyName, value, onGot) {
+  var cacheFields = updater.cacheFields;
+  if (!cacheIdentify.field(value)) {
+    if (onGot) {
+      onGot(propertyName, value);
+    }
+    return value;
+  }
+  var field2 = value;
+  var cachedField = cacheFields[propertyName];
+  if (cachedField) {
+    return cachedField.getter;
+  }
+  var getter = {
+    get: function get() {
+      var 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];
+      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: field2.value,
+    deps: field2.deps
+  };
+  return getter;
+}
+function extractInstance(updater, onGet) {
+  var instance = updater.instance;
+  if ((typeof instance === "undefined" ? "undefined" : _type_of(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) {
+    if (!onGet) {
+      return;
+    }
+    onGet(key, value);
+  };
+  return createProxy(instance, {
+    get: function get(target, p, receiver) {
+      var value = target[p];
+      if (typeof value === "function" && properties.indexOf(p) >= 0) {
+        var actionMethod = wrapToActionMethod(updater, p);
+        Object.assign(actionMethod, value);
+        handleGetter(p, actionMethod);
+        return actionMethod;
+      }
+      return wrapToField(updater, p, value, handleGetter);
+    }
+  });
+}
+export {
+  cacheIdentify,
+  createField,
+  createMethod,
+  extractInstance
+};

package/esm/tools.js

@@ -0,0 +1,78 @@
+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
+};