nanoeffects 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladimir Yazykov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,97 @@
-# Temporary Holding Version
+# nanoeffects
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/nanoeffects)](https://www.npmjs.com/package/nanoeffects)
+[![CI](https://github.com/nanoeffects/nanoeffects/actions/workflows/ci.yml/badge.svg)](https://github.com/nanoeffects/nanoeffects/actions/workflows/ci.yml)
+[![size](https://img.shields.io/bundlephobia/minzip/nanoeffects)](https://bundlephobia.com/package/nanoeffects)
+[![license](https://img.shields.io/npm/l/nanoeffects)](LICENSE)
+
+A small typed event bus. Handlers are tasks with an `AbortSignal`, and policies (`latest`, `debounce`, `throttle`, `queue`) and effects (`retry`, `timeout`) are plain functions that go straight into `on`.
+
+```ts
+import { createBus } from "nanoeffects";
+
+type Events = { greet: string };
+
+const bus = createBus<Events>();
+
+const unbind = bus.on("greet", (name) => console.log(`hello ${name}`));
+
+bus.emit("greet", "Ada"); // hello Ada
+unbind(); // `on` returns the unsubscribe function, as in nanoevents
+```
+
+`emit` takes the event as a string, as an object `{ type, payload }` (a Redux action fits as it is), or as a function with a `type`, a command that runs and returns its result:
+
+```ts
+bus.emit("greet", "Ada");
+bus.emit({ type: "greet", payload: "Ada" });
+bus.emit(double, 21); // a command: runs, returns 42
+```
+
+Then the same bus with a policy, no other change:
+
+```ts
+import { latest } from "nanoeffects/policies";
+
+// a newer search aborts the older one
+bus.on(
+  "search",
+  latest(async (query, ctx) => {
+    const items = await api.search(query, { signal: ctx.signal });
+    ctx.emit("results", items);
+  }),
+);
+```
+
+- **Tiny.** `createBus` is about 1.2 kB gzip; every other entry is bundled only when imported.
+- **Cancellation first.** Aborting a task aborts its children and `ctx.on` subscriptions and drops its result.
+- **One model** instead of `AbortController`, lodash `debounce`, `p-queue` and a hand-written retry.
+- **Typed** commands, actions, jobs and modules; **traced** with Redux DevTools; the trace can be cut out of the build.
+- **Checked** against lodash on random call sequences, and against known issues of RxJS, p-queue, p-retry and effector.
+
+## Install
+
+```bash
+npm install nanoeffects
+```
+
+ESM only, no dependencies, types included.
+
+## Entries
+
+| Import                   | What is in it                                                                 |
+| ------------------------ | ----------------------------------------------------------------------------- |
+| `nanoeffects`            | `createBus`, the types                                                        |
+| `nanoeffects/policies`   | `latest`, `leading`, `debounce`, `throttle`, `queue`                          |
+| `nanoeffects/effects`    | `retry`, `timeout`, `poll`, `delay`, `take`, `all`, `allSettled`, `race`      |
+| `nanoeffects/actions`    | `createAction`, `createCommand`, `createJob`, `createModule`, `modulePlugin` |
+| `nanoeffects/redux`      | `createEffectsMiddleware`, `nanoeffectsMiddleware`                            |
+| `nanoeffects/observable` | `createObserve`: an event as an Observable (RxJS)                             |
+| `nanoeffects/dev`        | `devPlugin`: warnings about listeners that pile up and messages about modules; a no-op in production |
+| `nanoeffects/trace`      | `createTracer` and the loggers                                                |
+
+## The task context
+
+`bus.on(event, handler)` calls `handler(payload, ctx)`. Each call is a task:
+
+| `ctx`             | Meaning                                                  |
+| ----------------- | -------------------------------------------------------- |
+| `signal`, `abort` | the signal of the task, and a way to abort it            |
+| `emit`            | emit as this task; does nothing after an abort           |
+| `on`, `off`       | subscribe; the subscription ends when the task aborts    |
+| `run(fn, ...)`    | a child task, aborted with this one                      |
+| `type`, `payload` | the event the task works on                              |
+
+The event map (`type Events = { name: Payload }`) is optional: `createBus()` takes any string event with an `unknown` payload. `createAction("user/loaded")` takes its payload type from the map, and `createAction<User>("user/loaded")` gives it when there is none.
+
+## Docs
+
+[**Guide**](docs/guide.md) · [Policies](docs/policies.md) · [Effects](docs/effects.md) · [Actions, commands, modules](docs/actions.md) · [Context fields](docs/context.md) · [Errors](docs/errors.md) · [Tracing](docs/tracing.md) · [Redux, Zustand, MobX](docs/stores.md) · [Observable](docs/observable.md) · [Hot reload and dev diagnostics](docs/hmr.md) · [Semantics](docs/semantics.md) · [Examples](examples)
+
+## Development
+
+```bash
+pnpm verify   # what CI runs: types, lint, tests, build, integration, package checks, size
+```
+
+[`AGENTS.md`](AGENTS.md) describes the structure and the rules of the code, for people and AI assistants.

package/dist/action-rqZEnRIp.d.ts

@@ -0,0 +1,303 @@
+//#region src/core/types.d.ts
+type PayloadOf<P> = undefined extends P ? [payload?: P] : [payload: P];
+type EventMap = Record<string, unknown>;
+type Keys<E> = keyof E & string;
+type Task<P, E extends EventMap, R = unknown> = (payload: P, ctx: Context<E>) => R;
+type EffectName = "every" | "latest" | "leading" | "debounce" | "throttle" | "run" | "all" | "race" | "retry" | "timeout" | "poll" | "take" | "queue" | "allSettled" | "command";
+type Phase = "start" | "done" | "error" | "cancel" | "drop";
+type TraceEvent<E = Record<string, unknown>> = { [K in Keys<E>]: {
+  id: number;
+  parent?: number;
+  type: K;
+  effect: EffectName;
+  phase: Phase;
+  payload: E[K];
+  error?: unknown;
+}; }[Keys<E>];
+/**
+ * The contract of every trace logger: receives each task phase of a bus.
+ * Adapters in `nanoeffects/trace` are factories that return one; pass it
+ * through `createTracer` to `createBus({ trace })`.
+ */
+type TraceLogger<E = Record<string, unknown>> = (event: TraceEvent<E>) => void;
+/** One logger or several; a throwing logger never breaks the task or the others. */
+type Trace<E = Record<string, unknown>> = TraceLogger<E> | readonly TraceLogger<E>[];
+type UnsubscribeCallback = () => void;
+//#endregion
+//#region src/core/store.d.ts
+declare const anyEventType = "*";
+//#endregion
+//#region src/core/tracer.d.ts
+/**
+ * What the bus needs from tracing. The implementation, `createTracer` in
+ * `nanoeffects/trace`, holds all the machinery (ids, events, loggers), so a
+ * bus without `trace` carries none of it. `Ref` is an opaque handle that
+ * `task` makes for each task.
+ */
+interface Tracer<Ref extends object = object> {
+  /** Registers a task and returns its handle; `parent` is the handle of its parent task. */
+  task(event: {
+    type: string;
+    payload?: unknown;
+  }, parent?: Ref): Ref;
+  /** Reports a phase of a task. */
+  report(ref: Ref, effect: EffectName, phase: Phase, error?: unknown): void;
+  /** Returns `settle(phase, error?)` that reports only the first phase it gets. */
+  settler(ref: Ref, effect: EffectName): (phase: Phase, error?: unknown) => void;
+  /**
+   * Runs `fn`, reporting `start` and then `done` / `error` of its (sync or
+   * async) result, or `cancel` if `signal` aborts first.
+   */
+  run<R>(ref: Ref, effect: EffectName, signal: AbortSignal, fn: () => R): R;
+}
+//#endregion
+//#region src/core/bus.d.ts
+/** Subscribes to every event; handlers receive the payload of any of them. */
+type AnyEvent = typeof anyEventType;
+type EventKey<E extends EventMap> = Keys<E>;
+type EventPayload<E extends EventMap> = E[EventKey<E>];
+type WithType<K extends string> = {
+  type: K;
+};
+type HandlerRef<E extends EventMap, Response = unknown> = (action: Action<E>) => Response;
+type Handler<E extends EventMap, Response = unknown, K extends EventKey<E> = EventKey<E>> = { [P in K]: {
+  type: P;
+  (payload: E[P]): Response;
+}; }[K];
+type Action<E extends EventMap> = {
+  type: EventKey<E>;
+  payload: EventPayload<E>;
+};
+type WithPayload<E extends EventMap, K extends EventKey<E>> = undefined extends E[K] ? {
+  type: K;
+  payload?: E[K];
+} : {
+  type: K;
+  payload: E[K];
+};
+type EventLike<E extends EventMap> = { [K in EventKey<E>]: WithPayload<E, K>; }[Keys<E>];
+/**
+ * A typed request for a result. `bus.emit(command, payload)` runs the handler
+ * of the command as a task and returns what it returns. Made by
+ * `createCommand` in `nanoeffects/actions`.
+ */
+type Command<P = never, R = unknown> = {
+  (payload: P, ctx?: never): R;
+  readonly type: string;
+  /** Wraps the handler that really runs, e.g. to route its outcome. */
+  readonly wrap?: (run: (payload: never, ctx: never) => unknown) => (payload: never, ctx: never) => unknown;
+};
+/**
+ * What the bus needs to run commands. The implementation, `createCommands` in
+ * `nanoeffects/actions`, holds the handlers bound to commands and runs the
+ * right one, so a bus without `commands` carries none of that.
+ */
+interface Commands {
+  run(command: Command, payload: unknown, ctx: unknown): unknown;
+}
+/** Anything `emit` takes as its first argument: an event type, an action or a command. */
+type Emittable<E extends EventMap> = EventKey<E> | Command | EventLike<E>;
+type Emit<E extends EventMap> = {
+  <K extends EventKey<E>>(event: K, ...payload: PayloadOf<E[K]>): void;
+  <K extends EventKey<E>, R>(event: Handler<E, R, K>, ...payload: PayloadOf<E[K]>): R;
+  <P, R>(command: Command<P, R>, ...payload: PayloadOf<P>): R;
+  (event: EventLike<E>): void;
+};
+type On<E extends EventMap> = {
+  (event: AnyEvent, fn: Task<EventPayload<E>, E>): UnsubscribeCallback;
+  <K extends EventKey<E>>(event: K, fn: Task<E[K], E>): UnsubscribeCallback;
+  /** An action creator without a payload type: the payload comes from the event map. */
+  <K extends EventKey<E>>(creator: FreeActionCreator<K>, fn: Task<E[K], E>): UnsubscribeCallback;
+  /** An action creator: the payload comes from it, so an event map is not needed. */
+  <P>(creator: ActionCreator<P>, fn: Task<P, E>): UnsubscribeCallback;
+  /** A command: the payload comes from it too. */
+  <P>(command: Command<P, unknown>, fn: Task<P, E>): UnsubscribeCallback;
+  <K extends EventKey<E>, Event extends {
+    type: K;
+  }>(event: Event & {
+    type: K;
+  }, fn: Task<E[K], E>): UnsubscribeCallback;
+};
+type Off<E extends EventMap> = {
+  (event: AnyEvent): void;
+  (event: AnyEvent, fn: Task<EventPayload<E>, E>): void;
+  <K extends EventKey<E>>(event: K): void;
+  <K extends EventKey<E>>(event: K, fn: Task<E[K], E>): void;
+  <K extends EventKey<E>, Event extends {
+    type: K;
+  }>(event: Event & {
+    type: K;
+  }, fn: Task<E[K], E>): void;
+  <P>(command: Command<P, unknown>, fn?: Task<P, E>): void;
+};
+declare const contextKey: unique symbol;
+/**
+ * Your own fields of every task context, in the event map: add it to the
+ * events with `&` and give the values in `createBus({ context })`. The fields
+ * are in the context of every task of that bus, and the compiler checks them.
+ *
+ * @example
+ * ```ts
+ * type Events = { save: Draft } & WithContext<{ store: Store }>;
+ *
+ * const bus = createBus<Events>({ context: { store } });
+ * bus.on("save", (draft, { store }) => store.put(draft));
+ * ```
+ */
+type WithContext<Fields extends object> = {
+  readonly [contextKey]?: Fields;
+};
+/** The fields that the event map `E` adds to the context of a task. */
+type ContextOf<E extends EventMap> = typeof contextKey extends keyof E ? NonNullable<E[typeof contextKey]> : unknown;
+/** Fields for the context of every task, or a function that makes them for one task. */
+type ContextOption<E extends EventMap> = ContextOf<E> | ((event: {
+  type: string;
+  payload?: unknown;
+}) => ContextOf<E>);
+/** Task context inside an effect. */
+type Context<E extends EventMap> = EventLike<E> & ContextOf<E> & {
+  signal: AbortSignal;
+  /** Abort this task (and attached children). */
+  abort: (reason?: unknown) => void;
+  /** Emit as this task; no-op after the task is aborted. */
+  emit: Emit<E>;
+  /**
+   * Subscribe as this task. The subscription is removed when the task aborts;
+   * after that this is a no-op that returns a no-op.
+   */
+  on: On<E>;
+  /** Same as the bus `off`. */
+  off: Off<E>;
+  /** Child task: aborted with the parent; errors propagate to the parent. */
+  run<P, R>(fn: Task<P, E, R>, ...args: PayloadOf<P>): Promise<Awaited<R>>;
+};
+interface Bus<E extends EventMap> {
+  on: On<E>;
+  off: Off<E>;
+  emit: Emit<E>;
+  /**
+   * Calls `plugin` with the bus and returns what it returns: an api, a
+   * function that undoes it. A plugin is any function of the bus; the bus keeps
+   * no list of them. See `modulePlugin` in `nanoeffects/actions`.
+   */
+  use<R>(plugin: (bus: Bus<E>) => R): R;
+  /** `BusOptions.context` and `.trace`, and `commands`, for what makes tasks of its own, like `modulePlugin`. */
+  readonly context?: ContextOption<E> | undefined;
+  /** What runs the commands; `createCommands(bus)` and `modulePlugin` set it. Without one a command runs its own handler. */
+  commands?: Commands | undefined;
+  readonly trace?: Tracer | undefined;
+}
+type BusOptions<E extends EventMap> = {
+  /** Tracing of every task phase; make it with `createTracer` from `nanoeffects/trace`. */
+  trace?: Tracer;
+  /**
+   * Receives errors of handlers: thrown ones and rejections of async ones.
+   * Without it handlers run like in a plain loop: the first error stops the
+   * rest and is thrown to the caller of `emit`, and rejections of async
+   * handlers are left unhandled. With it every handler runs and errors go
+   * here; an `onError` that throws is logged to `console.error`.
+   */
+  onError?: (error: unknown, event: Action<E>) => void;
+  /**
+   * Called when an event is emitted and nobody listens to it: the usual sign
+   * of a typo in an event name. Not called for commands, which always have a
+   * handler to run. Typically a warning in development only.
+   *
+   * @example
+   * ```ts
+   * createBus<Events>({
+   *   onUnhandled: import.meta.env.DEV ? ({ type }) => console.warn(`Nobody listens to "${type}"`) : void 0,
+   * });
+   * ```
+   */
+  onUnhandled?: (event: Action<E>) => void;
+  /**
+   * Fields added to the context of every task of this bus, its child tasks
+   * and the tasks of effects included: a store, a logger, a client. Their
+   * types come from `WithContext` in the event map. The fields of the library
+   * win over these when the names are the same. A function gets
+   * `{ type, payload }` of the task and returns its fields, for fields that
+   * depend on the task.
+   */
+  context?: ContextOption<E>;
+};
+declare const createBus: <Events extends EventMap>(options?: BusOptions<Events>) => Bus<Events>;
+//#endregion
+//#region src/actions/action.d.ts
+type Absent<P> = [P] extends [void] ? undefined : P;
+type Made<P, T extends string> = WithPayload<{ [K in T]: Absent<P>; }, T>;
+declare const free: unique symbol;
+type Free = typeof free;
+/**
+ * A creator whose payload type was not given: each call has the type of what
+ * it is given, and the bus checks it against its event map, so
+ * `createAction("user/loaded")` needs no generics and keeps its literal type.
+ */
+interface FreeActionCreator<T extends string> {
+  (): {
+    type: T;
+    payload: undefined;
+  };
+  <P>(payload: P): {
+    type: T;
+    payload: P;
+  };
+  readonly type: T;
+  /** Tells whether an action is one of this creator. */
+  match(action: {
+    type: string;
+    payload?: unknown;
+  }): action is {
+    type: T;
+    payload: unknown;
+  };
+  toString(): T;
+}
+/**
+ * Makes actions of one type. It also works as the event of that type:
+ * `bus.on(creator, fn)` and `bus.emit(creator(payload))`.
+ */
+interface ActionCreator<P = void, T extends string = string, A extends unknown[] = PayloadOf<P>> {
+  (...args: A): Made<P, T>;
+  readonly type: T;
+  /** Tells whether an action is one of this creator, and narrows its type. */
+  match(action: {
+    type: string;
+    payload?: unknown;
+  }): action is Made<P, T>;
+  toString(): T;
+}
+/**
+ * Creates an action creator, as in Redux Toolkit.
+ *
+ * - `createAction("user/loaded")` needs no generics: the payload type comes
+ *   from the event map of the bus that the action goes to, and the literal
+ *   type of the action is kept.
+ * - `createAction<User>("user/loaded")` gives the payload type, for a bus
+ *   without an event map or to check the calls of the creator. The type of
+ *   the action is then `string`; to keep the literal, give it as the second
+ *   generic: `createAction<User, "user/loaded">("user/loaded")`.
+ * - With `prepare` the arguments of the creator can differ from the payload,
+ *   and both types are inferred.
+ *
+ * @example
+ * ```ts
+ * const added = createAction<number>("counter/added");
+ * added(2); // { type: "counter/added", payload: 2 }
+ * added.type; // "counter/added"
+ * added.match(action); // true for actions of this type
+ *
+ * const renamed = createAction("user/renamed", (id: string, name: string) => ({
+ *   payload: { id, name },
+ * }));
+ *
+ * bus.emit(added(2));
+ * bus.on(added, (n) => console.log(n));
+ * ```
+ */
+declare function createAction<P = Free, T extends string = string>(type: T): [P] extends [Free] ? FreeActionCreator<T> : ActionCreator<P, T>;
+declare function createAction<A extends unknown[], P, T extends string = string>(type: T, prepare: (...args: A) => {
+  payload: P;
+}): ActionCreator<P, T, A>;
+//#endregion
+export { Keys as A, WithPayload as C, anyEventType as D, Tracer as E, TraceEvent as F, TraceLogger as I, UnsubscribeCallback as L, Phase as M, Task as N, EffectName as O, Trace as P, WithContext as S, createBus as T, EventPayload as _, AnyEvent as a, Off as b, Command as c, ContextOf as d, ContextOption as f, EventLike as g, EventKey as h, Action as i, PayloadOf as j, EventMap as k, Commands as l, Emittable as m, FreeActionCreator as n, Bus as o, Emit as p, createAction as r, BusOptions as s, ActionCreator as t, Context as u, Handler as v, WithType as w, On as x, HandlerRef as y };

package/dist/actions.d.ts

@@ -0,0 +1,58 @@
+import { N as Task, c as Command, k as EventMap, n as FreeActionCreator, r as createAction, t as ActionCreator } from "./action-rqZEnRIp.js";
+import { a as modulePlugin, c as createCommand, i as createModule, l as createCommands, n as ModuleApi, o as Binding, r as ModuleContext, s as bindHandler, t as Module } from "./module-BSCdR9D1.js";
+//#region src/actions/job.d.ts
+type Creator = {
+  (...args: never[]): {
+    type: string;
+    payload?: unknown;
+  };
+  readonly type: string;
+};
+type Outcome = string | Creator;
+/** What `createJob` returns: the command of the job and the actions of its outcome. */
+type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = {
+  command: Command<P, Promise<Awaited<R> | undefined>> & {
+    readonly type: T;
+  };
+  /** Made from a string with the result as its payload, or the creator that was given. */
+  successAction: S extends string ? ActionCreator<Awaited<R>, S> : S;
+  /** Made from a string with the error as its payload, or the creator that was given. */
+  failAction: F extends string ? ActionCreator<unknown, F> : F;
+};
+/**
+ * Creates a job: a command whose outcome is sent on as actions. When the
+ * handler succeeds, `successAction(result)` is emitted on the bus, and when it
+ * fails, `failAction(error)`. It is made for the case where nobody waits for
+ * the result and the bus carries it on, like `createAsyncThunk` or an effector
+ * effect. It returns the three together: `{ command, successAction, failAction }`.
+ *
+ * `success` and `fail` are a type string, from which the job makes an action
+ * creator with `createAction`, or an action creator that exists already, which
+ * is used and returned as it is. A missing one is made with the type
+ * `<type>/success` or `<type>/fail`.
+ *
+ * `bus.emit(command, payload)` returns a promise of the result. An error of the
+ * handler always counts as handled: it goes to `failAction` and the promise
+ * resolves with `undefined`; a command is the tool for a result that must reject.
+ * The actions are emitted as the task that ran the job, also for a handler bound
+ * with `commands.handle`, and are skipped once the task is aborted. A missing
+ * handler is not an outcome: `emit` throws `MissingHandlerError`. Calling the
+ * command directly runs only its handler.
+ *
+ * @example
+ * ```ts
+ * const { command: loadUser, successAction: userLoaded, failAction: userFailed } =
+ *   createJob("user/load", fetchUser, { success: "user/loaded", fail: "user/failed" });
+ *
+ * bus.on(userLoaded, (user) => render(user));
+ * bus.emit(loadUser, "1"); // userLoaded(user) or userFailed(error) comes later
+ * ```
+ */
+export declare const createJob: <P = void, R = void, T extends string = string, E extends EventMap = EventMap, S extends Outcome = `${T}/success`, F extends Outcome = `${T}/fail`>(type: T, handler?: Task<P, E, R>, outcomes?: {
+  /** Gets the result when the handler succeeds: a type to make an action creator of, or an action creator. */
+  success?: S;
+  /** Gets the error when the handler fails: a type to make an action creator of, or an action creator. */
+  fail?: F;
+}) => Job<P, R, T, S, F>;
+//#endregion
+export { type ActionCreator, type Binding, type FreeActionCreator, type Job, type Module, type ModuleApi, type ModuleContext, bindHandler, createAction, createCommand, createCommands, createModule, modulePlugin };

package/dist/actions.js

@@ -0,0 +1 @@
+import{t as e}from"./onAbort-BgMfspK4.js";import{i as t,n}from"./context-DlA80GOA.js";import{t as r}from"./event-0RIBGYqS.js";function i(e,t){return Object.assign((...n)=>({type:e,payload:t?t(...n).payload:n[0]}),{type:e,match:t=>t.type===e,toString:()=>e})}var a=class extends Error{};const o=(e,t)=>Object.assign((r,i)=>{if(!t)throw new a(`No handler for command "${e}"`);return t(r,i??n({event:{type:e,payload:r}}).ctx)},{type:e}),s=(e,t)=>[e,t],c=(e,t=[])=>{let n=/* @__PURE__ */ new Map,i=(e,t)=>{let r={fn:t};return n.set(e,[...n.get(e)??[],r]),()=>{let t=(n.get(e)??[]).filter(e=>e!==r);t.length>0?n.set(e,t):n.delete(e)}};function a(e,t){if(t)return i(r(e),t);let n=e.map(([e,t])=>i(r(e),t));return()=>{for(let e of n)e()}}a(t);let o={run:(e,t,r)=>{let i=(n.get(e.type)??[]).at(-1)?.fn,a=i&&e.wrap?e.wrap(i):i??e;return Reflect.apply(a,null,[t,r])},handle:a};return e.commands=o,o},l=e=>typeof e==`string`?i(e):e,u=(e,t,n)=>{let r=e.emit;r(Reflect.apply(t,null,[n]))},d=e=>{try{return Promise.resolve(e())}catch(e){if(e instanceof a)throw e;return Promise.reject(e)}},f=(e,t,n={})=>{let r=o(e,t),i=l(n.success??`${e}/success`),a=l(n.fail??`${e}/fail`),s=(e,t,n)=>{let r=n;return d(()=>Reflect.apply(e,null,[t,n])).then(e=>(u(r,i,e),e),e=>{u(r,a,e)})};return{command:Object.assign((e,t)=>t?s(r,e,t):d(()=>r(e)),{type:e,wrap:e=>(t,n)=>s(e,t,n)}),successAction:i,failAction:a}},p=(e,t)=>({name:e,setup:t}),m=(r=[])=>i=>{let a=i.commands??c(i),o={handle:(...e)=>{if(!a.handle)throw Error("modulePlugin: the `commands` of the bus is not a registry from `createCommands()`");return Reflect.apply(a.handle,null,e)}},s=n({event:{type:`app`,payload:void 0},bus:i,tracer:i.trace}),l=n=>{let r=/* @__PURE__ */ new Map,i=/* @__PURE__ */ new Map;return{mount:a=>{let s=r.get(a);if(s)return s;let c=i.get(a.name);c&&r.get(c)?.();let u=t(n,a.name),d=u.ctx,f=l(d),p=()=>{r.delete(a),i.get(a.name)===a&&i.delete(a.name),d.abort(),u.unlink()};r.set(a,p),i.set(a.name,a);let m=(t,n)=>{let r=Reflect.apply(o.handle,null,[t,n]);return e(d,r),r},h=(...e)=>{let t=e.map(e=>typeof e==`function`?m(e,e):f.mount(e));return()=>{for(let e of t)e()}},g=(e,...t)=>{d.run(e,...t).catch(e=>{if(!d.signal.aborted)throw e})};try{a.setup(Object.assign(d,{handle:m,use:h,spawn:g}))}catch(e){throw p(),e}return p},unmount:e=>r.get(e)?.(),isMounted:e=>r.has(e)}},u=l(s.ctx);for(let e of r)u.mount(e);return{commands:a,mount:e=>(s.ctx.signal.throwIfAborted(),u.mount(e)),unmount:u.unmount,isMounted:u.isMounted,dispose:()=>s.ctx.abort()}};export{s as bindHandler,i as createAction,o as createCommand,c as createCommands,f as createJob,p as createModule,m as modulePlugin};

package/dist/bus-CRnlwmQ4.js

@@ -0,0 +1 @@
+import{n as e}from"./onAbort-BgMfspK4.js";import{a as t,n,r}from"./context-DlA80GOA.js";import{n as i}from"./promise-CSLpzwSR.js";import{n as a,t as o}from"./event-0RIBGYqS.js";const s=`*`,c=()=>{let e={},t=/* @__PURE__ */ new WeakSet,n=n=>{let r=e[n]??[];if(!t.has(r))return e[n]=r,r;let i=[...r];return e[n]=i,i},r=(t,r)=>{if(!r){e[t]=[];return}let i=(e[t]??[]).indexOf(r);i>=0&&n(t).splice(i,1)};return{get:n=>{let r=e[n]??[];return t.add(r),r},add:(e,t)=>(n(e).push(t),()=>{r(e,t)}),remove:r}},l=(e,t,n)=>Reflect.apply(e,null,[t,n]),u=(s={})=>{let u=c(),d=(e,t)=>u.add(o(e),t),f=(e,t)=>u.remove(o(e),t),p=(t,a)=>{let{onError:o}=s,{ctx:c}=n({event:a,bus:m,tracer:s.trace,parent:{ref:r()}});if(!o){t(a.payload,c);return}let l=t=>{try{o(t,a)}catch(t){e(`onError failed`,t)}};try{let e=t(a.payload,c);i(e)&&Promise.resolve(e).catch(l)}catch(e){l(e)}},m={on:d,off:f,emit:(e,i)=>{let c=o(e),d=a(e,i),f={type:c,payload:d},h=[...u.get(c),...u.get(`*`)];h.length===0&&typeof e!=`function`&&s.onUnhandled?.(f);for(let e of h)p(e,f);if(typeof e==`function`){let{ctx:i}=n({event:f,bus:m,tracer:s.trace,parent:{ref:r()}}),a=m.commands?.run??l;return t(i,`command`,()=>a(e,d,i))}},use:e=>e(m),context:s.context,trace:s.trace};return m};export{s as n,u as t};

package/dist/context-DlA80GOA.js

@@ -0,0 +1 @@
+import{t as e}from"./onAbort-BgMfspK4.js";const t=t=>{let n=new AbortController;return{controller:n,unlink:e({signal:t},e=>n.abort(e))}},n=typeof __NANOEFFECTS_TRACE__>`u`||__NANOEFFECTS_TRACE__,r=/* @__PURE__ */ new WeakMap;let i;const a=()=>i,o=()=>{},s=(e,t,i,a)=>{let o=n&&r.get(e);o&&o.tracer.report(o.ref,t,i,a)},c=(e,t)=>{let i=n&&r.get(e);return i?i.tracer.settler(i.ref,t):o},l=(e,t,i)=>{let a=n&&r.get(e);return a?a.tracer.run(a.ref,t,e.signal,i):i()},u=(e,t)=>typeof e==`function`?e(t):e,d=e=>e,f=({event:a,bus:s,tracer:c,parent:p})=>{let{controller:m,unlink:h}=t(p?.signal),{signal:g}=m,_=n&&c?{tracer:c,ref:c.task(a,p?.ref)}:void 0,v=(...e)=>{if(g.aborted)return;let t=s?.emit,n=i;i=_?.ref;try{return t?.(...e)}finally{i=n}},y=(...t)=>{if(g.aborted)return o;let n=s?.on,r=n?.(...t);if(!r)return o;let i=e({signal:g},r);return()=>{i(),r()}},b=async(e,...t)=>{g.throwIfAborted();let n=t[0],r=f({event:{type:a.type,payload:n},bus:s,tracer:c,parent:{signal:g,ref:_?.ref}});try{return await l(r.ctx,`run`,()=>e(n,r.ctx))}finally{r.unlink()}},x=d({...u(s?.context,a),type:a.type,payload:a.payload,signal:g,abort:e=>m.abort(e),emit:v,on:y,off:s?.off??o,run:b});return _&&r.set(x,_),{ctx:x,unlink:h}},p=(e,t)=>{let i=n?r.get(e):void 0;return f({event:{type:t??e.type??``,payload:e.payload},bus:{emit:e.emit,on:e.on,off:e.off,context:e},tracer:i?.tracer,parent:{signal:e.signal,ref:i?.ref}})};export{l as a,p as i,f as n,s as o,a as r,c as t};

package/dist/delay-CIHnOh_L.js

@@ -0,0 +1 @@
+import{t as e}from"./onAbort-BgMfspK4.js";const t=2**31-1,n=(e,n)=>{let r={id:null};if(n===1/0)return r;let i=n=>{r.id=setTimeout(()=>{n>t?i(n-t):(r.id=null,e())},Math.min(n,t))};return i(n>0?n:0),r},r=e=>{e.id!==null&&(clearTimeout(e.id),e.id=null)},i=(t,i)=>new Promise((a,o)=>{let s=n(()=>{c(),a()},typeof i==`function`?i():i),c=e(t,e=>{r(s),o(e)})});export{r as n,n as r,i as t};

package/dist/dev.d.ts

@@ -0,0 +1,46 @@
+import { L as UnsubscribeCallback, k as EventMap, o as Bus } from "./action-rqZEnRIp.js";
+import { n as ModuleApi } from "./module-BSCdR9D1.js";
+//#region src/dev/types.d.ts
+/** The parts of what `modulePlugin` returned that the diagnostics report. */
+type ReportedApp<E extends EventMap> = Pick<ModuleApi<E>, "mount" | "unmount" | "isMounted">;
+type DevOptions<E extends EventMap = EventMap> = {
+  /** Warn when more listeners than this are added to one event and not unsubscribed. Default 10. */
+  maxListeners?: number;
+  /** Check the number of listeners. Default `true`. */
+  leaks?: boolean;
+  /** Report the modules of `app` that are mounted, replaced and unmounted. Default `true`. */
+  modules?: boolean;
+  /** Receives every message. Default: `console.warn` for leaks and `console.info` for modules. */
+  log?: (message: string) => void;
+  /** What `modulePlugin` returned, to report its modules. */
+  app?: ReportedApp<E>;
+};
+/** A plugin that connects the diagnostics to a bus; the function it returns disconnects them. */
+type DevPlugin = <E extends EventMap>(options?: DevOptions<E>) => (bus: Bus<E>) => UnsubscribeCallback;
+//#endregion
+//#region src/dev/plugin.d.ts
+/**
+ * A plugin with development diagnostics for a bus, used while the app is built
+ * and while its files are reloaded:
+ *
+ * - **Listeners that pile up.** When more than `maxListeners` listeners are
+ *   added to one event and not unsubscribed, one warning names the event and
+ *   the count: a file that was reloaded and subscribes again, or an
+ *   unsubscribe that is never called. The count follows the function that `on`
+ *   returns; `bus.off(event, fn)` is not seen.
+ * - **Modules.** With `app` (what `modulePlugin` returned) it reports a
+ *   module that is mounted, replaced by name and unmounted.
+ *
+ * It wraps `bus.on`, `app.mount` and `app.unmount`; the function that `bus.use` returns
+ * puts the originals back. In a production build `nanoeffects/dev` is a no-op, so
+ * the call can stay as it is.
+ *
+ * @example
+ * ```ts
+ * const app = bus.use(modulePlugin([userModule]));
+ * const disconnect = bus.use(devPlugin({ app })); // warnings and messages in the console while developing
+ * ```
+ */
+export declare const devPlugin: DevPlugin;
+//#endregion
+export type { DevOptions, DevPlugin };

package/dist/dev.js

@@ -0,0 +1 @@
+import{t as e}from"./event-0RIBGYqS.js";const t=`[nanoeffects]`,n=(e={})=>t=>{let{maxListeners:n=10,leaks:a=!0,modules:o=!0,app:s}=e,c=e.log??(e=>console.warn(e)),l=e.log??(e=>console.info(e)),u=[];return a&&u.push(r(t,n,c)),o&&s&&u.push(i(s,l)),()=>{for(let e of u.splice(0))e()}},r=(n,r,i)=>{let a=n.on,o=/* @__PURE__ */ new Map,s=/* @__PURE__ */ new Set;return n.on=(...c)=>{let[l]=c,u=e(l),d=(o.get(u)??0)+1;o.set(u,d),d>r&&!s.has(u)&&(s.add(u),i(`${t} ${d} listeners of "${u}" were added and not unsubscribed (more than ${r}). A file that is reloaded and subscribes again, or an unsubscribe that is never called?`));let f=Reflect.apply(a,n,c),p=!1;return()=>{if(!p){p=!0;let e=(o.get(u)??1)-1;o.set(u,e),e<=r&&s.delete(u)}f()}},()=>{n.on=a}},i=(e,n)=>{let{mount:r,unmount:i}=e,a=/* @__PURE__ */ new Map;return e.mount=i=>{let o=a.get(i.name);if(o===i&&e.isMounted(i))return r(i);let s=o!==void 0&&e.isMounted(o),c=r(i);return a.set(i.name,i),n(`${t} module "${i.name}" ${s?`replaced`:`mounted`}`),()=>{e.isMounted(i)&&n(`${t} module "${i.name}" unmounted`),c()}},e.unmount=r=>{e.isMounted(r)&&n(`${t} module "${r.name}" unmounted`),i(r)},()=>{e.mount=r,e.unmount=i}};export{n as devPlugin};