@vielzeug/flux 1.0.3

package/dist/operators/utility.js

@@ -0,0 +1,226 @@
+import { error as e, warn as t } from "../_dev.js";
+import { flux as n } from "../core.js";
+import { DEFAULT_SCHEDULER as r } from "../_scheduler.js";
+import { FluxTimeoutError as i } from "../errors.js";
+import { guard as a } from "../_safe.js";
+import { clampPositiveInt as o } from "../_numeric.js";
+//#region src/operators/utility.ts
+function s(e, t) {
+	let r = /* @__PURE__ */ new Set(), i = [], a, o = !1, s, c = !1;
+	return n((n) => {
+		if (c) {
+			n.error?.(s);
+			return;
+		}
+		for (let e of i) n.next(e);
+		if (o) {
+			n.complete?.();
+			return;
+		}
+		let l = {
+			complete: n.complete,
+			error: n.error,
+			next: n.next
+		};
+		return r.add(l), r.size === 1 && (a = e.subscribe({
+			complete() {
+				o = !0;
+				for (let e of [...r]) e.complete?.();
+				r.clear();
+			},
+			error(e) {
+				c = !0, s = e;
+				for (let t of [...r]) t.error?.(e);
+				r.clear();
+			},
+			next(e) {
+				t > 0 && (i.length >= t && i.shift(), i.push(e));
+				for (let t of [...r]) t.next(e);
+			}
+		})), () => {
+			r.delete(l), r.size === 0 && (a?.(), a = void 0);
+		};
+	});
+}
+function c() {
+	return (e) => s(e, 0);
+}
+function l(e = 1) {
+	let { clamped: n, value: r } = o(e);
+	return n && t(`shareReplay: bufferSize must be a finite integer >= 1, got ${e} — clamped to ${r}`), (e) => s(e, r);
+}
+function u(e) {
+	return (t) => n((n) => t.subscribe({
+		complete: n.complete,
+		error: n.error,
+		next(t) {
+			a(() => {
+				e(t), n.next(t);
+			}, n.error);
+		}
+	}));
+}
+function d(e, t = r) {
+	return (r) => n((n) => {
+		let i = [], a = r.subscribe({
+			complete() {
+				i.push(t.delay(() => n.complete?.(), e));
+			},
+			error: n.error,
+			next(r) {
+				i.push(t.delay(() => n.next(r), e));
+			}
+		});
+		return () => {
+			a();
+			for (let e of i) e();
+		};
+	});
+}
+function f(e, t = r) {
+	return (r) => n((n) => {
+		let a, o = () => {
+			a = t.delay(() => {
+				n.error?.(new i(e));
+			}, e);
+		};
+		o();
+		let s = r.subscribe({
+			complete() {
+				a(), n.complete?.();
+			},
+			error(e) {
+				a(), n.error?.(e);
+			},
+			next(e) {
+				a(), o(), n.next(e);
+			}
+		});
+		return () => {
+			a(), s();
+		};
+	});
+}
+function p(e) {
+	return (t) => n((n) => {
+		let r, i = t.subscribe({
+			complete: n.complete,
+			error(t) {
+				a(() => {
+					r = e(t).subscribe({
+						complete: n.complete,
+						error: n.error,
+						next: n.next
+					});
+				}, n.error);
+			},
+			next: n.next
+		});
+		return () => {
+			i(), r?.();
+		};
+	});
+}
+function m(e, t, i = r) {
+	return (r) => n((n) => {
+		let o = 0, s, c;
+		function l() {
+			s = r.subscribe({
+				complete: n.complete,
+				error(r) {
+					if (o < e) {
+						let e = o++;
+						t === void 0 ? l() : a(() => {
+							let n = typeof t == "function" ? t(e) : t;
+							c = i.delay(l, Math.max(0, n));
+						}, n.error);
+					} else n.error?.(r);
+				},
+				next: n.next
+			});
+		}
+		return l(), () => {
+			c?.(), s?.();
+		};
+	});
+}
+function h(t) {
+	return (r) => n((n) => {
+		let i = !1, a = () => {
+			if (!i) {
+				i = !0;
+				try {
+					t();
+				} catch (t) {
+					e("finalize: cleanup callback threw", t);
+				}
+			}
+		}, o = r.subscribe({
+			complete() {
+				a(), n.complete?.();
+			},
+			error(e) {
+				a(), n.error?.(e);
+			},
+			next: n.next
+		});
+		return () => {
+			a(), o();
+		};
+	});
+}
+function g(e) {
+	return e.reason ?? new DOMException("Aborted", "AbortError");
+}
+function _(e, t) {
+	return new Promise((n, r) => {
+		if (t?.aborted) {
+			r(g(t));
+			return;
+		}
+		let i, a = () => {}, o = () => {
+			a(), r(g(t));
+		};
+		t?.addEventListener("abort", o, { once: !0 }), a = e.subscribe({
+			complete() {
+				t?.removeEventListener("abort", o), n(i);
+			},
+			error(e) {
+				t?.removeEventListener("abort", o), r(e);
+			},
+			next(e) {
+				i = e;
+			}
+		});
+	});
+}
+function v(e, t) {
+	return new Promise((n, r) => {
+		let i = [];
+		if (t?.aborted) {
+			n(i);
+			return;
+		}
+		let a = () => {}, o = () => {
+			a(), n(i);
+		};
+		t?.addEventListener("abort", o, { once: !0 }), a = e.subscribe({
+			complete() {
+				t?.removeEventListener("abort", o), n(i);
+			},
+			error(e) {
+				t?.removeEventListener("abort", o), r(e);
+			},
+			next(e) {
+				i.push(e);
+			}
+		});
+	});
+}
+function y(...e) {
+	return (t) => e.reduce((e, t) => t(e), t);
+}
+//#endregion
+export { p as catchError, d as delay, h as finalize, y as flow, m as retry, c as share, l as shareReplay, u as tap, f as timeout, v as toArray, _ as toPromise };
+
+//# sourceMappingURL=utility.js.map

