@ng-org/alien-deepsignals 0.1.2-alpha.2 → 0.1.2-alpha.4

package/dist/test/frontend/utils/perfScenarios.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScenarioAdapter = registerScenarioAdapter;
+exports.registerSharedStateAdapter = registerSharedStateAdapter;
+exports.registerPerfRunners = registerPerfRunners;
+exports.runScenarioImmediately = runScenarioImmediately;
+const state_1 = require("./state");
+const renderMetrics_1 = require("./renderMetrics");
+const frameworks = ["react", "vue", "svelte"];
+const DEFAULT_COUNTS = {
+    primitives: 200,
+    nested: 120,
+    arrays: 80,
+    sets: 64,
+    objectSet: 80,
+    warmupRuns: 0,
+    repeatRuns: 1,
+};
+const adapters = {};
+const now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+const settle = () => new Promise((resolve) => {
+    if (typeof window !== "undefined" &&
+        typeof window.requestAnimationFrame === "function") {
+        window.requestAnimationFrame(() => resolve());
+    }
+    else {
+        setTimeout(() => resolve(), 16);
+    }
+});
+const withDefaults = (counts) => ({
+    primitives: counts?.primitives ?? DEFAULT_COUNTS.primitives,
+    nested: counts?.nested ?? DEFAULT_COUNTS.nested,
+    arrays: counts?.arrays ?? DEFAULT_COUNTS.arrays,
+    sets: counts?.sets ?? DEFAULT_COUNTS.sets,
+    objectSet: counts?.objectSet ?? DEFAULT_COUNTS.objectSet,
+    warmupRuns: counts?.warmupRuns ?? DEFAULT_COUNTS.warmupRuns,
+    repeatRuns: counts?.repeatRuns ?? DEFAULT_COUNTS.repeatRuns,
+});
+const diffNumericMap = (after, before) => {
+    const keys = new Set([...Object.keys(after), ...Object.keys(before)]);
+    const result = {};
+    for (const key of keys) {
+        result[key] = (after[key] ?? 0) - (before[key] ?? 0);
+    }
+    return result;
+};
+const diffObjectRenderCounts = (after, before) => {
+    const scope = new Set([...Object.keys(after), ...Object.keys(before)]);
+    const result = {};
+    for (const framework of scope) {
+        const afterEntries = after[framework] ?? {};
+        const beforeEntries = before[framework] ?? {};
+        const ids = new Set([
+            ...Object.keys(afterEntries),
+            ...Object.keys(beforeEntries),
+        ]);
+        const diff = {};
+        for (const id of ids) {
+            diff[id] = (afterEntries[id] ?? 0) - (beforeEntries[id] ?? 0);
+        }
+        result[framework] = diff;
+    }
+    return result;
+};
+const measureBlock = async (name, action) => {
+    const beforeRenders = (0, renderMetrics_1.snapshotRenderCounts)();
+    const beforeObjectRenders = (0, renderMetrics_1.snapshotObjectRenderCounts)();
+    const start = now();
+    await action();
+    await settle();
+    const duration = now() - start;
+    const afterRenders = (0, renderMetrics_1.snapshotRenderCounts)();
+    const afterObjectRenders = (0, renderMetrics_1.snapshotObjectRenderCounts)();
+    return {
+        name,
+        duration,
+        renderCounts: diffNumericMap(afterRenders, beforeRenders),
+        objectRenderCounts: diffObjectRenderCounts(afterObjectRenders, beforeObjectRenders),
+    };
+};
+const accumulateNumericMap = (target, delta) => {
+    for (const [key, value] of Object.entries(delta)) {
+        target[key] = (target[key] ?? 0) + value;
+    }
+};
+const accumulateObjectRenderCounts = (target, delta) => {
+    for (const [scope, entries] of Object.entries(delta)) {
+        const targetEntries = (target[scope] ??= {});
+        for (const [id, value] of Object.entries(entries)) {
+            targetEntries[id] = (targetEntries[id] ?? 0) + value;
+        }
+    }
+};
+const averageNumericMap = (source, divisor) => {
+    const result = {};
+    for (const [key, value] of Object.entries(source)) {
+        result[key] = Math.round(value / divisor);
+    }
+    return result;
+};
+const averageObjectRenderCounts = (source, divisor) => {
+    const result = {};
+    for (const [scope, entries] of Object.entries(source)) {
+        const averaged = {};
+        for (const [id, value] of Object.entries(entries)) {
+            averaged[id] = Math.round(value / divisor);
+        }
+        result[scope] = averaged;
+    }
+    return result;
+};
+const getAdapter = (framework, variant) => adapters[framework]?.[variant];
+const executeScenarioRun = async (framework, variant, adapter, resolved, runIndex) => {
+    await adapter.reset();
+    await settle();
+    const blocks = {};
+    blocks.mutateExisting = await measureBlock("mutateExisting", () => adapter.mutateExisting(resolved.objectSet));
+    blocks.bulkMutate = await measureBlock("bulkMutate", () => adapter.bulkMutate(resolved.primitives));
+    blocks.batchAddRemove = await measureBlock("batchAddRemove", () => adapter.batchAddRemove(resolved.sets));
+    const totalDuration = Object.values(blocks).reduce((sum, block) => sum + block.duration, 0);
+    const run = {
+        runIndex,
+        totalDuration,
+        blocks,
+    };
+    return run;
+};
+async function runScenarioWithAdapter(framework, variant, adapter, counts) {
+    const resolved = withDefaults(counts);
+    const warmups = Math.max(0, resolved.warmupRuns);
+    const repeats = Math.max(1, resolved.repeatRuns);
+    for (let i = 0; i < warmups; i += 1) {
+        await executeScenarioRun(framework, variant, adapter, resolved, i);
+    }
+    const runs = [];
+    for (let i = 0; i < repeats; i += 1) {
+        runs.push(await executeScenarioRun(framework, variant, adapter, resolved, warmups + i));
+    }
+    const aggregatedBlocks = {};
+    const blockSums = {};
+    for (const run of runs) {
+        Object.entries(run.blocks).forEach(([name, block]) => {
+            const accumulator = (blockSums[name] ??= {
+                name,
+                duration: 0,
+                renderCounts: {},
+                objectRenderCounts: {},
+            });
+            accumulator.duration += block.duration;
+            accumulateNumericMap(accumulator.renderCounts, block.renderCounts);
+            accumulateObjectRenderCounts(accumulator.objectRenderCounts, block.objectRenderCounts);
+        });
+    }
+    Object.entries(blockSums).forEach(([name, block]) => {
+        aggregatedBlocks[name] = {
+            name,
+            duration: block.duration / repeats,
+            renderCounts: averageNumericMap(block.renderCounts, repeats),
+            objectRenderCounts: averageObjectRenderCounts(block.objectRenderCounts, repeats),
+        };
+    });
+    const averageTotalDuration = runs.reduce((sum, run) => sum + run.totalDuration, 0) / repeats;
+    const result = {
+        framework,
+        variant,
+        totalDuration: averageTotalDuration,
+        blocks: aggregatedBlocks,
+        runCount: repeats,
+        warmupCount: warmups,
+        runs,
+        completedAt: Date.now(),
+    };
+    if (typeof window !== "undefined") {
+        window.perfSuite?.publishResult?.(result);
+    }
+    return result;
+}
+function registerScenarioAdapter(framework, variant, adapter) {
+    (adapters[framework] ??= {})[variant] = adapter;
+    registerPerfRunners();
+    return () => {
+        if (adapters[framework]?.[variant] === adapter) {
+            delete adapters[framework][variant];
+        }
+    };
+}
+const createSharedStateAdapter = () => {
+    if (typeof window !== "undefined") {
+        window.__adapterSharedIdentity =
+            state_1.sharedState === window.sharedState;
+    }
+    let syntheticCounter = 0;
+    const generateId = () => `perf-object-${++syntheticCounter}`;
+    const bumpGlobalNumericFields = () => {
+        state_1.sharedState.numValue += 2;
+        state_1.sharedState.hiddenValue += 2;
+        state_1.sharedState.objectValue.nestedNum += 2;
+        state_1.sharedState.count += 2;
+        const baseArray = state_1.sharedState.arrayValue;
+        for (let i = 0; i < baseArray.length; i += 1) {
+            baseArray[i] += 2;
+        }
+        const nestedArray = state_1.sharedState.objectValue.nestedArray;
+        for (let i = 0; i < nestedArray.length; i += 1) {
+            nestedArray[i] += 2;
+        }
+    };
+    return {
+        reset() {
+            (0, state_1.resetSharedState)();
+        },
+        mutateExisting(iterations) {
+            const entries = Array.from(state_1.sharedState.objectSet.values());
+            if (!entries.length)
+                return;
+            for (let cycle = 0; cycle < iterations; cycle += 1) {
+                let idx = 0;
+                for (const entry of entries) {
+                    entry.label = `Object ${entry["@id"]} #${cycle}-${idx}`;
+                    entry.count += 2;
+                    idx += 1;
+                }
+                bumpGlobalNumericFields();
+            }
+        },
+        bulkMutate(iterations) {
+            const entries = Array.from(state_1.sharedState.objectSet.values());
+            if (!entries.length)
+                return;
+            for (let i = 0; i < iterations; i += 1) {
+                for (const entry of entries) {
+                    entry.count += 2;
+                }
+                bumpGlobalNumericFields();
+            }
+        },
+        batchAddRemove(iterations) {
+            const created = [];
+            for (let i = 0; i < iterations; i += 1) {
+                const id = generateId();
+                state_1.sharedState.objectSet.add({
+                    "@id": id,
+                    label: `Perf entry ${id}`,
+                    count: i,
+                });
+                created.push(id);
+            }
+            for (const id of created) {
+                for (const entry of state_1.sharedState.objectSet) {
+                    if (entry["@id"] === id) {
+                        state_1.sharedState.objectSet.delete(entry);
+                        break;
+                    }
+                }
+            }
+        },
+    };
+};
+function registerSharedStateAdapter(framework) {
+    return registerScenarioAdapter(framework, "deep", createSharedStateAdapter());
+}
+function registerPerfRunners() {
+    if (typeof window === "undefined")
+        return false;
+    const suite = window.perfSuite;
+    if (!suite?.registerRunner)
+        return false;
+    Object.keys(adapters).forEach((framework) => {
+        const variants = adapters[framework];
+        if (!variants)
+            return;
+        Object.keys(variants).forEach((variant) => {
+            const adapter = variants[variant];
+            if (!adapter)
+                return;
+            suite.registerRunner(framework, variant, (counts) => runScenarioWithAdapter(framework, variant, adapter, counts));
+        });
+    });
+    return true;
+}
+async function runScenarioImmediately(framework, variant, counts) {
+    const adapter = getAdapter(framework, variant);
+    if (!adapter) {
+        throw new Error(`No perf scenario adapter registered for ${framework}:${variant}`);
+    }
+    return runScenarioWithAdapter(framework, variant, adapter, counts);
+}

