@signaltree/core 3.0.2 → 3.1.0

package/src/enhancers/middleware/lib/middleware.js

@@ -0,0 +1,179 @@
+const middlewareMap = new WeakMap();
+export 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;
+                    }
+                }
+                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;
+    };
+}
+export 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();
+        },
+    };
+}
+export function createPerformanceMiddleware() {
+    return {
+        id: 'performance',
+        before: (action) => {
+            console.time(`Tree update: ${action}`);
+            return true;
+        },
+        after: (action) => {
+            console.timeEnd(`Tree update: ${action}`);
+        },
+    };
+}
+export 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 function createPersistenceMiddleware(config) {
+    const { key, storage = localStorage, debounceMs = 1000, actions = ['UPDATE', 'BATCH_UPDATE'], } = config;
+    let timeoutId;
+    const debouncedSave = (state) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            try {
+                storage.setItem(key, JSON.stringify(state));
+                console.log(`💾 State auto-saved to ${key}`);
+            }
+            catch (error) {
+                console.error('Failed to save state:', error);
+            }
+        }, debounceMs);
+    };
+    return {
+        id: 'persistence',
+        after: (action, payload, state, newState) => {
+            if (actions.includes(action)) {
+                debouncedSave(newState);
+            }
+        },
+    };
+}

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

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

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

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

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

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

package/src/enhancers/presets/index.js

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

package/src/enhancers/presets/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/presets/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+    displayName: 'presets',
+    preset: '../../../jest.preset.js',
+    setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+    coverageDirectory: '../../../coverage/packages/core/enhancers/presets',
+    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/presets/lib/presets.d.ts

@@ -0,0 +1,11 @@
+import type { TreeConfig } from '../../../lib/types';
+export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
+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 declare function createDevTree(overrides?: Partial<TreeConfig>): {
+    readonly config: TreeConfig;
+    readonly enhancer: (tree: unknown) => unknown;
+};

package/src/enhancers/presets/lib/presets.js

