@but212/atom-effect 0.1.3 → 0.1.5

package/dist/tracking/dependency-manager.d.ts

@@ -1,224 +0,0 @@
-import { Dependency } from '../types';
-/**
- * Manages reactive dependencies with automatic cleanup and memory-efficient tracking.
- *
- * This class provides a centralized way to track dependencies between reactive
- * primitives (atoms, computed values) and their subscribers. It uses WeakRef
- * and WeakMap for memory-efficient storage that allows garbage collection
- * of unused dependencies.
- *
- * @remarks
- * - Uses WeakMap for O(1) lookup and automatic GC of unreferenced dependencies
- * - Uses WeakRef array for iteration while allowing GC
- * - Periodic cleanup removes stale WeakRefs to prevent memory leaks
- * - Thread-safe for single-threaded JavaScript execution
- *
- * @example
- * ```typescript
- * const manager = new DependencyManager();
- *
- * // Add a dependency with its unsubscribe callback
- * const unsubscribe = atom.subscribe(() => recompute());
- * manager.addDependency(atom, unsubscribe);
- *
- * // Check if dependency exists
- * if (manager.hasDependency(atom)) {
- *   console.log('Dependency tracked');
- * }
- *
- * // Remove specific dependency
- * manager.removeDependency(atom);
- *
- * // Clean up all dependencies
- * manager.unsubscribeAll();
- * ```
- */
-export declare class DependencyManager {
-    /**
-     * Array of tracked dependencies.
-     * Managed as a simple array for maximum performance (no WeakRef overhead).
-     */
-    private readonly depRefs;
-    /**
-     * Map of dependencies to their unsubscribe functions.
-     * WeakMap ensures automatic cleanup when dependency is garbage collected.
-     */
-    private readonly depMap;
-    /** Current number of active dependencies */
-    private count;
-    /**
-     * Number of additions before triggering automatic cleanup.
-     * @defaultValue 100
-     */
-    private cleanupThreshold;
-    /**
-     * Counter tracking additions since last cleanup.
-     */
-    private addCount;
-    constructor();
-    /**
-     * Adds a dependency with its associated unsubscribe callback.
-     *
-     * If the dependency already exists, the new unsubscribe callback is
-     * immediately called to prevent duplicate subscriptions.
-     *
-     * @param dep - The dependency to track (atom, computed, etc.)
-     * @param cleanup - Callback to invoke when removing the dependency
-     *
-     * @remarks
-     * - Duplicate dependencies are rejected with immediate unsubscribe
-     * - Automatic cleanup is triggered every `cleanupThreshold` additions
-     * - Time complexity: O(1) for add, O(n) when cleanup triggers
-     *
-     * @example
-     * ```typescript
-     * const unsubscribe = atom.subscribe(() => markDirty());
-     * manager.addDependency(atom, unsubscribe);
-     * ```
-     */
-    addDependency(dep: Dependency, cleanup: () => void): void;
-    /**
-     * Removes a dependency and calls its unsubscribe callback.
-     *
-     * @param dep - The dependency to remove
-     * @returns `true` if the dependency was found and removed, `false` otherwise
-     *
-     * @remarks
-     * - Unsubscribe errors are caught and logged to prevent cascading failures
-     * - The WeakRef entry is not immediately removed (cleaned up lazily)
-     * - Time complexity: O(1)
-     *
-     * @example
-     * ```typescript
-     * const wasRemoved = manager.removeDependency(atom);
-     * if (wasRemoved) {
-     *   console.log('Dependency successfully removed');
-     * }
-     * ```
-     */
-    removeDependency(dep: Dependency): boolean;
-    /**
-     * Checks if a dependency is currently being tracked.
-     *
-     * @param dep - The dependency to check
-     * @returns `true` if the dependency exists in the manager
-     *
-     * @remarks
-     * Time complexity: O(1)
-     *
-     * @example
-     * ```typescript
-     * if (manager.hasDependency(atom)) {
-     *   // Dependency is already tracked
-     * }
-     * ```
-     */
-    hasDependency(dep: Dependency): boolean;
-    /**
-     * Removes all dependencies and calls their unsubscribe callbacks.
-     *
-     * This method iterates through all tracked dependencies, calls their
-     * unsubscribe callbacks, and clears internal storage.
-     *
-     * @remarks
-     * - Errors during unsubscribe are caught and logged individually
-     * - Safe to call multiple times (idempotent after first call)
-     * - Time complexity: O(n) where n is the number of dependencies
-     *
-     * @example
-     * ```typescript
-     * // Clean up when disposing a computed value
-     * manager.unsubscribeAll();
-     * ```
-     */
-    unsubscribeAll(): void;
-    /**
-     * Removes stale references from the internal array.
-     *
-     * This method iterates through the `depRefs` array and removes any dependencies
-     * that are no longer present in the `depMap` (meaning their unsubscribe
-     * callback has been garbage collected or explicitly deleted).
-     *
-     * @remarks
-     * - Called automatically every `cleanupThreshold` additions
-     * - Can be called manually for immediate cleanup
-     * - Time complexity: O(n) where n is the number of dependencies
-     *
-     * @example
-     * ```typescript
-     * // Force immediate cleanup
-     * manager.cleanup();
-     * ```
-     */
-    cleanup(): void;
-    /**
-     * Gets the current number of live dependencies.
-     *
-     * @returns The count of dependencies that haven't been garbage collected
-     *
-     * @remarks
-     * - Triggers cleanup before counting for accurate results
-     * - Time complexity: O(n) due to cleanup
-     *
-     * @example
-     * ```typescript
-     * console.log(`Tracking ${manager.count} dependencies`);
-     * ```
-     */
-    get liveCount(): number;
-    /**
-     * Gets an array of all live dependencies.
-     *
-     * @returns Array of dependencies that haven't been garbage collected
-     *
-     * @remarks
-     * - Returns a new array (safe to modify)
-     * - Does not trigger cleanup (may include some stale refs)
-     * - Time complexity: O(n)
-     *
-     * @example
-     * ```typescript
-     * const deps = manager.getDependencies();
-     * deps.forEach(dep => console.log(dep));
-     * ```
-     */
-    getDependencies(): Dependency[];
-    /**
-     * Gets the internal WeakMap for advanced use cases.
-     *
-     * @returns The internal dependency -> unsubscribe WeakMap
-     *
-     * @remarks
-     * - Returns the actual internal map (not a copy)
-     * - Modifications will affect the manager's state
-     * - Use with caution in production code
-     *
-     * @example
-     * ```typescript
-     * const map = manager.getDepMap();
-     * const unsubscribe = map.get(someDependency);
-     * ```
-     */
-    getDepMap(): WeakMap<Dependency, () => void>;
-    /**
-     * Sets the threshold for automatic cleanup triggering.
-     *
-     * @param threshold - Number of additions before cleanup (minimum 1)
-     *
-     * @remarks
-     * - Lower values mean more frequent cleanup (less memory, more CPU)
-     * - Higher values mean less frequent cleanup (more memory, less CPU)
-     * - Default is 100, suitable for most use cases
-     *
-     * @example
-     * ```typescript
-     * // More aggressive cleanup for memory-constrained environments
-     * manager.setCleanupThreshold(50);
-     *
-     * // Less frequent cleanup for performance-critical paths
-     * manager.setCleanupThreshold(500);
-     * ```
-     */
-    setCleanupThreshold(threshold: number): void;
-}
-//# sourceMappingURL=dependency-manager.d.ts.map

