@signaltree/core 4.0.15 → 4.1.0

package/dist/enhancers/time-travel/lib/time-travel.js

@@ -1,192 +1,193 @@
-import { deepClone, deepEqual } from './utils';
+import { deepClone } from '../../../deep-clone.js';
+import { deepEqual } from '../../../deep-equal.js';
+
 class TimeTravelManager {
-    tree;
-    config;
-    restoreStateFn;
-    history = [];
-    currentIndex = -1;
-    maxHistorySize;
-    includePayload;
-    actionNames;
-    constructor(tree, config = {}, restoreStateFn) {
-        this.tree = tree;
-        this.config = config;
-        this.restoreStateFn = restoreStateFn;
-        this.maxHistorySize = config.maxHistorySize ?? 50;
-        this.includePayload = config.includePayload ?? true;
-        this.actionNames = {
-            update: 'UPDATE',
-            set: 'SET',
-            batch: 'BATCH',
-            ...config.actionNames,
-        };
-        this.addEntry('INIT', this.tree());
-    }
-    addEntry(action, state, payload) {
-        if (this.currentIndex < this.history.length - 1) {
-            this.history = this.history.slice(0, this.currentIndex + 1);
-        }
-        const entry = {
-            state: deepClone(state),
-            timestamp: Date.now(),
-            action: this.actionNames[action] || action,
-            ...(this.includePayload && payload !== undefined && { payload }),
-        };
-        this.history.push(entry);
-        this.currentIndex = this.history.length - 1;
-        if (this.history.length > this.maxHistorySize) {
-            this.history.shift();
-            this.currentIndex--;
-        }
-    }
-    undo() {
-        if (!this.canUndo()) {
-            return false;
-        }
-        this.currentIndex--;
-        const entry = this.history[this.currentIndex];
-        this.restoreState(entry.state);
-        return true;
-    }
-    redo() {
-        if (!this.canRedo()) {
-            return false;
-        }
-        this.currentIndex++;
-        const entry = this.history[this.currentIndex];
-        this.restoreState(entry.state);
-        return true;
-    }
-    getHistory() {
-        return this.history.map((entry) => ({
-            ...entry,
-            state: deepClone(entry.state),
-        }));
-    }
-    resetHistory() {
-        const currentState = this.tree();
-        this.history = [];
-        this.currentIndex = -1;
-        this.addEntry('RESET', currentState);
+  tree;
+  config;
+  restoreStateFn;
+  history = [];
+  currentIndex = -1;
+  maxHistorySize;
+  includePayload;
+  actionNames;
+  constructor(tree, config = {}, restoreStateFn) {
+    this.tree = tree;
+    this.config = config;
+    this.restoreStateFn = restoreStateFn;
+    this.maxHistorySize = config.maxHistorySize ?? 50;
+    this.includePayload = config.includePayload ?? true;
+    this.actionNames = {
+      update: 'UPDATE',
+      set: 'SET',
+      batch: 'BATCH',
+      ...config.actionNames
+    };
+    this.addEntry('INIT', this.tree());
+  }
+  addEntry(action, state, payload) {
+    if (this.currentIndex < this.history.length - 1) {
+      this.history = this.history.slice(0, this.currentIndex + 1);
     }
-    jumpTo(index) {
-        if (index < 0 || index >= this.history.length) {
-            return false;
-        }
-        this.currentIndex = index;
-        const entry = this.history[index];
-        this.restoreState(entry.state);
-        return true;
+    const entry = {
+      state: deepClone(state),
+      timestamp: Date.now(),
+      action: this.actionNames[action] || action,
+      ...(this.includePayload && payload !== undefined && {
+        payload
+      })
+    };
+    this.history.push(entry);
+    this.currentIndex = this.history.length - 1;
+    if (this.history.length > this.maxHistorySize) {
+      this.history.shift();
+      this.currentIndex--;
     }
-    getCurrentIndex() {
-        return this.currentIndex;
+  }
+  undo() {
+    if (!this.canUndo()) {
+      return false;
     }
-    canUndo() {
-        return this.currentIndex > 0;
+    this.currentIndex--;
+    const entry = this.history[this.currentIndex];
+    this.restoreState(entry.state);
+    return true;
+  }
+  redo() {
+    if (!this.canRedo()) {
+      return false;
     }
-    canRedo() {
-        return this.currentIndex < this.history.length - 1;
+    this.currentIndex++;
+    const entry = this.history[this.currentIndex];
+    this.restoreState(entry.state);
+    return true;
+  }
+  getHistory() {
+    return this.history.map(entry => ({
+      ...entry,
+      state: deepClone(entry.state)
+    }));
+  }
+  resetHistory() {
+    const currentState = this.tree();
+    this.history = [];
+    this.currentIndex = -1;
+    this.addEntry('RESET', currentState);
+  }
+  jumpTo(index) {
+    if (index < 0 || index >= this.history.length) {
+      return false;
     }
-    restoreState(state) {
-        if (this.restoreStateFn) {
-            this.restoreStateFn(state);
-        }
-        else {
-            this.tree(state);
-        }
+    this.currentIndex = index;
+    const entry = this.history[index];
+    this.restoreState(entry.state);
+    return true;
+  }
+  getCurrentIndex() {
+    return this.currentIndex;
+  }
+  canUndo() {
+    return this.currentIndex > 0;
+  }
+  canRedo() {
+    return this.currentIndex < this.history.length - 1;
+  }
+  restoreState(state) {
+    if (this.restoreStateFn) {
+      this.restoreStateFn(state);
+    } else {
+      this.tree(state);
     }
+  }
 }
-export function withTimeTravel(config = {}) {
-    return (tree) => {
-        const originalTreeCall = tree.bind(tree);
-        let isRestoring = false;
-        const timeTravelManager = new TimeTravelManager(tree, config, (state) => {
-            isRestoring = true;
-            try {
-                originalTreeCall(state);
-            }
-            finally {
-                isRestoring = false;
+function withTimeTravel(config = {}) {
+  return tree => {
+    const originalTreeCall = tree.bind(tree);
+    let isRestoring = false;
+    const timeTravelManager = new TimeTravelManager(tree, config, state => {
+      isRestoring = true;
+      try {
+        originalTreeCall(state);
+      } finally {
+        isRestoring = false;
+      }
+    });
+    const enhancedTree = function (...args) {
+      if (args.length === 0) {
+        return originalTreeCall();
+      } else {
+        if (isRestoring) {
+          if (args.length === 1) {
+            const arg = args[0];
+            if (typeof arg === 'function') {
+              return originalTreeCall(arg);
+            } else {
+              return originalTreeCall(arg);
             }
-        });
-        const enhancedTree = function (...args) {
-            if (args.length === 0) {
-                return originalTreeCall();
-            }
-            else {
-                if (isRestoring) {
-                    if (args.length === 1) {
-                        const arg = args[0];
-                        if (typeof arg === 'function') {
-                            return originalTreeCall(arg);
-                        }
-                        else {
-                            return originalTreeCall(arg);
-                        }
-                    }
-                    return;
-                }
-                const beforeState = originalTreeCall();
-                let result;
-                if (args.length === 1) {
-                    const arg = args[0];
-                    if (typeof arg === 'function') {
-                        result = originalTreeCall(arg);
-                    }
-                    else {
-                        result = originalTreeCall(arg);
-                    }
-                }
-                const afterState = originalTreeCall();
-                const statesEqual = deepEqual(beforeState, afterState);
-                if (!statesEqual) {
-                    timeTravelManager.addEntry('update', afterState);
-                }
-                return result;
-            }
-        };
-        Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
-        Object.assign(enhancedTree, tree);
-        if ('state' in tree) {
-            Object.defineProperty(enhancedTree, 'state', {
-                value: tree.state,
-                enumerable: false,
-                configurable: true,
-            });
+          }
+          return;
+        }
+        const beforeState = originalTreeCall();
+        let result;
+        if (args.length === 1) {
+          const arg = args[0];
+          if (typeof arg === 'function') {
+            result = originalTreeCall(arg);
+          } else {
+            result = originalTreeCall(arg);
+          }
         }
-        if ('$' in tree) {
-            Object.defineProperty(enhancedTree, '$', {
-                value: tree['$'],
-                enumerable: false,
-                configurable: true,
-            });
+        const afterState = originalTreeCall();
+        const statesEqual = deepEqual(beforeState, afterState);
+        if (!statesEqual) {
+          timeTravelManager.addEntry('update', afterState);
         }
-        enhancedTree.undo = () => {
-            timeTravelManager.undo();
-        };
-        enhancedTree.redo = () => {
-            timeTravelManager.redo();
-        };
-        enhancedTree.getHistory = () => timeTravelManager.getHistory();
-        enhancedTree.resetHistory =
-            () => {
-                timeTravelManager.resetHistory();
-            };
-        enhancedTree.jumpTo = (index) => {
-            timeTravelManager.jumpTo(index);
-        };
-        enhancedTree.canUndo = () => timeTravelManager.canUndo();
-        enhancedTree.canRedo = () => timeTravelManager.canRedo();
-        enhancedTree.getCurrentIndex =
-            () => timeTravelManager.getCurrentIndex();
-        return Object.assign(enhancedTree, {
-            __timeTravel: timeTravelManager,
-        });
+        return result;
+      }
+    };
+    Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
+    Object.assign(enhancedTree, tree);
+    if ('state' in tree) {
+      Object.defineProperty(enhancedTree, 'state', {
+        value: tree.state,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    if ('$' in tree) {
+      Object.defineProperty(enhancedTree, '$', {
+        value: tree['$'],
+        enumerable: false,
+        configurable: true
+      });
+    }
+    enhancedTree.undo = () => {
+      timeTravelManager.undo();
+    };
+    enhancedTree.redo = () => {
+      timeTravelManager.redo();
+    };
+    enhancedTree.getHistory = () => timeTravelManager.getHistory();
+    enhancedTree.resetHistory = () => {
+      timeTravelManager.resetHistory();
+    };
+    enhancedTree.jumpTo = index => {
+      timeTravelManager.jumpTo(index);
     };
+    enhancedTree.canUndo = () => timeTravelManager.canUndo();
+    enhancedTree.canRedo = () => timeTravelManager.canRedo();
+    enhancedTree.getCurrentIndex = () => timeTravelManager.getCurrentIndex();
+    return Object.assign(enhancedTree, {
+      __timeTravel: timeTravelManager
+    });
+  };
 }
-export function enableTimeTravel(maxHistorySize) {
-    return withTimeTravel({ maxHistorySize });
+function enableTimeTravel(maxHistorySize) {
+  return withTimeTravel({
+    maxHistorySize
+  });
 }
-export function getTimeTravel(tree) {
-    return tree.__timeTravel;
+function getTimeTravel(tree) {
+  return tree.__timeTravel;
 }
+
+export { enableTimeTravel, getTimeTravel, withTimeTravel };

package/dist/index.d.ts

@@ -1,17 +1 @@
-export { signalTree } from './lib/signal-tree';
-export type { SignalTree, TreeNode, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, Middleware, PerformanceMetrics, EntityHelpers, AsyncActionConfig, AsyncAction, TimeTravelEntry, } from './lib/types';
-export { equal, deepEqual, isNodeAccessor, isAnySignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
-export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';
-export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
-export { ENHANCER_META } from './lib/types';
-export { withBatching, withHighPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/lib/batching';
-export { withMemoization, withSelectorMemoization, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withShallowMemoization, memoize, memoizeShallow, memoizeReference, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/lib/memoization';
-export { withTimeTravel, enableTimeTravel, getTimeTravel, type TimeTravelInterface, } from './enhancers/time-travel/lib/time-travel';
-export { withEntities, enableEntities, withHighPerformanceEntities, } from './enhancers/entities/lib/entities';
-export { withSerialization, enableSerialization, withPersistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/lib/serialization';
-export { withDevTools, enableDevTools, withFullDevTools, withProductionDevTools, } from './enhancers/devtools/lib/devtools';
-export { withMiddleware, createLoggingMiddleware, createValidationMiddleware, } from './enhancers/middleware/lib/middleware';
-export { createAsyncOperation, trackAsync, } from './enhancers/middleware/lib/async-helpers';
-export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
-export { computedEnhancer, createComputed, type ComputedConfig, type ComputedSignal, type ComputedSignalTree, } from './enhancers/computed/lib/computed';
-export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';
+export * from "./src/index";

package/dist/index.js

@@ -1,16 +1,19 @@
-export { signalTree } from './lib/signal-tree';
-export { equal, deepEqual, isNodeAccessor, isAnySignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
-export { SecurityValidator, SecurityPresets, } from './lib/security/security-validator';
-export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
-export { ENHANCER_META } from './lib/types';
-export { withBatching, withHighPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/lib/batching';
-export { withMemoization, withSelectorMemoization, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withShallowMemoization, memoize, memoizeShallow, memoizeReference, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/lib/memoization';
-export { withTimeTravel, enableTimeTravel, getTimeTravel, } from './enhancers/time-travel/lib/time-travel';
-export { withEntities, enableEntities, withHighPerformanceEntities, } from './enhancers/entities/lib/entities';
-export { withSerialization, enableSerialization, withPersistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/lib/serialization';
-export { withDevTools, enableDevTools, withFullDevTools, withProductionDevTools, } from './enhancers/devtools/lib/devtools';
-export { withMiddleware, createLoggingMiddleware, createValidationMiddleware, } from './enhancers/middleware/lib/middleware';
-export { createAsyncOperation, trackAsync, } from './enhancers/middleware/lib/async-helpers';
-export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
-export { computedEnhancer, createComputed, } from './enhancers/computed/lib/computed';
-export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';
+export { signalTree } from './lib/signal-tree.js';
+export { composeEnhancers, createLazySignalTree, isAnySignal, isNodeAccessor, toWritableSignal } from './lib/utils.js';
+export { SecurityPresets, SecurityValidator } from './lib/security/security-validator.js';
+export { createEnhancer, resolveEnhancerOrder } from './enhancers/index.js';
+export { ENHANCER_META } from './lib/types.js';
+export { flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, withBatching, withHighPerformanceBatching } from './enhancers/batching/lib/batching.js';
+export { cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, memoize, memoizeReference, memoizeShallow, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withMemoization, withSelectorMemoization, withShallowMemoization } from './enhancers/memoization/lib/memoization.js';
+export { enableTimeTravel, getTimeTravel, withTimeTravel } from './enhancers/time-travel/lib/time-travel.js';
+export { enableEntities, withEntities, withHighPerformanceEntities } from './enhancers/entities/lib/entities.js';
+export { applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, withPersistence, withSerialization } from './enhancers/serialization/lib/serialization.js';
+export { enableDevTools, withDevTools, withFullDevTools, withProductionDevTools } from './enhancers/devtools/lib/devtools.js';
+export { createLoggingMiddleware, createValidationMiddleware, withMiddleware } from './enhancers/middleware/lib/middleware.js';
+export { createAsyncOperation, trackAsync } from './enhancers/middleware/lib/async-helpers.js';
+export { TREE_PRESETS, combinePresets, createDevTree, createPresetConfig, getAvailablePresets, validatePreset } from './enhancers/presets/lib/presets.js';
+export { computedEnhancer, createComputed } from './enhancers/computed/lib/computed.js';
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants.js';
+export { deepEqual, deepEqual as equal } from './deep-equal.js';
+export { parsePath } from './parse-path.js';
+export { isBuiltInObject } from './is-built-in-object.js';

package/dist/is-built-in-object.js

@@ -0,0 +1,23 @@
+function isBuiltInObject(value) {
+  if (value === null || value === undefined) return false;
+  if (value instanceof Date || value instanceof RegExp || typeof value === 'function' || value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet || value instanceof ArrayBuffer || value instanceof DataView || value instanceof Error || value instanceof Promise) {
+    return true;
+  }
+  if (value instanceof Int8Array || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int16Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Float64Array || value instanceof BigInt64Array || value instanceof BigUint64Array) {
+    return true;
+  }
+  if (typeof window !== 'undefined') {
+    if (value instanceof URL || value instanceof URLSearchParams || value instanceof FormData || value instanceof Blob || typeof File !== 'undefined' && value instanceof File || typeof FileList !== 'undefined' && value instanceof FileList || typeof Headers !== 'undefined' && value instanceof Headers || typeof Request !== 'undefined' && value instanceof Request || typeof Response !== 'undefined' && value instanceof Response || typeof AbortController !== 'undefined' && value instanceof AbortController || typeof AbortSignal !== 'undefined' && value instanceof AbortSignal) {
+      return true;
+    }
+  }
+  try {
+    const NodeBuffer = globalThis === null || globalThis === void 0 ? void 0 : globalThis.Buffer;
+    if (NodeBuffer && value instanceof NodeBuffer) {
+      return true;
+    }
+  } catch (_a) {}
+  return false;
+}
+
+export { isBuiltInObject };

package/dist/lib/constants.js

@@ -1,61 +1,57 @@
-import { DEFAULT_PATH_CACHE_SIZE } from '@signaltree/shared';
-export const SIGNAL_TREE_CONSTANTS = {
-    MAX_PATH_CACHE_SIZE: DEFAULT_PATH_CACHE_SIZE,
-    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,
+import { DEFAULT_PATH_CACHE_SIZE } from '../constants.js';
+
+const SIGNAL_TREE_CONSTANTS = {
+  MAX_PATH_CACHE_SIZE: DEFAULT_PATH_CACHE_SIZE,
+  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',
-    UPDATE_OPTIMIZED_NOT_AVAILABLE: 'update optimized 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',
+  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',
+  UPDATE_OPTIMIZED_NOT_AVAILABLE: 'update optimized 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 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 _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;
-export const SIGNAL_TREE_MESSAGES = Object.freeze(_isDev
-    ? DEV_MESSAGES
-    : PROD_MESSAGES);
+const SIGNAL_TREE_MESSAGES = Object.freeze(_isDev ? DEV_MESSAGES : PROD_MESSAGES);
+
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES };