@signaltree/core 4.0.7 → 4.0.8

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

@@ -0,0 +1,185 @@
+/**
+ * Security validator for SignalTree to prevent common vulnerabilities
+ * @packageDocumentation
+ */
+/**
+ * Security event types for monitoring and logging
+ */
+type SecurityEventType = 'dangerous-key-blocked' | 'xss-attempt-blocked' | 'function-value-blocked' | 'validation-error';
+/**
+ * Security event callback signature
+ */
+interface SecurityEvent {
+    type: SecurityEventType;
+    key?: string;
+    value?: unknown;
+    reason: string;
+    timestamp: number;
+}
+/**
+ * Configuration options for SecurityValidator
+ */
+interface SecurityValidatorConfig {
+    /**
+     * Enable prototype pollution prevention (default: true)
+     */
+    preventPrototypePollution?: boolean;
+    /**
+     * Enable XSS sanitization (default: false)
+     * When enabled, string values are sanitized to prevent script injection
+     */
+    preventXSS?: boolean;
+    /**
+     * Reject function values to ensure serializable state (default: true)
+     * Functions cannot be serialized and break time-travel, persistence, etc.
+     * This is ALWAYS enforced with no escape hatch to guarantee state serializability.
+     */
+    preventFunctions?: boolean;
+    /**
+     * Additional dangerous keys to block beyond the built-in list
+     */
+    customDangerousKeys?: string[];
+    /**
+     * Callback for security events (for logging/monitoring)
+     */
+    onSecurityEvent?: (event: SecurityEvent) => void;
+    /**
+     * Sanitization mode: 'strict' removes all HTML, 'permissive' allows safe HTML
+     * (default: 'strict')
+     */
+    sanitizationMode?: 'strict' | 'permissive';
+}
+
+/**
+ * SignalTree Core Types v2.0.2
+ * MIT License - Copyright (c) 2025 Jonathan D Borgia
+ */
+/**
+ * Helper type preventing ambiguity when a node itself stores a function value.
+ * In that case direct callable set(fn) would clash with the update(fn) signature.
+ * We exclude raw function values from the direct-set overload so users must use .set(fn)
+ * (after transform) instead of callable form, while updater form still works.
+ */
+type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
+/**
+ * Augment Angular's WritableSignal to support callable syntax for DX.
+ * This is purely TypeScript-level - the transform converts these calls to .set/.update
+ */
+declare module '@angular/core' {
+    interface WritableSignal<T> {
+        (value: NotFn<T>): void;
+        (updater: (current: T) => T): void;
+    }
+}
+interface TreeConfig {
+    batchUpdates?: boolean;
+    useMemoization?: boolean;
+    enableTimeTravel?: boolean;
+    useLazySignals?: boolean;
+    useShallowComparison?: boolean;
+    maxCacheSize?: number;
+    trackPerformance?: boolean;
+    treeName?: string;
+    enableDevTools?: boolean;
+    debugMode?: boolean;
+    useStructuralSharing?: boolean;
+    /**
+     * Security validation configuration
+     * When enabled, validates keys and values during tree construction and updates
+     * to prevent prototype pollution, XSS, and function values.
+     *
+     * @default undefined (no security validation)
+     * @see SecurityValidator for configuration options
+     *
+     * @example
+     * ```ts
+     * // Enable all security features
+     * const tree = signalTree(state, {
+     *   security: {
+     *     preventPrototypePollution: true,
+     *     preventXSS: true,
+     *     preventFunctions: true,
+     *     onSecurityEvent: (event) => console.warn('Security event:', event)
+     *   }
+     * });
+     *
+     * // Or use a preset
+     * import { SecurityPresets } from '@signaltree/core';
+     * const tree = signalTree(state, {
+     *   security: SecurityPresets.strict().getConfig()
+     * });
+     * ```
+     */
+    security?: SecurityValidatorConfig;
+}
+
+type TreePreset = 'basic' | 'performance' | 'development' | 'production';
+/**
+ * Pre-configured SignalTree configurations for common use cases.
+ *
+ * - **basic**: Minimal configuration with no advanced features
+ * - **performance**: Optimized for speed with batching and memoization
+ * - **development**: Full debugging features including time-travel and devtools
+ * - **production**: Optimized for production with performance features only
+ */
+declare const TREE_PRESETS: Record<TreePreset, Partial<TreeConfig>>;
+/**
+ * Helper function to create a tree configuration from a preset.
+ * Can be used to start with a preset and then customize specific options.
+ *
+ * @param preset - The preset name to use as a base
+ * @param overrides - Optional overrides to apply on top of the preset
+ * @returns Complete tree configuration
+ *
+ * @example
+ * ```typescript
+ * // Use development preset with custom tree name
+ * const config = createPresetConfig('development', { treeName: 'MyApp' });
+ *
+ * // Use performance preset but enable debug mode
+ * const debugPerf = createPresetConfig('performance', { debugMode: true });
+ * ```
+ */
+declare function createPresetConfig(preset: TreePreset, overrides?: Partial<TreeConfig>): TreeConfig;
+/**
+ * Validates that a preset configuration is valid.
+ * Useful for development-time checks.
+ *
+ * @param preset - The preset to validate
+ * @returns True if valid, throws error if invalid
+ */
+declare function validatePreset(preset: TreePreset): boolean;
+/**
+ * Gets the list of available preset names.
+ *
+ * @returns Array of preset names
+ */
+declare function getAvailablePresets(): TreePreset[];
+/**
+ * Creates a custom preset by combining multiple existing presets.
+ * Later presets in the array take precedence over earlier ones.
+ *
+ * @param presets - Array of presets to combine
+ * @param overrides - Optional final overrides
+ * @returns Combined configuration
+ *
+ * @example
+ * ```typescript
+ * // Combine basic preset with some performance features
+ * const config = combinePresets(['basic', 'performance'], { enableDevTools: true });
+ * ```
+ */
+declare function combinePresets(presets: TreePreset[], overrides?: Partial<TreeConfig>): TreeConfig;
+/**
+ * Convenience helper for creating a development-ready SignalTree.
+ * Composes dev-only enhancers (devtools, time-travel, async) into a single
+ * enhancer function that can be applied to a tree. This keeps packages
+ * independent while offering a one-line dev onboarding.
+ */
+declare function createDevTree(overrides?: Partial<TreeConfig>): {
+    readonly config: TreeConfig;
+    readonly enhancer: (tree: unknown) => unknown;
+};
+
+export { TREE_PRESETS, combinePresets, createDevTree, createPresetConfig, getAvailablePresets, validatePreset };
+export type { TreePreset };

