@effectionx/stream-helpers 0.7.1 → 0.7.3

package/README.md

@@ -165,6 +165,155 @@ function* example() {
 }
 ```
 
+### Drain
+
+The `drain` helper exhausts a stream, discarding all yielded values, and returns
+the close value. This is useful when you only care about the final result of a
+stream, not the intermediate values.
+
+```typescript
+import { drain } from "@effectionx/stream-helpers";
+
+function* example() {
+  // Get the response from a request channel (ignoring any progress)
+  const channel = yield* transport.send(request);
+  const response = yield* drain(channel);
+  console.log(response); // The close value
+}
+```
+
+### First
+
+The `first` helper returns the first value yielded by a stream, or `undefined`
+if the stream closes without yielding any values. Use `first.expect()` to throw
+an error instead of returning `undefined`.
+
+```typescript
+import { first } from "@effectionx/stream-helpers";
+import { streamOf } from "@effectionx/stream-helpers";
+
+function* example() {
+  const stream = streamOf([1, 2, 3]);
+  const value = yield* first(stream);
+  console.log(value); // 1
+
+  const empty = streamOf([]);
+  const none = yield* first(empty);
+  console.log(none); // undefined
+
+  // Use first.expect() to throw if stream is empty
+  const required = yield* first.expect(stream); // throws if empty
+}
+```
+
+### Last
+
+The `last` helper returns the last value yielded by a stream, or `undefined`
+if the stream closes without yielding any values. It exhausts the entire stream
+to find the last value. Use `last.expect()` to throw an error instead of
+returning `undefined`.
+
+```typescript
+import { last } from "@effectionx/stream-helpers";
+import { streamOf } from "@effectionx/stream-helpers";
+
+function* example() {
+  const stream = streamOf([1, 2, 3]);
+  const value = yield* last(stream);
+  console.log(value); // 3
+
+  const empty = streamOf([]);
+  const none = yield* last(empty);
+  console.log(none); // undefined
+
+  // Use last.expect() to throw if stream is empty
+  const required = yield* last.expect(stream); // throws if empty
+}
+```
+
+### Take
+
+The `take` helper creates a stream transformer that yields the first `n` values
+from the source stream, then closes with the last taken value.
+
+```typescript
+import { take, forEach, streamOf } from "@effectionx/stream-helpers";
+import { pipe } from "remeda";
+
+function* example() {
+  const stream = streamOf([1, 2, 3, 4, 5]);
+  // yields 1, 2, then closes with 3
+  const closeValue = yield* forEach(function* (value) {
+    console.log(value); // 1, then 2
+  }, take(3)(stream));
+  console.log(closeValue); // 3
+}
+
+// Works with pipe
+const limited = pipe(source, take(3));
+```
+
+### TakeWhile
+
+The `takeWhile` helper creates a stream transformer that yields values while
+the predicate returns true. When the predicate returns false, the stream closes
+immediately (the failing value is not included).
+
+```typescript
+import { takeWhile, forEach, streamOf } from "@effectionx/stream-helpers";
+import { pipe } from "remeda";
+
+function* example() {
+  const stream = streamOf([1, 2, 3, 4, 5]);
+  // yields 1, 2 (stops when value >= 3)
+  yield* forEach(function* (value) {
+    console.log(value); // 1, then 2
+  }, takeWhile((x) => x < 3)(stream));
+}
+
+// Works with pipe
+const filtered = pipe(source, takeWhile((x) => x.isValid));
+```
+
+### TakeUntil
+
+The `takeUntil` helper creates a stream transformer that yields values until
+the predicate returns true. When the predicate matches, the stream closes with
+the matching value. This is useful for "iterate until a condition is met"
+patterns.
+
+```typescript
+import { takeUntil, forEach } from "@effectionx/stream-helpers";
+import { pipe } from "remeda";
+
+function* example() {
+  // Iterate validation progress until we get a terminal status
+  const result = yield* forEach(
+    function* (progress) {
+      showSpinner(progress.status);
+    },
+    takeUntil((p) => p.status === "valid" || p.status === "invalid")(
+      validationStream,
+    ),
+  );
+
+  // result is the validation object with terminal status
+  if (result.status === "valid") {
+    console.log("Validation passed!");
+  }
+}
+
+// Works with pipe
+const untilDone = pipe(source, takeUntil((x) => x.done));
+```
+
+**Key difference between `takeWhile` and `takeUntil`:**
+
+| Helper      | Yields                  | Closes With    | Use Case                |
+| ----------- | ----------------------- | -------------- | ----------------------- |
+| `takeWhile` | While predicate is true | `undefined`    | "Keep going while good" |
+| `takeUntil` | Until predicate is true | Matching value | "Stop when you find it" |
+
 ### ForEach
 
 The `forEach` helper invokes a function for each item passing through a stream.

package/batch.test.ts

@@ -57,7 +57,7 @@ describe("batch", () => {
       }, stream),
     );
 
-    yield* sleep(1);
+    yield* sleep(0);
 
     yield* faucet.pour(function* (send) {
       for (let i = 1; i <= 10; i++) {
@@ -89,7 +89,7 @@ describe("batch", () => {
       }, stream),
     );
 
-    yield* sleep(1);
+    yield* sleep(0);
 
     yield* faucet.pour([1, 2, 3, 4, 5, 6]);
 

package/batch.ts

@@ -41,7 +41,6 @@ export function batch(
             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();

package/dist/batch.d.ts.map

@@ -1 +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"}
+{"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,CA6E/D"}

package/dist/batch.js

@@ -24,7 +24,6 @@ export function batch(options) {
                         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();

package/dist/drain.d.ts

@@ -0,0 +1,24 @@
+import type { Operation, Stream } from "effection";
+/**
+ * Exhausts a stream, discarding all yielded values, and returns the close value.
+ *
+ * Use this when you only care about the final result of a stream, not the
+ * intermediate values. This is common for request/response patterns where
+ * the response is the close value and there may be no progress events.
+ *
+ * @template T - The type of items in the stream (discarded)
+ * @template TClose - The type of the close value returned when the stream ends
+ * @param stream - The stream to drain
+ * @returns The close value of the stream
+ *
+ * @example
+ * ```typescript
+ * import { drain } from "./drain.ts";
+ *
+ * // Get the response from a request channel (ignoring any progress)
+ * const channel = yield* transport.send(request);
+ * const response = yield* drain(channel);
+ * ```
+ */
+export declare function drain<T, TClose>(stream: Stream<T, TClose>): Operation<TClose>;
+//# sourceMappingURL=drain.d.ts.map

package/dist/drain.d.ts.map

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

package/dist/drain.js

@@ -0,0 +1,33 @@
+/**
+ * Exhausts a stream, discarding all yielded values, and returns the close value.
+ *
+ * Use this when you only care about the final result of a stream, not the
+ * intermediate values. This is common for request/response patterns where
+ * the response is the close value and there may be no progress events.
+ *
+ * @template T - The type of items in the stream (discarded)
+ * @template TClose - The type of the close value returned when the stream ends
+ * @param stream - The stream to drain
+ * @returns The close value of the stream
+ *
+ * @example
+ * ```typescript
+ * import { drain } from "./drain.ts";
+ *
+ * // Get the response from a request channel (ignoring any progress)
+ * const channel = yield* transport.send(request);
+ * const response = yield* drain(channel);
+ * ```
+ */
+export function drain(stream) {
+    return {
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            let result = yield* subscription.next();
+            while (!result.done) {
+                result = yield* subscription.next();
+            }
+            return result.value;
+        },
+    };
+}

package/dist/first.d.ts

@@ -0,0 +1,28 @@
+import type { Operation, Stream } from "effection";
+/**
+ * Returns the first value yielded by a stream, or `undefined` if the stream
+ * closes without yielding any values.
+ *
+ * Use `first.expect()` if you want to throw an error when the stream is empty.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value (unused)
+ * @param stream - The stream to get the first value from
+ * @returns The first value yielded by the stream, or `undefined` if empty
+ *
+ * @example
+ * ```typescript
+ * import { first } from "./first.ts";
+ *
+ * const stream = streamOf([1, 2, 3]);
+ * const value = yield* first(stream); // returns 1
+ *
+ * const empty = streamOf([]);
+ * const value = yield* first(empty); // returns undefined
+ * ```
+ */
+export declare function first<T, TClose>(stream: Stream<T, TClose>): Operation<T | undefined>;
+export declare namespace first {
+    var expect: <T, TClose>(stream: Stream<T, TClose>) => Operation<T>;
+}
+//# sourceMappingURL=first.d.ts.map

package/dist/first.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.d.ts","sourceRoot":"","sources":["../first.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAC7B,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,GACxB,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAW1B;yBAbe,KAAK;iBAoCe,CAAC,EAAE,MAAM,UACnC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KACxB,SAAS,CAAC,CAAC,CAAC"}

package/dist/first.js

@@ -0,0 +1,67 @@
+/**
+ * Returns the first value yielded by a stream, or `undefined` if the stream
+ * closes without yielding any values.
+ *
+ * Use `first.expect()` if you want to throw an error when the stream is empty.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value (unused)
+ * @param stream - The stream to get the first value from
+ * @returns The first value yielded by the stream, or `undefined` if empty
+ *
+ * @example
+ * ```typescript
+ * import { first } from "./first.ts";
+ *
+ * const stream = streamOf([1, 2, 3]);
+ * const value = yield* first(stream); // returns 1
+ *
+ * const empty = streamOf([]);
+ * const value = yield* first(empty); // returns undefined
+ * ```
+ */
+export function first(stream) {
+    return {
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            const result = yield* subscription.next();
+            if (result.done) {
+                return undefined;
+            }
+            return result.value;
+        },
+    };
+}
+/**
+ * Returns the first value yielded by a stream.
+ * Throws an error if the stream closes without yielding any values.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value (unused)
+ * @param stream - The stream to get the first value from
+ * @returns The first value yielded by the stream
+ * @throws Error if the stream closes without yielding any values
+ *
+ * @example
+ * ```typescript
+ * import { first } from "./first.ts";
+ *
+ * const stream = streamOf([1, 2, 3]);
+ * const value = yield* first.expect(stream); // returns 1
+ *
+ * const empty = streamOf([]);
+ * const value = yield* first.expect(empty); // throws Error
+ * ```
+ */
+first.expect = function expectFirst(stream) {
+    return {
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            const result = yield* subscription.next();
+            if (result.done) {
+                throw new Error("Stream closed without yielding any values");
+            }
+            return result.value;
+        },
+    };
+};

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

@@ -1 +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"}
+{"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,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAC/B,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,CAYnB"}

package/dist/for-each.js

@@ -22,12 +22,16 @@
  * yield* stream.send(2);
  * ```
  */
