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

package/dist/deepSignal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deepSignal.d.ts","sourceRoot":"","sources":["../src/deepSignal.ts"],"names":[],"mappings":"AAWA,OAAO,EAGH,sBAAsB,EACtB,mBAAmB,EACnB,UAAU,EACV,iBAAiB,EAMpB,MAAM,SAAS,CAAC;AAo/BjB,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACvC,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,iBAAiB,GAC5B,UAAU,CAAC,CAAC,CAAC,CAwBf;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,EAAE,EAAE,mBAAmB,GAAG,sBAAsB,EAChD,gBAAgB,GAAE,OAAe,GAClC,MAAM,IAAI,CAoBZ;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,GAAG,SAAS,CAIpB;AAED,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAGnD;AAED,mFAAmF;AACnF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,QAItE;AAED,2FAA2F;AAC3F,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAa1E"}
+{"version":3,"file":"deepSignal.d.ts","sourceRoot":"","sources":["../src/deepSignal.ts"],"names":[],"mappings":"AAWA,OAAO,EAGH,sBAAsB,EACtB,mBAAmB,EACnB,UAAU,EACV,iBAAiB,EAMpB,MAAM,SAAS,CAAC;AA+qCjB,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACvC,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,iBAAiB,GAC5B,UAAU,CAAC,CAAC,CAAC,CAwBf;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,EAAE,EAAE,mBAAmB,GAAG,sBAAsB,EAChD,gBAAgB,GAAE,OAAe,GAClC,MAAM,IAAI,CAoBZ;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,GAAG,SAAS,CAIpB;AAED,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAGnD;AAED,mFAAmF;AACnF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,QAItE;AAED,2FAA2F;AAC3F,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAa1E"}

package/dist/deepSignal.js

@@ -31,6 +31,7 @@ const pendingRoots = new Set();
 const supported = new Set([Object, Array, Set]);
 const descriptor = Object.getOwnPropertyDescriptor;
 let blankNodeCounter = 0;
