@signaltree/core 4.0.1 → 4.0.3

package/dist/enhancers/serialization/index.js

@@ -1,837 +0,0 @@
-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