@signaltree/core 3.0.2 → 4.0.1

package/fesm2022/signaltree-core.mjs

@@ -1,1138 +0,0 @@
-import { isSignal, signal, computed, effect, inject, DestroyRef } from '@angular/core';
-
-const SIGNAL_TREE_CONSTANTS = {
-    MAX_PATH_CACHE_SIZE: 1000,
-    LAZY_THRESHOLD: 50,
-    ESTIMATE_MAX_DEPTH: 3,
-    ESTIMATE_SAMPLE_SIZE_ARRAY: 3,
-    ESTIMATE_SAMPLE_SIZE_OBJECT: 5,
-    DEFAULT_CACHE_SIZE: 100,
-    DEFAULT_BATCH_SIZE: 10,
-};
-const DEV_MESSAGES = {
-    NULL_OR_UNDEFINED: 'null/undefined',
-    CIRCULAR_REF: 'circular ref',
-    UPDATER_INVALID: 'updater invalid',
-    LAZY_FALLBACK: 'lazy fallback',
-    SIGNAL_CREATION_FAILED: 'signal creation failed',
-    UPDATE_PATH_NOT_FOUND: 'update path not found',
-    UPDATE_FAILED: 'update failed',
-    ROLLBACK_FAILED: 'rollback failed',
-    CLEANUP_ERROR: 'cleanup error',
-    PRESET_UNKNOWN: 'unknown preset',
-    STRATEGY_SELECTION: 'strategy select',
-    TREE_DESTROYED: 'destroyed',
-    UPDATE_TRANSACTION: 'update tx',
-    BATCH_NOT_ENABLED: 'batching disabled',
-    MEMOIZE_NOT_ENABLED: 'memoize disabled',
-    MIDDLEWARE_NOT_AVAILABLE: 'middleware missing',
-    ENTITY_HELPERS_NOT_AVAILABLE: 'entity helpers missing',
-    ASYNC_ACTIONS_NOT_AVAILABLE: 'async actions missing',
-    TIME_TRAVEL_NOT_AVAILABLE: 'time travel missing',
-    OPTIMIZE_NOT_AVAILABLE: 'optimize missing',
-    CACHE_NOT_AVAILABLE: 'cache missing',
-    PERFORMANCE_NOT_ENABLED: 'performance disabled',
-    ENHANCER_ORDER_FAILED: 'enhancer order failed',
-    ENHANCER_CYCLE_DETECTED: 'enhancer cycle',
-    ENHANCER_REQUIREMENT_MISSING: 'enhancer req missing',
-    ENHANCER_PROVIDES_MISSING: 'enhancer provides missing',
-    ENHANCER_FAILED: 'enhancer failed',
-    ENHANCER_NOT_FUNCTION: 'enhancer not function',
-    EFFECT_NO_CONTEXT: 'no angular context',
-    SUBSCRIBE_NO_CONTEXT: 'no angular context',
-};
-const PROD_MESSAGES = (() => {
-    const out = {};
-    let i = 0;
-    for (const k of Object.keys(DEV_MESSAGES)) {
-        out[k] = String(i++);
-    }
-    return out;
-})();
-const _isProdByEnv = Boolean(typeof globalThis === 'object' &&
-    globalThis !== null &&
-    'process' in globalThis &&
-    typeof globalThis.process === 'object' &&
-    'env' in globalThis.process &&
-    globalThis.process.env.NODE_ENV === 'production');
-const _isDev = typeof ngDevMode !== 'undefined' ? Boolean(ngDevMode) : !_isProdByEnv;
-const SIGNAL_TREE_MESSAGES = Object.freeze(_isDev
-    ? DEV_MESSAGES
-    : PROD_MESSAGES);
-
-const ENHANCER_META = Symbol('signaltree:enhancer:meta');
-function isSignalTree(value) {
-    return (value !== null &&
-        typeof value === 'function' &&
-        'state' in value &&
-        '$' in value &&
-        'with' in value &&
-        'destroy' in value);
-}
-
-function createEnhancer(meta, enhancerFn) {
-    const fn = enhancerFn;
-    try {
-        fn.metadata = meta;
-        try {
-            fn[ENHANCER_META] = meta;
-        }
-        catch {
-        }
-    }
-    catch {
-    }
-    return fn;
-}
-function resolveEnhancerOrder(enhancers, availableCapabilities = new Set(), debugMode = false) {
-    const nodes = enhancers.map((e, idx) => ({
-        fn: e,
-        name: e.metadata && e.metadata.name
-            ? String(e.metadata.name)
-            : `enhancer#${idx}`,
-        requires: new Set(e.metadata?.requires ?? []),
-        provides: new Set(e.metadata?.provides ?? []),
-    }));
-    const adj = new Map();
-    const nameToNode = new Map();
-    for (const n of nodes) {
-        nameToNode.set(n.name, n);
-        adj.set(n.name, new Set());
-    }
-    for (const a of nodes) {
-        for (const b of nodes) {
-            if (a === b)
-                continue;
-            for (const req of b.requires) {
-                if (availableCapabilities.has(req))
-                    continue;
-                if (a.provides.has(req)) {
-                    const set = adj.get(a.name);
-                    if (set)
-                        set.add(b.name);
-                }
-            }
-        }
-    }
-    const inDegree = new Map();
-    for (const entry of adj.keys())
-        inDegree.set(entry, 0);
-    for (const [, outs] of adj) {
-        for (const to of outs)
-            inDegree.set(to, (inDegree.get(to) || 0) + 1);
-    }
-    const queue = [];
-    for (const [name, deg] of inDegree.entries()) {
-        if (deg === 0)
-            queue.push(name);
-    }
-    const ordered = [];
-    while (queue.length > 0) {
-        const n = queue.shift();
-        if (!n)
-            break;
-        ordered.push(n);
-        const outs = adj.get(n);
-        if (!outs)
-            continue;
-        for (const m of outs) {
-            inDegree.set(m, (inDegree.get(m) || 0) - 1);
-            if (inDegree.get(m) === 0)
-                queue.push(m);
-        }
-    }
-    if (ordered.length !== nodes.length) {
-        if (debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_CYCLE_DETECTED);
-        }
-        return enhancers;
-    }
-    return ordered.map((name) => {
-        const n = nameToNode.get(name);
-        return (n ? n.fn : enhancers[0]);
-    });
-}
-
-const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
-function equal(a, b) {
-    if (a === b)
-        return true;
-    if (a == null || b == null)
-        return a === b;
-    const typeA = typeof a;
-    const typeB = typeof b;
-    if (typeA !== typeB)
-        return false;
-    if (typeA !== 'object')
-        return false;
-    if (a instanceof Date && b instanceof Date)
-        return a.getTime() === b.getTime();
-    if (a instanceof RegExp && b instanceof RegExp)
-        return a.source === b.source && a.flags === b.flags;
-    if (a instanceof Map && b instanceof Map) {
-        if (a.size !== b.size)
-            return false;
-        for (const [key, value] of a) {
-            if (!b.has(key) || !equal(value, b.get(key)))
-                return false;
-        }
-        return true;
-    }
-    if (a instanceof Set && b instanceof Set) {
-        if (a.size !== b.size)
-            return false;
-        for (const value of a) {
-            if (!b.has(value))
-                return false;
-        }
-        return true;
-    }
-    if (Array.isArray(a)) {
-        if (!Array.isArray(b) || a.length !== b.length)
-            return false;
-        return a.every((item, i) => equal(item, b[i]));
-    }
-    if (Array.isArray(b))
-        return false;
-    const objA = a;
-    const objB = b;
-    const keysA = Object.keys(objA);
-    const keysB = Object.keys(objB);
-    if (keysA.length !== keysB.length)
-        return false;
-    return keysA.every((k) => k in objB && equal(objA[k], objB[k]));
-}
-const deepEqual = equal;
-function isBuiltInObject(v) {
-    if (v === null || v === undefined)
-        return false;
-    if (v instanceof Date ||
-        v instanceof RegExp ||
-        typeof v === 'function' ||
-        v instanceof Map ||
-        v instanceof Set ||
-        v instanceof WeakMap ||
-        v instanceof WeakSet ||
-        v instanceof ArrayBuffer ||
-        v instanceof DataView ||
-        v instanceof Error ||
-        v instanceof Promise) {
-        return true;
-    }
-    if (v instanceof Int8Array ||
-        v instanceof Uint8Array ||
-        v instanceof Uint8ClampedArray ||
-        v instanceof Int16Array ||
-        v instanceof Uint16Array ||
-        v instanceof Int32Array ||
-        v instanceof Uint32Array ||
-        v instanceof Float32Array ||
-        v instanceof Float64Array ||
-        v instanceof BigInt64Array ||
-        v instanceof BigUint64Array) {
-        return true;
-    }
-    if (typeof window !== 'undefined') {
-        if (v instanceof URL ||
-            v instanceof URLSearchParams ||
-            v instanceof FormData ||
-            v instanceof Blob ||
-            (typeof File !== 'undefined' && v instanceof File) ||
-            (typeof FileList !== 'undefined' && v instanceof FileList) ||
-            (typeof Headers !== 'undefined' && v instanceof Headers) ||
-            (typeof Request !== 'undefined' && v instanceof Request) ||
-            (typeof Response !== 'undefined' && v instanceof Response) ||
-            (typeof AbortController !== 'undefined' &&
-                v instanceof AbortController) ||
-            (typeof AbortSignal !== 'undefined' && v instanceof AbortSignal)) {
-            return true;
-        }
-    }
-    try {
-        const NodeBuffer = globalThis?.Buffer;
-        if (NodeBuffer &&
-            v instanceof NodeBuffer)
-            return true;
-    }
-    catch {
-    }
-    return false;
-}
-function isNodeAccessor$1(value) {
-    return (typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value);
-}
-function isAnySignal(value) {
-    return isSignal(value) || isNodeAccessor$1(value);
-}
-class LRUCache {
-    maxSize;
-    cache = new Map();
-    constructor(maxSize) {
-        this.maxSize = maxSize;
-    }
-    set(key, value) {
-        if (this.cache.size >= this.maxSize) {
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey !== undefined)
-                this.cache.delete(firstKey);
-        }
-        this.cache.delete(key);
-        this.cache.set(key, value);
-    }
-    get(key) {
-        const value = this.cache.get(key);
-        if (value !== undefined) {
-            this.cache.delete(key);
-            this.cache.set(key, value);
-        }
-        return value;
-    }
-    clear() {
-        this.cache.clear();
-    }
-    size() {
-        return this.cache.size;
-    }
-}
-const pathCache = new LRUCache(SIGNAL_TREE_CONSTANTS.MAX_PATH_CACHE_SIZE);
-function parsePath(path) {
-    const cached = pathCache.get(path);
-    if (cached)
-        return cached;
-    const parts = path.split('.');
-    pathCache.set(path, parts);
-    return parts;
-}
-function composeEnhancers(...enhancers) {
-    return (tree) => enhancers.reduce((t, e) => e(t), tree);
-}
-function createLazySignalTree(obj, equalityFn, basePath = '') {
-    const signalCache = new Map();
-    const nestedProxies = new Map();
-    const nestedCleanups = new Map();
-    const cleanup = () => {
-        nestedCleanups.forEach((fn) => {
-            try {
-                fn();
-            }
-            catch (error) {
-                console.warn('Error during nested cleanup:', error);
-            }
-        });
-        nestedCleanups.clear();
-        signalCache.clear();
-        nestedProxies.clear();
-    };
-    const proxy = new Proxy(obj, {
-        get(target, prop) {
-            if (prop === '__cleanup__')
-                return cleanup;
-            if (typeof prop === 'symbol') {
-                return target[prop];
-            }
-            if (prop === 'valueOf' || prop === 'toString') {
-                return target[prop];
-            }
-            const key = prop;
-            const path = basePath ? `${basePath}.${key}` : key;
-            if (!(key in target))
-                return undefined;
-            const value = target[key];
-            if (isSignal(value))
-                return value;
-            if (signalCache.has(path))
-                return signalCache.get(path);
-            if (nestedProxies.has(path))
-                return nestedProxies.get(path);
-            if (value &&
-                typeof value === 'object' &&
-                !Array.isArray(value) &&
-                !isSignal(value) &&
-                !isBuiltInObject(value)) {
-                try {
-                    const nestedProxy = createLazySignalTree(value, equalityFn, path);
-                    nestedProxies.set(path, nestedProxy);
-                    const proxyWithCleanup = nestedProxy;
-                    if (typeof proxyWithCleanup.__cleanup__ === 'function') {
-                        nestedCleanups.set(path, proxyWithCleanup.__cleanup__);
-                    }
-                    return nestedProxy;
-                }
-                catch (error) {
-                    console.warn(`Failed to create lazy proxy for path "${path}":`, error);
-                    const fallbackSignal = signal(value, ...(ngDevMode ? [{ debugName: "fallbackSignal", equal: equalityFn }] : [{ equal: equalityFn }]));
-                    signalCache.set(path, fallbackSignal);
-                    return fallbackSignal;
-                }
-            }
-            try {
-                const newSignal = signal(value, ...(ngDevMode ? [{ debugName: "newSignal", equal: equalityFn }] : [{ equal: equalityFn }]));
-                signalCache.set(path, newSignal);
-                return newSignal;
-            }
-            catch (error) {
-                console.warn(`Failed to create signal for path "${path}":`, error);
-                return value;
-            }
-        },
-        set(target, prop, value) {
-            if (typeof prop === 'symbol') {
-                target[prop] = value;
-                return true;
-            }
-            const key = prop;
-            const path = basePath ? `${basePath}.${key}` : key;
-            try {
-                target[key] = value;
-                const cachedSignal = signalCache.get(path);
-                if (cachedSignal && 'set' in cachedSignal) {
-                    cachedSignal.set(value);
-                }
-                if (nestedProxies.has(path)) {
-                    const nestedCleanup = nestedCleanups.get(path);
-                    if (nestedCleanup) {
-                        nestedCleanup();
-                        nestedCleanups.delete(path);
-                    }
-                    nestedProxies.delete(path);
-                }
-                return true;
-            }
-            catch (error) {
-                console.warn(`Failed to set value for path "${path}":`, error);
-                return false;
-            }
-        },
-        has(target, prop) {
-            return prop in target;
-        },
-        ownKeys(target) {
-            return Reflect.ownKeys(target);
-        },
-        getOwnPropertyDescriptor(target, prop) {
-            return Reflect.getOwnPropertyDescriptor(target, prop);
-        },
-    });
-    return proxy;
-}
-function unwrap(node) {
-    if (node === null || node === undefined) {
-        return node;
-    }
-    if (isNodeAccessor$1(node)) {
-        const result = {};
-        for (const key in node) {
-            if (!Object.prototype.hasOwnProperty.call(node, key))
-                continue;
-            if (key === 'length' || key === 'prototype')
-                continue;
-            if (key === 'name') {
-                const value = node[key];
-                if (!isSignal(value) && !isNodeAccessor$1(value)) {
-                    continue;
-                }
-            }
-            const value = node[key];
-            if (isNodeAccessor$1(value)) {
-                result[key] = unwrap(value);
-            }
-            else if (isSignal(value)) {
-                const unwrappedValue = value();
-                if (typeof unwrappedValue === 'object' &&
-                    unwrappedValue !== null &&
-                    !Array.isArray(unwrappedValue) &&
-                    !isBuiltInObject(unwrappedValue)) {
-                    result[key] = unwrap(unwrappedValue);
-                }
-                else {
-                    result[key] = unwrappedValue;
-                }
-            }
-            else if (typeof value === 'object' &&
-                value !== null &&
-                !Array.isArray(value) &&
-                !isBuiltInObject(value)) {
-                result[key] = unwrap(value);
-            }
-            else {
-                result[key] = value;
-            }
-        }
-        return result;
-    }
-    if (isSignal(node)) {
-        const value = node();
-        if (typeof value === 'object' &&
-            value !== null &&
-            !Array.isArray(value) &&
-            !isBuiltInObject(value)) {
-            return unwrap(value);
-        }
-        return value;
-    }
-    if (typeof node !== 'object') {
-        return node;
-    }
-    if (Array.isArray(node)) {
-        return node;
-    }
-    if (isBuiltInObject(node)) {
-        return node;
-    }
-    const result = {};
-    for (const key in node) {
-        if (!Object.prototype.hasOwnProperty.call(node, key))
-            continue;
-        if (key === 'set' || key === 'update') {
-            const v = node[key];
-            if (typeof v === 'function')
-                continue;
-        }
-        const value = node[key];
-        if (isNodeAccessor$1(value)) {
-            const unwrappedValue = value();
-            if (typeof unwrappedValue === 'object' &&
-                unwrappedValue !== null &&
-                !Array.isArray(unwrappedValue) &&
-                !isBuiltInObject(unwrappedValue)) {
-                result[key] = unwrap(unwrappedValue);
-            }
-            else {
-                result[key] = unwrappedValue;
-            }
-        }
-        else if (isSignal(value)) {
-            const unwrappedValue = value();
-            if (typeof unwrappedValue === 'object' &&
-                unwrappedValue !== null &&
-                !Array.isArray(unwrappedValue) &&
-                !isBuiltInObject(unwrappedValue)) {
-                result[key] = unwrap(unwrappedValue);
-            }
-            else {
-                result[key] = unwrappedValue;
-            }
-        }
-        else if (typeof value === 'object' &&
-            value !== null &&
-            !Array.isArray(value) &&
-            !isBuiltInObject(value)) {
-            result[key] = unwrap(value);
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    const symbols = Object.getOwnPropertySymbols(node);
-    for (const sym of symbols) {
-        const value = node[sym];
-        if (isNodeAccessor$1(value)) {
-            const unwrappedValue = value();
-            if (typeof unwrappedValue === 'object' &&
-                unwrappedValue !== null &&
-                !Array.isArray(unwrappedValue) &&
-                !isBuiltInObject(unwrappedValue)) {
-                result[sym] = unwrap(unwrappedValue);
-            }
-            else {
-                result[sym] = unwrappedValue;
-            }
-        }
-        else if (isSignal(value)) {
-            const unwrappedValue = value();
-            if (typeof unwrappedValue === 'object' &&
-                unwrappedValue !== null &&
-                !Array.isArray(unwrappedValue) &&
-                !isBuiltInObject(unwrappedValue)) {
-                result[sym] = unwrap(unwrappedValue);
-            }
-            else {
-                result[sym] = unwrappedValue;
-            }
-        }
-        else if (typeof value === 'object' &&
-            value !== null &&
-            !Array.isArray(value) &&
-            !isBuiltInObject(value)) {
-            result[sym] = unwrap(value);
-        }
-        else {
-            result[sym] = value;
-        }
-    }
-    return result;
-}
-
-const NODE_ACCESSOR_SYMBOL = Symbol.for('NodeAccessor');
-function makeNodeAccessor() {
-    const accessor = function (arg) {
-        if (arguments.length === 0) {
-            return unwrap(accessor);
-        }
-        if (typeof arg === 'function') {
-            const updater = arg;
-            const currentValue = unwrap(accessor);
-            const newValue = updater(currentValue);
-            recursiveUpdate(accessor, newValue);
-        }
-        else {
-            recursiveUpdate(accessor, arg);
-        }
-    };
-    accessor[NODE_ACCESSOR_SYMBOL] = true;
-    return accessor;
-}
-function makeRootNodeAccessor(readSignal, writeSignal) {
-    const accessor = function (arg) {
-        if (arguments.length === 0) {
-            return readSignal();
-        }
-        if (typeof arg === 'function') {
-            const updater = arg;
-            writeSignal.set(updater(readSignal()));
-        }
-        else {
-            writeSignal.set(arg);
-        }
-    };
-    accessor[NODE_ACCESSOR_SYMBOL] = true;
-    return accessor;
-}
-function recursiveUpdate(target, updates) {
-    if (!updates || typeof updates !== 'object') {
-        return;
-    }
-    let targetObj;
-    if (isNodeAccessor(target)) {
-        targetObj = target;
-    }
-    else if (target && typeof target === 'object') {
-        targetObj = target;
-    }
-    else {
-        return;
-    }
-    const updatesObj = updates;
-    for (const key in updatesObj) {
-        if (!(key in targetObj)) {
-            continue;
-        }
-        const targetProp = targetObj[key];
-        const updateValue = updatesObj[key];
-        if (isSignal(targetProp)) {
-            if ('set' in targetProp && typeof targetProp.set === 'function') {
-                targetProp.set(updateValue);
-            }
-        }
-        else if (isNodeAccessor(targetProp)) {
-            if (updateValue && typeof updateValue === 'object') {
-                recursiveUpdate(targetProp, updateValue);
-            }
-            else {
-                targetProp(updateValue);
-            }
-        }
-    }
-}
-function isNodeAccessor(value) {
-    return (typeof value === 'function' &&
-        value &&
-        value[NODE_ACCESSOR_SYMBOL] === true);
-}
-function estimateObjectSize(obj, maxDepth = SIGNAL_TREE_CONSTANTS.ESTIMATE_MAX_DEPTH, currentDepth = 0) {
-    if (currentDepth >= maxDepth)
-        return 1;
-    if (obj === null || obj === undefined)
-        return 0;
-    if (typeof obj !== 'object')
-        return 1;
-    let size = 0;
-    try {
-        if (Array.isArray(obj)) {
-            size = obj.length;
-            const sampleSize = Math.min(SIGNAL_TREE_CONSTANTS.ESTIMATE_SAMPLE_SIZE_ARRAY, obj.length);
-            for (let i = 0; i < sampleSize; i++) {
-                size += estimateObjectSize(obj[i], maxDepth, currentDepth + 1) * 0.1;
-            }
-        }
-        else {
-            const keys = Object.keys(obj);
-            size = keys.length;
-            const sampleSize = Math.min(SIGNAL_TREE_CONSTANTS.ESTIMATE_SAMPLE_SIZE_OBJECT, keys.length);
-            for (let i = 0; i < sampleSize; i++) {
-                const value = obj[keys[i]];
-                size += estimateObjectSize(value, maxDepth, currentDepth + 1) * 0.5;
-            }
-        }
-    }
-    catch {
-        return 1;
-    }
-    return Math.floor(size);
-}
-function shouldUseLazy(obj, config, precomputedSize) {
-    if (config.useLazySignals !== undefined)
-        return config.useLazySignals;
-    if (config.debugMode || config.enableDevTools)
-        return false;
-    if (config.batchUpdates && config.useMemoization)
-        return true;
-    const estimatedSize = precomputedSize ?? estimateObjectSize(obj);
-    return estimatedSize > SIGNAL_TREE_CONSTANTS.LAZY_THRESHOLD;
-}
-function createEqualityFn(useShallowComparison) {
-    return useShallowComparison ? Object.is : equal;
-}
-function createSignalStore(obj, equalityFn) {
-    if (obj === null || obj === undefined || typeof obj !== 'object') {
-        return signal(obj, { equal: equalityFn });
-    }
-    if (Array.isArray(obj)) {
-        return signal(obj, { equal: equalityFn });
-    }
-    if (isBuiltInObject(obj)) {
-        return signal(obj, { equal: equalityFn });
-    }
-    const store = {};
-    const processedObjects = new WeakSet();
-    if (processedObjects.has(obj)) {
-        console.warn(SIGNAL_TREE_MESSAGES.CIRCULAR_REF);
-        return signal(obj, { equal: equalityFn });
-    }
-    processedObjects.add(obj);
-    try {
-        for (const [key, value] of Object.entries(obj)) {
-            try {
-                if (typeof key === 'symbol')
-                    continue;
-                if (isSignal(value)) {
-                    store[key] = value;
-                    continue;
-                }
-                if (value === null || value === undefined) {
-                    store[key] = signal(value, {
-                        equal: equalityFn,
-                    });
-                }
-                else if (typeof value !== 'object') {
-                    store[key] = signal(value, {
-                        equal: equalityFn,
-                    });
-                }
-                else if (Array.isArray(value) || isBuiltInObject(value)) {
-                    store[key] = signal(value, {
-                        equal: equalityFn,
-                    });
-                }
-                else {
-                    const branch = createSignalStore(value, equalityFn);
-                    const callableBranch = makeNodeAccessor();
-                    for (const branchKey in branch) {
-                        if (Object.prototype.hasOwnProperty.call(branch, branchKey)) {
-                            try {
-                                Object.defineProperty(callableBranch, branchKey, {
-                                    value: branch[branchKey],
-                                    enumerable: true,
-                                    configurable: true,
-                                });
-                            }
-                            catch {
-                            }
-                        }
-                    }
-                    store[key] = callableBranch;
-                }
-            }
-            catch (error) {
-                console.warn(`${SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED} "${key}":`, error);
-                store[key] = signal(value, {
-                    equal: equalityFn,
-                });
-            }
-        }
-        const symbols = Object.getOwnPropertySymbols(obj);
-        for (const sym of symbols) {
-            const value = obj[sym];
-            try {
-                if (isSignal(value)) {
-                    store[sym] = value;
-                }
-                else {
-                    store[sym] = signal(value, {
-                        equal: equalityFn,
-                    });
-                }
-            }
-            catch (error) {
-                console.warn(SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED, error);
-            }
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to create signal store: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-    return store;
-}
-function enhanceTree(tree, config = {}) {
-    const isLazy = config.useLazySignals ?? shouldUseLazy(tree.state, config);
-    tree.with = ((...enhancers) => {
-        if (enhancers.length === 0) {
-            return tree;
-        }
-        const coreCapabilities = new Set();
-        if (config.batchUpdates)
-            coreCapabilities.add('batchUpdate');
-        if (config.useMemoization)
-            coreCapabilities.add('memoize');
-        if (config.enableTimeTravel)
-            coreCapabilities.add('undo');
-        if (config.enableDevTools)
-            coreCapabilities.add('connectDevTools');
-        try {
-            for (const key of Object.keys(tree))
-                coreCapabilities.add(String(key));
-        }
-        catch {
-        }
-        const hasMetadata = enhancers.some((e) => Boolean(e.metadata && (e.metadata.requires || e.metadata.provides)));
-        let orderedEnhancers = enhancers;
-        if (hasMetadata) {
-            try {
-                orderedEnhancers = resolveEnhancerOrder(enhancers, coreCapabilities, config.debugMode);
-            }
-            catch (err) {
-                console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_ORDER_FAILED, err);
-            }
-        }
-        const provided = new Set(coreCapabilities);
-        let currentTree = tree;
-        for (let i = 0; i < orderedEnhancers.length; i++) {
-            const enhancer = orderedEnhancers[i];
-            if (typeof enhancer !== 'function') {
-                throw new Error(SIGNAL_TREE_MESSAGES.ENHANCER_NOT_FUNCTION.replace('%d', String(i)));
-            }
-            const reqs = enhancer.metadata?.requires ?? [];
-            for (const r of reqs) {
-                if (!(r in currentTree) && !provided.has(r)) {
-                    const name = enhancer.metadata?.name ?? `enhancer#${i}`;
-                    const msg = SIGNAL_TREE_MESSAGES.ENHANCER_REQUIREMENT_MISSING.replace('%s', name).replace('%s', r);
-                    if (config.debugMode) {
-                        throw new Error(msg);
-                    }
-                    else {
-                        console.warn(msg);
-                    }
-                }
-            }
-            try {
-                const result = enhancer(currentTree);
-                if (result !== currentTree)
-                    currentTree = result;
-                const provs = enhancer.metadata?.provides ?? [];
-                for (const p of provs)
-                    provided.add(p);
-                if (config.debugMode && provs.length > 0) {
-                    for (const p of provs) {
-                        if (!(p in currentTree)) {
-                            console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_PROVIDES_MISSING.replace('%s', enhancer.metadata?.name ?? String(i)).replace('%s', p));
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                const name = enhancer.metadata?.name || `enhancer at index ${i}`;
-                console.error(SIGNAL_TREE_MESSAGES.ENHANCER_FAILED.replace('%s', name), error);
-                if (config.debugMode) {
-                    console.error('[SignalTree] Enhancer stack trace:', enhancer);
-                    console.error('[SignalTree] Tree state at failure:', currentTree);
-                }
-                throw error;
-            }
-        }
-        return currentTree;
-    });
-    tree.destroy = () => {
-        try {
-            if (isLazy) {
-                const state = tree.state;
-                if (state && typeof state === 'object' && '__cleanup__' in state) {
-                    const cleanup = state.__cleanup__;
-                    if (typeof cleanup === 'function') {
-                        cleanup();
-                    }
-                }
-            }
-            if (config.debugMode) {
-                console.log(SIGNAL_TREE_MESSAGES.TREE_DESTROYED);
-            }
-        }
-        catch (error) {
-            console.error(SIGNAL_TREE_MESSAGES.CLEANUP_ERROR, error);
-        }
-    };
-    addStubMethods(tree, config);
-    return tree;
-}
-function addStubMethods(tree, config) {
-    tree.batchUpdate = (updater) => {
-        console.warn(SIGNAL_TREE_MESSAGES.BATCH_NOT_ENABLED);
-        tree((current) => {
-            const partial = updater(current);
-            return { ...current, ...partial };
-        });
-    };
-    tree.memoize = (fn, cacheKey) => {
-        console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
-        void cacheKey;
-        return computed(() => fn(tree()));
-    };
-    tree.memoizedUpdate = (updater) => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
-        }
-        tree((current) => ({ ...current, ...updater(current) }));
-    };
-    tree.clearMemoCache = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
-        }
-    };
-    tree.getCacheStats = () => ({
-        size: 0,
-        hitRate: 0,
-        totalHits: 0,
-        totalMisses: 0,
-        keys: [],
-    });
-    tree.effect = (fn) => {
-        try {
-            effect(() => fn(tree()));
-        }
-        catch (error) {
-            if (config.debugMode) {
-                console.warn(SIGNAL_TREE_MESSAGES.EFFECT_NO_CONTEXT, error);
-            }
-        }
-    };
-    tree.subscribe = (fn) => {
-        try {
-            const destroyRef = inject(DestroyRef);
-            let isDestroyed = false;
-            const effectRef = effect(() => {
-                if (!isDestroyed) {
-                    fn(tree());
-                }
-            }, ...(ngDevMode ? [{ debugName: "effectRef" }] : []));
-            const unsubscribe = () => {
-                isDestroyed = true;
-                effectRef.destroy();
-            };
-            destroyRef.onDestroy(unsubscribe);
-            return unsubscribe;
-        }
-        catch (error) {
-            if (config.debugMode) {
-                console.warn(SIGNAL_TREE_MESSAGES.SUBSCRIBE_NO_CONTEXT, error);
-            }
-            fn(tree());
-            return () => {
-            };
-        }
-    };
-    tree.optimize = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.OPTIMIZE_NOT_AVAILABLE);
-        }
-    };
-    tree.clearCache = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.CACHE_NOT_AVAILABLE);
-        }
-    };
-    tree.invalidatePattern = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.PERFORMANCE_NOT_ENABLED);
-        }
-        return 0;
-    };
-    tree.getMetrics = () => {
-        return {
-            updates: 0,
-            computations: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            averageUpdateTime: 0,
-        };
-    };
-    tree.addTap = (middleware) => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
-        }
-        void middleware;
-    };
-    tree.removeTap = (id) => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
-        }
-        void id;
-    };
-    tree.entities = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.ENTITY_HELPERS_NOT_AVAILABLE);
-        }
-        return {};
-    };
-    tree.asyncAction = (operation, asyncConfig = {}) => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.ASYNC_ACTIONS_NOT_AVAILABLE);
-        }
-        void operation;
-        void asyncConfig;
-        return {};
-    };
-    tree.undo = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
-        }
-    };
-    tree.redo = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
-        }
-    };
-    tree.getHistory = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
-        }
-        return [];
-    };
-    tree.resetHistory = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
-        }
-    };
-}
-function create(obj, config = {}) {
-    if (obj === null || obj === undefined) {
-        throw new Error(SIGNAL_TREE_MESSAGES.NULL_OR_UNDEFINED);
-    }
-    const estimatedSize = estimateObjectSize(obj);
-    const equalityFn = createEqualityFn(config.useShallowComparison ?? false);
-    if (Array.isArray(obj)) {
-        const signalState = signal(obj, {
-            equal: equalityFn,
-        });
-        const tree = makeRootNodeAccessor(signalState, signalState);
-        Object.defineProperty(tree, 'state', {
-            value: signalState,
-            enumerable: false,
-        });
-        Object.defineProperty(tree, '$', { value: signalState, enumerable: false });
-        enhanceTree(tree, config);
-        return tree;
-    }
-    const useLazy = shouldUseLazy(obj, config, estimatedSize);
-    if (config.debugMode) {
-        console.log(SIGNAL_TREE_MESSAGES.STRATEGY_SELECTION.replace('%s', useLazy ? 'lazy' : 'eager').replace('%d', String(estimatedSize)));
-    }
-    let signalState;
-    try {
-        if (useLazy && typeof obj === 'object') {
-            signalState = createLazySignalTree(obj, equalityFn);
-        }
-        else {
-            signalState = createSignalStore(obj, equalityFn);
-        }
-    }
-    catch (error) {
-        if (useLazy) {
-            console.warn(SIGNAL_TREE_MESSAGES.LAZY_FALLBACK, error);
-            signalState = createSignalStore(obj, equalityFn);
-        }
-        else {
-            throw error;
-        }
-    }
-    const tree = function (arg) {
-        if (arguments.length === 0) {
-            return unwrap(signalState);
-        }
-        if (typeof arg === 'function') {
-            const updater = arg;
-            const currentValue = unwrap(signalState);
-            const newValue = updater(currentValue);
-            recursiveUpdate(signalState, newValue);
-        }
-        else {
-            recursiveUpdate(signalState, arg);
-        }
-    };
-    Object.defineProperty(tree, NODE_ACCESSOR_SYMBOL, {
-        value: true,
-        enumerable: false,
-    });
-    Object.defineProperty(tree, 'state', {
-        value: signalState,
-        enumerable: false,
-    });
-    Object.defineProperty(tree, '$', { value: signalState, enumerable: false });
-    enhanceTree(tree, config);
-    for (const key in signalState) {
-        if (Object.prototype.hasOwnProperty.call(signalState, key)) {
-            if (!(key in tree)) {
-                try {
-                    Object.defineProperty(tree, key, {
-                        value: signalState[key],
-                        enumerable: true,
-                        configurable: true,
-                    });
-                }
-                catch {
-                }
-            }
-        }
-    }
-    return tree;
-}
-const presetConfigs = {
-    basic: {
-        useLazySignals: false,
-        debugMode: false,
-    },
-    performance: {
-        useLazySignals: true,
-        batchUpdates: true,
-        useMemoization: true,
-        useShallowComparison: true,
-    },
-    development: {
-        useLazySignals: false,
-        debugMode: true,
-        enableDevTools: true,
-        trackPerformance: true,
-    },
-    production: {
-        useLazySignals: true,
-        batchUpdates: true,
-        useMemoization: true,
-        debugMode: false,
-    },
-};
-function signalTree(obj, configOrPreset) {
-    if (typeof configOrPreset === 'string') {
-        const config = presetConfigs[configOrPreset];
-        if (!config) {
-            console.warn(SIGNAL_TREE_MESSAGES.PRESET_UNKNOWN.replace('%s', configOrPreset));
-            return create(obj, {});
-        }
-        return create(obj, config);
-    }
-    const config = configOrPreset || {};
-    return create(obj, config);
-}
-function applyEnhancer(tree, enhancer) {
-    return enhancer(tree);
-}
-
-export { ENHANCER_META, SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES, composeEnhancers, createEnhancer, createLazySignalTree, deepEqual, equal, isAnySignal, isBuiltInObject, isNodeAccessor$1 as isNodeAccessor, parsePath, resolveEnhancerOrder, signalTree };
-//# sourceMappingURL=signaltree-core.mjs.map