@effectionx/stream-helpers 0.4.1 → 0.6.0

package/README.md

@@ -192,6 +192,53 @@ function* exampleWithCloseValue() {
 }
 ```
 
+### Subject
+
+Subject helper converts any stream into a multicast stream that replays the
+latest value to new subscribers. It's analogous to
+[RxJS BehaviorSubject](https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject).
+
+```typescript
+import { createSubject } from "@effectionx/stream-helpers";
+import { createChannel, spawn } from "effection";
+
+function* example() {
+  const subject = createSubject<number>();
+  const channel = createChannel<number, void>();
+  const downstream = subject(channel);
+
+  // First subscriber
+  const sub1 = yield* downstream;
+
+  yield* channel.send(1);
+  yield* channel.send(2);
+
+  console.log(yield* sub1.next()); // { done: false, value: 1 }
+  console.log(yield* sub1.next()); // { done: false, value: 2 }
+
+  // Late subscriber gets the latest value immediately
+  const sub2 = yield* downstream;
+  console.log(yield* sub2.next()); // { done: false, value: 2 }
+}
+```
+
+Use it with a pipe operator to convert any stream into a behavior subject:
+
+```typescript
+import { createSubject, map } from "@effectionx/stream-helpers";
+import { pipe } from "remeda";
+
+const subject = createSubject<string>();
+
+const stream = pipe(
+  source,
+  map(function* (x) {
+    return x.toString();
+  }),
+  subject,
+);
+```
+
 ### Passthrough Tracker
 
 Passthrough Tracker stream helper provides a way to know if all items that

package/batch.test.ts

@@ -0,0 +1,112 @@
+import { describe, it } from "@effectionx/bdd";
+import { createArraySignal, is } from "@effectionx/signals";
+import { expect } from "expect";
+import { createChannel, sleep, spawn } from "effection";
+
+import { batch } from "./batch.ts";
+import { forEach } from "./for-each.ts";
+import { useFaucet } from "./test-helpers/faucet.ts";
+
+describe("batch", () => {
+  it("creates a batch when maxTime expires", function* () {
+    const source = createChannel<number, never>();
+    const stream = batch({ maxTime: 50 })(source);
+
+    const subscription = yield* stream;
+
+    let next = yield* spawn(() => subscription.next());
+
+    yield* source.send(1);
+    yield* source.send(2);
+    yield* source.send(3);
+
+    expect((yield* next).value).toEqual([1, 2, 3]);
+  });
+
+  it("creates a batch by maxSize when maxTime is not set", function* () {
+    const faucet = yield* useFaucet<number>({ open: true });
+    const stream = batch({ maxSize: 3 })(faucet);
+
+    const subscription = yield* stream;
+
+    yield* faucet.pour([1, 2, 3, 4, 5, 6]);
+
+    let next = yield* subscription.next();
+    expect(next.value).toEqual([1, 2, 3]);
+
+    next = yield* subscription.next();
+    expect(next.value).toEqual([4, 5, 6]);
+  });
+
+  it("creates a batch within maxTime when maxSize is never reached", function* () {
+    const faucet = yield* useFaucet<number>({ open: true });
+    const stream = batch({ maxSize: 8, maxTime: 50 })(faucet);
+
+    const batches = yield* createArraySignal<readonly number[]>([]);
+    const windows: number[] = [];
+
+    let last = performance.now();
+
+    yield* spawn(() =>
+      forEach<readonly number[], void>(function* (batch) {
+        const now = performance.now();
+        windows.push(now - last);
+        last = now;
+
+        batches.push(batch);
+      }, stream),
+    );
+
+    yield* sleep(1);
+
+    yield* faucet.pour(function* (send) {
+      for (let i = 1; i <= 10; i++) {
+        yield* send(i);
+        yield* sleep(20);
+      }
+    });
+
+    yield* is(batches, (list) => list.flat().length >= 10);
+
+    expect(windows.length).toBeGreaterThanOrEqual(3);
+
+    const avg = average(windows);
+    const percentDiff = Math.abs((avg - 50) / 50) * 100;
+    expect(percentDiff).toBeLessThanOrEqual(30);
+
+    expect(batches.valueOf().flat()).toHaveLength(10);
+  });
+
+  it("creates a batch within maxSize in maxTime window", function* () {
+    const faucet = yield* useFaucet<number>({ open: true });
+    const stream = batch({ maxSize: 5, maxTime: 3 })(faucet);
+
+    const batches = yield* createArraySignal<readonly number[]>([]);
+
+    yield* spawn(() =>
+      forEach<readonly number[], void>(function* (batch) {
+        batches.push(batch);
+      }, stream),
+    );
+
+    yield* sleep(1);
+
+    yield* faucet.pour([1, 2, 3, 4, 5, 6]);
+
+    yield* is(batches, (batches) => batches.flat().length >= 6);
+
+    expect(batches.length).toBeGreaterThan(1);
+    expect(batches.valueOf().every((batch) => batch.length <= 5)).toBe(true);
+  });
+});
+
+function average(arr: number[]) {
+  if (arr.length === 0) {
+    return 0;
+  }
+  const sum = arr.reduce(
+    (accumulator, currentValue) => accumulator + currentValue,
+    0,
+  );
+  return sum / arr.length;
+}

package/batch.ts

@@ -0,0 +1,107 @@
+import { timebox } from "@effectionx/timebox";
+import { type Stream, type Task, spawn } from "effection";
+
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<
+  T,
+  Exclude<keyof T, Keys>
+> &
+  {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+  }[Keys];
+
+export interface BatchOptions {
+  readonly maxTime: number;
+  readonly maxSize: number;
+}
+
+/**
+ * Creates batches of items from the source stream. The batches can be created either by
+ * specifying a maximum time or a maximum size. If both are specified, the batch will be
+ * created when either condition is met.
+ *
+ * @param options - The options for the batch.
+ * @param options.maxTime - The maximum time to wait for a batch.
+ * @param options.maxSize - The maximum size of a batch.
+ * @returns A stream of arrays of items from the source stream.
+ */
+export function batch(
+  options: RequireAtLeastOne<BatchOptions>,
+): <T>(stream: Stream<T, never>) => Stream<Readonly<T[]>, never> {
+  return <T>(stream: Stream<T, never>): Stream<Readonly<T[]>, never> => ({
+    *[Symbol.iterator]() {
+      const subscription = yield* stream;
+      let lastPull: Task<IteratorResult<T, never>> | undefined;
+
+      return {
+        *next() {
+          let start: DOMHighResTimeStamp = performance.now();
+          const batch: T[] = [];
+          let next: IteratorResult<T, never> = {
+            done: true as const,
+            value: undefined as never,
+          };
+          if (lastPull && options.maxTime) {
+            // biome-ignore lint/style/noNonNullAssertion: lastPull checked above
+            const timeout = yield* timebox(options.maxTime, () => lastPull!);
+            if (timeout.timeout) {
+              yield* lastPull.halt();
+              lastPull = undefined;
+            } else {
+              next = timeout.value;
+              lastPull = undefined;
+            }
+          } else {
+            next = yield* subscription.next();
+          }
+          // push the next value into the batch
+          while (!next.done) {
+            batch.push(next.value);
+            const now = performance.now();
+            if (options.maxSize && batch.length >= options.maxSize) {
+              return {
+                done: false as const,
+                value: batch,
+              };
+            }
+            if (options.maxTime && start + options.maxTime <= now) {
+              return {
+                done: false as const,
+                value: batch,
+              };
+            }
+            if (options.maxTime) {
+              const task = yield* spawn(() => subscription.next());
+
+              const timeout = yield* timebox(
+                start + options.maxTime - performance.now(),
+                () => task,
+              );
+
+              if (timeout.timeout) {
+                // produce the batch that we have, save task for next batch
+                lastPull = task;
+                return {
+                  done: false as const,
+                  value: batch,
+                };
+              }
+              next = timeout.value;
+            } else {
+              next = yield* subscription.next();
+            }
+          }
+
+          // Stream is done, return any remaining batch
+          if (batch.length > 0) {
+            return {
+              done: false as const,
+              value: batch,
+            };
+          }
+
+          return next;
+        },
+      };
+    },
+  });
+}

package/dist/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../batch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAoB,MAAM,WAAW,CAAC;AAE1D,KAAK,iBAAiB,CAAC,CAAC,EAAE,IAAI,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,IAAI,CAC9D,CAAC,EACD,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CACvB,GACC;KACG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,IAAI,CAAC,CAAC;AAEV,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,iBAAiB,CAAC,YAAY,CAAC,GACvC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CA8E/D"}

package/dist/batch.js

@@ -0,0 +1,86 @@
+import { timebox } from "@effectionx/timebox";
+import { spawn } from "effection";
+/**
+ * Creates batches of items from the source stream. The batches can be created either by
+ * specifying a maximum time or a maximum size. If both are specified, the batch will be
+ * created when either condition is met.
+ *
+ * @param options - The options for the batch.
+ * @param options.maxTime - The maximum time to wait for a batch.
+ * @param options.maxSize - The maximum size of a batch.
+ * @returns A stream of arrays of items from the source stream.
+ */
+export function batch(options) {
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            let lastPull;
+            return {
+                *next() {
+                    let start = performance.now();
+                    const batch = [];
+                    let next = {
+                        done: true,
+                        value: undefined,
+                    };
+                    if (lastPull && options.maxTime) {
+                        // biome-ignore lint/style/noNonNullAssertion: lastPull checked above
+                        const timeout = yield* timebox(options.maxTime, () => lastPull);
+                        if (timeout.timeout) {
+                            yield* lastPull.halt();
+                            lastPull = undefined;
+                        }
+                        else {
+                            next = timeout.value;
+                            lastPull = undefined;
+                        }
+                    }
+                    else {
+                        next = yield* subscription.next();
+                    }
+                    // push the next value into the batch
+                    while (!next.done) {
+                        batch.push(next.value);
+                        const now = performance.now();
+                        if (options.maxSize && batch.length >= options.maxSize) {
+                            return {
+                                done: false,
+                                value: batch,
+                            };
+                        }
+                        if (options.maxTime && start + options.maxTime <= now) {
+                            return {
+                                done: false,
+                                value: batch,
+                            };
+                        }
+                        if (options.maxTime) {
+                            const task = yield* spawn(() => subscription.next());
+                            const timeout = yield* timebox(start + options.maxTime - performance.now(), () => task);
+                            if (timeout.timeout) {
+                                // produce the batch that we have, save task for next batch
+                                lastPull = task;
+                                return {
+                                    done: false,
+                                    value: batch,
+                                };
+                            }
+                            next = timeout.value;
+                        }
+                        else {
+                            next = yield* subscription.next();
+                        }
+                    }
+                    // Stream is done, return any remaining batch
+                    if (batch.length > 0) {
+                        return {
+                            done: false,
+                            value: batch,
+                        };
+                    }
+                    return next;
+                },
+            };
+        },
+    });
+}

package/dist/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,SAAS,CAAC,OAAO,CAAC,GAC1C,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAuBvD"}

package/dist/filter.js

@@ -0,0 +1,43 @@
+/**
+ * Filters items from the stream based on a predicate function.
+ *
+ * @param predicate - The function to test each item
+ * @returns A stream transformer that only emits items that pass the predicate
+ *
+ * @example
+ * ```typescript
+ * import { filter } from "@effectionx/stream-helpers";
+ * import { run, each } from "effection";
+ *
+ * await run(function* () {
+ *   const stream = filter((x: number) => x > 5)(sourceStream);
+ *
+ *   for (const value of yield* each(stream)) {
+ *     console.log(value); // Only values > 5
+ *   }
+ * });
+ * ```
+ */
+export function filter(predicate) {
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            return {
+                *next() {
+                    while (true) {
+                        const next = yield* subscription.next();
+                        if (next.done) {
+                            return next;
+                        }
+                        if (yield* predicate(next.value)) {
+                            return {
+                                done: false,
+                                value: next.value,
+                            };
+                        }
+                    }
+                },
+            };
+        },
+    });
+}

package/dist/for-each.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-each.d.ts","sourceRoot":"","sources":["../for-each.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAiB,OAAO,CAAC,CAAC,EAAE,MAAM,EAChC,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,EAChC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,GACxB,SAAS,CAAC,MAAM,CAAC,CAQnB"}

package/dist/lines.d.ts

@@ -0,0 +1,29 @@
+import type { Stream } from "effection";
+/**
+ * Represents the close value of a lines stream, containing any
+ * remaining content that didn't end with a newline.
+ */
+export interface Remainder<T> {
+    remainder: string;
+    result: T;
+}
+/**
+ * Stream helper that transforms a stream of binary chunks into a stream of lines.
+ *
+ * Lines are split on newline characters (`\n`). The final line (content after
+ * the last newline) is returned as the `remainder` in the close value.
+ *
+ * @example
+ * ```ts
+ * import { lines } from "@effectionx/stream-helpers";
+ * import { pipe, each } from "effection";
+ *
+ * const lineStream = pipe(process.stdout, lines());
+ * for (const line of yield* each(lineStream)) {
+ *   console.log(line);
+ *   yield* each.next();
+ * }
+ * ```
+ */
+export declare function lines(): <T extends Uint8Array, TReturn>(stream: Stream<T, TReturn>) => Stream<string, Remainder<TReturn>>;
+//# sourceMappingURL=lines.d.ts.map

package/dist/lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lines.d.ts","sourceRoot":"","sources":["../lines.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,CAAC,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,IAAI,CAAC,CAAC,SAAS,UAAU,EAAE,OAAO,EACrD,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,KACvB,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CA0CtC"}

package/dist/lines.js

@@ -0,0 +1,61 @@
+/**
+ * Stream helper that transforms a stream of binary chunks into a stream of lines.
+ *
+ * Lines are split on newline characters (`\n`). The final line (content after
+ * the last newline) is returned as the `remainder` in the close value.
+ *
+ * @example
+ * ```ts
+ * import { lines } from "@effectionx/stream-helpers";
+ * import { pipe, each } from "effection";
+ *
+ * const lineStream = pipe(process.stdout, lines());
+ * for (const line of yield* each(lineStream)) {
+ *   console.log(line);
+ *   yield* each.next();
+ * }
+ * ```
+ */
+export function lines() {
+    const decoder = new TextDecoder();
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            const buffer = [];
+            let remainder = "";
+            return {
+                *next() {
+                    while (buffer.length === 0) {
+                        const next = yield* subscription.next();
+                        if (next.done) {
+                            return {
+                                done: true,
+                                value: {
+                                    remainder,
+                                    result: next.value,
+                                },
+                            };
+                        }
+                        const current = remainder + decoder.decode(next.value);
+                        const lines = current.split("\n");
+                        if (lines.length > 0) {
+                            buffer.push(...lines.slice(0, -1));
+                            remainder = lines.at(-1) ?? "";
+                        }
+                        else {
+                            remainder = current;
+                        }
+                    }
+                    const value = buffer.shift();
+                    if (value === undefined) {
+                        throw new Error("Unexpected empty buffer");
+                    }
+                    return {
+                        done: false,
+                        value,
+                    };
+                },
+            };
+        },
+    });
+}

package/dist/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EACtB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,GAC7B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAsB1D"}

package/dist/map.js

@@ -0,0 +1,26 @@
+/**
+ * Transforms each item in the stream using the provided function.
+ *
+ * @param fn - The function to transform each item
+ * @returns A stream transformer that applies the function to each item
+ */
+export function map(fn) {
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            return {
+                *next() {
+                    const next = yield* subscription.next();
+                    if (next.done) {
+                        return next;
+                    }
+                    const value = yield* fn(next.value);
+                    return {
+                        done: false,
+                        value,
+                    };
+                },
+            };
+        },
+    });
+}

package/dist/mod.d.ts

@@ -0,0 +1,9 @@
+export * from "./batch.ts";
+export * from "./valve.ts";
+export * from "./map.ts";
+export * from "./filter.ts";
+export * from "./tracker.ts";
+export * from "./for-each.ts";
+export * from "./subject.ts";
+export * from "./lines.ts";
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../mod.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/{esm → dist}/mod.js

@@ -4,3 +4,5 @@ export * from "./map.js";
 export * from "./filter.js";
 export * from "./tracker.js";
 export * from "./for-each.js";
+export * from "./subject.js";
+export * from "./lines.js";

package/dist/subject.d.ts

@@ -0,0 +1,38 @@
+import type { Stream } from "effection";
+/**
+ * Converts any stream into a multicast stream that produces latest value
+ * to new subscribers. It's designed to be analagous in function to [RxJS
+ * BehaviorSubject](https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject).
+ *
+ * @returns A function that takes a stream and returns a multicast stream
+ *
+ * @example
+ * ```ts
+ * const subject = createSubject<number>();
+ * const downstream = subject(upstream);
+ *
+ * const sub1 = yield* downstream; // subscribes to upstream
+ * yield* upstream.send(1);
+ * yield* sub1.next(); // { done: false, value: 1 }
+ *
+ * const sub2 = yield* downstream; // late subscriber
+ * yield* sub2.next(); // { done: false, value: 1 } - gets latest value
+ * ```
+ *
+ * Use it with a pipe operator to convert any stream into a behavior subject.
+ *
+ * @example
+ * ```
+ * let source = createChannel<string, void>();
+ * let subject = createSubject<string>();
+ *
+ * let pipeline = pipe([
+ *  top,
+ *  transform1,
+ *  transform2,
+ *  subject,
+ * ]);
+ * ```
+ */
+export declare function createSubject<T>(): <TClose>(stream: Stream<T, TClose>) => Stream<T, TClose>;
+//# sourceMappingURL=subject.d.ts.map

package/dist/subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject.d.ts","sourceRoot":"","sources":["../subject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,WAAW,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,aAAa,CAAC,CAAC,KAAK,CAAC,MAAM,EACzC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KACtB,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CA2BrB"}

package/dist/subject.js

@@ -0,0 +1,60 @@
+/**
+ * Converts any stream into a multicast stream that produces latest value
+ * to new subscribers. It's designed to be analagous in function to [RxJS
+ * BehaviorSubject](https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject).
+ *
+ * @returns A function that takes a stream and returns a multicast stream
+ *
+ * @example
+ * ```ts
+ * const subject = createSubject<number>();
+ * const downstream = subject(upstream);
+ *
+ * const sub1 = yield* downstream; // subscribes to upstream
+ * yield* upstream.send(1);
+ * yield* sub1.next(); // { done: false, value: 1 }
+ *
+ * const sub2 = yield* downstream; // late subscriber
+ * yield* sub2.next(); // { done: false, value: 1 } - gets latest value
+ * ```
+ *
+ * Use it with a pipe operator to convert any stream into a behavior subject.
+ *
+ * @example
+ * ```
+ * let source = createChannel<string, void>();
+ * let subject = createSubject<string>();
+ *
+ * let pipeline = pipe([
+ *  top,
+ *  transform1,
+ *  transform2,
+ *  subject,
+ * ]);
+ * ```
+ */
+export function createSubject() {
+    let current = undefined;
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            let upstream = yield* stream;
+            let iterator = current
+                ? {
+                    *next() {
+                        iterator = upstream;
+                        // biome-ignore lint/style/noNonNullAssertion: current checked in ternary condition
+                        return current;
+                    },
+                }
+                : {
+                    *next() {
+                        current = yield* upstream.next();
+                        return current;
+                    },
+                };
+            return {
+                next: () => iterator.next(),
+            };
+        },
+    });
+}

package/dist/test-helpers/faucet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faucet.d.ts","sourceRoot":"","sources":["../../test-helpers/faucet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAGvE;;GAEG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;IACjD;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAClC;;;OAGG;IACH,IAAI,CACF,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,GAC1D,SAAS,CAAC,IAAI,CAAC,CAAC;IACnB;;OAEG;IACH,IAAI,IAAI,IAAI,CAAC;IACb;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAiB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CA0B1E"}

package/dist/test-helpers.d.ts

@@ -0,0 +1,2 @@
+export * from "./test-helpers/faucet.ts";
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../test-helpers.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}