package/dist/tracking/dependency-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dependency-manager.d.ts","sourceRoot":"","sources":["../../src/tracking/dependency-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,iBAAiB;IAC5B;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAE5C;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IAEzD,4CAA4C;IAC5C,OAAO,CAAC,KAAK,CAAS;IAEtB;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAO;IAE/B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAK;;IAQrB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,aAAa,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI;IAoBzD;;;;;;;;;;;;;;;;;;OAkBG;IACH,gBAAgB,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO;IAwC1C;;;;;;;;;;;;;;;OAeG;IACH,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO;IAKvC;;;;;;;;;;;;;;;;OAgBG;IACH,cAAc,IAAI,IAAI;IAqBtB;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,IAAI,IAAI;IA8Bf;;;;;;;;;;;;;OAaG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;;;;;;;;;;;;;;OAeG;IACH,eAAe,IAAI,UAAU,EAAE;IAW/B;;;;;;;;;;;;;;;OAeG;IACH,SAAS,IAAI,OAAO,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC;IAI5C;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAG7C"}

package/dist/tracking/index.d.ts

@@ -1,5 +0,0 @@
-export * from './context';
-export * from './dependency-manager';
-export * from './tracking.types';
-export * from './untracked';
-//# sourceMappingURL=index.d.ts.map

