init

node_modules/computeds/out/computed.d.ts

@@ -0,0 +1 @@
+export declare function computed<T>(getter: (oldValue?: T) => T): () => T;

node_modules/computeds/out/computed.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computed = void 0;
+const tracker_1 = require("./tracker");
+const system_1 = require("./system");
+const dep_1 = require("./dep");
+function computed(getter) {
+    let oldValue;
+    const tracker = new tracker_1.Tracker(() => (0, system_1.trigger)(dep, 1 /* DirtyLevels.ComputedValueMaybeDirty */));
+    const fn = () => {
+        (0, system_1.track)(dep);
+        if (tracker.dirty
+            && !Object.is(oldValue, oldValue = tracker.track(() => getter(oldValue)))) {
+            (0, system_1.trigger)(dep, 2 /* DirtyLevels.ComputedValueDirty */);
+        }
+        return oldValue;
+    };
+    const dep = new dep_1.Dep(fn);
+    return fn;
+}
+exports.computed = computed;

node_modules/computeds/out/computeds/computedArray.d.ts

@@ -0,0 +1 @@
+export declare function computedArray<I, O>(arr: () => I[], computedItem: (item: () => I, index: number) => () => O): readonly Readonly<O>[];

node_modules/computeds/out/computeds/computedArray.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedArray = void 0;
+const computed_1 = require("../computed");
+function computedArray(arr, computedItem) {
+    const length = (0, computed_1.computed)(() => arr().length);
+    const keys = (0, computed_1.computed)(() => {
+        const keys = [];
+        for (let i = 0; i < length(); i++) {
+            keys.push(String(i));
+        }
+        return keys;
+    });
+    const items = (0, computed_1.computed)((array) => {
+        array ??= [];
+        while (array.length < length()) {
+            const index = array.length;
+            const item = (0, computed_1.computed)(() => arr()[index]);
+            array.push(computedItem(item, index));
+        }
+        if (array.length > length()) {
+            array.length = length();
+        }
+        return array;
+    });
+    return new Proxy({}, {
+        get(_, p, receiver) {
+            if (p === 'length') {
+                return length();
+            }
+            if (typeof p === 'string' && !isNaN(Number(p))) {
+                return items()[Number(p)]?.();
+            }
+            return Reflect.get(items(), p, receiver);
+        },
+        has(_, p) {
+            return Reflect.has(items(), p);
+        },
+        ownKeys() {
+            return keys();
+        },
+    });
+}
+exports.computedArray = computedArray;

node_modules/computeds/out/computeds/computedSet.d.ts

@@ -0,0 +1 @@
+export declare function computedSet<T>(getter: () => Set<T>): () => Set<T>;

node_modules/computeds/out/computeds/computedSet.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedSet = void 0;
+const computed_1 = require("../computed");
+function computedSet(getter) {
+    return (0, computed_1.computed)((oldValue) => {
+        const newValue = getter();
+        if (oldValue?.size === newValue.size && [...oldValue].every(c => newValue.has(c))) {
+            return oldValue;
+        }
+        return newValue;
+    });
+}
+exports.computedSet = computedSet;

node_modules/computeds/out/dep.d.ts

@@ -0,0 +1,5 @@
+import type { TrackToken } from './tracker';
+export declare class Dep extends Map<TrackToken, number> {
+    computed?: (() => void) | undefined;
+    constructor(computed?: (() => void) | undefined);
+}

node_modules/computeds/out/dep.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dep = void 0;
+class Dep extends Map {
+    constructor(computed) {
+        super();
+        this.computed = computed;
+    }
+}
+exports.Dep = Dep;

node_modules/computeds/out/effect.d.ts

@@ -0,0 +1,2 @@
+import { Tracker } from './tracker';
+export declare function effect(fn: () => void): Tracker;

node_modules/computeds/out/effect.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effect = void 0;
+const tracker_1 = require("./tracker");
+function effect(fn) {
+    const tracker = new tracker_1.Tracker(() => { }, () => {
+        if (tracker.dirty) {
+            tracker.track(fn);
+        }
+    });
+    tracker.track(fn);
+    return tracker;
+}
+exports.effect = effect;

node_modules/computeds/out/index.d.ts

@@ -0,0 +1,7 @@
+export * from './computed';
+export * from './effect';
+export * from './tracker';
+export * from './signal';
+export * from './system';
+export * from './computeds/computedArray';
+export * from './computeds/computedSet';

