nanoeffects 0.0.0-stage → 0.2.0

package/dist/notrace/effects.d.ts

@@ -0,0 +1,284 @@
+import { A as Keys, N as Task, k as EventMap, u as Context } from "./action-rqZEnRIp.js";
+//#region src/utils/delay.d.ts
+/**
+ * Resolves after `ms`, or rejects early if `ctx.signal` aborts. `ms` can be a
+ * function that returns the number of ms, called once when the delay starts:
+ * handy for a random pause (jitter).
+ *
+ * @example
+ * ```ts
+ * await delay({}, 500);
+ *
+ * // 200 to 400 ms
+ * await delay({}, () => 200 + Math.random() * 200);
+ *
+ * // inside a task: stops waiting when the task is aborted
+ * bus.on("retry", async (_, ctx) => {
+ *   await delay(ctx, 1000);
+ *   await load();
+ * });
+ * ```
+ */
+export declare const delay: (ctx: {
+  signal?: AbortSignal | undefined;
+}, ms: number | (() => number)) => Promise<void>;
+//#endregion
+//#region src/utils/onAbort.d.ts
+export declare const onAbort: (ctx: {
+  signal?: AbortSignal | undefined;
+}, fn: (reason: unknown) => void) => (() => void);
+//#endregion
+//#region src/effects/run.d.ts
+/** Context passed into `race` / `all` effect starters. */
+type EffectContext = {
+  signal: AbortSignal;
+  abort: (reason?: unknown) => void;
+};
+type Starter<T> = (ctx: EffectContext) => T | PromiseLike<T>;
+//#endregion
+//#region src/effects/all.d.ts
+/**
+ * Runs all starters; waits for every result. On failure or parent abort, cancels the rest.
+ *
+ * @example
+ * ```ts
+ * bus.on("load", async (id, ctx) => {
+ *   const { user, posts } = await all(ctx, {
+ *     user: ({ signal }) => fetchUser(id, { signal }),
+ *     posts: ({ signal }) => fetchPosts(id, { signal }),
+ *   });
+ *
+ *   // arrays work too: const [user, posts] = await all(ctx, [getUser, getPosts]);
+ * });
+ * ```
+ */
+export declare function all<T extends Record<string, Starter<unknown>>>(ctx: {
+  signal?: AbortSignal;
+}, effects: T): Promise<{ [K in keyof T]: Awaited<ReturnType<T[K]>>; }>;
+export declare function all<const T extends readonly Starter<unknown>[]>(ctx: {
+  signal?: AbortSignal;
+}, effects: T): Promise<{ -readonly [K in keyof T]: Awaited<ReturnType<T[K]>>; }>;
+//#endregion
+//#region src/effects/allSettled.d.ts
+/**
+ * Runs all starters and waits for every one to settle, whether it succeeds or
+ * fails: nothing is cancelled when a starter fails. The result has, for each
+ * starter, `{ status: "fulfilled", value }` or `{ status: "rejected", reason }`.
+ * Only an abort of `ctx` rejects it, with the abort reason.
+ *
+ * @example
+ * ```ts
+ * bus.on("load", async (id, ctx) => {
+ *   const { user, posts } = await allSettled(ctx, {
+ *     user: ({ signal }) => fetchUser(id, { signal }),
+ *     posts: ({ signal }) => fetchPosts(id, { signal }),
+ *   });
+ *
+ *   if (user.status === "fulfilled") render(user.value);
+ * });
+ * ```
+ */
+export declare function allSettled<T extends Record<string, Starter<unknown>>>(ctx: {
+  signal?: AbortSignal;
+}, effects: T): Promise<{ [K in keyof T]: PromiseSettledResult<Awaited<ReturnType<T[K]>>>; }>;
+export declare function allSettled<const T extends readonly Starter<unknown>[]>(ctx: {
+  signal?: AbortSignal;
+}, effects: T): Promise<{ -readonly [K in keyof T]: PromiseSettledResult<Awaited<ReturnType<T[K]>>>; }>;
+//#endregion
+//#region src/effects/cancellable.d.ts
+type CancellableHandle<T> = {
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: unknown) => void;
+  /** Registers a cleanup that runs if the promise is cancelled before it settles. */
+  onCancel: (cleanup: () => void) => void;
+};
+type CancellableExecutor<T> = (handle: CancellableHandle<T>) => void;
+/**
+ * A promise tied to `ctx.signal`. It works like `new Promise`, but the
+ * executor gets one object, `{ resolve, reject, onCancel }`. If the signal
+ * aborts before the promise settles, the cleanups run (last registered first)
+ * and the promise rejects with the abort reason. If the signal is already
+ * aborted, the executor does not run. After the promise settles, the abort
+ * listener is removed and the cleanups are dropped.
+ *
+ * @example
+ * ```ts
+ * bus.on(
+ *   "wait",
+ *   latest((_, ctx) =>
+ *     cancellable(ctx, ({ resolve, onCancel }) => {
+ *       const timer = setTimeout(resolve, 5000);
+ *       onCancel(() => clearTimeout(timer));
+ *     }),
+ *   ),
+ * );
+ * ```
+ */
+export declare const cancellable: <T = void>(ctx: {
+  signal: AbortSignal;
+}, executor: CancellableExecutor<T>) => Promise<T>;
+//#endregion
+//#region src/effects/poll.d.ts
+type PollOptions = {
+  /** Also call `fn` at once, not only after the first `ms`. Default `false`. */
+  leading?: boolean;
+  /**
+   * Start the pause after a call finishes, so calls never overlap. By default
+   * the calls come every `ms` whatever the duration of `fn`.
+   */
+  waitForFn?: boolean;
+};
+/**
+ * Calls a function every `ms`, like patronum `interval`: the first call comes
+ * after `ms` (with `leading` also at once), and the next ticks keep a steady
+ * rate whatever the duration of the function, so a slow one may overlap with
+ * the next call (`waitForFn` starts each pause when the call ends instead). An
+ * error stops the polling and rejects; an abort of the caller ends it without
+ * an error and clears the timer. Two forms:
+ *
+ * - `poll(ms, task, options)` wraps a Task `(payload, ctx) => result` and
+ *   returns a Task. Each call gets a context of its own, a child of the
+ *   caller's: `bus.on("watch", poll(10_000, refresh))`.
+ * - `poll(ctx, fn, ms, options)` is for one call inside a body; `fn` gets the
+ *   number of the call, starting at 0.
+ *
+ * `ms` can be a function of the number of the call that the pause leads to, for
+ * a growing or random pause: `(call) => Math.min(1000 * 2 ** call, 60_000)`.
+ *
+ * @example
+ * ```ts
+ * bus.on("watch", poll(10_000, (_, { signal }) => refresh({ signal })));
+ *
+ * bus.on("watch", async (_, ctx) => {
+ *   await poll(ctx, () => refresh(), 10_000);
+ * });
+ * ```
+ */
+type PollMs = number | ((call: number) => number);
+export declare function poll<P, E extends EventMap, R>(ms: PollMs, task: Task<P, E, R>, options?: PollOptions): Task<P, E, Promise<void>>;
+export declare function poll(ctx: {
+  signal: AbortSignal;
+}, fn: (tick: number) => unknown, ms: PollMs, options?: PollOptions): Promise<void>;
+//#endregion
+//#region src/effects/race.d.ts
+type RaceStarter<T> = Starter<T>;
+/**
+ * Runs all starters; first to settle wins, losers are cancelled via `ctx.abort`.
+ * The result holds only the winner's value, under its key or index.
+ *
+ * @example
+ * ```ts
+ * bus.on("load", async (id, ctx) => {
+ *   const result = await race(ctx, {
+ *     data: ({ signal }) => fetchData(id, { signal }),
+ *     timeout: ({ signal }) => delay({ signal }, 5000),
+ *   });
+ *
+ *   if ("timeout" in result) throw new Error("timed out");
+ *   render(result.data);
+ * });
+ * ```
+ */
+export declare function race<T extends Record<string, RaceStarter<unknown>>>(ctx: {
+  signal?: AbortSignal;
+}, effects: T): Promise<{ [K in keyof T]?: Awaited<ReturnType<T[K]>>; }>;
+export declare function race<const T extends readonly RaceStarter<unknown>[]>(ctx: {
+  signal?: AbortSignal;
+}, effects: T): Promise<{ -readonly [K in keyof T]?: Awaited<ReturnType<T[K]>>; }>;
+//#endregion
+//#region src/effects/retry.d.ts
+type RetryOptions = {
+  /** Total number of attempts, the first one included. Default 3. */
+  times?: number;
+  /**
+   * Pause before the next attempt, in ms: a number, or a function of the
+   * number of the attempt that just failed and its error. Default 0.
+   */
+  delay?: number | ((attempt: number, error: unknown) => number);
+  /** Return `false` to stop retrying and throw `error`. Default: always retry. */
+  shouldRetry?: (error: unknown, attempt: number) => boolean;
+};
+/**
+ * Calls a function until it succeeds or `times` attempts are used, then throws
+ * the last error. If the caller aborts, retrying stops and the result rejects
+ * with the abort reason. Two forms:
+ *
+ * - `retry(task, options)` wraps a Task `(payload, ctx) => result` and returns
+ *   a Task. Each attempt gets a context of its own, a child of the caller's, so
+ *   it can go straight into `on` and into `ctx.run`:
+ *   `bus.on("load", latest(retry(load, { times: 4 })))`. The number of the
+ *   attempt is not passed; use the other form when it is needed.
+ * - `retry(ctx, fn, options)` is for one call inside a body. `fn` gets the
+ *   number of the attempt, starting at 1.
+ *
+ * @example
+ * ```ts
+ * bus.on("load", latest(retry(loadUser, { times: 4, delay: (attempt) => 2 ** attempt * 100 })));
+ *
+ * bus.on("load", async (id, ctx) => {
+ *   const user = await retry(ctx, () => fetchUser(id, { signal: ctx.signal }), { times: 4 });
+ * });
+ * ```
+ */
+type RetryFn<T> = (attempt: number) => T | PromiseLike<T>;
+export declare function retry<P, E extends EventMap, R>(task: Task<P, E, R>, options?: RetryOptions): Task<P, E, Promise<Awaited<R>>>;
+export declare function retry<T>(ctx: {
+  signal?: AbortSignal;
+}, fn: RetryFn<T>, options?: RetryOptions): Promise<T>;
+//#endregion
+//#region src/effects/take.d.ts
+type TakeOptions<P> = {
+  /** Wait for the first payload this accepts; others are skipped. */
+  predicate?: (payload: P) => boolean;
+  /** Stop waiting when this aborts, e.g. the signal of a `race` starter. */
+  signal?: AbortSignal | undefined;
+};
+/**
+ * Waits for the next `event` on the bus and resolves with its payload. It sees
+ * only events emitted after the call, takes only one, and unsubscribes when it
+ * is done. If `ctx` (or `options.signal`) aborts first, it unsubscribes and
+ * rejects with the abort reason.
+ *
+ * @example
+ * ```ts
+ * bus.on("login", async (user, ctx) => {
+ *   const reason = await take(ctx, "logout");
+ *   cleanup(user, reason);
+ * });
+ *
+ * // wait for a matching event, but not longer than 5 s
+ * const done = await timeout(ctx, 5000, ({ signal }) =>
+ *   take(ctx, "saved", { signal, predicate: (id) => id === draftId }),
+ * );
+ * ```
+ */
+export declare const take: <E extends EventMap, K extends Keys<E>>(ctx: Context<E>, event: K, options?: TakeOptions<E[K]>) => Promise<E[K]>;
+//#endregion
+//#region src/effects/timeout.d.ts
+/**
+ * Runs a function; if it takes longer than `ms`, aborts its signal and rejects
+ * with a `TimeoutError` (a `DOMException`, like `AbortSignal.timeout`), even if
+ * it ignores the signal. If the caller aborts, rejects with its reason. Two
+ * forms:
+ *
+ * - `timeout(ms, task)` wraps a Task `(payload, ctx) => result` and returns a
+ *   Task. The Task gets a context of its own whose `signal` the time limit
+ *   aborts: `bus.on("load", latest(timeout(5000, load)))`.
+ * - `timeout(ctx, ms, starter)` is for one call inside a body; `starter` gets
+ *   `{ signal, abort }`.
+ *
+ * @example
+ * ```ts
+ * bus.on("load", timeout(5000, (id, { signal }) => fetchData(id, { signal })));
+ *
+ * bus.on("load", async (id, ctx) => {
+ *   const data = await timeout(ctx, 5000, ({ signal }) => fetchData(id, { signal }));
+ * });
+ * ```
+ */
+export declare function timeout<P, E extends EventMap, R>(ms: number, task: Task<P, E, R>): Task<P, E, Promise<Awaited<R>>>;
+export declare function timeout<T>(ctx: {
+  signal?: AbortSignal;
+}, ms: number, starter: Starter<T>): Promise<T>;
+//#endregion
+export type { CancellableExecutor, CancellableHandle, EffectContext, PollOptions, RaceStarter, RetryOptions, TakeOptions };

