@signaltree/core 4.2.0 → 5.0.0

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 {};