@but212/atom-effect 0.1.4 → 0.2.0

package/dist/core/effect/effect.d.ts

@@ -1,64 +0,0 @@
-import { EffectFunction, EffectObject, EffectOptions } from '../../types';
-/**
- * Creates a reactive effect that automatically re-executes when its dependencies change.
- *
- * @param fn - The effect function to execute. May return a cleanup function
- *             or a Promise that resolves to a cleanup function.
- * @param options - Configuration options for the effect
- * @param options.sync - If true, re-executes synchronously on dependency changes.
- *                       Defaults to false (scheduled/batched execution).
- * @param options.maxExecutionsPerSecond - Maximum executions per second before
- *                                          infinite loop detection triggers.
- *                                          Defaults to `SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_SECOND`.
- * @param options.trackModifications - If true, tracks and warns about dependencies
- *                                     that are both read and modified. Defaults to false.
- *
- * @returns An {@link EffectObject} with `run()`, `dispose()`, and state properties
- *
- * @throws {EffectError} If `fn` is not a function
- *
- * @remarks
- * Effects are the primary way to perform side effects in response to reactive
- * state changes. They automatically track which reactive values (atoms, computed)
- * are accessed during execution and re-run when those values change.
- *
- * The effect function may return a cleanup function that will be called before
- * the next execution or when the effect is disposed. This is useful for
- * cleaning up subscriptions, timers, or other resources.
- *
- * @example
- * Basic usage:
- * ```typescript
- * const counter = atom(0);
- *
- * const fx = effect(() => {
- *   console.log('Counter:', counter.value);
- * });
- * // Logs: "Counter: 0"
- *
- * counter.value = 1;
- * // Logs: "Counter: 1"
- *
- * fx.dispose(); // Stop the effect
- * ```
- *
- * @example
- * With cleanup function:
- * ```typescript
- * const fx = effect(() => {
- *   const timer = setInterval(() => console.log('tick'), 1000);
- *   return () => clearInterval(timer); // Cleanup
- * });
- * ```
- *
- * @example
- * Synchronous execution:
- * ```typescript
- * const fx = effect(
- *   () => console.log(counter.value),
- *   { sync: true }
- * );
- * ```
- */
-export declare function effect(fn: EffectFunction, options?: EffectOptions): EffectObject;
-//# sourceMappingURL=effect.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../../src/core/effect/effect.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,OAAO,KAAK,EAAc,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAiiB3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,cAAc,EAAE,OAAO,GAAE,aAAkB,GAAG,YAAY,CAUpF"}

package/dist/core/effect/index.d.ts

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

package/dist/core/effect/index.d.ts.map

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

package/dist/core/index.d.ts

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

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

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

package/dist/errors/errors.d.ts