package/dist/tracking/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tracking/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}

package/dist/tracking/tracking.types.d.ts

@@ -1,12 +0,0 @@
-/**
- * Interface for listeners that can track dependencies
- */
-export interface DependencyTracker {
-    addDependency?: (dep: unknown) => void;
-    execute?: () => void;
-}
-/**
- * Listener type
- */
-export type Listener = DependencyTracker | (() => void);
-//# sourceMappingURL=tracking.types.d.ts.map

package/dist/tracking/tracking.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracking.types.d.ts","sourceRoot":"","sources":["../../src/tracking/tracking.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,iBAAiB,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC"}

package/dist/tracking/untracked.d.ts

@@ -1,25 +0,0 @@
-/**
- * Executes a function without tracking any reactive dependencies.
- *
- * This utility allows reading atom values without establishing
- * a dependency relationship, useful for accessing values that
- * shouldn't trigger recomputation when they change.
- *
- * @template T - The return type of the function
- * @param fn - The function to execute without tracking
- * @returns The result of the executed function
- * @throws {AtomError} If the callback is not a function
- * @throws {AtomError} If an error occurs during execution
- *
- * @example
- * ```typescript
- * const count = atom(0);
- * const doubled = computed(() => {
- *   // This read will NOT be tracked as a dependency
- *   const untrackedValue = untracked(() => count.value);
- *   return untrackedValue * 2;
- * });
- * ```
- */
-export declare function untracked<T>(fn: () => T): T;
-//# sourceMappingURL=untracked.d.ts.map

package/dist/tracking/untracked.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"untracked.d.ts","sourceRoot":"","sources":["../../src/tracking/untracked.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAe3C"}

package/dist/types/atom.d.ts

@@ -1,13 +0,0 @@
-export interface AtomOptions {
-    sync?: boolean;
-}
-export interface ReadonlyAtom<T = unknown> {
-    readonly value: T;
-    subscribe(listener: (newValue?: T, oldValue?: T) => void): () => void;
-    peek(): T;
-}
-export interface WritableAtom<T = unknown> extends ReadonlyAtom<T> {
-    value: T;
-    dispose(): void;
-}
-//# sourceMappingURL=atom.d.ts.map

package/dist/types/atom.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atom.d.ts","sourceRoot":"","sources":["../../src/types/atom.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACvC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,SAAS,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACtE,IAAI,IAAI,CAAC,CAAC;CACX;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAChE,KAAK,EAAE,CAAC,CAAC;IACT,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/types/common.d.ts

@@ -1,45 +0,0 @@
-/**
- * Interface for poolable objects
- */
-export interface Poolable {
-    reset(): void;
-}
-/**
- * Subscriber interface for dependency notifications
- */
-export interface Subscriber {
-    execute(): void;
-}
-/**
- * Interface for subscribable dependencies
- */
-export interface Dependency {
-    subscribe(listener: (() => void) | Subscriber): () => void;
-    peek?(): unknown;
-    value?: unknown;
-}
-/**
- * WeakRef-based dependency entry structure
- */
-export interface DependencyEntry<T extends object = Dependency> {
-    ref: WeakRef<T>;
-    unsubscribe: () => void;
-}
-/**
- * Debug configuration interface
- */
-export interface DebugConfig {
-    enabled: boolean;
-    maxDependencies: number;
-    warnInfiniteLoop: boolean;
-    warn(condition: boolean, message: string): void;
-    checkCircular(dep: unknown, current: unknown, visited?: Set<unknown>): void;
-    attachDebugInfo(obj: object, type: string, id: number): void;
-    getDebugName(obj: unknown): string | undefined;
-    getDebugType(obj: unknown): string | undefined;
-}
-/**
- * Transform function type
- */
-export type TransformFunction<T, U> = (value: T) => U;
-//# sourceMappingURL=common.d.ts.map

