npm - @e7w/easy-model - Versions diffs - 0.0.1 - Mend

@e7w/easy-model 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,26 @@
+# 简单模型(easy-model)
+> 一个简单的状态管理包.\
+> A simple state management lib for Typescript
+## 例子(Example)
+```ts
+import { provide, subscribe } from "@e7w/easy-model";
+const A = provide(
+  class A {
+    msg = "1";
+    constructor(private id: number) {}
+    random() {
+      this.msg = `${Math.random()}`;
+    }
+  }
+);
+A(1) === A(1); // true
+subscribe(A(1), console.log.bind(console, "Path of changed value:"));
+A(1).msg = "123"; // Path of changed value: ["msg"]
+```

package/dist/helpers.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export type Ctor = new (...args: any[]) => any;
+export type Obj = Record<string | symbol | number, any>;
+export declare function safeGet(target: Obj, p: string | symbol): any;
+export declare function track(target: Obj, handler: (path: (string | symbol)[]) => void): void;
+export declare function subscribe(target: Obj, handler: (path: (string | symbol)[]) => void): () => void;
+export declare function trigger(target: Obj, path: (string | symbol)[]): void;

package/dist/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { subscribe } from "./helpers";
2	+ export { provide } from "./provide";

package/dist/index.es.js ADDED Viewed

@@ -0,0 +1,126 @@
+var O = Object.defineProperty;
+var _ = (n, t, e) => t in n ? O(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var c = (n, t, e) => (_(n, typeof t != "symbol" ? t + "" : t, e), e);
+const h = /* @__PURE__ */ new WeakMap(), g = Symbol("origin");
+function i(n) {
+  if (n = f(n), h.has(n))
+    return h.get(n);
+  const t = new Proxy(n, new j(n));
+  return h.set(n, t), t;
+}
+function f(n) {
+  return n[g] || n;
+}
+class j {
+  constructor(t) {
+    c(this, "triggers", {});
+    this.obj = t;
+  }
+  get(t, e, r) {
+    if (e === g)
+      return this.obj;
+    let s = k(t, e) || Reflect.get(t, e, r);
+    return typeof s == "function" ? s.bind(i(t)) : (typeof s == "object" && (s = i(s), p(s, this.getTrigger(e))), s);
+  }
+  set(t, e, r, s) {
+    const o = Reflect.set(t, e, r, s);
+    return y(this.obj, [e]), o;
+  }
+  getTrigger(t) {
+    return t in this.triggers || (this.triggers[t] = (e) => y(this.obj, [t, ...e])), this.triggers[t];
+  }
+}
+const l = ["push", "pop", "shift", "unshift", "splice"];
+function k(n, t) {
+  return t === "hasOwnProperty" ? function(e) {
+    return f(this).hasOwnProperty(e);
+  } : Array.isArray(n) && typeof l[t] == "function" ? function(...e) {
+    const r = l[t].apply(f(this), e);
+    return l.includes(t) && y(this, [t]), r;
+  } : null;
+}
+const a = /* @__PURE__ */ new WeakMap();
+function d(n) {
+  return n = f(n), a.has(n) || a.set(n, /* @__PURE__ */ new Set()), a.get(n);
+}
+function p(n, t) {
+  d(n).add(t);
+}
+function R(n, t) {
+  const e = (s) => {
+    t(s), p(n, e);
+  }, r = () => {
+    d(n).delete(e);
+  };
+  return p(n, e), r;
+}
+function y(n, t) {
+  const e = d(n), r = [...e];
+  return e.clear(), r.forEach((s) => s(t));
+}
+function C(n) {
+  return new Proxy(n, new u(n));
+}
+const b = class {
+  constructor(t) {
+    c(this, "fakeCtor");
+    c(this, "caches", /* @__PURE__ */ new Map());
+    this.Ctor = t;
+    const e = function() {
+    };
+    e.prototype = new Proxy(
+      {
+        constructor: t,
+        __proto__: t.prototype
+      },
+      b.prototypeHandlers
+    ), this.fakeCtor = e;
+  }
+  apply(t, e, r) {
+    return this.getInstance(r) || this.register(
+      r,
+      Reflect.construct(this.Ctor, r, this.fakeCtor)
+    );
+  }
+  construct(t, e, r) {
+    return Reflect.construct(
+      t,
+      e,
+      r === this.Ctor ? this.fakeCtor : r
+    );
+  }
+  getInstance(t) {
+    for (const e of this.caches.keys()) {
+      if (!e.every(
+        (s, o) => s === t[o] ? !0 : typeof s == "object" && typeof t[o] == "object" ? this.isShallowEqualObj(s, t[o]) : !1
+      ))
+        continue;
+      const r = this.caches.get(e);
+      return r.deref() ? i(r.deref()) : (this.caches.delete(e), null);
+    }
+    return null;
+  }
+  register(t, e) {
+    return this.caches.set(t, new WeakRef(e)), i(e);
+  }
+  isShallowEqualObj(t, e) {
+    const r = Object.keys(t), s = e.keys(e);
+    return r.length === s.length && r.every((o) => t[o] === e[o]);
+  }
+};
+let u = b;
+c(u, "prototypeHandlers", {
+  get(t, e, r) {
+    const s = k(t, e);
+    if (s)
+      return s;
+    const o = Reflect.get(t, e, r);
+    return typeof e == "symbol" || ["constructor", "__proto__"].includes(e) || typeof o != "function" ? o : function(...w) {
+      return o.apply(i(this), w);
+    };
+  }
+});
+export {
+  C as provide,
+  R as subscribe
+};

package/dist/index.umd.js ADDED Viewed

@@ -0,0 +1 @@

package/dist/observe.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { type Obj } from "./helpers";
+export declare function observe<T extends Obj>(target: T): T;
+export declare function getOrigin<T extends Obj>(target: T): T;

package/dist/provide.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { type Ctor } from "./helpers";
2	+ export declare function provide<T extends Ctor>(Ctor: T): T & ((...args: ConstructorParameters<T>) => InstanceType<T>);

package/package.json ADDED Viewed

@@ -0,0 +1,34 @@
+{
+  "name": "@e7w/easy-model",
+  "version": "0.0.1",
+  "description": "一个简单的状态管理包, A simple state management lib for Typescript",
+  "main": "./dist/index.es.js",
+  "module": "./dist/index.es.js",
+  "types": "./src/index.d.ts",
+  "typings": "./dist/index.d.ts",
+  "exports": {
+    "import": "./dist/index.es.js",
+    "require": "./dist/index.umd.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "keywords": [
+    "model",
+    "provide",
+    "observe"
+  ],
+  "author": "张一凡<344275632@qq.com>",
+  "license": "ISC",
+  "files": [
+    "package.json",
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "vite build"
+  }
+}

package/src/helpers.ts ADDED Viewed

@@ -0,0 +1,61 @@
+import { getOrigin } from "./observe";
+export type Ctor = new (...args: any[]) => any;
+export type Obj = Record<string | symbol | number, any>;
+const fakeArr: any = ["push", "pop", "shift", "unshift", "splice"];
+export function safeGet(target: Obj, p: string | symbol): any {
+  if (p === "hasOwnProperty") {
+    return function (this: Obj, key: string) {
+      return getOrigin(this).hasOwnProperty(key);
+    };
+  }
+  if (Array.isArray(target) && typeof fakeArr[p] === "function") {
+    return function (this: Obj, ...args: any) {
+      const ret = fakeArr[p].apply(getOrigin(this), args);
+      if (fakeArr.includes(p)) trigger(this, [p]);
+      return ret;
+    };
+  }
+  return null;
+}
+const updateHandlersMap = new WeakMap();
+function getUpdateHandlers(
+  target: Obj
+): Set<(path: (string | symbol)[]) => void> {
+  target = getOrigin(target);
+  if (!updateHandlersMap.has(target)) updateHandlersMap.set(target, new Set());
+  return updateHandlersMap.get(target);
+}
+export function track(
+  target: Obj,
+  handler: (path: (string | symbol)[]) => void
+): void {
+  const handlers = getUpdateHandlers(target);
+  handlers.add(handler);
+}
+export function subscribe(
+  target: Obj,
+  handler: (path: (string | symbol)[]) => void
+): () => void {
+  const wrappedHandler: typeof handler = (path) => {
+    handler(path);
+    track(target, wrappedHandler);
+  };
+  const unsubscribe = () => {
+    getUpdateHandlers(target).delete(wrappedHandler);
+  };
+  track(target, wrappedHandler);
+  return unsubscribe;
+}
+export function trigger(target: Obj, path: (string | symbol)[]): void {
+  const handlers = getUpdateHandlers(target);
+  const cbs = [...handlers];
+  handlers.clear();
+  return cbs.forEach((fn) => fn(path));
+}

package/src/index.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { subscribe } from "./helpers";
2	+ export { provide } from "./provide";

package/src/observe.ts ADDED Viewed

@@ -0,0 +1,54 @@
+import { type Obj, safeGet, track, trigger } from "./helpers";
+const observedMap = new WeakMap();
+const origin = Symbol("origin");
+export function observe<T extends Obj>(target: T): T {
+  target = getOrigin(target);
+  if (observedMap.has(target)) return observedMap.get(target);
+  const ret = new Proxy(target, new ObserveHandler(target));
+  observedMap.set(target, ret);
+  return ret;
+}
+export function getOrigin<T extends Obj>(target: T): T {
+  return target[origin] || target;
+}
+class ObserveHandler<T extends Obj> implements ProxyHandler<T> {
+  private triggers: Record<
+    string | symbol,
+    (path: (string | symbol)[]) => void
+  > = {};
+  public constructor(private obj: T) {}
+  public get(target: T, p: string | symbol, receiver: any): any {
+    if (p === origin) return this.obj;
+    let ret = safeGet(target, p) || Reflect.get(target, p, receiver);
+    if (typeof ret === "function") return ret.bind(observe(target));
+    if (typeof ret === "object") {
+      ret = observe(ret);
+      track(ret, this.getTrigger(p));
+    }
+    return ret;
+  }
+  public set(
+    target: T,
+    p: string | symbol,
+    newValue: any,
+    receiver: any
+  ): boolean {
+    const ret = Reflect.set(target, p, newValue, receiver);
+    trigger(this.obj, [p]);
+    return ret;
+  }
+  private getTrigger(p: string | symbol): (path: (string | symbol)[]) => void {
+    if (!(p in this.triggers)) {
+      this.triggers[p] = (path: (typeof p)[]) =>
+        trigger(this.obj, [p, ...path]);
+    }
+    return this.triggers[p];
+  }
+}

package/src/provide.ts ADDED Viewed

@@ -0,0 +1,111 @@
+import { type Ctor, type Obj, safeGet } from "./helpers";
+import { observe } from "./observe";
+export function provide<T extends Ctor>(
+  Ctor: T
+): T & ((...args: ConstructorParameters<T>) => InstanceType<T>) {
+  return new Proxy(Ctor, new Provider(Ctor)) as any;
+}
+class Provider<T extends Ctor> implements ProxyHandler<T> {
+  private static prototypeHandlers: ProxyHandler<Obj> = {
+    get(target, p, receiver) {
+      const safeVal = safeGet(target, p);
+      if (safeVal) return safeVal;
+      const ret = Reflect.get(target, p, receiver);
+      if (
+        typeof p === "symbol" ||
+        ["constructor", "__proto__"].includes(p) ||
+        typeof ret !== "function"
+      )
+        return ret;
+      return function (this: Obj, ...args: any[]) {
+        return ret.apply(observe(this), args);
+      };
+    },
+  };
+  public fakeCtor: T;
+  private caches = new Map<
+    ConstructorParameters<T>,
+    WeakRef<InstanceType<T>>
+  >();
+  public constructor(private Ctor: T) {
+    const fakeCtor: any = function () {};
+    fakeCtor.prototype = new Proxy(
+      {
+        constructor: Ctor,
+        __proto__: Ctor.prototype,
+      },
+      Provider.prototypeHandlers
+    );
+    this.fakeCtor = fakeCtor;
+  }
+  public apply(
+    _target: T,
+    _thisArg: any,
+    argArray: ConstructorParameters<T>
+  ): InstanceType<T> {
+    // todo: 循环引用创建时抛出错误
+    return (
+      this.getInstance(argArray) ||
+      this.register(
+        argArray,
+        Reflect.construct(this.Ctor, argArray, this.fakeCtor)
+      )
+    );
+  }
+  public construct(
+    target: T,
+    argArray: any[],
+    newTarget: any
+  ): InstanceType<T> {
+    return Reflect.construct(
+      target,
+      argArray,
+      newTarget === this.Ctor ? this.fakeCtor : newTarget
+    );
+  }
+  public getInstance(args: ConstructorParameters<T>): InstanceType<T> | null {
+    for (const cachedArgs of this.caches.keys()) {
+      if (
+        !cachedArgs.every((arg, index) =>
+          arg === args[index]
+            ? true
+            : typeof arg === "object" && typeof args[index] === "object"
+            ? this.isShallowEqualObj(arg, args[index]) // 只考虑 array 和 object 的浅比较, 其他奇怪的对象不应该出现在入参里.
+            : false
+        )
+      )
+        continue;
+      const instance = this.caches.get(cachedArgs)!;
+      if (instance.deref()) return observe(instance.deref()!);
+      this.caches.delete(cachedArgs);
+      return null;
+    }
+    return null;
+  }
+  public register(
+    args: ConstructorParameters<T>,
+    instance: InstanceType<T>
+  ): InstanceType<T> {
+    this.caches.set(args, new WeakRef(instance));
+    return observe(instance);
+  }
+  private isShallowEqualObj(objectA: Obj, objectB: Obj): Boolean {
+    const kOfA = Object.keys(objectA);
+    const kOfB = objectB.keys(objectB);
+    return (
+      kOfA.length === kOfB.length &&
+      kOfA.every((key) => objectA[key] === objectB[key])
+    );
+  }
+}