rexfect 0.0.7

package/dist/batch.js

@@ -0,0 +1,45 @@
+import { withHooks } from "./hooks";
+import { emitter } from "./emitter";
+let batchDepth = 0;
+/**
+ * Batches multiple state updates into a single reactive update.
+ *
+ * @param fn - Function containing multiple state updates
+ * @returns The return value of the function
+ *
+ * @example
+ * batch(() => {
+ *   setA(1);
+ *   setB(2);
+ *   setC(3);
+ * }); // Effects run once after all updates
+ */
+export function batch(fn) {
+    batchDepth++;
+    // First batch - set up the notification hook
+    if (batchDepth === 1) {
+        const onNotify = emitter();
+        try {
+            return withHooks({ scheduleNotify: onNotify.on }, fn);
+        }
+        finally {
+            batchDepth--;
+            // Keep hooks active while processing notifications
+            // This ensures effect re-runs are also batched
+            withHooks({ scheduleNotify: onNotify.on }, () => {
+                // Process until no more notifications (handles cascading updates)
+                while (onNotify.size > 0) {
+                    onNotify.emitAndClear();
+                }
+            });
+        }
+    }
+    // Nested batch - just run the function
+    try {
+        return fn();
+    }
+    finally {
+        batchDepth--;
+    }
+}
+//# sourceMappingURL=batch.js.map

package/dist/batch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.js","sourceRoot":"","sources":["../src/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,IAAI,UAAU,GAAG,CAAC,CAAC;AACnB;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,KAAK,CAAI,EAAW;IAClC,UAAU,EAAE,CAAC;IAEb,6CAA6C;IAC7C,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACrB,MAAM,QAAQ,GAAG,OAAO,EAAE,CAAC;QAC3B,IAAI,CAAC;YACH,OAAO,SAAS,CAAC,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACxD,CAAC;gBAAS,CAAC;YACT,UAAU,EAAE,CAAC;YACb,mDAAmD;YACnD,+CAA+C;YAC/C,SAAS,CAAC,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE;gBAC9C,kEAAkE;gBAClE,OAAO,QAAQ,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;oBACzB,QAAQ,CAAC,YAAY,EAAE,CAAC;gBAC1B,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,uCAAuC;IACvC,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,CAAC;IACd,CAAC;YAAS,CAAC;QACT,UAAU,EAAE,CAAC;IACf,CAAC;AACH,CAAC"}

package/dist/defer.d.ts

@@ -0,0 +1,56 @@
+/**
+ * A deferred promise - a promise whose resolve/reject can be called externally.
+ *
+ * Unlike a regular Promise where resolve/reject are only accessible inside
+ * the executor function, a Deferred exposes them as properties, allowing
+ * the promise to be resolved/rejected from anywhere.
+ *
+ * @template T - The type of value the promise resolves to
+ */
+export interface Deferred<T> {
+    /** The underlying promise that will be resolved/rejected */
+    readonly promise: Promise<T>;
+    /** Resolves the promise with the given value */
+    readonly resolve: (value: T) => void;
+    /** Rejects the promise with the given error */
+    readonly reject: (error: unknown) => void;
+}
+/**
+ * Creates a deferred promise - a promise with externally accessible resolve/reject.
+ *
+ * This is useful when you need to resolve a promise from a different context
+ * than where it was created, such as:
+ * - Waiting for an event to fire (`await action`)
+ * - Coordinating between async operations
+ * - Building thenable objects
+ *
+ * @template T - The type of value the promise resolves to
+ * @returns A Deferred object with { promise, resolve, reject }
+ *
+ * @example
+ * ```ts
+ * const deferred = defer<string>();
+ *
+ * // Somewhere else in the code...
+ * setTimeout(() => {
+ *   deferred.resolve("done!");
+ * }, 1000);
+ *
+ * // Await the promise
+ * const result = await deferred.promise; // "done!"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Used internally by action() for thenable support:
+ * let nextDispatch = defer<T>();
+ *
+ * // When action is awaited:
+ * action.then(...) → nextDispatch.promise.then(...)
+ *
+ * // When action is dispatched:
+ * action(payload) → nextDispatch.resolve(payload)
+ * ```
+ */
+export declare function defer<T>(): Deferred<T>;
+//# sourceMappingURL=defer.d.ts.map

