@signaltree/core 3.0.2 → 3.1.0

package/package.json

@@ -1,23 +1,70 @@
 {
   "name": "@signaltree/core",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
-  "peerDependencies": {
-    "@angular/core": "^20.1.0"
-  },
+  "type": "module",
   "sideEffects": false,
-  "module": "fesm2022/signaltree-core.mjs",
-  "typings": "index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
     ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/signaltree-core.mjs"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./enhancers": {
+      "import": "./dist/enhancers/index.js",
+      "types": "./dist/enhancers/index.d.ts"
+    },
+    "./enhancers/batching": {
+      "import": "./dist/enhancers/batching/index.js",
+      "types": "./dist/enhancers/batching/index.d.ts"
+    },
+    "./enhancers/computed": {
+      "import": "./dist/enhancers/computed/index.js",
+      "types": "./dist/enhancers/computed/index.d.ts"
+    },
+    "./enhancers/middleware": {
+      "import": "./dist/enhancers/middleware/index.js",
+      "types": "./dist/enhancers/middleware/index.d.ts"
+    },
+    "./enhancers/memoization": {
+      "import": "./dist/enhancers/memoization/index.js",
+      "types": "./dist/enhancers/memoization/index.d.ts"
+    },
+    "./enhancers/time-travel": {
+      "import": "./dist/enhancers/time-travel/index.js",
+      "types": "./dist/enhancers/time-travel/index.d.ts"
+    },
+    "./enhancers/devtools": {
+      "import": "./dist/enhancers/devtools/index.js",
+      "types": "./dist/enhancers/devtools/index.d.ts"
+    },
+    "./enhancers/presets": {
+      "import": "./dist/enhancers/presets/index.js",
+      "types": "./dist/enhancers/presets/index.d.ts"
+    },
+    "./enhancers/entities": {
+      "import": "./dist/enhancers/entities/index.js",
+      "types": "./dist/enhancers/entities/index.d.ts"
+    },
+    "./enhancers/serialization": {
+      "import": "./dist/enhancers/serialization/index.js",
+      "types": "./dist/enhancers/serialization/index.d.ts"
     }
   },
+  "peerDependencies": {
+    "@angular/core": "^20.3.0",
+    "jest-preset-angular": "*",
+    "@rollup/plugin-commonjs": "*",
+    "@rollup/plugin-node-resolve": "*",
+    "@rollup/plugin-typescript": "*",
+    "rollup": "*",
+    "rollup-plugin-dts": "*",
+    "tslib": "*"
+  },
   "dependencies": {
-    "tslib": "^2.3.0"
+    "@signaltree/shared": "workspace:*"
   }
 }

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

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

package/src/enhancers/batching/index.js

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

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

@@ -0,0 +1,15 @@
+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/batching/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+    displayName: 'batching',
+    preset: '../../../../../jest.preset.js',
+    setupFilesAfterEnv: ['<rootDir>/test-setup.ts'],
+    coverageDirectory: '../../../../../coverage/packages/core/enhancers/batching',
+    transform: {
+        '^.+\\.(ts|mjs|js|html)$': [
+            'jest-preset-angular',
+            {
+                tsconfig: '<rootDir>/tsconfig.spec.json',
+                stringifyContentPathRegex: '\\.(html|svg)$',
+            },
+        ],
+    },
+    transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+    snapshotSerializers: [
+        'jest-preset-angular/build/serializers/no-ng-attributes',
+        'jest-preset-angular/build/serializers/ng-snapshot',
+        'jest-preset-angular/build/serializers/html-comment',
+    ],
+};

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

@@ -0,0 +1,16 @@
+import type { SignalTree } from '../../../lib/types';
+interface BatchingConfig {
+    enabled?: boolean;
+    maxBatchSize?: number;
+    autoFlushDelay?: number;
+    batchTimeoutMs?: number;
+}
+interface BatchingSignalTree<T> extends SignalTree<T> {
+    batchUpdate(updater: (current: T) => Partial<T>): void;
+}
+export declare function withBatching<T>(config?: BatchingConfig): (tree: SignalTree<T>) => BatchingSignalTree<T>;
+export declare function withHighPerformanceBatching<T>(): (tree: SignalTree<T>) => BatchingSignalTree<T>;
+export declare function flushBatchedUpdates(): void;
+export declare function hasPendingUpdates(): boolean;
+export declare function getBatchQueueSize(): number;
+export {};

package/src/enhancers/batching/lib/batching.js

