@vielzeug/flux 1.0.3

package/dist/operators/filtering.js

@@ -0,0 +1,140 @@
+import { flux as e } from "../core.js";
+import { DEFAULT_SCHEDULER as t } from "../_scheduler.js";
+import { guard as n } from "../_safe.js";
+//#region src/operators/filtering.ts
+function r(t) {
+	return (n) => e((e) => {
+		if (t <= 0) {
+			e.complete?.();
+			return;
+		}
+		let r = 0, i = () => {};
+		return i = n.subscribe({
+			complete: e.complete,
+			error: e.error,
+			next(n) {
+				e.next(n), r++, r >= t && (e.complete?.(), i());
+			}
+		}), i;
+	});
+}
+function i(t) {
+	return (n) => e((e) => {
+		let r = 0;
+		return n.subscribe({
+			complete: e.complete,
+			error: e.error,
+			next(n) {
+				r < t ? r++ : e.next(n);
+			}
+		});
+	});
+}
+function a(t) {
+	return (n) => e((e) => {
+		let r = !1, i = () => {
+			r || (r = !0, e.complete?.(), a(), o?.());
+		}, a;
+		if (t instanceof AbortSignal) {
+			if (t.aborted) {
+				e.complete?.();
+				return;
+			}
+			t.addEventListener("abort", i, { once: !0 }), a = () => t.removeEventListener("abort", i);
+		} else a = t.subscribe({ next: i });
+		let o = n.subscribe({
+			complete() {
+				r = !0, a(), e.complete?.();
+			},
+			error(t) {
+				r = !0, a(), e.error?.(t);
+			},
+			next: e.next
+		});
+		return () => {
+			a(), o();
+		};
+	});
+}
+function o(t) {
+	return (r) => e((e) => {
+		let i = () => {};
+		return i = r.subscribe({
+			complete: e.complete,
+			error: e.error,
+			next(r) {
+				n(() => {
+					t(r) ? e.next(r) : (e.complete?.(), i());
+				}, e.error);
+			}
+		}), i;
+	});
+}
+function s(n, r = t) {
+	return (t) => e((e) => {
+		let i, a = t.subscribe({
+			complete() {
+				i?.(), e.complete?.();
+			},
+			error(t) {
+				i?.(), e.error?.(t);
+			},
+			next(t) {
+				i?.(), i = r.delay(() => e.next(t), n);
+			}
+		});
+		return () => {
+			i?.(), a();
+		};
+	});
+}
+function c(t, n = Date.now) {
+	return (r) => e((e) => {
+		let i = -Infinity;
+		return r.subscribe({
+			complete: e.complete,
+			error: e.error,
+			next(r) {
+				let a = n();
+				a - i >= t && (i = a, e.next(r));
+			}
+		});
+	});
+}
+function l(t) {
+	return (n) => e((e) => {
+		let r, i = !1, a = n.subscribe({
+			complete: e.complete,
+			error: e.error,
+			next(e) {
+				r = e, i = !0;
+			}
+		}), o = t.subscribe({ next() {
+			i && e.next(r);
+		} });
+		return () => {
+			a(), o();
+		};
+	});
+}
+function u() {
+	return r(1);
+}
+function d() {
+	return (t) => e((e) => {
+		let n, r = !1;
+		return t.subscribe({
+			complete() {
+				r && e.next(n), e.complete?.();
+			},
+			error: e.error,
+			next(e) {
+				n = e, r = !0;
+			}
+		});
+	});
+}
+//#endregion
+export { s as debounce, u as first, d as last, l as sample, i as skip, r as take, a as takeUntil, o as takeWhile, c as throttle };
+
+//# sourceMappingURL=filtering.js.map

