@effectionx/stream-helpers 0.7.2 → 0.7.3

package/take-while.test.ts

@@ -0,0 +1,89 @@
+import { describe, it } from "@effectionx/bdd";
+import { expect } from "expect";
+import { pipe } from "remeda";
+
+import { forEach } from "./for-each.ts";
+import { streamOf } from "./stream-of.ts";
+import { takeWhile } from "./take-while.ts";
+
+describe("takeWhile", () => {
+  it("should yield values while predicate is true", function* () {
+    const values: number[] = [];
+
+    const closeValue = yield* forEach(
+      function* (value) {
+        values.push(value);
+      },
+      takeWhile((x: number) => x < 3)(streamOf([1, 2, 3, 4, 5])),
+    );
+
+    expect(values).toEqual([1, 2]);
+    expect(closeValue).toBe(undefined);
+  });
+
+  it("should return source close value if stream ends before predicate fails", function* () {
+    const values: number[] = [];
+
+    const stream = streamOf(
+      (function* () {
+        yield 1;
+        yield 2;
+        return "early-close";
+      })(),
+    );
+
+    const closeValue = yield* forEach(
+      function* (value) {
+        values.push(value);
+      },
+      takeWhile((x: number) => x < 10)(stream),
+    );
+
+    expect(values).toEqual([1, 2]);
+    expect(closeValue).toBe("early-close");
+  });
+
+  it("should not include the failing value", function* () {
+    const values: number[] = [];
+
+    const closeValue = yield* forEach(
+      function* (value) {
+        values.push(value);
+      },
+      takeWhile((x: number) => x < 50)(streamOf([1, 2, 100, 3])),
+    );
+
+    expect(values).toEqual([1, 2]);
+    expect(closeValue).toBe(undefined);
+  });
+
+  it("should stop immediately if first value fails predicate", function* () {
+    const values: number[] = [];
+
+    const closeValue = yield* forEach(
+      function* (value) {
+        values.push(value);
+      },
+      takeWhile((x: number) => x < 50)(streamOf([100, 1, 2])),
+    );
+
+    expect(values).toEqual([]);
+    expect(closeValue).toBe(undefined);
+  });
+
+  it("should work with pipe", function* () {
+    const values: number[] = [];
+
+    const stream = pipe(
+      streamOf([1, 2, 3, 4, 5]),
+      takeWhile((x) => x < 4),
+    );
+
+    const closeValue = yield* forEach(function* (value) {
+      values.push(value);
+    }, stream);
+
+    expect(values).toEqual([1, 2, 3]);
+    expect(closeValue).toBe(undefined);
+  });
+});

package/take-while.ts

@@ -0,0 +1,74 @@
+import type { Stream } from "effection";
+
+/**
+ * Creates a stream transformer that yields values from the source stream
+ * while the predicate returns true. Closes when the predicate returns false,
+ * without including the failing value.
+ *
+ * When the predicate fails, the stream closes immediately without the failing
+ * value. The close value will be `undefined` since we don't have access to
+ * the source's close value without draining the entire stream.
+ *
+ * If the source stream closes before the predicate returns false, the
+ * resulting stream closes with the source's close value.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value
+ * @param predicate - A function that returns true to continue taking values
+ * @returns A stream transformer that yields values while predicate is true
+ *
+ * @example
+ * ```typescript
+ * import { takeWhile, streamOf } from "@effectionx/stream-helpers";
+ *
+ * const stream = streamOf([1, 2, 3, 4, 5]);
+ * // yields 1, 2 (stops when value >= 3)
+ * const limited = takeWhile((x: number) => x < 3)(stream);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { takeWhile, map } from "@effectionx/stream-helpers";
+ * import { pipe } from "remeda";
+ *
+ * const limited = pipe(
+ *   source,
+ *   map(function* (x) { return x * 2; }),
+ *   takeWhile((x) => x < 100),
+ * );
+ * ```
+ */
+export function takeWhile<T>(
+  predicate: (item: T) => boolean,
+): <TClose>(stream: Stream<T, TClose>) => Stream<T, TClose | undefined> {
+  return <TClose>(
+    stream: Stream<T, TClose>,
+  ): Stream<T, TClose | undefined> => ({
+    *[Symbol.iterator]() {
+      const subscription = yield* stream;
+      let done = false;
+
+      return {
+        *next() {
+          if (done) {
+            return { done: true, value: undefined as TClose | undefined };
+          }
+
+          const result = yield* subscription.next();
+          if (result.done) {
+            return result;
+          }
+
+          if (!predicate(result.value)) {
+            done = true;
+            // Close immediately without the failing value
+            // We return undefined as we don't drain the stream
+            return { done: true, value: undefined as TClose | undefined };
+          }
+
+          return result;
+        },
+      };
+    },
+  });
+}

