@effectionx/stream-helpers 0.7.1 → 0.7.3

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;
+        },
+      };
+    },
+  });
+}

package/test-helpers/faucet.test.ts

@@ -19,7 +19,7 @@ describe("useFaucet", () => {
     });
 
     yield* spawn(function* () {
-      yield* sleep(1);
+      yield* sleep(0);
       // Pour an array of items
       yield* faucet.pour([1, 2, 3]);
     });
@@ -71,7 +71,7 @@ describe("useFaucet", () => {
 
     // Pour using a generator function
     yield* spawn(function* () {
-      yield* sleep(1);
+      yield* sleep(0);
       yield* faucet.pour(function* (send) {
         yield* send(1);
         yield* sleep(10);
@@ -100,7 +100,7 @@ describe("useFaucet", () => {
 
     // Start pouring with a generator
     yield* spawn(function* () {
-      yield* sleep(1);
+      yield* sleep(0);
       yield* faucet.pour(function* (send) {
         yield* send(1);
         yield* sleep(10);

package/test-helpers/faucet.ts

@@ -1,5 +1,5 @@
-import { createChannel, type Operation, type Stream } from "effection";
 import { createBooleanSignal, is } from "@effectionx/signals";
+import { type Operation, type Stream, createChannel } from "effection";
 
 /**
  * Interface of the stream returned by `useFaucet`.
@@ -80,30 +80,34 @@ export interface FaucetOptions {
  * @param options.open - Whether the faucet is open.
  * @returns stream of items coming from the faucet
  */
-export function* useFaucet<T>(options: FaucetOptions): Operation<Faucet<T>> {
-  let signal = createChannel<T, never>();
-  let open = yield* createBooleanSignal(options.open);
-
+export function useFaucet<T>(options: FaucetOptions): Operation<Faucet<T>> {
   return {
-    [Symbol.iterator]: signal[Symbol.iterator],
-    *pour(items) {
-      if (Array.isArray(items)) {
-        for (let i of items) {
-          yield* is(open, (open) => open);
-          yield* signal.send(i);
-        }
-      } else {
-        yield* items(function* (item) {
-          yield* is(open, (open) => open);
-          yield* signal.send(item);
-        });
-      }
-    },
-    close() {
-      open.set(false);
-    },
-    open() {
-      open.set(true);
+    *[Symbol.iterator]() {
+      let signal = createChannel<T, never>();
+      let open = yield* createBooleanSignal(options.open);
+
+      return {
+        [Symbol.iterator]: signal[Symbol.iterator],
+        *pour(items) {
+          if (Array.isArray(items)) {
+            for (let i of items) {
+              yield* is(open, (open) => open);
+              yield* signal.send(i);
+            }
+          } else {
+            yield* items(function* (item) {
+              yield* is(open, (open) => open);
+              yield* signal.send(item);
+            });
+          }
+        },
+        close() {
+          open.set(false);
+        },
+        open() {
+          open.set(true);
+        },
+      };
     },
   };
 }

package/tracker.test.ts

@@ -33,13 +33,13 @@ describe("tracker", () => {
       }
     });
 
-    yield* sleep(1);
+    yield* sleep(0);
 
     yield* faucet.pour(function* (send) {
       yield* send(1);
-      yield* sleep(1);
+      yield* sleep(0);
       yield* send(2);
-      yield* sleep(1);
+      yield* sleep(0);
       yield* send(3);
     });
 
@@ -75,7 +75,7 @@ describe("tracker", () => {
       }
     });
 
-    yield* sleep(1);
+    yield* sleep(0);
 
     yield* faucet.pour(function* (send) {
       yield* send(1);

package/valve.test.ts

@@ -33,12 +33,12 @@ describe("valve", () => {
     yield* spawn(function* () {
       for (const value of yield* each(stream(faucet))) {
         values.push(value);
-        yield* sleep(1);
+        yield* sleep(0);
         yield* each.next();
       }
     });
 
-    yield* sleep(1);
+    yield* sleep(0);
 
     yield* faucet.pour([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);