package/dist/notrace/effects.js

@@ -0,0 +1 @@
+import{a as e,c as t,i as n,o as r,s as i,t as a}from"./context-yAWj0BFZ.js";import{n as o,r as s,t as c}from"./delay-Cgvn16oY.js";const l=(e,t)=>t?.signal?new Promise((n,r)=>{let a=i(t,r);e.then(n,r).finally(a)}):e,u=async(e,t,o,s)=>{t?.signal?.throwIfAborted();let{ctx:c,unlink:u}=n(t??{}),d=a(c,e);r(c,e,`start`),i(c,()=>d(`cancel`));try{let e=await l(o(c),t);return d(`done`),s?.(!1),e}catch(e){throw d(`error`,e),s?.(!0),e}finally{u()}},d=async(t,r)=>{let{ctx:i,unlink:a}=n(t);try{return await e(i,`run`,()=>r(i))}finally{a()}},f=e=>e,p=(e,t)=>n=>e(t,f(n)),m=e=>Array.isArray(e)?Array(e.length):{},h=(t,r)=>{let i=Object.entries(r).map(([r,i])=>{let a=n(t),o={signal:a.ctx.signal,abort:a.ctx.abort},s=()=>i(o);return{key:r,task:new Promise(t=>t(e(a.ctx,`run`,s))).finally(a.unlink),cancel:a.ctx.abort}});return{tasks:i.map(({key:e,task:t})=>[e,t]),cancelAll:()=>{for(let e of i)e.cancel()}}},g=(e,t,n,r,i)=>{let a=()=>{};return u(e,t,async e=>{let t=h(e,n);return a=t.cancelAll,r(t.tasks)},e=>{(e||i===`end`)&&a()})};function _(e,t){return g(`all`,e,t,async e=>{let n=await Promise.all(e.map(([,e])=>e)),r=m(t);for(let[t,[i]]of e.entries())r[i]=n[t];return r},`failure`)}const v=e=>e.then(e=>({status:`fulfilled`,value:e}),e=>({status:`rejected`,reason:e}));function y(e,t){return g(`allSettled`,e,t,async e=>{let n=await Promise.all(e.map(([,e])=>v(e))),r=m(t);for(let[t,[i]]of e.entries())r[i]=n[t];return r},`failure`)}const b=(e,n)=>e.signal.aborted?Promise.reject(e.signal.reason):new Promise((r,a)=>{let o=[],s=`pending`,c=e=>{try{e()}catch(e){t(`cancel cleanup failed`,e)}},l=i(e,e=>{s=`cancelled`;for(let e of o.reverse())c(e);a(e)}),u=e=>(...t)=>{s===`pending`&&(s=`settled`,l(),o.length=0,e(...t))},d=e=>{s===`pending`?o.push(e):s===`cancelled`&&c(e)};try{n({resolve:u(r),reject:u(a),onCancel:d})}catch(e){u(a)(e)}}),x=(e,t,n,r)=>{if(e.signal.aborted)return Promise.resolve();let a=r.leading??!1,c=r.waitForFn??!1;return u(`poll`,e,e=>new Promise((r,l)=>{let u=0,f=null,p=()=>{f!==null&&(o(f),f=null)},m=e=>{try{f=s(h,typeof n==`function`?n(e):n)}catch(e){p(),l(e)}},h=()=>{f=null,c||m(u+1),g()},g=()=>{let n=u++;d(e,e=>t(e,n)).then(()=>{c&&!e.signal.aborted&&m(u)},e=>{p(),l(e)})};i(e,p),a?(g(),c||m(u)):m(0)})).catch(t=>{if(!e.signal.aborted)throw t})};function S(e,t,n,r={}){if(typeof e!=`object`){let r=t,i=n??{};return(t,n)=>x(n,p(r,t),e,i)}let i=t;return x(e,(e,t)=>i(t),n,r)}function C(e,t){let n=m(t);return Object.keys(t).length===0?Promise.resolve(n):g(`race`,e,t,async e=>{let[t,r]=await Promise.race(e.map(([e,t])=>t.then(t=>[e,t])));return n[t]=r,n},`end`)}const w=(e,t,n)=>typeof e==`function`?e(t,n):e,T=e=>({times:e.times??3,delay:e.delay??0,shouldRetry:e.shouldRetry??(()=>!0)}),E=(e,t,n)=>u(`retry`,e,async e=>{let{times:r,delay:i,shouldRetry:a}=T(n);for(let n=1;;n++)try{return await d(e,e=>t(e,n))}catch(t){if(e.signal.throwIfAborted(),n>=r||!a(t,n))throw t;let o=w(i,n,t);o>0&&await c(e,o)}});function D(e,t,n={}){if(typeof e==`function`){let n=e;return(e,r)=>E(r,p(n,e),t??{})}let r=t;return E(e,(e,t)=>r(t),n)}const O=(e,t,n={})=>u(`take`,e,r=>new Promise((a,o)=>{let{predicate:s}=n,c=[],l=()=>{for(let e of c)e()},u=e=>{l(),o(e)};c.push(e.on(t,e=>{(!s||s(e))&&(l(),a(e))})),c.push(i(r,u)),c.push(i({signal:n.signal},u))})),k=(t,r,i)=>u(`timeout`,t,async t=>{let a=n(t),c=s(()=>a.ctx.abort(new DOMException(`Timed out after ${r}ms`,`TimeoutError`)),r);try{return await l(Promise.resolve(e(a.ctx,`run`,()=>i(a.ctx))),a.ctx)}finally{o(c),a.unlink()}});function A(e,t,n){if(typeof e==`number`){let n=t;return(t,r)=>k(r,e,p(n,t))}let r=t,i=n;return k(e,r,e=>i({signal:e.signal,abort:e.abort}))}export{_ as all,y as allSettled,b as cancellable,c as delay,i as onAbort,S as poll,C as race,D as retry,O as take,A as timeout};

