as-model 0.0.1

package/esm/updater/index.js

@@ -0,0 +1,129 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { createNoStateModel } from "../validation";
+import { generateNotifier } from "./notifier";
+import { generateTunnelCreator, createUnInitializedUpdater, destroy } from "./tunnel";
+function createInitializedUpdater(updater) {
+  var createTunnel = generateTunnelCreator(updater);
+  return {
+    notify: generateNotifier(updater),
+    createTunnel
+  };
+}
+function createUpdateFn(updater) {
+  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;
+      if (u.controlled) {
+        var instance = model(state);
+        return _object_spread_props(_object_spread({}, u), {
+          state,
+          instance,
+          model
+        });
+      }
+      if (u.isDestroyed) {
+        return u;
+      }
+      if (!u.initialized && !("initialState" in args)) {
+        throw new Error("Should update initialState first.");
+      }
+      if (!u.initialized) {
+        var instance1 = model(initialState);
+        var initializedUpdater = createInitializedUpdater(u);
+        return _object_spread(_object_spread_props(_object_spread({}, u), {
+          model,
+          state: initialState,
+          instance: instance1,
+          initialized: true
+        }), initializedUpdater);
+      }
+      if (Object.is(u.model, model) && Object.is(u.state, state)) {
+        return u;
+      }
+      var instance2 = model(state);
+      effect(function(up) {
+        up.notify({
+          type: null,
+          method: null,
+          prevInstance: u.instance,
+          instance: instance2,
+          prevState: u.state,
+          state
+        });
+      });
+      return _object_spread_props(_object_spread({}, u), {
+        state,
+        model,
+        instance: instance2,
+        initialized: true
+      });
+    });
+  };
+}
+var lazyModel = createNoStateModel();
+function createUpdater(model) {
+  var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  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({
+    sidePayload: void 0,
+    version: 0,
+    isDestroyed: false,
+    model,
+    instance: defaultInstance,
+    dispatch: null,
+    dispatches: [],
+    temporaryDispatches: [],
+    cacheMethods: {},
+    cacheFields: {},
+    state: defaultState,
+    initialized: hasDefaultState,
+    controlled: !!controlled,
+    isSubscribing: false,
+    config,
+    payload: function 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);
+        });
+      };
+      var result = callback(updater, function(effectFn) {
+        return effects.push(effectFn);
+      });
+      if (updater === result) {
+        runEffects(result);
+        return updater;
+      }
+      Object.assign(updater, result);
+      runEffects(updater);
+      return updater;
+    },
+    update: function(args) {
+    },
+    destroy: function destroy1() {
+      destroy(updater);
+    }
+  }, unInitializedUpdater);
+  var initialized = createInitializedUpdater(updater);
+  Object.assign(updater, initialized, {
+    update: createUpdateFn(updater)
+  });
+  return updater;
+}
+export {
+  createUpdater
+};

package/esm/updater/notifier.js