@@ -1,118 +0,0 @@
-/**
- * @fileoverview Error class hierarchy for atom-effect library
- * @description Structured error classes with cause tracking and recoverability flags
- */
-/**
- * Base error class for all atom-effect errors
- *
- * Provides enhanced error information including:
- * - Original cause tracking for error chains
- * - Recoverability flag for error handling strategies
- * - Timestamp for debugging and logging
- *
- * @example
- * ```ts
- * throw new AtomError('Invalid state', originalError, false);
- * ```
- */
-export declare class AtomError extends Error {
-    /** Original error that caused this error, if any */
-    cause: Error | null;
-    /** Whether this error can be recovered from */
-    recoverable: boolean;
-    /** When this error occurred */
-    timestamp: Date;
-    /**
-     * Creates a new AtomError
-     * @param message - Error message describing what went wrong
-     * @param cause - Original error that caused this error
-     * @param recoverable - Whether the operation can be retried
-     */
-    constructor(message: string, cause?: Error | null, recoverable?: boolean);
-}
-/**
- * Error thrown during computed value computation
- *
- * Computed errors are considered recoverable by default since they typically
- * result from transient data issues rather than programming errors.
- */
-export declare class ComputedError extends AtomError {
-    /**
-     * Creates a new ComputedError
-     * @param message - Error message
-     * @param cause - Original error
-     */
-    constructor(message: string, cause?: Error | null);
-}
-/**
- * Error thrown during effect execution
- *
- * Effect errors are considered non-recoverable by default since effects
- * typically represent critical side effects that shouldn't fail silently.
- */
-export declare class EffectError extends AtomError {
-    /**
-     * Creates a new EffectError
-     * @param message - Error message
-     * @param cause - Original error
-     */
-    constructor(message: string, cause?: Error | null);
-}
-/**
- * Error thrown by the scheduler system
- *
- * Scheduler errors indicate fundamental issues with the batching/scheduling
- * mechanism and are considered non-recoverable.
- */
-export declare class SchedulerError extends AtomError {
-    /**
-     * Creates a new SchedulerError
-     * @param message - Error message
-     * @param cause - Original error
-     */
-    constructor(message: string, cause?: Error | null);
-}
-/**
- * Wraps an unknown error in the appropriate AtomError subclass
- *
- * Provides consistent error handling by:
- * - Preserving original error information in the cause field
- * - Adding contextual information about where the error occurred
- * - Returning existing AtomErrors unchanged
- * - Handling various error types (TypeError, ReferenceError, etc.)
- *
- * @param error - Unknown error to wrap
- * @param ErrorClass - AtomError subclass to use for wrapping
- * @param context - Context string describing where the error occurred
- * @returns Wrapped error with contextual information
- *
- * @example
- * ```ts
- * try {
- *   computeFn();
- * } catch (err) {
- *   throw wrapError(err, ComputedError, 'computation phase');
- * }
- * ```
- */
-export declare function wrapError(error: unknown, ErrorClass: typeof AtomError, context: string): AtomError;
-/**
- * Type guard to check if a value is a Promise
- *
- * Uses duck-typing to detect Promise-like objects by checking for
- * the presence of a `then` method.
- *
- * @template T - The type the Promise resolves to
- * @param value - Value to check
- * @returns True if value has a `then` method (is Promise-like)
- *
- * @example
- * ```ts
- * const result = computeFn();
- * if (isPromise(result)) {
- *   await result;
- * }
- * ```
- */
-export declare function isPromise<T>(value: unknown): value is Promise<T>;
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC,oDAAoD;IACpD,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,+CAA+C;IAC/C,WAAW,EAAE,OAAO,CAAC;IACrB,+BAA+B;IAC/B,SAAS,EAAE,IAAI,CAAC;IAEhB;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,KAAK,GAAG,IAAW,EAAE,WAAW,GAAE,OAAc;CAOrF;AAED;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,SAAS;IAC1C;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,KAAK,GAAG,IAAW;CAIxD;AAED;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACxC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,KAAK,GAAG,IAAW;CAIxD;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,KAAK,GAAG,IAAW;CAIxD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,OAAO,SAAS,EAC5B,OAAO,EAAE,MAAM,GACd,SAAS,CAeX;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAMhE"}

package/dist/errors/messages.d.ts