package/dist/operators/filtering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtering.js","names":[],"sources":["../../src/operators/filtering.ts"],"sourcesContent":["import type { Flux, Operator, Scheduler, Unsubscribe } from '../types';\n\nimport { guard } from '../_safe';\nimport { DEFAULT_SCHEDULER } from '../_scheduler';\nimport { flux } from '../core';\n\n/**\n * Emit only the first `count` values, then complete.\n *\n * @example\n * interval(100).pipe(take(3)); // emits 0, 1, 2 then completes\n */\nexport function take<T>(count: number): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      if (count <= 0) {\n        observer.complete?.();\n\n        return;\n      }\n\n      let seen = 0;\n      let unsub: Unsubscribe = () => {};\n\n      unsub = source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          observer.next(v);\n          seen++;\n\n          if (seen >= count) {\n            observer.complete?.();\n            unsub();\n          }\n        },\n      });\n\n      return unsub;\n    });\n}\n\n/** Skip the first `count` values, then emit the rest. */\nexport function skip<T>(count: number): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let skipped = 0;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          if (skipped < count) {\n            skipped++;\n          } else {\n            observer.next(v);\n          }\n        },\n      });\n    });\n}\n\n/**\n * Complete when either `notifier` emits its first value or an `AbortSignal` aborts.\n *\n * @example\n * source$.pipe(takeUntil(stop$));\n * source$.pipe(takeUntil(abortController.signal));\n */\nexport function takeUntil<T>(notifier: AbortSignal | Flux<unknown>): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let done = false;\n\n      const finish = (): void => {\n        if (done) return;\n\n        done = true;\n        observer.complete?.();\n        notifierUnsub();\n        sourceUnsub?.();\n      };\n\n      let notifierUnsub: () => void;\n\n      if (notifier instanceof AbortSignal) {\n        if (notifier.aborted) {\n          observer.complete?.();\n\n          return;\n        }\n\n        notifier.addEventListener('abort', finish, { once: true });\n        notifierUnsub = () => notifier.removeEventListener('abort', finish);\n      } else {\n        notifierUnsub = notifier.subscribe({ next: finish });\n      }\n\n      const sourceUnsub = source.subscribe({\n        complete() {\n          done = true;\n          notifierUnsub();\n          observer.complete?.();\n        },\n        error(err) {\n          done = true;\n          notifierUnsub();\n          observer.error?.(err);\n        },\n        next: observer.next,\n      });\n\n      return () => {\n        notifierUnsub();\n        sourceUnsub();\n      };\n    });\n}\n\n/**\n * Emit values while `predicate` is truthy. Complete when it returns `false`.\n *\n * @example\n * of(1, 2, 3, 4).pipe(takeWhile((n) => n < 3)); // emits 1, 2\n */\nexport function takeWhile<T>(predicate: (value: T) => boolean): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let unsub: Unsubscribe = () => {};\n\n      unsub = source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            if (predicate(v)) {\n              observer.next(v);\n            } else {\n              observer.complete?.();\n              unsub();\n            }\n          }, observer.error);\n        },\n      });\n\n      return unsub;\n    });\n}\n\n/**\n * Emit the last value after `ms` milliseconds of silence.\n * Resets the timer on every source emission.\n *\n * **Note:** if the source completes while a value is pending (timer not yet fired),\n * the pending value is dropped. Only the completion signal is forwarded.\n *\n * @example\n * fromEvent(input, 'input').pipe(debounce(300)); // wait 300ms after last keystroke\n */\nexport function debounce<T>(ms: number, scheduler: Scheduler = DEFAULT_SCHEDULER): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let cancelTimer: (() => void) | undefined;\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          cancelTimer = scheduler.delay(() => observer.next(v), ms);\n        },\n      });\n\n      return () => {\n        cancelTimer?.();\n        unsub();\n      };\n    });\n}\n\n/**\n * Emit at most once per `ms` milliseconds. Leading edge by default.\n * Pass a custom `clock` function (default: `Date.now`) to control time in tests.\n *\n * @example\n * fromEvent(window, 'scroll').pipe(throttle(100));\n */\nexport function throttle<T>(ms: number, clock: () => number = Date.now): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let lastEmit = -Infinity;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          const now = clock();\n\n          if (now - lastEmit >= ms) {\n            lastEmit = now;\n            observer.next(v);\n          }\n        },\n      });\n    });\n}\n\n/**\n * When `notifier` emits, emit the latest value from `source` (if any).\n * Useful for polling-like patterns.\n *\n * @example\n * source$.pipe(sample(interval(1000))); // emit latest value every 1s\n */\nexport function sample<T>(notifier: Flux<unknown>): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let latest: T;\n      let hasValue = false;\n\n      const sourceUnsub = source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          latest = v;\n          hasValue = true;\n        },\n      });\n\n      const notifierUnsub = notifier.subscribe({\n        next() {\n          if (hasValue) observer.next(latest);\n        },\n      });\n\n      return () => {\n        sourceUnsub();\n        notifierUnsub();\n      };\n    });\n}\n\n/** Emit only the first value, then complete. Equivalent to `take(1)`. */\nexport function first<T>(): Operator<T, T> {\n  return take(1);\n}\n\n/**\n * Emit only the last value, collected when source completes.\n *\n * @example\n * of(1, 2, 3).pipe(last()); // emits 3\n */\nexport function last<T>(): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let latest: T;\n      let hasValue = false;\n\n      return source.subscribe({\n        complete() {\n          if (hasValue) observer.next(latest);\n\n          observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          latest = v;\n          hasValue = true;\n        },\n      });\n    });\n}\n"],"mappings":"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"}

package/dist/operators/transformation.cjs

@@ -0,0 +1,2 @@
+const e=require("../_dev.cjs"),t=require("../core.cjs"),n=require("../_safe.cjs"),r=require("../_numeric.cjs");function i(e){return r=>t.flux(t=>r.subscribe({complete:t.complete,error:t.error,next(r){n.guard(()=>t.next(e(r)),t.error)}}))}function a(e){return r=>t.flux(t=>r.subscribe({complete:t.complete,error:t.error,next(r){n.guard(()=>{e(r)&&t.next(r)},t.error)}}))}function o(e,r){return i=>t.flux(t=>{let a=r;return i.subscribe({complete:t.complete,error:t.error,next(r){n.guard(()=>{a=e(a,r),t.next(a)},t.error)}})})}function s(e){return r=>t.flux(t=>{let i,a=!1,o=()=>{a&&!i&&t.complete?.()},s=r.subscribe({complete(){a=!0,o()},error:t.error,next(r){n.guard(()=>{i?.(),i=e(r).subscribe({complete(){i=void 0,o()},error:t.error,next:t.next})},t.error)}});return()=>{s(),i?.()}})}function c(e){return r=>t.flux(t=>{let i=!1,a=0,o=new Set,s=()=>{i&&a===0&&t.complete?.()},c=r.subscribe({complete(){i=!0,s()},error:t.error,next(r){n.guard(()=>{a++;let n=!1,i=()=>{};i=e(r).subscribe({complete(){n=!0,a--,o.delete(i),s()},error:t.error,next:t.next}),n||o.add(i)},t.error)}});return()=>{c();for(let e of o)e()}})}function l(e,r=1/0){return i=>t.flux(t=>{let a=!1,o=[],s=!1,c;function l(){if(o.length===0){s=!1,a&&t.complete?.();return}s=!0;let r=o.shift();n.guard(()=>{c=e(r).subscribe({complete(){c=void 0,l()},error:t.error,next:t.next})},t.error)}let u=i.subscribe({complete(){a=!0,s||t.complete?.()},error:t.error,next(e){o.length<r&&(o.push(e),s||l())}});return()=>{u(),c?.(),o.length=0}})}function u(e){let r=e??Object.is;return e=>t.flux(t=>{let i=!1,a;return e.subscribe({complete:t.complete,error:t.error,next(e){n.guard(()=>{(!i||!r(a,e))&&(i=!0,a=e,t.next(e))},t.error)}})})}function d(...e){return n=>t.flux(t=>{for(let n of e)t.next(n);return n.subscribe(t)})}function f(n,i){let{clamped:a,value:o}=r.clampPositiveInt(n),{clamped:s,value:c}=r.clampPositiveInt(i??o);return a&&e.warn(`bufferCount: size must be a finite integer >= 1, got ${n} — clamped to ${o}`),i!==void 0&&s&&e.warn(`bufferCount: every must be a finite integer >= 1, got ${i} — clamped to ${c}`),e=>t.flux(t=>{let n=[],r=0;return e.subscribe({complete(){for(let e of n)e.length>0&&t.next(e);t.complete?.()},error:t.error,next(e){r%c===0&&n.push([]);for(let t of n)t.push(e);let i=0;for(;i<n.length;)n[i].length>=o?(t.next(n[i]),n.splice(i,1)):i++;r++}})})}function p(){return e=>t.flux(t=>{let n=!1,r;return e.subscribe({complete:t.complete,error:t.error,next(e){n&&t.next([r,e]),n=!0,r=e}})})}exports.bufferCount=f,exports.concatMap=l,exports.distinctUntilChanged=u,exports.filter=a,exports.flatMap=c,exports.map=i,exports.pairwise=p,exports.scan=o,exports.startWith=d,exports.switchMap=s;
+//# sourceMappingURL=transformation.cjs.map