package/dist/defer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defer.d.ts","sourceRoot":"","sources":["../src/defer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAC7B,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACrC,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,KAAK,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAYtC"}

package/dist/defer.js

@@ -0,0 +1,49 @@
+/**
+ * Creates a deferred promise - a promise with externally accessible resolve/reject.
+ *
+ * This is useful when you need to resolve a promise from a different context
+ * than where it was created, such as:
+ * - Waiting for an event to fire (`await action`)
+ * - Coordinating between async operations
+ * - Building thenable objects
+ *
+ * @template T - The type of value the promise resolves to
+ * @returns A Deferred object with { promise, resolve, reject }
+ *
+ * @example
+ * ```ts
+ * const deferred = defer<string>();
+ *
+ * // Somewhere else in the code...
+ * setTimeout(() => {
+ *   deferred.resolve("done!");
+ * }, 1000);
+ *
+ * // Await the promise
+ * const result = await deferred.promise; // "done!"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Used internally by action() for thenable support:
+ * let nextDispatch = defer<T>();
+ *
+ * // When action is awaited:
+ * action.then(...) → nextDispatch.promise.then(...)
+ *
+ * // When action is dispatched:
+ * action(payload) → nextDispatch.resolve(payload)
+ * ```
+ */
+export function defer() {
+    // These will be assigned synchronously by the Promise executor
+    let resolve;
+    let reject;
+    // Create promise and capture resolve/reject from executor
+    const promise = new Promise((...args) => {
+        [resolve, reject] = args;
+    });
+    // Non-null assertions are safe because Promise executor runs synchronously
+    return { promise, resolve: resolve, reject: reject };
+}
+//# sourceMappingURL=defer.js.map

package/dist/defer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defer.js","sourceRoot":"","sources":["../src/defer.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,UAAU,KAAK;IACnB,+DAA+D;IAC/D,IAAI,OAA2B,CAAC;IAChC,IAAI,MAAgC,CAAC;IAErC,0DAA0D;IAC1D,MAAM,OAAO,GAAG,IAAI,OAAO,CAAI,CAAC,GAAG,IAAI,EAAE,EAAE;QACzC,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAC3B,CAAC,CAAC,CAAC;IAEH,2EAA2E;IAC3E,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAQ,EAAE,MAAM,EAAE,MAAO,EAAE,CAAC;AACzD,CAAC"}

package/dist/effect.d.ts

@@ -0,0 +1,91 @@
+import type { EffectContext, EffectOptions } from "./types";
+/**
+ * Creates a reactive effect that runs when its dependencies change.
+ *
+ * ## How It Works
+ *
+ * 1. Effect runs immediately on creation
+ * 2. During execution, any atom/signal reads are automatically tracked
+ * 3. When any tracked dependency changes, effect re-runs
+ * 4. Before each re-run, cleanup functions are called
+ * 5. Dependencies are re-tracked on each run (supports conditional reads)
+ *
+ * ## Key Characteristics
+ *
+ * - **Synchronous only**: Effects cannot be async (throws if you return a Promise)
+ * - **Auto-tracking**: Dependencies detected automatically via signal reads
+ * - **Cleanup support**: Register cleanup via `ctx.onCleanup()`
+ * - **Error handling**: Register error handlers via `ctx.onError()`
+ * - **Deduplication**: Multiple dependency changes in same tick = single re-run
+ *
+ * @param fn - The effect function to run. Receives an EffectContext.
+ * @param options - Optional configuration (key for debugging)
+ * @returns A dispose function to stop the effect permanently
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = atom(0);
+ *
+ * const dispose = effect((ctx) => {
+ *   console.log("Count:", count()); // count() is auto-tracked
+ * });
+ * // Output: "Count: 0"
+ *
+ * setCount(1);
+ * // Output: "Count: 1"
+ *
+ * dispose(); // Stop the effect
+ * setCount(2); // No output
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With cleanup for subscriptions/timers
+ * effect((ctx) => {
+ *   const interval = setInterval(() => tick(), 1000);
+ *   ctx.onCleanup(() => clearInterval(interval));
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With error handling
+ * effect((ctx) => {
+ *   ctx.onError((err) => console.error("Effect failed:", err));
+ *   if (data() === "bad") throw new Error("Invalid data");
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Conditional tracking - only re-runs when relevant deps change
+ * effect(() => {
+ *   if (showDetails()) {
+ *     // details() only tracked when showDetails() is true
+ *     console.log(details());
+ *   }
+ * });
+ * ```
+ */
+export declare function effect(fn: (context: EffectContext) => void, options?: EffectOptions): VoidFunction;
+/**
+ * Creates an effect instance without immediately running it.
+ *
+ * This is the internal factory used by `effect()`. It's exposed separately
+ * for cases where you need to control when the effect first runs (e.g., testing,
+ * or deferred initialization).
+ *
+ * @internal
+ * @param fn - The effect function
+ * @param options - Optional configuration
+ * @returns An object with { options, run, dispose }
+ */
+export declare function effectInstance(fn: (context: EffectContext) => void, options?: EffectOptions): {
+    /** Original options passed to effectInstance */
+    options: EffectOptions | undefined;
+    /** Manually trigger the effect to run */
+    run: () => void;
+    /** Stop the effect permanently */
+    dispose: () => void;
+};
+//# sourceMappingURL=effect.d.ts.map

