@effectionx/stream-helpers 0.7.1 → 0.7.3

package/dist/take-while.d.ts

@@ -0,0 +1,41 @@
+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 declare function takeWhile<T>(predicate: (item: T) => boolean): <TClose>(stream: Stream<T, TClose>) => Stream<T, TClose | undefined>;
+//# sourceMappingURL=take-while.d.ts.map

package/dist/take-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.d.ts","sourceRoot":"","sources":["../take-while.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,CA+BtE"}

package/dist/take-while.js

@@ -0,0 +1,64 @@
+/**
+ * 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(predicate) {
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            let done = false;
+            return {
+                *next() {
+                    if (done) {
+                        return { done: true, value: 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 };
+                    }
+                    return result;
+                },
+            };
+        },
+    });
+}

package/dist/take.d.ts

@@ -0,0 +1,36 @@
+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 declare function take<T>(n: number): <TClose>(stream: Stream<T, TClose>) => Stream<T, T | TClose>;
+//# sourceMappingURL=take.d.ts.map

package/dist/take.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../take.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,CAAC,EAAE,MAAM,GACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CA6B9D"}

package/dist/take.js

@@ -0,0 +1,59 @@
+/**
+ * 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(n) {
+    return (stream) => ({
+        *[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 };
+                    }
+                    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/dist/test-helpers/faucet.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"faucet.d.ts","sourceRoot":"","sources":["../../test-helpers/faucet.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM,EAAiB,MAAM,WAAW,CAAC;AAEvE;;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,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CA8BzE"}

package/dist/test-helpers/faucet.js

@@ -1,5 +1,5 @@
-import { createChannel } from "effection";
 import { createBooleanSignal, is } from "@effectionx/signals";
+import { createChannel } from "effection";
 /**
  * Creates a stream that can be used to test the behavior of streams that use backpressure.
  * It's useful in tests where it can be used as a source stream. This function is used to create
@@ -43,30 +43,34 @@ import { createBooleanSignal, is } from "@effectionx/signals";
  * @param options.open - Whether the faucet is open.
  * @returns stream of items coming from the faucet
  */
-export function* useFaucet(options) {
-    let signal = createChannel();
-    let open = yield* createBooleanSignal(options.open);
+export function useFaucet(options) {
     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();
+            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);
+                },
+            };
         },
     };
 }