package/take.test.ts

@@ -0,0 +1,83 @@
+import { describe, it } from "@effectionx/bdd";
+import { expect } from "expect";
+import { pipe } from "remeda";
+
+import { forEach } from "./for-each.ts";
+import { streamOf } from "./stream-of.ts";
+import { take } from "./take.ts";
+
+describe("take", () => {
+  it("should take first n values and close with the nth value", function* () {
+    const values: number[] = [];
+
+    const closeValue = yield* forEach(
+      function* (value) {
+        values.push(value);
+      },
+      take<number>(3)(streamOf([1, 2, 3, 4, 5])),
+    );
+
+    expect(values).toEqual([1, 2]);
+    expect(closeValue).toBe(3);
+  });
+
+  it("should return source close value if stream ends before n values", function* () {
+    const values: number[] = [];
+
+    const stream = streamOf(
+      (function* () {
+        yield 1;
+        yield 2;
+        return "early-close";
+      })(),
+    );
+
+    const closeValue = yield* forEach(function* (value) {
+      values.push(value);
+    }, take<number>(5)(stream));
+
+    expect(values).toEqual([1, 2]);
+    expect(closeValue).toBe("early-close");
+  });
+
+  it("should work with n=1", function* () {
+    const values: number[] = [];
+
+    const closeValue = yield* forEach(
+      function* (value) {
+        values.push(value);
+      },
+      take<number>(1)(streamOf([42, 100])),
+    );
+
+    expect(values).toEqual([]);
+    expect(closeValue).toBe(42);
+  });
+
+  it("should work with n=0", function* () {
+    const values: number[] = [];
+
+    const closeValue = yield* forEach(
+      function* (value) {
+        values.push(value);
+      },
+      take<number>(0)(streamOf([1, 2, 3])),
+    );
+
+    expect(values).toEqual([]);
+    expect(closeValue).toBe(undefined);
+  });
+
+  it("should work with pipe", function* () {
+    const values: number[] = [];
+
+    const stream = pipe(streamOf([1, 2, 3, 4, 5]), take(2));
+
+    const closeValue = yield* forEach(function* (value) {
+      values.push(value);
+    }, stream);
+
+    expect(values).toEqual([1]);
+    expect(closeValue).toBe(2);
+  });
+});

package/take.ts

@@ -0,0 +1,67 @@
+import type { Stream } from "effection";
+
+/**
+ * Creates a stream transformer that yields the first `n` values from the
+ * source stream, then closes with the last taken value.
+ *
+ * If the source stream closes before yielding `n` values, the resulting
+ * stream closes with the source's close value.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value
+ * @param n - The number of values to take
+ * @returns A stream transformer that yields at most `n` values
+ *
+ * @example
+ * ```typescript
+ * import { take, streamOf } from "@effectionx/stream-helpers";
+ *
+ * const stream = streamOf([1, 2, 3, 4, 5]);
+ * // yields 1, 2, then closes with 3
+ * const limited = take(3)(stream);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { take, map } from "@effectionx/stream-helpers";
+ * import { pipe } from "remeda";
+ *
+ * const limited = pipe(
+ *   source,
+ *   map(function* (x) { return x * 2; }),
+ *   take(5),
+ * );
+ * ```
+ */
+export function take<T>(
+  n: number,
+): <TClose>(stream: Stream<T, TClose>) => Stream<T, T | TClose> {
+  return <TClose>(stream: Stream<T, TClose>): Stream<T, T | TClose> => ({
+    *[Symbol.iterator]() {
+      const subscription = yield* stream;
+      let count = 0;
+
+      return {
+        *next() {
+          if (count >= n) {
+            // Should not happen if used correctly, but handle gracefully
+            return { done: true, value: undefined as unknown as T | TClose };
+          }
+
+          const result = yield* subscription.next();
+          if (result.done) {
+            return result;
+          }
+
+          count++;
+          if (count >= n) {
+            // This is the nth value, return it and mark as done
+            return { done: true, value: result.value };
+          }
+
+          return result;
+        },
+      };
+    },
+  });
+}