@signaltree/core 4.2.1 → 5.0.0

package/dist/lib/path-notifier.js

@@ -0,0 +1,106 @@
+class PathNotifier {
+  subscribers = new Map();
+  interceptors = new Map();
+  subscribe(pattern, handler) {
+    if (!this.subscribers.has(pattern)) {
+      this.subscribers.set(pattern, new Set());
+    }
+    const handlers = this.subscribers.get(pattern);
+    if (!handlers) {
+      return () => {};
+    }
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.subscribers.delete(pattern);
+      }
+    };
+  }
+  intercept(pattern, interceptor) {
+    if (!this.interceptors.has(pattern)) {
+      this.interceptors.set(pattern, new Set());
+    }
+    const interceptors = this.interceptors.get(pattern);
+    if (!interceptors) {
+      return () => {};
+    }
+    interceptors.add(interceptor);
+    return () => {
+      interceptors.delete(interceptor);
+      if (interceptors.size === 0) {
+        this.interceptors.delete(pattern);
+      }
+    };
+  }
+  notify(path, value, prev) {
+    let blocked = false;
+    let transformed = value;
+    for (const [pattern, interceptorSet] of this.interceptors) {
+      if (this.matches(pattern, path)) {
+        for (const interceptor of interceptorSet) {
+          const result = interceptor(transformed, prev, path);
+          if (result.block) {
+            blocked = true;
+          }
+          if (result.transform !== undefined) {
+            transformed = result.transform;
+          }
+        }
+      }
+    }
+    if (blocked) {
+      return {
+        blocked: true,
+        value: prev
+      };
+    }
+    for (const [pattern, handlers] of this.subscribers) {
+      if (this.matches(pattern, path)) {
+        for (const handler of handlers) {
+          handler(transformed, prev, path);
+        }
+      }
+    }
+    return {
+      blocked: false,
+      value: transformed
+    };
+  }
+  matches(pattern, path) {
+    if (pattern === '**') return true;
+    if (pattern === path) return true;
+    if (pattern.endsWith('.*')) {
+      const prefix = pattern.slice(0, -2);
+      return path.startsWith(prefix + '.');
+    }
+    return false;
+  }
+  clear() {
+    this.subscribers.clear();
+    this.interceptors.clear();
+  }
+  getSubscriberCount() {
+    let count = 0;
+    for (const handlers of this.subscribers.values()) {
+      count += handlers.size;
+    }
+    return count;
+  }
+  getInterceptorCount() {
+    let count = 0;
+    for (const interceptors of this.interceptors.values()) {
+      count += interceptors.size;
+    }
+    return count;
+  }
+}
+let globalPathNotifier = null;
+function getPathNotifier() {
+  if (!globalPathNotifier) {
+    globalPathNotifier = new PathNotifier();
+  }
+  return globalPathNotifier;
+}
+
+export { PathNotifier, getPathNotifier };

package/dist/lib/signal-tree.js