@@ -0,0 +1,121 @@
+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";
+function defaultNotifyImplement(dispatches, action) {
+  dispatches.forEach(function(callback) {
+    callback(action);
+  });
+}
+function generateNotifier(updater) {
+  function pendAction(value) {
+    updater.mutate(function(u) {
+      var dispatching = u.dispatching;
+      if (!dispatching) {
+        var wrap = {
+          value
+        };
+        wrap.tail = wrap;
+        return _object_spread_props(_object_spread({}, u), {
+          dispatching: wrap
+        });
+      }
+      var tail = dispatching.tail;
+      if (!tail) {
+        return u;
+      }
+      var current = {
+        prev: tail,
+        value
+      };
+      tail.next = current;
+      dispatching.tail = current;
+      return _object_spread_props(_object_spread({}, u), {
+        dispatching
+      });
+    });
+  }
+  function unshiftAction() {
+    return updater.mutate(function(u) {
+      var dispatching = updater.dispatching;
+      if (!dispatching) {
+        return u;
+      }
+      var next = dispatching.next, tail = dispatching.tail;
+      if (tail === dispatching || !next) {
+        dispatching.tail = void 0;
+        return _object_spread_props(_object_spread({}, u), {
+          dispatching: void 0
+        });
+      }
+      next.prev = void 0;
+      var newFirst = next;
+      newFirst.tail = tail;
+      return _object_spread_props(_object_spread({}, 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)),
+        temporaryDispatches: []
+      }) : u;
+    });
+    var initializedAction = {
+      state: updater.state,
+      prevState: updater.state,
+      instance: updater.instance,
+      prevInstance: updater.instance,
+      type: null,
+      method: null
+    };
+    temporaryDispatches.forEach(function(call) {
+      call(initializedAction);
+    });
+  }
+  var config = updater.config;
+  return function notify(action) {
+    if (action == null) {
+      return;
+    }
+    var dispatching = updater.dispatching;
+    pendAction(action);
+    if (dispatching) {
+      return;
+    }
+    while (updater.dispatching) {
+      var wrap = updater.dispatching;
+      if (wrap) {
+        var dispatches = updater.dispatches;
+        var dispatchCallbacks = _to_consumable_array(dispatches);
+        try {
+          if (typeof config.batchNotify === "function" && dispatchCallbacks.length) {
+            config.batchNotify(dispatchCallbacks, wrap.value);
+          } else {
+            defaultNotifyImplement(dispatchCallbacks, wrap.value);
+          }
+        } catch (e) {
+          updater.mutate(function(u) {
+            return _object_spread_props(_object_spread({}, u), {
+              dispatching: void 0
+            });
+          });
+          throw e;
+        }
+        unshiftAction();
+      } else {
+        updater.mutate(function(u) {
+          return _object_spread_props(_object_spread({}, u), {
+            dispatching: void 0
+          });
+        });
+      }
+    }
+    consumeTemporaries();
+  };
+}
+export {
+  generateNotifier
+};

package/esm/updater/tunnel.js