package/dist/operators/utility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility.js","names":[],"sources":["../../src/operators/utility.ts"],"sourcesContent":["import type { Flux, Operator, Scheduler, Unsubscribe } from '../types';\n\nimport { error, warn } from '../_dev';\nimport { clampPositiveInt } from '../_numeric';\nimport { guard } from '../_safe';\nimport { DEFAULT_SCHEDULER } from '../_scheduler';\nimport { flux } from '../core';\nimport { FluxTimeoutError } from '../errors';\n\ntype SharedEntry<T> = { complete?: () => void; error?: (e: unknown) => void; next: (v: T) => void };\n\nfunction makeMulticast<T>(source: Flux<T>, maxBuffer: number): Flux<T> {\n  const subscribers = new Set<SharedEntry<T>>();\n  const buffer: T[] = [];\n  let sourceUnsub: Unsubscribe | undefined;\n  let sourceDone = false;\n  let sourceError: unknown;\n  let hasError = false;\n\n  return flux<T>((observer) => {\n    if (hasError) {\n      observer.error?.(sourceError);\n\n      return;\n    }\n\n    for (const v of buffer) observer.next(v);\n\n    if (sourceDone) {\n      observer.complete?.();\n\n      return;\n    }\n\n    const entry: SharedEntry<T> = {\n      complete: observer.complete,\n      error: observer.error,\n      next: observer.next,\n    };\n\n    subscribers.add(entry);\n\n    if (subscribers.size === 1) {\n      sourceUnsub = source.subscribe({\n        complete() {\n          sourceDone = true;\n          for (const s of [...subscribers]) s.complete?.();\n          subscribers.clear();\n        },\n        error(err) {\n          hasError = true;\n          sourceError = err;\n          for (const s of [...subscribers]) s.error?.(err);\n          subscribers.clear();\n        },\n        next(v) {\n          if (maxBuffer > 0) {\n            if (buffer.length >= maxBuffer) buffer.shift();\n\n            buffer.push(v);\n          }\n\n          for (const s of [...subscribers]) s.next(v);\n        },\n      });\n    }\n\n    return () => {\n      subscribers.delete(entry);\n\n      if (subscribers.size === 0) {\n        sourceUnsub?.();\n        sourceUnsub = undefined;\n      }\n    };\n  });\n}\n\n/**\n * Multicast a cold `Flux` to multiple subscribers. The first subscriber starts\n * the source; the last to unsubscribe stops it.\n *\n * @example\n * const hot$ = cold$.pipe(share()); // one source, many subscribers\n */\nexport function share<T>(): Operator<T, T> {\n  return (source) => makeMulticast(source, 0);\n}\n\n/**\n * Multicast a cold `Flux` and replay the last `bufferSize` values (default: 1)\n * to any new subscriber.\n *\n * @example\n * const hot$ = cold$.pipe(shareReplay(1)); // last value replayed to late subs\n */\nexport function shareReplay<T>(bufferSize = 1): Operator<T, T> {\n  const { clamped, value: safeSize } = clampPositiveInt(bufferSize);\n\n  if (clamped) {\n    warn(`shareReplay: bufferSize must be a finite integer >= 1, got ${bufferSize} — clamped to ${safeSize}`);\n  }\n\n  return (source) => makeMulticast(source, safeSize);\n}\n\n/** Run a side effect on each emission without modifying the value. */\nexport function tap<T>(fn: (value: T) => void): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) =>\n      source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            fn(v);\n            observer.next(v);\n          }, observer.error);\n        },\n      }),\n    );\n}\n\n/** Delay each emission by `ms` milliseconds. Pass a custom `scheduler` to control time in tests. */\nexport function delay<T>(ms: number, scheduler: Scheduler = DEFAULT_SCHEDULER): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      const cancels: Array<() => void> = [];\n\n      const unsub = source.subscribe({\n        complete() {\n          cancels.push(scheduler.delay(() => observer.complete?.(), ms));\n        },\n        error: observer.error,\n        next(v) {\n          cancels.push(scheduler.delay(() => observer.next(v), ms));\n        },\n      });\n\n      return () => {\n        unsub();\n        for (const cancel of cancels) cancel();\n      };\n    });\n}\n\n/**\n * Error if no value is emitted within `ms` milliseconds since the last emission\n * (or since subscription, for the first value). The timer resets on each emission —\n * this is an inactivity timeout, not a time-to-first-value or total-duration timeout.\n * Pass a custom `scheduler` to control time in tests.\n *\n * @example\n * source$.pipe(timeout(5000)); // throws FluxTimeoutError after 5s of silence\n */\nexport function timeout<T>(ms: number, scheduler: Scheduler = DEFAULT_SCHEDULER): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let cancelTimer!: () => void;\n\n      const startTimer = (): void => {\n        cancelTimer = scheduler.delay(() => {\n          observer.error?.(new FluxTimeoutError(ms));\n        }, ms);\n      };\n\n      startTimer();\n\n      const unsub = source.subscribe({\n        complete() {\n          cancelTimer();\n          observer.complete?.();\n        },\n        error(err) {\n          cancelTimer();\n          observer.error?.(err);\n        },\n        next(v) {\n          cancelTimer();\n          startTimer();\n          observer.next(v);\n        },\n      });\n\n      return () => {\n        cancelTimer();\n        unsub();\n      };\n    });\n}\n\n/**\n * Recover from an error by returning a new `Flux` to continue with.\n *\n * @example\n * source$.pipe(catchError((err) => of('fallback')));\n */\nexport function catchError<T>(handler: (err: unknown) => Flux<T>): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let fallbackUnsub: Unsubscribe | undefined;\n\n      const sourceUnsub = source.subscribe({\n        complete: observer.complete,\n        error(err) {\n          guard(() => {\n            fallbackUnsub = handler(err).subscribe({\n              complete: observer.complete,\n              error: observer.error,\n              next: observer.next,\n            });\n          }, observer.error);\n        },\n        next: observer.next,\n      });\n\n      return () => {\n        sourceUnsub();\n        fallbackUnsub?.();\n      };\n    });\n}\n\n/**\n * Re-subscribe to the source up to `count` times on error.\n * Pass `delayMs` as a fixed number or `(attempt) => number` function for backoff.\n * Pass a custom `scheduler` to control time in tests.\n *\n * @example\n * fetchStream$.pipe(retry(3));\n * fetchStream$.pipe(retry(3, (n) => Math.min(1000 * 2 ** n, 30_000))); // exponential backoff\n */\nexport function retry<T>(\n  count: number,\n  delayMs?: number | ((attempt: number) => number),\n  scheduler: Scheduler = DEFAULT_SCHEDULER,\n): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let attempts = 0;\n      let currentUnsub: Unsubscribe | undefined;\n      let cancelDelay: (() => void) | undefined;\n\n      function attempt(): void {\n        currentUnsub = source.subscribe({\n          complete: observer.complete,\n          error(err) {\n            if (attempts < count) {\n              const n = attempts++;\n\n              if (delayMs !== undefined) {\n                guard(() => {\n                  const ms = typeof delayMs === 'function' ? delayMs(n) : delayMs;\n\n                  cancelDelay = scheduler.delay(attempt, Math.max(0, ms));\n                }, observer.error);\n              } else {\n                attempt();\n              }\n            } else {\n              observer.error?.(err);\n            }\n          },\n          next: observer.next,\n        });\n      }\n\n      attempt();\n\n      return () => {\n        cancelDelay?.();\n        currentUnsub?.();\n      };\n    });\n}\n\n/**\n * Run `fn` when the stream ends — whether by completion, error, or unsubscription.\n *\n * @example\n * source$.pipe(finalize(() => console.log('stream ended')));\n */\nexport function finalize<T>(fn: () => void): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let called = false;\n\n      const call = (): void => {\n        if (called) return;\n\n        called = true;\n\n        try {\n          fn();\n        } catch (err) {\n          error('finalize: cleanup callback threw', err);\n        }\n      };\n\n      const unsub = source.subscribe({\n        complete() {\n          call();\n          observer.complete?.();\n        },\n        error(err) {\n          call();\n          observer.error?.(err);\n        },\n        next: observer.next,\n      });\n\n      return () => {\n        call();\n        unsub();\n      };\n    });\n}\n\n/** Reject value used when `signal` aborts a pending `toPromise()`/`toArray()`. */\nfunction abortError(signal: AbortSignal): unknown {\n  return signal.reason ?? new DOMException('Aborted', 'AbortError');\n}\n\n/**\n * Convert a `Flux` to a `Promise` that resolves with the last emitted value\n * when the source completes, or rejects on error.\n * Pass `signal` to unsubscribe and reject early if the caller loses interest\n * before the source completes (e.g. a component unmounting).\n *\n * @example\n * const result = await toPromise(source$);\n * const cancellable = await toPromise(source$, controller.signal);\n */\nexport function toPromise<T>(source: Flux<T>, signal?: AbortSignal): Promise<T | undefined> {\n  return new Promise<T | undefined>((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(abortError(signal));\n\n      return;\n    }\n\n    let last: T | undefined;\n    let unsub: Unsubscribe = () => {};\n\n    const onAbort = (): void => {\n      unsub();\n      reject(abortError(signal!));\n    };\n\n    // Add the listener before subscribing — the source may complete/error synchronously\n    // during subscribe(), and the complete/error handlers below need it already registered\n    // to remove it (otherwise it leaks on `signal` until the signal itself is GC'd).\n    signal?.addEventListener('abort', onAbort, { once: true });\n\n    unsub = source.subscribe({\n      complete() {\n        signal?.removeEventListener('abort', onAbort);\n        resolve(last);\n      },\n      error(err) {\n        signal?.removeEventListener('abort', onAbort);\n        reject(err);\n      },\n      next(v) {\n        last = v;\n      },\n    });\n  });\n}\n\n/**\n * Collect all emitted values into an array resolved when the source completes.\n * Pass `signal` to stop early and resolve with the values collected so far\n * (rather than reject) if the caller loses interest before completion.\n *\n * @example\n * const all = await toArray(of(1, 2, 3));\n * const partial = await toArray(source$, controller.signal);\n */\nexport function toArray<T>(source: Flux<T>, signal?: AbortSignal): Promise<T[]> {\n  return new Promise<T[]>((resolve, reject) => {\n    const results: T[] = [];\n\n    if (signal?.aborted) {\n      resolve(results);\n\n      return;\n    }\n\n    let unsub: Unsubscribe = () => {};\n\n    const onAbort = (): void => {\n      unsub();\n      resolve(results);\n    };\n\n    // See toPromise() above for why the listener is added before subscribing.\n    signal?.addEventListener('abort', onAbort, { once: true });\n\n    unsub = source.subscribe({\n      complete() {\n        signal?.removeEventListener('abort', onAbort);\n        resolve(results);\n      },\n      error(err) {\n        signal?.removeEventListener('abort', onAbort);\n        reject(err);\n      },\n      next(v) {\n        results.push(v);\n      },\n    });\n  });\n}\n\n/**\n * Compose multiple operators into a single reusable operator.\n * Provides full type safety at any pipeline depth — use instead of\n * `pipe()` overloads when chaining more than 4 operators.\n *\n * @example\n * const pipeline = flow(\n *   filter((n) => n % 2 === 0),\n *   map((n) => n * 10),\n *   take(5),\n * );\n * source$.pipe(pipeline).subscribe(console.log);\n */\nexport function flow<A, B>(op1: Operator<A, B>): Operator<A, B>;\nexport function flow<A, B, C>(op1: Operator<A, B>, op2: Operator<B, C>): Operator<A, C>;\nexport function flow<A, B, C, D>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>): Operator<A, D>;\nexport function flow<A, B, C, D, E>(\n  op1: Operator<A, B>,\n  op2: Operator<B, C>,\n  op3: Operator<C, D>,\n  op4: Operator<D, E>,\n): Operator<A, E>;\nexport function flow<A, B, C, D, E, F>(\n  op1: Operator<A, B>,\n  op2: Operator<B, C>,\n  op3: Operator<C, D>,\n  op4: Operator<D, E>,\n  op5: Operator<E, F>,\n): Operator<A, F>;\nexport function flow<A, B, C, D, E, F, G>(\n  op1: Operator<A, B>,\n  op2: Operator<B, C>,\n  op3: Operator<C, D>,\n  op4: Operator<D, E>,\n  op5: Operator<E, F>,\n  op6: Operator<F, G>,\n): Operator<A, G>;\nexport function flow<A, B, C, D, E, F, G, H>(\n  op1: Operator<A, B>,\n  op2: Operator<B, C>,\n  op3: Operator<C, D>,\n  op4: Operator<D, E>,\n  op5: Operator<E, F>,\n  op6: Operator<F, G>,\n  op7: Operator<G, H>,\n): Operator<A, H>;\nexport function flow<A, B, C, D, E, F, G, H, I>(\n  op1: Operator<A, B>,\n  op2: Operator<B, C>,\n  op3: Operator<C, D>,\n  op4: Operator<D, E>,\n  op5: Operator<E, F>,\n  op6: Operator<F, G>,\n  op7: Operator<G, H>,\n  op8: Operator<H, I>,\n): Operator<A, I>;\nexport function flow(...ops: Operator[]): Operator {\n  return (source: Flux<unknown>) => ops.reduce((f: Flux<unknown>, op) => op(f), source);\n}\n"],"mappings":"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"}

package/dist/subject.cjs

@@ -0,0 +1,2 @@
+const e=require("./_dev.cjs"),t=require("./_iterator.cjs"),n=require("./_pipe.cjs"),r=require("./_numeric.cjs");var i=()=>{};function a(){let t=new AbortController,n=new Set;function r(t){for(let r of[...n])try{t(r)}catch(t){e.error(`Subscriber threw during broadcast`,t)}}function a(e,r){let a=typeof e==`function`?{next:e}:e;if(t.signal.aborted||r?.aborted){try{a.complete?.()}catch{}return i}n.add(a);let o=()=>{n.delete(a),r&&r.removeEventListener(`abort`,o)};return r&&r.addEventListener(`abort`,o,{once:!0}),o}return{ac:t,broadcast:r,doSubscribe:a,subscribers:n}}function o(e,t,n,r){let a=typeof n==`function`?{next:n}:n;if(e.ac.signal.aborted||r?.aborted){try{a.complete?.()}catch{}return i}if(t(),e.ac.signal.aborted){try{a.complete?.()}catch{}return i}return e.doSubscribe(a,r)}function s(e){return()=>{e.ac.signal.aborted||(e.ac.abort(),e.broadcast(e=>e.complete?.()),e.subscribers.clear())}}function c(e){return t=>{e.ac.signal.aborted||(e.ac.abort(),e.broadcast(e=>e.error?.(t)),e.subscribers.clear())}}function l(){let e=a(),r=s(e),i={complete:r,get disposalSignal(){return e.ac.signal},dispose:r,get disposed(){return e.ac.signal.aborted},emit(t){e.ac.signal.aborted||e.broadcast(e=>e.next(t))},fail:c(e),pipe:n.makePipe(()=>i),subscribe(t,n){return e.doSubscribe(t,n)},[Symbol.asyncIterator](){return t.makeAsyncIterator(t=>e.doSubscribe(t))},[Symbol.dispose](){r()}};return i}function u(r){let i=a(),l=s(i),u=c(i),d=r,f={complete:l,get disposalSignal(){return i.ac.signal},dispose:l,get disposed(){return i.ac.signal.aborted},emit(e){i.ac.signal.aborted||(d=e,i.broadcast(t=>t.next(e)))},fail:u,pipe:n.makePipe(()=>f),subscribe(t,n){return o(i,()=>{let n=typeof t==`function`?{next:t}:t;try{n.next(d)}catch(t){e.error(`BehaviorSubject: subscriber threw during initial replay`,t)}},t,n)},[Symbol.asyncIterator](){return t.makeAsyncIterator(t=>o(i,()=>{try{t.next(d)}catch(t){e.error(`BehaviorSubject: subscriber threw during initial replay`,t)}},t))},[Symbol.dispose](){l()},get value(){return d}};return f}function d(i){let l=a(),u=s(l),d=c(l),{clamped:f,value:p}=r.clampPositiveInt(i),m=[];f&&e.warn(`createReplaySubject: bufferSize must be a finite integer >= 1, got ${i} — clamped to ${p}`);let h={get buffer(){return m},complete:u,get disposalSignal(){return l.ac.signal},dispose:u,get disposed(){return l.ac.signal.aborted},emit(e){l.ac.signal.aborted||(m.length>=p&&m.shift(),m.push(e),l.broadcast(t=>t.next(e)))},fail:d,pipe:n.makePipe(()=>h),subscribe(t,n){return o(l,()=>{let n=typeof t==`function`?{next:t}:t;for(let t of m)try{n.next(t)}catch(t){e.error(`ReplaySubject: subscriber threw during replay`,t)}},t,n)},[Symbol.asyncIterator](){return t.makeAsyncIterator(t=>o(l,()=>{for(let n of m)try{t.next(n)}catch(t){e.error(`ReplaySubject: subscriber threw during replay`,t)}},t))},[Symbol.dispose](){u()}};return h}exports.createBehaviorSubject=u,exports.createReplaySubject=d,exports.createSubject=l;
+//# sourceMappingURL=subject.cjs.map

package/dist/subject.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject.cjs","names":[],"sources":["../src/subject.ts"],"sourcesContent":["import type { Flux, Observer, Unsubscribe } from './types';\n\nimport { error, warn } from './_dev';\nimport { makeAsyncIterator } from './_iterator';\nimport { clampPositiveInt } from './_numeric';\nimport { makePipe } from './_pipe';\n\nconst NOOP: Unsubscribe = () => {};\n\n/**\n * A `Subject` is both a `Flux` and a manual emission handle.\n * Calling `emit()` pushes a value to all active subscribers.\n *\n * A Subject is hot — all subscribers share the same emission sequence.\n * Subscribers that subscribe after an emission will NOT receive past values.\n * Use `BehaviorSubject` to replay the latest value to late subscribers.\n */\nexport interface Subject<T> extends Flux<T> {\n  /** `true` after `dispose()` or `complete()` is called. */\n  readonly disposed: boolean;\n  /** Emit a complete signal to all subscribers and dispose the subject. */\n  complete(): void;\n  /** Push a value to all active subscribers. */\n  emit(value: T): void;\n  /** Push an error to all active subscribers and dispose the subject. */\n  fail(err: unknown): void;\n}\n\n/**\n * A `BehaviorSubject` is a `Subject` that replays the latest value to\n * any new subscriber immediately on subscription.\n */\nexport interface BehaviorSubject<T> extends Subject<T> {\n  /** The current (latest emitted) value. */\n  readonly value: T;\n}\n\n/**\n * A `ReplaySubject` is a `Subject` that replays the last N emitted values\n * to any new subscriber immediately on subscription.\n */\nexport interface ReplaySubject<T> extends Subject<T> {\n  /** Snapshot of the current replay buffer (up to `bufferSize` entries). */\n  readonly buffer: readonly T[];\n}\n\n// ── Shared internals ──────────────────────────────────────────────────────────\n\ninterface SubjectCore<T> {\n  ac: AbortController;\n  broadcast(fn: (obs: Observer<T>) => void): void;\n  doSubscribe(observerOrNext: Observer<T> | ((value: T) => void), signal?: AbortSignal): Unsubscribe;\n  subscribers: Set<Observer<T>>;\n}\n\nfunction makeCore<T>(): SubjectCore<T> {\n  const ac = new AbortController();\n  const subscribers = new Set<Observer<T>>();\n\n  function broadcast(fn: (obs: Observer<T>) => void): void {\n    for (const obs of [...subscribers]) {\n      try {\n        fn(obs);\n      } catch (err) {\n        error('Subscriber threw during broadcast', err);\n      }\n    }\n  }\n\n  function doSubscribe(observerOrNext: Observer<T> | ((value: T) => void), signal?: AbortSignal): Unsubscribe {\n    const observer: Observer<T> = typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n\n    if (ac.signal.aborted || signal?.aborted) {\n      try {\n        observer.complete?.();\n      } catch {\n        /* empty */\n      }\n\n      return NOOP;\n    }\n\n    subscribers.add(observer);\n\n    const unsub = (): void => {\n      subscribers.delete(observer);\n\n      if (signal) signal.removeEventListener('abort', unsub);\n    };\n\n    if (signal) signal.addEventListener('abort', unsub, { once: true });\n\n    return unsub;\n  }\n\n  return { ac, broadcast, doSubscribe, subscribers };\n}\n\n// Safely emit initial replay values; re-check disposed after sync replay.\nfunction replaySubscribe<T>(\n  core: SubjectCore<T>,\n  replay: () => void,\n  observerOrNext: Observer<T> | ((value: T) => void),\n  signal?: AbortSignal,\n): Unsubscribe {\n  const observer: Observer<T> = typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n\n  if (core.ac.signal.aborted || signal?.aborted) {\n    try {\n      observer.complete?.();\n    } catch {\n      /* empty */\n    }\n\n    return NOOP;\n  }\n\n  replay();\n\n  // Re-check: the synchronous replay may have triggered a dispose.\n  if (core.ac.signal.aborted) {\n    try {\n      observer.complete?.();\n    } catch {\n      /* empty */\n    }\n\n    return NOOP;\n  }\n\n  return core.doSubscribe(observer, signal);\n}\n\n/**\n * Shared `dispose()` implementation for every `Subject` variant: aborts the core,\n * notifies all active subscribers with `complete()`, and clears the subscriber set.\n * Reused instead of being copy-pasted per factory.\n * @internal\n */\nfunction makeDispose<T>(core: SubjectCore<T>): () => void {\n  return () => {\n    if (core.ac.signal.aborted) return;\n\n    core.ac.abort();\n    core.broadcast((obs) => obs.complete?.());\n    core.subscribers.clear();\n  };\n}\n\n/**\n * Shared `fail()` implementation for every `Subject` variant: aborts the core,\n * notifies all active subscribers with `error()`, and clears the subscriber set.\n * Reused instead of being copy-pasted per factory.\n * @internal\n */\nfunction makeFail<T>(core: SubjectCore<T>): (err: unknown) => void {\n  return (err) => {\n    if (core.ac.signal.aborted) return;\n\n    core.ac.abort();\n    core.broadcast((obs) => obs.error?.(err));\n    core.subscribers.clear();\n  };\n}\n\n// ── createSubject ─────────────────────────────────────────────────────────────\n\n/**\n * Creates a new `Subject<T>`.\n *\n * @example\n * const events = createSubject<string>();\n * events.subscribe((s) => console.log(s));\n * events.emit('hello');\n * events.dispose();\n */\nexport function createSubject<T>(): Subject<T> {\n  const core = makeCore<T>();\n  const dispose = makeDispose(core);\n  const fail = makeFail(core);\n\n  const subject: Subject<T> = {\n    complete: dispose,\n\n    get disposalSignal(): AbortSignal {\n      return core.ac.signal;\n    },\n\n    dispose,\n\n    get disposed(): boolean {\n      return core.ac.signal.aborted;\n    },\n\n    emit(value: T): void {\n      if (core.ac.signal.aborted) return;\n\n      core.broadcast((obs) => obs.next(value));\n    },\n\n    fail,\n\n    pipe: makePipe(() => subject),\n\n    subscribe(observerOrNext, signal) {\n      return core.doSubscribe(observerOrNext, signal);\n    },\n\n    [Symbol.asyncIterator](): AsyncIterableIterator<T> {\n      return makeAsyncIterator<T>((obs) => core.doSubscribe(obs));\n    },\n\n    [Symbol.dispose](): void {\n      dispose();\n    },\n  };\n\n  return subject;\n}\n\n// ── createBehaviorSubject ─────────────────────────────────────────────────────\n\n/**\n * Creates a new `BehaviorSubject<T>` with an initial value.\n * Late subscribers immediately receive the current value on subscribe.\n *\n * @example\n * const count = createBehaviorSubject(0);\n * count.subscribe((n) => console.log(n)); // logs 0 immediately\n * count.emit(1);                          // logs 1\n */\nexport function createBehaviorSubject<T>(initial: T): BehaviorSubject<T> {\n  const core = makeCore<T>();\n  const dispose = makeDispose(core);\n  const fail = makeFail(core);\n  let current = initial;\n\n  const subject: BehaviorSubject<T> = {\n    complete: dispose,\n\n    get disposalSignal(): AbortSignal {\n      return core.ac.signal;\n    },\n\n    dispose,\n\n    get disposed(): boolean {\n      return core.ac.signal.aborted;\n    },\n\n    emit(value: T): void {\n      if (core.ac.signal.aborted) return;\n\n      current = value;\n      core.broadcast((obs) => obs.next(value));\n    },\n\n    fail,\n\n    pipe: makePipe(() => subject),\n\n    subscribe(observerOrNext, signal) {\n      return replaySubscribe(\n        core,\n        () => {\n          const observer: Observer<T> =\n            typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n\n          try {\n            observer.next(current);\n          } catch (err) {\n            error('BehaviorSubject: subscriber threw during initial replay', err);\n          }\n        },\n        observerOrNext,\n        signal,\n      );\n    },\n\n    [Symbol.asyncIterator](): AsyncIterableIterator<T> {\n      return makeAsyncIterator<T>((obs) =>\n        replaySubscribe(\n          core,\n          () => {\n            try {\n              obs.next(current);\n            } catch (err) {\n              error('BehaviorSubject: subscriber threw during initial replay', err);\n            }\n          },\n          obs,\n        ),\n      );\n    },\n\n    [Symbol.dispose](): void {\n      dispose();\n    },\n\n    get value(): T {\n      return current;\n    },\n  };\n\n  return subject;\n}\n\n// ── createReplaySubject ───────────────────────────────────────────────────────\n\n/**\n * Creates a `ReplaySubject<T>` that buffers up to `bufferSize` values and\n * replays them in order to any new subscriber immediately on subscription.\n *\n * @example\n * const history = createReplaySubject<string>(3);\n * history.emit('a');\n * history.emit('b');\n * history.subscribe(console.log); // logs 'a', 'b' immediately\n */\nexport function createReplaySubject<T>(bufferSize: number): ReplaySubject<T> {\n  const core = makeCore<T>();\n  const dispose = makeDispose(core);\n  const fail = makeFail(core);\n  const { clamped, value: max } = clampPositiveInt(bufferSize);\n  const buf: T[] = [];\n\n  if (clamped) {\n    warn(`createReplaySubject: bufferSize must be a finite integer >= 1, got ${bufferSize} — clamped to ${max}`);\n  }\n\n  const subject: ReplaySubject<T> = {\n    get buffer(): readonly T[] {\n      return buf;\n    },\n\n    complete: dispose,\n\n    get disposalSignal(): AbortSignal {\n      return core.ac.signal;\n    },\n\n    dispose,\n\n    get disposed(): boolean {\n      return core.ac.signal.aborted;\n    },\n\n    emit(value: T): void {\n      if (core.ac.signal.aborted) return;\n\n      if (buf.length >= max) buf.shift();\n\n      buf.push(value);\n      core.broadcast((obs) => obs.next(value));\n    },\n\n    fail,\n\n    pipe: makePipe(() => subject),\n\n    subscribe(observerOrNext, signal) {\n      return replaySubscribe(\n        core,\n        () => {\n          const observer: Observer<T> =\n            typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n\n          for (const v of buf) {\n            try {\n              observer.next(v);\n            } catch (err) {\n              error('ReplaySubject: subscriber threw during replay', err);\n            }\n          }\n        },\n        observerOrNext,\n        signal,\n      );\n    },\n\n    [Symbol.asyncIterator](): AsyncIterableIterator<T> {\n      return makeAsyncIterator<T>((obs) =>\n        replaySubscribe(\n          core,\n          () => {\n            for (const v of buf) {\n              try {\n                obs.next(v);\n              } catch (err) {\n                error('ReplaySubject: subscriber threw during replay', err);\n              }\n            }\n          },\n          obs,\n        ),\n      );\n    },\n\n    [Symbol.dispose](): void {\n      dispose();\n    },\n  };\n\n  return subject;\n}\n"],"mappings":"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"}

package/dist/subject.d.ts

@@ -0,0 +1,67 @@
+import type { Flux } from './types';
+/**
+ * A `Subject` is both a `Flux` and a manual emission handle.
+ * Calling `emit()` pushes a value to all active subscribers.
+ *
+ * A Subject is hot — all subscribers share the same emission sequence.
+ * Subscribers that subscribe after an emission will NOT receive past values.
+ * Use `BehaviorSubject` to replay the latest value to late subscribers.
+ */
+export interface Subject<T> extends Flux<T> {
+    /** `true` after `dispose()` or `complete()` is called. */
+    readonly disposed: boolean;
+    /** Emit a complete signal to all subscribers and dispose the subject. */
+    complete(): void;
+    /** Push a value to all active subscribers. */
+    emit(value: T): void;
+    /** Push an error to all active subscribers and dispose the subject. */
+    fail(err: unknown): void;
+}
+/**
+ * A `BehaviorSubject` is a `Subject` that replays the latest value to
+ * any new subscriber immediately on subscription.
+ */
+export interface BehaviorSubject<T> extends Subject<T> {
+    /** The current (latest emitted) value. */
+    readonly value: T;
+}
+/**
+ * A `ReplaySubject` is a `Subject` that replays the last N emitted values
+ * to any new subscriber immediately on subscription.
+ */
+export interface ReplaySubject<T> extends Subject<T> {
+    /** Snapshot of the current replay buffer (up to `bufferSize` entries). */
+    readonly buffer: readonly T[];
+}
+/**
+ * Creates a new `Subject<T>`.
+ *
+ * @example
+ * const events = createSubject<string>();
+ * events.subscribe((s) => console.log(s));
+ * events.emit('hello');
+ * events.dispose();
+ */
+export declare function createSubject<T>(): Subject<T>;
+/**
+ * Creates a new `BehaviorSubject<T>` with an initial value.
+ * Late subscribers immediately receive the current value on subscribe.
+ *
+ * @example
+ * const count = createBehaviorSubject(0);
+ * count.subscribe((n) => console.log(n)); // logs 0 immediately
+ * count.emit(1);                          // logs 1
+ */
+export declare function createBehaviorSubject<T>(initial: T): BehaviorSubject<T>;
+/**
+ * Creates a `ReplaySubject<T>` that buffers up to `bufferSize` values and
+ * replays them in order to any new subscriber immediately on subscription.
+ *
+ * @example
+ * const history = createReplaySubject<string>(3);
+ * history.emit('a');
+ * history.emit('b');
+ * history.subscribe(console.log); // logs 'a', 'b' immediately
+ */
+export declare function createReplaySubject<T>(bufferSize: number): ReplaySubject<T>;
+//# sourceMappingURL=subject.d.ts.map

package/dist/subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject.d.ts","sourceRoot":"","sources":["../src/subject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAyB,MAAM,SAAS,CAAC;AAS3D;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IACzC,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,IAAI,IAAI,CAAC;IACjB,8CAA8C;IAC9C,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACrB,uEAAuE;IACvE,IAAI,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IACpD,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IAClD,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC;CAC/B;AA2HD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CA0C7C;AAID;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CA0EvE;AAID;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAqF3E"}

package/dist/subject.js

@@ -0,0 +1,181 @@
+import { error as e, warn as t } from "./_dev.js";
+import { makeAsyncIterator as n } from "./_iterator.js";
+import { makePipe as r } from "./_pipe.js";
+import { clampPositiveInt as i } from "./_numeric.js";
+//#region src/subject.ts
+var a = () => {};
+function o() {
+	let t = new AbortController(), n = /* @__PURE__ */ new Set();
+	function r(t) {
+		for (let r of [...n]) try {
+			t(r);
+		} catch (t) {
+			e("Subscriber threw during broadcast", t);
+		}
+	}
+	function i(e, r) {
+		let i = typeof e == "function" ? { next: e } : e;
+		if (t.signal.aborted || r?.aborted) {
+			try {
+				i.complete?.();
+			} catch {}
+			return a;
+		}
+		n.add(i);
+		let o = () => {
+			n.delete(i), r && r.removeEventListener("abort", o);
+		};
+		return r && r.addEventListener("abort", o, { once: !0 }), o;
+	}
+	return {
+		ac: t,
+		broadcast: r,
+		doSubscribe: i,
+		subscribers: n
+	};
+}
+function s(e, t, n, r) {
+	let i = typeof n == "function" ? { next: n } : n;
+	if (e.ac.signal.aborted || r?.aborted) {
+		try {
+			i.complete?.();
+		} catch {}
+		return a;
+	}
+	if (t(), e.ac.signal.aborted) {
+		try {
+			i.complete?.();
+		} catch {}
+		return a;
+	}
+	return e.doSubscribe(i, r);
+}
+function c(e) {
+	return () => {
+		e.ac.signal.aborted || (e.ac.abort(), e.broadcast((e) => e.complete?.()), e.subscribers.clear());
+	};
+}
+function l(e) {
+	return (t) => {
+		e.ac.signal.aborted || (e.ac.abort(), e.broadcast((e) => e.error?.(t)), e.subscribers.clear());
+	};
+}
+function u() {
+	let e = o(), t = c(e), i = {
+		complete: t,
+		get disposalSignal() {
+			return e.ac.signal;
+		},
+		dispose: t,
+		get disposed() {
+			return e.ac.signal.aborted;
+		},
+		emit(t) {
+			e.ac.signal.aborted || e.broadcast((e) => e.next(t));
+		},
+		fail: l(e),
+		pipe: r(() => i),
+		subscribe(t, n) {
+			return e.doSubscribe(t, n);
+		},
+		[Symbol.asyncIterator]() {
+			return n((t) => e.doSubscribe(t));
+		},
+		[Symbol.dispose]() {
+			t();
+		}
+	};
+	return i;
+}
+function d(t) {
+	let i = o(), a = c(i), u = l(i), d = t, f = {
+		complete: a,
+		get disposalSignal() {
+			return i.ac.signal;
+		},
+		dispose: a,
+		get disposed() {
+			return i.ac.signal.aborted;
+		},
+		emit(e) {
+			i.ac.signal.aborted || (d = e, i.broadcast((t) => t.next(e)));
+		},
+		fail: u,
+		pipe: r(() => f),
+		subscribe(t, n) {
+			return s(i, () => {
+				let n = typeof t == "function" ? { next: t } : t;
+				try {
+					n.next(d);
+				} catch (t) {
+					e("BehaviorSubject: subscriber threw during initial replay", t);
+				}
+			}, t, n);
+		},
+		[Symbol.asyncIterator]() {
+			return n((t) => s(i, () => {
+				try {
+					t.next(d);
+				} catch (t) {
+					e("BehaviorSubject: subscriber threw during initial replay", t);
+				}
+			}, t));
+		},
+		[Symbol.dispose]() {
+			a();
+		},
+		get value() {
+			return d;
+		}
+	};
+	return f;
+}
+function f(a) {
+	let u = o(), d = c(u), f = l(u), { clamped: p, value: m } = i(a), h = [];
+	p && t(`createReplaySubject: bufferSize must be a finite integer >= 1, got ${a} — clamped to ${m}`);
+	let g = {
+		get buffer() {
+			return h;
+		},
+		complete: d,
+		get disposalSignal() {
+			return u.ac.signal;
+		},
+		dispose: d,
+		get disposed() {
+			return u.ac.signal.aborted;
+		},
+		emit(e) {
+			u.ac.signal.aborted || (h.length >= m && h.shift(), h.push(e), u.broadcast((t) => t.next(e)));
+		},
+		fail: f,
+		pipe: r(() => g),
+		subscribe(t, n) {
+			return s(u, () => {
+				let n = typeof t == "function" ? { next: t } : t;
+				for (let t of h) try {
+					n.next(t);
+				} catch (t) {
+					e("ReplaySubject: subscriber threw during replay", t);
+				}
+			}, t, n);
+		},
+		[Symbol.asyncIterator]() {
+			return n((t) => s(u, () => {
+				for (let n of h) try {
+					t.next(n);
+				} catch (t) {
+					e("ReplaySubject: subscriber threw during replay", t);
+				}
+			}, t));
+		},
+		[Symbol.dispose]() {
+			d();
+		}
+	};
+	return g;
+}
+//#endregion
+export { d as createBehaviorSubject, f as createReplaySubject, u as createSubject };
+
+//# sourceMappingURL=subject.js.map

package/dist/subject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject.js","names":[],"sources":["../src/subject.ts"],"sourcesContent":["import type { Flux, Observer, Unsubscribe } from './types';\n\nimport { error, warn } from './_dev';\nimport { makeAsyncIterator } from './_iterator';\nimport { clampPositiveInt } from './_numeric';\nimport { makePipe } from './_pipe';\n\nconst NOOP: Unsubscribe = () => {};\n\n/**\n * A `Subject` is both a `Flux` and a manual emission handle.\n * Calling `emit()` pushes a value to all active subscribers.\n *\n * A Subject is hot — all subscribers share the same emission sequence.\n * Subscribers that subscribe after an emission will NOT receive past values.\n * Use `BehaviorSubject` to replay the latest value to late subscribers.\n */\nexport interface Subject<T> extends Flux<T> {\n  /** `true` after `dispose()` or `complete()` is called. */\n  readonly disposed: boolean;\n  /** Emit a complete signal to all subscribers and dispose the subject. */\n  complete(): void;\n  /** Push a value to all active subscribers. */\n  emit(value: T): void;\n  /** Push an error to all active subscribers and dispose the subject. */\n  fail(err: unknown): void;\n}\n\n/**\n * A `BehaviorSubject` is a `Subject` that replays the latest value to\n * any new subscriber immediately on subscription.\n */\nexport interface BehaviorSubject<T> extends Subject<T> {\n  /** The current (latest emitted) value. */\n  readonly value: T;\n}\n\n/**\n * A `ReplaySubject` is a `Subject` that replays the last N emitted values\n * to any new subscriber immediately on subscription.\n */\nexport interface ReplaySubject<T> extends Subject<T> {\n  /** Snapshot of the current replay buffer (up to `bufferSize` entries). */\n  readonly buffer: readonly T[];\n}\n\n// ── Shared internals ──────────────────────────────────────────────────────────\n\ninterface SubjectCore<T> {\n  ac: AbortController;\n  broadcast(fn: (obs: Observer<T>) => void): void;\n  doSubscribe(observerOrNext: Observer<T> | ((value: T) => void), signal?: AbortSignal): Unsubscribe;\n  subscribers: Set<Observer<T>>;\n}\n\nfunction makeCore<T>(): SubjectCore<T> {\n  const ac = new AbortController();\n  const subscribers = new Set<Observer<T>>();\n\n  function broadcast(fn: (obs: Observer<T>) => void): void {\n    for (const obs of [...subscribers]) {\n      try {\n        fn(obs);\n      } catch (err) {\n        error('Subscriber threw during broadcast', err);\n      }\n    }\n  }\n\n  function doSubscribe(observerOrNext: Observer<T> | ((value: T) => void), signal?: AbortSignal): Unsubscribe {\n    const observer: Observer<T> = typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n\n    if (ac.signal.aborted || signal?.aborted) {\n      try {\n        observer.complete?.();\n      } catch {\n        /* empty */\n      }\n\n      return NOOP;\n    }\n\n    subscribers.add(observer);\n\n    const unsub = (): void => {\n      subscribers.delete(observer);\n\n      if (signal) signal.removeEventListener('abort', unsub);\n    };\n\n    if (signal) signal.addEventListener('abort', unsub, { once: true });\n\n    return unsub;\n  }\n\n  return { ac, broadcast, doSubscribe, subscribers };\n}\n\n// Safely emit initial replay values; re-check disposed after sync replay.\nfunction replaySubscribe<T>(\n  core: SubjectCore<T>,\n  replay: () => void,\n  observerOrNext: Observer<T> | ((value: T) => void),\n  signal?: AbortSignal,\n): Unsubscribe {\n  const observer: Observer<T> = typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n\n  if (core.ac.signal.aborted || signal?.aborted) {\n    try {\n      observer.complete?.();\n    } catch {\n      /* empty */\n    }\n\n    return NOOP;\n  }\n\n  replay();\n\n  // Re-check: the synchronous replay may have triggered a dispose.\n  if (core.ac.signal.aborted) {\n    try {\n      observer.complete?.();\n    } catch {\n      /* empty */\n    }\n\n    return NOOP;\n  }\n\n  return core.doSubscribe(observer, signal);\n}\n\n/**\n * Shared `dispose()` implementation for every `Subject` variant: aborts the core,\n * notifies all active subscribers with `complete()`, and clears the subscriber set.\n * Reused instead of being copy-pasted per factory.\n * @internal\n */\nfunction makeDispose<T>(core: SubjectCore<T>): () => void {\n  return () => {\n    if (core.ac.signal.aborted) return;\n\n    core.ac.abort();\n    core.broadcast((obs) => obs.complete?.());\n    core.subscribers.clear();\n  };\n}\n\n/**\n * Shared `fail()` implementation for every `Subject` variant: aborts the core,\n * notifies all active subscribers with `error()`, and clears the subscriber set.\n * Reused instead of being copy-pasted per factory.\n * @internal\n */\nfunction makeFail<T>(core: SubjectCore<T>): (err: unknown) => void {\n  return (err) => {\n    if (core.ac.signal.aborted) return;\n\n    core.ac.abort();\n    core.broadcast((obs) => obs.error?.(err));\n    core.subscribers.clear();\n  };\n}\n\n// ── createSubject ─────────────────────────────────────────────────────────────\n\n/**\n * Creates a new `Subject<T>`.\n *\n * @example\n * const events = createSubject<string>();\n * events.subscribe((s) => console.log(s));\n * events.emit('hello');\n * events.dispose();\n */\nexport function createSubject<T>(): Subject<T> {\n  const core = makeCore<T>();\n  const dispose = makeDispose(core);\n  const fail = makeFail(core);\n\n  const subject: Subject<T> = {\n    complete: dispose,\n\n    get disposalSignal(): AbortSignal {\n      return core.ac.signal;\n    },\n\n    dispose,\n\n    get disposed(): boolean {\n      return core.ac.signal.aborted;\n    },\n\n    emit(value: T): void {\n      if (core.ac.signal.aborted) return;\n\n      core.broadcast((obs) => obs.next(value));\n    },\n\n    fail,\n\n    pipe: makePipe(() => subject),\n\n    subscribe(observerOrNext, signal) {\n      return core.doSubscribe(observerOrNext, signal);\n    },\n\n    [Symbol.asyncIterator](): AsyncIterableIterator<T> {\n      return makeAsyncIterator<T>((obs) => core.doSubscribe(obs));\n    },\n\n    [Symbol.dispose](): void {\n      dispose();\n    },\n  };\n\n  return subject;\n}\n\n// ── createBehaviorSubject ─────────────────────────────────────────────────────\n\n/**\n * Creates a new `BehaviorSubject<T>` with an initial value.\n * Late subscribers immediately receive the current value on subscribe.\n *\n * @example\n * const count = createBehaviorSubject(0);\n * count.subscribe((n) => console.log(n)); // logs 0 immediately\n * count.emit(1);                          // logs 1\n */\nexport function createBehaviorSubject<T>(initial: T): BehaviorSubject<T> {\n  const core = makeCore<T>();\n  const dispose = makeDispose(core);\n  const fail = makeFail(core);\n  let current = initial;\n\n  const subject: BehaviorSubject<T> = {\n    complete: dispose,\n\n    get disposalSignal(): AbortSignal {\n      return core.ac.signal;\n    },\n\n    dispose,\n\n    get disposed(): boolean {\n      return core.ac.signal.aborted;\n    },\n\n    emit(value: T): void {\n      if (core.ac.signal.aborted) return;\n\n      current = value;\n      core.broadcast((obs) => obs.next(value));\n    },\n\n    fail,\n\n    pipe: makePipe(() => subject),\n\n    subscribe(observerOrNext, signal) {\n      return replaySubscribe(\n        core,\n        () => {\n          const observer: Observer<T> =\n            typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n\n          try {\n            observer.next(current);\n          } catch (err) {\n            error('BehaviorSubject: subscriber threw during initial replay', err);\n          }\n        },\n        observerOrNext,\n        signal,\n      );\n    },\n\n    [Symbol.asyncIterator](): AsyncIterableIterator<T> {\n      return makeAsyncIterator<T>((obs) =>\n        replaySubscribe(\n          core,\n          () => {\n            try {\n              obs.next(current);\n            } catch (err) {\n              error('BehaviorSubject: subscriber threw during initial replay', err);\n            }\n          },\n          obs,\n        ),\n      );\n    },\n\n    [Symbol.dispose](): void {\n      dispose();\n    },\n\n    get value(): T {\n      return current;\n    },\n  };\n\n  return subject;\n}\n\n// ── createReplaySubject ───────────────────────────────────────────────────────\n\n/**\n * Creates a `ReplaySubject<T>` that buffers up to `bufferSize` values and\n * replays them in order to any new subscriber immediately on subscription.\n *\n * @example\n * const history = createReplaySubject<string>(3);\n * history.emit('a');\n * history.emit('b');\n * history.subscribe(console.log); // logs 'a', 'b' immediately\n */\nexport function createReplaySubject<T>(bufferSize: number): ReplaySubject<T> {\n  const core = makeCore<T>();\n  const dispose = makeDispose(core);\n  const fail = makeFail(core);\n  const { clamped, value: max } = clampPositiveInt(bufferSize);\n  const buf: T[] = [];\n\n  if (clamped) {\n    warn(`createReplaySubject: bufferSize must be a finite integer >= 1, got ${bufferSize} — clamped to ${max}`);\n  }\n\n  const subject: ReplaySubject<T> = {\n    get buffer(): readonly T[] {\n      return buf;\n    },\n\n    complete: dispose,\n\n    get disposalSignal(): AbortSignal {\n      return core.ac.signal;\n    },\n\n    dispose,\n\n    get disposed(): boolean {\n      return core.ac.signal.aborted;\n    },\n\n    emit(value: T): void {\n      if (core.ac.signal.aborted) return;\n\n      if (buf.length >= max) buf.shift();\n\n      buf.push(value);\n      core.broadcast((obs) => obs.next(value));\n    },\n\n    fail,\n\n    pipe: makePipe(() => subject),\n\n    subscribe(observerOrNext, signal) {\n      return replaySubscribe(\n        core,\n        () => {\n          const observer: Observer<T> =\n            typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n\n          for (const v of buf) {\n            try {\n              observer.next(v);\n            } catch (err) {\n              error('ReplaySubject: subscriber threw during replay', err);\n            }\n          }\n        },\n        observerOrNext,\n        signal,\n      );\n    },\n\n    [Symbol.asyncIterator](): AsyncIterableIterator<T> {\n      return makeAsyncIterator<T>((obs) =>\n        replaySubscribe(\n          core,\n          () => {\n            for (const v of buf) {\n              try {\n                obs.next(v);\n              } catch (err) {\n                error('ReplaySubject: subscriber threw during replay', err);\n              }\n            }\n          },\n          obs,\n        ),\n      );\n    },\n\n    [Symbol.dispose](): void {\n      dispose();\n    },\n  };\n\n  return subject;\n}\n"],"mappings":"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"}