-export function* forEach(fn, stream) {
-    let subscription = yield* stream;
-    let next = yield* subscription.next();
-    while (!next.done) {
-        yield* fn(next.value);
-        next = yield* subscription.next();
-    }
-    return next.value;
+export function forEach(fn, stream) {
+    return {
+        *[Symbol.iterator]() {
+            let subscription = yield* stream;
+            let next = yield* subscription.next();
+            while (!next.done) {
+                yield* fn(next.value);
+                next = yield* subscription.next();
+            }
+            return next.value;
+        },
+    };
 }

package/dist/last.d.ts

@@ -0,0 +1,29 @@
+import type { Operation, Stream } from "effection";
+/**
+ * Returns the last value yielded by a stream, or `undefined` if the stream
+ * closes without yielding any values.
+ *
+ * Exhausts the entire stream to find the last value.
+ * Use `last.expect()` if you want to throw an error when the stream is empty.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value (unused)
+ * @param stream - The stream to get the last value from
+ * @returns The last value yielded by the stream, or `undefined` if empty
+ *
+ * @example
+ * ```typescript
+ * import { last } from "./last.ts";
+ *
+ * const stream = streamOf([1, 2, 3]);
+ * const value = yield* last(stream); // returns 3
+ *
+ * const empty = streamOf([]);
+ * const value = yield* last(empty); // returns undefined
+ * ```
+ */
+export declare function last<T, TClose>(stream: Stream<T, TClose>): Operation<T | undefined>;
+export declare namespace last {
+    var expect: <T, TClose>(stream: Stream<T, TClose>) => Operation<T>;
+}
+//# sourceMappingURL=last.d.ts.map

package/dist/last.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"last.d.ts","sourceRoot":"","sources":["../last.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAC5B,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,GACxB,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAqB1B;yBAvBe,IAAI;iBA+Cc,CAAC,EAAE,MAAM,UACjC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KACxB,SAAS,CAAC,CAAC,CAAC"}

package/dist/last.js

@@ -0,0 +1,81 @@
+/**
+ * Returns the last value yielded by a stream, or `undefined` if the stream
+ * closes without yielding any values.
+ *
+ * Exhausts the entire stream to find the last value.
+ * Use `last.expect()` if you want to throw an error when the stream is empty.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value (unused)
+ * @param stream - The stream to get the last value from
+ * @returns The last value yielded by the stream, or `undefined` if empty
+ *
+ * @example
+ * ```typescript
+ * import { last } from "./last.ts";
+ *
+ * const stream = streamOf([1, 2, 3]);
+ * const value = yield* last(stream); // returns 3
+ *
+ * const empty = streamOf([]);
+ * const value = yield* last(empty); // returns undefined
+ * ```
+ */
+export function last(stream) {
+    return {
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            const first = yield* subscription.next();
+            if (first.done) {
+                return undefined;
+            }
+            let lastValue = first.value;
+            let result = yield* subscription.next();
+            while (!result.done) {
+                lastValue = result.value;
+                result = yield* subscription.next();
+            }
+            return lastValue;
+        },
+    };
+}
+/**
+ * Returns the last value yielded by a stream.
+ * Exhausts the entire stream to find the last value.
+ * Throws an error if the stream closes without yielding any values.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value (unused)
+ * @param stream - The stream to get the last value from
+ * @returns The last value yielded by the stream
+ * @throws Error if the stream closes without yielding any values
+ *
+ * @example
+ * ```typescript
+ * import { last } from "./last.ts";
+ *
+ * const stream = streamOf([1, 2, 3]);
+ * const value = yield* last.expect(stream); // returns 3
+ *
+ * const empty = streamOf([]);
+ * const value = yield* last.expect(empty); // throws Error
+ * ```
+ */
+last.expect = function expectLast(stream) {
+    return {
+        *[Symbol.iterator]() {
+            const subscription = yield* stream;
+            const first = yield* subscription.next();
+            if (first.done) {
+                throw new Error("Stream closed without yielding any values");
+            }
+            let lastValue = first.value;
+            let result = yield* subscription.next();
+            while (!result.done) {
+                lastValue = result.value;
+                result = yield* subscription.next();
+            }
+            return lastValue;
+        },
+    };
+};