+let tmpIdCounter = 0;
 const wellKnownSymbols = new Set([
     Symbol.asyncDispose,
     Symbol.asyncIterator,
@@ -414,12 +415,6 @@ function createProxy(target, root, options, parentMeta, key, isSyntheticId) {
     rawToProxy.set(target, proxy);
     return proxy;
 }
-/** Normalize a value prior to writes, ensuring nested objects are proxied. */
-function ensureValueForWrite(value, receiver, key) {
-    const rawValue = rawToMeta.get(value) ?? value;
-    const proxied = ensureChildProxy(rawValue, receiver, key);
-    return { raw: rawValue, proxied };
-}
 /** Return primitive literals (string/number/boolean) for patch serialization. */
 function snapshotLiteral(value) {
     if (typeof value === "string" ||
@@ -452,8 +447,8 @@ function emitPatchesForNew(value, meta, basePath, inSet = false) {
         {
             path: basePath,
             op: "add",
-            type: value instanceof Set ? "set" : "object",
-            value: value instanceof Set ? [] : undefined,
+            value: value instanceof Set || Array.isArray(value) ? [] : {},
+            type: value instanceof Set ? "set" : undefined,
         },
     ];
     // The id property name, usually `@id`
@@ -507,6 +502,128 @@ function emitPatchesForNew(value, meta, basePath, inSet = false) {
     }
     return patches;
 }
+/**
+ * Refresh numeric index signals for an array target so reads return current items
+ * and dependent effects are notified. Recreates/proxies values for indices < length
+ * and clears signals for indices >= length.
+ */
+function refreshNumericIndexSignals(target, receiver) {
+    const sigs = propertiesToSignals.get(target);
+    if (!sigs)
+        return;
+    for (const k of Array.from(sigs.keys())) {
+        if (typeof k === "string" && /^\d+$/.test(k)) {
+            const idx = Number(k);
+            if (idx >= target.length) {
+                const existing = sigs.get(k);
+                if (existing &&
+                    typeof existing.set === "function") {
+                    existing.set(undefined);
+                }
+                sigs.delete(k);
+            }
+            else {
+                const val = target[idx];
+                const proxied = ensureChildProxy(val, receiver, idx);
+                setSignalValue(sigs, k, proxied);
+            }
+        }
+    }
+}
+let hasWarnedAboutMissingSupportForReverse = false;
+let hasWarnedAboutMissingSupportForSort = false;
+/** Returns proxy function for array-mutating functions. */
+const getArrayMutationProxy = (target, key, receiver) => {
+    const meta = rawToMeta.get(target);
+    if (key === "reverse") {
+        if (!hasWarnedAboutMissingSupportForReverse) {
+            console.warn(".reverse() was called on deepSignal array. In place modifications with .sort() and .reverse() are not supported. `toReversed` will be called instead.");
+            hasWarnedAboutMissingSupportForReverse = true;
+        }
+        return target.toReversed;
+    }
+    else if (key === "sort") {
+        if (!hasWarnedAboutMissingSupportForSort) {
+            console.warn(".sort() was called on deepSignal array. In place modifications with .sort() and .reverse() are not supported. `toSorted` will be called instead.");
+            hasWarnedAboutMissingSupportForSort = true;
+        }
+        return target.toSorted;
+    }
+    else if (key === "shift") {
+        return () => {
+            target.shift();
+            schedulePatch(meta, () => ({
+                op: "remove",
+                path: buildPath(meta, "0"),
+            }));
+            // Update length of proxy explicitly.
+            receiver.length = target.length;
+            // Refresh numeric index signals so shifted indices don't return stale values.
+            refreshNumericIndexSignals(target, receiver);
+        };
+    }
+    else if (key === "splice") {
+        return (start, deleteCount, ...items) => {
+            // Call splice on (non-proxied) target.
+            const deletedItems = target.splice(start, deleteCount, ...items);
+            // Manually schedule patches.
+            schedulePatch(meta, () => {
+                const patches = [];
+                // All items can be deleted at the same path / index.
+                for (let i = 0; i < deleteCount; i++) {
+                    patches.push({
+                        op: "remove",
+                        path: buildPath(meta, String(start)),
+                    });
+                }
+                // All items can be inserted at same path / index, by adding items in reverse order.
+                for (const newItem of items.toReversed()) {
+                    patches.push({
+                        op: "add",
+                        path: buildPath(meta, String(start)),
+                        value: newItem,
+                    });
+                }
+                return patches;
+            });
+            // Ensure newly added items are proxied.
+            for (let i = 0; i < items.length; i++) {
+                ensureChildProxy(items[i], target, start + i);
+            }
+            // Refresh numeric index signals so shifted indices don't return stale values.
+            refreshNumericIndexSignals(target, receiver);
+            // Update length of proxy explicitly.
+            receiver.length = target.length;
+            return deletedItems;
+        };
+    }
+    else if (key === "unshift") {
+        return (...items) => {
+            const deletedItems = target.unshift(...items);
+            schedulePatch(meta, () => {
+                const patches = [];
+                // All items can be inserted at index 0, by adding items in reverse order.
+                for (const newItem of items.toReversed()) {
+                    patches.push({
+                        op: "add",
+                        path: buildPath(meta, "0"),
+                        value: newItem,
+                    });
+                }
+                return patches;
+            });
+            // Ensure newly added items are proxied.
+            for (let i = 0; i < items.length; i++) {
+                ensureChildProxy(items[i], target, i);
+            }
+            // Update length of proxy explicitly.
+            receiver.length = target.length;
+            // Refresh numeric index signals so shifted indices don't return stale values.
+            refreshNumericIndexSignals(target, receiver);
+            return deletedItems;
+        };
+    }
+};
 /** Proxy handler driving reactivity for plain objects and arrays. */
 const objectHandlers = {
     get(target, key, receiver) {
@@ -524,6 +641,14 @@ const objectHandlers = {
             if (!isReactiveSymbol(key))
                 return Reflect.get(target, key, receiver);
         }
+        // Array helper handling. We need that because otherwise, every array position change would go as a separate operation through the proxy.
+        // Thus, we need to schedule the patches manually for mutating array functions.
+        if (Array.isArray(target)) {
+            const mutationProxy = getArrayMutationProxy(target, key, receiver);
+            if (mutationProxy) {
+                return mutationProxy;
+            }
+        }
         // Get object map from key to signal.
         const signals = ensureSignalMap(target);
         // Ensure that target object is signal.
@@ -552,29 +677,56 @@ const objectHandlers = {
         const desc = descriptor(target, key);
         const hasAccessor = !!desc &&
             (typeof desc.get === "function" || typeof desc.set === "function");
-        const { raw, proxied } = ensureValueForWrite(value, receiver, key);
+        const proxied = ensureChildProxy(value, target, key);
+        const rawValue = value?.[RAW_KEY] ?? value;
         const hadKey = Object.prototype.hasOwnProperty.call(target, key);
-        const result = Reflect.set(target, key, raw, receiver);
+        const shouldManuallyTrimLength = Array.isArray(target) && key === "length" && value < target.length;
+        // If `length` is used to reduce the size of the array, delete the overflowing slots
+        // manually so that existing delete reactivity emits the patches and clears signals.
+        if (shouldManuallyTrimLength) {
+            for (let i = target.length - 1; i >= value; i -= 1) {
+                delete receiver[i];
+            }
+        }
+        // === Set value on actual target ===
+        const result = Reflect.set(target, key, rawValue, receiver);
         if (!hasAccessor) {
             const signals = ensureSignalMap(target);
             setSignalValue(signals, key, proxied);
         }
         if (!hadKey)
             touchIterable(target);
-        if (meta && path && typeof raw === "object") {
-            initializeObjectTreeIfNoListeners(meta, path, raw, false);
+        if (meta && path && typeof rawValue === "object") {
+            initializeObjectTreeIfNoListeners(meta, path, rawValue, false);
+        }
+        // Modifications to the length should not emit patches
+        if (Array.isArray(target) && key === "length") {
+            return result;
         }
         schedulePatch(meta, () => {
             const resolvedPath = path ?? buildPath(meta, key);
-            if (!hadKey || typeof raw === "object") {
-                return emitPatchesForNew(raw, meta, resolvedPath);
+            if (!hadKey || typeof rawValue === "object") {
+                const patches = emitPatchesForNew(rawValue, meta, resolvedPath);
+                // TODO: Document
+                // If an object is added to an array (this happens in discrete CRDTs), we will eventually receive an @id back.
+                // However, the @id is not available from the beginning but frontend frameworks might depend on @id.
+                // Thus, we set a temporary @id which will be replaced once we are called back with the real @id.
+                // Also, we don't emit a patch for this.
+                if (Array.isArray(target) &&
+                    !isNaN(Number(key)) &&
+                    value &&
+                    typeof value === "object" &&
+                    meta?.options.syntheticIdPropertyName !== "@id") {
+                    rawValue["@id"] = `tmp-${++tmpIdCounter}`;
+                }
+                return patches;
             }
-            if (snapshotLiteral(raw) === undefined)
+            if (snapshotLiteral(rawValue) === undefined)
                 return undefined;
             return {
                 path: resolvedPath,
                 op: "add",
-                value: raw,
+                value: rawValue,
             };
         });
         return result;

package/dist/hooks/svelte/useDeepSignal.svelte.d.ts

@@ -1,11 +1,7 @@
 import { type Readable } from "svelte/store";
-import { type DeepPatchBatch, DeepSignalOptions, RevertDeepSignal } from "../../index";
+import { DeepSignalOptions, RevertDeepSignal } from "../../index";
 /** Base result contract for a deepSignal-backed Svelte integration. */
-export interface UseDeepSignalResult<T extends object> extends Readable<T> {
-    /** Store of the full deep proxy tree (also accessible via `subscribe` directly on this result). */
-    deep: Readable<T>;
-    /** Last batch of deep mutation patches for this root (empties only on next non-empty batch). */
-    patches: Readable<DeepPatchBatch | null>;
+export interface UseDeepSignalResult<T> extends Readable<T> {
     /** Derive a nested selection; re-runs when the underlying tree version increments. */
     select<U>(selector: (tree: T) => U): Readable<U>;
     /** Stop receiving further updates (invoked automatically on component destroy). */
@@ -26,6 +22,6 @@ export interface UseDeepSignalResult<T extends object> extends Readable<T> {
  * @param deepSignalObjects When the object is not a deepSignal already, options passed to `deepSignal`.
  * @returns A rune for using the deepSignal object in svelte.
  */
-export declare function useDeepSignal<T extends object>(object: T, options?: DeepSignalOptions): UseDeepSignalResult<RevertDeepSignal<T>>;
+export declare function useDeepSignal<T extends object>(object: T | Promise<T>, options?: DeepSignalOptions): UseDeepSignalResult<RevertDeepSignal<T>>;
 export default useDeepSignal;
 //# sourceMappingURL=useDeepSignal.svelte.d.ts.map

package/dist/hooks/svelte/useDeepSignal.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDeepSignal.svelte.d.ts","sourceRoot":"","sources":["../../../src/hooks/svelte/useDeepSignal.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,EAAqB,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEhE,OAAO,EAGH,KAAK,cAAc,EACnB,iBAAiB,EAEjB,gBAAgB,EAEnB,MAAM,aAAa,CAAC;AAErB,uEAAuE;AACvE,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IACtE,mGAAmG;IACnG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IAClB,gGAAgG;IAChG,OAAO,EAAE,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IACzC,sFAAsF;IACtF,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACjD,mFAAmF;IACnF,OAAO,IAAI,IAAI,CAAC;IAChB,sGAAsG;IACtG,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IAChC,4DAA4D;IAC5D,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;CACnD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC1C,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,iBAAiB,GAC5B,mBAAmB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAiD1C;AAED,eAAe,aAAa,CAAC"}
+{"version":3,"file":"useDeepSignal.svelte.d.ts","sourceRoot":"","sources":["../../../src/hooks/svelte/useDeepSignal.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,EAAqB,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEhE,OAAO,EAIH,iBAAiB,EAEjB,gBAAgB,EAEnB,MAAM,aAAa,CAAC;AAErB,uEAAuE;AACvE,MAAM,WAAW,mBAAmB,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IACvD,sFAAsF;IACtF,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACjD,mFAAmF;IACnF,OAAO,IAAI,IAAI,CAAC;IAChB,sGAAsG;IACtG,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IAChC,4DAA4D;IAC5D,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;CACnD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC1C,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACtB,OAAO,CAAC,EAAE,iBAAiB,GAC5B,mBAAmB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAkE1C;AAED,eAAe,aAAa,CAAC"}

package/dist/hooks/svelte/useDeepSignal.svelte.js

@@ -25,26 +25,42 @@ const index_1 = require("../../index");
  * @returns A rune for using the deepSignal object in svelte.
  */
 function useDeepSignal(object, options) {
-    const deepProxy = (0, index_1.deepSignal)(object, options);
-    const rootId = (0, index_1.getDeepSignalRootId)(deepProxy);
-    const initialVersion = (0, index_1.getDeepSignalVersion)(deepProxy) ?? 0;
-    const version = (0, store_1.writable)(initialVersion);
-    const patchesStore = (0, store_1.writable)(null);
-    const unsubscribe = (0, index_1.subscribeDeepMutations)(deepProxy, (batch) => {
-        if (!rootId)
+    const version = (0, store_1.writable)(-1);
+    let deepProxy;
+    let unsubscribe;
+    let isDestroyed = false;
+    const init = (obj) => {
+        if (isDestroyed)
             return;
-        if (batch.patches.length) {
-            patchesStore.set(batch);
-            version.set(batch.version);
-        }
-    });
-    const deep = (0, store_1.derived)(version, () => deepProxy);
-    const select = (selector) => (0, store_1.derived)(deep, (t) => selector(t));
-    const dispose = () => unsubscribe();
+        deepProxy = (0, index_1.deepSignal)(obj, options);
+        const rootId = (0, index_1.getDeepSignalRootId)(deepProxy);
+        const initialVersion = (0, index_1.getDeepSignalVersion)(deepProxy) ?? 0;
+        unsubscribe = (0, index_1.subscribeDeepMutations)(deepProxy, (batch) => {
+            if (!rootId)
+                return;
+            if (batch.patches.length) {
+                version.set(batch.version);
+            }
+        });
+        version.set(initialVersion);
+    };
+    if (object instanceof Promise) {
+        object.then(init);
+    }
+    else {
+        init(object);
+    }
+    const dispose = () => {
+        isDestroyed = true;
+        if (unsubscribe)
+            unsubscribe();
+    };
     (0, svelte_1.onDestroy)(dispose);
+    const deep = (0, store_1.derived)(version, () => deepProxy);
+    const select = (selector) => (0, store_1.derived)(deep, (t) => (t ? selector(t) : undefined));
     // Expose Svelte store contract by delegating subscribe to deep store.
     const applyReplacement = (next) => {
-        if (!next || typeof next !== "object")
+        if (!deepProxy || !next || typeof next !== "object")
             return;
         // Remove keys absent in next
         for (const k of Object.keys(deepProxy)) {
@@ -55,8 +71,6 @@ function useDeepSignal(object, options) {
         Object.assign(deepProxy, next);
     };
     const store = {
-        deep,
-        patches: patchesStore,
         select,
         dispose,
         subscribe: deep.subscribe,
@@ -64,6 +78,8 @@ function useDeepSignal(object, options) {
             applyReplacement(next);
         },
         update(updater) {
+            if (!deepProxy)
+                return;
             const result = updater(deepProxy);
             if (result && typeof result === "object")
                 applyReplacement(result);

package/dist/hooks/vue/useDeepSignal.d.ts

@@ -1,3 +1,4 @@
+import { type MaybeRefOrGetter } from "vue";
 import { DeepSignal, DeepSignalOptions } from "../../";
 /**
  * Create or use an existing deepSignal object in your component.
@@ -5,11 +6,11 @@ import { DeepSignal, DeepSignalOptions } from "../../";
  * If modifications of the object are made from somewhere else, the component
  * is rerendered as well.
  *
- * @param object The object that should become reactive
- * @param deepSignalObjects When the object is not a deepSignal already, options passed to `deepSignal`.
+ * @param object The object that should become reactive (can be a ref or getter)
+ * @param options When the object is not a deepSignal already, options passed to `deepSignal`.
  * @returns The deepSignal object of the object param.
  *
  */
-export declare function useDeepSignal<T extends object>(object: T, options?: DeepSignalOptions): DeepSignal<T>;
+export declare function useDeepSignal<T extends object>(object: MaybeRefOrGetter<T>, options?: DeepSignalOptions): DeepSignal<T>;
 export default useDeepSignal;
 //# sourceMappingURL=useDeepSignal.d.ts.map

package/dist/hooks/vue/useDeepSignal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDeepSignal.d.ts","sourceRoot":"","sources":["../../../src/hooks/vue/useDeepSignal.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,UAAU,EAAc,iBAAiB,EAAS,MAAM,QAAQ,CAAC;AAE1E;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC1C,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,iBAAiB,GAC5B,UAAU,CAAC,CAAC,CAAC,CAgDf;AAED,eAAe,aAAa,CAAC"}
+{"version":3,"file":"useDeepSignal.d.ts","sourceRoot":"","sources":["../../../src/hooks/vue/useDeepSignal.ts"],"names":[],"mappings":"AAUA,OAAO,EAGH,KAAK,gBAAgB,EAGxB,MAAM,KAAK,CAAC;AACb,OAAO,EAAE,UAAU,EAAc,iBAAiB,EAAS,MAAM,QAAQ,CAAC;AAE1E;;;;;;;;;;GAUG;AAEH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC1C,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,OAAO,CAAC,EAAE,iBAAiB,GAC5B,UAAU,CAAC,CAAC,CAAC,CAkFf;AAED,eAAe,aAAa,CAAC"}

package/dist/hooks/vue/useDeepSignal.js

@@ -18,54 +18,82 @@ const __1 = require("../../");
  * If modifications of the object are made from somewhere else, the component
  * is rerendered as well.
  *
- * @param object The object that should become reactive
- * @param deepSignalObjects When the object is not a deepSignal already, options passed to `deepSignal`.
+ * @param object The object that should become reactive (can be a ref or getter)
+ * @param options When the object is not a deepSignal already, options passed to `deepSignal`.
  * @returns The deepSignal object of the object param.
  *
  */
+// Note partly written with the help of Gemini 3.
 function useDeepSignal(object, options) {
     const version = (0, vue_1.ref)(0);
-    const signalObject = (0, __1.deepSignal)(object, options);
-    const stopHandle = (0, __1.watch)(signalObject, ({ patches }) => {
-        if (patches.length > 0) {
-            version.value++;
+    // Holds the current reactive signal object.
+    let currentSignal;
+    let stopHandle;
+    // Watch the input object for changes.
+    const stopWatchingSource = (0, vue_1.watch)(() => (0, vue_1.toValue)(object), (newObj) => {
+        if (stopHandle) {
+            stopHandle.stopListening();
+            stopHandle = undefined;
         }
-    });
-    // Proxy that creates Vue dependency on version for any access
-    const proxy = new Proxy(signalObject, {
+        if (newObj) {
+            currentSignal = (0, __1.deepSignal)(newObj, options);
+            stopHandle = (0, __1.watch)(currentSignal, ({ patches }) => {
+                if (patches.length > 0)
+                    version.value++;
+            });
+        }
+        // Trigger Vue update.
+        version.value++;
+    }, { immediate: true });
+    // Determines the initial target for the Proxy (array vs object).
+    const initialVal = (0, vue_1.toValue)(object);
+    const proxyTarget = (Array.isArray(initialVal) ? [] : {});
+    // Proxy that creates Vue dependency on version for any access.
+    const proxy = new Proxy(proxyTarget, {
         get(target, key) {
             if (key === "__raw")
-                return target;
-            // Track version to create reactive dependency
+                return currentSignal;
+            // Track version to create reactive dependency.
             version.value;
-            const value = target[key];
-            // Bind methods to maintain correct `this` context
-            return typeof value === "function" ? value.bind(target) : value;
+            // Delegate to current signal.
+            const actualTarget = currentSignal || target;
+            const value = Reflect.get(actualTarget, key);
+            // Bind methods to maintain correct `this` context.
+            return typeof value === "function"
+                ? value.bind(actualTarget)
+                : value;
         },
         set(target, key, value) {
-            // Directly forward writes to the deep signal root so other frameworks observe the change.
-            return Reflect.set(target, key, value);
+            // Delegate to current signal.
+            const actualTarget = currentSignal || target;
+            return Reflect.set(actualTarget, key, value);
         },
         has(target, key) {
             version.value;
-            return key in target;
+            const actualTarget = currentSignal || target;
+            return Reflect.has(actualTarget, key);
         },
         ownKeys(target) {
             version.value;
-            return Reflect.ownKeys(target);
+            const actualTarget = currentSignal || target;
+            return Reflect.ownKeys(actualTarget);
         },
         getOwnPropertyDescriptor(target, key) {
             version.value;
-            const desc = Object.getOwnPropertyDescriptor(target, key);
+            const actualTarget = currentSignal || target;
+            const desc = Reflect.getOwnPropertyDescriptor(actualTarget, key);
             return desc ? { ...desc, configurable: true } : undefined;
         },
     });
     (0, vue_1.onBeforeUnmount)(() => {
-        try {
-            stopHandle.stopListening();
-        }
-        catch {
-            // ignore
+        stopWatchingSource();
+        if (stopHandle) {
+            try {
+                stopHandle.stopListening();
+            }
+            catch {
+                // ignore
+            }
         }
     });
     return proxy;

package/dist/test/frontend/astro-app/src/components/PerfSuiteClient.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+declare const PerfSuiteClient: React.FC;
+export default PerfSuiteClient;
+//# sourceMappingURL=PerfSuiteClient.d.ts.map

package/dist/test/frontend/astro-app/src/components/PerfSuiteClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerfSuiteClient.d.ts","sourceRoot":"","sources":["../../../../../../src/test/frontend/astro-app/src/components/PerfSuiteClient.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAuC,MAAM,OAAO,CAAC;AA+C5D,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAkL5B,CAAC;AAEF,eAAe,eAAe,CAAC"}