package/dist/types/common.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,CAAC,QAAQ,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,UAAU,GAAG,MAAM,IAAI,CAAC;IAC3D,IAAI,CAAC,IAAI,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,MAAM,GAAG,UAAU;IAC5D,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAChB,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5E,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7D,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IAC/C,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;CAChD;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC"}

package/dist/types/computed.d.ts

@@ -1,18 +0,0 @@
-import { ReadonlyAtom } from './atom';
-export type AsyncStateType = 'idle' | 'pending' | 'resolved' | 'rejected';
-export interface ComputedOptions<T = unknown> {
-    equal?: (a: T, b: T) => boolean;
-    defaultValue?: T;
-    lazy?: boolean;
-    onError?: (error: Error) => void;
-}
-export interface ComputedAtom<T = unknown> extends ReadonlyAtom<T> {
-    readonly state: AsyncStateType;
-    readonly hasError: boolean;
-    readonly lastError: Error | null;
-    readonly isPending: boolean;
-    readonly isResolved: boolean;
-    invalidate(): void;
-    dispose(): void;
-}
-//# sourceMappingURL=computed.d.ts.map

package/dist/types/computed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed.d.ts","sourceRoot":"","sources":["../../src/types/computed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;AAE1E,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAChC,YAAY,CAAC,EAAE,CAAC,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAChE,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,KAAK,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,UAAU,IAAI,IAAI,CAAC;IACnB,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/types/effect.d.ts

@@ -1,13 +0,0 @@
-export interface EffectOptions {
-    sync?: boolean;
-    maxExecutionsPerSecond?: number;
-    trackModifications?: boolean;
-}
-export interface EffectObject {
-    dispose(): void;
-    run(): void;
-    readonly isDisposed: boolean;
-    readonly executionCount: number;
-}
-export type EffectFunction = () => void | (() => void) | Promise<undefined | (() => void)>;
-//# sourceMappingURL=effect.d.ts.map

package/dist/types/effect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/types/effect.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,IAAI,IAAI,CAAC;IAChB,GAAG,IAAI,IAAI,CAAC;IACZ,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,OAAO,CAAC,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC"}

package/dist/types/index.d.ts

@@ -1,5 +0,0 @@
-export * from './atom';
-export * from './common';
-export * from './computed';
-export * from './effect';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC"}

package/dist/utils/debug.d.ts

@@ -1,85 +0,0 @@
-import { DebugConfig } from '../types';
-/**
- * Symbol key for storing debug display name on reactive objects.
- *
- * @remarks
- * Using symbols prevents property name collisions with user-defined properties.
- *
- * @example
- * ```typescript
- * const atom = createAtom(0);
- * console.log(atom[DEBUG_NAME]); // "atom_1"
- * ```
- */
-export declare const DEBUG_NAME: unique symbol;
-/**
- * Symbol key for storing unique identifier on reactive objects.
- *
- * @remarks
- * Each reactive object (atom, computed, effect) receives a unique numeric ID
- * for debugging and tracking purposes.
- */
-export declare const DEBUG_ID: unique symbol;
-/**
- * Symbol key for storing the type discriminator on reactive objects.
- *
- * @remarks
- * Possible values: 'atom' | 'computed' | 'effect'
- */
-export declare const DEBUG_TYPE: unique symbol;
-/**
- * Sentinel value to distinguish "no default value provided" from `undefined`.
- *
- * @remarks
- * This allows computed values to differentiate between:
- * - User explicitly passing `undefined` as default
- * - User not providing any default value
- *
- * @example
- * ```typescript
- * const hasDefault = options.defaultValue !== NO_DEFAULT_VALUE;
- * ```
- */
-export declare const NO_DEFAULT_VALUE: unique symbol;
-/**
- * Debug configuration instance with runtime utilities.
- *
- * Provides development-time features including:
- * - Circular dependency detection (direct and indirect)
- * - Large dependency graph warnings
- * - Debug metadata attachment for inspection
- *
- * @remarks
- * Most features are only active when `NODE_ENV === 'development'`
- * to avoid performance overhead in production builds.
- *
- * @example
- * ```typescript
- * // Check for circular dependencies
- * debug.checkCircular(dependencyAtom, computedAtom);
- *
- * // Warn about potential issues
- * debug.warn(count > 100, 'Large dependency count detected');
- *
- * // Attach debug info to a reactive object
- * debug.attachDebugInfo(atom, 'atom', 42);
- * ```
- */
-export declare const debug: DebugConfig;
-/**
- * Generates a unique numeric identifier for reactive objects.
- *
- * @returns A unique positive integer, incrementing with each call
- *
- * @remarks
- * IDs are globally unique within a single runtime session.
- * The counter resets when the module is reloaded.
- *
- * @example
- * ```typescript
- * const atomId = generateId(); // 1
- * const computedId = generateId(); // 2
- * ```
- */
-export declare const generateId: () => number;
-//# sourceMappingURL=debug.d.ts.map