package/dist/test/frontend/utils/renderMetrics.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    interface Window {
+        renderCounts?: Record<string, number>;
+        renderEventCounts?: Record<string, number>;
+        objectRenderCounts?: Record<string, Record<string, number>>;
+    }
+}
+export declare function recordRender(framework: string, count: number): void;
+export declare function getRenderCount(framework: string): number;
+export declare function snapshotRenderCounts(): Record<string, number>;
+export declare function recordObjectRender(framework: string, objectId: string, count: number): void;
+export declare function snapshotObjectRenderCounts(): Record<string, Record<string, number>>;
+//# sourceMappingURL=renderMetrics.d.ts.map

package/dist/test/frontend/utils/renderMetrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderMetrics.d.ts","sourceRoot":"","sources":["../../../../src/test/frontend/utils/renderMetrics.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QACZ,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC3C,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;KAC/D;CACJ;AAQD,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAK5D;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAI7D;AAED,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,QAOhB;AAED,wBAAgB,0BAA0B,IAAI,MAAM,CAChD,MAAM,EACN,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CACzB,CAKA"}

package/dist/test/frontend/utils/renderMetrics.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordRender = recordRender;
+exports.getRenderCount = getRenderCount;
+exports.snapshotRenderCounts = snapshotRenderCounts;
+exports.recordObjectRender = recordObjectRender;
+exports.snapshotObjectRenderCounts = snapshotObjectRenderCounts;
+const incrementRenderEvents = (framework) => {
+    if (typeof window === "undefined")
+        return;
+    const events = (window.renderEventCounts ??= {});
+    events[framework] = (events[framework] ?? 0) + 1;
+};
+function recordRender(framework, count) {
+    if (typeof window === "undefined")
+        return;
+    const store = (window.renderCounts ??= {});
+    store[framework] = count;
+    incrementRenderEvents(framework);
+}
+function getRenderCount(framework) {
+    if (typeof window === "undefined")
+        return 0;
+    return window.renderCounts?.[framework] ?? 0;
+}
+function snapshotRenderCounts() {
+    if (typeof window === "undefined")
+        return {};
+    const source = window.renderEventCounts ?? {};
+    return Object.fromEntries(Object.entries(source));
+}
+function recordObjectRender(framework, objectId, count) {
+    if (typeof window === "undefined")
+        return;
+    const host = (window.objectRenderCounts ??= {});
+    const entries = (host[framework] ??= {});
+    entries[objectId] = count;
+    incrementRenderEvents(framework);
+}
+function snapshotObjectRenderCounts() {
+    if (typeof window === "undefined")
+        return {};
+    const source = window.objectRenderCounts ?? {};
+    return JSON.parse(JSON.stringify(source));
+}

