nanoeffects 0.13.0 → 0.15.0

package/README.md

@@ -87,8 +87,9 @@ Start with the [Guide](docs/guide.md) (bus → policies → effects → modules)
 | 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) |
+| See what ran and why (console, Redux DevTools) | [Tracing](docs/tracing.md) |
 
-[Full index, package entries, tracing](docs/README.md) · [Examples](examples/README.md) · [Why nanoeffects exists](docs/motivation.md)
+[Full index and package entries](docs/README.md) · [Examples](examples/README.md) · [Why nanoeffects exists](docs/motivation.md)
 
 - **Tiny.** `createBus` is about 1.4 kB gzip (1.3 kB brotli); other entries load only when imported.
 - **Cancellation first.** Aborting a task aborts its children and drops its result.

package/dist/actions.d.ts

@@ -1,6 +1,6 @@
 import { B as EventMap, G as Task, T as EventKey, U as PayloadOf, c as WithScope, h as Bus, n as Free, o as Scope, r as FreeActionCreator, t as ActionCreator } from "./action-creator-CQlFgQm4.js";
-import { r as Scoped, t as FieldsOfScope } from "./types-bzocBVYc.js";
-import { a as createModule, c as CarryingCalls, d as commandsPlugin, f as createCommand, l as MadeCommand, n as ModuleApi, o as modulePlugin, r as ModuleContext, s as Binding, t as Module, u as bindHandler } from "./module-woawvR28.js";
+import { r as Scoped, t as FieldsOfScope } from "./types-C7ukMwE-.js";
+import { a as createModule, c as CarryingCalls, d as commandsPlugin, f as createCommand, l as MadeCommand, n as ModuleApi, o as modulePlugin, r as ModuleContext, s as Binding, t as Module, u as bindHandler } from "./module-COv9ZSzS.js";
 import { t as OriginOptions } from "./origin-key-CxK0SkeG.js";
 //#region src/actions/action.d.ts
 type ScopedCreator<P, T extends string, F> = [P] extends [Free] ? FreeActionCreator<T, F> & WithScope<F> : ActionCreator<P, T, PayloadOf<P>, F> & WithScope<F>;

package/dist/context-types-qXxr_Grf.d.ts

@@ -0,0 +1,14 @@
+import { B as EventMap, x as ContextOf } from "./action-creator-CQlFgQm4.js";
+//#region src/core/context-types.d.ts
+/** What a function that makes the fields of a task gets to see. */
+type ContextTask = {
+  type: string;
+  payload?: unknown;
+};
+/**
+ * `unknown` when none of the `fields` is already a context field of the bus,
+ * else `never`: the call does not compile. Used as `bus: Bus<E> & NoClash<…>`.
+ */
+type NoClash<Fields extends object, E extends EventMap> = [keyof Fields & keyof ContextOf<E>] extends [never] ? unknown : never;
+//#endregion
+export { NoClash as n, ContextTask as t };

package/dist/context.d.ts

@@ -0,0 +1,25 @@
+import { B as EventMap, N as WithContext, h as Bus } from "./action-creator-CQlFgQm4.js";
+import { n as NoClash, t as ContextTask } from "./context-types-qXxr_Grf.js";
+//#region src/context/plugin.d.ts
+/**
+ * Puts `fields` on the context of every task of the bus: a store, a client, a
+ * logger. The types come from the value, so the event map needs no
+ * `WithContext`. Returns the same bus, typed with the fields. A function gets
+ * `{ type, payload }` of the task and returns its fields.
+ *
+ * Several uses merge with each other, with the `context` option of `createBus`
+ * and with `effectsPlugin`. A name that the bus already has is a type error. The
+ * fields of the library (`signal`, `emit`, `run`, …) win, and a field that the
+ * context already has is not replaced.
+ *
+ * @example
+ * ```ts
+ * type Events = { "user/loaded": User };
+ *
+ * const bus = createBus<Events>().use(contextPlugin({ store }));
+ * bus.on("user/loaded", (user, { store }) => store.put(user)); // ctx.store: Store
+ * ```
+ */
+export declare const contextPlugin: <Fields extends object>(fields: Fields | ((task: ContextTask) => Fields)) => <E extends EventMap>(bus: Bus<E> & NoClash<Fields, E>) => Bus<E & WithContext<Fields>>;
+//#endregion
+export type { ContextTask, NoClash };

package/dist/context.js

@@ -0,0 +1 @@
+const e=e=>typeof e==`function`,t=e=>({type:Reflect.get(e,`type`),payload:Reflect.get(e,`payload`)}),n=n=>r=>{let i=r.addContext;return r.addContext=r=>{i?.(r);let a=e(n)?n(t(r)):n;for(let[e,t]of Object.entries(a))e in r||Reflect.set(r,e,t)},r};export{n as contextPlugin};

package/dist/dev.d.ts

@@ -1,5 +1,5 @@
 import { B as EventMap, Y as UnsubscribeCallback, h as Bus } from "./action-creator-CQlFgQm4.js";
-import { i as WithApp, n as ModuleApi } from "./module-woawvR28.js";
+import { i as WithApp, n as ModuleApi } from "./module-COv9ZSzS.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,5 +1,5 @@
 import { B as EventMap, G as Task, u as Effect } from "./action-creator-CQlFgQm4.js";