@@ -0,0 +1,155 @@
+import { parsePath } from '@signaltree/shared';
+import { isNodeAccessor } from '../../../lib/utils';
+let updateQueue = [];
+let isUpdating = false;
+let flushTimeoutId;
+let currentBatchingConfig = {};
+function addToQueue(update, config = currentBatchingConfig) {
+    const maxSize = config.maxBatchSize ?? 100;
+    if (update.path) {
+        updateQueue = updateQueue.filter((existing) => existing.path !== update.path);
+    }
+    updateQueue.push(update);
+    if (updateQueue.length > maxSize) {
+        flushUpdates();
+        return true;
+    }
+    scheduleFlush(config);
+    return false;
+}
+function scheduleFlush(config) {
+    if (flushTimeoutId !== undefined) {
+        clearTimeout(flushTimeoutId);
+    }
+    const delay = config.autoFlushDelay ?? 16;
+    flushTimeoutId = setTimeout(() => {
+        flushUpdates();
+    }, delay);
+}
+function flushUpdates() {
+    if (isUpdating)
+        return;
+    let queue;
+    do {
+        if (updateQueue.length === 0)
+            return;
+        isUpdating = true;
+        queue = updateQueue;
+        updateQueue = [];
+        if (flushTimeoutId !== undefined) {
+            clearTimeout(flushTimeoutId);
+            flushTimeoutId = undefined;
+        }
+        queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
+        try {
+            queue.forEach(({ fn }) => fn());
+        }
+        finally {
+            isUpdating = false;
+        }
+    } while (updateQueue.length > 0);
+}
+function batchUpdates(fn, path) {
+    const startTime = performance.now();
+    const depth = path ? parsePath(path).length : 0;
+    const update = { fn, startTime, depth, path };
+    const wasFlushed = addToQueue(update, currentBatchingConfig);
+    if (!wasFlushed) {
+        const isTimedOut = currentBatchingConfig.batchTimeoutMs &&
+            updateQueue.length > 0 &&
+            startTime - updateQueue[0].startTime >=
+                currentBatchingConfig.batchTimeoutMs;
+        if (isTimedOut) {
+            flushUpdates();
+        }
+        else if (!isUpdating && updateQueue.length > 0) {
+            queueMicrotask(() => {
+                flushUpdates();
+            });
+        }
+    }
+}
+export function withBatching(config = {}) {
+    const { enabled = true } = config;
+    currentBatchingConfig = { ...currentBatchingConfig, ...config };
+    return (tree) => {
+        if (!enabled) {
+            return tree;
+        }
+        const originalTreeCall = tree.bind(tree);
+        const enhancedTree = function (...args) {
+            if (args.length === 0) {
+                return originalTreeCall();
+            }
+            else {
+                batchUpdates(() => {
+                    if (args.length === 1) {
+                        const arg = args[0];
+                        if (typeof arg === 'function') {
+                            originalTreeCall(arg);
+                        }
+                        else {
+                            originalTreeCall(arg);
+                        }
+                    }
+                });
+            }
+        };
+        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.batchUpdate = (updater) => {
+            batchUpdates(() => {
+                const current = originalTreeCall();
+                const updates = updater(current);
+                Object.entries(updates).forEach(([key, value]) => {
+                    const property = enhancedTree.state[key];
+                    if (property && 'set' in property) {
+                        property.set(value);
+                    }
+                    else if (isNodeAccessor(property)) {
+                        property(value);
+                    }
+                });
+            });
+        };
+        return enhancedTree;
+    };
+}
+export function withHighPerformanceBatching() {
+    return withBatching({
+        enabled: true,
+        maxBatchSize: 200,
+        batchTimeoutMs: 0,
+    });
+}
+export function flushBatchedUpdates() {
+    if (updateQueue.length > 0) {
+        const queue = updateQueue.slice();
+        updateQueue = [];
+        isUpdating = false;
+        queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
+        queue.forEach(({ fn }) => {
+            fn();
+        });
+    }
+}
+export function hasPendingUpdates() {
+    return updateQueue.length > 0;
+}
+export function getBatchQueueSize() {
+    return updateQueue.length;
+}

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

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

package/src/enhancers/batching/test-setup.js

@@ -0,0 +1,5 @@
+import { setupZoneTestEnv } from 'jest-preset-angular/setup-env/zone';
+setupZoneTestEnv({
+    errorOnUnknownElements: true,
+    errorOnUnknownProperties: true,
+});

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

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

package/src/enhancers/computed/index.js

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

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

@@ -0,0 +1,15 @@
+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/computed/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+    displayName: 'computed',
+    preset: '../../../jest.preset.js',
+    setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+    coverageDirectory: '../../../coverage/packages/core/enhancers/computed',
+    transform: {
+        '^.+\\.(ts|mjs|js|html)$': [
+            'jest-preset-angular',
+            {
+                tsconfig: '<rootDir>/tsconfig.spec.json',
+                stringifyContentPathRegex: '\\.(html|svg)$',
+            },
+        ],
+    },
+    transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+    snapshotSerializers: [
+        'jest-preset-angular/build/serializers/no-ng-attributes',
+        'jest-preset-angular/build/serializers/ng-snapshot',
+        'jest-preset-angular/build/serializers/html-comment',
+    ],
+};

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

@@ -0,0 +1,12 @@
+import { Signal } from '@angular/core';
+import type { TreeNode, SignalTree } from '../../../lib/types';
+export interface ComputedConfig {
+    lazy?: boolean;
+    memoize?: boolean;
+}
+export type ComputedSignal<T> = Signal<T>;
+export interface ComputedSignalTree<T extends Record<string, unknown>> extends SignalTree<T> {
+    computed<U>(computeFn: (tree: TreeNode<T>) => U): ComputedSignal<U>;
+}
+export declare function computedEnhancer(config?: ComputedConfig): import("../../../lib/types").EnhancerWithMeta<SignalTree<Record<string, unknown>>, ComputedSignalTree<Record<string, unknown>>>;
+export declare function createComputed<T>(dependencies: readonly Signal<unknown>[], computeFn: () => T): ComputedSignal<T>;

