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

package/dist/test/frontend/astro-app/src/components/perf/react/ReactPerfNative.js

@@ -0,0 +1,184 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const mockData_1 = require("../../../../../utils/mockData");
+const renderMetrics_1 = require("../../../../../utils/renderMetrics");
+const perfScenarios_1 = require("../../../../../utils/perfScenarios");
+const ObjectRow = ({ entry, updateEntries }) => {
+    const rowRenderCount = (0, react_1.useRef)(0);
+    rowRenderCount.current += 1;
+    (0, renderMetrics_1.recordObjectRender)("react", entry["@id"], rowRenderCount.current);
+    return (<div className="object-row" data-entry-id={entry["@id"]} data-render-count={rowRenderCount.current}>
+            <span className="object-id">{entry["@id"]}</span>
+            <input type="text" data-role="label" value={entry.label} onChange={(event) => updateEntries((draft) => {
+            const target = draft.find((item) => item["@id"] === entry["@id"]);
+            if (target)
+                target.label = event.target.value;
+        })}/>
+            <input type="number" data-role="count-input" value={entry.count} onChange={(event) => updateEntries((draft) => {
+            const target = draft.find((item) => item["@id"] === entry["@id"]);
+            if (target)
+                target.count = Number(event.target.value || 0);
+        })}/>
+            <span data-role="count">{entry.count}</span>
+            <button type="button" data-action="increment" onClick={() => updateEntries((draft) => {
+            const target = draft.find((item) => item["@id"] === entry["@id"]);
+            if (target)
+                target.count += 1;
+        })}>
+                +1
+            </button>
+        </div>);
+};
+const cloneInitialEntries = () => (0, mockData_1.cloneDefaultObjectSet)();
+const ReactPerfNative = () => {
+    const [objectSet, setObjectSet] = (0, react_1.useState)(() => new Set(cloneInitialEntries()));
+    const renderCount = (0, react_1.useRef)(0);
+    const counterRef = (0, react_1.useRef)(0);
+    const [busy, setBusy] = (0, react_1.useState)(false);
+    renderCount.current += 1;
+    (0, react_1.useEffect)(() => {
+        (0, renderMetrics_1.recordRender)("react", renderCount.current);
+    });
+    const entries = (0, react_1.useMemo)(() => Array.from(objectSet.values()), [objectSet]);
+    const updateEntries = (0, react_1.useCallback)((mutate) => {
+        setObjectSet((prev) => {
+            const draft = Array.from(prev.values()).map((entry) => ({
+                ...entry,
+            }));
+            mutate(draft);
+            return new Set(draft);
+        });
+    }, []);
+    (0, react_1.useEffect)(() => {
+        const dispose = (0, perfScenarios_1.registerScenarioAdapter)("react", "native", {
+            reset: () => {
+                setObjectSet(new Set(cloneInitialEntries()));
+            },
+            mutateExisting: (iterations) => {
+                updateEntries((draft) => {
+                    if (!draft.length)
+                        return;
+                    for (let cycle = 0; cycle < iterations; cycle += 1) {
+                        draft.forEach((entry, index) => {
+                            entry.label = `POJO ${entry["@id"]} #${cycle}-${index}`;
+                            entry.count += 2;
+                        });
+                    }
+                });
+            },
+            bulkMutate: (iterations) => {
+                updateEntries((draft) => {
+                    if (!draft.length)
+                        return;
+                    for (let i = 0; i < iterations; i += 1) {
+                        for (const entry of draft) {
+                            entry.count += 2;
+                        }
+                    }
+                });
+            },
+            batchAddRemove: (iterations) => {
+                const additions = [];
+                for (let i = 0; i < iterations; i += 1) {
+                    counterRef.current += 1;
+                    const id = `react-native-${counterRef.current}`;
+                    additions.push({
+                        "@id": id,
+                        label: `Native ${id}`,
+                        count: i,
+                    });
+                }
+                updateEntries((draft) => {
+                    draft.push(...additions);
+                });
+                updateEntries((draft) => {
+                    const start = Math.max(draft.length - additions.length, 0);
+                    draft.splice(start, additions.length);
+                });
+            },
+        });
+        return () => dispose();
+    }, [updateEntries]);
+    const handleAddEntry = () => {
+        counterRef.current += 1;
+        const id = `react-native-${counterRef.current}`;
+        updateEntries((draft) => {
+            draft.push({ "@id": id, label: `Native ${id}`, count: 0 });
+        });
+    };
+    const handleRemoveEntry = () => {
+        updateEntries((draft) => {
+            draft.pop();
+        });
+    };
+    const handleRunScenario = async () => {
+        try {
+            setBusy(true);
+            await (0, perfScenarios_1.runScenarioImmediately)("react", "native");
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    return (<section className="perf-panel react" data-field="objectSet">
+            <h2 className="title">react (native state)</h2>
+            <div className="render-meta" data-render-count={renderCount.current}>
+                Render #{renderCount.current}
+            </div>
+            <div className="field" data-field="objectSet">
+                <legend>objectSet entries</legend>
+                <div className="set-controls">
+                    <span data-role="set-size">Size: {objectSet.size}</span>
+                    <div>
+                        <button type="button" onClick={handleAddEntry}>
+                            Add entry
+                        </button>
+                        <button type="button" onClick={handleRemoveEntry}>
+                            Remove entry
+                        </button>
+                        <button type="button" data-action="run-scenario" onClick={handleRunScenario} disabled={busy}>
+                            {busy ? "Running…" : "Run perf scenario"}
+                        </button>
+                    </div>
+                </div>
+                <div className="object-set">
+                    {entries.map((entry) => (<ObjectRow key={entry["@id"]} entry={entry} updateEntries={updateEntries}/>))}
+                </div>
+            </div>
+        </section>);
+};
+exports.default = ReactPerfNative;

package/dist/test/frontend/playwright/crossFrameworkHooks.spec.d.ts

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

package/dist/test/frontend/playwright/crossFrameworkHooks.spec.d.ts.map

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

package/dist/test/frontend/playwright/crossFrameworkHooks.spec.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const mockData_1 = require("../utils/mockData");
+const frameworks = ["react", "vue", "svelte"];
+const alphaEntry = Array.from(mockData_1.mockTestObject.objectSet).find((entry) => entry["@id"] === "urn:object:alpha");
+if (!alphaEntry) {
+    throw new Error("mock data must include an objectSet entry with @id urn:object:alpha");
+}
+const fieldLocator = (page, framework, key) => page.locator(`.${framework} [data-field='${key}']`);
+const createTextPlan = (key, nextValue) => ({
+    key,
+    mutate: async (page, framework) => {
+        const field = fieldLocator(page, framework, key);
+        const input = field.locator("input[data-role='editor']");
+        await input.fill(nextValue);
+        await input.blur();
+    },
+    assert: async (page, framework) => {
+        const field = fieldLocator(page, framework, key);
+        await (0, test_1.expect)(field.locator("[data-role='value']")).toHaveText(nextValue);
+    },
+});
+const createNumberPlan = (key, nextValue) => ({
+    key,
+    mutate: async (page, framework) => {
+        const field = fieldLocator(page, framework, key);
+        const input = field.locator("input[data-role='editor']");
+        await input.fill(String(nextValue));
+        await input.blur();
+    },
+    assert: async (page, framework) => {
+        const field = fieldLocator(page, framework, key);
+        await (0, test_1.expect)(field.locator("[data-role='value']")).toHaveText(String(nextValue));
+    },
+});
+const createBooleanPlan = (key, nextValue) => ({
+    key,
+    mutate: async (page, framework) => {
+        const field = fieldLocator(page, framework, key);
+        const input = field.locator("input[data-role='editor']");
+        await input.setChecked(nextValue);
+    },
+    assert: async (page, framework) => {
+        const field = fieldLocator(page, framework, key);
+        await (0, test_1.expect)(field.locator("[data-role='value']")).toHaveText(String(nextValue));
+    },
+});
+const createArrayPlan = (key, initialLength, additions) => ({
+    key,
+    mutate: async (page, framework) => {
+        const field = fieldLocator(page, framework, key);
+        const addButton = field.locator("button[data-action='push']");
+        for (let i = 0; i < additions; i++) {
+            await addButton.click();
+        }
+    },
+    assert: async (page, framework) => {
+        const expectedLength = initialLength + additions;
+        const field = fieldLocator(page, framework, key);
+        await (0, test_1.expect)(field.locator("[data-role='array-length']")).toHaveText(`Length: ${expectedLength}`);
+    },
+});
+const createSetPlan = (key, initialSize, additions) => ({
+    key,
+    mutate: async (page, framework) => {
+        const field = fieldLocator(page, framework, key);
+        const addButton = field.locator("button[data-action='add']");
+        for (let i = 0; i < additions; i++) {
+            await addButton.click();
+        }
+    },
+    assert: async (page, framework) => {
+        const expectedSize = initialSize + additions;
+        const field = fieldLocator(page, framework, key);
+        await (0, test_1.expect)(field.locator("[data-role='set-size']")).toHaveText(`Size: ${expectedSize}`);
+    },
+});
+const createObjectSetPlan = (entryId, nextLabel, expectedCount) => ({
+    key: "objectSet",
+    mutate: async (page, framework) => {
+        const entry = fieldLocator(page, framework, "objectSet").locator(`[data-entry-id='${entryId}']`);
+        const labelInput = entry.locator("input[data-role='label']");
+        await labelInput.fill(nextLabel);
+        await labelInput.blur();
+        await entry.locator("button[data-action='increment']").click();
+    },
+    assert: async (page, framework) => {
+        const entry = fieldLocator(page, framework, "objectSet").locator(`[data-entry-id='${entryId}']`);
+        await (0, test_1.expect)(entry.locator("input[data-role='label']")).toHaveValue(nextLabel);
+        await (0, test_1.expect)(entry.locator("[data-role='count']")).toHaveText(String(expectedCount));
+    },
+});
+const fieldPlans = [
+    createTextPlan("type", "TestObjectUpdated"),
+    createTextPlan("stringValue", "string_changed"),
+    createNumberPlan("numValue", 1337),
+    createBooleanPlan("boolValue", false),
+    createTextPlan("objectValue.nestedString", "nested_changed"),
+    createNumberPlan("objectValue.nestedNum", 77),
+    createArrayPlan("arrayValue", mockData_1.mockTestObject.arrayValue.length, 2),
+    createArrayPlan("objectValue.nestedArray", mockData_1.mockTestObject.objectValue.nestedArray.length, 1),
+    createSetPlan("setValue", mockData_1.mockTestObject.setValue.size, 1),
+    createObjectSetPlan(alphaEntry["@id"], "Alpha updated", alphaEntry.count + 1),
+];
+const getRenderCounts = (page) => page.evaluate(() => ({ ...(window.renderCounts ?? {}) }));
+const waitForFrameworkReady = async (page, framework) => {
+    try {
+        await page.waitForSelector(`.${framework} .title`, {
+            state: "visible",
+        });
+    }
+    catch (error) {
+        throw new Error(`${framework} panel did not render within 10 seconds: ${error}`);
+    }
+};
+test_1.test.beforeEach(async ({ page }) => {
+    await page.goto("/");
+    await waitForFrameworkReady(page, "react");
+    await waitForFrameworkReady(page, "vue");
+    await waitForFrameworkReady(page, "svelte");
+    await page.waitForFunction("window.testHarness?.ready === true");
+    await page.evaluate(() => window.testHarness?.resetState());
+});
+(0, test_1.test)("components load", async ({ page }) => {
+    for (const framework of frameworks) {
+        await (0, test_1.expect)(page.locator(`.${framework} .title`)).toHaveText(framework);
+    }
+});
+test_1.test.describe("cross framework propagation", () => {
+    for (const source of frameworks) {
+        for (const target of frameworks) {
+            if (source === target)
+                continue;
+            (0, test_1.test)(`${source} edits propagate to ${target}`, async ({ page }) => {
+                await test_1.test.step(`mutate in ${source}`, async () => {
+                    for (const plan of fieldPlans) {
+                        await plan.mutate(page, source);
+                    }
+                });
+                await page.waitForTimeout(100);
+                await test_1.test.step(`assert in ${target}`, async () => {
+                    for (const plan of fieldPlans) {
+                        await plan.assert(page, target);
+                    }
+                });
+                await test_1.test.step(`validate mutated source ${source}`, async () => {
+                    for (const plan of fieldPlans) {
+                        await plan.assert(page, source);
+                    }
+                });
+            });
+        }
+    }
+});
+(0, test_1.test)("hidden mutations do not trigger renders", async ({ page }) => {
+    const before = await getRenderCounts(page);
+    await page.evaluate(() => {
+        if (window.sharedState) {
+            window.sharedState.hiddenValue = Math.random();
+        }
+    });
+    await page.waitForTimeout(50);
+    const after = await getRenderCounts(page);
+    for (const framework of frameworks) {
+        const previous = before[framework] ?? 0;
+        const current = after[framework] ?? 0;
+        (0, test_1.expect)(current).toBeGreaterThanOrEqual(previous);
+        (0, test_1.expect)(current - previous).toBeLessThanOrEqual(2);
+    }
+});

package/dist/test/frontend/playwright/perfSuite.spec.d.ts

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

package/dist/test/frontend/playwright/perfSuite.spec.d.ts.map

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

package/dist/test/frontend/playwright/perfSuite.spec.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const frameworks = ["react", "vue", "svelte"];
+const scenarios = frameworks.flatMap((framework) => [
+    { framework, variant: "deep" },
+    { framework, variant: "native" },
+]);
+const waitForFrameworkReady = async (page, framework) => {
+    await page.waitForSelector(`.${framework} .title`, {
+        state: "visible",
+    });
+    await page.waitForFunction((name) => (window.renderEventCounts?.[name] ?? 0) > 0, framework, { timeout: 5_000 });
+};
+const waitForPerfSuiteReady = async (page, framework, variant) => {
+    await page.waitForFunction(({ framework, variant }) => Boolean(window.perfSuite?.runners?.[framework]?.[variant]), { framework, variant }, { timeout: 15_000 });
+};
+const navigateToScenario = async (page, framework, variant) => {
+    await page.goto(`/perf?framework=${framework}&variant=${variant}`);
+    await waitForFrameworkReady(page, framework);
+    await waitForPerfSuiteReady(page, framework, variant);
+};
+const runScenario = async (page, framework, variant, counts) => {
+    return page.evaluate(({ framework, variant, counts }) => window.perfSuite?.runScenario?.(framework, variant, counts), { framework, variant, counts });
+};
+const formatDuration = (value) => typeof value === "number" ? `${value.toFixed(1)}ms` : "n/a";
+const logScenarioOverview = (framework, variant, result) => {
+    if (!result) {
+        // eslint-disable-next-line no-console
+        console.log(`[perfSuite] ${framework}/${variant} produced no result`);
+        return;
+    }
+    const mutate = result.blocks?.mutateExisting;
+    const renderCount = mutate?.renderCounts?.[framework] ?? 0;
+    const touchedIds = Object.keys(mutate?.objectRenderCounts?.[framework] ?? {});
+    const sample = touchedIds.slice(0, 5);
+    const sampleDisplay = sample.length
+        ? ` [${sample.join(", ")}${touchedIds.length > sample.length ? ", ..." : ""}]`
+        : "";
+    // eslint-disable-next-line no-console
+    console.log(`[perfSuite] ${framework}/${variant} total=${formatDuration(result.totalDuration)} mutate=${formatDuration(mutate?.duration)} renders=${renderCount} touched=${touchedIds.length}${sampleDisplay}`);
+};
+test_1.test.describe("perfSuite object-set scenarios", () => {
+    const baseCounts = {
+        primitives: 96,
+        nested: 64,
+        arrays: 40,
+        sets: 40,
+        objectSet: 48,
+    };
+    for (const { framework, variant } of scenarios) {
+        (0, test_1.test)(`${framework}/${variant} runner reports block metrics`, async ({ page, }) => {
+            await navigateToScenario(page, framework, variant);
+            if (framework === "react" && variant === "deep") {
+                const debugInfo = await page.evaluate(() => ({
+                    identity: window.__reactSharedIdentity,
+                    globalMatch: window.__reactSharedGlobal,
+                    watchHits: window.__reactWatchHits,
+                    adapterMatch: window.__adapterSharedIdentity,
+                    version: window.sharedStateVersion,
+                }));
+                // eslint-disable-next-line no-console
+                console.log(`[debug] react/deep identity=${debugInfo.identity} global=${debugInfo.globalMatch} adapter=${debugInfo.adapterMatch} watchHits=${debugInfo.watchHits} version=${debugInfo.version}`);
+            }
+            const result = await runScenario(page, framework, variant, baseCounts);
+            (0, test_1.expect)(result).toBeTruthy();
+            const mutateBlock = result?.blocks?.mutateExisting;
+            logScenarioOverview(framework, variant, result);
+            (0, test_1.expect)(mutateBlock?.duration ?? 0).toBeGreaterThan(0);
+            const alphaRenders = mutateBlock?.objectRenderCounts?.[framework]?.["urn:object:alpha"] ?? 0;
+            (0, test_1.expect)(alphaRenders).toBeGreaterThan(0);
+        });
+    }
+    (0, test_1.test)("objectSet counts are configurable (react/deep)", async ({ page }) => {
+        const framework = "react";
+        const variant = "deep";
+        await navigateToScenario(page, framework, variant);
+        const light = await runScenario(page, framework, variant, {
+            objectSet: 1,
+        });
+        const heavy = await runScenario(page, framework, variant, {
+            objectSet: 8,
+        });
+        (0, test_1.expect)(light).toBeTruthy();
+        (0, test_1.expect)(heavy).toBeTruthy();
+        const lightAlpha = light?.blocks?.mutateExisting?.objectRenderCounts?.react?.["urn:object:alpha"] ?? 0;
+        const heavyAlpha = heavy?.blocks?.mutateExisting?.objectRenderCounts?.react?.["urn:object:alpha"] ?? 0;
+        (0, test_1.expect)(heavyAlpha).toBeGreaterThanOrEqual(lightAlpha);
+    });
+    for (const framework of frameworks) {
+        (0, test_1.test)(`${framework}/deep only re-renders touched object`, async ({ page, }) => {
+            const variant = "deep";
+            await navigateToScenario(page, framework, variant);
+            const targetId = "urn:object:alpha";
+            const peerId = "urn:object:beta";
+            const targetRow = page.locator(`[data-entry-id="${targetId}"]`);
+            const peerRow = page.locator(`[data-entry-id="${peerId}"]`);
+            await Promise.all([targetRow.waitFor(), peerRow.waitFor()]);
+            const readRenderCount = async (locator) => Number((await locator.getAttribute("data-render-count")) ?? 0);
+            const targetBefore = await readRenderCount(targetRow);
+            const peerBefore = await readRenderCount(peerRow);
+            await page.evaluate((id) => {
+                const state = window.sharedState;
+                const entry = Array.from(state.objectSet.values()).find((item) => item["@id"] === id);
+                if (!entry)
+                    throw new Error("Entry not found");
+                entry.count += 1;
+            }, targetId);
+            await page.waitForFunction(({ selector, before }) => {
+                const element = document.querySelector(selector);
+                if (!element)
+                    return false;
+                const count = Number(element.getAttribute("data-render-count") ?? "0");
+                return count > before;
+            }, {
+                selector: `[data-entry-id="${targetId}"]`,
+                before: targetBefore,
+            });
+            const targetAfter = await readRenderCount(targetRow);
+            const peerAfter = await readRenderCount(peerRow);
+            (0, test_1.expect)(targetAfter).toBeGreaterThan(targetBefore);
+            if (framework === "react") {
+                test_1.test.fail(true, "React reconciles the entire list because the single deepSignal subscription sits at the component root, so any Set mutation invalidates every row.");
+            }
+            (0, test_1.expect)(peerAfter).toBe(peerBefore);
+        });
+    }
+});

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

@@ -0,0 +1,53 @@
+export type PerfCounters = {
+    react: number;
+    svelte: number;
+    vue: number;
+};
+export interface TestState {
+    type: string;
+    stringValue: string;
+    numValue: number;
+    boolValue: boolean;
+    nullValue: null;
+    hiddenValue: number;
+    arrayValue: number[];
+    objectValue: {
+        nestedString: string;
+        nestedNum: number;
+        nestedArray: number[];
+    };
+    setValue: Set<string>;
+    objectSet: Set<TaggedObject>;
+    count: number;
+    perfCounters: PerfCounters;
+}
+export interface TaggedObject {
+    "@id": string;
+    label: string;
+    count: number;
+}
+export declare const mockTestObject: Readonly<{
+    type: string;
+    stringValue: string;
+    numValue: number;
+    boolValue: true;
+    nullValue: null;
+    hiddenValue: number;
+    arrayValue: number[];
+    objectValue: {
+        nestedString: string;
+        nestedNum: number;
+        nestedArray: number[];
+    };
+    setValue: Set<string>;
+    objectSet: Set<TaggedObject>;
+    count: number;
+    perfCounters: {
+        react: number;
+        svelte: number;
+        vue: number;
+    };
+}>;
+export declare function cloneDefaultObjectSet(): TaggedObject[];
+export declare function buildInitialState(): TestState;
+//# sourceMappingURL=mockData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mockData.d.ts","sourceRoot":"","sources":["../../../../src/test/frontend/utils/mockData.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE;QACT,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,EAAE,CAAC;KACzB,CAAC;IACF,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,SAAS,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,YAAY,CAAC;CAC9B;AAED,MAAM,WAAW,YAAY;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACjB;AA4BD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;EA0BzB,CAAC;AAEH,wBAAgB,qBAAqB,IAAI,YAAY,EAAE,CAEtD;AAED,wBAAgB,iBAAiB,IAAI,SAAS,CAyB7C"}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockTestObject = void 0;
+exports.cloneDefaultObjectSet = cloneDefaultObjectSet;
+exports.buildInitialState = buildInitialState;
+const buildDefaultObjectSetEntries = () => {
+    const baseEntries = [
+        {
+            "@id": "urn:object:alpha",
+            label: "Alpha",
+            count: 1,
+        },
+        {
+            "@id": "urn:object:beta",
+            label: "Beta",
+            count: 3,
+        },
+    ];
+    const extraEntries = Array.from({ length: 298 }, (_, index) => {
+        const idNumber = (index + 1).toString().padStart(3, "0");
+        return {
+            "@id": `urn:object:item-${idNumber}`,
+            label: `Item ${idNumber}`,
+            count: 5 + index,
+        };
+    });
+    return [...baseEntries, ...extraEntries];
+};
+const defaultObjectSetEntries = buildDefaultObjectSetEntries();
+exports.mockTestObject = Object.freeze({
+    type: "TestObject",
+    stringValue: "string",
+    numValue: 42,
+    boolValue: true,
+    nullValue: null,
+    hiddenValue: 0,
+    arrayValue: [1, 2, 3],
+    objectValue: {
+        nestedString: "nested",
+        nestedNum: 7,
+        nestedArray: [10, 12],
+    },
+    setValue: new Set(["v1", "v2", "v3"]),
+    objectSet: new Set(defaultObjectSetEntries.map((entry) => ({ ...entry }))),
+    count: 0,
+    perfCounters: {
+        react: 0,
+        svelte: 0,
+        vue: 0,
+    },
+});
+function cloneDefaultObjectSet() {
+    return defaultObjectSetEntries.map((entry) => ({ ...entry }));
+}
+function buildInitialState() {
+    return {
+        type: exports.mockTestObject.type,
+        stringValue: exports.mockTestObject.stringValue,
+        numValue: exports.mockTestObject.numValue,
+        boolValue: exports.mockTestObject.boolValue,
+        nullValue: exports.mockTestObject.nullValue,
+        hiddenValue: exports.mockTestObject.hiddenValue,
+        arrayValue: [...exports.mockTestObject.arrayValue],
+        objectValue: {
+            nestedString: exports.mockTestObject.objectValue.nestedString,
+            nestedNum: exports.mockTestObject.objectValue.nestedNum,
+            nestedArray: [...exports.mockTestObject.objectValue.nestedArray],
+        },
+        setValue: new Set(Array.from(exports.mockTestObject.setValue)),
+        objectSet: new Set(Array.from(exports.mockTestObject.objectSet).map((entry) => ({ ...entry }))),
+        count: exports.mockTestObject.count,
+        perfCounters: {
+            react: 0,
+            svelte: 0,
+            vue: 0,
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+export type PathSegment = string | number;
+export declare function getByPath<T = any>(source: any, path: string): T | undefined;
+export declare function setByPath(source: any, path: string, value: any): boolean;
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/test/frontend/utils/paths.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAK1C,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAM3E;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAWxE"}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getByPath = getByPath;
+exports.setByPath = setByPath;
+const toSegment = (segment) => segment.match(/^\d+$/) ? Number(segment) : segment;
+function getByPath(source, path) {
+    const segments = path.split(".").filter(Boolean).map(toSegment);
+    return segments.reduce((acc, key) => {
+        if (acc == null)
+            return undefined;
+        return acc[key];
+    }, source);
+}
+function setByPath(source, path, value) {
+    const segments = path.split(".").filter(Boolean).map(toSegment);
+    if (!segments.length)
+        return false;
+    const lastKey = segments.pop();
+    const parent = segments.reduce((acc, key) => {
+        if (acc == null)
+            return undefined;
+        return acc[key];
+    }, source);
+    if (parent == null)
+        return false;
+    parent[lastKey] = value;
+    return true;
+}