@@ -0,0 +1,102 @@
+import { composeEnhancers } from '../../../lib/utils';
+export const TREE_PRESETS = {
+    basic: {
+        batchUpdates: false,
+        useMemoization: false,
+        trackPerformance: false,
+        enableTimeTravel: false,
+        enableDevTools: false,
+        debugMode: false,
+    },
+    performance: {
+        batchUpdates: true,
+        useMemoization: true,
+        trackPerformance: false,
+        enableTimeTravel: false,
+        enableDevTools: false,
+        debugMode: false,
+        useShallowComparison: true,
+        maxCacheSize: 200,
+    },
+    development: {
+        batchUpdates: true,
+        useMemoization: true,
+        trackPerformance: true,
+        enableTimeTravel: true,
+        enableDevTools: true,
+        debugMode: true,
+        maxCacheSize: 100,
+    },
+    production: {
+        batchUpdates: true,
+        useMemoization: true,
+        trackPerformance: false,
+        enableTimeTravel: false,
+        enableDevTools: false,
+        debugMode: false,
+        useShallowComparison: true,
+        maxCacheSize: 200,
+    },
+};
+export function createPresetConfig(preset, overrides = {}) {
+    const baseConfig = TREE_PRESETS[preset];
+    return {
+        ...baseConfig,
+        ...overrides,
+    };
+}
+export function validatePreset(preset) {
+    if (!TREE_PRESETS[preset]) {
+        throw new Error(`Invalid preset: ${preset}. Valid presets are: ${Object.keys(TREE_PRESETS).join(', ')}`);
+    }
+    return true;
+}
+export function getAvailablePresets() {
+    return Object.keys(TREE_PRESETS);
+}
+export function combinePresets(presets, overrides = {}) {
+    let combined = {};
+    for (const preset of presets) {
+        validatePreset(preset);
+        combined = { ...combined, ...TREE_PRESETS[preset] };
+    }
+    return { ...combined, ...overrides };
+}
+export function createDevTree(overrides = {}) {
+    const config = createPresetConfig('development', overrides);
+    const enhancers = [];
+    function tryRequire(id) {
+        const maybeReq = globalThis.require;
+        if (typeof maybeReq !== 'function')
+            return undefined;
+        try {
+            return maybeReq(id);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    try {
+        const mod = tryRequire('@signaltree/devtools');
+        const withDevtools = mod && (mod.withDevtools ?? mod.withDevTools ?? mod.default ?? mod);
+        if (typeof withDevtools === 'function')
+            enhancers.push(withDevtools);
+    }
+    catch (e) {
+        void e;
+    }
+    try {
+        const mod = tryRequire('@signaltree/time-travel');
+        const withTimeTravel = mod && (mod.withTimeTravel ?? mod.default ?? mod);
+        if (typeof withTimeTravel === 'function')
+            enhancers.push(withTimeTravel);
+    }
+    catch (e) {
+        void e;
+    }
+    const composed = composeEnhancers(...enhancers);
+    return {
+        config,
+        enhancer: composed,
+    };
+}

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

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

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

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

package/src/enhancers/serialization/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const TYPE_MARKERS: {
+    readonly DATE: "§d";
+    readonly REGEXP: "§r";
+    readonly MAP: "§m";
+    readonly SET: "§s";
+    readonly UNDEFINED: "§u";
+    readonly NAN: "§n";
+    readonly INFINITY: "§i";
+    readonly NEG_INFINITY: "§-i";
+    readonly BIGINT: "§b";
+    readonly SYMBOL: "§y";
+    readonly FUNCTION: "§f";
+    readonly CIRCULAR: "§c";
+};

package/src/enhancers/serialization/constants.js

@@ -0,0 +1,14 @@
+export const TYPE_MARKERS = {
+    DATE: '§d',
+    REGEXP: '§r',
+    MAP: '§m',
+    SET: '§s',
+    UNDEFINED: '§u',
+    NAN: '§n',
+    INFINITY: '§i',
+    NEG_INFINITY: '§-i',
+    BIGINT: '§b',
+    SYMBOL: '§y',
+    FUNCTION: '§f',
+    CIRCULAR: '§c',
+};

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

@@ -0,0 +1,2 @@
+export * from './lib/serialization';
+export * from './constants';

package/src/enhancers/serialization/index.js

@@ -0,0 +1,2 @@
+export * from './lib/serialization';
+export * from './constants';

package/src/enhancers/serialization/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/serialization/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+    displayName: 'serialization',
+    preset: '../../../jest.preset.js',
+    setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+    coverageDirectory: '../../../coverage/packages/core/enhancers/serialization',
+    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/serialization/lib/serialization.d.ts

@@ -0,0 +1,59 @@
+import type { SignalTree } from '../../../lib/types';
+import type { EnhancerWithMeta } from '../../../lib/types';
+export interface SerializationConfig {
+    includeMetadata?: boolean;
+    replacer?: (key: string, value: unknown) => unknown;
+    reviver?: (key: string, value: unknown) => unknown;
+    preserveTypes?: boolean;
+    maxDepth?: number;
+    handleCircular?: boolean;
+}
+export interface SerializedState<T = unknown> {
+    data: T;
+    metadata?: {
+        timestamp: number;
+        version: string;
+        appVersion?: string;
+        types?: Record<string, string>;
+        circularRefs?: Array<{
+            path: string;
+            targetPath: string;
+        }>;
+        nodeMap?: Record<string, 'b' | 'r'>;
+    };
+}
+export interface SerializableSignalTree<T> extends SignalTree<T> {
+    $: any;
+    serialize(config?: SerializationConfig): string;
+    deserialize(json: string, config?: SerializationConfig): void;
+    toJSON(): T;
+    fromJSON(data: T, metadata?: SerializedState<T>['metadata']): void;
+    snapshot(): SerializedState<T>;
+    restore(snapshot: SerializedState<T>): void;
+}
+export interface PersistenceMethods {
+    save(): Promise<void>;
+    load(): Promise<void>;
+    clear(): Promise<void>;
+    __flushAutoSave?: () => Promise<void>;
+}
+export declare function withSerialization<T extends Record<string, unknown> = Record<string, unknown>>(defaultConfig?: SerializationConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
+export declare function enableSerialization<T extends Record<string, unknown> = Record<string, unknown>>(): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
+export interface StorageAdapter {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+export interface PersistenceConfig extends SerializationConfig {
+    key: string;
+    storage?: StorageAdapter;
+    autoSave?: boolean;
+    debounceMs?: number;
+    autoLoad?: boolean;
+    skipCache?: boolean;
+}
+export declare function withPersistence<T extends Record<string, unknown> = Record<string, unknown>>(config: PersistenceConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T> & PersistenceMethods>;
+export declare function createStorageAdapter(getItem: (key: string) => string | null | Promise<string | null>, setItem: (key: string, value: string) => void | Promise<void>, removeItem: (key: string) => void | Promise<void>): StorageAdapter;
+export declare function createIndexedDBAdapter(dbName?: string, storeName?: string): StorageAdapter;
+export declare function applySerialization<T extends Record<string, unknown>>(tree: SignalTree<T>): SerializableSignalTree<T>;
+export declare function applyPersistence<T extends Record<string, unknown>>(tree: SignalTree<T>, cfg: PersistenceConfig): SerializableSignalTree<T> & PersistenceMethods;