package/dist/mod.d.ts

@@ -8,4 +8,10 @@ export * from "./subject.ts";
 export * from "./lines.ts";
 export * from "./stream-of.ts";
 export * from "./reduce.ts";
+export * from "./drain.ts";
+export * from "./first.ts";
+export * from "./last.ts";
+export * from "./take.ts";
+export * from "./take-while.ts";
+export * from "./take-until.ts";
 //# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -1 +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;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}
+{"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;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC"}

package/dist/mod.js

@@ -8,3 +8,9 @@ export * from "./subject.js";
 export * from "./lines.js";
 export * from "./stream-of.js";
 export * from "./reduce.js";
+export * from "./drain.js";
+export * from "./first.js";
+export * from "./last.js";
+export * from "./take.js";
+export * from "./take-while.js";
+export * from "./take-until.js";

package/dist/subject.d.ts.map

@@ -1 +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"}
+{"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,CA0BrB"}

package/dist/subject.js

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

package/dist/take-until.d.ts

@@ -0,0 +1,46 @@
+import type { Stream } from "effection";
+/**
+ * Creates a stream transformer that yields values from the source stream
+ * until the predicate returns true. Closes with the matching value when
+ * the predicate returns true.
+ *
+ * This is useful for "iterate until a condition is met" patterns, where
+ * the matching value is meaningful (e.g., a terminal status).
+ *
+ * If the source stream closes before the predicate returns true, 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 stop taking values
+ * @returns A stream transformer that yields values until predicate is true,
+ *          closing with the matching value
+ *
+ * @example
+ * ```typescript
+ * import { takeUntil, forEach } from "@effectionx/stream-helpers";
+ *
+ * // Iterate validation progress until we get a terminal status
+ * const result = yield* forEach(function*(progress) {
+ *   showSpinner(progress.status);
+ * }, takeUntil((p) => p.status === "valid" || p.status === "invalid")(channel));
+ *
+ * // result is the validation object with terminal status
+ * if (result.status === "valid") {
+ *   // proceed
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { takeUntil, map } from "@effectionx/stream-helpers";
+ * import { pipe } from "remeda";
+ *
+ * const limited = pipe(
+ *   source,
+ *   takeUntil((x) => x.done),
+ * );
+ * ```
+ */
+export declare function takeUntil<T>(predicate: (item: T) => boolean): <TClose>(stream: Stream<T, TClose>) => Stream<T, T | TClose>;
+//# sourceMappingURL=take-until.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-until.d.ts","sourceRoot":"","sources":["../take-until.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;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,CAAC,GAAG,MAAM,CAAC,CA4B9D"}