package/dist/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../src/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAU,MAAM,SAAS,CAAC;AASpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAgB,MAAM,CACpB,EAAE,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,EACpC,OAAO,CAAC,EAAE,aAAa,GACtB,YAAY,CAMd;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,EACpC,OAAO,CAAC,EAAE,aAAa;IAsOrB,gDAAgD;;IAEhD,yCAAyC;;IAEzC,kCAAkC;;EAGrC"}

package/dist/effect.js

@@ -0,0 +1,311 @@
+import { emitter } from "./emitter";
+import { getHooks, withHooks } from "./hooks";
+import { isPromiseLike } from "./isPromiseLike";
+// ============================================================================
+// Effect - Reactive Side Effects
+// ============================================================================
+/**
+ * Creates a reactive effect that runs when its dependencies change.
+ *
+ * ## How It Works
+ *
+ * 1. Effect runs immediately on creation
+ * 2. During execution, any atom/signal reads are automatically tracked
+ * 3. When any tracked dependency changes, effect re-runs
+ * 4. Before each re-run, cleanup functions are called
+ * 5. Dependencies are re-tracked on each run (supports conditional reads)
+ *
+ * ## Key Characteristics
+ *
+ * - **Synchronous only**: Effects cannot be async (throws if you return a Promise)
+ * - **Auto-tracking**: Dependencies detected automatically via signal reads
+ * - **Cleanup support**: Register cleanup via `ctx.onCleanup()`
+ * - **Error handling**: Register error handlers via `ctx.onError()`
+ * - **Deduplication**: Multiple dependency changes in same tick = single re-run
+ *
+ * @param fn - The effect function to run. Receives an EffectContext.
+ * @param options - Optional configuration (key for debugging)
+ * @returns A dispose function to stop the effect permanently
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = atom(0);
+ *
+ * const dispose = effect((ctx) => {
+ *   console.log("Count:", count()); // count() is auto-tracked
+ * });
+ * // Output: "Count: 0"
+ *
+ * setCount(1);
+ * // Output: "Count: 1"
+ *
+ * dispose(); // Stop the effect
+ * setCount(2); // No output
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With cleanup for subscriptions/timers
+ * effect((ctx) => {
+ *   const interval = setInterval(() => tick(), 1000);
+ *   ctx.onCleanup(() => clearInterval(interval));
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With error handling
+ * effect((ctx) => {
+ *   ctx.onError((err) => console.error("Effect failed:", err));
+ *   if (data() === "bad") throw new Error("Invalid data");
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Conditional tracking - only re-runs when relevant deps change
+ * effect(() => {
+ *   if (showDetails()) {
+ *     // details() only tracked when showDetails() is true
+ *     console.log(details());
+ *   }
+ * });
+ * ```
+ */
+export function effect(fn, options) {
+    const instance = effectInstance(fn, options);
+    // Run immediately on creation
+    instance.run();
+    // Return dispose function for cleanup
+    return instance.dispose;
+}
+// ============================================================================
+// Effect Instance - Internal Implementation
+// ============================================================================
+/**
+ * Creates an effect instance without immediately running it.
+ *
+ * This is the internal factory used by `effect()`. It's exposed separately
+ * for cases where you need to control when the effect first runs (e.g., testing,
+ * or deferred initialization).
+ *
+ * @internal
+ * @param fn - The effect function
+ * @param options - Optional configuration
+ * @returns An object with { options, run, dispose }
+ */
+export function effectInstance(fn, options) {
+    const { key } = options ?? {};
+    // ---------------------------------------------------------------------------
+    // Internal State
+    // ---------------------------------------------------------------------------
+    /** True after dispose() is called - prevents further runs */
+    let disposed = false;
+    /**
+     * True when a re-run is scheduled but not yet executed.
+     * Used to deduplicate: if multiple deps change before next tick,
+     * we only run once.
+     */
+    let scheduled = false;
+    /**
+     * Error handler emitter. Lazily created when ctx.onError() is first called.
+     * If no error handler is registered and an error occurs, it propagates up.
+     */
+    let onErrorEmitter;
+    /**
+     * Cleanup handler emitter. Lazily created when ctx.onCleanup() is first called.
+     * Cleanup functions run:
+     * - Before each re-run (to clean up previous run's resources)
+     * - NOT on dispose (use dispose for final cleanup if needed)
+     */
+    let onCleanupEmitter;
+    /**
+     * Run counter. Starts at -1, incremented before each run.
+     * - First run: nth = 0
+     * - Second run: nth = 1
+     * - etc.
+     *
+     * Useful for skipping logic on first run:
+     * ```ts
+     * effect((ctx) => {
+     *   if (ctx.nth === 0) return; // Skip first run
+     *   // ... logic for subsequent runs only
+     * });
+     * ```
+     */
+    let nth = -1;
+    // ---------------------------------------------------------------------------
+    // Context Builders
+    // ---------------------------------------------------------------------------
+    /**
+     * Registers a cleanup function to run before the next effect execution.
+     *
+     * Note: Cleanup does NOT run on dispose - only before re-runs.
+     * This matches React's useEffect cleanup behavior.
+     */
+    const onCleanup = (listener) => {
+        // Lazy creation of cleanup emitter
+        if (!onCleanupEmitter)
+            onCleanupEmitter = emitter();
+        return onCleanupEmitter.on(listener);
+    };
+    /**
+     * Registers an error handler for this effect.
+     *
+     * If an error handler is registered, errors are caught and passed to handlers
+     * instead of propagating up. If no handler is registered, errors throw normally.
+     */
+    const onError = (listener) => {
+        // Lazy creation of error emitter
+        if (!onErrorEmitter)
+            onErrorEmitter = emitter();
+        return onErrorEmitter.on(listener);
+    };
+    // ---------------------------------------------------------------------------
+    // Core Run Logic
+    // ---------------------------------------------------------------------------
+    /**
+     * Executes the effect function and sets up dependency tracking.
+     *
+     * Execution flow:
+     * 1. Clear scheduled flag
+     * 2. Exit early if disposed
+     * 3. Run cleanup functions from previous run
+     * 4. Clear error handlers (fresh set for this run)
+     * 5. Increment run counter
+     * 6. Execute effect function with hooks for dependency tracking
+     * 7. Check for async (throw if Promise returned)
+     * 8. Subscribe to all tracked dependencies
+     */
+    const run = () => {
+        // Step 1: Clear scheduled flag (we're running now)
+        scheduled = false;
+        // Step 2: Exit if disposed
+        if (disposed)
+            return;
+        // Step 3: Run cleanup from previous run
+        // emitAndClear() calls all listeners then removes them
+        onCleanupEmitter?.emitAndClear();
+        // Step 4: Clear error handlers (user registers fresh ones each run)
+        onErrorEmitter?.clear();
+        // Step 5: Increment run counter
+        nth++;
+        // Track which signals are read during this execution
+        const signals = new Set();
+        try {
+            // Build the context object passed to the effect function
+            const ctx = {
+                nth,
+                key,
+                onError,
+                onCleanup,
+                /**
+                 * Plugin system for extending context functionality.
+                 * Same pattern as OnContext.use() in actions.
+                 */
+                use(plugin, ...args) {
+                    return plugin(ctx, ...args);
+                },
+            };
+            // Step 6: Execute effect with hooks enabled
+            // withHooks() sets up the tracking context so that:
+            // - Any signal.on() call during execution triggers track()
+            // - scheduleCleanup is available for nested subscriptions
+            const result = withHooks({
+                // Register cleanup handlers for subscriptions created during effect
+                scheduleCleanup: onCleanup,
+                // Track signals that are read during effect execution
+                track(signal) {
+                    signals.add(signal);
+                },
+            }, () => fn(ctx));
+            // Step 7: Check for async functions (common mistake)
+            // Effects must be synchronous for predictable dependency tracking
+            if (isPromiseLike(result)) {
+                throw new Error("effect() received an async function. Effects must be synchronous. " +
+                    "Use event().on() for async operations instead.");
+            }
+        }
+        catch (error) {
+            // Handle errors: if error handler registered, emit to it
+            // Otherwise, re-throw the error
+            if (onErrorEmitter && onErrorEmitter.size > 0) {
+                onErrorEmitter.emitAndClear(error);
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            // Step 8: Subscribe to all tracked dependencies
+            // When any dependency changes, schedule a re-run
+            // The subscription itself is registered as a cleanup, so it's
+            // automatically removed before the next run (then re-added with fresh deps)
+            signals.forEach((signal) => onCleanup(signal.on(scheduleRun)));
+        }
+    };
+    // ---------------------------------------------------------------------------
+    // Scheduling
+    // ---------------------------------------------------------------------------
+    /**
+     * Schedules an effect re-run on the next tick.
+     *
+     * This is called when any tracked dependency changes.
+     * Deduplication: if multiple deps change before next tick, only runs once.
+     *
+     * Uses hooks.scheduleNotify() which typically queues to microtask,
+     * allowing multiple sync updates to batch into single effect run.
+     */
+    const scheduleRun = () => {
+        // Skip if already scheduled or disposed
+        if (scheduled || disposed)
+            return;
+        scheduled = true;
+        // Queue the run for next microtask
+        getHooks().scheduleNotify(run);
+    };
+    // ---------------------------------------------------------------------------
+    // Disposal
+    // ---------------------------------------------------------------------------
+    /**
+     * Permanently stops the effect.
+     *
+     * After dispose:
+     * - No more runs will occur
+     * - Error and cleanup handlers are cleared
+     * - Subscriptions are NOT explicitly cleaned up here - they'll be
+     *   garbage collected when the effect instance is no longer referenced
+     */
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        // Clear emitters to release handler references
+        onErrorEmitter?.clear();
+        onCleanupEmitter?.emitAndClear();
+    };
+    // ---------------------------------------------------------------------------
+    // Hook Integration
+    // ---------------------------------------------------------------------------
+    /**
+     * Register this effect's dispose with the current hooks context.
+     *
+     * This enables automatic cleanup when effects are created inside:
+     * - React components (via useRx internals)
+     * - Other effects (nested effects dispose with parent)
+     * - Test harnesses
+     *
+     * If no scheduleCleanup hook is set, this is a no-op.
+     */
+    getHooks().scheduleCleanup?.(dispose);
+    // Return the effect instance interface
+    return {
+        /** Original options passed to effectInstance */
+        options,
+        /** Manually trigger the effect to run */
+        run,
+        /** Stop the effect permanently */
+        dispose,
+    };
+}
+//# sourceMappingURL=effect.js.map

package/dist/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","sourceRoot":"","sources":["../src/effect.ts"],"names":[],"mappings":"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"}

package/dist/effect.test.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"effect.test.d.ts","sourceRoot":"","sources":["../src/effect.test.ts"],"names":[],"mappings":""}