@signaltree/core 3.1.0 → 4.0.1

package/src/lib/utils.js

@@ -1,286 +0,0 @@
-import { isSignal, signal } from '@angular/core';
-import { deepEqual, isBuiltInObject, parsePath } from '@signaltree/shared';
-const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
-export { deepEqual };
-export { deepEqual as equal };
-export { isBuiltInObject };
-export { parsePath };
-export function isNodeAccessor(value) {
-    return (typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value);
-}
-export function isAnySignal(value) {
-    return isSignal(value) || isNodeAccessor(value);
-}
-export function composeEnhancers(...enhancers) {
-    return (tree) => enhancers.reduce((t, e) => e(t), tree);
-}
-export function createLazySignalTree(obj, equalityFn, basePath = '', memoryManager) {
-    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();
-        if (memoryManager) {
-            memoryManager.dispose();
-        }
-    };
-    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 (memoryManager) {
-                const cached = memoryManager.getSignal(path);
-                if (cached)
-                    return cached;
-            }
-            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, memoryManager);
-                    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, { equal: equalityFn });
-                    signalCache.set(path, fallbackSignal);
-                    if (memoryManager) {
-                        memoryManager.cacheSignal(path, fallbackSignal);
-                    }
-                    return fallbackSignal;
-                }
-            }
-            try {
-                const newSignal = signal(value, { equal: equalityFn });
-                signalCache.set(path, newSignal);
-                if (memoryManager) {
-                    memoryManager.cacheSignal(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;
-}
-export function unwrap(node) {
-    if (node === null || node === undefined) {
-        return node;
-    }
-    if (isNodeAccessor(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(value)) {
-                    continue;
-                }
-            }
-            const value = node[key];
-            if (isNodeAccessor(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(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(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;
-}