package/dist/enhancers/presets/index.js

@@ -0,0 +1,170 @@
+import '@angular/core';
+import '@signaltree/shared';
+
+function composeEnhancers(...enhancers) {
+    return (tree) => enhancers.reduce((t, e) => e(t), tree);
+}
+
+/**
+ * Pre-configured SignalTree configurations for common use cases.
+ *
+ * - **basic**: Minimal configuration with no advanced features
+ * - **performance**: Optimized for speed with batching and memoization
+ * - **development**: Full debugging features including time-travel and devtools
+ * - **production**: Optimized for production with performance features only
+ */
+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,
+    },
+};
+/**
+ * Helper function to create a tree configuration from a preset.
+ * Can be used to start with a preset and then customize specific options.
+ *
+ * @param preset - The preset name to use as a base
+ * @param overrides - Optional overrides to apply on top of the preset
+ * @returns Complete tree configuration
+ *
+ * @example
+ * ```typescript
+ * // Use development preset with custom tree name
+ * const config = createPresetConfig('development', { treeName: 'MyApp' });
+ *
+ * // Use performance preset but enable debug mode
+ * const debugPerf = createPresetConfig('performance', { debugMode: true });
+ * ```
+ */
+function createPresetConfig(preset, overrides = {}) {
+    const baseConfig = TREE_PRESETS[preset];
+    return {
+        ...baseConfig,
+        ...overrides,
+    };
+}
+/**
+ * Validates that a preset configuration is valid.
+ * Useful for development-time checks.
+ *
+ * @param preset - The preset to validate
+ * @returns True if valid, throws error if invalid
+ */
+function validatePreset(preset) {
+    if (!TREE_PRESETS[preset]) {
+        throw new Error(`Invalid preset: ${preset}. Valid presets are: ${Object.keys(TREE_PRESETS).join(', ')}`);
+    }
+    return true;
+}
+/**
+ * Gets the list of available preset names.
+ *
+ * @returns Array of preset names
+ */
+function getAvailablePresets() {
+    return Object.keys(TREE_PRESETS);
+}
+/**
+ * Creates a custom preset by combining multiple existing presets.
+ * Later presets in the array take precedence over earlier ones.
+ *
+ * @param presets - Array of presets to combine
+ * @param overrides - Optional final overrides
+ * @returns Combined configuration
+ *
+ * @example
+ * ```typescript
+ * // Combine basic preset with some performance features
+ * const config = combinePresets(['basic', 'performance'], { enableDevTools: true });
+ * ```
+ */
+function combinePresets(presets, overrides = {}) {
+    let combined = {};
+    for (const preset of presets) {
+        validatePreset(preset);
+        combined = { ...combined, ...TREE_PRESETS[preset] };
+    }
+    return { ...combined, ...overrides };
+}
+/**
+ * Convenience helper for creating a development-ready SignalTree.
+ * Composes dev-only enhancers (devtools, time-travel, async) into a single
+ * enhancer function that can be applied to a tree. This keeps packages
+ * independent while offering a one-line dev onboarding.
+ */
+function createDevTree(overrides = {}) {
+    const config = createPresetConfig('development', overrides);
+    // Compose enhancers in a predictable left-to-right order. We import the
+    // enhancers lazily so consumers who don't install dev packages won't fail at
+    // module-eval time.
+    const enhancers = [];
+    // Helper to access CommonJS-style require at runtime without forcing Node types
+    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) {
+    }
+    try {
+        const mod = tryRequire('@signaltree/time-travel');
+        const withTimeTravel = mod && (mod.withTimeTravel ?? mod.default ?? mod);
+        if (typeof withTimeTravel === 'function')
+            enhancers.push(withTimeTravel);
+    }
+    catch (e) {
+    }
+    const composed = composeEnhancers(...enhancers);
+    return {
+        config,
+        enhancer: composed,
+    };
+}
+
+export { TREE_PRESETS, combinePresets, createDevTree, createPresetConfig, getAvailablePresets, validatePreset };
+//# sourceMappingURL=index.js.map