node_modules/computeds/out/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./computed"), exports);
+__exportStar(require("./effect"), exports);
+__exportStar(require("./tracker"), exports);
+__exportStar(require("./signal"), exports);
+__exportStar(require("./system"), exports);
+__exportStar(require("./computeds/computedArray"), exports);
+__exportStar(require("./computeds/computedSet"), exports);

node_modules/computeds/out/signal.d.ts

@@ -0,0 +1,7 @@
+export interface Signal<T = any> {
+    (): T;
+    set(newValue: T): void;
+    markDirty(): void;
+}
+export declare function signal<T>(): Signal<T | undefined>;
+export declare function signal<T>(oldValue: T): Signal<T>;

node_modules/computeds/out/signal.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signal = void 0;
+const system_1 = require("./system");
+const dep_1 = require("./dep");
+function signal(oldValue) {
+    const dep = new dep_1.Dep();
+    const fn = (() => {
+        (0, system_1.track)(dep);
+        return oldValue;
+    });
+    fn.markDirty = () => {
+        (0, system_1.trigger)(dep, 3 /* DirtyLevels.Dirty */);
+    };
+    fn.set = (newValue) => {
+        if (!Object.is(oldValue, oldValue = newValue)) {
+            fn.markDirty();
+        }
+    };
+    return fn;
+}
+exports.signal = signal;

node_modules/computeds/out/system.d.ts

@@ -0,0 +1,17 @@
+import type { Dep } from './dep';
+import type { Tracker, TrackToken } from './tracker';
+export declare const enum DirtyLevels {
+    NotDirty = 0,
+    ComputedValueMaybeDirty = 1,
+    ComputedValueDirty = 2,
+    Dirty = 3
+}
+export declare let activeTrackers: Tracker[];
+export declare function pauseTracking(): void;
+export declare function resetTracking(): void;
+export declare function pauseEffect(): void;
+export declare function resetEffect(): void;
+export declare const depsMap: WeakMap<TrackToken, Dep[]>;
+export declare function track(dep: Dep): void;
+export declare function cleanupDepEffect(dep: Dep, tracker: Tracker): void;
+export declare function trigger(dep: Dep, dirtyLevel: DirtyLevels): void;

node_modules/computeds/out/system.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigger = exports.cleanupDepEffect = exports.track = exports.depsMap = exports.resetEffect = exports.pauseEffect = exports.resetTracking = exports.pauseTracking = exports.activeTrackers = void 0;
+exports.activeTrackers = [];
+let pauseEffectStack = 0;
+const pausedTrackers = [];
+const pausedEffects = [];
+function pauseTracking() {
+    pausedTrackers.push(exports.activeTrackers);
+    exports.activeTrackers = [];
+}
+exports.pauseTracking = pauseTracking;
+function resetTracking() {
+    exports.activeTrackers = pausedTrackers.pop();
+}
+exports.resetTracking = resetTracking;
+function pauseEffect() {
+    pauseEffectStack++;
+}
+exports.pauseEffect = pauseEffect;
+function resetEffect() {
+    pauseEffectStack--;
+    while (!pauseEffectStack && pausedEffects.length) {
+        pausedEffects.shift().effect();
+    }
+}
+exports.resetEffect = resetEffect;
+exports.depsMap = new WeakMap();
+const trackerRegistry = new FinalizationRegistry(trackToken => {
+    const deps = exports.depsMap.get(trackToken);
+    if (deps) {
+        for (const dep of deps) {
+            dep.delete(trackToken);
+        }
+        deps.length = 0;
+    }
+});
+function track(dep) {
+    if (exports.activeTrackers.length) {
+        const tracker = exports.activeTrackers[exports.activeTrackers.length - 1];
+        if (!tracker.trackToken) {
+            if (tracker.effect) {
+                tracker.trackToken = tracker;
+            }
+            else {
+                tracker.trackToken = new WeakRef(tracker);
+                trackerRegistry.register(tracker, tracker.trackToken, tracker);
+            }
+            exports.depsMap.set(tracker.trackToken, []);
+        }
+        const trackToken = tracker.trackToken;
+        const deps = exports.depsMap.get(trackToken);
+        if (deps) {
+            if (dep.get(tracker) !== tracker.trackId) {
+                dep.set(tracker, tracker.trackId);
+                const oldDep = deps[tracker.depsLength];
+                if (oldDep !== dep) {
+                    if (oldDep) {
+                        cleanupDepEffect(oldDep, tracker);
+                    }
+                    deps[tracker.depsLength++] = dep;
+                }
+                else {
+                    tracker.depsLength++;
+                }
+            }
+        }
+    }
+}
+exports.track = track;
+function cleanupDepEffect(dep, tracker) {
+    const trackId = dep.get(tracker);
+    if (trackId !== undefined && tracker.trackId !== trackId) {
+        dep.delete(tracker);
+    }
+}
+exports.cleanupDepEffect = cleanupDepEffect;
+function trigger(dep, dirtyLevel) {
+    pauseEffect();
+    for (const trackToken of dep.keys()) {
+        const tracker = trackToken.deref();
+        if (!tracker) {
+            continue;
+        }
+        if (tracker.dirtyLevel < dirtyLevel &&
+            (!tracker.runnings || dirtyLevel !== 2 /* DirtyLevels.ComputedValueDirty */)) {
+            const lastDirtyLevel = tracker.dirtyLevel;
+            tracker.dirtyLevel = dirtyLevel;
+            if (lastDirtyLevel === 0 /* DirtyLevels.NotDirty */ &&
+                (!tracker.queryings || dirtyLevel !== 2 /* DirtyLevels.ComputedValueDirty */)) {
+                tracker.spread();
+                if (tracker.effect) {
+                    pausedEffects.push(tracker);
+                }
+            }
+        }
+    }
+    resetEffect();
+}
+exports.trigger = trigger;

