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

package/dist/test/lib/deepSignalOptions.test.js

@@ -0,0 +1,230 @@
+"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 deepSignal_1 = require("../../deepSignal");
+const watch_1 = require("../../watch");
+(0, vitest_1.describe)("deepSignal options", () => {
+    (0, vitest_1.describe)("custom ID generator", () => {
+        (0, vitest_1.it)("uses custom ID generator for objects without @id", async () => {
+            let counter = 1000;
+            const options = {
+                propGenerator: () => ({ syntheticId: `custom-${counter++}` }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ data: {} }, options);
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            state.data.user = { name: "Alice" };
+            await Promise.resolve();
+            // Check that @id was assigned
+            (0, vitest_1.expect)(state.data.user["@id"]).toBe("custom-1000");
+            // Check that patch was emitted for @id
+            const flat = patches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(flat).toContain("data.user.@id");
+            stop();
+        });
+        (0, vitest_1.it)("respects existing @id on objects", async () => {
+            const options = {
+                propGenerator: () => ({ syntheticId: "should-not-be-used" }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ items: [] }, options);
+            state.items.push({ "@id": "existing-123", value: 42 });
+            // Should use the existing @id
+            (0, vitest_1.expect)(state.items[0]["@id"]).toBe("existing-123");
+        });
+        (0, vitest_1.it)("uses @id property from objects added to Sets", async () => {
+            const options = {
+                propGenerator: ({ object }) => ({
+                    syntheticId: object["@id"] || "fallback-id",
+                }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ s: new Set() }, options);
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            const obj = { "@id": "set-entry-1", data: "test" };
+            state.s.add(obj);
+            await Promise.resolve();
+            const flat = patches.flat().map((p) => p.path.join("."));
+            // Path should use the @id as synthetic key
+            (0, vitest_1.expect)(flat.some((p) => p.startsWith("s.set-entry-1"))).toBe(true);
+            stop();
+        });
+    });
+    (0, vitest_1.describe)("syntheticIdPropertyName option", () => {
+        (0, vitest_1.it)("adds @id to all nested objects when enabled", async () => {
+            let counter = 100;
+            const options = {
+                propGenerator: () => ({ syntheticId: `auto-${counter++}` }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ root: {} }, options);
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            state.root.level1 = {
+                level2: {
+                    level3: { value: "deep" },
+                },
+            };
+            await Promise.resolve();
+            // Check all levels have @id
+            (0, vitest_1.expect)(state.root.level1["@id"]).toBeDefined();
+            (0, vitest_1.expect)(state.root.level1.level2["@id"]).toBeDefined();
+            (0, vitest_1.expect)(state.root.level1.level2.level3["@id"]).toBeDefined();
+            // Check patches were emitted for all @id fields
+            const flat = patches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(flat).toContain("root.level1.@id");
+            (0, vitest_1.expect)(flat).toContain("root.level1.level2.@id");
+            (0, vitest_1.expect)(flat).toContain("root.level1.level2.level3.@id");
+            stop();
+        });
+        (0, vitest_1.it)("does not add @id when option is false", () => {
+            const state = (0, deepSignal_1.deepSignal)({ data: { nested: {} } });
+            // Should not have @id
+            (0, vitest_1.expect)("@id" in state.data).toBe(false);
+            (0, vitest_1.expect)("@id" in state.data.nested).toBe(false);
+        });
+        (0, vitest_1.it)("adds @id to objects in arrays", async () => {
+            let counter = 200;
+            const options = {
+                propGenerator: () => ({ syntheticId: `arr-${counter++}` }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ items: [] }, options);
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            state.items.push({ name: "Item 1" }, { name: "Item 2" });
+            await Promise.resolve();
+            // Both items should have @id
+            (0, vitest_1.expect)(state.items[0]["@id"]).toBeDefined();
+            (0, vitest_1.expect)(state.items[1]["@id"]).toBeDefined();
+            // Check patches
+            const flat = patches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(flat).toContain("items.0.@id");
+            (0, vitest_1.expect)(flat).toContain("items.1.@id");
+            stop();
+        });
+        (0, vitest_1.it)("adds @id to objects in Sets", async () => {
+            const options = {
+                propGenerator: () => ({
+                    syntheticId: `gen-${Math.random().toString(36).substr(2, 9)}`,
+                }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ s: new Set() }, options);
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            const obj1 = { value: 1 };
+            const obj2 = { value: 2 };
+            state.s.add(obj1);
+            state.s.add(obj2);
+            await Promise.resolve();
+            // Get proxied objects from Set
+            const proxiedObjs = Array.from(state.s);
+            (0, vitest_1.expect)(proxiedObjs[0]["@id"]).toBeDefined();
+            (0, vitest_1.expect)(proxiedObjs[1]["@id"]).toBeDefined();
+            // @id should be used as synthetic key in paths
+            const flat = patches.flat().map((p) => p.path.join("."));
+            const obj1Id = proxiedObjs[0]["@id"];
+            const obj2Id = proxiedObjs[1]["@id"];
+            (0, vitest_1.expect)(flat.some((p) => p.startsWith(`s.${obj1Id}`))).toBe(true);
+            (0, vitest_1.expect)(flat.some((p) => p.startsWith(`s.${obj2Id}`))).toBe(true);
+            stop();
+        });
+    });
+    (0, vitest_1.describe)("@id property behavior", () => {
+        (0, vitest_1.it)("makes @id readonly", () => {
+            const options = {
+                syntheticIdPropertyName: "@id",
+                readOnlyProps: ["@id"],
+            };
+            const state = (0, deepSignal_1.deepSignal)({ obj: {} }, options);
+            state.obj.data = { value: 1 };
+            // Attempting to modify @id should throw
+            (0, vitest_1.expect)(() => {
+                state.obj.data["@id"] = "new-id";
+            }).toThrow("Cannot modify readonly property '@id'");
+        });
+        (0, vitest_1.it)("makes @id enumerable", () => {
+            let counter = 300;
+            const options = {
+                propGenerator: () => ({ syntheticId: `enum-${counter++}` }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ obj: {} }, options);
+            state.obj.data = { value: 1 };
+            // @id should show up in Object.keys()
+            const keys = Object.keys(state.obj.data);
+            (0, vitest_1.expect)(keys).toContain("@id");
+        });
+        (0, vitest_1.it)("emits patches for @id even on objects with existing @id", async () => {
+            const options = {
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ container: {} }, options);
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            // Object already has @id before being added
+            const objWithId = { "@id": "pre-existing", data: "test" };
+            state.container.item = objWithId;
+            await Promise.resolve();
+            const flat = patches.flat().map((p) => p.path.join("."));
+            // Patch should still be emitted for @id
+            (0, vitest_1.expect)(flat).toContain("container.item.@id");
+            // Verify the value in the patch
+            const idPatch = patches
+                .flat()
+                .find((p) => p.path.join(".") === "container.item.@id");
+            (0, vitest_1.expect)(idPatch.value).toBe("pre-existing");
+            stop();
+        });
+    });
+    (0, vitest_1.describe)("options inheritance", () => {
+        (0, vitest_1.it)("child objects inherit options from root", async () => {
+            let idCounter = 5000;
+            const options = {
+                propGenerator: () => ({
+                    syntheticId: `inherited-${idCounter++}`,
+                }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ root: {} }, options);
+            // Add nested structure
+            state.root.child = {
+                grandchild: {
+                    value: "nested",
+                },
+            };
+            // All should have IDs generated by the custom generator
+            (0, vitest_1.expect)(state.root.child["@id"]).toMatch(/^inherited-/);
+            (0, vitest_1.expect)(state.root.child.grandchild["@id"]).toMatch(/^inherited-/);
+        });
+        (0, vitest_1.it)("objects added to Sets inherit options", async () => {
+            let counter = 9000;
+            const options = {
+                propGenerator: () => ({
+                    syntheticId: `set-child-${counter++}`,
+                }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, deepSignal_1.deepSignal)({ s: new Set() }, options);
+            const obj = { nested: { value: 1 } };
+            state.s.add(obj);
+            // Iterate to get proxied object
+            const proxied = Array.from(state.s)[0];
+            // Object and nested object should have custom IDs
+            (0, vitest_1.expect)(proxied["@id"]).toMatch(/^set-child-/);
+            (0, vitest_1.expect)(proxied.nested["@id"]).toMatch(/^set-child-/);
+        });
+    });
+});

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

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

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

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