@@ -1,101 +0,0 @@
-/**
- * @fileoverview Centralized error messages for better maintainability
- * @description All error messages in English for international accessibility
- * @module errors/messages
- */
-/**
- * Centralized error message constants for the atom-effect library.
- *
- * @description
- * Provides consistent, maintainable error messages across the library.
- * All messages are in English for international accessibility.
- *
- * @remarks
- * - Computed errors: Related to computed atom creation and execution
- * - Atom errors: Related to atom subscription and notification
- * - Effect errors: Related to effect lifecycle and cleanup
- * - Debug warnings: Non-critical warnings for debugging
- *
- * @example
- * ```ts
- * import { ERROR_MESSAGES } from './messages';
- *
- * if (typeof fn !== 'function') {
- *   throw new Error(ERROR_MESSAGES.COMPUTED_MUST_BE_FUNCTION);
- * }
- * ```
- */
-export declare const ERROR_MESSAGES: {
-    /**
-     * Error thrown when computed() receives a non-function argument.
-     */
-    readonly COMPUTED_MUST_BE_FUNCTION: "Computed function must be a function";
-    /**
-     * Error thrown when subscribe() receives a non-function listener.
-     */
-    readonly COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber listener must be a function";
-    /**
-     * Error thrown when accessing a pending async computed without a default value.
-     */
-    readonly COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation is pending. No default value provided";
-    /**
-     * Error thrown when a synchronous computed computation fails.
-     */
-    readonly COMPUTED_COMPUTATION_FAILED: "Computed computation failed";
-    /**
-     * Error thrown when an asynchronous computed computation fails.
-     */
-    readonly COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computed computation failed";
-    /**
-     * Error thrown when subscribing to a dependency fails.
-     */
-    readonly COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: "Failed to subscribe to dependency";
-    /**
-     * Error thrown when atom.subscribe() receives a non-function listener.
-     */
-    readonly ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscription listener must be a function";
-    /**
-     * Error thrown when the atom subscriber notification process fails.
-     */
-    readonly ATOM_SUBSCRIBER_EXECUTION_FAILED: "Error occurred while executing atom subscribers";
-    /**
-     * Error logged when an individual subscriber throws during notification.
-     * @remarks This error is caught and logged to prevent cascading failures.
-     */
-    readonly ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Error during individual atom subscriber execution";
-    /**
-     * Error thrown when effect() receives a non-function argument.
-     */
-    readonly EFFECT_MUST_BE_FUNCTION: "Effect function must be a function";
-    /**
-     * Error thrown when an effect's execution fails.
-     */
-    readonly EFFECT_EXECUTION_FAILED: "Effect execution failed";
-    /**
-     * Error thrown when an effect's cleanup function fails.
-     */
-    readonly EFFECT_CLEANUP_FAILED: "Effect cleanup function execution failed";
-    /**
-     * Warning message for large dependency graphs.
-     *
-     * @param count - The number of dependencies detected
-     * @returns Formatted warning message with dependency count
-     *
-     * @example
-     * ```ts
-     * console.warn(ERROR_MESSAGES.LARGE_DEPENDENCY_GRAPH(150));
-     * // Output: "Large dependency graph detected: 150 dependencies"
-     * ```
-     */
-    readonly LARGE_DEPENDENCY_GRAPH: (count: number) => string;
-    /**
-     * Warning logged when attempting to unsubscribe a non-existent listener.
-     */
-    readonly UNSUBSCRIBE_NON_EXISTENT: "Attempted to unsubscribe a non-existent listener";
-    /**
-     * Error logged when the onError callback itself throws an error.
-     * @remarks This prevents cascading failures from masking the original error.
-     */
-    readonly CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution";
-};
-//# sourceMappingURL=messages.d.ts.map

package/dist/errors/messages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/errors/messages.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc;IAKzB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAOH;;OAEG;;IAGH;;OAEG;;IAGH;;;OAGG;;IAOH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAOH;;;;;;;;;;;OAWG;6CAC6B,MAAM,KAAG,MAAM;IAG/C;;OAEG;;IAGH;;;OAGG;;CAEK,CAAC"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACtF,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhD,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAExF,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,KAAK,IAAI,aAAa,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/scheduler/batch.d.ts

@@ -1,31 +0,0 @@
-/**
- * Executes multiple reactive updates in a single batch.
- *
- * Batching groups multiple state changes together, deferring notifications
- * until all updates are complete. This prevents intermediate states from
- * triggering unnecessary recomputations and improves performance.
- *
- * @template T - The return type of the callback function
- * @param callback - The function containing batched updates
- * @returns The result of the callback function
- * @throws {AtomError} If the callback is not a function
- * @throws {AtomError} If an error occurs during batch execution
- *
- * @example
- * ```typescript
- * const firstName = atom('John');
- * const lastName = atom('Doe');
- *
- * // Without batching: triggers 2 separate updates
- * firstName.value = 'Jane';
- * lastName.value = 'Smith';
- *
- * // With batching: triggers 1 combined update
- * batch(() => {
- *   firstName.value = 'Jane';
- *   lastName.value = 'Smith';
- * });
- * ```
- */
-export declare function batch<T>(callback: () => T): T;
-//# sourceMappingURL=batch.d.ts.map

package/dist/scheduler/batch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/scheduler/batch.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAc7C"}

package/dist/scheduler/index.d.ts

@@ -1,3 +0,0 @@
-export * from './batch';
-export * from './scheduler';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scheduler/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/dist/scheduler/scheduler.d.ts

