iter-fest 0.1.1-main.e1f1fd3 → 0.1.1-main.edf2470

package/README.md

@@ -16,22 +16,38 @@ Iterables can contains infinite number of items, please use this package respons
 npm install iter-fest
 ```
 
+### `Array.prototype` ports
+
+We ported majority of functions from `Array.prototype.*` to `iterable*`.
+
+```ts
+import { iterableIncludes, iterableReduce } from 'iter-fest'; // Via default exports.
+import { iterableSome } from 'iter-fest/iterableSome'; // Via named exports.
+
+const iterable: Iterable<number> = [1, 2, 3, 4, 5].values();
+
+console.log(iterableIncludes(iterable, 3)); // Prints "true".
+console.log(iterableReduce(iterable, (sum, value) => sum + value, 0)); // Prints "15".
+console.log(iterableSome(iterable, value => value % 2)); // Prints "true".
+```
+
+List of ported functions: [`at`](https://tc39.es/ecma262/#sec-array.prototype.at), [`concat`](https://tc39.es/ecma262/#sec-array.prototype.concat), [`entries`](https://tc39.es/ecma262/#sec-array.prototype.entries), [`every`](https://tc39.es/ecma262/#sec-array.prototype.every), [`filter`](https://tc39.es/ecma262/#sec-array.prototype.filter), [`find`](https://tc39.es/ecma262/#sec-array.prototype.find), [`findIndex`](https://tc39.es/ecma262/#sec-array.prototype.findindex), [`findLast`](https://tc39.es/ecma262/#sec-array.prototype.findlast), [`findLastIndex`](https://tc39.es/ecma262/#sec-array.prototype.findlastindex), [`forEach`](https://tc39.es/ecma262/#sec-array.prototype.foreach), [`includes`](https://tc39.es/ecma262/#sec-array.prototype.includes), [`indexOf`](https://tc39.es/ecma262/#sec-array.prototype.indexof), [`join`](https://tc39.es/ecma262/#sec-array.prototype.join), [`keys`](https://tc39.es/ecma262/#sec-array.prototype.keys), [`map`](https://tc39.es/ecma262/#sec-array.prototype.map), [`reduce`](https://tc39.es/ecma262/#sec-array.prototype.reduce), [`slice`](https://tc39.es/ecma262/#sec-array.prototype.slice), [`some`](https://tc39.es/ecma262/#sec-array.prototype.some), [`toSpliced`](https://tc39.es/ecma262/#sec-array.prototype.tospliced), and [`toString`](https://tc39.es/ecma262/#sec-array.prototype.tostring).
+
 ## Conversions
 
-| From                          | To                      | Function signature                                                                                                                                         |
-| ----------------------------- | ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Iterator`                    | `IterableIterator`      | [`iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T>`](#converting-an-iterator-to-iterable)                                                 |
-| `AsyncIterator`               | `AsyncIterableIterator` | [`asyncIteratorToAsyncIterable<T>(asyncIterator: AsyncIterator<T>): AsyncIterableIterator<T>`](#converting-an-iterator-to-iterable)                        |
-| `Observable`                  | `ReadableStream`        | [`observableSubscribeAsReadable<T>(observable: Observable<T>): ReadableStream<T>`](#converting-an-observable-to-readablestream)                            |
-| `ReadableStreamDefaultReader` | `AsyncIterableIterator` | [`readerValues`<T>(reader: ReadableStreamDefaultReader<T>): AsyncIterableIterator<T>`](#converting-a-readablestreamdefaultreader-to-asynciterableiterator) |
-| `AsyncIterable`               | `Observable`            | [`observableFromAsync<T>(iterable: AsyncIterable<T>): Observable<T>`](#converting-an-asynciterable-to-observable)                                          |
-| `AsyncIterable`/`Iterable`    | `ReadableStream`        | [`readableStreamFrom<T>(anyIterable: AsyncIterable<T> \| Iterable<T>): ReadableStream<T>`](#converting-an-asynciterableiterable-to-readablestream)         |
+| From                          | To                      | Function signature                                                                                                                               |
+| ----------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `Iterator`                    | `IterableIterator`      | [`iteratorToIterable<T>(iterator: Iterator<T>): IterableIterator<T>`](#converting-an-iterator-to-iterable)                                       |
+| `Observable`                  | `ReadableStream`        | [`observableSubscribeAsReadable<T>(observable: Observable<T>): ReadableStream<T>`](#converting-an-observable-to-readablestream)                  |
+| `ReadableStreamDefaultReader` | `AsyncIterableIterator` | [`readerValues`<T>(reader: ReadableStreamDefaultReader<T>): AsyncIterableIterator<T>`](#iterating-readablestreamdefaultreader)                   |
+| `AsyncIterable`               | `Observable`            | [`observableFromAsync<T>(iterable: AsyncIterable<T>): Observable<T>`](#converting-an-asynciterable-to-observable)                                |
+| `AsyncIterable`/`Iterable`    | `ReadableStream`        | [`iterableGetReadable<T>(iterable: AsyncIterable<T> \| Iterable<T>): ReadableStream<T>`](#converting-an-asynciterableiterable-to-readablestream) |
 
 To convert `Observable` to `AsyncIterableIterator`, [use `ReadableStream` as intermediate format](#converting-an-observable-to-asynciterableiterator).
 
 ### Converting an iterator to iterable
 
-`iteratorToIterable` and `asyncIteratorToAsyncIterable` enable a [pure iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator) to be iterable using a for-loop statement.
+`iteratorToIterable` enable a [pure iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator) to be iterable using a for-loop statement.
 
 ```ts
 const iterate = (): Iterator<number> => {
@@ -43,7 +59,7 @@ const iterate = (): Iterator<number> => {
         return { value };
       }
 
-      return { done: true, value: undefined } satisfies IteratorResult<number>;
+      return { done: true, value: undefined };
     }
   };
 };
@@ -53,31 +69,28 @@ for (const value of iteratorToIterable(iterate())) {
 }
 ```
 
-Note: calling `[Symbol.iterator]()` or `[Symbol.asyncIterator]()` will not restart the iteration. This is because iterator is an instance of iteration and is not restartable.
+Note: calling `[Symbol.iterator]` will not refresh the iteration.
 
 ### Converting an `Observable` to `AsyncIterableIterator`
 
-`ReadableStream` can be used as an intermediate format when converting an `Observable` to `AsyncIterableIterator`.
+`ReadableStream` can be used to when converting an `Observable` to `AsyncIterableIterator`.
 
 Note: `Observable` is push-based and it does not support flow control. When converting to `AsyncIterableIteratorrr`, the internal buffer of `ReadableStream` could build up quickly.
 
 ```ts
 const observable = Observable.from([1, 2, 3]);
 const readable = observableSubscribeAsReadable(observable);
-const iterable = readerValues(readable.getReader());
 
-for await (const value of iterable) {
+for await (const value of readerValues(readable.getReader())) {
   console.log(value); // Prints "1", "2", "3".
 }
 ```
 
-Note: calling `[Symbol.asyncIterator]()` will not resubscribe and read from the start of the observable. This is because the intermediate format does not support restart.
-
 ### Converting an `AsyncIterable` to `Observable`
 
 `Observable.from` converts `Iterable` into `Observable`. However, it does not convert `AsyncIterable`.
 
-`observableFromAsync` will convert `AsyncIterable` into `Observable`. It will try to restart the iteration by calling `[Symbol.asyncIterator]()`.
+`observableFromAsync` will convert `AsyncIterable` into `Observable`.
 
 ```ts
 async function* generate() {
@@ -92,11 +105,7 @@ const next = value => console.log(value);
 observable.subscribe({ next }); // Prints "1", "2", "3".
 ```
 
-Note: `observableFromAsync` will call `[Symbol.asyncIterator]()` initially to restart the iteration where possible.
-
-Note: It is not recommended to convert `AsyncGenerator` to an `Observable`. `AsyncGenerator` has more functionalities and `Observable` does not support many of them.
-
-### Converting an `Observable` to `ReadableStream`
+## Converting an `Observable` to `ReadableStream`
 
 `ReadableStream` is powerful for transforming and piping stream of data. It can be formed using data from both push-based and pull-based source with backpressuree.
 
@@ -105,11 +114,12 @@ Note: `Observable` is push-based and it does not support flow control. When conv
 ```ts
 const observable = Observable.from([1, 2, 3]);
 const readable = observableSubscribeAsReadable(observable);
+const reader = readable.getReader();
 
 readable.pipeTo(stream.writable); // Will write 1, 2, 3.
 ```
 
-### Converting a `ReadableStreamDefaultReader` to `AsyncIterableIterator`
+### Iterating `ReadableStreamDefaultReader`
 
 `readerValues` will convert default reader of `ReadableStream` into an `AsyncIterableIterator` to use in for-loop.
 
@@ -125,28 +135,20 @@ const readableStream = new ReadableStream({
   }
 });
 
-const iterable = readerValues(readableStream.getReader());
-
-for await (const value of iterable) {
+for await (const value of readerValues(readableStream.getReader())) {
   console.log(value); // Prints "1", "2", "3".
 }
 ```
 
-Note: `[Symbol.asyncIterator]()` will not restart the reader and read from start of the stream. Reader is not restartable and streams are not seekable.
-
-### Converting an `AsyncIterable`/`Iterable` to `ReadableStream`
-
-> Notes: this feature is part of [Streams Standard](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static).
+## Converting an `AsyncIterable`/`Iterable` to `ReadableStream`
 
 ```ts
 const iterable = [1, 2, 3].values();
-const readable = readableStreamFrom(iterable);
+const readable = iterableGetReadable(iterable);
 
 readable.pipeTo(stream.writable); // Will write 1, 2, 3.
 ```
 
-Note: `readableStreamFrom()` will call `[Symbol.iterator]()` initially to restart the iteration where possible.
-
 ## Others
 
 ### Typed `Observable`
@@ -155,18 +157,14 @@ Note: `readableStreamFrom()` will call `[Symbol.iterator]()` initially to restar
 
 ### Producer-consumer queue
 
-`IterableWritableStream` is a push-based producer-consumer queue designed to decouple the flow between a producer and multiple consumers. The producer can push a new job at anytime. The consumer can pull a job at its own convenience via for-loop.
-
-`IterableWritableStream` supports multiple consumers and continuation:
+`PushAsyncIterableIterator` is a simple push-based producer-consumer queue and designed to decouple the flow between a producer and consumer. The producer can push a new job at anytime. The consumer can pull a job at its own convenience.
 
-- Multiple consumers: when 2 or more consumers are active at the same time, jobs will be distributed across all consumers in a round robin fashion when possible
-- Continuation: when the last consumer disconnected while producer keep pushing new jobs, the next consumer will pick up where the last consumer left
+Compare to pull-based queue, a push-based queue is easier to use. However, pull-based queue offers better flow control as it will produce a job only if there is a consumer ready to consume.
 
-Compare to pull-based queue, a push-based queue is easy to use. However, pull-based queue offers better flow control as it will produce a job only if there is a consumer ready to consume.
+For a full-featured producer-consumer queue that supports flow control, use `ReadableStream` instead.
 
 ```ts
-const iterable = new IterableWritableStream();
-const writer = iterable.getWriter();
+const iterable = new PushAsyncIterableIterator();
 
 (async function consumer() {
   for await (const value of iterable) {
@@ -177,10 +175,10 @@ const writer = iterable.getWriter();
 })();
 
 (async function producer() {
-  writer.write(1);
-  writer.write(2);
-  writer.write(3);
-  writer.close();
+  iterable.push(1);
+  iterable.push(2);
+  iterable.push(3);
+  iterable.close();
 })();
 
 // Prints "1", "2", "3", "Done".
@@ -197,11 +195,11 @@ The `generatorWithLastValue()` and `asyncGeneratorWithLastValue()` helps bridge
 ```ts
 const generator = generatorWithLastValue(
   (function* () {
-    yield 1; // { done: false, value: 1 }
-    yield 2; // { done: false, value: 2 }
-    yield 3; // { done: false, value: 3 }
+    yield 1;
+    yield 2;
+    yield 3;
 
-    return 'end'; // { done: true, value: 'end' }
+    return 'end';
   })()
 );
 
@@ -224,23 +222,6 @@ const generator = generatorWithLastValue(
 );
 ```
 
-## `Array.prototype` ports
-
-We ported majority of functions from `Array.prototype.*` to `iterable*`.
-
-```ts
-import { iterableIncludes, iterableReduce } from 'iter-fest'; // Via default exports.
-import { iterableSome } from 'iter-fest/iterableSome'; // Via named exports.
-
-const iterable: Iterable<number> = [1, 2, 3, 4, 5].values();
-
-console.log(iterableIncludes(iterable, 3)); // Prints "true".
-console.log(iterableReduce(iterable, (sum, value) => sum + value, 0)); // Prints "15".
-console.log(iterableSome(iterable, value => value % 2)); // Prints "true".
-```
-
-List of ported functions: [`at`](https://tc39.es/ecma262/#sec-array.prototype.at), [`concat`](https://tc39.es/ecma262/#sec-array.prototype.concat), [`entries`](https://tc39.es/ecma262/#sec-array.prototype.entries), [`every`](https://tc39.es/ecma262/#sec-array.prototype.every), [`filter`](https://tc39.es/ecma262/#sec-array.prototype.filter), [`find`](https://tc39.es/ecma262/#sec-array.prototype.find), [`findIndex`](https://tc39.es/ecma262/#sec-array.prototype.findindex), [`findLast`](https://tc39.es/ecma262/#sec-array.prototype.findlast), [`findLastIndex`](https://tc39.es/ecma262/#sec-array.prototype.findlastindex), [`forEach`](https://tc39.es/ecma262/#sec-array.prototype.foreach), [`includes`](https://tc39.es/ecma262/#sec-array.prototype.includes), [`indexOf`](https://tc39.es/ecma262/#sec-array.prototype.indexof), [`join`](https://tc39.es/ecma262/#sec-array.prototype.join), [`keys`](https://tc39.es/ecma262/#sec-array.prototype.keys), [`map`](https://tc39.es/ecma262/#sec-array.prototype.map), [`reduce`](https://tc39.es/ecma262/#sec-array.prototype.reduce), [`slice`](https://tc39.es/ecma262/#sec-array.prototype.slice), [`some`](https://tc39.es/ecma262/#sec-array.prototype.some), [`toSpliced`](https://tc39.es/ecma262/#sec-array.prototype.tospliced), and [`toString`](https://tc39.es/ecma262/#sec-array.prototype.tostring).
-
 ## Behaviors
 
 ### How this compares to the TC39 proposals?
@@ -289,21 +270,18 @@ Generator has more functionalities than iterator and array. It is not recommende
 - Generator can define the return value
   - `return { done: true, value: 'the very last value' }`
   - Iterating generator using for-loop will not get any values from `{ done: true }`
-  - The `generatorWithLastValue()` will help capturing and retrieving the last return value
 - Generator can receive feedback values from its iterator
   - `generator.next('something')`, the feedback can be assigned to variable via `const feedback = yield;`
   - For-loop cannot send feedbacks to generator
 
 ### When should I use `Iterable`, `IterableIterator` and `Iterator`?
 
-For best compatibility, you should generally follow this API signature: use `Iterable` for inputs, and use `IterableIterator` for outputs. You should avoid exporting pure `Iterator`. Sample function signature should looks below.
+For best compatibility, you should generally follow this API signature: use `Iterable` for inputs, and use `IterableIterator` for outputs. You should avoid exporting pure `Iterator`.
 
 ```ts
-function myFunction<T>(input: Iterable<T>): IterableIterator<T>;
+function transform<T>(iterable: Iterable<T>): IterableIterator<T>;
 ```
 
-`IterableIterator` may opt to support restarting the iteration through `[Symbol.iterator]()`. When consuming an `IterableIterator`, you should call `[Symbol.iterator]()` to obtain a fresh iteration or use for-loop statement if possible. However, `[Symbol.iterator]()` is an opt-in feature and does not always guarantee a fresh iteration.
-
 ### What is on the roadmap?
 
 We are planning to bring iterables and its siblings together, including:

package/dist/{chunk-YJSIVBF7.mjs → chunk-MOBXUTO5.mjs}

@@ -1,9 +1,9 @@
-// src/readableStreamFrom.ts
+// src/iterableGetReadable.ts
 function isIterable(iterable) {
   return !!(iterable && typeof iterable === "object" && Symbol.iterator in iterable);
 }
-function readableStreamFrom(anyIterable) {
-  const iterator = isIterable(anyIterable) ? anyIterable[Symbol.iterator]() : anyIterable[Symbol.asyncIterator]();
+function iterableGetReadable(iterable) {
+  const iterator = isIterable(iterable) ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
   return new ReadableStream({
     async pull(controller) {
       const result = await iterator.next();
@@ -17,6 +17,6 @@ function readableStreamFrom(anyIterable) {
 }
 
 export {
-  readableStreamFrom
+  iterableGetReadable
 };
-//# sourceMappingURL=chunk-YJSIVBF7.mjs.map
+//# sourceMappingURL=chunk-MOBXUTO5.mjs.map

package/dist/chunk-MOBXUTO5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableGetReadable.ts"],"sourcesContent":["function isIterable(iterable: unknown): iterable is Iterable<unknown> {\n  return !!(iterable && typeof iterable === 'object' && Symbol.iterator in iterable);\n}\n\nexport function iterableGetReadable<T>(iterable: AsyncIterable<T> | Iterable<T>): ReadableStream<T> {\n  const iterator = isIterable(iterable) ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();\n\n  return new ReadableStream({\n    async pull(controller) {\n      const result = await iterator.next();\n\n      if (result.done) {\n        controller.close();\n      } else {\n        controller.enqueue(result.value);\n      }\n    }\n  });\n}\n"],"mappings":";AAAA,SAAS,WAAW,UAAkD;AACpE,SAAO,CAAC,EAAE,YAAY,OAAO,aAAa,YAAY,OAAO,YAAY;AAC3E;AAEO,SAAS,oBAAuB,UAA6D;AAClG,QAAM,WAAW,WAAW,QAAQ,IAAI,SAAS,OAAO,QAAQ,EAAE,IAAI,SAAS,OAAO,aAAa,EAAE;AAErG,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,KAAK,YAAY;AACrB,YAAM,SAAS,MAAM,SAAS,KAAK;AAEnC,UAAI,OAAO,MAAM;AACf,mBAAW,MAAM;AAAA,MACnB,OAAO;AACL,mBAAW,QAAQ,OAAO,KAAK;AAAA,MACjC;AAAA,IACF;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-O5SQJUKB.mjs

@@ -0,0 +1,37 @@
+// src/private/withResolvers.ts
+import coreJSPromiseWithResolvers from "core-js-pure/full/promise/with-resolvers";
+function withResolvers() {
+  return coreJSPromiseWithResolvers();
+}
+
+// src/PushAsyncIterableIterator.ts
+var CLOSE = Symbol("close");
+var PushAsyncIterableIterator = class {
+  #closed = false;
+  #pushResolvers = withResolvers();
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  close() {
+    this.#closed = true;
+    this.#pushResolvers.resolve(CLOSE);
+  }
+  async next() {
+    const value = await this.#pushResolvers.promise;
+    if (value === CLOSE) {
+      return { done: true, value: void 0 };
+    }
+    return { done: false, value };
+  }
+  push(value) {
+    if (!this.#closed) {
+      this.#pushResolvers.resolve(value);
+      this.#pushResolvers = withResolvers();
+    }
+  }
+};
+
+export {
+  PushAsyncIterableIterator
+};
+//# sourceMappingURL=chunk-O5SQJUKB.mjs.map

package/dist/chunk-O5SQJUKB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/private/withResolvers.ts","../src/PushAsyncIterableIterator.ts"],"sourcesContent":["// @ts-expect-error \"core-js\" is not typed.\nimport coreJSPromiseWithResolvers from 'core-js-pure/full/promise/with-resolvers';\n\nexport default function withResolvers<T>(): PromiseWithResolvers<T> {\n  return coreJSPromiseWithResolvers();\n}\n","import withResolvers from './private/withResolvers';\n\nconst CLOSE = Symbol('close');\n\nexport class PushAsyncIterableIterator<T> implements AsyncIterableIterator<T> {\n  #closed: boolean = false;\n  #pushResolvers: PromiseWithResolvers<T | typeof CLOSE> = withResolvers();\n\n  [Symbol.asyncIterator]() {\n    return this;\n  }\n\n  close() {\n    this.#closed = true;\n    this.#pushResolvers.resolve(CLOSE);\n  }\n\n  async next(): Promise<IteratorResult<T>> {\n    const value = await this.#pushResolvers.promise;\n\n    if (value === CLOSE) {\n      return { done: true, value: undefined };\n    }\n\n    return { done: false, value };\n  }\n\n  push(value: T) {\n    if (!this.#closed) {\n      this.#pushResolvers.resolve(value);\n      this.#pushResolvers = withResolvers();\n    }\n  }\n}\n"],"mappings":";AACA,OAAO,gCAAgC;AAExB,SAAR,gBAA6D;AAClE,SAAO,2BAA2B;AACpC;;;ACHA,IAAM,QAAQ,OAAO,OAAO;AAErB,IAAM,4BAAN,MAAuE;AAAA,EAC5E,UAAmB;AAAA,EACnB,iBAAyD,cAAc;AAAA,EAEvE,CAAC,OAAO,aAAa,IAAI;AACvB,WAAO;AAAA,EACT;AAAA,EAEA,QAAQ;AACN,SAAK,UAAU;AACf,SAAK,eAAe,QAAQ,KAAK;AAAA,EACnC;AAAA,EAEA,MAAM,OAAmC;AACvC,UAAM,QAAQ,MAAM,KAAK,eAAe;AAExC,QAAI,UAAU,OAAO;AACnB,aAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,IACxC;AAEA,WAAO,EAAE,MAAM,OAAO,MAAM;AAAA,EAC9B;AAAA,EAEA,KAAK,OAAU;AACb,QAAI,CAAC,KAAK,SAAS;AACjB,WAAK,eAAe,QAAQ,KAAK;AACjC,WAAK,iBAAiB,cAAc;AAAA,IACtC;AAAA,EACF;AACF;","names":[]}

package/dist/iter-fest.d.mts

@@ -1,7 +1,7 @@
 export { CompleteFunction, ErrorFunction, NextFunction, Observable, Observer, StartFunction, SubscriberFunction, Subscription, SubscriptionObserver } from './iter-fest.observable.mjs';
+export { PushAsyncIterableIterator } from './iter-fest.pushAsyncIterableIterator.mjs';
 export { SymbolObservable } from './iter-fest.symbolObservable.mjs';
 export { AsyncGeneratorWithLastValue, asyncGeneratorWithLastValue } from './iter-fest.asyncGeneratorWithLastValue.mjs';
-export { asyncIteratorToAsyncIterable } from './iter-fest.asyncIteratorToAsyncIterable.mjs';
 export { GeneratorWithLastValue, generatorWithLastValue } from './iter-fest.generatorWithLastValue.mjs';
 export { iterableAt } from './iter-fest.iterableAt.mjs';
 export { iterableConcat } from './iter-fest.iterableConcat.mjs';
@@ -13,6 +13,7 @@ export { iterableFindIndex } from './iter-fest.iterableFindIndex.mjs';
 export { iterableFindLast } from './iter-fest.iterableFindLast.mjs';
 export { iterableFindLastIndex } from './iter-fest.iterableFindLastIndex.mjs';
 export { iterableForEach } from './iter-fest.iterableForEach.mjs';
+export { iterableGetReadable } from './iter-fest.iterableGetReadable.mjs';
 export { iterableIncludes } from './iter-fest.iterableIncludes.mjs';
 export { iterableIndexOf } from './iter-fest.iterableIndexOf.mjs';
 export { iterableJoin } from './iter-fest.iterableJoin.mjs';
@@ -23,10 +24,8 @@ export { iterableSlice } from './iter-fest.iterableSlice.mjs';
 export { iterableSome } from './iter-fest.iterableSome.mjs';
 export { iterableToSpliced } from './iter-fest.iterableToSpliced.mjs';
 export { iterableToString } from './iter-fest.iterableToString.mjs';
-export { IterableWritableStream } from './iter-fest.iterableWritableStream.mjs';
 export { iteratorToIterable } from './iter-fest.iteratorToIterable.mjs';
 export { observableFromAsync } from './iter-fest.observableFromAsync.mjs';
 export { observableSubscribeAsReadable } from './iter-fest.observableSubscribeAsReadable.mjs';
-export { readableStreamFrom } from './iter-fest.readableStreamFrom.mjs';
 export { readerValues } from './iter-fest.readerValues.mjs';
 import 'core-js-pure/full/observable';

package/dist/iter-fest.d.ts

@@ -1,7 +1,7 @@
 export { CompleteFunction, ErrorFunction, NextFunction, Observable, Observer, StartFunction, SubscriberFunction, Subscription, SubscriptionObserver } from './iter-fest.observable.js';
+export { PushAsyncIterableIterator } from './iter-fest.pushAsyncIterableIterator.js';
 export { SymbolObservable } from './iter-fest.symbolObservable.js';
 export { AsyncGeneratorWithLastValue, asyncGeneratorWithLastValue } from './iter-fest.asyncGeneratorWithLastValue.js';
-export { asyncIteratorToAsyncIterable } from './iter-fest.asyncIteratorToAsyncIterable.js';
 export { GeneratorWithLastValue, generatorWithLastValue } from './iter-fest.generatorWithLastValue.js';
 export { iterableAt } from './iter-fest.iterableAt.js';
 export { iterableConcat } from './iter-fest.iterableConcat.js';
@@ -13,6 +13,7 @@ export { iterableFindIndex } from './iter-fest.iterableFindIndex.js';
 export { iterableFindLast } from './iter-fest.iterableFindLast.js';
 export { iterableFindLastIndex } from './iter-fest.iterableFindLastIndex.js';
 export { iterableForEach } from './iter-fest.iterableForEach.js';
+export { iterableGetReadable } from './iter-fest.iterableGetReadable.js';
 export { iterableIncludes } from './iter-fest.iterableIncludes.js';
 export { iterableIndexOf } from './iter-fest.iterableIndexOf.js';
 export { iterableJoin } from './iter-fest.iterableJoin.js';
@@ -23,10 +24,8 @@ export { iterableSlice } from './iter-fest.iterableSlice.js';
 export { iterableSome } from './iter-fest.iterableSome.js';
 export { iterableToSpliced } from './iter-fest.iterableToSpliced.js';
 export { iterableToString } from './iter-fest.iterableToString.js';
-export { IterableWritableStream } from './iter-fest.iterableWritableStream.js';
 export { iteratorToIterable } from './iter-fest.iteratorToIterable.js';
 export { observableFromAsync } from './iter-fest.observableFromAsync.js';
 export { observableSubscribeAsReadable } from './iter-fest.observableSubscribeAsReadable.js';
-export { readableStreamFrom } from './iter-fest.readableStreamFrom.js';
 export { readerValues } from './iter-fest.readerValues.js';
 import 'core-js-pure/full/observable';

package/dist/iter-fest.iterableGetReadable.d.mts

@@ -0,0 +1,3 @@
+declare function iterableGetReadable<T>(iterable: AsyncIterable<T> | Iterable<T>): ReadableStream<T>;
+
+export { iterableGetReadable };

package/dist/iter-fest.iterableGetReadable.d.ts

@@ -0,0 +1,3 @@
+declare function iterableGetReadable<T>(iterable: AsyncIterable<T> | Iterable<T>): ReadableStream<T>;
+
+export { iterableGetReadable };

package/dist/{iter-fest.readableStreamFrom.js → iter-fest.iterableGetReadable.js}

@@ -17,17 +17,17 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/readableStreamFrom.ts
-var readableStreamFrom_exports = {};
-__export(readableStreamFrom_exports, {
-  readableStreamFrom: () => readableStreamFrom
+// src/iterableGetReadable.ts
+var iterableGetReadable_exports = {};
+__export(iterableGetReadable_exports, {
+  iterableGetReadable: () => iterableGetReadable
 });
-module.exports = __toCommonJS(readableStreamFrom_exports);
+module.exports = __toCommonJS(iterableGetReadable_exports);
 function isIterable(iterable) {
   return !!(iterable && typeof iterable === "object" && Symbol.iterator in iterable);
 }
-function readableStreamFrom(anyIterable) {
-  const iterator = isIterable(anyIterable) ? anyIterable[Symbol.iterator]() : anyIterable[Symbol.asyncIterator]();
+function iterableGetReadable(iterable) {
+  const iterator = isIterable(iterable) ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
   return new ReadableStream({
     async pull(controller) {
       const result = await iterator.next();
@@ -41,6 +41,6 @@ function readableStreamFrom(anyIterable) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  readableStreamFrom
+  iterableGetReadable
 });
-//# sourceMappingURL=iter-fest.readableStreamFrom.js.map
+//# sourceMappingURL=iter-fest.iterableGetReadable.js.map

package/dist/iter-fest.iterableGetReadable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/iterableGetReadable.ts"],"sourcesContent":["function isIterable(iterable: unknown): iterable is Iterable<unknown> {\n  return !!(iterable && typeof iterable === 'object' && Symbol.iterator in iterable);\n}\n\nexport function iterableGetReadable<T>(iterable: AsyncIterable<T> | Iterable<T>): ReadableStream<T> {\n  const iterator = isIterable(iterable) ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();\n\n  return new ReadableStream({\n    async pull(controller) {\n      const result = await iterator.next();\n\n      if (result.done) {\n        controller.close();\n      } else {\n        controller.enqueue(result.value);\n      }\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAAS,WAAW,UAAkD;AACpE,SAAO,CAAC,EAAE,YAAY,OAAO,aAAa,YAAY,OAAO,YAAY;AAC3E;AAEO,SAAS,oBAAuB,UAA6D;AAClG,QAAM,WAAW,WAAW,QAAQ,IAAI,SAAS,OAAO,QAAQ,EAAE,IAAI,SAAS,OAAO,aAAa,EAAE;AAErG,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,KAAK,YAAY;AACrB,YAAM,SAAS,MAAM,SAAS,KAAK;AAEnC,UAAI,OAAO,MAAM;AACf,mBAAW,MAAM;AAAA,MACnB,OAAO;AACL,mBAAW,QAAQ,OAAO,KAAK;AAAA,MACjC;AAAA,IACF;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/iter-fest.iterableGetReadable.mjs

@@ -0,0 +1,7 @@
+import {
+  iterableGetReadable
+} from "./chunk-MOBXUTO5.mjs";
+export {
+  iterableGetReadable
+};
+//# sourceMappingURL=iter-fest.iterableGetReadable.mjs.map

package/dist/iter-fest.js

@@ -30,11 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  IterableWritableStream: () => IterableWritableStream,
   Observable: () => Observable,
+  PushAsyncIterableIterator: () => PushAsyncIterableIterator,
   SymbolObservable: () => SymbolObservable,
   asyncGeneratorWithLastValue: () => asyncGeneratorWithLastValue,
-  asyncIteratorToAsyncIterable: () => asyncIteratorToAsyncIterable,
   generatorWithLastValue: () => generatorWithLastValue,
   iterableAt: () => iterableAt,
   iterableConcat: () => iterableConcat,
@@ -46,6 +45,7 @@ __export(src_exports, {
   iterableFindLast: () => iterableFindLast,
   iterableFindLastIndex: () => iterableFindLastIndex,
   iterableForEach: () => iterableForEach,
+  iterableGetReadable: () => iterableGetReadable,
   iterableIncludes: () => iterableIncludes,
   iterableIndexOf: () => iterableIndexOf,
   iterableJoin: () => iterableJoin,
@@ -59,7 +59,6 @@ __export(src_exports, {
   iteratorToIterable: () => iteratorToIterable,
   observableFromAsync: () => observableFromAsync,
   observableSubscribeAsReadable: () => observableSubscribeAsReadable,
-  readableStreamFrom: () => readableStreamFrom,
   readerValues: () => readerValues
 });
 module.exports = __toCommonJS(src_exports);
@@ -92,6 +91,39 @@ var Observable = class extends import_observable2.default {
   }
 };
 
+// src/private/withResolvers.ts
+var import_with_resolvers = __toESM(require("core-js-pure/full/promise/with-resolvers"));
+function withResolvers() {
+  return (0, import_with_resolvers.default)();
+}
+
+// src/PushAsyncIterableIterator.ts
+var CLOSE = Symbol("close");
+var PushAsyncIterableIterator = class {
+  #closed = false;
+  #pushResolvers = withResolvers();
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  close() {
+    this.#closed = true;
+    this.#pushResolvers.resolve(CLOSE);
+  }
+  async next() {
+    const value = await this.#pushResolvers.promise;
+    if (value === CLOSE) {
+      return { done: true, value: void 0 };
+    }
+    return { done: false, value };
+  }
+  push(value) {
+    if (!this.#closed) {
+      this.#pushResolvers.resolve(value);
+      this.#pushResolvers = withResolvers();
+    }
+  }
+};
+
 // src/asyncGeneratorWithLastValue.ts
 var STILL_ITERATING = Symbol();
 function asyncGeneratorWithLastValue(generator) {
@@ -123,17 +155,6 @@ function asyncGeneratorWithLastValue(generator) {
   return asyncGeneratorWithLastValue2;
 }
 
-// src/asyncIteratorToAsyncIterable.ts
-function asyncIteratorToAsyncIterable(asyncIterator) {
-  const asyncIterableIterator = {
-    [Symbol.asyncIterator]: () => asyncIterableIterator,
-    next: asyncIterator.next.bind(asyncIterator),
-    ...asyncIterator.return ? { return: asyncIterator.return.bind(asyncIterator) } : {},
-    ...asyncIterator.throw ? { throw: asyncIterator.throw.bind(asyncIterator) } : {}
-  };
-  return asyncIterableIterator;
-}
-
 // src/generatorWithLastValue.ts
 var STILL_ITERATING2 = Symbol();
 function generatorWithLastValue(generator) {
@@ -316,6 +337,24 @@ function iterableForEach(iterable, callbackfn, thisArg) {
   }
 }
 
+// src/iterableGetReadable.ts
+function isIterable(iterable) {
+  return !!(iterable && typeof iterable === "object" && Symbol.iterator in iterable);
+}
+function iterableGetReadable(iterable) {
+  const iterator = isIterable(iterable) ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const result = await iterator.next();
+      if (result.done) {
+        controller.close();
+      } else {
+        controller.enqueue(result.value);
+      }
+    }
+  });
+}
+
 // src/iterableIncludes.ts
 function iterableIncludes(iterable, searchElement, fromIndex = 0) {
   let index = 0;
@@ -472,48 +511,6 @@ function iterableToString(iterable) {
   return iterableJoin(iterable);
 }
 
-// src/private/withResolvers.ts
-var import_with_resolvers = __toESM(require("core-js-pure/full/promise/with-resolvers"));
-function withResolvers() {
-  return (0, import_with_resolvers.default)();
-}
-
-// src/iterableWritableStream.ts
-var CLOSE = Symbol();
-var IterableWritableStream = class extends WritableStream {
-  constructor() {
-    super({
-      close: () => {
-        this.#buffer.push(CLOSE);
-        this.#writeResolvers.resolve();
-      },
-      write: (chunk) => {
-        this.#buffer.push(chunk);
-        this.#writeResolvers.resolve();
-        this.#writeResolvers = withResolvers();
-      }
-    });
-  }
-  #buffer = [];
-  #writeResolvers = withResolvers();
-  [Symbol.asyncIterator]() {
-    return {
-      next: async () => {
-        while (!this.#buffer.length) {
-          await this.#writeResolvers.promise;
-        }
-        const value = this.#buffer[0];
-        if (value === CLOSE) {
-          return { done: true, value: void 0 };
-        }
-        this.#buffer.shift();
-        await void 0;
-        return { done: false, value };
-      }
-    };
-  }
-};
-
 // src/iteratorToIterable.ts
 function iteratorToIterable(iterator) {
   const iterableIterator = {
@@ -571,24 +568,6 @@ function observableSubscribeAsReadable(observable) {
   });
 }
 
-// src/readableStreamFrom.ts
-function isIterable(iterable) {
-  return !!(iterable && typeof iterable === "object" && Symbol.iterator in iterable);
-}
-function readableStreamFrom(anyIterable) {
-  const iterator = isIterable(anyIterable) ? anyIterable[Symbol.iterator]() : anyIterable[Symbol.asyncIterator]();
-  return new ReadableStream({
-    async pull(controller) {
-      const result = await iterator.next();
-      if (result.done) {
-        controller.close();
-      } else {
-        controller.enqueue(result.value);
-      }
-    }
-  });
-}
-
 // src/readerValues.ts
 function readerValues(reader) {
   const iterable = {
@@ -611,11 +590,10 @@ function readerValues(reader) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  IterableWritableStream,
   Observable,
+  PushAsyncIterableIterator,
   SymbolObservable,
   asyncGeneratorWithLastValue,
-  asyncIteratorToAsyncIterable,
   generatorWithLastValue,
   iterableAt,
   iterableConcat,
@@ -627,6 +605,7 @@ function readerValues(reader) {
   iterableFindLast,
   iterableFindLastIndex,
   iterableForEach,
+  iterableGetReadable,
   iterableIncludes,
   iterableIndexOf,
   iterableJoin,
@@ -640,7 +619,6 @@ function readerValues(reader) {
   iteratorToIterable,
   observableFromAsync,
   observableSubscribeAsReadable,
-  readableStreamFrom,
   readerValues
 });
 //# sourceMappingURL=iter-fest.js.map