package/dist/notrace/event-0RIBGYqS.js

@@ -0,0 +1 @@
+const e=e=>typeof e==`string`?e:e.type,t=(e,t)=>typeof e==`object`?e.payload:t;export{t as n,e as t};

package/dist/notrace/index.d.ts

@@ -0,0 +1,2 @@
+import { A as Keys, C as WithPayload, D as anyEventType, E as Tracer, F as TraceEvent, I as TraceLogger, L as UnsubscribeCallback, M as Phase, N as Task, O as EffectName, P as Trace, S as WithContext, T as createBus, _ as EventPayload, a as AnyEvent, b as Off, c as Command, d as ContextOf, f as ContextOption, g as EventLike, h as EventKey, i as Action, j as PayloadOf, k as EventMap, l as Commands, m as Emittable, o as Bus, p as Emit, s as BusOptions, u as Context, v as Handler, w as WithType, x as On, y as HandlerRef } from "./action-rqZEnRIp.js";
+export { type Action, type AnyEvent, type Bus, type BusOptions, type Command, type Commands, type Context, type ContextOf, type ContextOption, type EffectName, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type Handler, type HandlerRef, type Keys, type Off, type On, type PayloadOf, type Phase, type Task, type Trace, type TraceEvent, type TraceLogger, type Tracer, type UnsubscribeCallback, type WithContext, type WithPayload, type WithType, anyEventType, createBus };

