@signaltree/core 3.0.1 → 3.1.0

package/{fesm2022/signaltree-core.mjs → src/lib/signal-tree.js}

@@ -1,568 +1,10 @@
-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;
-}
-
+import { computed, DestroyRef, effect, inject, isSignal, signal } from '@angular/core';
+import { resolveEnhancerOrder } from '../enhancers';
+import { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './constants';
+import { SignalMemoryManager } from './memory/memory-manager';
+import { OptimizedUpdateEngine } from './performance/update-engine';
+import { SecurityValidator } from './security/security-validator';
+import { createLazySignalTree, equal, isBuiltInObject, unwrap } from './utils';
 const NODE_ACCESSOR_SYMBOL = Symbol.for('NodeAccessor');
 function makeNodeAccessor() {
     const accessor = function (arg) {
@@ -634,7 +76,7 @@ function recursiveUpdate(target, updates) {
         }
     }
 }
-function isNodeAccessor(value) {
+export function isNodeAccessor(value) {
     return (typeof value === 'function' &&
         value &&
         value[NODE_ACCESSOR_SYMBOL] === true);
@@ -680,6 +122,56 @@ function shouldUseLazy(obj, config, precomputedSize) {
     const estimatedSize = precomputedSize ?? estimateObjectSize(obj);
     return estimatedSize > SIGNAL_TREE_CONSTANTS.LAZY_THRESHOLD;
 }
+function validateTree(obj, config, path = []) {
+    if (!config.security) {
+        return;
+    }
+    const validator = new SecurityValidator(config.security);
+    function validate(value, currentPath) {
+        if (value === null || value === undefined) {
+            return;
+        }
+        if (typeof value !== 'object') {
+            validator.validateValue(value);
+            return;
+        }
+        if (isBuiltInObject(value)) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+                validate(item, [...currentPath, String(index)]);
+            });
+            return;
+        }
+        const keys = [
+            ...Object.keys(value),
+            ...Object.getOwnPropertyNames(value),
+        ];
+        const uniqueKeys = [...new Set(keys)];
+        for (const key of uniqueKeys) {
+            if (typeof key === 'symbol')
+                continue;
+            try {
+                validator.validateKey(key);
+            }
+            catch (error) {
+                const err = error;
+                throw new Error(`${err.message}\nPath: ${[...currentPath, key].join('.')}`);
+            }
+            const val = value[key];
+            try {
+                validator.validateValue(val);
+            }
+            catch (error) {
+                const err = error;
+                throw new Error(`${err.message}\nPath: ${[...currentPath, key].join('.')}`);
+            }
+            validate(val, [...currentPath, key]);
+        }
+    }
+    validate(obj, path);
+}
 function createEqualityFn(useShallowComparison) {
     return useShallowComparison ? Object.is : equal;
 }
@@ -922,7 +414,7 @@ function addStubMethods(tree, config) {
                 if (!isDestroyed) {
                     fn(tree());
                 }
-            }, ...(ngDevMode ? [{ debugName: "effectRef" }] : []));
+            });
             const unsubscribe = () => {
                 isDestroyed = true;
                 effectRef.destroy();
@@ -955,6 +447,27 @@ function addStubMethods(tree, config) {
         }
         return 0;
     };
+    const treeWithEngine = tree;
+    if (!treeWithEngine.updateEngine) {
+        treeWithEngine.updateEngine = new OptimizedUpdateEngine(tree);
+    }
+    tree.updateOptimized = (updates, options = {}) => {
+        const treeWithEngine = tree;
+        const engine = treeWithEngine.updateEngine;
+        if (!engine) {
+            if (config.debugMode) {
+                console.warn(SIGNAL_TREE_MESSAGES.UPDATE_OPTIMIZED_NOT_AVAILABLE);
+            }
+            tree((current) => ({ ...current, ...updates }));
+            return {
+                changed: true,
+                duration: 0,
+                changedPaths: Object.keys(updates),
+                stats: undefined,
+            };
+        }
+        return engine.update(tree(), updates, options);
+    };
     tree.getMetrics = () => {
         return {
             updates: 0,
@@ -1016,6 +529,7 @@ function create(obj, config = {}) {
     if (obj === null || obj === undefined) {
         throw new Error(SIGNAL_TREE_MESSAGES.NULL_OR_UNDEFINED);
     }
+    validateTree(obj, config);
     const estimatedSize = estimateObjectSize(obj);
     const equalityFn = createEqualityFn(config.useShallowComparison ?? false);
     if (Array.isArray(obj)) {
@@ -1036,9 +550,11 @@ function create(obj, config = {}) {
         console.log(SIGNAL_TREE_MESSAGES.STRATEGY_SELECTION.replace('%s', useLazy ? 'lazy' : 'eager').replace('%d', String(estimatedSize)));
     }
     let signalState;
+    let memoryManager;
     try {
         if (useLazy && typeof obj === 'object') {
-            signalState = createLazySignalTree(obj, equalityFn);
+            memoryManager = new SignalMemoryManager();
+            signalState = createLazySignalTree(obj, equalityFn, '', memoryManager);
         }
         else {
             signalState = createSignalStore(obj, equalityFn);
@@ -1048,6 +564,7 @@ function create(obj, config = {}) {
         if (useLazy) {
             console.warn(SIGNAL_TREE_MESSAGES.LAZY_FALLBACK, error);
             signalState = createSignalStore(obj, equalityFn);
+            memoryManager = undefined;
         }
         else {
             throw error;
@@ -1076,6 +593,19 @@ function create(obj, config = {}) {
         enumerable: false,
     });
     Object.defineProperty(tree, '$', { value: signalState, enumerable: false });
+    if (memoryManager) {
+        Object.defineProperty(tree, 'dispose', {
+            value: () => {
+                memoryManager?.dispose();
+                const cleanup = signalState.__cleanup__;
+                if (typeof cleanup === 'function') {
+                    cleanup();
+                }
+            },
+            enumerable: false,
+            writable: false,
+        });
+    }
     enhanceTree(tree, config);
     for (const key in signalState) {
         if (Object.prototype.hasOwnProperty.call(signalState, key)) {
@@ -1118,7 +648,7 @@ const presetConfigs = {
         debugMode: false,
     },
 };
-function signalTree(obj, configOrPreset) {
+export function signalTree(obj, configOrPreset) {
     if (typeof configOrPreset === 'string') {
         const config = presetConfigs[configOrPreset];
         if (!config) {
@@ -1130,9 +660,6 @@ function signalTree(obj, configOrPreset) {
     const config = configOrPreset || {};
     return create(obj, config);
 }
-function applyEnhancer(tree, enhancer) {
+export 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