package/dist/test/frontend/utils/state.d.ts

@@ -0,0 +1,57 @@
+import { type TestState } from "./mockData.js";
+declare global {
+    interface Window {
+        sharedState?: TestState;
+        testHarness?: {
+            resetState: () => void;
+            noopMutation: (path: string) => void;
+            getRenderCounts: () => Record<string, number>;
+            ready: boolean;
+        };
+        perfSuite?: {
+            registerRunner: (framework: string, variant: string, runner: (counts: PerfScenarioCounts) => Promise<PerfScenarioResult>) => void;
+            runScenario?: (framework: string, variant: string, counts: PerfScenarioCounts) => Promise<PerfScenarioResult | undefined>;
+            runners?: Record<string, Record<string, (counts: PerfScenarioCounts) => Promise<PerfScenarioResult>>>;
+            latestResults?: Record<string, Record<string, PerfScenarioResult>>;
+            listeners?: Set<(result: PerfScenarioResult) => void>;
+            publishResult?: (result: PerfScenarioResult) => void;
+            subscribe?: (listener: (result: PerfScenarioResult) => void) => () => void;
+        };
+        subscribeSharedState?: (listener: () => void) => () => void;
+        sharedStateVersion?: number;
+    }
+}
+export type PerfScenarioCounts = {
+    primitives?: number;
+    nested?: number;
+    arrays?: number;
+    sets?: number;
+    objectSet?: number;
+    warmupRuns?: number;
+    repeatRuns?: number;
+};
+export type PerfVariant = "deep" | "native";
+export type PerfScenarioBlockResult = {
+    name: string;
+    duration: number;
+    renderCounts: Record<string, number>;
+    objectRenderCounts: Record<string, Record<string, number>>;
+};
+export type PerfScenarioRun = {
+    runIndex: number;
+    totalDuration: number;
+    blocks: Record<string, PerfScenarioBlockResult>;
+};
+export type PerfScenarioResult = {
+    framework: string;
+    variant: PerfVariant;
+    totalDuration: number;
+    blocks: Record<string, PerfScenarioBlockResult>;
+    runCount: number;
+    warmupCount: number;
+    runs?: PerfScenarioRun[];
+    completedAt?: number;
+};
+export declare const sharedState: import("../../../types.js").DeepSignalObject<TestState>;
+export declare function resetSharedState(): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/test/frontend/utils/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/test/frontend/utils/state.ts"],"names":[],"mappings":"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"}