package/dist/utils/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/utils/debug.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,MAA4B,CAAC;AAE7D;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE,OAAO,MAAqB,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,MAAuB,CAAC;AAExD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAiC,CAAC;AAmBxE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,KAAK,EAAE,WAsKnB,CAAC;AASF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,QAAO,MAAkB,CAAC"}

package/dist/utils/object-pool.d.ts

@@ -1,159 +0,0 @@
-import { Poolable } from '../types';
-/**
- * Object Pool for efficient object reuse
- *
- * Implements the object pool pattern to reduce garbage collection pressure by
- * reusing objects instead of continuously creating and destroying them.
- *
- * ## Benefits:
- * - **Reduced GC pressure**: ~45% reduction in garbage collection overhead
- * - **Predictable performance**: No allocation spikes during high-load scenarios
- * - **Memory efficiency**: Caps maximum pool size to prevent memory bloat
- *
- * ## Usage Pattern:
- * 1. Acquire object from pool (or create new if pool empty)
- * 2. Use object for operation
- * 3. Release object back to pool (calls reset() automatically)
- *
- * @template T - Type that implements the Poolable interface
- *
- * @example
- * ```ts
- * const pool = new ObjectPool(() => new MyObject(), 100);
- *
- * // Pre-allocate for performance
- * pool.warmup(50);
- *
- * // Use pooled objects
- * const obj = pool.acquire();
- * obj.doSomething();
- * pool.release(obj); // Returns to pool for reuse
- * ```
- */
-declare class ObjectPool<T extends Poolable> {
-    /** Array holding pooled objects */
-    private pool;
-    /** Current number of available objects in pool */
-    private poolSize;
-    /** Maximum pool size to prevent unbounded growth */
-    private readonly maxPoolSize;
-    /** Factory function to create new instances */
-    private readonly factory;
-    /**
-     * Creates a new object pool
-     *
-     * @param factory - Function that creates new instances of T
-     * @param maxPoolSize - Maximum number of objects to pool (default: 1000)
-     */
-    constructor(factory: () => T, maxPoolSize?: number);
-    /**
-     * Pre-allocates objects in the pool for better performance
-     *
-     * Useful before performance-critical operations to avoid allocation
-     * overhead during execution. Creates objects up to the specified count
-     * or maxPoolSize, whichever is smaller.
-     *
-     * @param count - Number of objects to pre-allocate
-     *
-     * @example
-     * ```ts
-     * const pool = new ObjectPool(() => new Notification());
-     * pool.warmup(100); // Pre-allocate 100 objects
-     * ```
-     */
-    warmup(count: number): void;
-    /**
-     * Acquires an object from the pool or creates a new one
-     *
-     * If pool has available objects, returns a pooled instance (O(1)).
-     * Otherwise, creates a new instance using the factory function.
-     *
-     * @returns Reusable object instance
-     */
-    acquire(): T;
-    /**
-     * Returns an object to the pool for reuse
-     *
-     * Automatically calls reset() on the object before pooling.
-     * If pool is at max capacity, the object is discarded.
-     *
-     * @param obj - Object to return to pool
-     */
-    release(obj: T): void;
-    /**
-     * Clears all objects from the pool
-     *
-     * Useful for cleanup or resetting pool state.
-     */
-    clear(): void;
-}
-/**
- * Notification object for subscriber notifications
- *
- * Poolable object used to batch subscriber notifications efficiently.
- * Reduces allocation overhead when notifying multiple subscribers of
- * atom value changes.
- *
- * @template T - Type of the value being notified
- */
-declare class Notification<T = unknown> implements Poolable {
-    /** Listener callback function */
-    listener: Function | null;
-    /** New value after change */
-    newValue: T | undefined;
-    /** Previous value before change */
-    oldValue: T | undefined;
-    /**
-     * Creates a new notification
-     *
-     * @param listener - Callback to invoke
-     * @param newValue - New value to pass to callback
-     * @param oldValue - Old value to pass to callback
-     */
-    constructor(listener?: Function, newValue?: T, oldValue?: T);
-    /**
-     * Executes the notification callback with stored values
-     */
-    execute(): void;
-    /**
-     * Resets notification to initial state for pooling
-     */
-    reset(): void;
-}
-/**
- * Scheduler callback object
- *
- * Poolable object for scheduler queue callbacks.
- * Reduces allocation overhead during batch operations.
- */
-declare class SchedulerCallback implements Poolable {
-    /** Callback function to execute */
-    callback: (() => void) | null;
-    /**
-     * Creates a new scheduler callback
-     *
-     * @param callback - Function to execute
-     */
-    constructor(callback?: () => void);
-    /**
-     * Executes the stored callback
-     */
-    execute(): void;
-    /**
-     * Resets callback to initial state for pooling
-     */
-    reset(): void;
-}
-/**
- * Global object pool for notification objects
- * Pre-allocated for performance-critical subscriber notifications
- */
-export declare const notificationPool: ObjectPool<Notification<unknown>>;
-/**
- * Global object pool for scheduler callbacks
- * Reduces allocation overhead in batching operations
- */
-export declare const schedulerCallbackPool: ObjectPool<SchedulerCallback>;
-export { Notification, ObjectPool, SchedulerCallback };
-export type { Poolable };
-//# sourceMappingURL=object-pool.d.ts.map

