nanoeffects 0.0.0-stage → 0.2.0

package/dist/notrace/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?: never;
+  /**
+   * 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/notrace/actions.d.ts

@@ -0,0 +1,222 @@
+import { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as EventMap, n as FreeActionCreator, o as Bus, r as createAction, t as ActionCreator, u as Context } from "./action-rqZEnRIp.js";
+//#region src/actions/command.d.ts
+/**
+ * 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.
+ *
+ * The handler is optional. A command without one is only a contract, and the
+ * bus gets its implementation from the `commands` registry (see
+ * `createCommands` 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.
+ *
+ * @example
+ * ```ts
+ * const getUser = createCommand("user/get", (id: string, { signal }) =>
+ *   fetchUser(id, { signal }),
+ * );
+ * const sendMail = createCommand<Mail, void>("mail/send"); // implemented elsewhere
+ *
+ * const commands = createCommands([bindHandler(sendMail, smtpSend)]);
+ * const bus = createBus({ commands });
+ * const user = await bus.emit(getUser, "1");
+ *
+ * commands.handle(getUser, async () => fakeUser); // in a test
+ * ```
+ */
+export declare const createCommand: <P = void, R = void, T extends string = string, E extends EventMap = EventMap>(type: T, handler?: Task<P, E, R>) => Command<P, R> & {
+  readonly type: T;
+};
+/** A command (or its type) with the handler to bind to it; `bindHandler` makes one. */
+type Binding<E extends EventMap = EventMap> = readonly [Command<never, unknown> | string, Task<never, E, unknown>];
+/**
+ * Pairs a command with the handler to bind to it, for `createCommands`. It
+ * checks that the handler fits the command.
+ *
+ * @example
+ * ```ts
+ * createCommands([bindHandler(sendMail, smtpSend)]);
+ * ```
+ */
+export declare const bindHandler: <P, R, E extends EventMap>(command: Command<P, R>, fn: Task<P, E, R>) => Binding<E>;
+/**
+ * The handlers bound to commands of `bus`: it makes the registry, sets it as
+ * the commands of the bus and returns it. Each bus has its own, so each test
+ * can have its own implementation. `handle` binds more later and returns the
+ * function that unbinds. A second `createCommands(bus)` replaces the registry
+ * of that bus.
+ *
+ * What the bus runs for a command: the handler bound last, else the one the
+ * command was created with, else it throws `No handler for command "..."`.
+ *
+ * @example
+ * ```ts
+ * const bus = createBus<Events>();
+ * const commands = createCommands(bus, [bindHandler(sendMail, smtpSend)]);
+ *
+ * const unbind = commands.handle(getUser, async () => fakeUser);
+ * unbind(); // the command's own handler is back
+ * ```
+ */
+export declare const createCommands: <E extends EventMap>(bus: Bus<E>, bindings?: readonly Binding<E>[]) => {
+  run: (command: Command, payload: unknown, ctx: unknown) => unknown;
+  handle: {
+    <P, R>(command: Command<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
+    (type: string, fn: Task<never, E, unknown>): UnsubscribeCallback;
+    (bindings: readonly Binding<E>[]): UnsubscribeCallback;
+  };
+};
+//#endregion
+//#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
+//#region src/actions/module.d.ts
+/**
+ * What a module's `setup` gets: the context of the module's task, so `on`,
+ * `emit` and `run` work as in a handler, plus `handle` to bind commands, `use`
+ * to mount sub-modules and `spawn` to start a background task. Everything the
+ * module does is undone when it is unmounted.
+ */
+type ModuleContext<E extends EventMap = EventMap> = Context<E> & {
+  /** Binds the handler of a command, or a list of them; undone on unmount. */
+  handle<P, R>(command: Command<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
+  handle(type: string, fn: Task<never, E, unknown>): UnsubscribeCallback;
+  handle(bindings: readonly Binding<E>[]): UnsubscribeCallback;
+  /**
+   * Brings sub-modules and commands, in any order. A sub-module is mounted and
+   * unmounted with this one. A command is bound to the handler it carries, for
+   * as long as this module is mounted; a command that answers by itself keeps
+   * answering after the module is gone, since the handler is its own. The
+   * returned function undoes just this call, e.g. for what was added later from
+   * a listener.
+   */
+  use(...items: Array<Module<E> | Command<never, unknown>>): UnsubscribeCallback;
+  /**
+   * Starts a background task that lives as long as the module: it is aborted
+   * on unmount, and an error of it is left unhandled, as in any handler.
+   */
+  spawn<P>(fn: Task<P, E, unknown>, ...payload: PayloadOf<P>): void;
+};
+type Module<E extends EventMap = EventMap> = {
+  readonly name: string;
+  readonly setup: (m: ModuleContext<E>) => void;
+};
+/**
+ * Describes one domain of an app: the commands it handles, the events it
+ * listens to, its sub-modules and its background tasks. The `name` shows up as
+ * the type of the module's tasks in the trace.
+ *
+ * @example
+ * ```ts
+ * export const userModule = createModule<Events>("user", (m) => {
+ *   m.handle(getUser, fetchUser);
+ *   m.handle([bindHandler(sendMail, smtpSend)]);
+ *   m.use(authModule);
+ *
+ *   m.on(loginRequested, (user, ctx) => ctx.emit(userLoaded(user)));
+ *   m.spawn(async (_, ctx) => {
+ *     for (;;) await handleNext(await take(ctx, "job"));
+ *   });
+ * });
+ * ```
+ */
+export declare const createModule: <E extends EventMap = EventMap>(name: string, setup: (m: ModuleContext<E>) => void) => Module<E>;
+type Registry<E extends EventMap> = ReturnType<typeof createCommands<E>>;
+/** What `modulePlugin` returns. */
+type ModuleApi<E extends EventMap = EventMap> = {
+  /** The registry of command handlers of the bus: the one it was made with, or the app's own. */
+  commands: Registry<E>;
+  /** Mounts a module and returns the function that unmounts it; a module that is mounted already is not run again. */
+  mount(module: Module<E>): UnsubscribeCallback;
+  unmount(module: Module<E>): void;
+  isMounted(module: Module<E>): boolean;
+  /** Unmounts every module; a disposed app cannot mount modules. */
+  dispose(): void;
+};
+/**
+ * The plugin that assembles an app from modules: `bus.use(modulePlugin(modules))`
+ * mounts `modules` at once, in the order given, and returns `mount`, `unmount`,
+ * `isMounted`, `dispose` and `commands` for the modules that come and go later. The bus runs the commands that the
+ * modules bind: if `createCommands(bus)` was called before, that registry is
+ * used, otherwise the app attaches its own, as `app.commands`.
+ *
+ * A module is known by its `name`: mounting a module whose name is taken
+ * replaces the mounted one, which is unmounted first. That is what hot reload
+ * needs (see `docs/hmr.md`): the new version of a module file mounts again and
+ * the old version goes away with its subscriptions, commands and tasks.
+ *
+ * Unmounting undoes everything the module did: its subscriptions, its bound
+ * commands, its sub-modules and its background tasks. `dispose` unmounts them
+ * all, and a disposed app cannot mount modules.
+ *
+ * @example
+ * ```ts
+ * const bus = createBus<Events>();
+ * const app = bus.use(modulePlugin([userModule]));
+ *
+ * const unmount = app.mount(orderModule); // later, e.g. after a lazy import
+ * unmount(); // or app.unmount(orderModule)
+ *
+ * bus.emit(getUser, "1");
+ * app.commands.handle(getUser, fakeUser); // in a test
+ * app.dispose();
+ * ```
+ */
+export declare const modulePlugin: <E extends EventMap>(modules?: readonly Module<E>[]) => (bus: Bus<E>) => ModuleApi<E>;
+//#endregion
+export { type ActionCreator, type Binding, type FreeActionCreator, type Job, type Module, type ModuleApi, type ModuleContext, createAction };

package/dist/notrace/actions.js

@@ -0,0 +1 @@
+import{i as e,n as t,s as n}from"./context-yAWj0BFZ.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,n)=>Object.assign((r,i)=>{if(!n)throw new a(`No handler for command "${e}"`);return n(r,i??t({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=t({event:{type:`app`,payload:void 0},bus:i,tracer:i.trace}),l=t=>{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=e(t,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=(e,t)=>{let r=Reflect.apply(o.handle,null,[e,t]);return n(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/notrace/bus-Dx0l9X6h.js

@@ -0,0 +1 @@
+import{a as e,c as t,n,r}from"./context-yAWj0BFZ.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=(e,a)=>{let{onError:o}=s,{ctx:c}=n({event:a,bus:m,tracer:s.trace,parent:{ref:r()}});if(!o){e(a.payload,c);return}let l=e=>{try{o(e,a)}catch(e){t(`onError failed`,e)}};try{let t=e(a.payload,c);i(t)&&Promise.resolve(t).catch(l)}catch(e){l(e)}},m={on:d,off:f,emit:(t,i)=>{let c=o(t),d=a(t,i),f={type:c,payload:d},h=[...u.get(c),...u.get(`*`)];h.length===0&&typeof t!=`function`&&s.onUnhandled?.(f);for(let e of h)p(e,f);if(typeof t==`function`){let{ctx:i}=n({event:f,bus:m,tracer:s.trace,parent:{ref:r()}}),a=m.commands?.run??l;return e(i,`command`,()=>a(t,d,i))}},use:e=>e(m),context:s.context,trace:s.trace};return m};export{s as n,u as t};

package/dist/notrace/context-yAWj0BFZ.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)}},a=e=>{let t=new AbortController;return{controller:t,unlink:i({signal:e},e=>t.abort(e))}};let o;const s=()=>o,c=()=>{},l=(e,t,n,r)=>{},u=(e,t)=>c,d=(e,t,n)=>n(),f=(e,t)=>typeof e==`function`?e(t):e,p=e=>e,m=({event:e,bus:t,tracer:n,parent:r})=>{let{controller:s,unlink:l}=a(r?.signal),{signal:u}=s,h=(...e)=>{if(u.aborted)return;let n=t?.emit,r=o;o=void 0;try{return n?.(...e)}finally{o=r}},g=(...e)=>{if(u.aborted)return c;let n=t?.on,r=n?.(...e);if(!r)return c;let a=i({signal:u},r);return()=>{a(),r()}},_=async(r,...i)=>{u.throwIfAborted();let a=i[0],o=m({event:{type:e.type,payload:a},bus:t,tracer:n,parent:{signal:u,ref:void 0}});try{return await d(o.ctx,`run`,()=>r(a,o.ctx))}finally{o.unlink()}};return{ctx:p({...f(t?.context,e),type:e.type,payload:e.payload,signal:u,abort:e=>s.abort(e),emit:h,on:g,off:t?.off??c,run:_}),unlink:l}},h=(e,t)=>m({event:{type:t??e.type??``,payload:e.payload},bus:{emit:e.emit,on:e.on,off:e.off,context:e},tracer:void 0,parent:{signal:e.signal,ref:void 0}});export{d as a,e as c,h as i,m as n,l as o,s as r,i as s,u as t};

package/dist/notrace/delay-Cgvn16oY.js

@@ -0,0 +1 @@
+import{s as e}from"./context-yAWj0BFZ.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};