package/src/enhancers/computed/lib/computed.js

@@ -0,0 +1,18 @@
+import { computed } from '@angular/core';
+import { createEnhancer } from '../..';
+export function computedEnhancer(config = {}) {
+    return createEnhancer({
+        name: 'computed',
+        provides: ['computed'],
+        requires: [],
+    }, (tree) => {
+        const computedTree = tree;
+        computedTree.computed = function (computeFn) {
+            return computed(() => computeFn(tree.state));
+        };
+        return computedTree;
+    });
+}
+export function createComputed(dependencies, computeFn) {
+    return computed(computeFn);
+}

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

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

package/src/enhancers/devtools/index.js

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

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

@@ -0,0 +1,15 @@
+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/devtools/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+    displayName: 'devtools',
+    preset: '../../../jest.preset.js',
+    setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+    coverageDirectory: '../../../coverage/packages/core/enhancers/devtools',
+    transform: {
+        '^.+\\.(ts|mjs|js|html)$': [
+            'jest-preset-angular',
+            {
+                tsconfig: '<rootDir>/tsconfig.spec.json',
+                stringifyContentPathRegex: '\\.(html|svg)$',
+            },
+        ],
+    },
+    transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+    snapshotSerializers: [
+        'jest-preset-angular/build/serializers/no-ng-attributes',
+        'jest-preset-angular/build/serializers/ng-snapshot',
+        'jest-preset-angular/build/serializers/html-comment',
+    ],
+};

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

@@ -0,0 +1,77 @@
+import { Signal } from '@angular/core';
+import type { SignalTree } from '../../../lib/types';
+export interface ModuleMetadata {
+    name: string;
+    methods: string[];
+    addedAt: Date;
+    lastActivity: Date;
+    operationCount: number;
+    averageExecutionTime: number;
+    errorCount: number;
+}
+export interface ModularPerformanceMetrics {
+    totalUpdates: number;
+    moduleUpdates: Record<string, number>;
+    modulePerformance: Record<string, number>;
+    compositionChain: string[];
+    signalGrowth: Record<string, number>;
+    memoryDelta: Record<string, number>;
+    moduleCacheStats: Record<string, {
+        hits: number;
+        misses: number;
+    }>;
+}
+export interface ModuleActivityTracker {
+    trackMethodCall: (module: string, method: string, duration: number) => void;
+    trackError: (module: string, error: Error, context?: string) => void;
+    getModuleActivity: (module: string) => ModuleMetadata | undefined;
+    getAllModules: () => ModuleMetadata[];
+}
+export interface CompositionLogger {
+    logComposition: (modules: string[], action: 'with' | 'enhance') => void;
+    logMethodExecution: (module: string, method: string, args: unknown[], result: unknown) => void;
+    logStateChange: (module: string, path: string, oldValue: unknown, newValue: unknown) => void;
+    logPerformanceWarning: (module: string, operation: string, duration: number, threshold: number) => void;
+    exportLogs: () => Array<{
+        timestamp: Date;
+        module: string;
+        type: 'composition' | 'method' | 'state' | 'performance';
+        data: unknown;
+    }>;
+}
+export interface ModularDevToolsInterface<T = unknown> {
+    activityTracker: ModuleActivityTracker;
+    logger: CompositionLogger;
+    metrics: Signal<ModularPerformanceMetrics>;
+    trackComposition: (modules: string[]) => void;
+    startModuleProfiling: (module: string) => string;
+    endModuleProfiling: (profileId: string) => void;
+    connectDevTools: (treeName: string) => void;
+    exportDebugSession: () => {
+        metrics: ModularPerformanceMetrics;
+        modules: ModuleMetadata[];
+        logs: Array<unknown>;
+        compositionHistory: Array<{
+            timestamp: Date;
+            chain: string[];
+        }>;
+    };
+}
+export declare function withDevTools<T>(config?: {
+    enabled?: boolean;
+    treeName?: string;
+    enableBrowserDevTools?: boolean;
+    enableLogging?: boolean;
+    performanceThreshold?: number;
+}): (tree: SignalTree<T>) => SignalTree<T> & {
+    __devTools: ModularDevToolsInterface<T>;
+};
+export declare function enableDevTools<T>(treeName?: string): (tree: SignalTree<T>) => SignalTree<T> & {
+    __devTools: ModularDevToolsInterface<T>;
+};
+export declare function withFullDevTools<T>(treeName?: string): (tree: SignalTree<T>) => SignalTree<T> & {
+    __devTools: ModularDevToolsInterface<T>;
+};
+export declare function withProductionDevTools<T>(): (tree: SignalTree<T>) => SignalTree<T> & {
+    __devTools: ModularDevToolsInterface<T>;
+};