-import { a as RaceStarter, c as all, d as delay, i as take, l as EffectContext, n as effectsPlugin, o as race, r as TakeOptions, s as allSettled, u as Starter } from "./plugin-BrTsPg2Y.js";
+import { a as RaceStarter, c as all, d as delay, i as take, l as EffectContext, n as effectsPlugin, o as race, r as TakeOptions, s as allSettled, u as Starter } from "./plugin-15-kkZp0.js";
 //#region src/utils/onAbort.d.ts
 export declare const onAbort: (ctx: {
   signal?: AbortSignal | undefined;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 import { A as HandlerRef, B as EventMap, C as Emit, D as EventPayload, E as EventLike, F as commandCall, G as Task, I as createBus, J as TraceLogger, K as Trace, L as Tracer, M as On, N as WithContext, O as EventsOf, P as WithType, R as anyEventType, S as ContextOption, T as EventKey, U as PayloadOf, V as Keys, W as Phase, Y as UnsubscribeCallback, _ as Command, b as Context, g as BusOptions, h as Bus, i as WithPayload, j as Off, k as Handler, m as AnyEvent, p as Action, q as TraceEvent, v as CommandCall, w as Emittable, x as ContextOf, y as Commands, z as EffectName } from "./action-creator-CQlFgQm4.js";
-import { n as NoClash, r as contextPlugin, t as ContextTask } from "./context-plugin-Cphk8jfq.js";
-export { type Action, type AnyEvent, type Bus, type BusOptions, type Command, type CommandCall, type Commands, type Context, type ContextOf, type ContextOption, type ContextTask, type EffectName, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type EventsOf, type Handler, type HandlerRef, type Keys, type NoClash, 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, contextPlugin, createBus };
+import { n as NoClash, t as ContextTask } from "./context-types-qXxr_Grf.js";
+export { type Action, type AnyEvent, type Bus, type BusOptions, type Command, type CommandCall, type Commands, type Context, type ContextOf, type ContextOption, type ContextTask, type EffectName, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type EventsOf, type Handler, type HandlerRef, type Keys, type NoClash, 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 @@
-import{a as e,r as t,t as n}from"./bus-Cdw5ajKF.js";const r=e=>typeof e==`function`,i=e=>({type:Reflect.get(e,`type`),payload:Reflect.get(e,`payload`)}),a=e=>t=>{let n=t.addContext;return t.addContext=t=>{n?.(t);let a=r(e)?e(i(t)):e;for(let[e,n]of Object.entries(a))e in t||Reflect.set(t,e,n)},t};export{e as anyEventType,n as commandCall,a as contextPlugin,t as createBus};
+export{a as anyEventType,t as commandCall,r as createBus}from"./bus-Cdw5ajKF.js";

package/dist/{module-woawvR28.d.ts → module-COv9ZSzS.d.ts}

@@ -1,5 +1,5 @@
 import { B as EventMap, G as Task, U as PayloadOf, Y as UnsubscribeCallback, _ as Command, b as Context, c as WithScope, h as Bus, o as Scope, v as CommandCall, y as Commands } from "./action-creator-CQlFgQm4.js";
-import { n as ScopeSlots, r as Scoped, t as FieldsOfScope } from "./types-bzocBVYc.js";
+import { n as ScopeSlots, r as Scoped, t as FieldsOfScope } from "./types-C7ukMwE-.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> & {

package/dist/notrace/actions.d.ts

@@ -1,5 +1,5 @@
 import { B as PayloadOf, C as EventKey, H as Task, K as UnsubscribeCallback, R as EventMap, _ as Commands, a as Scope, g as CommandCall, h as Command, n as Free, o as WithFields, p as Bus, r as FreeActionCreator, s as WithScope, t as ActionCreator, u as Effects, v as Context } from "./action-creator-Ls3Gy3jk.js";
-import { t as BoundOf } from "./plugin-Cw45_-Bo.js";
+import { t as BoundOf } from "./plugin-W4pZY7mM.js";
 import { t as OriginOptions } from "./origin-key-CxK0SkeG.js";
 //#region src/scope/types.d.ts
 /**

package/dist/notrace/context-types-DQYBFJG4.d.ts

@@ -0,0 +1,14 @@
+import { R as EventMap, y as ContextOf } from "./action-creator-Ls3Gy3jk.js";
+//#region src/core/context-types.d.ts
+/** What a function that makes the fields of a task gets to see. */
+type ContextTask = {
+  type: string;
+  payload?: unknown;
+};
+/**
+ * `unknown` when none of the `fields` is already a context field of the bus,
+ * else `never`: the call does not compile. Used as `bus: Bus<E> & NoClash<…>`.
+ */
+type NoClash<Fields extends object, E extends EventMap> = [keyof Fields & keyof ContextOf<E>] extends [never] ? unknown : never;
+//#endregion
+export { NoClash as n, ContextTask as t };

package/dist/notrace/effects.d.ts

@@ -1,5 +1,5 @@
 import { H as Task, R as EventMap, l as Effect } from "./action-creator-Ls3Gy3jk.js";
-import { a as RaceStarter, c as all, d as delay, i as take, l as EffectContext, n as effectsPlugin, o as race, r as TakeOptions, s as allSettled, u as Starter } from "./plugin-Cw45_-Bo.js";
+import { a as RaceStarter, c as all, d as delay, i as take, l as EffectContext, n as effectsPlugin, o as race, r as TakeOptions, s as allSettled, u as Starter } from "./plugin-W4pZY7mM.js";
 //#region src/utils/onAbort.d.ts
 export declare const onAbort: (ctx: {
   signal?: AbortSignal | undefined;

package/dist/notrace/index.d.ts

@@ -1,3 +1,3 @@
 import { A as On, B as PayloadOf, C as EventKey, D as Handler, E as EventsOf, F as Tracer, G as TraceLogger, H as Task, I as anyEventType, K as UnsubscribeCallback, L as EffectName, M as WithType, N as commandCall, O as HandlerRef, P as createBus, R as EventMap, S as Emittable, T as EventPayload, U as Trace, V as Phase, W as TraceEvent, _ as Commands, b as ContextOption, d as Action, f as AnyEvent, g as CommandCall, h as Command, i as WithPayload, j as WithContext, k as Off, m as BusOptions, p as Bus, v as Context, w as EventLike, x as Emit, y as ContextOf, z as Keys } from "./action-creator-Ls3Gy3jk.js";
-import { n as NoClash, r as contextPlugin, t as ContextTask } from "./context-plugin-BQa-wtbj.js";
-export { type Action, type AnyEvent, type Bus, type BusOptions, type Command, type CommandCall, type Commands, type Context, type ContextOf, type ContextOption, type ContextTask, type EffectName, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type EventsOf, type Handler, type HandlerRef, type Keys, type NoClash, 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, contextPlugin, createBus };
+import { n as NoClash, t as ContextTask } from "./context-types-DQYBFJG4.js";
+export { type Action, type AnyEvent, type Bus, type BusOptions, type Command, type CommandCall, type Commands, type Context, type ContextOf, type ContextOption, type ContextTask, type EffectName, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type EventsOf, type Handler, type HandlerRef, type Keys, type NoClash, 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/notrace/index.js

@@ -1 +1 @@
-import{i as e,n as t,t as n}from"./bus-G2AdGObY.js";const r=e=>typeof e==`function`,i=e=>({type:Reflect.get(e,`type`),payload:Reflect.get(e,`payload`)}),a=e=>t=>{let n=t.addContext;return t.addContext=t=>{n?.(t);let a=r(e)?e(i(t)):e;for(let[e,n]of Object.entries(a))e in t||Reflect.set(t,e,n)},t};export{e as anyEventType,n as commandCall,a as contextPlugin,t as createBus};
+export{i as anyEventType,t as commandCall,n as createBus}from"./bus-G2AdGObY.js";

package/dist/notrace/{plugin-Cw45_-Bo.d.ts → plugin-W4pZY7mM.d.ts}

@@ -1,5 +1,5 @@
 import { R as EventMap, c as BoundForm, j as WithContext, p as Bus, u as Effects, v as Context, z as Keys } from "./action-creator-Ls3Gy3jk.js";
-import { n as NoClash } from "./context-plugin-BQa-wtbj.js";
+import { n as NoClash } from "./context-types-DQYBFJG4.js";
 //#region src/utils/delay.d.ts
 /**
  * Resolves after `ms`, or rejects early if `ctx.signal` aborts. `ms` can be a

package/dist/observable.d.ts

@@ -17,4 +17,33 @@ export interface Subscribable<T> {
 export type Observable<T> = Subscribable<T> & {};
 export type Observe<E extends EventMap> = <K extends Keys<E>>(event: K) => Observable<E[K]>;
 export declare const createObserve: <E extends EventMap>(bus: Bus<E>) => Observe<E>;
+/**
+ * What a `Subject` reads and writes: the `on` and `emit` of a bus. An instance
+ * of a class made by `extendBus` or `Emitter` fits as well, and its `on` keeps
+ * the subscription for `dispose()`.
+ */
+export type Source<E extends EventMap> = Pick<Bus<E>, "on" | "emit">;
+/**
+ * One event of a source as an Observable that can also push a payload back:
+ * `subscribe` is `source.on(event, …)` and `next` is `source.emit(event, payload)`.
+ * It never completes, fails or replays, and it can be extended.
+ *
+ * @example
+ * ```ts
+ * const typed = new Subject(bus, "typed"); // Subject — the event "typed" of the bus as a stream
+ * const subscription = typed.subscribe((text) => console.log(text));
+ * typed.next("hello"); // the same as bus.emit("typed", "hello")
+ * subscription.unsubscribe();
+ * ```
+ */
+export declare class Subject<E extends EventMap, K extends Keys<E>> implements Observable<E[K]> {
+  [$$observable]: () => Subscribable<E[K]>;
+  readonly source: Source<E>;
+  readonly event: K;
+  constructor(source: Source<E>, event: K);
+  subscribe(observer: Observer<E[K]>): {
+    unsubscribe(): void;
+  };
+  next(payload: E[K]): void;
+}
 //#endregion

package/dist/observable.js

@@ -1 +1 @@
-const e=typeof Symbol==`function`&&Symbol.observable||`@@observable`,t=t=>n=>({subscribe:e=>({unsubscribe:t.on(n,t=>{typeof e==`function`?e(t):e.next?.(t)})}),[e](){return this}});export{e as $$observable,t as createObserve};
+const e=typeof Symbol==`function`&&Symbol.observable||`@@observable`,t=e=>t=>{typeof e==`function`?e(t):e.next?.(t)},n=n=>r=>({subscribe:e=>({unsubscribe:n.on(r,t(e))}),[e](){return this}});var r=class{source;event;constructor(e,t){this.source=e,this.event=t,this.next=this.next.bind(this)}subscribe(e){return{unsubscribe:this.source.on(this.event,t(e))}}next(e){let t=this.source.emit;Reflect.apply(t,this.source,[this.event,e])}[e](){return this}};export{e as $$observable,r as Subject,n as createObserve};

package/dist/oop.d.ts

@@ -87,7 +87,51 @@ export declare function Once<P>(event: EventOf<P>, options: ListenerOptions): Me
 export declare function Once(event: string, wrap?: Wrap, options?: ListenerOptions): MethodDecorator<never>;
 export declare function Once(event: string, options: ListenerOptions): MethodDecorator<never>;
 //#endregion
+//#region src/oop/emitter.d.ts
+/**
+ * A base class whose every instance is an independent emitter: it has `on`,
+ * `once`, `off`, `emit`, `dispose` and its own `bus`, typed by the event map
+ * `E`. Events of one instance never reach another instance. A subscription
+ * made through `this.on` or `this.once`, a method decorated with `@On` or
+ * `@Once`, and a `Subject` made over `this` all end with `dispose()`.
+ *
+ * `on`, `once`, `off` and `emit` are bound to the instance, so they can be
+ * taken off it (`const { emit } = video`). A subclass replaces one with an
+ * arrow property; TypeScript does not let it redeclare one as a method.
+ *
+ * It has no methods of plugins, because its bus is made inside. For a bus that
+ * instances share, or for plugins, use `extendBus(bus)`.
+ *
+ * @example
+ * ```ts
+ * type VideoEvents = { "video/time": number };
+ *
+ * class VideoService extends Emitter<VideoEvents> {
+ *   constructor() {
+ *     super();
+ *     this.on("video/time", (seconds) => console.log(seconds)); // ends with dispose()
+ *   }
+ * }
+ *
+ * const video = new VideoService();
+ * video.emit("video/time", 12);
+ * video.dispose(); // its subscriptions are gone
+ * ```
+ */
+export declare class Emitter<E extends EventMap = EventMap> {
+  on: Bus<E>["on"];
+  once: Bus<E>["once"];
+  off: Bus<E>["off"];
+  emit: Bus<E>["emit"];
+  [Symbol.dispose]: () => void;
+  constructor();
+  get bus(): Bus<E>;
+  /** Removes every subscription made through `on` and `once` of this instance. */
+  dispose(): void;
+}
+//#endregion
 //#region src/oop/extend.d.ts
+declare class Empty {}
 /**
  * Makes a class from `Base` whose instances have the methods of a bus, with the
  * subscriptions made through an instance ended by `dispose()`. `new Extended(…)`
@@ -100,6 +144,9 @@ export declare function Once(event: string, options: ListenerOptions): MethodDec
  * shared by its instances. The methods of the plugins used on `bus` before this
  * call are on the instances too; the ones of plugins used later are not.
  *
+ * `extendBus(bus)` with no class returns a class over an empty base, to extend
+ * as it is: `class Service extends extendBus(bus) {}`.
+ *
  * @example
  * ```ts
  * class SearchServiceBase {
@@ -116,6 +163,7 @@ export declare function Once(event: string, options: ListenerOptions): MethodDec
  */
 export declare function extendBus<C extends Constructor>(Base: C): Extended<C, Bus<EventMap>>;
 export declare function extendBus<B extends object, C extends Constructor>(bus: B, Base: C): Extended<C, B>;
+export declare function extendBus<B extends object>(bus: B): Extended<typeof Empty, B>;
 //#endregion
 //#region src/oop/subscriptions.d.ts
 /**

package/dist/oop.js

@@ -1 +1 @@
-import{r as e}from"./bus-Cdw5ajKF.js";const t=/* @__PURE__ */ new WeakMap,n=e=>typeof e==`function`,r=e=>Reflect.ownKeys(e).flatMap(t=>{let r=Reflect.getOwnPropertyDescriptor(e,t)?.value;return n(r)?[{key:t,value:r}]:[]}),i=/* @__PURE__ */ new WeakMap,a=e=>{let n=i.get(e);if(n)return n;let a=/* @__PURE__ */ new Set,o=[];for(let n=e;n&&n!==Object.prototype;n=Reflect.getPrototypeOf(n))for(let{key:e,value:i}of r(n)){if(e===`constructor`||a.has(e))continue;a.add(e);let n=t.get(i);n&&o.push({key:e,method:i,spec:n})}return i.set(e,o),o},o=/* @__PURE__ */ new WeakMap,s=e=>typeof e==`object`&&!!e||typeof e==`function`,c=e=>{let t=o.get(e);if(t)return t;let n=/* @__PURE__ */ new Set;return o.set(e,n),n},l=e=>{if(typeof e==`string`)return e;if(s(e)){let t=Reflect.get(e,`type`);return typeof t==`string`?t:e}return e},u=(e,t,n)=>Reflect.apply(Reflect.get(e,t),e,n),d=(e,t,n,r)=>{let[i,a,...o]=r,s=c(e),l={event:i,handler:a,off:()=>{}},d=u(t,n,[i,n===`once`?(e,t)=>(s.delete(l),typeof a==`function`?Reflect.apply(a,null,[e,t]):void 0):a,...o]),f=typeof d==`function`?()=>d():()=>{};return l.off=f,s.add(l),()=>{s.delete(l),f()}},f=(e,t,n)=>{let[r,i]=n,a=c(e);r===void 0&&a.clear();for(let e of[...a])Object.is(l(e.event),l(r))&&(i===void 0||e.handler===i)&&(a.delete(e),e.off());return u(t,`off`,n)},p=e=>{if(!s(e))return;let t=o.get(e);if(t){o.delete(e);for(let e of t)e.off()}},m=/* @__PURE__ */ new Set([`on`,`once`,`off`,`emit`,`ctx`,`commands`,`trace`,`addContext`,`applyScope`,`fitScope`,`app`,`use`]),h=Reflect.get(Symbol,`dispose`),g=e=>typeof e==`function`,_=(e,t,n,r)=>{n in t||Object.defineProperty(e,n,{configurable:!0,enumerable:!1,...r})},v=/* @__PURE__ */ new WeakMap,y=(e,t)=>{let n=v.get(e);if(n)return n;let r={on:(...n)=>d(e,t,`on`,n),once:(...n)=>d(e,t,`once`,n),off:(...n)=>f(e,t,n)};return v.set(e,r),r},b=(e,t)=>(...n)=>Reflect.apply(Reflect.get(e,t),e,n),x=(e,t)=>{for(let{method:n,spec:r}of a(Reflect.getPrototypeOf(e)??{})){let i=(t,r)=>Reflect.apply(n,e,[t,r]),a=r.wrap?r.wrap(i):i,o=r.once?`once`:`on`;d(e,t,o,[r.event,a,r.options])}},S=(e,t,n)=>{for(let r of[`on`,`once`,`off`])_(e,t,r,{get(){return y(this,n)[r]}});_(e,t,`emit`,{value:b(n,`emit`)});for(let[r,i]of Object.entries(n))typeof i==`function`&&!m.has(r)&&_(e,t,r,{value:b(n,r)});let r=function(){p(this)};_(e,t,`dispose`,{value:r}),h&&_(e,t,h,{value:r}),_(e,t,`bus`,{get:()=>n})},C=(e,t)=>{let n=function(...r){let i=Reflect.construct(t,r,new.target??n);return x(i,e),i};return Object.setPrototypeOf(n,t),n.prototype=Object.create(t.prototype,{constructor:{value:n,writable:!0,configurable:!0}}),Object.defineProperty(n,"name",{value:t.name,configurable:!0}),`bus`in t||Object.defineProperty(n,"bus",{value:e,configurable:!0}),S(n.prototype,t.prototype,e),n};function w(t,n){if(g(t))return C(e(),t);if(!n)throw TypeError(`extendBus: pass the class to extend`);return C(t,n)}function T(e){return t=>e?w(e,t):w(t)}const E=e=>{let[t,n,r]=e;return typeof n==`string`||typeof n==`symbol`?Reflect.get(Object(r),`value`):t},D=(e,n,r,i)=>((...a)=>{let o=E(a);if(typeof o==`function`){let a=typeof n==`function`?n:void 0,s=typeof n==`function`?r:n??r;t.set(o,{event:e,wrap:a,once:i,options:s})}});function O(e,t,n){return D(e,t,n,!1)}function k(e,t,n){return D(e,t,n,!0)}export{O as On,k as Once,T as WithBus,p as disposeBus,w as extendBus};
+import{r as e}from"./bus-Cdw5ajKF.js";const t=/* @__PURE__ */ new WeakMap,n=e=>typeof e==`function`,r=e=>Reflect.ownKeys(e).flatMap(t=>{let r=Reflect.getOwnPropertyDescriptor(e,t)?.value;return n(r)?[{key:t,value:r}]:[]}),i=/* @__PURE__ */ new WeakMap,a=e=>{let n=i.get(e);if(n)return n;let a=/* @__PURE__ */ new Set,o=[];for(let n=e;n&&n!==Object.prototype;n=Reflect.getPrototypeOf(n))for(let{key:e,value:i}of r(n)){if(e===`constructor`||a.has(e))continue;a.add(e);let n=t.get(i);n&&o.push({key:e,method:i,spec:n})}return i.set(e,o),o},o=/* @__PURE__ */ new WeakMap,s=e=>typeof e==`object`&&!!e||typeof e==`function`,c=e=>{let t=o.get(e);if(t)return t;let n=/* @__PURE__ */ new Set;return o.set(e,n),n},l=e=>{if(typeof e==`string`)return e;if(s(e)){let t=Reflect.get(e,`type`);return typeof t==`string`?t:e}return e},u=(e,t,n)=>Reflect.apply(Reflect.get(e,t),e,n),d=(e,t,n,r)=>{let[i,a,...o]=r,s=c(e),l={event:i,handler:a,off:()=>{}},d=u(t,n,[i,n===`once`?(e,t)=>(s.delete(l),typeof a==`function`?Reflect.apply(a,null,[e,t]):void 0):a,...o]),f=typeof d==`function`?()=>d():()=>{};return l.off=f,s.add(l),()=>{s.delete(l),f()}},f=(e,t,n)=>{let[r,i]=n,a=c(e);r===void 0&&a.clear();for(let e of[...a])Object.is(l(e.event),l(r))&&(i===void 0||e.handler===i)&&(a.delete(e),e.off());return u(t,`off`,n)},p=e=>{if(!s(e))return;let t=o.get(e);if(t){o.delete(e);for(let e of t)e.off()}},m=/* @__PURE__ */ new Set([`on`,`once`,`off`,`emit`,`ctx`,`commands`,`trace`,`addContext`,`applyScope`,`fitScope`,`app`,`use`]),h=Reflect.get(Symbol,`dispose`),g=e=>typeof e==`function`;var _=class{};const v=(e,t,n,r)=>{n in t||Object.defineProperty(e,n,{configurable:!0,enumerable:!1,...r})},y=/* @__PURE__ */ new WeakMap,b=(e,t)=>{let n=y.get(e);if(n)return n;let r={on:(...n)=>d(e,t,`on`,n),once:(...n)=>d(e,t,`once`,n),off:(...n)=>f(e,t,n)};return y.set(e,r),r},x=(e,t)=>(...n)=>Reflect.apply(Reflect.get(e,t),e,n),S=(e,t)=>{for(let{method:n,spec:r}of a(Reflect.getPrototypeOf(e)??{})){let i=(t,r)=>Reflect.apply(n,e,[t,r]),a=r.wrap?r.wrap(i):i,o=r.once?`once`:`on`;d(e,t,o,[r.event,a,r.options])}},C=(e,t,n)=>{for(let r of[`on`,`once`,`off`])v(e,t,r,{get(){return b(this,n)[r]}});v(e,t,`emit`,{value:x(n,`emit`)});for(let[r,i]of Object.entries(n))typeof i==`function`&&!m.has(r)&&v(e,t,r,{value:x(n,r)});let r=function(){p(this)};v(e,t,`dispose`,{value:r}),h&&v(e,t,h,{value:r}),v(e,t,`bus`,{get:()=>n})},w=(e,t)=>{let n=function(...r){let i=Reflect.construct(t,r,new.target??n);return S(i,e),i};return Object.setPrototypeOf(n,t),n.prototype=Object.create(t.prototype,{constructor:{value:n,writable:!0,configurable:!0}}),Object.defineProperty(n,"name",{value:t.name,configurable:!0}),`bus`in t||Object.defineProperty(n,"bus",{value:e,configurable:!0}),C(n.prototype,t.prototype,e),n};function T(t,n){return g(t)?w(e(),t):w(t,n??_)}function E(e){return t=>e?T(e,t):T(t)}const D=e=>{let[t,n,r]=e;return typeof n==`string`||typeof n==`symbol`?Reflect.get(Object(r),`value`):t},O=(e,n,r,i)=>((...a)=>{let o=D(a);if(typeof o==`function`){let a=typeof n==`function`?n:void 0,s=typeof n==`function`?r:n??r;t.set(o,{event:e,wrap:a,once:i,options:s})}});function k(e,t,n){return O(e,t,n,!1)}function A(e,t,n){return O(e,t,n,!0)}const j=/* @__PURE__ */ new WeakMap,M=t=>{let n=j.get(t);if(n)return n;let r=e();return j.set(t,r),r},N=[`on`,`once`,`off`,`emit`],P=e=>{for(let t of N){let n=Reflect.get(e,t);Reflect.set(e,t,n.bind(e))}};var F=class{constructor(){P(this),S(this,M(this))}get bus(){return M(this)}dispose(){p(this)}};const I={on(...e){return d(this,M(this),`on`,e)},once(...e){return d(this,M(this),`once`,e)},off(...e){return f(this,M(this),e)},emit(...e){let t=M(this);return Reflect.apply(Reflect.get(t,`emit`),t,e)}};for(let e of N)Object.defineProperty(F.prototype,e,{configurable:!0,writable:!0,value:I[e]});h&&Object.defineProperty(F.prototype,h,{configurable:!0,value:function(){this.dispose()}});export{F as Emitter,k as On,A as Once,E as WithBus,p as disposeBus,T as extendBus};

package/dist/{plugin-BrTsPg2Y.d.ts → plugin-15-kkZp0.d.ts}

@@ -1,5 +1,5 @@
 import { B as EventMap, N as WithContext, V as Keys, b as Context, d as Effects, h as Bus, l as BoundForm } from "./action-creator-CQlFgQm4.js";
-import { n as NoClash } from "./context-plugin-Cphk8jfq.js";
+import { n as NoClash } from "./context-types-qXxr_Grf.js";
 //#region src/utils/delay.d.ts
 /**
  * Resolves after `ms`, or rejects early if `ctx.signal` aborts. `ms` can be a

package/dist/scope.d.ts

@@ -1,5 +1,5 @@
 import { B as EventMap, a as EmitScope, d as Effects, f as Signaled, h as Bus, o as Scope, u as Effect } from "./action-creator-CQlFgQm4.js";
-import { n as ScopeSlots, r as Scoped } from "./types-bzocBVYc.js";
+import { n as ScopeSlots, r as Scoped } from "./types-C7ukMwE-.js";
 //#region src/scope/effect.d.ts
 /**
  * Marks a function whose first parameter is `{ signal }` as an effect, so that

package/dist/{types-bzocBVYc.d.ts → types-C7ukMwE-.d.ts}

@@ -1,5 +1,5 @@
 import { B as EventMap, d as Effects, o as Scope, s as WithFields } from "./action-creator-CQlFgQm4.js";
-import { t as BoundOf } from "./plugin-BrTsPg2Y.js";
+import { t as BoundOf } from "./plugin-15-kkZp0.js";
 //#region src/scope/types.d.ts
 /**
  * The slots `scopePlugin` fills for `modulePlugin`. They are not on `Bus`: a bus

package/docs/cancel-stale-requests.md

@@ -60,7 +60,7 @@ const bus = createBus(); // the bus: events and handlers
 // latest: a newer search aborts the request in flight
 const searchLatest = latest(async (query, { signal }) => {
   const items = await api.search(query, { signal });
-  bus.emit("results", items);
+  render(items);
 });
 
 // debounce: run after 300 ms without a new "typed"
@@ -84,7 +84,11 @@ const searchOnce = timeout(5000, (query, { signal }) => api.search(query, { sign
 // retry: up to 4 attempts, backoff makes the pause longer each time
 const searchWithRetry = retry(searchOnce, {
   times: 4,
-  delay: backoff({ base: 200, max: 5000, jitter: true }),
+  delay: backoff({
+    base: 200,
+    max: 5000,
+    jitter: true,
+  }),
 });
 
 // latest: a newer search aborts the whole retry chain

package/docs/context.md

@@ -25,10 +25,11 @@ To give fields to **one** command, action, job or module, or to replace them for
 
 ## Type the fields (optional)
 
-In TypeScript, `contextPlugin` puts the fields on every task of **this** bus and takes their types from the value you pass. The event map holds only events. It does not wire anything across the app — another bus can have different fields or none.
+In TypeScript, `contextPlugin` (from `nanoeffects/context`) puts the fields on every task of **this** bus and takes their types from the value you pass. The event map holds only events. It does not wire anything across the app — another bus can have different fields or none.
 
 ```ts
-import { contextPlugin, createBus } from "nanoeffects";
+import { createBus } from "nanoeffects";
+import { contextPlugin } from "nanoeffects/context";
 
 // Events — event name → payload
 type Events = { save: Draft };

package/docs/debounce-and-abort.md

@@ -25,13 +25,11 @@ const bus = createBus(); // the bus: events and handlers
 const searchLatest = latest(async (query, { signal }) => {
   // signal: pass it on so the browser cancels the request itself
   const items = await api.search(query, { signal });
-  bus.emit("results", items);
+  render(items);
 });
 
 // debounce: run searchLatest after 300 ms without a new "typed"
 bus.on("typed", debounce(300, searchLatest));
-
-bus.on("results", (items) => render(items));
 ```
 
 What to replace: `api.search` is your own request function. It must accept `{ signal }` and give it to `fetch`. `render` shows the items.

package/docs/effects.md

@@ -124,7 +124,11 @@ import { backoff, retry } from "nanoeffects/effects";
 const loadWithRetry = retry(loadUser, {
   times: 5,
   // backoff — pause 200, 400, 800, … ms, never over 5 s, a random part of it
-  delay: backoff({ base: 200, max: 5000, jitter: true }),
+  delay: backoff({
+    base: 200,
+    max: 5000,
+    jitter: true,
+  }),
 });
 ```
 
@@ -147,8 +151,11 @@ If handlers call the same helpers often, put them on the task once. A handler th
 import { createBus } from "nanoeffects";
 import { all, delay, effectsPlugin, race } from "nanoeffects/effects";
 
-// effectsPlugin — add race, all and delay to the context of every task; returns the same bus
-const bus = createBus().use(effectsPlugin({ race, all, delay }));
+// effectsPlugin — add race, all and delay to the context of every task
+const effects = effectsPlugin({ race, all, delay });
+
+// use returns the same bus, typed with the new fields
+const bus = createBus().use(effects);
 
 bus.on("load", async (id, { race, all, delay }) => {
   // race — same as race(ctx, …)

package/docs/observable.md

@@ -70,6 +70,56 @@ bus.on(queryChanged, (query) => console.log("search for", query));
 
 The Observable can come from anywhere, not only from `createObserve`. `subscription.unsubscribe()` stops it; the bus does not know about it. Pass the callback to `subscribe` as it is, and do not call `bus.emitter(...)` inside the operators on every value.
 
+## Read and write one event with a Subject
+
+Problem: `createObserve` only reads. Code written for streams often also needs to push a value into the same event, and passing a bus and an event name around for that is clumsy.
+
+`Subject` is one event of a bus as one object. `subscribe` listens, `next` emits. It has no `complete`, no `error` and no replay: an event of a bus does not end, and the bus keeps no values.
+
+```js
+import { createBus } from "nanoeffects";
+import { Subject } from "nanoeffects/observable";
+
+const bus = createBus(); // the bus: events and handlers
+
+const typed = new Subject(bus, "typed"); // Subject — the event "typed" as a stream you can also write to
+
+const subscription = typed.subscribe((text) => console.log(text)); // like bus.on("typed", …)
+typed.next("hello"); // like bus.emit("typed", "hello"): bus.on handlers and subscribers both run
+subscription.unsubscribe(); // removes this subscription only
+```
+
+- `next` works when you take it off the subject, so `input.addEventListener("input", (event) => typed.next(event.target.value))` and `store.subscribe(typed.next)` need no wrapper.
+- A subscriber that is added later does not get a value emitted before. Add `startWith` or `shareReplay` in RxJS when it should.
+- RxJS takes a `Subject` as it takes `createObserve`: `from(typed)`. It is not an RxJS `Subject` (no `error`, `complete` or `pipe`), so it does not fit where that type is wanted.
+
+### Extend it for a named stream
+
+Problem: the event name is repeated wherever the stream is made. A subclass fixes it once.
+
+```js
+import { createBus } from "nanoeffects";
+import { Subject } from "nanoeffects/observable";
+
+class TypedText extends Subject {
+  constructor(bus) {
+    super(bus, "typed"); // the event is fixed by the class
+  }
+
+  next(text) {
+    super.next(text.trim()); // a method of the subclass replaces the one of Subject
+  }
+}
+
+const bus = createBus(); // the bus: events and handlers
+const typed = new TypedText(bus);
+typed.next("  hello "); // emits "typed" with "hello"
+```
+
+### Use it inside a class with a bus
+
+A class made with `extendBus` has its own `on` and `emit`. Pass `this` as the source and the subscription belongs to the instance, so `dispose()` ends it ([Classes with a bus](oop.md)).
+
 ## Do the work in a handler, not in `switchMap`
 
 An Observable is good for shaping values. A request is better in a handler with a policy, because the handler has a `signal` and the trace shows it. Split it: RxJS ends at the value, the bus starts the work.

package/docs/oop.md

@@ -1,6 +1,11 @@
 # Use the bus from a class
 
-Use this page when **your domain logic lives in classes**: a service, a store or a controller that needs the bus inside its methods. A class made with `extendBus` has `on`, `emit` and the other methods of the bus, and remembers what each instance subscribed to, so `dispose()` ends it all.
+Use this page when **your domain logic lives in classes**: a service, a store or a controller that needs the bus inside its methods. There are two ways to give a class the methods of a bus, and both remember what each instance subscribed to, so `dispose()` ends it all:
+
+| You want | Use |
+| -------- | --- |
+| every `new Service()` to be an independent emitter | `extends Emitter` |
+| the instances to share a bus, or to use plugins | `extends extendBus(bus)` |
 
 If your logic is plain functions, stay with [modules](actions.md#mount-domains-with-modules): a module is the same idea without a class.
 
@@ -8,7 +13,68 @@ If your logic is plain functions, stay with [modules](actions.md#mount-domains-w
 
 A class that listens to the bus keeps a reference to it, and keeps every unsubscribe function in a list to call when the object goes away. Forget one and the old object keeps handling events. `extendBus` does both for you.
 
-## Give a class the methods of a bus
+## Make an independent emitter with `Emitter`
+
+`Emitter` is a base class. Every instance of a class that extends it has a bus of its own: the events of one instance never reach another. It is the shape of Node's `EventEmitter`.
+
+```js
+// video-service.js
+import { Emitter } from "nanoeffects/oop";
+
+// Emitter — a base class: each new VideoService() gets on, once, off, emit, dispose and its own bus
+export class VideoService extends Emitter {
+  constructor() {
+    super();
+    // this.on — a subscription of this instance; dispose() removes it
+    this.on("played", () => console.log("playing"));
+  }
+}
+```
+
+```js
+import { VideoService } from "./video-service";
+
+const first = new VideoService();
+const second = new VideoService();
+first.on("paused", () => console.log("first paused"));
+second.emit("paused"); // nothing: the instances do not share a bus
+first.emit("paused"); // logs "first paused"
+first.dispose(); // its subscriptions are gone
+```
+
+What you get:
+
+- `on`, `once`, `off`, `emit`, `dispose` and `bus` (the bus of that instance). `instance[Symbol.dispose]()` does the same as `dispose()`, so `using video = new VideoService()` works where the runtime supports it.
+- `@On` and `@Once` work on its methods (see below). They are subscribed when the base constructor runs, so before the fields of your subclass.
+- `on`, `once`, `off` and `emit` are bound to the instance, so `const { emit } = video` works. A subclass replaces one with an arrow property (`emit = (…) => …`); TypeScript does not let it redeclare one as a method. `dispose` is a method and can be overridden as usual.
+- No methods of plugins: the bus is made inside, so no plugin is on it. For plugins, or for a bus that several instances or classes share, use `extendBus` (next sections).
+- For a stream of one event, see [`Subject`](observable.md#read-and-write-one-event-with-a-subject) and [Stream an event with a `Subject`](#stream-an-event-with-a-subject).
+
+### Type the events (optional)
+
+`Emitter` takes the events of the class as a type parameter.
+
+```ts
+// video-service.ts
+import { Emitter } from "nanoeffects/oop";
+
+// VideoEvents — checker only: the payload of each event of this class
+type VideoEvents = { "video/time": number; "video/paused": void };
+
+export class VideoService extends Emitter<VideoEvents> {
+  constructor() {
+    super();
+    // seconds is a number because "video/time" carries one
+    this.on("video/time", (seconds) => console.log(seconds));
+  }
+}
+
+const video = new VideoService();
+video.emit("video/time", 12); // checked against VideoEvents
+video.emit("video/paused"); // no payload
+```
+
+## Give a class the methods of a shared bus
 
 `extendBus(bus, Base)` returns a subclass of `Base`. Its instances have the methods of the bus, and the arguments of `new` go to the constructor of `Base`.
 
@@ -69,9 +135,33 @@ What you get:
 - `bus` is the bus, and `Class.bus` is the same one.
 - `this.on` works in the constructor of `Base`. The methods exist on the prototype of the subclass, which is the prototype of the instance already.
 
+### Extend the result with no class of your own
+
+`extendBus(bus)` without a class returns a class with the methods of that bus and nothing else. Extend it as it is.
+
+```js
+// service.js
+import { createBus } from "nanoeffects";
+import { extendBus } from "nanoeffects/oop";
+
+const bus = createBus(); // the bus that the services share
+
+// extendBus(bus) — a class with on, once, off, emit and dispose over this bus
+export class AudioService extends extendBus(bus) {
+  constructor() {
+    super();
+    this.on("muted", () => console.log("muted")); // ends with dispose()
+  }
+}
+
+const audio = new AudioService();
+bus.emit("muted"); // the instances share this bus: logs "muted"
+audio.dispose();
+```
+
 ## Let the class make its bus
 
-Leave the bus out and the class gets its own, shared by all of its instances.
+Leave the bus out and the class gets its own, shared by all of its instances. That is one bus for each class; `Emitter` makes one for each instance.
 
 ```js
 // notifier.js
@@ -113,6 +203,37 @@ stop(); // the function on returned still works, and does nothing now
 
 A subscription that you removed yourself (the function `on` returned, `this.off`, or a `once` that fired) is forgotten, so the instance holds nothing for it.
 
+## Stream an event with a `Subject`
+
+Problem: a service hands one of its events to code written for streams, and the stream subscription should end with the service. `createObserve(this.bus)` would not: it subscribes through the bus, so `dispose()` does not know it.
+
+Pass `this` to `Subject` as the source. The subject subscribes through `this.on`, so the subscription belongs to the instance ([Read and write one event with a Subject](observable.md#read-and-write-one-event-with-a-subject)).
+
+```js
+// typing.js
+import { createBus } from "nanoeffects";
+import { Subject } from "nanoeffects/observable";
+import { extendBus } from "nanoeffects/oop";
+
+const bus = createBus(); // the bus: events and handlers
+
+class TypingBase {
+  constructor() {
+    this.typed = new Subject(this, "typed"); // Subject — the event "typed" as a stream; this is the source
+    this.typed.subscribe((text) => console.log(text));
+  }
+}
+
+const Typing = extendBus(bus, TypingBase); // extendBus — a class with on, emit and dispose
+
+const typing = new Typing();
+typing.typed.next("a"); // logs "a"
+typing.dispose(); // ends the subscription of the Subject too
+typing.typed.next("b"); // nothing is logged
+```
+
+In TypeScript, declare `on` and `emit` in the class (`declare on: BusMethods<typeof bus>["on"]`, see [Type the instances](#type-the-instances-optional)) so that `this` fits as the source.
+
 ## Keep a method of your own
 
 The class wins any clash of names. If `Base` has `emit`, `dispose`, `on` or `bus`, yours stays and the bus method is not added. A `Base` with its own `dispose` would never end the subscriptions, so call `disposeBus(this)` from there.
@@ -285,4 +406,5 @@ service.emit("order/placed", { id: "o1" }); // checked against Events
 
 - `this` is not bound in a handler that you pass by hand (see above).
 - The methods of a plugin used after `extendBus` are not on the class. Use the plugins first, then `extendBus`.
-- One bus for each instance, mixing the methods into an object that exists, and decorators for fields or parameters are not part of this entry.
+- `Emitter` has no methods of plugins, because its bus is made inside. Use `extendBus(bus)` for them.
+- Mixing the methods into an object that exists, and decorators for fields or parameters are not part of this entry.

package/docs/package.md

@@ -9,6 +9,7 @@ Imports are split so you only load what you use. `createBus` stays small; the re
 | `nanoeffects/effects` | `retry`, `timeout`, `poll`, `delay`, `take`, `all`, `allSettled`, `race`, `effectsPlugin` |
 | `nanoeffects/actions` | `createAction`, `createCommand`, `createJob`, `createModule`, `modulePlugin`, `commandsPlugin` |
 | `nanoeffects/match` | `matchPlugin`: `on`, `once` and `off` that take a function which picks the events |
+| `nanoeffects/context` | `contextPlugin`: your own fields (a store, a client) on `ctx` of every task, typed from the value |
 | `nanoeffects/signal` | `signalPlugin`: `emit(call, { signal })` ties the tasks of an emit to an outside `AbortSignal` |
 | `nanoeffects/oop` | `extendBus`, `WithBus`, `On`, `Once`, `disposeBus`: the methods of a bus on a class, with the subscriptions of each instance ended by `dispose()` |
 | `nanoeffects/scope` | `scopePlugin`, `effect`: fields for one command, action, job, module or `emit` (the types `Scope`, `Effect`) |