@but212/atom-effect 0.30.1 → 0.31.0

package/dist/index.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Returns a promise that resolves after the next scheduler flush.
+ * This can be used to wait for all asynchronous effects to be processed.
+ *
+ * @param fn - Optional callback to execute after the flush.
+ * @returns A promise that resolves after the flush completes.
+ */
+export declare function aeNextTick(fn?: () => void): Promise<void>;
+
 /**
  * Async operation states for public API and high-level checks.
  */
@@ -105,7 +114,7 @@ export declare const composeLens: <T extends object, P extends Paths<T>>(lens: W
 
 /**
  * Creates a computed value.
- * @param fn - Computation function
+ * @param computation - Computation function
  * @param options - Options object
  */
 export declare function computed<T>(fn: () => T, options?: ComputedOptions<T>): ComputedAtom<T>;
@@ -117,7 +126,7 @@ export declare function computed<T>(fn: () => Promise<T>, options: ComputedOptio
 /**
  * Computed atom interface.
  */
-export declare interface ComputedAtom<T = unknown> extends ReadonlyAtom<T>, Disposable_2 {
+export declare interface ComputedAtom<T = unknown> extends ReadonlyAtom<T> {
     /* Excluded from this release type: [BRAND] */
     readonly state: AsyncStateType;
     readonly hasError: boolean;
@@ -129,8 +138,6 @@ export declare interface ComputedAtom<T = unknown> extends ReadonlyAtom<T>, Disp
     readonly errors: readonly Error[];
     /** Invalidates atom. */
     invalidate(): void;
-    dispose(): void;
-    [Symbol.dispose](): void;
 }
 
 /** Thrown when a computation fails. */
@@ -223,10 +230,6 @@ declare interface Disposable_2 {
      * Cleans up the object and releases resources.
      */
     dispose(): void;
-    /**
-     * Support for explicit resource management (TS 5.2+).
-     */
-    [Symbol.dispose](): void;
 }
 export { Disposable_2 as Disposable }
 
@@ -259,8 +262,6 @@ export declare type EffectFunction = () => (void | EffectCleanup) | Promise<void
 
 export declare interface EffectObject extends Disposable_2 {
     /* Excluded from this release type: [BRAND] */
-    dispose(): void;
-    [Symbol.dispose](): void;
     run(): void;
     readonly isDisposed: boolean;
     readonly executionCount: number;
@@ -329,7 +330,7 @@ export declare type PathValue<T, P extends string> = P extends `${infer K}.${inf
 /**
  * Readonly atom interface.
  */
-export declare interface ReadonlyAtom<T = unknown> {
+export declare interface ReadonlyAtom<T = unknown> extends Disposable_2 {
     /* Excluded from this release type: [BRAND] */
     /** The current value of the atom. */
     readonly value: T;
@@ -351,11 +352,7 @@ export declare interface ReadonlyAtom<T = unknown> {
 
 /**
  * The global debug singleton instance.
- * Automatically switches between development and production implementations
- * based on the environment configuration (IS_DEV).
- *
- * In production, this becomes a lightweight object with empty methods,
- * allowing engines to inline or ignore calls, effectively providing zero overhead.
+ * Automatically switches between development and production implementations.
  *
  * @public
  */
@@ -371,26 +368,18 @@ export declare const runtimeDebug: DebugConfig;
  * - Microsecond-level scheduling via queueMicrotask.
  */
 declare class Scheduler_2 {
-    /** Double buffer to allow scheduling new jobs while processing the current queue. */
-    private _queueBuffer;
-    /** Pointer to the currently active buffer for ingestion. */
     private _bufferIndex;
-    /** Current size of the active ingestion buffer. */
     private _size;
-    /** Current internal epoch for job tagging. */
     private _epoch;
-    /** Flag indicating the scheduler is currently draining a microtask loop. */
+    private _batchDepth;
+    private _batchQueueSize;
+    private _maxFlushIterations;
     private _isProcessing;
-    /** Flag indicating a synchronous flush (batch end) is currently active. */
     private _isFlushingSync;
-    /** Number of active nested batch contexts. */
-    private _batchDepth;
+    private _buffer0;
+    private _buffer1;
     /** Temporary holding area for jobs scheduled during an active batch or sync flush. */
     private _batchQueue;
-    /** Current number of jobs in the batch holding area. */
-    private _batchQueueSize;
-    /** Maximum allowed internal loop iterations before assuming an infinite loop. */
-    private _maxFlushIterations;
     /** Optional callback fired when the scheduler drops jobs due to overflow. */
     onOverflow: ((droppedCount: number) => void) | null;
     private readonly _boundRunLoop;
@@ -400,8 +389,7 @@ declare class Scheduler_2 {
     get isBatching(): boolean;
     /**
      * Schedules a job for execution.
-     * Jobs are deduplicated based on the current epoch; if the same job is scheduled twice
-     * in the same epoch, the second call is ignored.
+     * Jobs are deduplicated based on the current epoch.
      *
      * @param callback - The task to be executed.
      */
@@ -414,26 +402,21 @@ declare class Scheduler_2 {
     _flushSync(): void;
     /**
      * Merges the temporal batch queue into the main active buffer.
-     * Increments the epoch to allow previously executed jobs to be re-scheduled if needed.
      */
     private _mergeBatchQueue;
     /**
      * Continuous loop that drains both main and batch queues.
-     * Processes until all queues are empty or max iterations reached.
      */
     private _drainQueue;
     /** Executes all jobs currently in the primary buffer and swaps buffers. */
     private _processQueue;
-    /** Resets the scheduler state on infinite loop detection and notifies via onOverflow. */
+    /** Resets the scheduler state on infinite loop detection. */
     private _handleFlushOverflow;
     /** Enters a new batching depth. */
     startBatch(): void;
-    /**
-     * Decrements batching depth. If depth reaches 0, triggers a synchronous flush
-     * to apply all coherent updates collected during the batch.
-     */
+    /** Decrements batching depth. */
     endBatch(): void;
-    /** Configures the maximum safety iterations for the flush loop. */
+    /** Configures the maximum safety iterations. */
     setMaxFlushIterations(max: number): void;
 }
 
@@ -473,7 +456,7 @@ declare interface SchedulerJobObject {
 
 /**
  * Internal recursive helper for creating deep immutable copies with structural sharing.
- * Only clones nodes along the path where changes occur.
+ * Optimized for performance: avoids Regex overhead and minimizes object allocations.
  */
 export declare function setDeepValue(obj: unknown, keys: string[], index: number, value: unknown): unknown;
 
@@ -498,13 +481,8 @@ export declare function untracked<T>(fn: () => T): T;
 /**
  * Writable atom interface.
  */
-export declare interface WritableAtom<T = unknown> extends ReadonlyAtom<T>, Disposable_2 {
+export declare interface WritableAtom<T = unknown> extends ReadonlyAtom<T> {
     value: T;
-    /**
-     * Cleans up the atom and releases resources.
-     */
-    dispose(): void;
-    [Symbol.dispose](): void;
 }
 
 export { }