@@ -0,0 +1,138 @@
+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 { noop } from "../tools";
+function createUnInitializedUpdater() {
+  return {
+    notify: function(a) {
+    },
+    createTunnel: function(dispatcher) {
+      return {
+        connect: noop,
+        disconnect: noop
+      };
+    }
+  };
+}
+function destroy(updater) {
+  function destroyDispatching() {
+    updater.mutate(function(u) {
+      var dispatching = u.dispatching;
+      if (!dispatching) {
+        return u;
+      }
+      var wrapper = dispatching;
+      while (wrapper) {
+        var next = wrapper.next;
+        wrapper.next = void 0;
+        wrapper.prev = void 0;
+        if (next) {
+          next.prev = void 0;
+        }
+        wrapper = next;
+      }
+      dispatching.tail = void 0;
+      return _object_spread_props(_object_spread({}, u), {
+        dispatching: void 0,
+        initialized: false
+      });
+    });
+  }
+  updater.mutate(function(u, effect) {
+    var destroyed = createUnInitializedUpdater();
+    effect(function() {
+      destroyDispatching();
+    });
+    return _object_spread_props(_object_spread({}, 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;
+    if (exist) {
+      return updater.mutate(function(u) {
+        return _object_spread_props(_object_spread({}, u), {
+          isDestroyed: false
+        });
+      });
+    }
+    if (isControlled) {
+      return updater.mutate(function(u) {
+        return _object_spread_props(_object_spread({}, 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
+      ]);
+      if (u.dispatching) {
+        return _object_spread_props(_object_spread({}, u), {
+          temporaryDispatches: nextTds,
+          isDestroyed: false
+        });
+      }
+      effect(function(up) {
+        var initializedAction = {
+          state: up.state,
+          prevState: up.state,
+          instance: up.instance,
+          prevInstance: up.instance,
+          type: null,
+          method: null
+        };
+        nextTds.forEach(function(td) {
+          td(initializedAction);
+        });
+      });
+      return _object_spread_props(_object_spread({}, u), {
+        temporaryDispatches: [],
+        dispatches: _to_consumable_array(ds).concat(_to_consumable_array(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;
+        });
+        if (ds.length === nextDs.length && tds.length === nextTds.length) {
+          return u;
+        }
+        return _object_spread_props(_object_spread({}, u), {
+          dispatches: nextDs,
+          temporaryDispatches: nextTds
+        });
+      });
+    }
+    return {
+      connect: function connect() {
+        subscribe(dispatcher);
+      },
+      disconnect: function disconnect1() {
+        disconnect();
+      }
+    };
+  };
+}
+export {
+  createUnInitializedUpdater,
+  destroy,
+  generateTunnelCreator
+};

package/esm/validation/index.js

@@ -0,0 +1,25 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+var noStateAModelKey = "no-state-a-model-key";
+function createNoStateModel() {
+  return function noStateModel(state) {
+    return _define_property({}, noStateAModelKey, true);
+  };
+}
+function isInstanceFromNoStateModel(instance) {
+  if (instance == null) {
+    return false;
+  }
+  if ((typeof instance === "undefined" ? "undefined" : _type_of(instance)) !== "object") {
+    return false;
+  }
+  var ins = instance;
+  return !!ins[noStateAModelKey];
+}
+var validations = {
+  isInstanceFromNoStateModel
+};
+export {
+  createNoStateModel,
+  validations
+};

package/index.d.ts

@@ -0,0 +1,163 @@
+declare interface ModelInstance {
+  [key: string]: unknown;
+  [key: number]: unknown;
+}
+
+declare type ValidInstance<S, T extends ModelInstance> = {
+  [K in keyof T]: T[K] extends (...args: unknown[]) => S
+    ? T[K]
+    : T[K] extends (...args: unknown[]) => unknown
+      ? never
+      : T[K];
+};
+
+export type Model<S, T extends ModelInstance> = (
+  state: S
+) => ValidInstance<S, T>;
+
+export type Action<S = any, T extends ModelInstance = ModelInstance> = {
+  type: null | string;
+  method: null | ((...args: any[]) => any);
+  params?: any[];
+  state: S;
+  prevState?: S;
+  instance: T;
+  prevInstance?: T;
+};
+
+declare type Dispatch = (action: Action) => unknown;
+
+export interface Key<S = any, T extends ModelInstance = any>
+  extends Model<S, T> {
+  (s: S): T;
+  source: Model<S, T>;
+  modelKeyIdentifier: () => boolean;
+  [k: string]: any;
+}
+
+export interface Config {
+  controlled?: boolean;
+  batchNotify?: (
+    listeners: ((action: Action) => void)[],
+    action: Action
+  ) => void;
+}
+
+/** createStore * */
+
+export interface KeyWrapper<S = any, T extends ModelInstance = any> {
+  key: Key<S, T>;
+}
+
+export interface Store<S = any, T extends ModelInstance = any>
+  extends KeyWrapper<S, T> {
+  subscribe: (dispatcher: Dispatch) => () => void;
+  getInstance: () => T;
+  update: (args?: { model?: Model<S, T>; state?: S }) => void;
+  destroy: () => void;
+  payload: <R>(
+    callback?: (payload: R | undefined) => R | undefined
+  ) => R | undefined;
+  isDestroyed: () => boolean;
+}
+
+export function createStore<S, T extends ModelInstance, D extends S>(
+  model: Model<S, T> | Key<S, T>,
+  state?: D
+): Store<S, T>;
+
+/** createKey * */
+
+export interface ModelKey<S = any, T extends ModelInstance = any>
+  extends Key<S, T> {
+  (s: S): T;
+  createStore: <D extends S>(state?: D) => Store<S, T>;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export interface createKey {
+  <S, T extends ModelInstance, D extends S>(
+    model: Model<S, T>,
+    state?: D
+  ): ModelKey<S, T>;
+  isModelKey: <S, T extends ModelInstance>(
+    data: unknown
+  ) => data is ModelKey<S, T>;
+}
+
+/** createStores * */
+
+export interface StoreCollection {
+  find: <S, T extends ModelInstance>(
+    key: Key<S, T> | KeyWrapper<S, T>
+  ) => Store<S, T> | null;
+  update: (...keys: (ModelKey | KeyWrapper)[]) => void;
+  destroy: () => void;
+}
+
+export function createStores(
+  ...modelKeys: (ModelKey | KeyWrapper)[]
+): StoreCollection;
+
+/** model API * */
+
+export interface ModelUsage<S, T extends ModelInstance> {
+  (s: S): ValidInstance<S, T>;
+  createKey: (state?: S) => ModelKey<S, T>;
+  createStore: (state?: S) => Store<S, T>;
+}
+
+declare type FieldStructure<R = any> = {
+  callback: () => R;
+  deps: unknown[] | undefined;
+  identifier: (d: unknown) => d is FieldStructure<R>;
+  value: R;
+  get: () => R;
+};
+
+declare type MethodStructure<
+  R extends (...args: any[]) => any = (...args: any[]) => any
+> = R & {
+  identifier: (d: unknown) => d is MethodStructure;
+};
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export interface model {
+  <S, T extends ModelInstance>(modelFn: Model<S, T>): ModelUsage<S, T>;
+  createField: <R extends () => any>(
+    callback: R,
+    deps?: unknown[]
+  ) => FieldStructure<ReturnType<R>>;
+  createMethod: <R extends (...args: any[]) => any = (...args: any[]) => any>(
+    method: R
+  ) => MethodStructure<R>;
+}
+
+/** createSignal * */
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+declare interface SignalStore<S = any, T extends ModelInstance = any>
+  extends KeyWrapper<S, T> {
+  subscribe: (dispatcher: Dispatch) => () => void;
+  getSignal: () => {
+    (): T;
+    startStatistics: () => void;
+    stopStatistics: () => void;
+    subscribe: (dispatcher: Dispatch) => () => void;
+    payload: <R>(
+      callback?: (payload: R | undefined) => R | undefined
+    ) => R | undefined;
+  };
+}
+
+export declare function createSignal<S, T extends ModelInstance>(
+  store: Store<S, T>
+): SignalStore<S, T>;
+
+/** config * */
+export declare function config(configuration: Config): {
+  createStore: typeof createStore;
+  createKey: typeof createKey;
+  createStores: typeof createStores;
+  model: typeof model;
+};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "private": false,
+  "name": "as-model",
+  "version": "0.0.1",
+  "description": "This is a model state management tool",
+  "license": "MIT",
+  "author": "Jimmy.Harding",
+  "homepage": "https://github.com/filefoxper/a-model",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/filefoxper/a-model"
+  },
+  "main": "dist/index.js",
+  "module": "esm/index.js",
+  "files": [
+    "dist",
+    "esm",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "build": "node ./build.js",
+    "docs": "docsify serve ./docs",
+    "lint": "eslint src --fix --ext .ts,.tsx ",
+    "lint-init": "eslint --init",
+    "test": "jest --coverage"
+  },
+  "typings": "index.d.ts",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@babel/cli": "^7.25.9",
+    "@babel/core": "^7.26.0",
+    "@babel/eslint-parser": "^7.25.9",
+    "@babel/plugin-transform-runtime": "^7.25.9",
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@babel/runtime": "^7.26.0",
+    "esbuild": "^0.25.0",
+    "esbuild-plugin-es5": "2.1.1",
+    "eslint": "^8.49.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-airbnb-typescript": "^17.1.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-import-resolver-typescript": "^3.6.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-jsx-a11y": "^6.7.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-react": "^7.33.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "eslint-webpack-plugin": "^4.0.1",
+    "prettier": "^3.0.3",
+    "prettier-eslint": "^15.0.1",
+    "prettier-eslint-cli": "^7.1.0",
+    "typescript": "^4.9.5",
+    "babel-jest": "29.7.0",
+    "jest": "29.7.0",
+    "jest-environment-jsdom": "29.7.0",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.8.1",
+    "pmnps": "^4.5.3",
+    "@pmnps/plugin-publish": "4.5.0"
+  },
+  "keywords": [
+    "model",
+    "state",
+    "state-management",
+    "typescript"
+  ]
+}