node_modules/computeds/out/tracker.d.ts

@@ -0,0 +1,17 @@
+import { DirtyLevels } from './system';
+export type TrackToken = WeakRef<Tracker> | Tracker;
+export declare class Tracker {
+    spread: () => void;
+    effect?: (() => void) | undefined;
+    trackToken?: TrackToken;
+    dirtyLevel: DirtyLevels;
+    trackId: number;
+    runnings: number;
+    queryings: number;
+    depsLength: number;
+    constructor(spread: () => void, effect?: (() => void) | undefined);
+    get dirty(): boolean;
+    track<T>(fn: () => T): T;
+    reset(): void;
+    deref(): this;
+}

node_modules/computeds/out/tracker.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tracker = void 0;
+const system_1 = require("./system");
+class Tracker {
+    constructor(spread, effect) {
+        this.spread = spread;
+        this.effect = effect;
+        this.dirtyLevel = 3 /* DirtyLevels.Dirty */;
+        this.trackId = 0;
+        this.runnings = 0;
+        this.queryings = 0;
+        this.depsLength = 0;
+    }
+    get dirty() {
+        if (this.dirtyLevel === 1 /* DirtyLevels.ComputedValueMaybeDirty */) {
+            this.dirtyLevel = 0 /* DirtyLevels.NotDirty */;
+            if (this.trackToken) {
+                const deps = system_1.depsMap.get(this.trackToken);
+                if (deps) {
+                    this.queryings++;
+                    (0, system_1.pauseTracking)();
+                    for (const dep of deps) {
+                        if (dep.computed) {
+                            dep.computed();
+                            if (this.dirtyLevel >= 2 /* DirtyLevels.ComputedValueDirty */) {
+                                break;
+                            }
+                        }
+                    }
+                    (0, system_1.resetTracking)();
+                    this.queryings--;
+                }
+            }
+        }
+        return this.dirtyLevel >= 2 /* DirtyLevels.ComputedValueDirty */;
+    }
+    track(fn) {
+        try {
+            system_1.activeTrackers.push(this);
+            this.runnings++;
+            preCleanup(this);
+            return fn();
+        }
+        finally {
+            postCleanup(this);
+            this.runnings--;
+            system_1.activeTrackers.pop();
+            if (!this.runnings) {
+                this.dirtyLevel = 0 /* DirtyLevels.NotDirty */;
+            }
+        }
+    }
+    reset() {
+        preCleanup(this);
+        postCleanup(this);
+        this.dirtyLevel = 3 /* DirtyLevels.Dirty */;
+    }
+    deref() {
+        return this;
+    }
+}
+exports.Tracker = Tracker;
+function preCleanup(tracker) {
+    tracker.trackId++;
+    tracker.depsLength = 0;
+}
+function postCleanup(tracker) {
+    if (tracker.trackToken) {
+        const deps = system_1.depsMap.get(tracker.trackToken);
+        if (deps && deps.length > tracker.depsLength) {
+            for (let i = tracker.depsLength; i < deps.length; i++) {
+                (0, system_1.cleanupDepEffect)(deps[i], tracker);
+            }
+            deps.length = tracker.depsLength;
+        }
+    }
+}