package/dist/take-until.js

@@ -0,0 +1,68 @@
+/**
+ * Creates a stream transformer that yields values from the source stream
+ * until the predicate returns true. Closes with the matching value when
+ * the predicate returns true.
+ *
+ * This is useful for "iterate until a condition is met" patterns, where
+ * the matching value is meaningful (e.g., a terminal status).
+ *
+ * If the source stream closes before the predicate returns true, 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 stop taking values
+ * @returns A stream transformer that yields values until predicate is true,
+ *          closing with the matching value
+ *
+ * @example
+ * ```typescript
+ * import { takeUntil, forEach } from "@effectionx/stream-helpers";
+ *
+ * // Iterate validation progress until we get a terminal status
+ * const result = yield* forEach(function*(progress) {
+ *   showSpinner(progress.status);
+ * }, takeUntil((p) => p.status === "valid" || p.status === "invalid")(channel));
+ *
+ * // result is the validation object with terminal status
+ * if (result.status === "valid") {
+ *   // proceed
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { takeUntil, map } from "@effectionx/stream-helpers";
+ * import { pipe } from "remeda";
+ *
+ * const limited = pipe(
+ *   source,
+ *   takeUntil((x) => x.done),
+ * );
+ * ```
+ */
+export function takeUntil(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 with the matching value
+                        return { done: true, value: result.value };
+                    }
+                    return result;
+                },
+            };
+        },
+    });
+}