@@ -185,6 +185,10 @@ function createSignalStore(obj, equalityFn) {
     for (const [key, value] of Object.entries(obj)) {
       try {
         if (typeof key === 'symbol') continue;
+        if (isEntityMapMarker(value)) {
+          store[key] = value;
+          continue;
+        }
         if (isSignal(value)) {
           store[key] = value;
           continue;
@@ -228,6 +232,10 @@ function createSignalStore(obj, equalityFn) {
     for (const sym of symbols) {
       const value = obj[sym];
       try {
+        if (isEntityMapMarker(value)) {
+          store[sym] = value;
+          continue;
+        }
         if (isSignal(value)) {
           store[sym] = value;
         } else {
@@ -244,6 +252,9 @@ function createSignalStore(obj, equalityFn) {
   }
   return store;
 }
+function isEntityMapMarker(value) {
+  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
+}
 function enhanceTree(tree, config = {}) {
   const isLazy = config.useLazySignals ?? shouldUseLazy(tree.state, config);
   tree.with = (...enhancers) => {
@@ -395,8 +406,7 @@ function addStubMethods(tree, config) {
       if (config.debugMode) {
         console.warn(SIGNAL_TREE_MESSAGES.SUBSCRIBE_NO_CONTEXT, error);
       }
-      fn(tree());
-      return () => {};
+      throw error;
     }
   };
   tree.optimize = () => {
@@ -448,16 +458,6 @@ function addStubMethods(tree, config) {
       averageUpdateTime: 0
     };
   };
-  tree.addTap = middleware => {
-    if (config.debugMode) {
-      console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
-    }
-  };
-  tree.removeTap = id => {
-    if (config.debugMode) {
-      console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
-    }
-  };
   tree.entities = () => {
     if (config.debugMode) {
       console.warn(SIGNAL_TREE_MESSAGES.ENTITY_HELPERS_NOT_AVAILABLE);

package/dist/lib/types.js

@@ -1,3 +1,9 @@
 const ENHANCER_META = Symbol('signaltree:enhancer:meta');
+function entityMap(config) {
+  return {
+    __isEntityMap: true,
+    __entityMapConfig: config ?? {}
+  };
+}
 
-export { ENHANCER_META };
+export { ENHANCER_META, entityMap };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "4.2.1",
+  "version": "5.0.0",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "type": "module",
   "sideEffects": false,

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

@@ -1,22 +1,20 @@
-import type { SignalTree, EntityHelpers } from '../../../lib/types';
-interface EntityConfig {
+import type { EntitySignal, SignalTree, EntityAwareTreeNode } from '../../../lib/types';
+interface EntitiesEnhancerConfig {
     enabled?: boolean;
-    trackChanges?: boolean;
-    validateIds?: boolean;
 }
-export declare function withEntities(config?: EntityConfig): <T>(tree: SignalTree<T>) => SignalTree<T> & {
-    entities<E extends {
-        id: string | number;
-    }>(entityKey: keyof T | string): EntityHelpers<E>;
+export declare function withEntities(config?: EntitiesEnhancerConfig): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
+    state: EntityAwareTreeNode<T>;
+    $: EntityAwareTreeNode<T>;
+    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
 };
-export declare function enableEntities(): <T>(tree: SignalTree<T>) => SignalTree<T> & {
-    entities<E extends {
-        id: string | number;
-    }>(entityKey: keyof T | string): EntityHelpers<E>;
+export declare function enableEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
+    state: EntityAwareTreeNode<T>;
+    $: EntityAwareTreeNode<T>;
+    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
 };
-export declare function withHighPerformanceEntities(): <T>(tree: SignalTree<T>) => SignalTree<T> & {
-    entities<E extends {
-        id: string | number;
-    }>(entityKey: keyof T | string): EntityHelpers<E>;
+export declare function withHighPerformanceEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
+    state: EntityAwareTreeNode<T>;
+    $: EntityAwareTreeNode<T>;
+    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
 };
 export {};

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

@@ -7,5 +7,5 @@ export declare function getAvailablePresets(): TreePreset[];
 export declare function combinePresets(presets: TreePreset[], overrides?: Partial<TreeConfig>): TreeConfig;
 export declare function createDevTree(overrides?: Partial<TreeConfig>): {
     readonly config: TreeConfig;
-    readonly enhancer: (tree: import("../../../lib/types").SignalTree<unknown>) => import("../../../lib/types").SignalTree<unknown>;
+    readonly enhancer: (tree: import("../../memoization/lib/memoization").MemoizedSignalTree<unknown>) => import("../../memoization/lib/memoization").MemoizedSignalTree<unknown>;
 };

package/src/enhancers/types.d.ts

@@ -16,18 +16,6 @@ export interface ComputedConfig {
     lazy?: boolean;
     memoize?: boolean;
 }
-export interface MiddlewareConfig {
-    beforeUpdate?: (path: string[], value: unknown) => void | boolean;
-    afterUpdate?: (path: string[], value: unknown, previousValue: unknown) => void;
-    beforeRead?: (path: string[]) => void;
-    afterRead?: (path: string[], value: unknown) => void;
-}
-export interface MiddlewareContext {
-    path: string[];
-    value: unknown;
-    previousValue?: unknown;
-    operation: 'read' | 'write';
-}
 export interface MemoizationConfig {
     maxSize?: number;
     ttl?: number;
@@ -73,25 +61,6 @@ export interface EntityConfig {
     indexes?: string[];
     relations?: Record<string, string>;
 }
-export interface EntityCollection<T = unknown> {
-    add(entity: T): void;
-    remove(id: string | number): boolean;
-    update(id: string | number, updates: Partial<T>): boolean;
-    get(id: string | number): T | undefined;
-    find(predicate: (entity: T) => boolean): T | undefined;
-    filter(predicate: (entity: T) => boolean): T[];
-    count(): number;
-}
-export interface AsyncConfig {
-    timeout?: number;
-    retryAttempts?: number;
-    retryDelay?: number;
-}
-export interface AsyncAction<T = unknown> {
-    execute(): Promise<T>;
-    cancel(): void;
-    status: 'pending' | 'fulfilled' | 'rejected' | 'cancelled';
-}
 export interface SerializationConfig {
     includeComputed?: boolean;
     includeMeta?: boolean;

package/src/index.d.ts

@@ -1,5 +1,6 @@
 export { signalTree } from './lib/signal-tree';
-export type { SignalTree, TreeNode, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, DeepPath, DeepAccess, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, Middleware, PerformanceMetrics, EntityHelpers, TimeTravelEntry, } from './lib/types';
+export type { SignalTree, TreeNode, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, DeepPath, DeepAccess, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, PerformanceMetrics, EntityHelpers, TimeTravelEntry, } from './lib/types';
+export { entityMap } from './lib/types';
 export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, 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';
@@ -10,8 +11,7 @@ export { withTimeTravel, enableTimeTravel, getTimeTravel, type TimeTravelInterfa
 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 { createAsyncOperation, trackAsync } from './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';

package/src/{enhancers/middleware/lib → lib}/async-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { SignalTree } from '../../../lib/types';
+import type { SignalTree } from './types';
 export declare function createAsyncOperation<T, TResult>(name: string, operation: () => Promise<TResult>): (tree: SignalTree<T>) => Promise<TResult>;
 export declare function trackAsync<T>(operation: () => Promise<T>): {
     pending: import("@angular/core").Signal<boolean>;

package/src/lib/entity-signal.d.ts

@@ -0,0 +1 @@
+export declare function entityMap<E extends Record<string, unknown>, K extends string | number = string>(config?: Partial<EntityConfig<E, K>>): unknown;

package/src/lib/path-notifier.d.ts

@@ -0,0 +1,4 @@
+export type PathNotifierInterceptor = (value: unknown, prev: unknown, path: string) => {
+    block?: boolean;
+    transform?: unknown;
+};

package/src/lib/types.d.ts

@@ -90,8 +90,6 @@ export type SignalTree<T> = NodeAccessor<T> & {
         };
     };
     getMetrics(): PerformanceMetrics;
-    addTap(middleware: Middleware<T>): void;
-    removeTap(id: string): void;
     entities<E extends {
         id: string | number;
     }>(entityKey?: keyof T): EntityHelpers<E>;
@@ -120,11 +118,6 @@ export interface TreeConfig {
     useStructuralSharing?: boolean;
     security?: SecurityValidatorConfig;
 }
-export interface Middleware<T> {
-    id: string;
-    before?: (action: string, payload: unknown, state: T) => boolean;
-    after?: (action: string, payload: unknown, state: T, newState: T) => void;
-}
 export interface PerformanceMetrics {
     updates: number;
     computations: number;
@@ -132,6 +125,83 @@ export interface PerformanceMetrics {
     cacheMisses: number;
     averageUpdateTime: number;
 }
+export interface EntityConfig<E, K extends string | number = string> {
+    selectId?: (entity: E) => K;
+    hooks?: {
+        beforeAdd?: (entity: E) => E | false;
+        beforeUpdate?: (id: K, changes: Partial<E>) => Partial<E> | false;
+        beforeRemove?: (id: K, entity: E) => boolean;
+    };
+}
+export interface EntityMapMarker<E, K extends string | number> {
+    readonly __entityType?: E;
+    readonly __keyType?: K;
+    readonly __isEntityMap?: true;
+    readonly __entityMapConfig?: EntityConfig<E, K>;
+}
+export declare function entityMap<E, K extends string | number = E extends {
+    id: infer I extends string | number;
+} ? I : string>(config?: EntityConfig<E, K>): EntityMapMarker<E, K>;
+export interface MutationOptions {
+    onError?: (error: Error) => void;
+}
+export interface AddOptions<E, K> extends MutationOptions {
+    selectId?: (entity: E) => K;
+}
+export interface AddManyOptions<E, K> extends AddOptions<E, K> {
+    mode?: 'strict' | 'skip' | 'overwrite';
+}
+export interface TapHandlers<E, K extends string | number> {
+    onAdd?: (entity: E, id: K) => void;
+    onUpdate?: (id: K, changes: Partial<E>, entity: E) => void;
+    onRemove?: (id: K, entity: E) => void;
+    onChange?: () => void;
+}
+export interface InterceptContext<T> {
+    block(reason?: string): void;
+    transform(value: T): void;
+    readonly blocked: boolean;
+    readonly blockReason: string | undefined;
+}
+export interface InterceptHandlers<E, K extends string | number> {
+    onAdd?: (entity: E, ctx: InterceptContext<E>) => void | Promise<void>;
+    onUpdate?: (id: K, changes: Partial<E>, ctx: InterceptContext<Partial<E>>) => void | Promise<void>;
+    onRemove?: (id: K, entity: E, ctx: InterceptContext<void>) => void | Promise<void>;
+}
+export type EntityNode<E> = {
+    (): E;
+    (value: E): void;
+    (updater: (current: E) => E): void;
+} & {
+    [P in keyof E]: E[P] extends object ? E[P] extends readonly unknown[] ? CallableWritableSignal<E[P]> : EntityNode<E[P]> : CallableWritableSignal<E[P]>;
+};
+export interface EntitySignal<E, K extends string | number = string> {
+    byId(id: K): EntityNode<E> | undefined;
+    byIdOrFail(id: K): EntityNode<E>;
+    all(): Signal<E[]>;
+    count(): Signal<number>;
+    ids(): Signal<K[]>;
+    has(id: K): Signal<boolean>;
+    isEmpty(): Signal<boolean>;
+    map(): Signal<ReadonlyMap<K, E>>;
+    where(predicate: (entity: E) => boolean): Signal<E[]>;
+    find(predicate: (entity: E) => boolean): Signal<E | undefined>;
+    addOne(entity: E, opts?: AddOptions<E, K>): K;
+    addMany(entities: E[], opts?: AddManyOptions<E, K>): K[];
+    updateOne(id: K, changes: Partial<E>, opts?: MutationOptions): void;
+    updateMany(ids: K[], changes: Partial<E>, opts?: MutationOptions): void;
+    updateWhere(predicate: (entity: E) => boolean, changes: Partial<E>): number;
+    upsertOne(entity: E, opts?: AddOptions<E, K>): K;
+    upsertMany(entities: E[], opts?: AddOptions<E, K>): K[];
+    removeOne(id: K, opts?: MutationOptions): void;
+    removeMany(ids: K[], opts?: MutationOptions): void;
+    removeWhere(predicate: (entity: E) => boolean): number;
+    clear(): void;
+    removeAll(): void;
+    setAll(entities: E[], opts?: AddOptions<E, K>): void;
+    tap(handlers: TapHandlers<E, K>): () => void;
+    intercept(handlers: InterceptHandlers<E, K>): () => void;
+}
 export interface EntityHelpers<E extends {
     id: string | number;
 }> {
@@ -146,6 +216,56 @@ export interface EntityHelpers<E extends {
     selectTotal(): Signal<number>;
     clear(): void;
 }
+export interface LoggingConfig {
+    name?: string;
+    filter?: (path: string) => boolean;
+    collapsed?: boolean;
+    onLog?: (entry: LogEntry) => void;
+}
+export interface LogEntry {
+    path: string;
+    prev: unknown;
+    value: unknown;
+    timestamp: number;
+}
+export interface ValidationConfig<T> {
+    validators: Array<{
+        match: (path: string) => boolean;
+        validate: (value: unknown, path: string) => void | never;
+    }>;
+    onError?: (error: Error, path: string) => void;
+}
+export interface PersistenceConfig {
+    key: string;
+    storage?: Storage;
+    debounceMs?: number;
+    filter?: (path: string) => boolean;
+    serialize?: (state: unknown) => string;
+    deserialize?: (json: string) => unknown;
+}
+export interface DevToolsConfig {
+    name?: string;
+    maxAge?: number;
+    features?: {
+        jump?: boolean;
+        skip?: boolean;
+        reorder?: boolean;
+    };
+}
+export type EntityType<T> = T extends EntitySignal<infer E, any> ? E : never;
+export type EntityKeyType<T> = T extends EntitySignal<unknown, infer K> ? K : never;
+export type IsEntityMap<T> = T extends EntityMapMarker<unknown, any> ? true : false;
+export type EntityAwareTreeNode<T> = {
+    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends object ? EntityAwareTreeNode<T[K]> : CallableWritableSignal<T[K]>;
+};
+export type PathHandler = (value: unknown, prev: unknown, path: string) => void;
+export type PathInterceptor = (ctx: {
+    path: string;
+    value: unknown;
+    prev: unknown;
+    blocked: boolean;
+    blockReason?: string;
+}, next: () => void) => void | Promise<void>;
 export interface TimeTravelEntry<T> {
     action: string;
     timestamp: number;

package/dist/enhancers/middleware/lib/middleware.js

@@ -1,156 +0,0 @@
-const middlewareMap = new WeakMap();
-function withMiddleware(middlewares = []) {
-  return tree => {
-    middlewareMap.set(tree, [...middlewares]);
-    const originalTreeCall = tree.bind(tree);
-    const enhancedTree = function (...args) {
-      if (args.length === 0) {
-        return originalTreeCall();
-      } else {
-        const action = 'UPDATE';
-        const currentState = originalTreeCall();
-        const treeMiddlewares = middlewareMap.get(tree) || [];
-        let updateResult;
-        if (args.length === 1) {
-          const arg = args[0];
-          if (typeof arg === 'function') {
-            updateResult = arg(currentState);
-          } else {
-            updateResult = arg;
-          }
-        } else {
-          return;
-        }
-        for (const middleware of treeMiddlewares) {
-          if (middleware.before && !middleware.before(action, updateResult, currentState)) {
-            return;
-          }
-        }
-        let isNoMutation = true;
-        if (updateResult && typeof updateResult === 'object') {
-          for (const k in updateResult) {
-            if (!Object.prototype.hasOwnProperty.call(updateResult, k)) continue;
-            const nextVal = updateResult[k];
-            const prevVal = currentState[k];
-            if (nextVal !== prevVal) {
-              isNoMutation = false;
-              break;
-            }
-          }
-        }
-        if (isNoMutation) {
-          for (const middleware of treeMiddlewares) {
-            if (middleware.after) {
-              middleware.after(action, updateResult, currentState, currentState);
-            }
-          }
-          return;
-        }
-        const previousState = currentState;
-        if (args.length === 1) {
-          const arg = args[0];
-          if (typeof arg === 'function') {
-            originalTreeCall(arg);
-          } else {
-            originalTreeCall(arg);
-          }
-        }
-        const newState = originalTreeCall();
-        for (const middleware of treeMiddlewares) {
-          if (middleware.after) {
-            middleware.after(action, updateResult, previousState, newState);
-          }
-        }
-      }
-    };
-    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.addTap = middleware => {
-      const treeMiddlewares = middlewareMap.get(tree) || [];
-      const existingIndex = treeMiddlewares.findIndex(m => m.id === middleware.id);
-      if (existingIndex >= 0) {
-        treeMiddlewares[existingIndex] = middleware;
-      } else {
-        treeMiddlewares.push(middleware);
-      }
-      middlewareMap.set(tree, treeMiddlewares);
-    };
-    enhancedTree.removeTap = id => {
-      const treeMiddlewares = middlewareMap.get(tree) || [];
-      const filtered = treeMiddlewares.filter(m => m.id !== id);
-      middlewareMap.set(tree, filtered);
-    };
-    const originalBatchUpdate = tree.batchUpdate;
-    if (originalBatchUpdate) {
-      enhancedTree.batchUpdate = updater => {
-        const action = 'BATCH_UPDATE';
-        const currentState = originalTreeCall();
-        const updateResult = updater(currentState);
-        const treeMiddlewares = middlewareMap.get(tree) || [];
-        for (const middleware of treeMiddlewares) {
-          if (middleware.before && !middleware.before(action, updateResult, currentState)) {
-            return;
-          }
-        }
-        const previousState = currentState;
-        originalBatchUpdate.call(tree, updater);
-        const newState = originalTreeCall();
-        for (const middleware of treeMiddlewares) {
-          if (middleware.after) {
-            middleware.after(action, updateResult, previousState, newState);
-          }
-        }
-      };
-    }
-    const originalDestroy = tree.destroy;
-    enhancedTree.destroy = () => {
-      middlewareMap.delete(tree);
-      if (originalDestroy) {
-        originalDestroy.call(tree);
-      }
-    };
-    return enhancedTree;
-  };
-}
-function createLoggingMiddleware(treeName) {
-  return {
-    id: 'logging',
-    before: (action, payload, state) => {
-      console.group(`🏪 ${treeName}: ${action}`);
-      console.log('Previous state:', state);
-      console.log('Payload:', typeof payload === 'function' ? 'Function' : payload);
-      return true;
-    },
-    after: (action, payload, state, newState) => {
-      console.log('New state:', newState);
-      console.groupEnd();
-    }
-  };
-}
-function createValidationMiddleware(validator) {
-  return {
-    id: 'validation',
-    after: (action, payload, state, newState) => {
-      const error = validator(newState);
-      if (error) {
-        console.error(`Validation failed after ${action}:`, error);
-      }
-    }
-  };
-}
-
-export { createLoggingMiddleware, createValidationMiddleware, withMiddleware };

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

@@ -1,2 +0,0 @@
-export * from './lib/middleware';
-export * from './lib/async-helpers';

package/src/enhancers/middleware/jest.config.d.ts

@@ -1,15 +0,0 @@
-declare const _default: {
-    displayName: string;
-    preset: string;
-    setupFilesAfterEnv: string[];
-    coverageDirectory: string;
-    transform: {
-        '^.+\\.(ts|mjs|js|html)$': (string | {
-            tsconfig: string;
-            stringifyContentPathRegex: string;
-        })[];
-    };
-    transformIgnorePatterns: string[];
-    snapshotSerializers: string[];
-};
-export default _default;

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

@@ -1,11 +0,0 @@
-import type { Middleware, SignalTree } from '../../../lib/types';
-export declare function withMiddleware<T>(middlewares?: Middleware<T>[]): (tree: SignalTree<T>) => SignalTree<T>;
-export declare function createLoggingMiddleware<T>(treeName: string): Middleware<T>;
-export declare function createPerformanceMiddleware<T>(): Middleware<T>;
-export declare function createValidationMiddleware<T>(validator: (state: T) => string | null): Middleware<T>;
-export declare function createPersistenceMiddleware<T>(config: {
-    key: string;
-    storage?: Storage;
-    debounceMs?: number;
-    actions?: string[];
-}): Middleware<T>;

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

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