@effectionx/stream-helpers 0.6.1 → 0.7.2

package/README.md

@@ -63,6 +63,27 @@ function* example(stream: Stream<number, unknown>) {
 }
 ```
 
+### Reduce
+
+The `reduce` helper transforms each item in a stream by applying it to
+an accumulated value.
+
+```typescript
+import { reduce } from "@effectionx/stream-helpers";
+import { each } from "effection";
+
+function* example(stream: Stream<number, unknown>) {
+  let sum = reduce(function* (total: number, current: number) {
+    return total + current;
+  }, 0);
+
+  for (let value of yield* each(sum(streamOf([1,2,3]))) {
+    console.log(value) // logs 1 -> 3 -> 6
+    yield* each.next();
+  }
+}
+```
+
 ### Batch
 
 The `batch` helper is useful when you want to convert individual items passing
@@ -144,6 +165,72 @@ 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
+}
+```
+
 ### 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/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

@@ -6,4 +6,9 @@ export * from "./tracker.ts";
 export * from "./for-each.ts";
 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";
 //# 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"}
+{"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"}

package/dist/mod.js

@@ -6,3 +6,8 @@ export * from "./tracker.js";
 export * from "./for-each.js";
 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";

package/dist/reduce.d.ts

@@ -0,0 +1,23 @@
+import type { Operation, Stream } from "effection";
+/**
+ * Transforms a stream by taking each item and applying it to an
+ * accumulated value to produce a new accumulated value which is then
+ *  passed downstream.
+ *
+ * @example
+ * ```ts
+ * import { reduce, streamOf } from "@effectionx/stream-helpers";
+ *
+ * const sum = reduce(function*(total: number, item: number) {
+ *   return sum + number;
+ * }, 0);
+ *
+ * sum(streamOf([1,2,3])) //=> yields 1, 3, 6
+ * ```
+ *
+ * @param fn - The operation to apply a single item to the accumulated value
+ * @param initial - The first accumulated value from which all others will descend
+ * @returns A stream transformer that applies the reduction over the lifetime of the stream
+ */
+export declare function reduce<T, TSum>(fn: (current: TSum, item: T) => Operation<TSum>, initial: TSum): <TClose>(stream: Stream<T, TClose>) => Stream<TSum, TClose>;
+//# sourceMappingURL=reduce.d.ts.map

package/dist/reduce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce.d.ts","sourceRoot":"","sources":["../reduce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAC5B,EAAE,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,EAC/C,OAAO,EAAE,IAAI,GACZ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAuB7D"}

package/dist/reduce.js

@@ -0,0 +1,42 @@
+/**
+ * Transforms a stream by taking each item and applying it to an
+ * accumulated value to produce a new accumulated value which is then
+ *  passed downstream.
+ *
+ * @example
+ * ```ts
+ * import { reduce, streamOf } from "@effectionx/stream-helpers";
+ *
+ * const sum = reduce(function*(total: number, item: number) {
+ *   return sum + number;
+ * }, 0);
+ *
+ * sum(streamOf([1,2,3])) //=> yields 1, 3, 6
+ * ```
+ *
+ * @param fn - The operation to apply a single item to the accumulated value
+ * @param initial - The first accumulated value from which all others will descend
+ * @returns A stream transformer that applies the reduction over the lifetime of the stream
+ */
+export function reduce(fn, initial) {
+    return (upstream) => ({
+        *[Symbol.iterator]() {
+            let current = initial;
+            let subscription = yield* upstream;
+            return {
+                *next() {
+                    let next = yield* subscription.next();
+                    while (!next.done) {
+                        let reduction = yield* fn(current, next.value);
+                        if (reduction !== current) {
+                            current = reduction;
+                            return { done: false, value: current };
+                        }
+                        next = yield* subscription.next();
+                    }
+                    return next;
+                },
+            };
+        },
+    });
+}

package/dist/stream-of.d.ts

@@ -0,0 +1,9 @@
+import type { Stream } from "effection";
+/**
+ * Lift a synchronous iterable into a stream context.
+ *
+ * @param iterable - synchronous iterable to present as an Effection `Stream`
+ * @returns a stream that yields the members of the iterable.
+ */
+export declare function streamOf<T, TDone>(iterable: Iterable<T, TDone>): Stream<T, TDone>;
+//# sourceMappingURL=stream-of.d.ts.map

package/dist/stream-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-of.d.ts","sourceRoot":"","sources":["../stream-of.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAC/B,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAC3B,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAWlB"}

package/dist/stream-of.js

@@ -0,0 +1,18 @@
+/**
+ * Lift a synchronous iterable into a stream context.
+ *
+ * @param iterable - synchronous iterable to present as an Effection `Stream`
+ * @returns a stream that yields the members of the iterable.
+ */
+export function streamOf(iterable) {
+    return {
+        *[Symbol.iterator]() {
+            let iterator = iterable[Symbol.iterator]();
+            return {
+                *next() {
+                    return iterator.next();
+                },
+            };
+        },
+    };
+}

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