package/dist/notrace/index.js

@@ -0,0 +1 @@
+export{n as anyEventType,t as createBus}from"./bus-Dx0l9X6h.js";

package/dist/notrace/policies.d.ts

@@ -0,0 +1,171 @@
+import { N as Task, k as EventMap } from "./action-rqZEnRIp.js";
+//#region src/policies/keyed.d.ts
+/** Options shared by every policy that can keep its state per key. */
+type KeyOption<P> = {
+  /**
+   * Gives each key its own state: calls with different keys do not affect
+   * each other. The state of a key is dropped when that key goes idle, so
+   * keys can be unbounded (ids, urls).
+   */
+  key?: (payload: P) => unknown;
+};
+//#endregion
+//#region src/policies/debounce.d.ts
+type DebounceResult<R> = Promise<R | undefined> | Promise<Awaited<R> | undefined> | undefined;
+type DebounceOptions<P = never> = KeyOption<P> & {
+  /** Run the first call of a burst at once. Default `false`. */
+  leading?: boolean;
+  /** Run the last call of a burst after `ms` of quiet. Default `true`. */
+  trailing?: boolean;
+};
+/**
+ * Waits for `ms` of quiet, then runs; a new call restarts the wait and drops
+ * the previous. With `leading` the first call of a burst runs at once, and the
+ * trailing run happens only if more calls follow it. With `trailing: false`
+ * only the leading call runs. With `options.key` each key has its own wait.
+ *
+ * @example
+ * ```ts
+ * bus.on(
+ *   "input",
+ *   debounce(300, async (text, { signal }) => {
+ *     const res = await fetch(`/api?q=${text}`, { signal });
+ *     showResults(await res.json());
+ *   }),
+ * );
+ *
+ * bus.emit("input", "r");
+ * bus.emit("input", "re"); // only the last call runs, 300 ms after it
+ * ```
+ */
+export declare const debounce: <P, E extends EventMap, R>(ms: number, fn: Task<P, E, R>, options?: DebounceOptions<P>) => Task<P, E, DebounceResult<R>>;
+//#endregion
+//#region src/policies/latest.d.ts
+type LatestOptions<P = never> = KeyOption<P>;
+/**
+ * Aborts the previous run when a new call arrives; stale results are dropped.
+ * With `options.key` each key has its own latest run.
+ *
+ * @example
+ * ```ts
+ * bus.on(
+ *   "search",
+ *   latest(async (query, { signal }) => {
+ *     const res = await fetch(`/api?q=${query}`, { signal });
+ *     showResults(await res.json());
+ *   }),
+ * );
+ *
+ * bus.emit("search", "re"); // aborted by the next call
+ * bus.emit("search", "redux"); // only this one finishes
+ *
+ * // one latest run per user instead of one for all
+ * bus.on("load", latest(loadUser, { key: (user) => user.id }));
+ * ```
+ */
+export declare const latest: <P, E extends EventMap, R>(fn: Task<P, E, R>, options?: LatestOptions<P>) => Task<P, E, R | Promise<Awaited<R> | undefined> | undefined>;
+//#endregion
+//#region src/policies/leading.d.ts
+type LeadingOptions<P = never> = KeyOption<P>;
+/**
+ * Drops new calls while the task is still running. The lock is released when
+ * the run settles or when its task is aborted, whichever comes first, so a
+ * `fn` that ignores the abort signal may overlap with the next run. With
+ * `options.key` each key has its own lock.
+ *
+ * @example
+ * ```ts
+ * bus.on(
+ *   "save",
+ *   leading(async (draft) => {
+ *     await api.save(draft);
+ *   }),
+ * );
+ *
+ * bus.emit("save", draft); // runs
+ * bus.emit("save", draft); // dropped while the first save is in flight
+ * ```
+ */
+export declare const leading: <P, E extends EventMap, R>(fn: Task<P, E, R>, options?: LeadingOptions<P>) => Task<P, E, R | Promise<Awaited<R>> | undefined>;
+//#endregion
+//#region src/policies/queue.d.ts
+type QueueOptions<P = never> = KeyOption<P> & {
+  /** How many calls may run at the same time. Default 1. */
+  concurrency?: number;
+  /** How many calls may wait for a free slot. Default: no limit. */
+  limit?: number;
+  /**
+   * What to drop when a call arrives and `limit` calls already wait: the new
+   * call (`"drop-new"`, the default) or the oldest waiting one (`"drop-old"`,
+   * which keeps the most recent calls). A dropped call resolves with `undefined`.
+   */
+  overflow?: "drop-new" | "drop-old";
+};
+/**
+ * Runs calls one after another, in the order they arrived: a call starts when
+ * fewer than `concurrency` calls are running. Every call returns a promise with
+ * the result of its own run; an error rejects only that call, and the queue
+ * goes on. The first call on an idle queue starts synchronously.
+ *
+ * With `limit` the number of waiting calls is capped. `limit: 1` with
+ * `overflow: "drop-old"` keeps only the latest call while one is running, and
+ * runs it when the current one is done.
+ *
+ * With `options.key` each key has its own line.
+ *
+ * A call whose task aborts while it waits is skipped and resolves with
+ * `undefined`. When the task of a running call aborts, its slot is freed at
+ * once and its result is dropped; a `fn` that ignores the abort signal can
+ * then overlap with the next run.
+ *
+ * @example
+ * ```ts
+ * bus.on(
+ *   "save",
+ *   queue(async (draft, { signal }) => {
+ *     await api.save(draft, { signal });
+ *   }),
+ * );
+ *
+ * bus.emit("save", a); // runs
+ * bus.emit("save", b); // waits for a, then runs
+ * ```
+ */
+export declare const queue: <P, E extends EventMap, R>(fn: Task<P, E, R>, options?: QueueOptions<P>) => Task<P, E, Promise<Awaited<R> | undefined>>;
+//#endregion
+//#region src/policies/throttle.d.ts
+type ThrottleOptions<P = never> = KeyOption<P> & {
+  /** Run the first call at once, when the throttle is idle. Default `true`. */
+  leading?: boolean;
+  /** Run the latest call made while waiting, at the end of the window. Default `true`. */
+  trailing?: boolean;
+};
+/**
+ * At most one run per `ms`, with the semantics of lodash `throttle` (and
+ * patronum): a call made when the throttle is idle, that is, at least `ms`
+ * after the previous call and the previous run, runs at once (`leading`); calls
+ * made while it waits are held, and the latest of them runs when the window
+ * closes (`trailing`). Under a steady stream of calls it runs every `ms`.
+ *
+ * A held call returns a promise that settles with its result; calls superseded
+ * by a newer one, or not allowed to wait (`trailing: false`), resolve with
+ * `undefined`. With `leading: false` even the first call waits for the end of
+ * its window. With `options.key` each key has its own throttle.
+ *
+ * @example
+ * ```ts
+ * bus.on(
+ *   "scroll",
+ *   throttle(200, (position) => {
+ *     saveScrollPosition(position);
+ *   }),
+ * );
+ *
+ * bus.emit("scroll", 10); // runs now
+ * bus.emit("scroll", 20); // superseded
+ * bus.emit("scroll", 30); // runs once the 200 ms window closes
+ * ```
+ */
+export declare const throttle: <P, E extends EventMap, R>(ms: number, fn: Task<P, E, R>, options?: ThrottleOptions<P>) => Task<P, E, R | Promise<R | undefined> | undefined>;
+//#endregion
+export type { DebounceOptions, LatestOptions, LeadingOptions, QueueOptions, ThrottleOptions };