package/dist/operators/transformation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformation.cjs","names":[],"sources":["../../src/operators/transformation.ts"],"sourcesContent":["import type { Flux, Operator, Unsubscribe } from '../types';\n\nimport { warn } from '../_dev';\nimport { clampPositiveInt } from '../_numeric';\nimport { guard } from '../_safe';\nimport { flux } from '../core';\n\n/** Transform each emitted value through `fn`. */\nexport function map<A, B>(fn: (value: A) => B): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) =>\n      source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => observer.next(fn(v)), observer.error);\n        },\n      }),\n    );\n}\n\n/** Emit only values for which `predicate` returns `true`. */\nexport function filter<T>(predicate: (value: T) => boolean): 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            if (predicate(v)) observer.next(v);\n          }, observer.error);\n        },\n      }),\n    );\n}\n\n/**\n * Accumulate state with a reducer. Emits the accumulated value after each source emission.\n *\n * @example\n * of(1, 2, 3).pipe(scan((acc, n) => acc + n, 0)); // emits 1, 3, 6\n */\nexport function scan<T, A>(reducer: (acc: A, value: T) => A, seed: A): Operator<T, A> {\n  return (source) =>\n    flux<A>((observer) => {\n      let acc = seed;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            acc = reducer(acc, v);\n            observer.next(acc);\n          }, observer.error);\n        },\n      });\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, cancelling the previous inner on each new emission.\n * Useful for search-as-you-type, navigation, etc.\n */\nexport function switchMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let innerUnsub: Unsubscribe | undefined;\n      let outerDone = false;\n\n      const checkDone = (): void => {\n        if (outerDone && !innerUnsub) observer.complete?.();\n      };\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n          checkDone();\n        },\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            innerUnsub?.();\n            innerUnsub = fn(v).subscribe({\n              complete() {\n                innerUnsub = undefined;\n                checkDone();\n              },\n              error: observer.error,\n              next: observer.next,\n            });\n          }, observer.error);\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        innerUnsub?.();\n      };\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, merging all inner streams concurrently.\n * All inner subscriptions run simultaneously.\n */\nexport function flatMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let outerDone = false;\n      let activeInner = 0;\n      const innerUnsubs = new Set<Unsubscribe>();\n\n      const checkDone = (): void => {\n        if (outerDone && activeInner === 0) observer.complete?.();\n      };\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n          checkDone();\n        },\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            activeInner++;\n\n            let syncDone = false;\n            // Init to NOOP to avoid TDZ if complete fires synchronously during subscribe().\n            let unsub: Unsubscribe = () => {};\n\n            const sub = fn(v).subscribe({\n              complete() {\n                syncDone = true;\n                activeInner--;\n                innerUnsubs.delete(unsub);\n                checkDone();\n              },\n              error: observer.error,\n              next: observer.next,\n            });\n\n            unsub = sub;\n\n            if (!syncDone) innerUnsubs.add(unsub);\n          }, observer.error);\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        for (const u of innerUnsubs) u();\n      };\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, subscribing to each one only after\n * the previous inner completes (sequential, queued).\n * Pass `maxBuffer` to cap queued items; excess items are dropped silently.\n */\nexport function concatMap<A, B>(fn: (value: A) => Flux<B>, maxBuffer = Infinity): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let outerDone = false;\n      const queue: A[] = [];\n      let processing = false;\n      let currentUnsub: Unsubscribe | undefined;\n\n      function processNext(): void {\n        if (queue.length === 0) {\n          processing = false;\n\n          if (outerDone) observer.complete?.();\n\n          return;\n        }\n\n        processing = true;\n\n        const item = queue.shift()!;\n\n        guard(() => {\n          currentUnsub = fn(item).subscribe({\n            complete() {\n              currentUnsub = undefined;\n\n              processNext();\n            },\n            error: observer.error,\n            next: observer.next,\n          });\n        }, observer.error);\n      }\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n\n          if (!processing) observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          if (queue.length < maxBuffer) {\n            queue.push(v);\n\n            if (!processing) processNext();\n          }\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        currentUnsub?.();\n        queue.length = 0;\n      };\n    });\n}\n\n/**\n * Suppress consecutive duplicate values.\n * Uses `Object.is` by default; provide a custom `comparator` for deep equality.\n *\n * @example\n * of(1, 1, 2, 2, 3).pipe(distinctUntilChanged()); // emits 1, 2, 3\n */\nexport function distinctUntilChanged<T>(comparator?: (a: T, b: T) => boolean): Operator<T, T> {\n  const eq = comparator ?? Object.is;\n\n  return (source) =>\n    flux<T>((observer) => {\n      let hasPrev = false;\n      let prev: T;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            if (!hasPrev || !eq(prev, v)) {\n              hasPrev = true;\n              prev = v;\n              observer.next(v);\n            }\n          }, observer.error);\n        },\n      });\n    });\n}\n\n/**\n * Prepend one or more static values before the source's first emission.\n *\n * @example\n * of(2, 3).pipe(startWith(0, 1)).subscribe(console.log); // 0, 1, 2, 3\n */\nexport function startWith<T>(...values: T[]): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      for (const v of values) observer.next(v);\n\n      return source.subscribe(observer);\n    });\n}\n\n/**\n * Collect source emissions into fixed-size arrays, emitting each batch when full.\n * A partial batch at the end of the source is flushed on completion.\n *\n * @param size - Number of emissions per batch.\n * @param every - Start a new batch every `every` emissions (default: `size`, non-overlapping).\n *\n * @example\n * of(1, 2, 3, 4, 5, 6).pipe(bufferCount(2)).subscribe(console.log);\n * // [1, 2], [3, 4], [5, 6]\n */\nexport function bufferCount<T>(size: number, every?: number): Operator<T, T[]> {\n  const { clamped: sizeClamped, value: safeSize } = clampPositiveInt(size);\n  const { clamped: everyClamped, value: step } = clampPositiveInt(every ?? safeSize);\n\n  if (sizeClamped) {\n    warn(`bufferCount: size must be a finite integer >= 1, got ${size} — clamped to ${safeSize}`);\n  }\n\n  if (every !== undefined && everyClamped) {\n    warn(`bufferCount: every must be a finite integer >= 1, got ${every} — clamped to ${step}`);\n  }\n\n  return (source) =>\n    flux<T[]>((observer) => {\n      const buffers: T[][] = [];\n      let count = 0;\n\n      return source.subscribe({\n        complete() {\n          for (const buf of buffers) {\n            if (buf.length > 0) observer.next(buf);\n          }\n\n          observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          if (count % step === 0) buffers.push([]);\n\n          for (const buf of buffers) buf.push(v);\n\n          let i = 0;\n\n          while (i < buffers.length) {\n            if (buffers[i]!.length >= safeSize) {\n              observer.next(buffers[i]!);\n              buffers.splice(i, 1);\n            } else {\n              i++;\n            }\n          }\n\n          count++;\n        },\n      });\n    });\n}\n\n/**\n * Emit the previous and current value as a `[prev, curr]` tuple.\n * No emission occurs until the second source value arrives.\n *\n * @example\n * of(1, 2, 3).pipe(pairwise()).subscribe(console.log); // [1, 2], [2, 3]\n */\nexport function pairwise<T>(): Operator<T, [T, T]> {\n  return (source) =>\n    flux<[T, T]>((observer) => {\n      let hasPrev = false;\n      let prev: T;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          if (hasPrev) observer.next([prev, v]);\n\n          hasPrev = true;\n          prev = v;\n        },\n      });\n    });\n}\n"],"mappings":"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"}

