@signaltree/core 3.0.2 → 4.0.1

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

@@ -0,0 +1,302 @@
+import { WritableSignal, Signal } from '@angular/core';
+
+/**
+ * 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;
+    }
+}
+/**
+ * Built-in object types that should be treated as primitive values
+ * (Keep this list in sync with runtime isBuiltInObject)
+ */
+type BuiltInObject = Date | RegExp | ((...args: unknown[]) => unknown) | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView | Error | Promise<unknown> | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | URL | URLSearchParams | FormData | Blob | File | Headers | Request | Response | AbortController | AbortSignal;
+/**
+ * Node accessor interface - unified API for get/set/update via function calls.
+ * Overloads:
+ *  (): T                     - getter
+ *  (value: NotFn<T>): void   - direct set (blocked when T is itself a function)
+ *  (updater: (T)=>T): void   - functional update
+ */
+interface NodeAccessor<T> {
+    (): T;
+    (value: T): void;
+    (updater: (current: T) => T): void;
+}
+/**
+ * Signalified node with callable interface
+ */
+type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
+/**
+ * Deep signalification type - converts object properties to signals recursively
+ * - Leaves (primitives, arrays, functions, built-ins): Raw Angular WritableSignal<T>
+ * - Nested objects: NodeAccessor<T> (callable) + recursive TreeNode<T> properties
+ */
+type CallableWritableSignal<T> = WritableSignal<T> & {
+    (value: NotFn<T>): void;
+    (updater: (current: T) => T): void;
+};
+type TreeNode<T> = {
+    [K in keyof T]: T[K] extends readonly unknown[] ? CallableWritableSignal<T[K]> : T[K] extends object ? T[K] extends Signal<unknown> ? T[K] : T[K] extends BuiltInObject ? CallableWritableSignal<T[K]> : T[K] extends (...args: unknown[]) => unknown ? CallableWritableSignal<T[K]> : AccessibleNode<T[K]> : CallableWritableSignal<T[K]>;
+};
+/** Enhancer metadata for optional auto-ordering */
+interface EnhancerMeta {
+    name?: string;
+    requires?: string[];
+    provides?: string[];
+}
+/** Enhancer function that may carry metadata */
+type Enhancer<Input = unknown, Output = unknown> = (input: Input) => Output;
+/** Enhancer with optional metadata attached */
+type EnhancerWithMeta<Input = unknown, Output = unknown> = Enhancer<Input, Output> & {
+    metadata?: EnhancerMeta;
+};
+/**
+ * Simplified overload set for .with() method
+ * Reduced from 20+ complex overloads to basic patterns that TypeScript can infer.
+ * For complex enhancer chains, use applyEnhancer() helper or type assertions.
+ */
+interface WithMethod<T> {
+    (): SignalTree<T>;
+    <O>(enhancer: (input: SignalTree<T>) => O): O;
+    <O1, O2>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2): O2;
+    <O1, O2, O3>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2, e3: (input: O2) => O3): O3;
+    <O>(enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;
+    <O1, O2>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>): O2;
+    <O1, O2, O3>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>): O3;
+}
+/**
+ * Main SignalTree type with all methods
+ */
+type SignalTree<T> = NodeAccessor<T> & {
+    /** The reactive state object */
+    state: TreeNode<T>;
+    /** Shorthand alias for state */
+    $: TreeNode<T>;
+    /** Core methods */
+    with: WithMethod<T>;
+    destroy(): void;
+    /**
+     * Dispose of the signal tree and clean up memory resources.
+     * Only available when using lazy signals (useLazySignals: true).
+     *
+     * This method:
+     * - Clears the memory manager cache (releases WeakRef references)
+     * - Calls the cleanup function on the lazy proxy
+     * - Allows garbage collection of unused signals
+     *
+     * @example
+     * ```typescript
+     * const tree = signalTree({ users: largeUserList }, { useLazySignals: true });
+     * // ... use tree
+     * tree.dispose(); // Clean up when done
+     * ```
+     */
+    dispose?(): void;
+    /** Enhanced functionality */
+    effect(fn: (tree: T) => void): void;
+    subscribe(fn: (tree: T) => void): () => void;
+    batch(updater: (tree: T) => void): void;
+    batchUpdate(updater: (current: T) => Partial<T>): void;
+    memoize<R>(fn: (tree: T) => R, cacheKey?: string): Signal<R>;
+    memoizedUpdate(updater: (current: T) => Partial<T>, cacheKey?: string): void;
+    clearMemoCache(key?: string): void;
+    getCacheStats(): {
+        size: number;
+        hitRate: number;
+        totalHits: number;
+        totalMisses: number;
+        keys: string[];
+    };
+    /** Performance methods */
+    optimize(): void;
+    clearCache(): void;
+    invalidatePattern(pattern: string): number;
+    /**
+     * Optimized update using diff-based patching and batching.
+     * Only updates signals that actually changed, providing significant
+     * performance improvements for large trees and partial updates.
+     *
+     * @param updates - Partial updates to apply
+     * @param options - Update options (batching, equality, etc.)
+     * @returns Update result with performance metrics
+     *
+     * @example
+     * ```typescript
+     * const tree = signalTree({ users: largeUserList });
+     *
+     * // Only updates what changed
+     * const result = tree.updateOptimized({
+     *   users: { 0: { name: 'Updated' } }
+     * });
+     *
+     * console.log(result.changedPaths); // ['users.0.name']
+     * console.log(result.duration); // ~2ms
+     * ```
+     */
+    updateOptimized?(updates: Partial<T>, options?: {
+        batch?: boolean;
+        batchSize?: number;
+        maxDepth?: number;
+        ignoreArrayOrder?: boolean;
+        equalityFn?: (a: unknown, b: unknown) => boolean;
+    }): {
+        changed: boolean;
+        duration: number;
+        changedPaths: string[];
+        stats?: {
+            totalPaths: number;
+            optimizedPaths: number;
+            batchedUpdates: number;
+        };
+    };
+    getMetrics(): PerformanceMetrics;
+    /** Middleware */
+    addTap(middleware: Middleware<T>): void;
+    removeTap(id: string): void;
+    /** Entity helpers */
+    entities<E extends {
+        id: string | number;
+    }>(entityKey?: keyof T): EntityHelpers<E>;
+    /** Async actions */
+    asyncAction<TInput, TResult>(operation: (input: TInput) => Promise<TResult>, config?: AsyncActionConfig<T, TResult>): AsyncAction<TInput, TResult>;
+    /** Time travel */
+    undo(): void;
+    redo(): void;
+    getHistory(): TimeTravelEntry<T>[];
+    resetHistory(): void;
+    jumpTo?: (index: number) => void;
+    canUndo?: () => boolean;
+    canRedo?: () => boolean;
+    getCurrentIndex?: () => number;
+    /** Index signature for enhancer compatibility */
+    [key: string]: unknown;
+};
+interface Middleware<T> {
+    id: string;
+    before?: (action: string, payload: unknown, state: T) => boolean;
+    after?: (action: string, payload: unknown, state: T, newState: T) => void;
+}
+interface PerformanceMetrics {
+    updates: number;
+    computations: number;
+    cacheHits: number;
+    cacheMisses: number;
+    averageUpdateTime: number;
+}
+interface EntityHelpers<E extends {
+    id: string | number;
+}> {
+    add(entity: E): void;
+    update(id: E['id'], updates: Partial<E>): void;
+    remove(id: E['id']): void;
+    upsert(entity: E): void;
+    selectById(id: E['id']): Signal<E | undefined>;
+    selectBy(predicate: (entity: E) => boolean): Signal<E[]>;
+    selectIds(): Signal<Array<string | number>>;
+    selectAll(): Signal<E[]>;
+    selectTotal(): Signal<number>;
+    clear(): void;
+}
+interface AsyncActionConfig<T, TResult> {
+    onStart?: (state: T) => Partial<T>;
+    onSuccess?: (result: TResult, state: T) => Partial<T>;
+    onError?: (error: Error, state: T) => Partial<T>;
+    onComplete?: (state: T) => Partial<T>;
+}
+interface AsyncAction<TInput, TResult> {
+    execute(input: TInput): Promise<TResult>;
+    pending: Signal<boolean>;
+    error: Signal<Error | null>;
+    result: Signal<TResult | null>;
+}
+interface TimeTravelEntry<T> {
+    action: string;
+    timestamp: number;
+    state: T;
+    payload?: unknown;
+}
+
+/**
+ * Configuration for the computed enhancer
+ */
+interface ComputedConfig {
+    /** Whether to enable lazy evaluation */
+    lazy?: boolean;
+    /** Whether to memoize computed values */
+    memoize?: boolean;
+}
+/**
+ * Computed signal type for derived state
+ */
+type ComputedSignal<T> = Signal<T>;
+/**
+ * Extended SignalTree with computed signal capabilities
+ */
+interface ComputedSignalTree<T extends Record<string, unknown>> extends SignalTree<T> {
+    /**
+     * Create a computed signal from the current tree state
+     * @param computeFn Function that computes the derived value
+     * @returns A computed signal that updates when dependencies change
+     */
+    computed<U>(computeFn: (tree: TreeNode<T>) => U): ComputedSignal<U>;
+}
+/**
+ * Computed enhancer factory function
+ * @param config Configuration options for computed signals
+ * @returns Enhancer that adds computed signal functionality
+ *
+ * @example
+ * ```typescript
+ * import { signalTree } from '@signaltree/core';
+ * import { computed } from '@signaltree/core/enhancers/computed';
+ *
+ * const state = signalTree(
+ *   { count: 0, multiplier: 2 },
+ *   { enhancers: [computed()] }
+ * );
+ *
+ * // Create a computed signal
+ * const doubled = state.computed(tree => tree.count() * tree.multiplier());
+ *
+ * console.log(doubled()); // 0
+ * state.count.set(5);
+ * console.log(doubled()); // 10
+ * ```
+ */
+declare function computedEnhancer(config?: ComputedConfig): EnhancerWithMeta<SignalTree<Record<string, unknown>>, ComputedSignalTree<Record<string, unknown>>>;
+/**
+ * Utility function to create a computed signal from multiple dependencies
+ * @param dependencies Array of signals to depend on
+ * @param computeFn Function that computes the result
+ * @returns Computed signal
+ *
+ * @example
+ * ```typescript
+ * import { signal } from '@angular/core';
+ * import { createComputed } from '@signaltree/core/enhancers/computed';
+ *
+ * const a = signal(1);
+ * const b = signal(2);
+ * const sum = createComputed([a, b], () => a() + b());
+ * ```
+ */
+declare function createComputed<T>(dependencies: readonly Signal<unknown>[], computeFn: () => T): ComputedSignal<T>;
+
+export { computedEnhancer, createComputed };
+export type { ComputedConfig, ComputedSignal, ComputedSignalTree };