package/dist/notrace/policies.js

@@ -0,0 +1 @@
+import{a as e,i as t,o as n,s as r,t as i}from"./context-yAWj0BFZ.js";import{n as a,r as o,t as s}from"./delay-Cgvn16oY.js";import{n as c,t as l}from"./promise-CSLpzwSR.js";const u=()=>{},d=(e,t)=>{let n=/* @__PURE__ */ new Map;return(r,i)=>{let a=e(r),o=n.get(a);if(!o){let e=t(()=>{n.get(a)===e&&n.delete(a)});o=e,n.set(a,e)}return o(r,i)}},f=(e,t)=>e?d(e,t):t(u),p=(e,t={})=>f(t.key,t=>m(`latest`,(t,n,r)=>(r(),e(t,n)),t)),m=(e,a,o=u)=>{let s=null;return(l,u)=>{if(s?.abort(),u.signal.aborted)return;let{ctx:d,unlink:f}=t(u);s=d;let p=i(d,e),m=!1,h=()=>{d.signal.aborted||(m=!0,n(d,e,`start`))};r(d,()=>p(m?`cancel`:`drop`));let g=()=>{f(),s===d&&(s=null,o())},_=e=>{if(!d.signal.aborted)return p(m?`done`:`drop`),e};try{let e=a(l,d,h);return c(e)?Promise.resolve(e).then(_,e=>{if(!d.signal.aborted)throw p(`error`,e),e}).finally(g):(g(),_(e))}catch(e){if(g(),d.signal.aborted)return;throw p(`error`,e),e}}},h=(e,t,n={})=>f(n.key,r=>_(e,t,n,r)),g=(t,r,i,s)=>{let c=s!==u,l=null,d=null;return(u,f)=>{if(f.signal.aborted)return;let p=Date.now(),m=l===null||p-l>=t||p-l<0;return l=p,d!==null&&a(d),d=c?o(s,t):null,i&&m?Promise.resolve(e(f,`debounce`,()=>r(u,f))):(n(f,`debounce`,`drop`),Promise.resolve(void 0))}},_=(t,n,i,a)=>{let o=i.leading??!1,c=i.trailing??!0;if(!c)return g(t,n,o,a);let l=!1,u=0,d=m(`debounce`,([e,i],a,o)=>{let d=u;return r(a,()=>{u===d&&(l=!1)}),s(a,t).then(()=>{if(l=!1,c&&!i)return o(),n(e,a)})},a);return(t,r)=>{if(r.signal.aborted)return;let i=o&&!l;l=!0,u++;let a=d([t,i],r);return i?Promise.resolve(e(r,`debounce`,()=>n(t,r))):a}},v=(t,i={})=>f(i.key,i=>{let a=null;return(o,s)=>{if(s.signal.aborted)return;if(a){n(s,`leading`,`drop`);return}let c={};a=c;let u=()=>{d(),a===c&&(a=null,i())},d=r(s,u);try{return l(e(s,`leading`,()=>t(o,s)),u)}catch(e){throw u(),e}}}),y=(e,t={})=>f(t.key,n=>b(e,t,n)),b=(t,i,a)=>{let o=i.concurrency??1,s=i.limit??1/0,c=[],l=0,d=()=>{for(;l<o;){let e=c.shift();if(!e)return;e.start()}};return(f,p)=>new Promise((m,h)=>{if(p.signal.aborted){m(void 0);return}let g=u,_=()=>{g(),n(p,`queue`,`drop`),m(void 0)},v=()=>{if(g(),p.signal.aborted){_();return}l++;let n=!0,i=()=>{n&&(n=!1,l--,d(),l===0&&c.length===0&&a())},o=r(p,()=>{i(),m(void 0)}),s;try{s=Promise.resolve(e(p,`queue`,()=>t(f,p)))}catch(e){s=Promise.reject(e)}let u=()=>{o(),i()};s.then(e=>{u(),m(p.signal.aborted?void 0:e)},e=>{u(),p.signal.aborted?m(void 0):h(e)})};if(l<o){v();return}if(c.length>=s){if(i.overflow!==`drop-old`||s<=0){_();return}c.shift()?.drop()}let y={start:v,drop:_};c.push(y),g=r(p,()=>{let e=c.indexOf(y);e>=0&&c.splice(e,1),_()})})},x=(e,t,n={})=>f(n.key,r=>S(e,t,n,r)),S=(t,r,i,s)=>{let c=i.leading??!0,l=i.trailing??!0,d=s!==u,f=null,p=0,m=null,h=null,g=null,_=!1,v=e=>f===null||e-f>=t||e-f<0||e-p>=t,y=e=>n(e,`throttle`,`drop`),b=()=>{let e=g;g=null,e&&(y(e.ctx),e.resolve())},x=(e,t)=>(b(),new Promise((n,r)=>{g={payload:e,ctx:t,resolve:n,reject:r}})),S=(t,n,i)=>{b(),p=i,_=!0;try{return e(n,`throttle`,()=>r(t,n))}finally{_=!1}},C=()=>{d&&(h=o(w,t))},w=()=>{if(h=null,!d||m!==null||g)return;let e=Date.now(),n=Math.max(t-(e-(f??-1/0)),t-(e-p));n<=0?s():h=o(w,n)},T=e=>{m=null;let t=g;if(l&&t&&!t.ctx.signal.aborted){g=null;try{t.resolve(S(t.payload,t.ctx,e))}catch(e){t.reject(e)}}else b();w()},E=()=>{let e=Date.now();v(e)?T(e):m=o(E,Math.min(t-(e-(f??e)),t-(e-p)))},D=()=>{h!==null&&(a(h),h=null)},O=(e,t)=>{if(!l)y(t);else return x(e,t)},k=(e,t,n,r)=>{if(!r)y(t);else if(p=n,C(),!c)y(t);else return S(e,t,n)},A=(e,n,r,i)=>i&&m!==null?(a(m),m=o(E,t),S(e,n,r)):m===null&&(m=o(E,t),i&&(p=r,c))?S(e,n,r):O(e,n);return(e,t)=>{if(t.signal.aborted)return;let n=Date.now(),r=!_&&v(n);return f=n,D(),l?A(e,t,n,r):k(e,t,n,r)}};export{h as debounce,p as latest,v as leading,y as queue,x as throttle};

