@signaltree/core 4.0.8 → 4.0.9

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

@@ -1,185 +0,0 @@
-/**
- * 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

@@ -1,170 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,262 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1 +0,0 @@
-{"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

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