nanoeffects 0.3.0 → 0.4.0

package/README.md

@@ -5,35 +5,46 @@
 [![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`.
+A small event bus for JavaScript apps. Each handler runs as a **task** with an `AbortSignal`, so you can cancel in-flight work. Policies (`latest`, `debounce`, …) and effects (`retry`, `timeout`, …) are plain functions you pass to `on`.
 
-```ts
-import { createBus } from "nanoeffects";
+## Install
 
-type Events = { greet: string };
+```bash
+npm install nanoeffects
+```
+
+ESM only, no dependencies, types included.
 
-const bus = createBus<Events>();
+## Create a bus
 
-const unbind = bus.on("greet", (name) => console.log(`hello ${name}`));
+Subscribe with `on`, send with `emit`. `on` returns a function that unsubscribes.
+
+```js
+import { createBus } from "nanoeffects";
+
+const bus = createBus(); // event bus; each handler call is a task
+
+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
+unbind();
 ```
 
-`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:
+That is enough for a small app or a widget. The handler’s second argument is a task context (`signal`, `emit`, …). See the [Guide](docs/guide.md).
 
-```ts
-bus.emit("greet", "Ada");
-bus.emit({ type: "greet", payload: "Ada" });
-bus.emit(double, 21); // a command: runs, returns 42
-```
+## Abort overlapping work
 
-Then the same bus with a policy, no other change:
+In a SPA, a newer search should abort the older one. Wrap the handler in `latest` and pass `ctx.signal` to `fetch` (and similar APIs).
 
-```ts
+```js
+import { createBus } from "nanoeffects";
 import { latest } from "nanoeffects/policies";
 
-// a newer search aborts the older one
+const bus = createBus();
+
+// latest — a newer run aborts the older one
 bus.on(
   "search",
   latest(async (query, ctx) => {
@@ -43,55 +54,39 @@ bus.on(
 );
 ```
 
-- **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
-```
+Same `on` / `emit`. Replace `api.search` with your own request.
 
-ESM only, no dependencies, types included.
+## Get a result from `emit`
 
-## Entries
+A **command** is like an event, but `emit` runs its handler and returns the result (a promise if the handler is async).
 
-| 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`                                                     |
-| `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                                                |
+```js
+import { createBus } from "nanoeffects";
+import { createCommand } from "nanoeffects/actions";
 
-## The task context
+const bus = createBus();
 
-`bus.on(event, handler)` calls `handler(payload, ctx)`. Each call is a task:
+// createCommand — emit runs the handler and returns what it returns
+const double = createCommand("math/double", (value) => value * 2);
 
-| `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                              |
+const answer = bus.emit(double(21)); // 42
+```
 
-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.
+More (contracts, jobs, modules): [Actions](docs/actions.md).
 
 ## 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)
+Start with the [Guide](docs/guide.md) (bus → policies → effects → modules). Or jump by need:
 
-## Development
+| Need | Page |
+| ---- | ---- |
+| Async UI races (search, submit) | [Policies](docs/policies.md) |
+| Retry, timeout, wait for events | [Effects](docs/effects.md) |
+| Domain logic off the UI | [Actions, commands, modules](docs/actions.md) |
+| Redux / Zustand / MobX | [Stores](docs/stores.md) |
 
-```bash
-pnpm verify   # what CI runs: types, lint, tests, build, integration, package checks, size
-```
+[Full index, package entries, tracing](docs/README.md) · [Examples](examples)
 
-[`AGENTS.md`](AGENTS.md) describes the structure and the rules of the code, for people and AI assistants.
+- **Tiny.** `createBus` is about 1.3 kB gzip; other entries load only when imported.
+- **Cancellation first.** Aborting a task aborts its children and drops its result.
+- **One model** instead of hand-rolled `AbortController`, lodash debounce, and retry glue.

package/dist/{action-Bdfp-Wvd.d.ts → action-creator-D48fp13T.d.ts}

@@ -1,29 +1,3 @@
-//#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
@@ -68,21 +42,29 @@ 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
+ * Brands `{ type, payload }` from a command call so `emit` can run the command.
+ * Not enumerable on the object.
+ */
+declare const commandCall: unique symbol;
+/**
+ * What `command(payload)` returns: an action-shaped value that `emit` runs as
+ * that command. A plain `{ type, payload }` without this brand is notify-only.
+ */
+type CommandCall<P = unknown, R = unknown> = {
+  type: string;
+  payload: P;
+  readonly [commandCall]: Command<P, R>;
+};
+/**
+ * A typed request for a result. Calling it builds `{ type, payload }` like
+ * `createAction`; `bus.emit(command(payload))` (or `bus.emit(command, payload)`)
+ * runs the handler 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;
+  (payload: P): CommandCall<P, 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;
@@ -96,11 +78,13 @@ 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 Emittable<E extends EventMap> = EventKey<E> | Command | CommandCall | 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;
+  /** Before Handler: a command is callable too, and must return its result type. */
   <P, R>(command: Command<P, R>, ...payload: PayloadOf<P>): R;
+  <P, R>(call: CommandCall<P, R>): R;
+  <K extends EventKey<E>, R>(event: Handler<E, R, K>, ...payload: PayloadOf<E[K]>): R;
   (event: EventLike<E>): void;
 };
 type On<E extends EventMap> = {
@@ -119,6 +103,8 @@ type On<E extends EventMap> = {
   }, fn: Task<E[K], E>): UnsubscribeCallback;
 };
 type Off<E extends EventMap> = {
+  /** Removes every listener of every event (including `"*"`). */
+  (): void;
   (event: AnyEvent): void;
   (event: AnyEvent, fn: Task<EventPayload<E>, E>): void;
   <K extends EventKey<E>>(event: K): void;
@@ -173,6 +159,11 @@ type Context<E extends EventMap> = EventLike<E> & ContextOf<E> & {
 };
 interface Bus<E extends EventMap> {
   on: On<E>;
+  /**
+   * Like `on`, but the handler runs at most once: it is removed before it is
+   * invoked, so a nested emit of the same event does not re-enter it.
+   */
+  once: On<E>;
   off: Off<E>;
   emit: Emit<E>;
   /**
@@ -223,7 +214,40 @@ type BusOptions<E extends EventMap> = {
 };
 declare const createBus: <Events extends EventMap>(options?: BusOptions<Events>) => Bus<Events>;
 //#endregion
-//#region src/actions/action.d.ts
+//#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/action-creator.d.ts
+type WithPayload<E extends EventMap, K extends Keys<E>> = undefined extends E[K] ? {
+  type: K;
+  payload?: E[K];
+} : {
+  type: K;
+  payload: E[K];
+};
 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;
@@ -267,37 +291,5 @@ interface ActionCreator<P = void, T extends string = string, A extends 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 };
+export { Handler as A, ContextOf as C, EventKey as D, Emittable as E, WithType as F, commandCall as I, createBus as L, Off as M, On as N, EventLike as O, WithContext as P, Tracer as R, Context as S, Emit as T, Bus as _, EffectName as a, CommandCall as b, PayloadOf as c, Trace as d, TraceEvent as f, AnyEvent as g, Action as h, WithPayload as i, HandlerRef as j, EventPayload as k, Phase as l, UnsubscribeCallback as m, Free as n, EventMap as o, TraceLogger as p, FreeActionCreator as r, Keys as s, ActionCreator as t, Task as u, BusOptions as v, ContextOption as w, Commands as x, Command as y, anyEventType as z };

package/dist/actions.d.ts

@@ -1,5 +1,39 @@
-import { N as Task, k as EventMap, n as FreeActionCreator, r as createAction, t as ActionCreator } from "./action-Bdfp-Wvd.js";
-import { a as modulePlugin, c as bindHandler, i as createModule, l as commandsPlugin, n as ModuleApi, o as Binding, r as ModuleContext, s as MadeCommand, t as Module, u as createCommand } from "./module-I1ixyJzx.js";
+import { n as Free, o as EventMap, r as FreeActionCreator, t as ActionCreator, u as Task } from "./action-creator-D48fp13T.js";
+import { a as modulePlugin, c as bindHandler, i as createModule, l as commandsPlugin, n as ModuleApi, o as Binding, r as ModuleContext, s as MadeCommand, t as Module, u as createCommand } from "./module-DVX8aYlq.js";
+//#region src/actions/action.d.ts
+/**
+ * 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));
+ * ```
+ */
+export declare function createAction<P = Free, T extends string = string>(type: T): [P] extends [Free] ? FreeActionCreator<T> : ActionCreator<P, T>;
+export declare function createAction<A extends unknown[], P, T extends string = string>(type: T, prepare: (...args: A) => {
+  payload: P;
+}): ActionCreator<P, T, A>;
+//#endregion
 //#region src/actions/job.d.ts
 type Creator = {
   (...args: never[]): {
@@ -29,13 +63,13 @@ type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = MadeCom
  * 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
+ * `bus.emit(job(payload))` returns a promise of the result. An error of the
  * handler always counts as handled: it goes to `job.fail` 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.
+ * job builds `{ type, payload }` like a command; it does not run the handler.
  *
  * @example
  * ```ts
@@ -45,7 +79,7 @@ type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = MadeCom
  * });
  *
  * bus.on(loadUser.success, (user) => render(user));
- * bus.emit(loadUser, "1"); // loadUser.success(user) or loadUser.fail(error) comes later
+ * bus.emit(loadUser("1")); // loadUser.success(user) or loadUser.fail(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?: {
@@ -55,4 +89,4 @@ export declare const createJob: <P = void, R = void, T extends string = string,
   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, commandsPlugin, createAction, createCommand, createModule, modulePlugin };
+export { type ActionCreator, type Binding, type FreeActionCreator, type Job, type Module, type ModuleApi, type ModuleContext, bindHandler, commandsPlugin, createCommand, createModule, modulePlugin };

package/dist/actions.js

@@ -1 +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,match:t=>t.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(e);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 t.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 Object.assign((e,t)=>t?s(r,e,t):d(()=>r(e)),{type:e,match:r.match,wrap:e=>(t,n)=>s(e,t,n),success:i,fail: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 `commandsPlugin()`");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,c as commandsPlugin,i as createAction,o as createCommand,f as createJob,p as createModule,m as modulePlugin};
+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";import{r as i}from"./bus-Cho463Sq.js";function a(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 o=class extends Error{};const s=(e,t)=>{let n=t=>t.type===e;function r(n,r){if(typeof r==`object`){if(!t)throw new o(`No handler for command "${e}"`);return t(n,r)}return i(a,e,n)}let a=Object.assign(r,{type:e,match:n});return a},c=(e,t)=>[e,t],l=(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(e);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 t.commands=o,o},u=e=>typeof e==`string`?a(e):e,d=(e,t,n)=>{let r=e.emit;r(Reflect.apply(t,null,[n]))},f=e=>{try{return Promise.resolve(e())}catch(e){if(e instanceof o)throw e;return Promise.reject(e)}},p=(e,t,n={})=>{let r=s(e,t),a=u(n.success??`${e}/success`),o=u(n.fail??`${e}/fail`),c=(e,t,n)=>{let r=n;return f(()=>Reflect.apply(e,null,[t,n])).then(e=>(d(r,a,e),e),e=>{d(r,o,e)})},l=e=>(t,n)=>c(e,t,n);function p(t,n){return typeof n==`object`?c(r,t,n):i(m,e,t)}let m=Object.assign(p,{type:e,match:r.match,wrap:l,success:a,fail:o});return m},m=(e,t)=>({name:e,setup:t}),h=(r=[])=>i=>{let a=i.commands??l()(i),o={handle:(...e)=>{if(!a.handle)throw Error("modulePlugin: the `commands` of the bus is not a registry from `commandsPlugin()`");return Reflect.apply(a.handle,null,e)}},s=n({event:{type:`app`,payload:void 0},bus:i,tracer:i.trace}),c=n=>{let r=/* @__PURE__ */ new Map,i=/* @__PURE__ */ new Map;return{mount:a=>{let s=r.get(a);if(s)return s;let l=i.get(a.name);l&&r.get(l)?.();let u=t(n,a.name),d=u.ctx,f=c(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=c(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{c as bindHandler,l as commandsPlugin,a as createAction,s as createCommand,p as createJob,m as createModule,h as modulePlugin};

package/dist/bus-Cho463Sq.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={},n=n=>(t[n]=void 0,e[n]??=/* @__PURE__ */ new Map,e[n]),r=(e,t)=>{let r=n(e),i=r.get(t)??0;i>1?r.set(t,i-1):t?r.delete(t):r.clear()};return{get:n=>(t[n]??=[...e[n]??[]].flatMap(([e,t])=>Array(t).fill(e)),t[n]),add:(e,t)=>{let i=n(e);return i.set(t,(i.get(t)??0)+1),()=>{r(e,t)}},remove:r,clear:()=>{for(let t of Reflect.ownKeys(e))delete e[t];for(let e of Reflect.ownKeys(t))delete t[e]}}},l=Symbol(`nanoeffects.commandCall`),u=(e,t,n)=>{let r={type:t,payload:n};return Object.defineProperty(r,l,{value:e,enumerable:!1}),r},d=e=>{if(typeof e==`function`)return e;if(typeof e==`object`&&e&&l in e)return e[l]},f=(e,t,n)=>Reflect.apply(e,null,[t,n]),p=(s={})=>{let l=c(),u=(e,t)=>l.add(o(e),t),p=(e,t)=>{let n=u(e,(e,r)=>(n(),t(e,r)));return n},m=(e,t)=>{e===void 0?l.clear():l.remove(o(e),t)},h=(t,a)=>{let{onError:o}=s,{ctx:c}=n({event:a,bus:g,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)}},g={on:u,once:p,off:m,emit:(e,i)=>{let c=o(e),u=a(e,i),p={type:c,payload:u},m=d(e),_=[...l.get(c),...l.get(`*`)];_.length===0&&!m&&s.onUnhandled?.(p);for(let e of _)h(e,p);if(m){let{ctx:e}=n({event:p,bus:g,tracer:s.trace,parent:{ref:r()}}),i=g.commands?.run??f;return t(e,`command`,()=>i(m,u,e))}},use:e=>e(g),context:s.context,trace:s.trace};return g};export{s as i,p as n,u as r,l as t};

package/dist/dev.d.ts

@@ -1,5 +1,5 @@
-import { L as UnsubscribeCallback, k as EventMap, o as Bus } from "./action-Bdfp-Wvd.js";
-import { n as ModuleApi } from "./module-I1ixyJzx.js";
+import { _ as Bus, m as UnsubscribeCallback, o as EventMap } from "./action-creator-D48fp13T.js";
+import { n as ModuleApi } from "./module-DVX8aYlq.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">;

package/dist/effects.d.ts

@@ -1,4 +1,4 @@
-import { A as Keys, N as Task, k as EventMap, u as Context } from "./action-Bdfp-Wvd.js";
+import { S as Context, o as EventMap, s as Keys, u as Task } from "./action-creator-D48fp13T.js";
 //#region src/utils/delay.d.ts
 /**
  * Resolves after `ms`, or rejects early if `ctx.signal` aborts. `ms` can be a

package/dist/index.d.ts

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

package/dist/index.js

@@ -1 +1 @@
-export{n as anyEventType,t as createBus}from"./bus-CRnlwmQ4.js";
+export{i as anyEventType,t as commandCall,n as createBus}from"./bus-Cho463Sq.js";

package/dist/{module-I1ixyJzx.d.ts → module-DVX8aYlq.d.ts}

@@ -1,4 +1,4 @@
-import { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as EventMap, o as Bus, u as Context } from "./action-Bdfp-Wvd.js";
+import { S as Context, _ as Bus, c as PayloadOf, m as UnsubscribeCallback, o as EventMap, u as Task, y as Command } from "./action-creator-D48fp13T.js";
 //#region src/actions/command.d.ts
 /** What `createCommand` returns: a command that also tells whether an action is of its type. */
 type MadeCommand<P, R, T extends string> = Command<P, R> & {
@@ -13,17 +13,18 @@ type MadeCommand<P, R, T extends string> = Command<P, R> & {
   };
 };
 /**
- * Creates a command: a typed request for a result. `bus.emit(command, payload)`
- * runs its handler as a task, with a context, and returns what the handler
- * returns. Listeners of the command's type are told first, as for any event.
+ * Creates a command: a typed request for a result. Calling it builds
+ * `{ type, payload }` like `createAction`. `bus.emit(command(payload))` (or
+ * `bus.emit(command, payload)`) runs its handler as a task, with a context, and
+ * returns what the handler returns. Listeners of the command's type are told
+ * first, as for any event.
  *
  * The handler is optional. A command without one is only a contract, and the
  * bus gets its implementation from the `commands` registry (see
  * `commandsPlugin` and `bindHandler`). A handler bound there wins over the one
  * the command was created with, so a test can give a bus its own implementation.
  *
- * A handler can be wrapped in a policy, e.g. `latest(fn)`. Calling the command
- * directly, `command(payload)`, runs its own handler outside of any bus.
+ * A handler can be wrapped in a policy, e.g. `latest(fn)`.
  * `command.match(action)` tells whether an action has the type of the command,
  * as it does for an action creator.
  *
@@ -34,9 +35,9 @@ type MadeCommand<P, R, T extends string> = Command<P, R> & {
  * );
  * const sendMail = createCommand<Mail, void>("mail/send"); // implemented elsewhere
  *
+ * const bus = createBus<Events>();
  * bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
- * const bus = createBus({ commands });
- * const user = await bus.emit(getUser, "1");
+ * const user = await bus.emit(getUser("1"));
  *
  * commands.handle(getUser, async () => fakeUser); // in a test
  * ```