@signaltree/core 9.0.0 → 9.1.0

package/README.md

@@ -118,7 +118,7 @@ Performance and bundle size vary by app shape, build tooling, device, and runtim
 
 ## Best Practices (SignalTree-First)
 
-> 📖 **Full guide**: [Implementation Patterns](https://github.com/JBorgia/signaltree/blob/main/docs/IMPLEMENTATION_PATTERNS.md)
+> 📖 **Production app structure**: For anything beyond a single-component prototype, follow the [Recommended Default Architecture](https://github.com/JBorgia/signaltree/blob/main/docs/architecture/signaltree-architecture-guide.md#recommended-default-architecture) — it wraps the patterns below in an `AppStore` facade with a `$ + ops` split, derived tiers, and an ESLint guard against direct tree mutation from components/services. The snippets in this README are deliberately minimal and use the low-level core API directly so they stay self-contained; in real apps the mutations shown here belong inside `*Ops` classes.
 
 Follow these principles for idiomatic SignalTree code:
 
@@ -416,17 +416,18 @@ effect(() => {
 // Best Practices:
 // 1. Use computed() for derived state that depends on signals
 // 2. Keep computations pure - no side effects
-// 3. Leverage automatic memoization for expensive operations
+// 3. Angular's computed() automatically caches results
 // 4. Chain computed values for complex transformations
 // 5. Use factory functions for parameterized computations
 ```
 
-### Performance optimization with memoization
+### Performance optimization with computed()
 
-Computed values become even more powerful with the built-in memoization enhancer:
+Angular's built-in `computed()` provides automatic memoization — a result is cached until one of the signals it reads from changes. No additional enhancer is required:
 
 ```typescript
-import { signalTree, memoization } from '@signaltree/core';
+import { computed } from '@angular/core';
+import { signalTree } from '@signaltree/core';
 
 const tree = signalTree({
   items: Array.from({ length: 10000 }, (_, i) => ({
@@ -434,9 +435,9 @@ const tree = signalTree({
     value: Math.random(),
     category: `cat-${i % 10}`,
   })),
-}).with(memoization());
+});
 
-// Expensive computation - automatically cached by memoization enhancer
+// Expensive computation - automatically cached by Angular's computed()
 const expensiveComputation = computed(() => {
   return tree.$.items()
     .filter((item) => item.value > 0.5)
@@ -444,9 +445,11 @@ const expensiveComputation = computed(() => {
 });
 
 // The computation only runs when tree.$.items() actually changes
-// Subsequent calls return cached result
+// Subsequent calls return the cached result
 ```
 
+> **9.0.1 note:** The `memoization()` enhancer was removed. Angular's `computed()` already memoizes; the enhancer added no value on top of it.
+
 ### Advanced usage (full state tree)
 
 ```typescript
@@ -644,9 +647,8 @@ All enhancers are exported directly from `@signaltree/core`:
 **Performance Enhancers:**
 
 - `batching()` - Batch updates to reduce recomputation and rendering
-- `memoization()` - Intelligent caching for expensive computations
-- `highPerformanceBatching()` - Advanced batching for high-frequency updates
-- `withHighPerformanceMemoization()` - Optimized memoization for large state trees
+
+> **9.0.1 note:** The `memoization()` enhancer and all preset variants were removed. Use Angular's built-in `computed()` — it provides equivalent memoization with zero additional runtime cost.
 
 **Data Management:**
 
@@ -661,11 +663,6 @@ All enhancers are exported directly from `@signaltree/core`:
 - `devTools()` - Redux DevTools auto-connect, path actions, and time-travel dispatch
 - `withTimeTravel()` - Undo/redo functionality
 
-**Presets:**
-
-- `createDevTree()` - Pre-configured development setup
-- `TREE_PRESETS` - Common configuration patterns
-
 #### Additional Packages
 
 These are the **only** separate packages in the SignalTree ecosystem:
@@ -691,7 +688,7 @@ const tree = signalTree({ count: 0 }).with(
 **Performance-Focused Stack:**
 
 ```typescript
-import { signalTree, batching, memoization, entities } from '@signaltree/core';
+import { signalTree, batching, entities } from '@signaltree/core';
 
 const tree = signalTree({
   products: entityMap<Product>(),
@@ -756,27 +753,9 @@ Enhancers can declare metadata for automatic dependency resolution:
 // Enhancers are automatically ordered based on requirements
 const tree = signalTree(state).with(
   devTools(), // Requires: core, provides: debugging
-  batching(), // Requires: core, provides: batching
-  memoization() // Requires: batching, provides: caching
+  batching() // Requires: core, provides: batching
 );
-// Automatically ordered: batching -> memoization -> devtools
-```
-
-#### Quick Start with Presets
-
-For common patterns, use presets that combine multiple enhancers:
-
-```typescript
-import { createDevTree, TREE_PRESETS } from '@signaltree/core';
-
-// Development preset includes: batching, memoization, devtools, time-travel
-const devTree = createDevTree({
-  products: [] as Product[],
-  cart: { items: [], total: 0 },
-});
-
-// Or use preset configurations
-const customTree = signalTree(state, TREE_PRESETS.DASHBOARD);
+// Automatically ordered: batching -> devtools
 ```
 
 #### Core Stubs
@@ -1548,15 +1527,14 @@ tree.effect(() => console.log('State changed'));
 ### Performance-Enhanced Composition
 
 ```typescript
-import { signalTree, batching, memoization } from '@signaltree/core';
+import { signalTree, batching } from '@signaltree/core';
 
 // Add performance optimizations
 const tree = signalTree({
   products: [] as Product[],
   filters: { category: '', search: '' },
 }).with(
-  batching(), // Batch updates for optimal rendering
-  memoization() // Cache expensive computations
+  batching() // Batch updates for optimal rendering
 );
 
 // Now supports batched updates
@@ -1565,7 +1543,7 @@ tree.batchUpdate((state) => ({
   filters: { category: 'electronics', search: '' },
 }));
 
-// Expensive computations are automatically cached
+// Angular's computed() automatically caches derived values
 const filteredProducts = computed(() => {
   return tree.$.products()
     .filter((p) => p.category.includes(tree.$.filters.category()))
@@ -1671,7 +1649,8 @@ tree.save(); // Persistence
 ```
 
 ### Aggregated Redux DevTools Instance
-~~~~
+
+````
 When using multiple independent trees (e.g. per lazy-loaded feature module), each `devTools()` call creates a separate Redux DevTools instance by default. Use `aggregatedReduxInstance` to group multiple trees under a **single Redux DevTools instance**:
 
 ```typescript
@@ -1770,21 +1749,21 @@ const tree = signalTree(state).with(
 ### Preset-Based Composition
 
 ```typescript
-import { createDevTree, TREE_PRESETS } from '@signaltree/core';
+import { signalTree, batching, devTools, withTimeTravel } from '@signaltree/core';
 
-// Use presets for common patterns
-const devTree = createDevTree({
+// Compose the enhancers you actually need
+const devTree = signalTree({
   products: [],
   cart: { items: [], total: 0 },
   user: null,
-});
-// Includes: batching, memoization, devtools, time-travel
-
-// Or use preset configurations directly
-const customTree = signalTree(state, TREE_PRESETS.PERFORMANCE);
-// Includes: batching, memoization optimizations
+})
+  .with(batching())
+  .with(devTools())
+  .with(withTimeTravel());
 ```
 
+> **9.0.1 note:** Preset factories (`createDevTree`, `TREE_PRESETS`, etc.) were removed. Compose enhancers directly with `.with()`.
+
 ### Measuring bundle size
 
 Bundle sizes depend on your build, tree-shaking, and which enhancers you include. Use the scripts in `scripts/` to analyze min+gz for your configuration.
@@ -1818,7 +1797,7 @@ if (isDevelopment) {
 }
 
 if (needsPerformance) {
-  tree = tree.with(batching(), memoization());
+  tree = tree.with(batching());
 }
 
 if (needsTimeTravel) {
@@ -2085,6 +2064,7 @@ tree.unwrap(); // Get plain object
 
 // Tree operations
 tree.update(updater); // Update entire tree
+tree.updateAndReport(updater); // Update + return changed leaf paths (9.1+)
 tree.effect(fn); // Create reactive effects
 tree.subscribe(fn); // Manual subscriptions
 tree.destroy(); // Cleanup resources
@@ -2096,15 +2076,35 @@ tree.destroy(); // Cleanup resources
 // tree.$.users.selectBy(pred);  // Filtered signal
 ```
 
+### updateAndReport (9.1+)
+
+Like `update`, but returns the dot-paths of every leaf signal whose value
+actually changed. Useful for diff logging, audit trails, optimistic-update
+rollback, and selective re-syncing to a server.
+
+```typescript
+const tree = signalTree({ user: { name: 'Ada', age: 36 }, count: 0 });
+
+const changed = tree.updateAndReport({
+  user: { name: 'Ada', age: 37 }, // age changes, name is ref-equal
+  count: 0, // ref-equal, skipped
+});
+// changed === ['user.age']
+```
+
+Reference-equal values are skipped automatically by the underlying
+`update` path, so passing a server-returned partial that mostly matches
+local state is cheap (`O(changed)` instead of `O(N)`).
+
 ## Extending with enhancers
 
 SignalTree Core includes all enhancers built-in:
 
 ```typescript
-import { signalTree, batching, memoization, withTimeTravel } from '@signaltree/core';
+import { signalTree, batching, withTimeTravel } from '@signaltree/core';
 
 // All enhancers available from @signaltree/core
-const tree = signalTree(initialState).with(batching(), memoization(), withTimeTravel());
+const tree = signalTree(initialState).with(batching(), withTimeTravel());
 ```
 
 ### Available enhancers
@@ -2112,13 +2112,10 @@ const tree = signalTree(initialState).with(batching(), memoization(), withTimeTr
 All enhancers are included in `@signaltree/core`:
 
 - **batching()** - Batch multiple updates for better performance
-- **memoization()** - Intelligent caching & performance optimization
 - **entities()** - Advanced entity management & CRUD operations
 - **devTools()** - Redux DevTools integration for debugging
 - **withTimeTravel()** - Undo/redo functionality & state history
 - **serialization()** - State persistence & SSR support
-- **createDevTree()** - Pre-configured development setup
-- **TREE_PRESETS** - Common configuration patterns (PERFORMANCE, DASHBOARD, etc.)
 
 ## When to use core only
 
@@ -2132,7 +2129,7 @@ Perfect for:
 
 Consider enhancers when you need:
 
-- ⚡ Performance optimization (batching, memoization)
+- ⚡ Performance optimization (batching)
 - 🐛 Advanced debugging (devTools, withTimeTravel)
 - 📦 Entity management (entities)
 
@@ -2144,6 +2141,21 @@ Consider separate packages when you need:
 
 ## Migration from NgRx
 
+### Case Study
+
+Measured from a production Angular mobile application migrating from NgRx Signal Store to SignalTree. Results reflect one team's experience; your mileage will vary depending on app complexity and existing architecture.
+
+| Metric | NgRx | SignalTree | Change |
+| --- | --- | --- | --- |
+| **App state code** | 11,735 lines / 45 files | 2,825 lines / 23 files | **-76%** |
+| **npm packages** | 4 (@ngrx/\*) | 1 (@signaltree/core) | **-75%** |
+| **State bundle (gzip)** | ~50KB | ~27KB | **-46%** |
+| **Boilerplate files** | 17 custom `withX` helpers | 0 (built-in) | **Eliminated** |
+
+13 separate stores → 1 unified tree. `entityMap()` replaced a 222-line `withEntityCrud` wrapper. Derived tiers replaced scattered `withComputed` blocks.
+
+### Migration Steps
+
 ```typescript
 // Step 1: Create parallel tree
 const tree = signalTree(initialState);
@@ -2265,7 +2277,6 @@ All enhancers are now consolidated in the core package. The following features a
 ### Performance & Optimization
 
 - **batching()** (+1.27KB gzipped) - Batch multiple updates for better performance
-- **memoization()** (+2.33KB gzipped) - Intelligent caching & performance optimization
 
 ### Advanced Features
 
@@ -2279,8 +2290,6 @@ All enhancers are now consolidated in the core package. The following features a
 ### Integration & Convenience
 
 - **serialization()** (+0.84KB gzipped) - State persistence & SSR support
-- **ecommercePreset()** - Pre-configured setups for e-commerce applications
-- **dashboardPreset()** - Pre-configured setups for dashboard applications
 
 ### Quick Start with Extensions
 
@@ -2294,13 +2303,10 @@ npm install @signaltree/core
 import {
   signalTree,
   batching,
-  memoization,
   entities,
   devTools,
   withTimeTravel,
-  serialization,
-  ecommercePreset,
-  dashboardPreset
+  serialization
 } from '@signaltree/core';
 ```
 
@@ -2626,7 +2632,7 @@ export default {
 
 **Start with just `@signaltree/core`** - it includes comprehensive enhancers for most applications:
 
-- Performance optimization (batching, memoization)
+- Performance optimization (batching)
 - Data management (entities, async operations)
 - Development tools (devtools, time-travel)
 - State persistence (serialization)
@@ -2671,3 +2677,4 @@ MIT License with AI Training Restriction - see the [LICENSE](../../LICENSE) file
 ---
 
 **Ready to get started?** This core package provides everything you need for most applications. Add extensions only when you need them! 🚀
+````

package/dist/index.js

@@ -10,7 +10,6 @@ export { composeEnhancers, isAnySignal, isNodeAccessor, toWritableSignal } from
 export { getPathNotifier } from './lib/path-notifier.js';
 export { createEnhancer, resolveEnhancerOrder } from './enhancers/index.js';
 export { batching } from './enhancers/batching/batching.js';
-export { memoization } from './enhancers/memoization/memoization.js';
 export { timeTravel } from './enhancers/time-travel/time-travel.js';
 export { persistence, serialization } from './enhancers/serialization/serialization.js';
 export { devTools } from './enhancers/devtools/devtools.js';

package/dist/lib/signal-tree.js

@@ -1,4 +1,4 @@
-import { signal, isSignal } from '@angular/core';
+import { signal, isSignal, untracked } from '@angular/core';
 import { SIGNAL_TREE_MESSAGES, SIGNAL_TREE_CONSTANTS } from './constants.js';
 import { batchScope } from './internals/batch-scope.js';
 import { isRegisteredMarker, materializeMarkers } from './internals/materialize-markers.js';
@@ -114,19 +114,25 @@ function makeNodeAccessor(store) {
   }
   return accessor;
 }
-function recursiveUpdate(target, updates) {
+function recursiveUpdate(target, updates, out, pathPrefix = '') {
   if (!updates || typeof updates !== 'object') return;
   const targetObj = isNodeAccessor(target) ? target : target;
   for (const [key, value] of Object.entries(updates)) {
     const prop = targetObj[key];
     if (prop === undefined) continue;
+    const childPath = pathPrefix ? `${pathPrefix}.${key}` : key;
     if (isSignal(prop) && 'set' in prop) {
-      prop.set(value);
+      const sig = prop;
+      const current = untracked(() => sig());
+      if (current === value) continue;
+      sig.set(value);
+      if (out) out.push(childPath);
     } else if (isNodeAccessor(prop)) {
       if (value && typeof value === 'object') {
-        recursiveUpdate(prop, value);
+        recursiveUpdate(prop, value, out, childPath);
       } else {
         prop(value);
+        if (out) out.push(childPath);
       }
     }
   }
@@ -333,6 +339,25 @@ function create(initialState, config) {
     writable: true,
     configurable: true
   });
+  Object.defineProperty(tree, 'updateAndReport', {
+    value: function (arg) {
+      if (arguments.length === 0) return [];
+      const out = [];
+      if (typeof arg === 'function') {
+        const updater = arg;
+        const current = unwrap(signalState);
+        batchScope(() => recursiveUpdate(signalState, updater(current), out));
+      } else if (typeof arg === 'object' && arg !== null && !Array.isArray(arg)) {
+        batchScope(() => recursiveUpdate(signalState, arg, out));
+      } else {
+        recursiveUpdate(signalState, arg, out);
+      }
+      return out;
+    },
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
   for (const key of Object.keys(signalState)) {
     if (!(key in tree)) {
       Object.defineProperty(tree, key, {
@@ -453,6 +478,26 @@ function createBuilder(baseTree) {
       configurable: true
     });
   }
+  Object.defineProperty(builder, 'updateAndReport', {
+    value: function (arg) {
+      finalize();
+      const fn = baseTree['updateAndReport'];
+      return fn ? fn.call(baseTree, arg) : [];
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  Object.defineProperty(builder, 'batchUpdate', {
+    value: function (arg) {
+      finalize();
+      const fn = baseTree['batchUpdate'];
+      if (fn) fn.call(baseTree, arg);
+    },
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
   Object.defineProperty(builder, 'derived', {
     value: function (factory) {
       if (isFinalized) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "9.0.0",
+  "version": "9.1.0",
   "description": "Reactive JSON for Angular. JSON branches, reactive leaves. No actions. No reducers. No selectors.",
   "license": "MIT",
   "type": "module",
@@ -14,11 +14,6 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./presets": {
-      "types": "./src/presets.d.ts",
-      "import": "./dist/presets.js",
-      "default": "./dist/presets.js"
-    },
     "./security": {
       "types": "./src/security.d.ts",
       "import": "./dist/security.js",

package/src/enhancers/types.d.ts

@@ -1 +1 @@
-export { BatchingMethods, BatchingConfig, MemoizationMethods, MemoizationConfig, TimeTravelMethods, TimeTravelConfig, EffectsMethods, DevToolsMethods, DevToolsConfig, EntitiesEnabled, Enhancer, EnhancerWithMeta, EnhancerMeta, } from '../lib/types';
+export { BatchingMethods, BatchingConfig, TimeTravelMethods, TimeTravelConfig, EffectsMethods, DevToolsMethods, DevToolsConfig, EntitiesEnabled, Enhancer, EnhancerWithMeta, EnhancerMeta, } from '../lib/types';

package/src/enhancers/typing/helpers-types.d.ts

@@ -1,2 +1,2 @@
-export type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+export type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
 export type Assert<T extends true> = T;

package/src/index.d.ts

@@ -1,5 +1,5 @@
 export { signalTree } from './lib/signal-tree';
-export type { ISignalTree, SignalTree, SignalTreeBase, FullSignalTree, ProdSignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, Primitive, NotFn, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, TimeTravelEntry, TimeTravelMethods, EnhancerCleanup, } from './lib/types';
+export type { ISignalTree, SignalTree, SignalTreeBase, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, Primitive, NotFn, TreeConfig, Enhancer, EnhancerMeta, EnhancerWithMeta, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, TimeTravelEntry, TimeTravelMethods, EnhancerCleanup, } from './lib/types';
 export { entityMap } from './lib/types';
 export type { ProcessDerived, DeepMergeTree, DerivedFactory, WithDerived, } from './lib/internals/derived-types';
 export { derivedFrom, externalDerived } from './lib/internals/derived-types';
@@ -15,7 +15,6 @@ export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
 export { ENHANCER_META } from './lib/types';
 export { batching } from './enhancers/batching/batching';
 export type { BatchingConfig, BatchingMethods } from './lib/types';
-export { memoization } from './enhancers/memoization/memoization';
 export { timeTravel } from './enhancers/time-travel/time-travel';
 export { serialization, persistence, } from './enhancers/serialization/serialization';
 export { devTools } from './enhancers/devtools/devtools';

package/src/lib/types.d.ts

@@ -14,13 +14,6 @@ export interface TimeTravelConfig {
         [key: string]: string | undefined;
     };
 }
-export interface MemoizationConfig {
-    enabled?: boolean;
-    maxCacheSize?: number;
-    ttl?: number;
-    enableLRU?: boolean;
-    equality?: 'deep' | 'shallow' | 'reference';
-}
 export type Primitive = string | number | boolean | null | undefined | bigint | symbol;
 export type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
 declare module '@angular/core' {
@@ -45,6 +38,7 @@ export interface ISignalTree<T> extends NodeAccessor<T> {
     destroy(): void;
     readonly destroyed: Signal<boolean>;
     registerCleanup(fn: EnhancerCleanup): void;
+    updateAndReport(updates: Partial<T> | ((current: T) => Partial<T>)): string[];
 }
 export type EnhancerCleanup = () => void;
 export interface EffectsMethods<T> {
@@ -61,20 +55,6 @@ export interface BatchingMethods<T = unknown> {
     hasPendingNotifications(): boolean;
     flushNotifications(): void;
 }
-export interface MemoizationMethods<T> {
-    memoize<R>(fn: (state: T) => R, cacheKey?: string): Signal<R>;
-    memoizedUpdate?: (updater: (current: T) => Partial<T>, cacheKey?: string) => void;
-    clearMemoCache(key?: string): void;
-    clearCache?: (key?: string) => void;
-    getCacheStats(): CacheStats;
-}
-export type CacheStats = {
-    size: number;
-    hitRate: number;
-    totalHits: number;
-    totalMisses: number;
-    keys: string[];
-};
 export interface TimeTravelMethods<T = unknown> {
     undo(): void;
     redo(): void;
@@ -125,10 +105,8 @@ export interface TimeTravelEntry<T> {
     state: T;
     payload?: unknown;
 }
-export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
 export interface TreeConfig {
     batchUpdates?: boolean;
-    useMemoization?: boolean;
     enableTimeTravel?: boolean;
     useLazySignals?: boolean;
     useShallowComparison?: boolean;
@@ -310,9 +288,6 @@ export interface EnhancerMeta {
     provides?: string[];
     description?: string;
 }
-export type FullSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods<T> & MemoizationMethods<T> & TimeTravelMethods<T> & DevToolsMethods & EntitiesEnabled & OptimizedUpdateMethods<T>;
-export type ProdSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods<T> & MemoizationMethods<T> & EntitiesEnabled & OptimizedUpdateMethods<T>;
-export type MinimalSignalTree<T> = ISignalTree<T> & EffectsMethods<T>;
 export type SignalTree<T> = ISignalTree<T> & TreeNode<T>;
 export type SignalTreeBase<T> = ISignalTree<T> & TreeNode<T>;
 export declare function isSignalTree<T>(value: unknown): value is ISignalTree<T>;

package/dist/enhancers/effects/effects.js

@@ -1,74 +0,0 @@
-import { effect, untracked } from '@angular/core';
-import { ENHANCER_META } from '../../lib/types.js';
-
-function effects(config = {}) {
-  const {
-    enabled = true
-  } = config;
-  const enhancerFn = tree => {
-    const cleanupFns = [];
-    const methods = {
-      effect(effectFn) {
-        if (!enabled) {
-          return () => {};
-        }
-        let innerCleanup;
-        const effectRef = effect(() => {
-          const state = tree();
-          if (innerCleanup) {
-            untracked(() => innerCleanup());
-          }
-          innerCleanup = untracked(() => effectFn(state));
-        });
-        const cleanup = () => {
-          if (innerCleanup) {
-            innerCleanup();
-          }
-          effectRef.destroy();
-        };
-        cleanupFns.push(cleanup);
-        return cleanup;
-      },
-      subscribe(fn) {
-        if (!enabled) {
-          return () => {};
-        }
-        const effectRef = effect(() => {
-          const state = tree();
-          untracked(() => fn(state));
-        });
-        const cleanup = () => {
-          effectRef.destroy();
-        };
-        cleanupFns.push(cleanup);
-        return cleanup;
-      }
-    };
-    const originalDestroy = tree.destroy?.bind(tree);
-    tree.destroy = () => {
-      cleanupFns.forEach(fn => fn());
-      cleanupFns.length = 0;
-      if (originalDestroy) {
-        originalDestroy();
-      }
-    };
-    return Object.assign(tree, methods);
-  };
-  const meta = {
-    name: 'effects',
-    provides: ['effects']
-  };
-  enhancerFn.metadata = meta;
-  enhancerFn[ENHANCER_META] = meta;
-  return enhancerFn;
-}
-function enableEffects() {
-  return effects({
-    enabled: true
-  });
-}
-Object.assign((config = {}) => effects(config), {
-  enable: enableEffects
-});
-
-export { effects, enableEffects };

package/dist/enhancers/memoization/memoization.js

@@ -1,325 +0,0 @@
-import { computed } from '@angular/core';
-import { isNodeAccessor } from '../../lib/utils.js';
-import { ENHANCER_META } from '../../lib/types.js';
-import { LRUCache } from '../../shared/lib/lru-cache.js';
-import { deepEqual } from '../../shared/lib/deep-equal.js';
-
-function isDevMode() {
-  if (typeof __DEV__ !== 'undefined') {
-    return __DEV__;
-  }
-  return false;
-}
-const MAX_CACHE_SIZE = 1000;
-const memoizationCache = new Map();
-function createMemoCacheStore(maxSize, enableLRU) {
-  if (enableLRU) {
-    const cache = new LRUCache(maxSize);
-    const shadow = new Map();
-    const pruneShadow = () => {
-      while (shadow.size > cache.size()) {
-        const oldestKey = shadow.keys().next().value;
-        if (oldestKey === undefined) {
-          break;
-        }
-        shadow.delete(oldestKey);
-      }
-    };
-    return {
-      get: key => {
-        const value = cache.get(key);
-        if (value !== undefined) {
-          shadow.set(key, value);
-        } else if (shadow.has(key)) {
-          shadow.delete(key);
-        }
-        return value;
-      },
-      set: (key, value) => {
-        cache.set(key, value);
-        shadow.set(key, value);
-        pruneShadow();
-      },
-      delete: key => {
-        cache.delete(key);
-        shadow.delete(key);
-      },
-      clear: () => {
-        cache.clear();
-        shadow.clear();
-      },
-      size: () => shadow.size,
-      forEach: callback => {
-        shadow.forEach((value, key) => callback(value, key));
-      },
-      keys: () => shadow.keys()
-    };
-  }
-  const store = new Map();
-  return {
-    get: key => store.get(key),
-    set: (key, value) => {
-      store.set(key, value);
-    },
-    delete: key => store.delete(key),
-    clear: () => store.clear(),
-    size: () => store.size,
-    forEach: callback => {
-      store.forEach((value, key) => callback(value, key));
-    },
-    keys: () => store.keys()
-  };
-}
-function getCleanupInterval(tree) {
-  return tree._memoCleanupInterval;
-}
-function setCleanupInterval(tree, interval) {
-  if (interval === undefined) {
-    delete tree._memoCleanupInterval;
-    return;
-  }
-  tree._memoCleanupInterval = interval;
-}
-function clearCleanupInterval(tree) {
-  const interval = getCleanupInterval(tree);
-  if (!interval) {
-    return;
-  }
-  try {
-    clearInterval(interval);
-  } catch {}
-  setCleanupInterval(tree);
-}
-function shallowEqual(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  if (typeof a !== typeof b) return false;
-  if (typeof a === 'object' && typeof b === 'object') {
-    const objA = a;
-    const objB = b;
-    let countA = 0;
-    for (const key in objA) {
-      if (!Object.prototype.hasOwnProperty.call(objA, key)) continue;
-      countA++;
-      if (!(key in objB) || objA[key] !== objB[key]) return false;
-    }
-    let countB = 0;
-    for (const key in objB) {
-      if (Object.prototype.hasOwnProperty.call(objB, key)) countB++;
-    }
-    return countA === countB;
-  }
-  return false;
-}
-function generateCacheKey(fn, args) {
-  try {
-    return `${fn.name || 'anonymous'}_${JSON.stringify(args)}`;
-  } catch {
-    return `${fn.name || 'anonymous'}_${args.length}`;
-  }
-}
-function getEqualityFn(strategy) {
-  switch (strategy) {
-    case 'shallow':
-      return shallowEqual;
-    case 'reference':
-      return (a, b) => a === b;
-    case 'deep':
-    default:
-      return deepEqual;
-  }
-}
-const MEMOIZATION_PRESETS = {
-  selector: {
-    equality: 'reference',
-    maxCacheSize: 10,
-    enableLRU: false,
-    ttl: undefined
-  },
-  computed: {
-    equality: 'shallow',
-    maxCacheSize: 100,
-    enableLRU: false,
-    ttl: undefined
-  },
-  deepState: {
-    equality: 'deep',
-    maxCacheSize: 1000,
-    enableLRU: true,
-    ttl: 5 * 60 * 1000
-  },
-  highFrequency: {
-    equality: 'reference',
-    maxCacheSize: 5,
-    enableLRU: false,
-    ttl: undefined
-  }
-};
-function selectorMemoization() {
-  return memoization(MEMOIZATION_PRESETS.selector);
-}
-function computedMemoization() {
-  return memoization(MEMOIZATION_PRESETS.computed);
-}
-function deepStateMemoization() {
-  return memoization(MEMOIZATION_PRESETS.deepState);
-}
-function highFrequencyMemoization() {
-  return memoization(MEMOIZATION_PRESETS.highFrequency);
-}
-Object.assign((config = {}) => memoization(config), {
-  selector: selectorMemoization,
-  computed: computedMemoization,
-  deep: deepStateMemoization,
-  fast: highFrequencyMemoization
-});
-function memoization(config = {}) {
-  const {
-    enabled = true,
-    maxCacheSize = 1000,
-    ttl,
-    equality = 'deep',
-    enableLRU = true
-  } = config;
-  const enhancer = tree => {
-    const originalTreeCall = tree.bind(tree);
-    const applyUpdateResult = result => {
-      Object.entries(result).forEach(([propKey, value]) => {
-        const property = tree.state[propKey];
-        if (property && 'set' in property) {
-          property.set(value);
-        } else if (isNodeAccessor(property)) {
-          property(value);
-        }
-      });
-    };
-    if (!enabled) {
-      const memoTree = tree;
-      memoTree.memoize = (fn, _cacheKey) => {
-        return computed(() => fn(originalTreeCall()));
-      };
-      memoTree.memoizedUpdate = updater => {
-        const currentState = originalTreeCall();
-        const result = updater(currentState);
-        applyUpdateResult(result);
-      };
-      memoTree.clearMemoCache = () => {};
-      memoTree.clearCache = memoTree.clearMemoCache;
-      memoTree.getCacheStats = () => ({
-        size: 0,
-        hitRate: 0,
-        totalHits: 0,
-        totalMisses: 0,
-        keys: []
-      });
-      return memoTree;
-    }
-    const cache = createMemoCacheStore(maxCacheSize, enableLRU);
-    memoizationCache.set(tree, cache);
-    const equalityFn = getEqualityFn(equality);
-    tree.memoizedUpdate = (updater, cacheKey) => {
-      const currentState = originalTreeCall();
-      const key = cacheKey || generateCacheKey(updater, [currentState]);
-      const cached = cache.get(key);
-      if (cached && equalityFn(cached.deps, [currentState])) {
-        const cachedUpdate = cached.value;
-        applyUpdateResult(cachedUpdate);
-        return;
-      }
-      const result = updater(currentState);
-      cache.set(key, {
-        value: result,
-        deps: [currentState],
-        timestamp: Date.now(),
-        hitCount: 1
-      });
-      applyUpdateResult(result);
-    };
-    const memoizeResultCache = createMemoCacheStore(MAX_CACHE_SIZE, true);
-    tree.memoize = (fn, cacheKey) => {
-      return computed(() => {
-        const currentState = originalTreeCall();
-        const key = cacheKey || generateCacheKey(fn, [currentState]);
-        const cached = memoizeResultCache.get(key);
-        if (cached && equalityFn(cached.deps, [currentState])) {
-          return cached.value;
-        }
-        if (isDevMode() && tree.__devHooks?.onRecompute) {
-          try {
-            tree.__devHooks.onRecompute(key, 1);
-          } catch {}
-        }
-        const result = fn(currentState);
-        memoizeResultCache.set(key, {
-          value: result,
-          deps: [currentState],
-          timestamp: Date.now(),
-          hitCount: 1
-        });
-        return result;
-      });
-    };
-    tree.clearMemoCache = key => {
-      if (key) {
-        cache.delete(key);
-      } else {
-        cache.clear();
-      }
-    };
-    tree.clearCache = tree.clearMemoCache;
-    tree.getCacheStats = () => {
-      let totalHits = 0;
-      let totalMisses = 0;
-      cache.forEach(entry => {
-        totalHits += entry.hitCount || 0;
-        totalMisses += Math.floor((entry.hitCount || 0) / 2);
-      });
-      const hitRate = totalHits + totalMisses > 0 ? totalHits / (totalHits + totalMisses) : 0;
-      return {
-        size: cache.size(),
-        hitRate,
-        totalHits,
-        totalMisses,
-        keys: Array.from(cache.keys())
-      };
-    };
-    const maybeInterval = getCleanupInterval(tree);
-    if (maybeInterval) {
-      const origClear = tree.clearMemoCache.bind(tree);
-      tree.clearMemoCache = key => {
-        origClear(key);
-        clearCleanupInterval(tree);
-      };
-    }
-    tree.clearCache = tree.clearMemoCache;
-    if (ttl) {
-      const cleanup = () => {
-        const now = Date.now();
-        cache.forEach((entry, key) => {
-          if (entry.timestamp && now - entry.timestamp > ttl) {
-            cache.delete(key);
-          }
-        });
-      };
-      const intervalId = setInterval(cleanup, ttl);
-      setCleanupInterval(tree, intervalId);
-    }
-    if (typeof tree.registerCleanup === 'function') {
-      tree.registerCleanup(() => {
-        clearCleanupInterval(tree);
-        cache.clear();
-        memoizationCache.delete(tree);
-      });
-    }
-    return tree;
-  };
-  const meta = {
-    name: 'memoization',
-    provides: ['memoization']
-  };
-  enhancer.metadata = meta;
-  enhancer[ENHANCER_META] = meta;
-  return enhancer;
-}
-
-export { MEMOIZATION_PRESETS, computedMemoization, deepStateMemoization, highFrequencyMemoization, memoization, selectorMemoization };

package/dist/enhancers/presets/lib/presets.js

@@ -1,27 +0,0 @@
-const TREE_PRESETS = {};
-function createPresetConfig(preset, overrides = {}) {
-  return {
-    ...overrides
-  };
-}
-function validatePreset(preset) {
-  return typeof preset === 'string';
-}
-function getAvailablePresets() {
-  return Object.keys(TREE_PRESETS);
-}
-function combinePresets(presets, overrides = {}) {
-  let combined = {};
-  for (const p of presets) {
-    combined = {
-      ...combined,
-      ...TREE_PRESETS[p]
-    };
-  }
-  return {
-    ...combined,
-    ...overrides
-  };
-}
-
-export { TREE_PRESETS, combinePresets, createPresetConfig, getAvailablePresets, validatePreset };

package/dist/lib/presets.js

@@ -1,30 +0,0 @@
-import { signalTree } from './signal-tree.js';
-import { effects } from '../enhancers/effects/effects.js';
-import { batching } from '../enhancers/batching/batching.js';
-import { memoization } from '../enhancers/memoization/memoization.js';
-import { timeTravel } from '../enhancers/time-travel/time-travel.js';
-import { devTools } from '../enhancers/devtools/devtools.js';
-
-function createDevTree(initialState, config = {}) {
-  if (arguments.length === 0) {
-    const enhancer = tree => tree.with(effects()).with(batching()).with(memoization()).with(timeTravel()).with(devTools());
-    return {
-      enhancer
-    };
-  }
-  const base = signalTree(initialState, config);
-  const enhanced = base.with(effects()).with(batching(config.batching)).with(memoization(config.memoization)).with(timeTravel(config.timeTravel)).with(devTools(config.devTools));
-  return enhanced;
-}
-function createProdTree(initialState, config = {}) {
-  const base = signalTree(initialState, config);
-  const enhanced = base.with(effects()).with(batching(config.batching)).with(memoization(config.memoization));
-  return enhanced;
-}
-function createMinimalTree(initialState, config = {}) {
-  const base = signalTree(initialState, config);
-  const enhanced = base.with(effects());
-  return enhanced;
-}
-
-export { createDevTree, createMinimalTree, createProdTree };

package/dist/presets.js

@@ -1,2 +0,0 @@
-export { TREE_PRESETS, combinePresets, createPresetConfig, getAvailablePresets, validatePreset } from './enhancers/presets/lib/presets.js';
-export { createDevTree, createMinimalTree, createProdTree } from './lib/presets.js';

package/src/enhancers/memoization/index.d.ts

@@ -1 +0,0 @@
-export * from './memoization';

package/src/enhancers/memoization/memoization.d.ts

@@ -1,54 +0,0 @@
-import type { ISignalTree } from '../../lib/types';
-export declare function cleanupMemoizationCache(): void;
-import type { MemoizationConfig, MemoizationMethods } from '../../lib/types';
-export declare function memoize<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string, config?: MemoizationConfig): (...args: TArgs) => TReturn;
-export declare function memoizeShallow<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
-export declare function memoizeReference<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
-export declare const MEMOIZATION_PRESETS: {
-    readonly selector: {
-        readonly equality: "reference";
-        readonly maxCacheSize: 10;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-    readonly computed: {
-        readonly equality: "shallow";
-        readonly maxCacheSize: 100;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-    readonly deepState: {
-        readonly equality: "deep";
-        readonly maxCacheSize: 1000;
-        readonly enableLRU: true;
-        readonly ttl: number;
-    };
-    readonly highFrequency: {
-        readonly equality: "reference";
-        readonly maxCacheSize: 5;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-};
-export declare function selectorMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function computedMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function deepStateMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function highFrequencyMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare const withMemoization: ((config?: MemoizationConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>) & {
-    selector: typeof selectorMemoization;
-    computed: typeof computedMemoization;
-    deep: typeof deepStateMemoization;
-    fast: typeof highFrequencyMemoization;
-};
-export declare function memoization(config?: MemoizationConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function enableMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function highPerformanceMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function lightweightMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function shallowMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function clearAllCaches(): void;
-export declare function getGlobalCacheStats(): {
-    treeCount: number;
-    totalSize: number;
-    totalHits: number;
-    averageCacheSize: number;
-};

package/src/enhancers/memoization/memoization.types.d.ts

@@ -1 +0,0 @@
-export {};

package/src/enhancers/memoization/test-setup.d.ts

@@ -1,3 +0,0 @@
-import '@angular/compiler';
-import 'zone.js';
-import 'zone.js/testing';

package/src/enhancers/presets/index.d.ts

@@ -1 +0,0 @@
-export * from './lib/presets';

package/src/enhancers/presets/lib/presets.d.ts

@@ -1,8 +0,0 @@
-import { createDevTree, createMinimalTree, createProdTree } from '../../../lib/presets';
-import type { TreeConfig, TreePreset } from '../../../lib/types';
-export declare const TREE_PRESETS: Record<TreePreset, Partial<TreeConfig>>;
-export declare function createPresetConfig(preset: TreePreset, overrides?: Partial<TreeConfig>): TreeConfig;
-export declare function validatePreset(preset: TreePreset): boolean;
-export declare function getAvailablePresets(): TreePreset[];
-export declare function combinePresets(presets: TreePreset[], overrides?: Partial<TreeConfig>): TreeConfig;
-export { createDevTree, createProdTree, createMinimalTree };

package/src/lib/presets.d.ts

@@ -1,34 +0,0 @@
-import type { ISignalTree, TreeConfig, BatchingConfig, MemoizationConfig, TimeTravelConfig, DevToolsConfig, BatchingMethods, MemoizationMethods, TimeTravelMethods, DevToolsMethods, EffectsMethods, EntitiesEnabled } from './types';
-export interface DevTreeConfig extends TreeConfig {
-    effects?: Record<string, never>;
-    batching?: BatchingConfig;
-    memoization?: MemoizationConfig;
-    timeTravel?: TimeTravelConfig;
-    devTools?: DevToolsConfig;
-    entities?: Record<string, never>;
-}
-export interface ProdTreeConfig extends TreeConfig {
-    effects?: Record<string, never>;
-    batching?: BatchingConfig;
-    memoization?: MemoizationConfig;
-    entities?: Record<string, never>;
-}
-export interface MinimalTreeConfig extends TreeConfig {
-    effects?: Record<string, never>;
-}
-export type FullSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods & MemoizationMethods<T> & EntitiesEnabled & TimeTravelMethods & DevToolsMethods;
-export type ProdSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods & MemoizationMethods<T> & EntitiesEnabled;
-export type MinimalSignalTree<T> = ISignalTree<T> & EffectsMethods<T>;
-export declare function createDevTree<T extends object>(initialState: T, config?: DevTreeConfig): FullSignalTree<T>;
-export declare function createDevTree(): {
-    enhancer: <T>(tree: ISignalTree<T>) => ISignalTree<T> & EffectsMethods<T> & BatchingMethods<T> & MemoizationMethods<T> & EntitiesEnabled & TimeTravelMethods<T> & DevToolsMethods;
-};
-export declare function createProdTree<T extends object>(initialState: T, config?: ProdTreeConfig): ProdSignalTree<T>;
-export declare function createMinimalTree<T extends object>(initialState: T, config?: MinimalTreeConfig): MinimalSignalTree<T>;
-export declare const devTree: typeof createDevTree;
-export declare const prodTree: typeof createProdTree;
-export declare const minimalTree: typeof createMinimalTree;
-export declare function buildTree<T extends object>(initialState: T, config?: TreeConfig): {
-    add<R>(enhancer: (t: ISignalTree<T>) => R): any;
-    done(): ISignalTree<T>;
-};

package/src/presets.d.ts

@@ -1,2 +0,0 @@
-export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, createProdTree, createMinimalTree, } from './enhancers/presets/lib/presets';
-export type { TreePreset } from './lib/types';