subay 0.0.6 → 0.0.7

package/src/s.ts

@@ -0,0 +1,193 @@
+interface IUpdater {
+    (): void;
+    _whoIOwn: Array<IUpdater>;
+    _whoINeed: Array<ITrigger>;
+    _dirty: boolean;
+    _onCleanupCallback: Array<() => void>;
+}
+
+interface ITrigger {
+    _whoNeedMe: Array<IUpdater>;
+    _data: IO<any>;
+    _pendingValue: any;
+}
+
+interface IS<T> {
+    (): T;
+}
+
+interface IO<T> {
+    (): T;
+    (nextValue: T): T;
+}
+
+let currentUpdate: IUpdater | undefined = undefined;
+const NoValue: unique symbol = Symbol();
+let triggerQueue: Array<ITrigger> | undefined = undefined;
+const fun2s = new WeakMap<(...args: any[]) => any, IUpdater>();
+class Reactive {}
+class Observable extends Reactive {}
+class Computation extends Reactive {}
+const cProto = new Computation();
+const oProto = new Observable();
+
+export const root = <T>(fn: (destroy: () => void) => T): T => {
+    const backup = currentUpdate;
+    const rootUpdate: IUpdater = (() => {}) as any;
+    resetUpdate(rootUpdate);
+    rootUpdate._dirty = false;
+    currentUpdate = rootUpdate;
+    const result = fn(() => {
+        recycleUpdate(rootUpdate);
+        currentUpdate = undefined;
+    });
+    currentUpdate = backup;
+    return result;
+};
+export const S = <T>(fn: (pv: T | undefined) => T, value?: T): IS<T> => {
+    const data = () => {
+        if (update._dirty) {
+            update();
+        } else if (currentUpdate) {
+            update._whoINeed.forEach((t) => t._data());
+        }
+        return value as T;
+    };
+    Object.setPrototypeOf(data, cProto);
+    const update: IUpdater = (() => {
+        const backup = currentUpdate;
+        recycleUpdate(update);
+        update._dirty = false;
+        currentUpdate = update;
+        value = fn(value);
+        currentUpdate = backup;
+    }) as any;
+    if (currentUpdate) {
+        currentUpdate._whoIOwn.push(update);
+    }
+    resetUpdate(update);
+    update();
+    fun2s.set(fn, update);
+    return data;
+};
+export const o = <T>(value: T): IO<T> => {
+    function data(): T;
+    function data(nextValue: T): T;
+    function data(nextValue?: T) {
+        if (arguments.length === 0) {
+            if (currentUpdate) {
+                if (!currentUpdate._whoINeed.includes(trigger)) {
+                    currentUpdate._whoINeed.push(trigger);
+                }
+                if (!trigger._whoNeedMe.includes(currentUpdate)) {
+                    trigger._whoNeedMe.push(currentUpdate);
+                }
+            }
+            return value;
+        }
+
+        if (triggerQueue) {
+            if (trigger._pendingValue === NoValue) {
+                triggerQueue.push(trigger);
+            }
+            trigger._pendingValue = nextValue;
+            return nextValue;
+        }
+
+        value = nextValue!;
+
+        const backup = currentUpdate;
+        currentUpdate = undefined;
+
+        const whoNeedMeLasttime = trigger._whoNeedMe.filter((it) => {
+            return it._whoINeed.includes(trigger);
+        });
+        whoNeedMeLasttime.forEach((u) => {
+            u._dirty = true;
+        });
+        trigger._whoNeedMe = [];
+        whoNeedMeLasttime.forEach((u) => {
+            if (u._dirty) {
+                u();
+            }
+        });
+
+        currentUpdate = backup;
+
+        return value;
+    }
+
+    Object.setPrototypeOf(data, oProto);
+
+    const trigger: ITrigger = {
+        _whoNeedMe: [],
+        _data: data,
+        _pendingValue: NoValue,
+    };
+
+    return data;
+};
+const recycleUpdate = (update: IUpdater) => {
+    update._whoIOwn.forEach(recycleUpdate);
+    update._dirty = false;
+    update._onCleanupCallback.forEach((f) => f());
+    resetUpdate(update);
+};
+
+const resetUpdate = (update: IUpdater) => {
+    update._whoINeed = [];
+    update._whoIOwn = [];
+    update._onCleanupCallback = [];
+};
+
+export const cleanup = <T extends () => void>(f: T): T => {
+    if (currentUpdate) {
+        currentUpdate._onCleanupCallback.push(f);
+    }
+    return f;
+};
+
+export const transaction = <T>(f: () => T): T => {
+    const fallback = triggerQueue;
+    triggerQueue = [] as ITrigger[];
+    const result = f();
+    const workedQueue = triggerQueue;
+    triggerQueue = fallback;
+
+    workedQueue.forEach((t) => {
+        if (t._pendingValue !== NoValue) {
+            const pv = t._pendingValue;
+            t._pendingValue = NoValue;
+            t._data(pv);
+        }
+    });
+
+    return result;
+};
+
+export { o as observable };
+
+export const sample = <T>(f: () => T): T => {
+    const fallback = currentUpdate;
+    currentUpdate = undefined;
+    const value = f();
+    currentUpdate = fallback;
+    return value;
+};
+
+export const isListening = () => !!currentUpdate;
+
+export const subscribe = (f: () => void) => {
+    S(f);
+    return () => unsubscribe(f);
+};
+export const unsubscribe = (f: () => void) => {
+    const update = fun2s.get(f);
+    if (update) {
+        recycleUpdate(update);
+    }
+};
+
+export const isObservable = (o: any): o is IO<any> => o instanceof Observable;
+export const isComputed = (o: any): o is IS<any> => o instanceof Computation;
+export const isReactive = (o: any): o is IO<any> | IS<any> => o instanceof Reactive;