@@ -1,153 +0,0 @@
-/**
- * Scheduler for managing reactive updates and batching operations.
- *
- * The Scheduler is responsible for coordinating when reactive computations
- * are executed. It supports both immediate (microtask) execution and
- * batched synchronous execution for optimal performance.
- *
- * Key features:
- * - Deduplication of callbacks via Set
- * - Nested batch support with depth tracking
- * - Infinite loop protection with configurable iteration limit
- * - Error isolation to prevent one callback from breaking others
- *
- * @example
- * ```typescript
- * // Schedule a callback for microtask execution
- * scheduler.schedule(() => console.log('Updated!'));
- *
- * // Batch multiple updates
- * scheduler.startBatch();
- * scheduler.schedule(() => console.log('Update 1'));
- * scheduler.schedule(() => console.log('Update 2'));
- * scheduler.endBatch(); // Both execute synchronously here
- * ```
- */
-declare class Scheduler {
-    /** Queue of callbacks waiting for microtask execution */
-    /** Queue buffers for double buffering optimization */
-    private queueA;
-    private queueB;
-    /** Currently active queue receiving new tasks */
-    private queue;
-    /** Whether the scheduler is currently processing the queue */
-    private isProcessing;
-    /** Whether batching is currently active */
-    isBatching: boolean;
-    /** Current nesting depth of batch operations */
-    private batchDepth;
-    /** Array of callbacks queued during batching */
-    private batchQueue;
-    /** Current size of the batch queue (for array reuse) */
-    private batchQueueSize;
-    /** Whether synchronous flush is in progress */
-    private isFlushingSync;
-    /** Maximum iterations allowed during flush to prevent infinite loops */
-    private maxFlushIterations;
-    /**
-     * Schedules a callback for execution.
-     *
-     * If batching is active or a sync flush is in progress, the callback
-     * is added to the batch queue. Otherwise, it's added to the main queue
-     * and a flush is triggered via microtask.
-     *
-     * @param callback - The function to schedule for execution
-     * @throws {SchedulerError} If callback is not a function
-     *
-     * @example
-     * ```typescript
-     * scheduler.schedule(() => {
-     *   // This runs in the next microtask (or sync if batching)
-     *   updateUI();
-     * });
-     * ```
-     */
-    schedule(callback: () => void): void;
-    /**
-     * Flushes the queue asynchronously via microtask.
-     *
-     * Executes all queued callbacks in a microtask, allowing the current
-     * synchronous execution to complete first. Errors in individual
-     * callbacks are caught and logged without interrupting others.
-     *
-     * @private
-     * @remarks
-     * This method is idempotent - calling it multiple times while
-     * processing is active has no effect.
-     */
-    private flush;
-    /**
-     * Flushes all queued callbacks synchronously.
-     *
-     * This method is called when a batch ends. It processes all callbacks
-     * in the batch queue and main queue synchronously, allowing callbacks
-     * to schedule additional callbacks that are processed in the same flush.
-     *
-     * @private
-     * @remarks
-     * - Includes infinite loop protection via maxFlushIterations
-     * - Errors in callbacks are caught and logged individually
-     * - The isFlushingSync flag prevents re-entrancy issues
-     */
-    private flushSync;
-    /**
-     * Starts a new batch operation.
-     *
-     * While batching is active, all scheduled callbacks are deferred
-     * until endBatch() is called. Batches can be nested - only the
-     * outermost endBatch() triggers execution.
-     *
-     * @example
-     * ```typescript
-     * scheduler.startBatch();
-     * // All updates here are deferred
-     * atom1.value = 'a';
-     * atom2.value = 'b';
-     * scheduler.endBatch(); // Both updates processed together
-     * ```
-     */
-    startBatch(): void;
-    /**
-     * Ends a batch operation.
-     *
-     * Decrements the batch depth counter. When depth reaches zero,
-     * all queued callbacks are flushed synchronously and batching
-     * is disabled.
-     *
-     * @remarks
-     * Safe to call even if startBatch() wasn't called - depth is
-     * clamped to zero minimum.
-     *
-     * @example
-     * ```typescript
-     * scheduler.startBatch();
-     * try {
-     *   // ... batched operations
-     * } finally {
-     *   scheduler.endBatch(); // Always end batch, even on error
-     * }
-     * ```
-     */
-    endBatch(): void;
-    /**
-     * Sets the maximum number of flush iterations allowed.
-     *
-     * This limit prevents infinite loops when reactive dependencies
-     * form cycles. If exceeded, the queue is cleared and an error
-     * is logged.
-     *
-     * @param max - Maximum iterations (must be at least 10)
-     * @throws {SchedulerError} If max is less than 10
-     *
-     * @example
-     * ```typescript
-     * // Increase limit for complex dependency graphs
-     * scheduler.setMaxFlushIterations(5000);
-     * ```
-     */
-    setMaxFlushIterations(max: number): void;
-}
-/** Global scheduler instance for reactive updates */
-export declare const scheduler: Scheduler;
-export {};
-//# sourceMappingURL=scheduler.d.ts.map