package/dist/operators/transformation.d.ts

@@ -0,0 +1,64 @@
+import type { Flux, Operator } from '../types';
+/** Transform each emitted value through `fn`. */
+export declare function map<A, B>(fn: (value: A) => B): Operator<A, B>;
+/** Emit only values for which `predicate` returns `true`. */
+export declare function filter<T>(predicate: (value: T) => boolean): Operator<T, T>;
+/**
+ * Accumulate state with a reducer. Emits the accumulated value after each source emission.
+ *
+ * @example
+ * of(1, 2, 3).pipe(scan((acc, n) => acc + n, 0)); // emits 1, 3, 6
+ */
+export declare function scan<T, A>(reducer: (acc: A, value: T) => A, seed: A): Operator<T, A>;
+/**
+ * Map each source value to an inner `Flux`, cancelling the previous inner on each new emission.
+ * Useful for search-as-you-type, navigation, etc.
+ */
+export declare function switchMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B>;
+/**
+ * Map each source value to an inner `Flux`, merging all inner streams concurrently.
+ * All inner subscriptions run simultaneously.
+ */
+export declare function flatMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B>;
+/**
+ * Map each source value to an inner `Flux`, subscribing to each one only after
+ * the previous inner completes (sequential, queued).
+ * Pass `maxBuffer` to cap queued items; excess items are dropped silently.
+ */
+export declare function concatMap<A, B>(fn: (value: A) => Flux<B>, maxBuffer?: number): Operator<A, B>;
+/**
+ * Suppress consecutive duplicate values.
+ * Uses `Object.is` by default; provide a custom `comparator` for deep equality.
+ *
+ * @example
+ * of(1, 1, 2, 2, 3).pipe(distinctUntilChanged()); // emits 1, 2, 3
+ */
+export declare function distinctUntilChanged<T>(comparator?: (a: T, b: T) => boolean): Operator<T, T>;
+/**
+ * Prepend one or more static values before the source's first emission.
+ *
+ * @example
+ * of(2, 3).pipe(startWith(0, 1)).subscribe(console.log); // 0, 1, 2, 3
+ */
+export declare function startWith<T>(...values: T[]): Operator<T, T>;
+/**
+ * Collect source emissions into fixed-size arrays, emitting each batch when full.
+ * A partial batch at the end of the source is flushed on completion.
+ *
+ * @param size - Number of emissions per batch.
+ * @param every - Start a new batch every `every` emissions (default: `size`, non-overlapping).
+ *
+ * @example
+ * of(1, 2, 3, 4, 5, 6).pipe(bufferCount(2)).subscribe(console.log);
+ * // [1, 2], [3, 4], [5, 6]
+ */
+export declare function bufferCount<T>(size: number, every?: number): Operator<T, T[]>;
+/**
+ * Emit the previous and current value as a `[prev, curr]` tuple.
+ * No emission occurs until the second source value arrives.
+ *
+ * @example
+ * of(1, 2, 3).pipe(pairwise()).subscribe(console.log); // [1, 2], [2, 3]
+ */
+export declare function pairwise<T>(): Operator<T, [T, T]>;
+//# sourceMappingURL=transformation.d.ts.map

