@signaltree/core 4.0.6 → 4.0.8

package/dist/enhancers/serialization/index.js

@@ -0,0 +1,837 @@
+import { isSignal } from '@angular/core';
+
+/**
+ * Type markers for special object serialization
+ * Using compact symbols to minimize serialized size
+ */
+const TYPE_MARKERS = {
+    DATE: '§d',
+    REGEXP: '§r',
+    MAP: '§m',
+    SET: '§s',
+    UNDEFINED: '§u',
+    NAN: '§n',
+    INFINITY: '§i',
+    NEG_INFINITY: '§-i',
+    BIGINT: '§b',
+    SYMBOL: '§y',
+    FUNCTION: '§f',
+    CIRCULAR: '§c',
+};
+
+/**
+ * Default serialization config
+ */
+const DEFAULT_CONFIG = {
+    includeMetadata: true,
+    replacer: undefined,
+    reviver: undefined,
+    preserveTypes: true,
+    maxDepth: 50,
+    handleCircular: true,
+};
+/**
+ * Safely unwrap object with circular reference detection
+ */
+function unwrapObjectSafely(obj, visited = new WeakSet(), depth = 0, maxDepth = 50, preserveTypes = true) {
+    // Prevent infinite recursion
+    if (depth > maxDepth)
+        return '[Max Depth Exceeded]';
+    // Primitives and non-objects
+    if (obj === null || typeof obj !== 'object') {
+        if (!preserveTypes)
+            return obj;
+        if (obj === undefined)
+            return { [TYPE_MARKERS.UNDEFINED]: true };
+        if (typeof obj === 'number') {
+            if (Number.isNaN(obj))
+                return { [TYPE_MARKERS.NAN]: true };
+            if (obj === Infinity)
+                return { [TYPE_MARKERS.INFINITY]: true };
+            if (obj === -Infinity)
+                return { [TYPE_MARKERS.NEG_INFINITY]: true };
+            return obj;
+        }
+        if (typeof obj === 'bigint')
+            return { [TYPE_MARKERS.BIGINT]: String(obj) };
+        if (typeof obj === 'symbol')
+            return { [TYPE_MARKERS.SYMBOL]: String(obj) };
+        return obj;
+    }
+    // Handle callable signals (no longer need complex branch wrapper detection)
+    if (typeof obj === 'function') {
+        try {
+            // Check if it's a callable signal by trying to invoke it
+            const result = obj();
+            return unwrapObjectSafely(result, visited, depth + 1, maxDepth, preserveTypes);
+        }
+        catch {
+            // Not a callable signal, treat as regular function (non-serializable)
+            return '[Function]';
+        }
+    }
+    // If object already visited, mark as circular
+    if (visited.has(obj))
+        return '[Circular Reference]';
+    // Unwrap signals
+    if (isSignal(obj))
+        return obj();
+    // Preserve special types
+    if (preserveTypes) {
+        if (obj instanceof Date)
+            return { [TYPE_MARKERS.DATE]: obj.toISOString() };
+        if (obj instanceof RegExp)
+            return {
+                [TYPE_MARKERS.REGEXP]: { source: obj.source, flags: obj.flags },
+            };
+        if (obj instanceof Map) {
+            return { [TYPE_MARKERS.MAP]: Array.from(obj.entries()) };
+        }
+        if (obj instanceof Set) {
+            return { [TYPE_MARKERS.SET]: Array.from(obj.values()) };
+        }
+    }
+    else {
+        if (obj instanceof Date || obj instanceof RegExp)
+            return obj;
+    }
+    visited.add(obj);
+    try {
+        if (Array.isArray(obj)) {
+            const arr = obj.map((item) => unwrapObjectSafely(item, visited, depth + 1, maxDepth, preserveTypes));
+            visited.delete(obj);
+            return arr;
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            // Skip runtime helpers when they are plain functions (not signals)
+            if ((k === 'set' || k === 'update') &&
+                typeof v === 'function' &&
+                !isSignal(v))
+                continue;
+            if (isSignal(v)) {
+                out[k] = unwrapObjectSafely(v(), visited, depth + 1, maxDepth, preserveTypes);
+            }
+            else if (typeof v === 'function' && k !== 'set' && k !== 'update') {
+                // Handle callable signals - these are functions but not helper methods
+                try {
+                    const callResult = v();
+                    out[k] = unwrapObjectSafely(callResult, visited, depth + 1, maxDepth, preserveTypes);
+                }
+                catch {
+                    // If calling fails, skip this property
+                    continue;
+                }
+            }
+            else {
+                out[k] = unwrapObjectSafely(v, visited, depth + 1, maxDepth, preserveTypes);
+            }
+        }
+        visited.delete(obj);
+        return out;
+    }
+    catch {
+        visited.delete(obj);
+        return '[Serialization Error]';
+    }
+}
+/**
+ * Detects circular references in an object
+ */
+function detectCircularReferences(obj, path = '', seen = new WeakSet(), paths = new Map()) {
+    const circular = [];
+    if (obj === null || typeof obj !== 'object') {
+        return circular;
+    }
+    // Check if we've seen this object before
+    if (seen.has(obj)) {
+        // Found a circular reference
+        const targetPath = paths.get(obj) || '';
+        circular.push({ path, targetPath });
+        return circular; // Don't recurse into circular references
+    }
+    // Mark this object as seen
+    seen.add(obj);
+    paths.set(obj, path);
+    // Recursively check children
+    if (Array.isArray(obj)) {
+        const arrObj = obj;
+        for (let i = 0; i < arrObj.length; i++) {
+            const itemPath = path ? `${path}[${i}]` : `[${i}]`;
+            const childCircular = detectCircularReferences(arrObj[i], itemPath, seen, paths);
+            circular.push(...childCircular);
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(obj)) {
+            const propPath = path ? `${path}.${key}` : key;
+            const childCircular = detectCircularReferences(value, propPath, seen, paths);
+            circular.push(...childCircular);
+        }
+    }
+    // Remove from seen set when backing out (allows siblings to reference same objects)
+    seen.delete(obj);
+    return circular;
+}
+/**
+ * Custom replacer that handles circular references only
+ */
+function createReplacer(config) {
+    const seen = new WeakSet();
+    const circularPaths = new Map();
+    return function replacer(key, value) {
+        // Apply custom replacer first if provided
+        if (config.replacer) {
+            value = config.replacer.call(this, key, value);
+        }
+        // Skip signals - we already unwrapped them
+        if (isSignal(value)) {
+            return value();
+        }
+        // Handle circular references
+        if (value && typeof value === 'object') {
+            if (seen.has(value)) {
+                if (config.handleCircular) {
+                    const targetPath = circularPaths.get(value) || '';
+                    return { [TYPE_MARKERS.CIRCULAR]: targetPath };
+                }
+                return undefined;
+            }
+            seen.add(value);
+            const currentPath = key || '';
+            circularPaths.set(value, currentPath);
+        }
+        // All special type handling is now done in unwrapObjectSafely
+        return value;
+    };
+}
+/**
+ * Resolves circular references after parsing
+ */
+function resolveCircularReferences(obj, circularPaths) {
+    for (const { path, targetPath } of circularPaths) {
+        const pathParts = path.split(/\.|\[|\]/).filter(Boolean);
+        const targetParts = targetPath.split(/\.|\[|\]/).filter(Boolean);
+        // Navigate to the circular reference location
+        let current = obj;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            current = current[pathParts[i]];
+            if (!current)
+                break;
+        }
+        // Navigate to the target
+        let target = obj;
+        for (const part of targetParts) {
+            target = target[part];
+            if (!target)
+                break;
+        }
+        // Set the circular reference
+        if (current && target) {
+            current[pathParts[pathParts.length - 1]] = target;
+        }
+    }
+}
+/**
+ * Enhances a SignalTree with serialization capabilities
+ */
+function withSerialization(defaultConfig = {}) {
+    const enhancer = (tree) => {
+        const enhanced = tree;
+        /**
+         * Get plain object representation
+         */
+        enhanced.toJSON = () => {
+            // Delegate to the tree's public unwrap() which already strips helper
+            // methods like `set`/`update`. Keep unwrapObjectSafely for
+            // serialize() where we need type-preserving markers.
+            return tree();
+        };
+        /**
+         * Restore from plain object
+         */
+        enhanced.fromJSON = (data, metadata) => {
+            // Convert special type markers back to their actual types
+            const restoreSpecialTypes = (value) => {
+                if (!value || typeof value !== 'object') {
+                    return value;
+                }
+                // Check for type markers
+                if (TYPE_MARKERS.UNDEFINED in value) {
+                    return undefined;
+                }
+                if (TYPE_MARKERS.NAN in value) {
+                    return NaN;
+                }
+                if (TYPE_MARKERS.INFINITY in value) {
+                    return Infinity;
+                }
+                if (TYPE_MARKERS.NEG_INFINITY in value) {
+                    return -Infinity;
+                }
+                if (TYPE_MARKERS.BIGINT in value) {
+                    return BigInt(value[TYPE_MARKERS.BIGINT]);
+                }
+                if (TYPE_MARKERS.SYMBOL in value) {
+                    return Symbol.for(value[TYPE_MARKERS.SYMBOL]);
+                }
+                if (TYPE_MARKERS.DATE in value) {
+                    return new Date(value[TYPE_MARKERS.DATE]);
+                }
+                if (TYPE_MARKERS.REGEXP in value) {
+                    const regexpData = value[TYPE_MARKERS.REGEXP];
+                    return new RegExp(regexpData.source, regexpData.flags);
+                }
+                if (TYPE_MARKERS.MAP in value) {
+                    return new Map(value[TYPE_MARKERS.MAP]);
+                }
+                if (TYPE_MARKERS.SET in value) {
+                    return new Set(value[TYPE_MARKERS.SET]);
+                }
+                // Handle arrays
+                if (Array.isArray(value)) {
+                    return value.map(restoreSpecialTypes);
+                }
+                // Handle objects
+                const result = {};
+                for (const [k, v] of Object.entries(value)) {
+                    result[k] = restoreSpecialTypes(v);
+                }
+                return result;
+            };
+            // Restore special types in the data
+            const restoredData = restoreSpecialTypes(data);
+            // Helper to resolve a signal from the root alias (`tree.$`) using the
+            // accumulated path so keys that collide with branch methods (like "set")
+            // still map to the child signals.
+            function resolveAliasSignal(path, key) {
+                let node = tree.$;
+                if (path && node) {
+                    for (const part of path.split('.')) {
+                        if (!part)
+                            continue;
+                        const next = node[part];
+                        if (!next ||
+                            (typeof next !== 'object' && typeof next !== 'function')) {
+                            node = undefined;
+                            break;
+                        }
+                        node = next;
+                    }
+                }
+                const candidate = node?.[key];
+                return isSignal(candidate)
+                    ? candidate
+                    : undefined;
+            }
+            function updateSignals(target, source, path = '') {
+                if (!target || !source)
+                    return;
+                for (const key in source) {
+                    if (!Object.prototype.hasOwnProperty.call(source, key))
+                        continue;
+                    const sourceValue = source[key];
+                    const direct = target[key];
+                    // Prefer the real signal if present; otherwise resolve from root alias
+                    const targetSignal = isSignal(direct)
+                        ? direct
+                        : // Check if it's a callable signal (function with set method)
+                            typeof direct === 'function' &&
+                                'set' in direct &&
+                                typeof direct.set === 'function'
+                                ? direct
+                                : resolveAliasSignal(path, key);
+                    if (targetSignal) {
+                        targetSignal.set(sourceValue);
+                        continue;
+                    }
+                    if (sourceValue &&
+                        typeof sourceValue === 'object' &&
+                        !Array.isArray(sourceValue) &&
+                        direct &&
+                        (typeof direct === 'object' ||
+                            (typeof direct === 'function' && !('set' in direct))) &&
+                        !isSignal(direct)) {
+                        updateSignals(direct, sourceValue, path ? `${path}.${key}` : key);
+                    }
+                }
+            }
+            // If the serialized data contains a compact nodeMap, use it to apply
+            // updates deterministically: 'r' => root set, 'b' => set on branch
+            const nodeMap = metadata?.nodeMap;
+            if (nodeMap && Object.keys(nodeMap).length > 0) {
+                // Root marker
+                if (nodeMap[''] === 'r') {
+                    const rootAlias = tree.$;
+                    if (rootAlias && typeof rootAlias.set === 'function') {
+                        rootAlias.set(restoredData);
+                        // Don't return; still perform targeted updates below to ensure
+                        // type-preserving restoration for all branches.
+                    }
+                }
+                // For branch entries, apply child signal .set directly when possible
+                for (const [path, kind] of Object.entries(nodeMap)) {
+                    if (path === '')
+                        continue; // root handled
+                    if (kind !== 'b')
+                        continue;
+                    // Navigate to path and set the node if a WritableSignal is found
+                    const parts = path.split(/\.|\[|\]/).filter(Boolean);
+                    let node = tree.$;
+                    for (const p of parts) {
+                        if (!node)
+                            break;
+                        node =
+                            node[p] ?? undefined;
+                    }
+                    if (node &&
+                        (isSignal(node) ||
+                            (typeof node === 'function' &&
+                                'set' in node &&
+                                typeof node.set === 'function'))) {
+                        // Extract the corresponding value from restoredData
+                        let current = restoredData;
+                        for (const p of parts) {
+                            if (current == null) {
+                                current = undefined;
+                                break;
+                            }
+                            if (typeof current === 'object') {
+                                current = current[p];
+                            }
+                            else {
+                                current = undefined;
+                                break;
+                            }
+                        }
+                        try {
+                            node.set(current);
+                        }
+                        catch {
+                            /* ignore per-path failures */
+                        }
+                    }
+                }
+                // After applying nodeMap-targeted sets, perform a best-effort deep update for remaining keys
+                updateSignals(tree.state, restoredData);
+                return;
+            }
+            updateSignals(tree.state, restoredData);
+        };
+        // Encode/decode helpers that work on already-unwrapped plain data
+        function encodeSpecials(v, preserveTypes) {
+            if (!preserveTypes)
+                return v;
+            if (v === undefined)
+                return { [TYPE_MARKERS.UNDEFINED]: true };
+            if (typeof v === 'number') {
+                if (Number.isNaN(v))
+                    return { [TYPE_MARKERS.NAN]: true };
+                if (v === Infinity)
+                    return { [TYPE_MARKERS.INFINITY]: true };
+                if (v === -Infinity)
+                    return { [TYPE_MARKERS.NEG_INFINITY]: true };
+                return v;
+            }
+            if (typeof v === 'bigint')
+                return { [TYPE_MARKERS.BIGINT]: String(v) };
+            if (typeof v === 'symbol')
+                return { [TYPE_MARKERS.SYMBOL]: String(v) };
+            if (v instanceof Date)
+                return { [TYPE_MARKERS.DATE]: v.toISOString() };
+            if (v instanceof RegExp)
+                return {
+                    [TYPE_MARKERS.REGEXP]: { source: v.source, flags: v.flags },
+                };
+            if (v instanceof Map)
+                return { [TYPE_MARKERS.MAP]: Array.from(v.entries()) };
+            if (v instanceof Set)
+                return { [TYPE_MARKERS.SET]: Array.from(v.values()) };
+            if (Array.isArray(v))
+                return v.map((x) => encodeSpecials(x, preserveTypes));
+            if (v && typeof v === 'object') {
+                const out = {};
+                for (const [k, val] of Object.entries(v))
+                    out[k] = encodeSpecials(val, preserveTypes);
+                return out;
+            }
+            return v;
+        }
+        /**
+         * Serialize to JSON string
+         */
+        enhanced.serialize = (config) => {
+            const fullConfig = {
+                ...DEFAULT_CONFIG,
+                ...defaultConfig,
+                ...config,
+            };
+            // Use a safe local unwrap to avoid accidental dropping of keys like
+            // 'set' which may collide with branch helpers; let encodeSpecials
+            // handle special type markers.
+            const raw = unwrapObjectSafely(tree.state, new WeakSet(), 0, fullConfig.maxDepth, fullConfig.preserveTypes);
+            const state = encodeSpecials(raw, fullConfig.preserveTypes);
+            // Detect circular references if needed
+            const circularPaths = fullConfig.handleCircular
+                ? detectCircularReferences(state)
+                : [];
+            // Prepare data
+            const data = {
+                data: state,
+            };
+            // Build a compact nodeMap by traversing the callable proxy alias (tree.$)
+            // and marking any signal-like branch node we encounter. Also mark a
+            // root-as-signal marker ('r') if the root alias exposes a .set().
+            const nodeMap = {};
+            try {
+                const rootAlias = tree.$;
+                if (rootAlias && typeof rootAlias.set === 'function') {
+                    nodeMap[''] = 'r';
+                }
+                const visited = new WeakSet();
+                const isBranch = (v) => isSignal(v) ||
+                    (typeof v === 'function' &&
+                        'set' in v &&
+                        typeof v.set === 'function');
+                const walkAlias = (obj, path = '') => {
+                    if (!obj || (typeof obj !== 'object' && typeof obj !== 'function'))
+                        return;
+                    const ref = obj;
+                    if (visited.has(ref))
+                        return;
+                    visited.add(ref);
+                    if (path && isBranch(obj)) {
+                        nodeMap[path] = 'b';
+                    }
+                    // Traverse own enumerable properties (callable proxies expose children here)
+                    for (const [k, v] of Object.entries(obj)) {
+                        const childPath = path ? `${path}.${k}` : k;
+                        walkAlias(v, childPath);
+                    }
+                };
+                if (rootAlias)
+                    walkAlias(rootAlias);
+            }
+            catch {
+                // Do not block serialization on nodeMap errors
+            }
+            // Add metadata if requested
+            if (fullConfig.includeMetadata) {
+                data.metadata = {
+                    timestamp: Date.now(),
+                    version: '1.0.0',
+                    ...(circularPaths.length > 0 && { circularRefs: circularPaths }),
+                    ...(Object.keys(nodeMap).length > 0 && { nodeMap }),
+                };
+            }
+            // Serialize with custom replacer
+            const replacer = createReplacer(fullConfig);
+            const json = JSON.stringify(data, replacer, 2);
+            // Extra debug: if JSON contains MAP or SET markers, print compact preview
+            return json;
+        };
+        /**
+         * Deserialize from JSON string
+         */
+        enhanced.deserialize = (json, config) => {
+            const fullConfig = {
+                ...DEFAULT_CONFIG,
+                ...defaultConfig,
+                ...config,
+            };
+            try {
+                // Parse with simple JSON.parse (no custom reviver)
+                const parsed = JSON.parse(json);
+                // Extract data and metadata
+                const { data, metadata } = parsed;
+                // Resolve circular references if present
+                if (metadata?.circularRefs && fullConfig.handleCircular) {
+                    resolveCircularReferences(data, metadata.circularRefs);
+                }
+                // Apply parsed data to the tree; fromJSON will handle type restoration
+                enhanced.fromJSON(data, metadata);
+                // Log restoration if in debug mode
+                if (tree.__config?.debugMode) {
+                    console.log('[SignalTree] State restored from serialized data', {
+                        timestamp: metadata?.timestamp,
+                        version: metadata?.version,
+                    });
+                }
+            }
+            catch (error) {
+                console.error('[SignalTree] Failed to deserialize:', error);
+                throw new Error(`Failed to deserialize SignalTree state: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        };
+        /**
+         * Create a snapshot
+         */
+        enhanced.snapshot = () => {
+            const state = enhanced.toJSON();
+            const circularPaths = detectCircularReferences(state);
+            return {
+                data: JSON.parse(JSON.stringify(state)), // Deep clone
+                metadata: {
+                    timestamp: Date.now(),
+                    version: '1.0.0',
+                    ...(circularPaths.length > 0 && { circularRefs: circularPaths }),
+                },
+            };
+        };
+        /**
+         * Restore from snapshot
+         */
+        enhanced.restore = (snapshot) => {
+            const { data, metadata } = snapshot;
+            // Resolve circular references if present
+            if (metadata?.circularRefs) {
+                resolveCircularReferences(data, metadata.circularRefs);
+            }
+            enhanced.fromJSON(data, metadata);
+        };
+        return enhanced;
+    };
+    enhancer.metadata = {
+        name: 'serialization',
+    };
+    return enhancer;
+}
+/**
+ * Convenience function to enable serialization with defaults
+ */
+function enableSerialization() {
+    return withSerialization({
+        includeMetadata: true,
+        preserveTypes: true,
+        handleCircular: true,
+    });
+}
+/**
+ * Adds persistence capabilities to a SerializableSignalTree
+ */
+function withPersistence(config) {
+    const { key, storage = typeof window !== 'undefined' ? window.localStorage : undefined, autoSave = true, debounceMs = 1000, autoLoad = true, ...serializationConfig } = config;
+    if (!storage) {
+        throw new Error('No storage adapter available. Provide a storage adapter in the config.');
+    }
+    // Narrow storage for TypeScript and linter: from here on it's defined.
+    const storageAdapter = storage;
+    function enhancer(tree) {
+        // First enhance with serialization
+        const serializable = withSerialization(serializationConfig)(tree);
+        // Add persistence methods
+        const enhanced = serializable;
+        // Cache to avoid redundant storage writes. Use a metadata-free cache key
+        // so timestamps in metadata don't cause false positives for changes.
+        let lastCacheKey = null;
+        /**
+         * Save current state to storage
+         */
+        enhanced.save = async () => {
+            try {
+                // Compute a deterministic cache key that excludes metadata (timestamps)
+                const cacheKey = enhanced.serialize({
+                    ...serializationConfig,
+                    includeMetadata: false,
+                });
+                // Only write to storage if the state has changed (by cacheKey), unless skipCache is true
+                if (config.skipCache || cacheKey !== lastCacheKey) {
+                    // Persist the full payload (respecting includeMetadata from config)
+                    const serialized = enhanced.serialize(serializationConfig);
+                    await Promise.resolve(storageAdapter.setItem(key, serialized));
+                    lastCacheKey = cacheKey;
+                    if (tree.__config?.debugMode) {
+                        console.log(`[SignalTree] State saved to storage key: ${key}`);
+                    }
+                }
+                else if (tree.__config?.debugMode) {
+                    console.log(`[SignalTree] State unchanged, skipping storage write for key: ${key}`);
+                }
+            }
+            catch (error) {
+                console.error('[SignalTree] Failed to save state:', error);
+                throw error; // Re-throw for tests to catch
+            }
+        };
+        /**
+         * Load state from storage
+         */
+        enhanced.load = async () => {
+            try {
+                const data = await Promise.resolve(storageAdapter.getItem(key));
+                if (data) {
+                    enhanced.deserialize(data, serializationConfig);
+                    // Reset cache after loading new data using a metadata-free key
+                    lastCacheKey = enhanced.serialize({
+                        ...serializationConfig,
+                        includeMetadata: false,
+                    });
+                    if (tree.__config?.debugMode) {
+                        console.log(`[SignalTree] State loaded from storage key: ${key}`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('[SignalTree] Failed to load state:', error);
+                throw error; // Re-throw for tests to catch
+            }
+        };
+        /**
+         * Clear state from storage
+         */
+        enhanced.clear = async () => {
+            try {
+                await Promise.resolve(storageAdapter.removeItem(key));
+                lastCacheKey = null;
+                if (tree.__config?.debugMode) {
+                    console.log(`[SignalTree] State cleared from storage key: ${key}`);
+                }
+            }
+            catch (error) {
+                console.error('[SignalTree] Failed to clear state:', error);
+                throw error; // Re-throw for tests to catch
+            }
+        };
+        // Auto-load on creation if enabled
+        if (autoLoad) {
+            // Use setTimeout to avoid blocking initialization and timing issues
+            setTimeout(() => {
+                enhanced.load().catch((error) => {
+                    console.warn('[SignalTree] Auto-load failed:', error);
+                });
+            }, 0);
+        }
+        // Auto-save on updates if enabled
+        if (autoSave) {
+            let saveTimeout;
+            // Hook into state changes to trigger auto-save
+            const triggerAutoSave = () => {
+                // Debounce saves
+                if (saveTimeout) {
+                    clearTimeout(saveTimeout);
+                }
+                saveTimeout = setTimeout(() => {
+                    enhanced.save().catch((error) => {
+                        console.error('[SignalTree] Auto-save failed:', error);
+                    });
+                }, debounceMs);
+            };
+            // Watch for any signal changes in the tree
+            const watchSignals = (obj, path = '') => {
+                if (!obj || typeof obj !== 'object')
+                    return;
+                for (const [key, value] of Object.entries(obj)) {
+                    if (isSignal(value)) {
+                        // Create an effect to watch this signal
+                        const signal = value;
+                        let previousValue = signal();
+                        // Periodically check for changes (this is a simplified approach)
+                        // In a real implementation, you'd want to use Angular's effect() or similar
+                        const checkForChanges = () => {
+                            const currentValue = signal();
+                            if (currentValue !== previousValue) {
+                                previousValue = currentValue;
+                                triggerAutoSave();
+                            }
+                            setTimeout(checkForChanges, 50); // Check every 50ms
+                        };
+                        setTimeout(checkForChanges, 0);
+                    }
+                    else if (value && typeof value === 'object') {
+                        watchSignals(value, path ? `${path}.${key}` : key);
+                    }
+                }
+            };
+            // Start watching signals
+            watchSignals(tree.state);
+            // Store cleanup function for testing
+            enhanced.__flushAutoSave = () => {
+                if (saveTimeout) {
+                    clearTimeout(saveTimeout);
+                    saveTimeout = undefined;
+                    return enhanced.save();
+                }
+                return Promise.resolve();
+            };
+        }
+        return enhanced;
+    }
+    enhancer.metadata = { name: 'persistence' };
+    return enhancer;
+}
+/**
+ * Create a custom storage adapter
+ */
+function createStorageAdapter(getItem, setItem, removeItem) {
+    return { getItem, setItem, removeItem };
+}
+/**
+ * IndexedDB storage adapter for large state trees
+ */
+function createIndexedDBAdapter(dbName = 'SignalTreeDB', storeName = 'states') {
+    let db = null;
+    const openDB = async () => {
+        if (db)
+            return db;
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(dbName, 1);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                db = request.result;
+                resolve(db);
+            };
+            request.onupgradeneeded = (event) => {
+                const database = event.target.result;
+                if (!database.objectStoreNames.contains(storeName)) {
+                    database.createObjectStore(storeName);
+                }
+            };
+        });
+    };
+    return {
+        async getItem(key) {
+            const database = await openDB();
+            return new Promise((resolve, reject) => {
+                const transaction = database.transaction([storeName], 'readonly');
+                const store = transaction.objectStore(storeName);
+                const request = store.get(key);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve(request.result || null);
+            });
+        },
+        async setItem(key, value) {
+            const database = await openDB();
+            return new Promise((resolve, reject) => {
+                const transaction = database.transaction([storeName], 'readwrite');
+                const store = transaction.objectStore(storeName);
+                const request = store.put(value, key);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve();
+            });
+        },
+        async removeItem(key) {
+            const database = await openDB();
+            return new Promise((resolve, reject) => {
+                const transaction = database.transaction([storeName], 'readwrite');
+                const store = transaction.objectStore(storeName);
+                const request = store.delete(key);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve();
+            });
+        },
+    };
+}
+// Type-only exports (none)
+/**
+ * Helpers to apply enhancers with explicit typing to avoid depending on
+ * complex `.with()` overload inference in tests and tooling.
+ */
+function applySerialization(tree) {
+    return withSerialization()(tree);
+}
+function applyPersistence(tree, cfg) {
+    return withPersistence(cfg)(tree);
+}
+
+export { TYPE_MARKERS, applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, withPersistence, withSerialization };
+//# sourceMappingURL=index.js.map