package/dist/notrace/promise-CSLpzwSR.js

@@ -0,0 +1 @@
+const e=e=>typeof e!=`object`||!e?!1:`then`in e&&typeof e.then==`function`,t=(t,n)=>e(t)?Promise.resolve(t).finally(n):(n(),t);export{e as n,t};

package/dist/notrace/redux.d.ts

@@ -0,0 +1,92 @@
+import { k as EventMap, o as Bus, s as BusOptions } from "./action-rqZEnRIp.js";
+//#region src/store/redux/middleware.d.ts
+/** What Redux passes through a middleware: an action is a plain object with a `type`. */
+type ReduxAction = {
+  type: string;
+  payload?: unknown;
+};
+type NanoeffectsMiddlewareOptions = {
+  /** Return `false` for the actions that the bus should not get. Default: all of them. */
+  filter?: (action: ReduxAction) => boolean;
+};
+/**
+ * A Redux middleware that sends every action to the bus, after the reducers
+ * have handled it, so a handler that reads the store sees the new state. It
+ * does not depend on Redux: it only has the shape of a middleware. Values that
+ * are not plain actions (the functions of redux-thunk) go through untouched.
+ *
+ * The other way needs no adapter: give the store to the tasks with
+ * `createBus({ context: { store } })` and dispatch from a handler.
+ *
+ * Take care of loops: a handler must not dispatch the action it handles.
+ * Errors of handlers reach the caller of `dispatch`, as for `bus.emit`; set
+ * `onError` on the bus to isolate them.
+ *
+ * @example
+ * ```ts
+ * const store = configureStore({
+ *   reducer,
+ *   middleware: (getDefault) => getDefault().concat(nanoeffectsMiddleware(bus)),
+ * });
+ *
+ * bus.on(userRequested, latest(async (id, { store, signal }) => {
+ *   store.dispatch(userLoaded(await fetchUser(id, { signal })));
+ * }));
+ * ```
+ */
+export declare const nanoeffectsMiddleware: <E extends EventMap>(bus: Bus<E>, options?: NanoeffectsMiddlewareOptions) => () => (next: (action: unknown) => unknown) => (action: unknown) => unknown;
+//#endregion
+//#region src/store/redux/effects.d.ts
+/** What Redux gives a middleware: the parts of the store that it may use. */
+type ReduxStoreApi<State = unknown> = {
+  dispatch: (action: {
+    type: string;
+    payload?: unknown;
+  }) => unknown;
+  getState: () => State;
+};
+type EffectsMiddlewareOptions<E extends EventMap> = Omit<BusOptions<E>, "context"> & NanoeffectsMiddlewareOptions & {
+  /** More fields for the context of every task, next to `store`. */
+  context?: object;
+};
+/**
+ * Creates a bus and the Redux middleware that feeds it: the effects of an app
+ * in one place, without sagas. Every task gets `ctx.store`, the `dispatch` and
+ * `getState` of the store, as soon as the middleware is added to it. Type it
+ * in the event map:
+ *
+ * ```ts
+ * type Events = { userRequested: string } & WithContext<{ store: ReduxStoreApi<RootState> }>;
+ * ```
+ *
+ * Two things are looked after for you:
+ *
+ * - **A handler does not loop on its own action.** An action that a handler
+ *   dispatches through `ctx.store` and that has the type the handler works on
+ *   does not go back to the bus (a handler of `a` that dispatches `a`). Other
+ *   handlers of that type do not get it either. Longer cycles, `a` to `b` to
+ *   `a`, are yours to avoid.
+ * - **A failing handler does not break `dispatch`.** Errors go to `onError`,
+ *   by default to `console.error`, as in Redux Toolkit listeners; reducers
+ *   still throw to the caller.
+ *
+ * @example
+ * ```ts
+ * const effects = createEffectsMiddleware<Events>();
+ *
+ * const store = configureStore({
+ *   reducer,
+ *   middleware: (getDefault) => getDefault().concat(effects.middleware),
+ * });
+ *
+ * effects.bus.on(userRequested, latest(async (id, { store, signal }) => {
+ *   store.dispatch(userLoaded(await fetchUser(id, { signal })));
+ * }));
+ * ```
+ */
+export declare const createEffectsMiddleware: <E extends EventMap = EventMap>(options?: EffectsMiddlewareOptions<E>) => {
+  bus: Bus<E>;
+  middleware: (storeApi: ReduxStoreApi) => (next: (action: unknown) => unknown) => (action: unknown) => unknown;
+};
+//#endregion
+export type { EffectsMiddlewareOptions, NanoeffectsMiddlewareOptions, ReduxStoreApi };