package/dist/test/frontend/utils/state.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedState = void 0;
+exports.resetSharedState = resetSharedState;
+const deepSignal_js_1 = require("../../../deepSignal.js");
+const mockData_js_1 = require("./mockData.js");
+const paths_js_1 = require("./paths.js");
+const createState = () => (0, deepSignal_js_1.deepSignal)((0, mockData_js_1.buildInitialState)());
+exports.sharedState = createState();
+const sharedStateListeners = new Set();
+const notifySharedStateListeners = () => {
+    if (!sharedStateListeners.size)
+        return;
+    sharedStateListeners.forEach((listener) => {
+        try {
+            listener();
+        }
+        catch (error) {
+            console.error("sharedState listener failed", error);
+        }
+    });
+};
+const now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+const microtask = () => new Promise((resolve) => setTimeout(resolve, 0));
+function resetSharedState() {
+    const next = (0, mockData_js_1.buildInitialState)();
+    for (const key of Object.keys(exports.sharedState)) {
+        delete exports.sharedState[key];
+    }
+    Object.assign(exports.sharedState, next);
+}
+const measure = async (mutator, settle = true) => {
+    const start = now();
+    mutator();
+    if (settle)
+        await microtask();
+    return now() - start;
+};
+if (typeof window !== "undefined") {
+    window.sharedState = exports.sharedState;
+    const harness = (window.testHarness ??= {
+        resetState: () => undefined,
+        noopMutation: () => undefined,
+        getRenderCounts: () => (window.renderCounts ?? {}),
+        ready: false,
+    });
+    harness.resetState = () => resetSharedState();
+    harness.noopMutation = (path) => {
+        const current = (0, paths_js_1.getByPath)(exports.sharedState, path);
+        (0, paths_js_1.setByPath)(exports.sharedState, path, current);
+    };
+    harness.ready = true;
+    const perfSuite = (window.perfSuite ??= {
+        runners: {},
+        latestResults: {},
+        listeners: new Set(),
+        registerRunner(framework, variant, runner) {
+            const runnerMap = (this.runners ??= {});
+            const frameworkRunners = (runnerMap[framework] ??= {});
+            frameworkRunners[variant] = runner;
+        },
+        publishResult(result) {
+            const latest = (this.latestResults ??= {});
+            (latest[result.framework] ??= {})[result.variant] = result;
+            this.listeners?.forEach((listener) => listener(result));
+        },
+        subscribe(listener) {
+            this.listeners?.add(listener);
+            return () => this.listeners?.delete(listener);
+        },
+        async runScenario(framework, variant, counts) {
+            const runnerMap = (this.runners ??= {});
+            const runner = runnerMap[framework]?.[variant];
+            if (!runner)
+                return undefined;
+            return runner(counts);
+        },
+    });
+}