package/dist/enhancers/computed/index.js

@@ -0,0 +1,165 @@
+import { computed } from '@angular/core';
+import '@signaltree/shared';
+
+// Full developer-facing messages
+const DEV_MESSAGES = {
+    NULL_OR_UNDEFINED: 'null/undefined',
+    CIRCULAR_REF: 'circular ref',
+    UPDATER_INVALID: 'updater invalid',
+    LAZY_FALLBACK: 'lazy fallback',
+    SIGNAL_CREATION_FAILED: 'signal creation failed',
+    UPDATE_PATH_NOT_FOUND: 'update path not found',
+    UPDATE_FAILED: 'update failed',
+    ROLLBACK_FAILED: 'rollback failed',
+    CLEANUP_ERROR: 'cleanup error',
+    PRESET_UNKNOWN: 'unknown preset',
+    STRATEGY_SELECTION: 'strategy select',
+    TREE_DESTROYED: 'destroyed',
+    UPDATE_TRANSACTION: 'update tx',
+    BATCH_NOT_ENABLED: 'batching disabled',
+    MEMOIZE_NOT_ENABLED: 'memoize disabled',
+    MIDDLEWARE_NOT_AVAILABLE: 'middleware missing',
+    ENTITY_HELPERS_NOT_AVAILABLE: 'entity helpers missing',
+    ASYNC_ACTIONS_NOT_AVAILABLE: 'async actions missing',
+    TIME_TRAVEL_NOT_AVAILABLE: 'time travel missing',
+    OPTIMIZE_NOT_AVAILABLE: 'optimize missing',
+    UPDATE_OPTIMIZED_NOT_AVAILABLE: 'update optimized missing',
+    CACHE_NOT_AVAILABLE: 'cache missing',
+    PERFORMANCE_NOT_ENABLED: 'performance disabled',
+    ENHANCER_ORDER_FAILED: 'enhancer order failed',
+    ENHANCER_CYCLE_DETECTED: 'enhancer cycle',
+    ENHANCER_REQUIREMENT_MISSING: 'enhancer req missing',
+    ENHANCER_PROVIDES_MISSING: 'enhancer provides missing',
+    ENHANCER_FAILED: 'enhancer failed',
+    ENHANCER_NOT_FUNCTION: 'enhancer not function',
+    EFFECT_NO_CONTEXT: 'no angular context',
+    SUBSCRIBE_NO_CONTEXT: 'no angular context',
+};
+// Compact production messages (very short numeric codes) to keep bundles minimal.
+// We map each key to a short numeric string like '0','1','2' to minimize bytes.
+const PROD_MESSAGES = (() => {
+    const out = {};
+    let i = 0;
+    for (const k of Object.keys(DEV_MESSAGES)) {
+        out[k] = String(i++);
+    }
+    return out;
+})();
+// Avoid referencing the bare `process` identifier to keep builds free of Node
+// type assumptions; use globalThis to check env when available.
+const _isProdByEnv = Boolean(typeof globalThis === 'object' &&
+    globalThis !== null &&
+    'process' in globalThis &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof globalThis.process === 'object' &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    'env' in globalThis.process &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    globalThis.process.env.NODE_ENV === 'production');
+const _isDev = typeof ngDevMode !== 'undefined' ? Boolean(ngDevMode) : !_isProdByEnv;
+Object.freeze(_isDev
+    ? DEV_MESSAGES
+    : PROD_MESSAGES);
+
+/** Symbol key for enhancer metadata */
+const ENHANCER_META = Symbol('signaltree:enhancer:meta');
+
+/**
+ * Helper to create an enhancer with metadata attached
+ *
+ * @param meta - Metadata describing the enhancer
+ * @param enhancerFn - The enhancer function
+ * @returns Enhancer function with metadata attached
+ *
+ * @example
+ * ```typescript
+ * const myEnhancer = createEnhancer(
+ *   {
+ *     name: 'myEnhancer',
+ *     provides: ['feature1'],
+ *     requires: ['feature2']
+ *   },
+ *   (tree) => {
+ *     // Enhance the tree
+ *     return { ...tree, feature1: true };
+ *   }
+ * );
+ * ```
+ */
+function createEnhancer(meta, enhancerFn) {
+    const fn = enhancerFn;
+    try {
+        fn.metadata = meta;
+        // Also attach under symbol for third-party compatibility
+        try {
+            fn[ENHANCER_META] = meta;
+        }
+        catch {
+            // Ignore if property can't be set
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return fn;
+}
+
+/**
+ * Computed enhancer factory function
+ * @param config Configuration options for computed signals
+ * @returns Enhancer that adds computed signal functionality
+ *
+ * @example
+ * ```typescript
+ * import { signalTree } from '@signaltree/core';
+ * import { computed } from '@signaltree/core/enhancers/computed';
+ *
+ * const state = signalTree(
+ *   { count: 0, multiplier: 2 },
+ *   { enhancers: [computed()] }
+ * );
+ *
+ * // Create a computed signal
+ * const doubled = state.computed(tree => tree.count() * tree.multiplier());
+ *
+ * console.log(doubled()); // 0
+ * state.count.set(5);
+ * console.log(doubled()); // 10
+ * ```
+ */
+function computedEnhancer(config = {}) {
+    return createEnhancer({
+        name: 'computed',
+        provides: ['computed'],
+        requires: [],
+    }, (tree) => {
+        const computedTree = tree;
+        // Add computed method to the tree
+        computedTree.computed = function (computeFn) {
+            return computed(() => computeFn(tree.state));
+        };
+        return computedTree;
+    });
+}
+/**
+ * Utility function to create a computed signal from multiple dependencies
+ * @param dependencies Array of signals to depend on
+ * @param computeFn Function that computes the result
+ * @returns Computed signal
+ *
+ * @example
+ * ```typescript
+ * import { signal } from '@angular/core';
+ * import { createComputed } from '@signaltree/core/enhancers/computed';
+ *
+ * const a = signal(1);
+ * const b = signal(2);
+ * const sum = createComputed([a, b], () => a() + b());
+ * ```
+ */
+function createComputed(dependencies, computeFn) {
+    return computed(computeFn);
+}
+
+export { computedEnhancer, createComputed };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../packages/core/src/lib/constants.ts","../../../../../../../packages/core/src/lib/types.ts","../../../../../../../packages/core/src/enhancers/index.ts","../../../../../../../packages/core/src/enhancers/computed/lib/computed.ts"],"sourcesContent":[null,null,null,null],"names":[],"mappings":";;;AAsBA;AACA,MAAM,YAAY,GAAG;AACnB,IAAA,iBAAiB,EAAE,gBAAgB;AACnC,IAAA,YAAY,EAAE,cAAc;AAC5B,IAAA,eAAe,EAAE,iBAAiB;AAClC,IAAA,aAAa,EAAE,eAAe;AAC9B,IAAA,sBAAsB,EAAE,wBAAwB;AAChD,IAAA,qBAAqB,EAAE,uBAAuB;AAC9C,IAAA,aAAa,EAAE,eAAe;AAC9B,IAAA,eAAe,EAAE,iBAAiB;AAClC,IAAA,aAAa,EAAE,eAAe;AAC9B,IAAA,cAAc,EAAE,gBAAgB;AAChC,IAAA,kBAAkB,EAAE,iBAAiB;AACrC,IAAA,cAAc,EAAE,WAAW;AAC3B,IAAA,kBAAkB,EAAE,WAAW;AAC/B,IAAA,iBAAiB,EAAE,mBAAmB;AACtC,IAAA,mBAAmB,EAAE,kBAAkB;AACvC,IAAA,wBAAwB,EAAE,oBAAoB;AAC9C,IAAA,4BAA4B,EAAE,wBAAwB;AACtD,IAAA,2BAA2B,EAAE,uBAAuB;AACpD,IAAA,yBAAyB,EAAE,qBAAqB;AAChD,IAAA,sBAAsB,EAAE,kBAAkB;AAC1C,IAAA,8BAA8B,EAAE,0BAA0B;AAC1D,IAAA,mBAAmB,EAAE,eAAe;AACpC,IAAA,uBAAuB,EAAE,sBAAsB;AAC/C,IAAA,qBAAqB,EAAE,uBAAuB;AAC9C,IAAA,uBAAuB,EAAE,gBAAgB;AACzC,IAAA,4BAA4B,EAAE,sBAAsB;AACpD,IAAA,yBAAyB,EAAE,2BAA2B;AACtD,IAAA,eAAe,EAAE,iBAAiB;AAClC,IAAA,qBAAqB,EAAE,uBAAuB;AAC9C,IAAA,iBAAiB,EAAE,oBAAoB;AACvC,IAAA,oBAAoB,EAAE,oBAAoB;CAClC;AAEV;AACA;AACA,MAAM,aAAa,GAAG,CAAC,MAAK;IAC1B,MAAM,GAAG,GAAG,EAA+C;IAC3D,IAAI,CAAC,GAAG,CAAC;IACT,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAEvC,EAAE;QACD,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC;IACtB;AACA,IAAA,OAAO,GAAG;AACZ,CAAC,GAAG;AAMJ;AACA;AACA,MAAM,YAAY,GAAG,OAAO,CAC1B,OAAO,UAAU,KAAK,QAAQ;AAC5B,IAAA,UAAU,KAAK,IAAI;AACnB,IAAA,SAAS,IAAI,UAAU;;AAEvB,IAAA,OAAQ,UAAkB,CAAC,OAAO,KAAK,QAAQ;;IAE/C,KAAK,IAAK,UAAkB,CAAC,OAAO;;IAEnC,UAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAC5D;AAED,MAAM,MAAM,GACV,OAAO,SAAS,KAAK,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY;AAEnC,MAAM,CAAC,MAAM,CAC/C;AACE,MAAG;MACA,aAAqC;;ACiF5C;AACO,MAAM,aAAa,GAAG,MAAM,CAAC,0BAA0B,CAAC;;ACxK/D;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,cAAc,CAC5B,IAAkB,EAClB,UAA2B,EAAA;IAE3B,MAAM,EAAE,GAAG,UAAoC;AAC/C,IAAA,IAAI;AACF,QAAA,EAAE,CAAC,QAAQ,GAAG,IAAI;;AAElB,QAAA,IAAI;AACD,YAAA,EAAyC,CAAC,aAAa,CAAC,GAAG,IAAI;QAClE;AAAE,QAAA,MAAM;;QAER;IACF;AAAE,IAAA,MAAM;;IAER;AACA,IAAA,OAAO,EAAE;AACX;;ACbA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,gBAAgB,CAAC,MAAA,GAAyB,EAAE,EAAA;AAC1D,IAAA,OAAO,cAAc,CAInB;AACE,QAAA,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE,CAAC,UAAU,CAAC;AACtB,QAAA,QAAQ,EAAE,EAAE;KACb,EACD,CAAC,IAAI,KAAI;QACP,MAAM,YAAY,GAAG,IAAmD;;AAGxE,QAAA,YAAY,CAAC,QAAQ,GAAG,UACtB,SAAyD,EAAA;AAEzD,YAAA,OAAO,QAAQ,CAAC,MAAM,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC9C,QAAA,CAAC;AAED,QAAA,OAAO,YAAY;AACrB,IAAA,CAAC,CACF;AACH;AAEA;;;;;;;;;;;;;;;AAeG;AACG,SAAU,cAAc,CAC5B,YAAwC,EACxC,SAAkB,EAAA;AAElB,IAAA,OAAO,QAAQ,CAAC,SAAS,CAAC;AAC5B;;;;"}

package/dist/enhancers/computed/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/computed/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/computed/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/computed/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"}