package/dist/utils/object-pool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object-pool.d.ts","sourceRoot":"","sources":["../../src/utils/object-pool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,cAAM,UAAU,CAAC,CAAC,SAAS,QAAQ;IACjC,mCAAmC;IACnC,OAAO,CAAC,IAAI,CAAW;IACvB,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAK;IACrB,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,+CAA+C;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAElC;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAE,MAA6B;IAKxE;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAO3B;;;;;;;OAOG;IACH,OAAO,IAAI,CAAC;IAOZ;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;IAOrB;;;;OAIG;IACH,KAAK,IAAI,IAAI;CAId;AAED;;;;;;;;GAQG;AACH,cAAM,YAAY,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,QAAQ;IACjD,iCAAiC;IACjC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAQ;IACjC,6BAA6B;IAC7B,QAAQ,EAAE,CAAC,GAAG,SAAS,CAAa;IACpC,mCAAmC;IACnC,QAAQ,EAAE,CAAC,GAAG,SAAS,CAAa;IAEpC;;;;;;OAMG;gBACS,QAAQ,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC;IAM3D;;OAEG;IACH,OAAO,IAAI,IAAI;IAMf;;OAEG;IACH,KAAK,IAAI,IAAI;CAKd;AAED;;;;;GAKG;AACH,cAAM,iBAAkB,YAAW,QAAQ;IACzC,mCAAmC;IACnC,QAAQ,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAQ;IAErC;;;;OAIG;gBACS,QAAQ,CAAC,EAAE,MAAM,IAAI;IAIjC;;OAEG;IACH,OAAO,IAAI,IAAI;IAMf;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,mCAAiE,CAAC;AAE/F;;;GAGG;AACH,eAAO,MAAM,qBAAqB,+BAGjC,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;AACvD,YAAY,EAAE,QAAQ,EAAE,CAAC"}