package/dist/test/lib/core.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=core.test.d.ts.map

package/dist/test/lib/core.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.test.d.ts","sourceRoot":"","sources":["../../../src/test/lib/core.test.ts"],"names":[],"mappings":""}

package/dist/test/lib/core.test.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const core_1 = require("../../core");
+const deepSignal_1 = require("../../deepSignal");
+(0, vitest_1.describe)("core.ts coverage", () => {
+    (0, vitest_1.it)("signal tagging helpers (.value/.peek/.get/.set)", () => {
+        const s = (0, core_1.signal)(1);
+        (0, vitest_1.expect)((0, core_1.isSignal)(s)).toBe(true);
+        (0, vitest_1.expect)(s.value).toBe(1);
+        (0, vitest_1.expect)(s.peek()).toBe(1);
+        (0, vitest_1.expect)(s.get()).toBe(1);
+        s.set(2);
+        (0, vitest_1.expect)(s.value).toBe(2);
+        s.value = 3;
+        (0, vitest_1.expect)(s.peek()).toBe(3);
+    });
+    (0, vitest_1.it)("computed tagging helpers (.value/.peek/.get)", () => {
+        const s = (0, core_1.signal)(2);
+        const c = (0, core_1.computed)(() => s.value * 2);
+        (0, vitest_1.expect)((0, core_1.isSignal)(c)).toBe(true);
+        (0, vitest_1.expect)(c.value).toBe(4);
+        (0, vitest_1.expect)(c.peek()).toBe(4);
+        (0, vitest_1.expect)(c.get()).toBe(4);
+        s.value = 3;
+        (0, vitest_1.expect)(c.value).toBe(6);
+    });
+});
+(0, vitest_1.describe)("deepSignal.ts extra branches", () => {
+    (0, vitest_1.it)("access well-known symbol property returns raw value and not a signal", () => {
+        const tag = Symbol.toStringTag;
+        const ds = (0, deepSignal_1.deepSignal)({ [tag]: "Custom", x: 1 });
+        const val = ds[tag];
+        (0, vitest_1.expect)(val).toBe("Custom");
+    });
+    (0, vitest_1.it)("access Set Symbol.iterator.toString() key path (skip branch)", () => {
+        const ds = (0, deepSignal_1.deepSignal)({ set: new Set([1]) });
+        const iterKey = Symbol.iterator.toString(); // 'Symbol(Symbol.iterator)'
+        // Accessing this string property triggers skip branch (no special handling needed)
+        const maybe = ds.set[iterKey];
+        // underlying Set likely has undefined for that string key
+        (0, vitest_1.expect)(maybe).toBeUndefined();
+    });
+});

package/dist/test/lib/deepSignalOptions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deepSignalOptions.test.d.ts.map

package/dist/test/lib/deepSignalOptions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepSignalOptions.test.d.ts","sourceRoot":"","sources":["../../../src/test/lib/deepSignalOptions.test.ts"],"names":[],"mappings":""}