package/dist/operators/transformation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformation.d.ts","sourceRoot":"","sources":["../../src/operators/transformation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAe,MAAM,UAAU,CAAC;AAO5D,iDAAiD;AACjD,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAW7D;AAED,6DAA6D;AAC7D,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAa1E;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAgBpF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAoCzE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAgDvE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,SAAW,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAwD/F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAsB5F;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAO3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CA8C7E;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAiBjD"}

package/dist/operators/transformation.js

@@ -0,0 +1,185 @@
+import { warn as e } from "../_dev.js";
+import { flux as t } from "../core.js";
+import { guard as n } from "../_safe.js";
+import { clampPositiveInt as r } from "../_numeric.js";
+//#region src/operators/transformation.ts
+function i(e) {
+	return (r) => t((t) => r.subscribe({
+		complete: t.complete,
+		error: t.error,
+		next(r) {
+			n(() => t.next(e(r)), t.error);
+		}
+	}));
+}
+function a(e) {
+	return (r) => t((t) => r.subscribe({
+		complete: t.complete,
+		error: t.error,
+		next(r) {
+			n(() => {
+				e(r) && t.next(r);
+			}, t.error);
+		}
+	}));
+}
+function o(e, r) {
+	return (i) => t((t) => {
+		let a = r;
+		return i.subscribe({
+			complete: t.complete,
+			error: t.error,
+			next(r) {
+				n(() => {
+					a = e(a, r), t.next(a);
+				}, t.error);
+			}
+		});
+	});
+}
+function s(e) {
+	return (r) => t((t) => {
+		let i, a = !1, o = () => {
+			a && !i && t.complete?.();
+		}, s = r.subscribe({
+			complete() {
+				a = !0, o();
+			},
+			error: t.error,
+			next(r) {
+				n(() => {
+					i?.(), i = e(r).subscribe({
+						complete() {
+							i = void 0, o();
+						},
+						error: t.error,
+						next: t.next
+					});
+				}, t.error);
+			}
+		});
+		return () => {
+			s(), i?.();
+		};
+	});
+}
+function c(e) {
+	return (r) => t((t) => {
+		let i = !1, a = 0, o = /* @__PURE__ */ new Set(), s = () => {
+			i && a === 0 && t.complete?.();
+		}, c = r.subscribe({
+			complete() {
+				i = !0, s();
+			},
+			error: t.error,
+			next(r) {
+				n(() => {
+					a++;
+					let n = !1, i = () => {};
+					i = e(r).subscribe({
+						complete() {
+							n = !0, a--, o.delete(i), s();
+						},
+						error: t.error,
+						next: t.next
+					}), n || o.add(i);
+				}, t.error);
+			}
+		});
+		return () => {
+			c();
+			for (let e of o) e();
+		};
+	});
+}
+function l(e, r = Infinity) {
+	return (i) => t((t) => {
+		let a = !1, o = [], s = !1, c;
+		function l() {
+			if (o.length === 0) {
+				s = !1, a && t.complete?.();
+				return;
+			}
+			s = !0;
+			let r = o.shift();
+			n(() => {
+				c = e(r).subscribe({
+					complete() {
+						c = void 0, l();
+					},
+					error: t.error,
+					next: t.next
+				});
+			}, t.error);
+		}
+		let u = i.subscribe({
+			complete() {
+				a = !0, s || t.complete?.();
+			},
+			error: t.error,
+			next(e) {
+				o.length < r && (o.push(e), s || l());
+			}
+		});
+		return () => {
+			u(), c?.(), o.length = 0;
+		};
+	});
+}
+function u(e) {
+	let r = e ?? Object.is;
+	return (e) => t((t) => {
+		let i = !1, a;
+		return e.subscribe({
+			complete: t.complete,
+			error: t.error,
+			next(e) {
+				n(() => {
+					(!i || !r(a, e)) && (i = !0, a = e, t.next(e));
+				}, t.error);
+			}
+		});
+	});
+}
+function d(...e) {
+	return (n) => t((t) => {
+		for (let n of e) t.next(n);
+		return n.subscribe(t);
+	});
+}
+function f(n, i) {
+	let { clamped: a, value: o } = r(n), { clamped: s, value: c } = r(i ?? o);
+	return a && e(`bufferCount: size must be a finite integer >= 1, got ${n} — clamped to ${o}`), i !== void 0 && s && e(`bufferCount: every must be a finite integer >= 1, got ${i} — clamped to ${c}`), (e) => t((t) => {
+		let n = [], r = 0;
+		return e.subscribe({
+			complete() {
+				for (let e of n) e.length > 0 && t.next(e);
+				t.complete?.();
+			},
+			error: t.error,
+			next(e) {
+				r % c === 0 && n.push([]);
+				for (let t of n) t.push(e);
+				let i = 0;
+				for (; i < n.length;) n[i].length >= o ? (t.next(n[i]), n.splice(i, 1)) : i++;
+				r++;
+			}
+		});
+	});
+}
+function p() {
+	return (e) => t((t) => {
+		let n = !1, r;
+		return e.subscribe({
+			complete: t.complete,
+			error: t.error,
+			next(e) {
+				n && t.next([r, e]), n = !0, r = e;
+			}
+		});
+	});
+}
+//#endregion
+export { f as bufferCount, l as concatMap, u as distinctUntilChanged, a as filter, c as flatMap, i as map, p as pairwise, o as scan, d as startWith, s as switchMap };
+
+//# sourceMappingURL=transformation.js.map

