@effectionx/stream-helpers 0.5.1 → 0.6.0

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

@@ -5,3 +5,4 @@ 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.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/{esm → dist}/subject.js

@@ -42,12 +42,14 @@ export function createSubject() {
                 ? {
                     *next() {
                         iterator = upstream;
+                        // biome-ignore lint/style/noNonNullAssertion: current checked in ternary condition
                         return current;
                     },
                 }
                 : {
                     *next() {
-                        return current = yield* upstream.next();
+                        current = yield* upstream.next();
+                        return current;
                     },
                 };
             return {

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"}

package/dist/tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracker.d.ts","sourceRoot":"","sources":["../tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAY,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAGlE,MAAM,WAAW,OAAQ,SAAQ,SAAS,CAAC,IAAI,CAAC;IAC9C;;;;OAIG;IACH,WAAW,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACjE;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC1C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,SAAS,CAAC,OAAO,CAAC,CA+BlD"}

package/{esm → dist}/tracker.js

@@ -13,20 +13,18 @@ export function createTracker() {
                 yield* is(tracked, (set) => set.size === 0);
             },
             passthrough() {
-                return function (stream) {
-                    return {
-                        *[Symbol.iterator]() {
-                            const subscription = yield* stream;
-                            return {
-                                *next() {
-                                    const next = yield* subscription.next();
-                                    tracked.add(next.value);
-                                    return next;
-                                },
-                            };
-                        },
-                    };
-                };
+                return (stream) => ({
+                    *[Symbol.iterator]() {
+                        const subscription = yield* stream;
+                        return {
+                            *next() {
+                                const next = yield* subscription.next();
+                                tracked.add(next.value);
+                                return next;
+                            },
+                        };
+                    },
+                });
             },
             markOne(item) {
                 tracked.delete(item);