package/dist/scheduler/scheduler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/scheduler/scheduler.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,cAAM,SAAS;IACb,yDAAyD;IACzD,sDAAsD;IACtD,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,MAAM,CAA8B;IAE5C,iDAAiD;IACjD,OAAO,CAAC,KAAK,CAAgC;IAE7C,8DAA8D;IAC9D,OAAO,CAAC,YAAY,CAAkB;IAEtC,2CAA2C;IACpC,UAAU,EAAE,OAAO,CAAS;IAEnC,gDAAgD;IAChD,OAAO,CAAC,UAAU,CAAa;IAE/B,gDAAgD;IAChD,OAAO,CAAC,UAAU,CAAyB;IAE3C,wDAAwD;IACxD,OAAO,CAAC,cAAc,CAAK;IAE3B,+CAA+C;IAC/C,OAAO,CAAC,cAAc,CAAkB;IAExC,wEAAwE;IACxE,OAAO,CAAC,kBAAkB,CAAgB;IAE1C;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAepC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,KAAK;IAgCb;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,SAAS;IAuDjB;;;;;;;;;;;;;;;OAeG;IACH,UAAU,IAAI,IAAI;IAKlB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,IAAI,IAAI;IAShB;;;;;;;;;;;;;;;OAeG;IACH,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAMzC;AAED,qDAAqD;AACrD,eAAO,MAAM,SAAS,WAAkB,CAAC"}

package/dist/tracking/context.d.ts

@@ -1,76 +0,0 @@
-import { Listener } from './tracking.types';
-/**
- * Interface for the tracking context that manages dependency tracking.
- *
- * The tracking context is responsible for maintaining the current listener
- * during reactive computations, enabling automatic dependency collection.
- *
- * @interface TrackingContext
- */
-export interface TrackingContext {
-    /**
-     * The currently active listener being tracked.
-     * `null` when no tracking is in progress.
-     */
-    current: Listener | null;
-    /**
-     * Executes a function within a tracking context.
-     *
-     * Sets the provided listener as the current tracking target,
-     * executes the function, and restores the previous context.
-     *
-     * @template T - The return type of the function
-     * @param listener - The listener to set as current during execution
-     * @param fn - The function to execute within the tracking context
-     * @returns The result of the executed function
-     *
-     * @example
-     * ```typescript
-     * const result = trackingContext.run(myListener, () => {
-     *   // Any atom access here will be tracked
-     *   return someAtom.value + otherAtom.value;
-     * });
-     * ```
-     */
-    run<T>(listener: Listener, fn: () => T): T;
-    /**
-     * Gets the currently active listener.
-     *
-     * @returns The current listener or `null` if no tracking is active
-     *
-     * @example
-     * ```typescript
-     * const current = trackingContext.getCurrent();
-     * if (current) {
-     *   // Dependency tracking is active
-     * }
-     * ```
-     */
-    getCurrent(): Listener | null;
-}
-/**
- * Global tracking context singleton for dependency tracking.
- *
- * This object manages the current listener during reactive computations,
- * enabling atoms and computed values to automatically track their dependencies.
- *
- * @remarks
- * - The context uses a stack-like behavior via the `run` method
- * - Nested `run` calls properly restore the previous context
- * - Thread-safe within a single JavaScript execution context
- *
- * @example
- * ```typescript
- * // Setting up tracking for a computed value
- * const value = trackingContext.run(computedListener, () => {
- *   return atom1.value + atom2.value; // Both atoms are tracked
- * });
- *
- * // Checking if tracking is active
- * if (trackingContext.getCurrent()) {
- *   // Register this atom as a dependency
- * }
- * ```
- */
-export declare const trackingContext: TrackingContext;
-//# sourceMappingURL=context.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/tracking/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEzB;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAE3C;;;;;;;;;;;;OAYG;IACH,UAAU,IAAI,QAAQ,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,eAAe,EAAE,eAsB7B,CAAC"}