package/dist/enhancers/presets/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../packages/core/src/lib/utils.ts","../../../../../../../packages/core/src/enhancers/presets/lib/presets.ts"],"sourcesContent":[null,null],"names":[],"mappings":"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"}

package/dist/enhancers/presets/types/packages/core/src/enhancers/batching/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/batching';
+//# sourceMappingURL=index.d.ts.map

package/dist/enhancers/presets/types/packages/core/src/enhancers/batching/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/enhancers/presets/types/packages/core/src/enhancers/batching/jest.config.d.ts

@@ -0,0 +1,16 @@
+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;
+//# sourceMappingURL=jest.config.d.ts.map

package/dist/enhancers/presets/types/packages/core/src/enhancers/batching/jest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/jest.config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,wBAoBE"}

package/dist/enhancers/presets/types/packages/core/src/enhancers/batching/lib/batching.d.ts

@@ -0,0 +1,262 @@
+import type { SignalTree } from '../../../lib/types';
+/**
+ * Configuration options for intelligent batching behavior.
+ * Controls how updates are grouped and processed for optimal performance.
+ * Uses unconstrained recursive typing - no limitations on T
+ *
+ * @example
+ * ```typescript
+ * const config: BatchingConfig = {
+ *   enabled: true,
+ *   maxBatchSize: 50,
+ *   autoFlushDelay: 16, // 60fps
+ *   batchTimeoutMs: 100
+ * };
+ * ```
+ */
+interface BatchingConfig {
+    /** Whether batching is enabled (default: true) */
+    enabled?: boolean;
+    /** Maximum number of updates per batch (default: 100) */
+    maxBatchSize?: number;
+    /** Delay before auto-flushing batch in milliseconds (default: 16) */
+    autoFlushDelay?: number;
+    /** Maximum time to wait before forcing batch flush (default: 100) */
+    batchTimeoutMs?: number;
+}
+/**
+ * Enhanced SignalTree interface with intelligent batching capabilities.
+ * Provides high-performance batch update methods that group multiple state changes.
+ *
+ * @template T - The state object type extending StateObject
+ *
+ * @example
+ * ```typescript
+ * interface AppState {
+ *   users: User[];
+ *   ui: { loading: boolean; error: string | null };
+ *   stats: { total: number; active: number };
+ * }
+ *
+ * const tree: BatchingSignalTree<AppState> = create(initialState)
+ *   .with(withBatching());
+ *
+ * // Batch multiple related updates
+ * tree.batchUpdate((state) => ({
+ *   users: [...state.users, newUser],
+ *   ui: { ...state.ui, loading: false },
+ *   stats: {
+ *     total: state.users.length + 1,
+ *     active: state.users.filter(u => u.active).length + (newUser.active ? 1 : 0)
+ *   }
+ * }));
+ * Uses unconstrained recursive typing - no limitations on T
+ * ```
+ */
+interface BatchingSignalTree<T> extends SignalTree<T> {
+    /**
+     * Batches multiple state updates into a single change cycle for optimal performance.
+     * Groups related updates to prevent UI thrashing and improve rendering efficiency.
+     *
+     * @param updater - Function that receives current state and returns partial update
+     *
+     * @example
+     * ```typescript
+     * // Instead of multiple individual updates
+     * tree.update(() => ({ loading: true }));
+     * tree.update(() => ({ error: null }));
+     * tree.update(() => ({ users: [] }));
+     *
+     * // Use a single batched update
+     * tree.batchUpdate((state) => ({
+     *   loading: true,
+     *   error: null,
+     *   users: []
+     * }));
+     * ```
+     */
+    batchUpdate(updater: (current: T) => Partial<T>): void;
+}
+/**
+ * Enhances a SignalTree with intelligent batching capabilities for optimal performance.
+ * Automatically groups rapid state updates into efficient batch cycles to eliminate UI thrashing.
+ *
+ * @template T - The state object type extending StateObject
+ * @param config - Configuration options for batching behavior
+ * @returns Function that enhances a SignalTree with batching capabilities
+ *
+ * @example
+ * ```typescript
+ * // Basic batching with default settings
+ * const tree = create(initialState).with(withBatching());
+ *
+ * // High-performance batching for demanding applications
+ * const tree = create(initialState).with(withBatching({
+ *   maxBatchSize: 50,
+ *   autoFlushDelay: 8, // ~120fps
+ *   batchTimeoutMs: 50
+ * }));
+ *
+ * // Conservative batching for stable UIs
+ * const tree = create(initialState).with(withBatching({
+ *   maxBatchSize: 10,
+ *   autoFlushDelay: 100,
+ *   batchTimeoutMs: 200
+ * }));
+ *
+ * // Use batching methods
+ * tree.batchUpdate((state) => ({
+ *   users: [...state.users, newUser],
+ *   loading: false,
+ *   error: null
+ * }));
+ * Uses unconstrained recursive typing - no limitations on T
+ * ```
+ */
+export declare function withBatching<T>(config?: BatchingConfig): (tree: SignalTree<T>) => BatchingSignalTree<T>;
+/**
+ * Convenience function to enable batching with default settings.
+ * Equivalent to withBatching({ enabled: true }) but more concise for common usage.
+ *
+ * @template T - The state object type extending StateObject
+ * @returns Function that enhances a SignalTree with default batching settings
+ *
+ * @example
+ * ```typescript
+ * // Simple batching enablement
+ * const tree = create(initialState).with(enableBatching());
+ *
+ * // Equivalent to:
+ * const tree = create(initialState).with(withBatching({ enabled: true }));
+ * Uses unconstrained recursive typing - no limitations on T
+ * ```
+ */
+/**
+ * Creates high-performance batching configuration optimized for demanding applications.
+ * Uses aggressive batching settings for maximum performance in high-frequency update scenarios.
+ * Uses unconstrained recursive typing - no limitations on T
+ *
+ * @template T - The state object type extending StateObject
+ * @returns Function that enhances a SignalTree with high-performance batching
+ *
+ * @example
+ * ```typescript
+ * // For performance-critical applications
+ * const gameTree = create(gameState).with(withHighPerformanceBatching());
+ *
+ * // Perfect for:
+ * // - Real-time games
+ * // - High-frequency data updates
+ * // - Animation-heavy UIs
+ * // - Large dataset operations
+ *
+ * // Automatically includes:
+ * // - Large batch sizes (200 updates)
+ * // - Immediate processing (0ms timeout)
+ * // - Aggressive optimization
+ * Uses unconstrained recursive typing - no limitations on T
+ * ```
+ */
+export declare function withHighPerformanceBatching<T>(): (tree: SignalTree<T>) => BatchingSignalTree<T>;
+/**
+ * Manually flushes all pending batched updates immediately.
+ * Forces synchronous execution of queued updates, bypassing normal batching delays.
+ * Useful for testing scenarios or when immediate state consistency is required.
+ *
+ * @example
+ * ```typescript
+ * // Queue some updates
+ * tree.batchUpdate(() => ({ count: 1 }));
+ * tree.batchUpdate(() => ({ name: 'test' }));
+ *
+ * // In tests, ensure updates are applied immediately
+ * flushBatchedUpdates();
+ * expect(tree().count).toBe(1);
+ * expect(tree().name).toBe('test');
+ *
+ * // Before critical operations that need current state
+ * flushBatchedUpdates();
+ * const currentState = tree(); // Guaranteed to be up-to-date
+ *
+ * // In animation frames for precise timing
+ * requestAnimationFrame(() => {
+ *   flushBatchedUpdates(); // Ensure updates are applied before render
+ *   updateUI();
+ * });
+ * ```
+ */
+export declare function flushBatchedUpdates(): void;
+/**
+ * Checks if there are pending batched updates waiting to be processed.
+ * Useful for testing, debugging, or conditional logic based on update queue state.
+ *
+ * @returns True if updates are queued, false if queue is empty
+ *
+ * @example
+ * ```typescript
+ * // Check before critical operations
+ * tree.batchUpdate(() => ({ loading: true }));
+ *
+ * if (hasPendingUpdates()) {
+ *   console.log('Updates are queued for processing');
+ *   flushBatchedUpdates(); // Process them now if needed
+ * }
+ *
+ * // In testing
+ * tree.batchUpdate(() => ({ count: 1 }));
+ * expect(hasPendingUpdates()).toBe(true);
+ *
+ * flushBatchedUpdates();
+ * expect(hasPendingUpdates()).toBe(false);
+ *
+ * // Conditional behavior
+ * function performCriticalOperation() {
+ *   if (hasPendingUpdates()) {
+ *     flushBatchedUpdates(); // Ensure consistent state
+ *   }
+ *   // Proceed with operation
+ * }
+ * ```
+ */
+export declare function hasPendingUpdates(): boolean;
+/**
+ * Gets the current number of updates waiting in the batch queue.
+ * Useful for performance monitoring, debugging, and batch size optimization.
+ *
+ * @returns Number of queued updates
+ *
+ * @example
+ * ```typescript
+ * // Performance monitoring
+ * function monitorBatchPerformance() {
+ *   const queueSize = getBatchQueueSize();
+ *
+ *   if (queueSize > 50) {
+ *     console.warn(`Large batch queue detected: ${queueSize} updates`);
+ *   }
+ *
+ *   // Log metrics
+ *   console.log(`Current queue size: ${queueSize}`);
+ * }
+ *
+ * // Debug batching behavior
+ * tree.batchUpdate(() => ({ a: 1 }));
+ * tree.batchUpdate(() => ({ b: 2 }));
+ * tree.batchUpdate(() => ({ c: 3 }));
+ *
+ * console.log(`Queue size: ${getBatchQueueSize()}`); // 3
+ *
+ * flushBatchedUpdates();
+ * console.log(`Queue size after flush: ${getBatchQueueSize()}`); // 0
+ *
+ * // Optimize batch configuration
+ * const currentQueueSize = getBatchQueueSize();
+ * if (currentQueueSize > 100) {
+ *   // Consider reducing maxBatchSize or autoFlushDelay
+ *   console.log('Consider optimizing batch configuration');
+ * }
+ * ```
+ */
+export declare function getBatchQueueSize(): number;
+export {};
+//# sourceMappingURL=batching.d.ts.map

package/dist/enhancers/presets/types/packages/core/src/enhancers/batching/lib/batching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batching.d.ts","sourceRoot":"","sources":["../../../../../../../../src/enhancers/batching/lib/batching.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;GAcG;AACH,UAAU,cAAc;IACtB,kDAAkD;IAClD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,UAAU,kBAAkB,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;IACnD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAAW,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CACxD;AA4JD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,GAAE,cAAmB,GAC1B,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,kBAAkB,CAAC,CAAC,CAAC,CAgFhD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,oDAM5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAc1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/enhancers/presets/types/packages/core/src/enhancers/batching/test-setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/enhancers/presets/types/packages/core/src/enhancers/batching/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/test-setup.ts"],"names":[],"mappings":""}

package/dist/enhancers/presets/types/packages/core/src/enhancers/computed/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/computed';
+//# sourceMappingURL=index.d.ts.map

package/dist/enhancers/presets/types/packages/core/src/enhancers/computed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/computed/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/enhancers/presets/types/packages/core/src/enhancers/computed/jest.config.d.ts

@@ -0,0 +1,16 @@
+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;
+//# sourceMappingURL=jest.config.d.ts.map