@signaltree/core 4.2.0 → 5.0.0

package/dist/lib/entity-signal.js

@@ -0,0 +1,280 @@
+import { signal, computed } from '@angular/core';
+
+class EntitySignalImpl {
+  pathNotifier;
+  basePath;
+  storage = new Map();
+  allSignal;
+  countSignal;
+  idsSignal;
+  mapSignal;
+  nodeCache = new Map();
+  selectId;
+  tapHandlers = [];
+  interceptHandlers = [];
+  constructor(config, pathNotifier, basePath) {
+    this.pathNotifier = pathNotifier;
+    this.basePath = basePath;
+    this.selectId = config.selectId ?? (entity => entity['id']);
+    this.allSignal = signal([]);
+    this.countSignal = signal(0);
+    this.idsSignal = signal([]);
+    this.mapSignal = signal(new Map());
+    return new Proxy(this, {
+      get: (target, prop) => {
+        if (typeof prop === 'string' && !isNaN(Number(prop))) {
+          return target.byId(Number(prop));
+        }
+        return target[prop];
+      }
+    });
+  }
+  byId(id) {
+    const entity = this.storage.get(id);
+    if (!entity) return undefined;
+    return this.getOrCreateNode(id, entity);
+  }
+  byIdOrFail(id) {
+    const node = this.byId(id);
+    if (!node) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    return node;
+  }
+  all() {
+    return this.allSignal;
+  }
+  count() {
+    return this.countSignal;
+  }
+  ids() {
+    return this.idsSignal;
+  }
+  map() {
+    return this.mapSignal;
+  }
+  has(id) {
+    return computed(() => this.storage.has(id));
+  }
+  isEmpty() {
+    return computed(() => this.storage.size === 0);
+  }
+  where(predicate) {
+    return computed(() => {
+      const result = [];
+      for (const entity of this.storage.values()) {
+        if (predicate(entity)) {
+          result.push(entity);
+        }
+      }
+      return result;
+    });
+  }
+  find(predicate) {
+    return computed(() => {
+      for (const entity of this.storage.values()) {
+        if (predicate(entity)) {
+          return entity;
+        }
+      }
+      return undefined;
+    });
+  }
+  addOne(entity, opts) {
+    const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+    if (this.storage.has(id)) {
+      throw new Error(`Entity with id ${String(id)} already exists`);
+    }
+    let transformedEntity = entity;
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: value => {
+          transformedEntity = value;
+        },
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onAdd?.(entity, ctx);
+    }
+    this.storage.set(id, transformedEntity);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, transformedEntity, undefined);
+    for (const handler of this.tapHandlers) {
+      handler.onAdd?.(transformedEntity, id);
+    }
+    return id;
+  }
+  addMany(entities, opts) {
+    const ids = [];
+    for (const entity of entities) {
+      ids.push(this.addOne(entity, opts));
+    }
+    return ids;
+  }
+  updateOne(id, changes) {
+    const entity = this.storage.get(id);
+    if (!entity) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    const prev = entity;
+    let transformedChanges = changes;
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: value => {
+          transformedChanges = value;
+        },
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onUpdate?.(id, changes, ctx);
+    }
+    const finalUpdated = {
+      ...entity,
+      ...transformedChanges
+    };
+    this.storage.set(id, finalUpdated);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, finalUpdated, prev);
+    for (const handler of this.tapHandlers) {
+      handler.onUpdate?.(id, transformedChanges, finalUpdated);
+    }
+  }
+  updateMany(ids, changes) {
+    for (const id of ids) {
+      this.updateOne(id, changes);
+    }
+  }
+  updateWhere(predicate, changes) {
+    let count = 0;
+    for (const [id, entity] of this.storage) {
+      if (predicate(entity)) {
+        this.updateOne(id, changes);
+        count++;
+      }
+    }
+    return count;
+  }
+  removeOne(id) {
+    const entity = this.storage.get(id);
+    if (!entity) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot remove entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: () => {},
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onRemove?.(id, entity, ctx);
+    }
+    this.storage.delete(id);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, undefined, entity);
+    for (const handler of this.tapHandlers) {
+      handler.onRemove?.(id, entity);
+    }
+  }
+  removeMany(ids) {
+    for (const id of ids) {
+      this.removeOne(id);
+    }
+  }
+  removeWhere(predicate) {
+    const idsToRemove = [];
+    for (const [id, entity] of this.storage) {
+      if (predicate(entity)) {
+        idsToRemove.push(id);
+      }
+    }
+    let count = 0;
+    for (const id of idsToRemove) {
+      this.removeOne(id);
+      count++;
+    }
+    return count;
+  }
+  upsertOne(entity, opts) {
+    const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+    if (this.storage.has(id)) {
+      this.updateOne(id, entity);
+    } else {
+      this.addOne(entity, opts);
+    }
+    return id;
+  }
+  upsertMany(entities, opts) {
+    return entities.map(e => this.upsertOne(e, opts));
+  }
+  clear() {
+    this.storage.clear();
+    this.nodeCache.clear();
+    this.updateSignals();
+  }
+  removeAll() {
+    this.clear();
+  }
+  setAll(entities, opts) {
+    this.clear();
+    this.addMany(entities, opts);
+  }
+  tap(handlers) {
+    this.tapHandlers.push(handlers);
+    return () => {
+      const idx = this.tapHandlers.indexOf(handlers);
+      if (idx > -1) this.tapHandlers.splice(idx, 1);
+    };
+  }
+  intercept(handlers) {
+    this.interceptHandlers.push(handlers);
+    return () => {
+      const idx = this.interceptHandlers.indexOf(handlers);
+      if (idx > -1) this.interceptHandlers.splice(idx, 1);
+    };
+  }
+  updateSignals() {
+    const entities = Array.from(this.storage.values());
+    const ids = Array.from(this.storage.keys());
+    const map = new Map(this.storage);
+    this.allSignal.set(entities);
+    this.countSignal.set(entities.length);
+    this.idsSignal.set(ids);
+    this.mapSignal.set(map);
+  }
+  getOrCreateNode(id, entity) {
+    let node = this.nodeCache.get(id);
+    if (!node) {
+      node = this.createEntityNode(id, entity);
+      this.nodeCache.set(id, node);
+    }
+    return node;
+  }
+  createEntityNode(id, entity) {
+    const node = () => this.storage.get(id);
+    for (const key of Object.keys(entity)) {
+      Object.defineProperty(node, key, {
+        get: () => {
+          const current = this.storage.get(id);
+          const value = current?.[key];
+          return () => value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return node;
+  }
+}
+
+export { EntitySignalImpl };

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.0",
+  "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): 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): 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): 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;
+};