package/dist/operators/transformation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformation.js","names":[],"sources":["../../src/operators/transformation.ts"],"sourcesContent":["import type { Flux, Operator, Unsubscribe } from '../types';\n\nimport { warn } from '../_dev';\nimport { clampPositiveInt } from '../_numeric';\nimport { guard } from '../_safe';\nimport { flux } from '../core';\n\n/** Transform each emitted value through `fn`. */\nexport function map<A, B>(fn: (value: A) => B): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) =>\n      source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => observer.next(fn(v)), observer.error);\n        },\n      }),\n    );\n}\n\n/** Emit only values for which `predicate` returns `true`. */\nexport function filter<T>(predicate: (value: T) => boolean): 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            if (predicate(v)) observer.next(v);\n          }, observer.error);\n        },\n      }),\n    );\n}\n\n/**\n * Accumulate state with a reducer. Emits the accumulated value after each source emission.\n *\n * @example\n * of(1, 2, 3).pipe(scan((acc, n) => acc + n, 0)); // emits 1, 3, 6\n */\nexport function scan<T, A>(reducer: (acc: A, value: T) => A, seed: A): Operator<T, A> {\n  return (source) =>\n    flux<A>((observer) => {\n      let acc = seed;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            acc = reducer(acc, v);\n            observer.next(acc);\n          }, observer.error);\n        },\n      });\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, cancelling the previous inner on each new emission.\n * Useful for search-as-you-type, navigation, etc.\n */\nexport function switchMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let innerUnsub: Unsubscribe | undefined;\n      let outerDone = false;\n\n      const checkDone = (): void => {\n        if (outerDone && !innerUnsub) observer.complete?.();\n      };\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n          checkDone();\n        },\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            innerUnsub?.();\n            innerUnsub = fn(v).subscribe({\n              complete() {\n                innerUnsub = undefined;\n                checkDone();\n              },\n              error: observer.error,\n              next: observer.next,\n            });\n          }, observer.error);\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        innerUnsub?.();\n      };\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, merging all inner streams concurrently.\n * All inner subscriptions run simultaneously.\n */\nexport function flatMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let outerDone = false;\n      let activeInner = 0;\n      const innerUnsubs = new Set<Unsubscribe>();\n\n      const checkDone = (): void => {\n        if (outerDone && activeInner === 0) observer.complete?.();\n      };\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n          checkDone();\n        },\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            activeInner++;\n\n            let syncDone = false;\n            // Init to NOOP to avoid TDZ if complete fires synchronously during subscribe().\n            let unsub: Unsubscribe = () => {};\n\n            const sub = fn(v).subscribe({\n              complete() {\n                syncDone = true;\n                activeInner--;\n                innerUnsubs.delete(unsub);\n                checkDone();\n              },\n              error: observer.error,\n              next: observer.next,\n            });\n\n            unsub = sub;\n\n            if (!syncDone) innerUnsubs.add(unsub);\n          }, observer.error);\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        for (const u of innerUnsubs) u();\n      };\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, subscribing to each one only after\n * the previous inner completes (sequential, queued).\n * Pass `maxBuffer` to cap queued items; excess items are dropped silently.\n */\nexport function concatMap<A, B>(fn: (value: A) => Flux<B>, maxBuffer = Infinity): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let outerDone = false;\n      const queue: A[] = [];\n      let processing = false;\n      let currentUnsub: Unsubscribe | undefined;\n\n      function processNext(): void {\n        if (queue.length === 0) {\n          processing = false;\n\n          if (outerDone) observer.complete?.();\n\n          return;\n        }\n\n        processing = true;\n\n        const item = queue.shift()!;\n\n        guard(() => {\n          currentUnsub = fn(item).subscribe({\n            complete() {\n              currentUnsub = undefined;\n\n              processNext();\n            },\n            error: observer.error,\n            next: observer.next,\n          });\n        }, observer.error);\n      }\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n\n          if (!processing) observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          if (queue.length < maxBuffer) {\n            queue.push(v);\n\n            if (!processing) processNext();\n          }\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        currentUnsub?.();\n        queue.length = 0;\n      };\n    });\n}\n\n/**\n * Suppress consecutive duplicate values.\n * Uses `Object.is` by default; provide a custom `comparator` for deep equality.\n *\n * @example\n * of(1, 1, 2, 2, 3).pipe(distinctUntilChanged()); // emits 1, 2, 3\n */\nexport function distinctUntilChanged<T>(comparator?: (a: T, b: T) => boolean): Operator<T, T> {\n  const eq = comparator ?? Object.is;\n\n  return (source) =>\n    flux<T>((observer) => {\n      let hasPrev = false;\n      let prev: T;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            if (!hasPrev || !eq(prev, v)) {\n              hasPrev = true;\n              prev = v;\n              observer.next(v);\n            }\n          }, observer.error);\n        },\n      });\n    });\n}\n\n/**\n * Prepend one or more static values before the source's first emission.\n *\n * @example\n * of(2, 3).pipe(startWith(0, 1)).subscribe(console.log); // 0, 1, 2, 3\n */\nexport function startWith<T>(...values: T[]): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      for (const v of values) observer.next(v);\n\n      return source.subscribe(observer);\n    });\n}\n\n/**\n * Collect source emissions into fixed-size arrays, emitting each batch when full.\n * A partial batch at the end of the source is flushed on completion.\n *\n * @param size - Number of emissions per batch.\n * @param every - Start a new batch every `every` emissions (default: `size`, non-overlapping).\n *\n * @example\n * of(1, 2, 3, 4, 5, 6).pipe(bufferCount(2)).subscribe(console.log);\n * // [1, 2], [3, 4], [5, 6]\n */\nexport function bufferCount<T>(size: number, every?: number): Operator<T, T[]> {\n  const { clamped: sizeClamped, value: safeSize } = clampPositiveInt(size);\n  const { clamped: everyClamped, value: step } = clampPositiveInt(every ?? safeSize);\n\n  if (sizeClamped) {\n    warn(`bufferCount: size must be a finite integer >= 1, got ${size} — clamped to ${safeSize}`);\n  }\n\n  if (every !== undefined && everyClamped) {\n    warn(`bufferCount: every must be a finite integer >= 1, got ${every} — clamped to ${step}`);\n  }\n\n  return (source) =>\n    flux<T[]>((observer) => {\n      const buffers: T[][] = [];\n      let count = 0;\n\n      return source.subscribe({\n        complete() {\n          for (const buf of buffers) {\n            if (buf.length > 0) observer.next(buf);\n          }\n\n          observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          if (count % step === 0) buffers.push([]);\n\n          for (const buf of buffers) buf.push(v);\n\n          let i = 0;\n\n          while (i < buffers.length) {\n            if (buffers[i]!.length >= safeSize) {\n              observer.next(buffers[i]!);\n              buffers.splice(i, 1);\n            } else {\n              i++;\n            }\n          }\n\n          count++;\n        },\n      });\n    });\n}\n\n/**\n * Emit the previous and current value as a `[prev, curr]` tuple.\n * No emission occurs until the second source value arrives.\n *\n * @example\n * of(1, 2, 3).pipe(pairwise()).subscribe(console.log); // [1, 2], [2, 3]\n */\nexport function pairwise<T>(): Operator<T, [T, T]> {\n  return (source) =>\n    flux<[T, T]>((observer) => {\n      let hasPrev = false;\n      let prev: T;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          if (hasPrev) observer.next([prev, v]);\n\n          hasPrev = true;\n          prev = v;\n        },\n      });\n    });\n}\n"],"mappings":"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"}