package/dist/notrace/redux.js

@@ -0,0 +1 @@
+import{c as e}from"./context-yAWj0BFZ.js";import{t}from"./bus-Dx0l9X6h.js";const n=e=>typeof e==`object`&&!!e&&`type`in e,r=(e,t={})=>{let r=e.emit;return()=>e=>i=>{let a=e(i);return n(i)&&(t.filter?.(i)??!0)&&r(i),a}},i=(n={})=>{let{filter:i,context:a,onError:o,...s}=n,c,l=/* @__PURE__ */ new WeakMap,u=e=>({...a,store:c&&{getState:c.getState,dispatch:t=>{typeof t==`object`&&t&&l.set(t,e.type);let n=t;return c?.dispatch(n)}}}),d=t({...s,onError:o??((t,{type:n})=>{e(`handler of "${n}" failed`,t)}),context:u}),f=r(d,{filter:e=>l.get(e)!==e.type&&(i?.(e)??!0)});return{bus:d,middleware:e=>(c=e,f())}};export{i as createEffectsMiddleware,r as nanoeffectsMiddleware};

package/dist/observable.d.ts

@@ -0,0 +1,20 @@
+import { A as Keys, k as EventMap, o as Bus } from "./action-rqZEnRIp.js";
+//#region src/observable.d.ts
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+export declare const $$observable: symbol;
+export type Observer<T> = ((value: T) => void) | {
+  next?: (value: T) => void;
+};
+export interface Subscribable<T> {
+  subscribe(observer: Observer<T>): {
+    unsubscribe(): void;
+  };
+}
+export type Observable<T> = Subscribable<T> & {};
+export type Observe<E extends EventMap> = <K extends Keys<E>>(event: K) => Observable<E[K]>;
+export declare const createObserve: <E extends EventMap>(bus: Bus<E>) => Observe<E>;
+//#endregion

package/dist/observable.js

@@ -0,0 +1 @@
+const e=typeof Symbol==`function`&&Symbol.observable||`@@observable`,t=t=>n=>({subscribe:e=>({unsubscribe:t.on(n,t=>{typeof e==`function`?e(t):e.next?.(t)})}),[e](){return this}});export{e as $$observable,t as createObserve};

package/dist/onAbort-BgMfspK4.js

@@ -0,0 +1 @@
+const e=(e,t)=>{globalThis.console?.error(`[nanoeffects] ${e}`,t)},t=()=>{},n=/* @__PURE__ */ new WeakMap,r=t=>{let r=n.get(t);if(r)return r;let i=/* @__PURE__ */ new Set;return n.set(t,i),t.addEventListener(`abort`,()=>{let n=[...i];i.clear();for(let{fn:r}of n)try{r(t.reason)}catch(t){e(`abort callback failed`,t)}},{once:!0}),i},i=(e,n)=>{let{signal:i}=e;if(!i)return t;if(i.aborted)return n(i.reason),t;let a=r(i),o={fn:n};return a.add(o),()=>{a.delete(o)}};export{e as n,i as t};