package/dist/operators/utility.cjs

@@ -0,0 +1,2 @@
+const e=require("../_dev.cjs"),t=require("../core.cjs"),n=require("../_scheduler.cjs"),r=require("../errors.cjs"),i=require("../_safe.cjs"),a=require("../_numeric.cjs");function o(e,n){let r=new Set,i=[],a,o=!1,s,c=!1;return t.flux(t=>{if(c){t.error?.(s);return}for(let e of i)t.next(e);if(o){t.complete?.();return}let l={complete:t.complete,error:t.error,next:t.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){n>0&&(i.length>=n&&i.shift(),i.push(e));for(let t of[...r])t.next(e)}})),()=>{r.delete(l),r.size===0&&(a?.(),a=void 0)}})}function s(){return e=>o(e,0)}function c(t=1){let{clamped:n,value:r}=a.clampPositiveInt(t);return n&&e.warn(`shareReplay: bufferSize must be a finite integer >= 1, got ${t} — clamped to ${r}`),e=>o(e,r)}function l(e){return n=>t.flux(t=>n.subscribe({complete:t.complete,error:t.error,next(n){i.guard(()=>{e(n),t.next(n)},t.error)}}))}function u(e,r=n.DEFAULT_SCHEDULER){return n=>t.flux(t=>{let i=[],a=n.subscribe({complete(){i.push(r.delay(()=>t.complete?.(),e))},error:t.error,next(n){i.push(r.delay(()=>t.next(n),e))}});return()=>{a();for(let e of i)e()}})}function d(e,i=n.DEFAULT_SCHEDULER){return n=>t.flux(t=>{let a,o=()=>{a=i.delay(()=>{t.error?.(new r.FluxTimeoutError(e))},e)};o();let s=n.subscribe({complete(){a(),t.complete?.()},error(e){a(),t.error?.(e)},next(e){a(),o(),t.next(e)}});return()=>{a(),s()}})}function f(e){return n=>t.flux(t=>{let r,a=n.subscribe({complete:t.complete,error(n){i.guard(()=>{r=e(n).subscribe({complete:t.complete,error:t.error,next:t.next})},t.error)},next:t.next});return()=>{a(),r?.()}})}function p(e,r,a=n.DEFAULT_SCHEDULER){return n=>t.flux(t=>{let o=0,s,c;function l(){s=n.subscribe({complete:t.complete,error(n){if(o<e){let e=o++;r===void 0?l():i.guard(()=>{let t=typeof r==`function`?r(e):r;c=a.delay(l,Math.max(0,t))},t.error)}else t.error?.(n)},next:t.next})}return l(),()=>{c?.(),s?.()}})}function m(n){return r=>t.flux(t=>{let i=!1,a=()=>{if(!i){i=!0;try{n()}catch(t){e.error(`finalize: cleanup callback threw`,t)}}},o=r.subscribe({complete(){a(),t.complete?.()},error(e){a(),t.error?.(e)},next:t.next});return()=>{a(),o()}})}function h(e){return e.reason??new DOMException(`Aborted`,`AbortError`)}function g(e,t){return new Promise((n,r)=>{if(t?.aborted){r(h(t));return}let i,a=()=>{},o=()=>{a(),r(h(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 _(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 v(...e){return t=>e.reduce((e,t)=>t(e),t)}exports.catchError=f,exports.delay=u,exports.finalize=m,exports.flow=v,exports.retry=p,exports.share=s,exports.shareReplay=c,exports.tap=l,exports.timeout=d,exports.toArray=_,exports.toPromise=g;
+//# sourceMappingURL=utility.cjs.map

package/dist/operators/utility.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility.cjs","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/operators/utility.d.ts

@@ -0,0 +1,98 @@
+import type { Flux, Operator, Scheduler } from '../types';
+/**
+ * Multicast a cold `Flux` to multiple subscribers. The first subscriber starts
+ * the source; the last to unsubscribe stops it.
+ *
+ * @example
+ * const hot$ = cold$.pipe(share()); // one source, many subscribers
+ */
+export declare function share<T>(): Operator<T, T>;
+/**
+ * Multicast a cold `Flux` and replay the last `bufferSize` values (default: 1)
+ * to any new subscriber.
+ *
+ * @example
+ * const hot$ = cold$.pipe(shareReplay(1)); // last value replayed to late subs
+ */
+export declare function shareReplay<T>(bufferSize?: number): Operator<T, T>;
+/** Run a side effect on each emission without modifying the value. */
+export declare function tap<T>(fn: (value: T) => void): Operator<T, T>;
+/** Delay each emission by `ms` milliseconds. Pass a custom `scheduler` to control time in tests. */
+export declare function delay<T>(ms: number, scheduler?: Scheduler): Operator<T, T>;
+/**
+ * Error if no value is emitted within `ms` milliseconds since the last emission
+ * (or since subscription, for the first value). The timer resets on each emission —
+ * this is an inactivity timeout, not a time-to-first-value or total-duration timeout.
+ * Pass a custom `scheduler` to control time in tests.
+ *
+ * @example
+ * source$.pipe(timeout(5000)); // throws FluxTimeoutError after 5s of silence
+ */
+export declare function timeout<T>(ms: number, scheduler?: Scheduler): Operator<T, T>;
+/**
+ * Recover from an error by returning a new `Flux` to continue with.
+ *
+ * @example
+ * source$.pipe(catchError((err) => of('fallback')));
+ */
+export declare function catchError<T>(handler: (err: unknown) => Flux<T>): Operator<T, T>;
+/**
+ * Re-subscribe to the source up to `count` times on error.
+ * Pass `delayMs` as a fixed number or `(attempt) => number` function for backoff.
+ * Pass a custom `scheduler` to control time in tests.
+ *
+ * @example
+ * fetchStream$.pipe(retry(3));
+ * fetchStream$.pipe(retry(3, (n) => Math.min(1000 * 2 ** n, 30_000))); // exponential backoff
+ */
+export declare function retry<T>(count: number, delayMs?: number | ((attempt: number) => number), scheduler?: Scheduler): Operator<T, T>;
+/**
+ * Run `fn` when the stream ends — whether by completion, error, or unsubscription.
+ *
+ * @example
+ * source$.pipe(finalize(() => console.log('stream ended')));
+ */
+export declare function finalize<T>(fn: () => void): Operator<T, T>;
+/**
+ * Convert a `Flux` to a `Promise` that resolves with the last emitted value
+ * when the source completes, or rejects on error.
+ * Pass `signal` to unsubscribe and reject early if the caller loses interest
+ * before the source completes (e.g. a component unmounting).
+ *
+ * @example
+ * const result = await toPromise(source$);
+ * const cancellable = await toPromise(source$, controller.signal);
+ */
+export declare function toPromise<T>(source: Flux<T>, signal?: AbortSignal): Promise<T | undefined>;
+/**
+ * Collect all emitted values into an array resolved when the source completes.
+ * Pass `signal` to stop early and resolve with the values collected so far
+ * (rather than reject) if the caller loses interest before completion.
+ *
+ * @example
+ * const all = await toArray(of(1, 2, 3));
+ * const partial = await toArray(source$, controller.signal);
+ */
+export declare function toArray<T>(source: Flux<T>, signal?: AbortSignal): Promise<T[]>;
+/**
+ * Compose multiple operators into a single reusable operator.
+ * Provides full type safety at any pipeline depth — use instead of
+ * `pipe()` overloads when chaining more than 4 operators.
+ *
+ * @example
+ * const pipeline = flow(
+ *   filter((n) => n % 2 === 0),
+ *   map((n) => n * 10),
+ *   take(5),
+ * );
+ * source$.pipe(pipeline).subscribe(console.log);
+ */
+export declare function flow<A, B>(op1: Operator<A, B>): Operator<A, B>;
+export declare function flow<A, B, C>(op1: Operator<A, B>, op2: Operator<B, C>): Operator<A, C>;
+export declare function flow<A, B, C, D>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>): Operator<A, D>;
+export declare function flow<A, B, C, D, E>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>): Operator<A, E>;
+export declare function flow<A, B, C, D, E, F>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>): Operator<A, F>;
+export declare function flow<A, B, C, D, E, F, G>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: Operator<F, G>): Operator<A, G>;
+export declare function flow<A, B, C, D, E, F, G, H>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: Operator<F, G>, op7: Operator<G, H>): Operator<A, H>;
+export declare function flow<A, B, C, D, E, F, G, H, I>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: Operator<F, G>, op7: Operator<G, H>, op8: Operator<H, I>): Operator<A, I>;
+//# sourceMappingURL=utility.d.ts.map

package/dist/operators/utility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility.d.ts","sourceRoot":"","sources":["../../src/operators/utility.ts"],"names":[],"mappings":"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"}