iter-fest 0.1.1-main.1b2076b → 0.1.1-main.4decbaa

package/README.md

@@ -57,6 +57,100 @@ for (const value of iteratorToIterable(iterate())) {
 }
 ```
 
+### Typed `Observable`
+
+`Observable` and `Symbol.observable` is re-exported from `core-js-pure` with proper type definitions.
+
+### Converting an `Observable` to `AsyncIterableIterator`
+
+`observableValues` subscribes to an `Observable` and return as `AsyncIterableIterator`.
+
+`Observable` is push-based and `AsyncIterableIterator` is pull-based. Values from `Observable` may push continuously and will be buffered internally. When for-loop break or complete, the iterator will unsubscribe from the `Observable`.
+
+```ts
+const observable = Observable.from([1, 2, 3]);
+
+for await (const value of observableValues(observable)) {
+  console.log(value); // Prints "1", "2", "3".
+}
+```
+
+### Converting an `AsyncIterable` to `Observable`
+
+`Observable.from` converts `Iterable` into `Observable`. However, it does not convert `AsyncIterable`.
+
+`observableFromAsync` will convert `AsyncIterable` into `Observable`.
+
+```ts
+async function* generate() {
+  yield 1;
+  yield 2;
+  yield 3;
+}
+
+const observable = observableFromAsync(generate());
+const next = value => console.log(value);
+
+observable.subscribe({ next }); // Prints "1", "2", "3".
+```
+
+### Producer-consumer queue
+
+`PushAsyncIterableIterator` is a simple push-based producer-consumer queue. The producer can push a new job at anytime. The consumer will wait for jobs to be available.
+
+A push-based queue is easier to use than a pull-based queue. However, pull-based queue offers better flow control. For a full-featured producer-consumer queue that supports flow control, use `ReadableStream` instead.
+
+```ts
+const iterable = new PushAsyncIterableIterator();
+
+(async function consumer() {
+  for await (const value of iterable) {
+    console.log(value);
+  }
+
+  console.log('Done');
+})();
+
+(async function producer() {
+  iterable.push(1);
+  iterable.push(2);
+  iterable.push(3);
+  iterable.close();
+})();
+
+// Prints "1", "2", "3", "Done".
+```
+
+### Iterating `ReadableStreamDefaultReader`
+
+`readerToAsyncIterableIterator` will convert default reader of `ReadableStream` into an `AsyncIterableIterator` to use in for-loop.
+
+```ts
+const readableStream = new ReadableStream({
+  start(controller) {
+    controller.enqueue(1);
+    controller.enqueue(2);
+    controller.close();
+  }
+});
+
+for await (const value of readerToAsyncIterableIterator(readableStream.getReader())) {
+  console.log(value); // Prints "1", "2", "3".
+}
+```
+
+## Converts `Observable` into `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.
+
+```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.
+```
+
 ## Behaviors
 
 ### How this compares to the TC39 proposals?

package/dist/chunk-2HLJODU3.mjs

@@ -0,0 +1,21 @@
+// src/readerToAsyncIterableIterator.ts
+function readerToAsyncIterableIterator(reader) {
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return iterable;
+    },
+    async next() {
+      const result = await Promise.race([reader.read(), reader.closed]);
+      if (!result || result.done) {
+        return { done: true, value: void 0 };
+      }
+      return { value: result.value };
+    }
+  };
+  return iterable;
+}
+
+export {
+  readerToAsyncIterableIterator
+};
+//# sourceMappingURL=chunk-2HLJODU3.mjs.map

package/dist/chunk-2HLJODU3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/readerToAsyncIterableIterator.ts"],"sourcesContent":["export function readerToAsyncIterableIterator<T>(reader: ReadableStreamDefaultReader<T>): AsyncIterableIterator<T> {\n  const iterable = {\n    [Symbol.asyncIterator]() {\n      return iterable;\n    },\n    async next(): Promise<IteratorResult<T>> {\n      const result = await Promise.race([reader.read(), reader.closed]);\n\n      if (!result || result.done) {\n        return { done: true, value: undefined };\n      }\n\n      return { value: result.value };\n    }\n  };\n\n  return iterable;\n}\n"],"mappings":";AAAO,SAAS,8BAAiC,QAAkE;AACjH,QAAM,WAAW;AAAA,IACf,CAAC,OAAO,aAAa,IAAI;AACvB,aAAO;AAAA,IACT;AAAA,IACA,MAAM,OAAmC;AACvC,YAAM,SAAS,MAAM,QAAQ,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,MAAM,CAAC;AAEhE,UAAI,CAAC,UAAU,OAAO,MAAM;AAC1B,eAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,MACxC;AAEA,aAAO,EAAE,OAAO,OAAO,MAAM;AAAA,IAC/B;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-4LRYDU2Y.mjs

@@ -0,0 +1,62 @@
+import {
+  withResolvers
+} from "./chunk-U6G4RNZ2.mjs";
+
+// src/observableValues.ts
+var COMPLETE = Symbol("complete");
+var NEXT = Symbol("next");
+var THROW = Symbol("throw");
+function observableValues(observable) {
+  const queue = [];
+  let deferred = withResolvers();
+  const push = (entry) => {
+    queue.push(entry);
+    deferred.resolve(entry);
+    deferred = withResolvers();
+  };
+  const subscription = observable.subscribe({
+    complete() {
+      push([COMPLETE]);
+    },
+    error(err) {
+      push([THROW, err]);
+    },
+    next(value) {
+      push([NEXT, value]);
+    }
+  });
+  const asyncIterableIterator = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async next() {
+      let entry = queue.shift();
+      if (!entry) {
+        entry = await deferred.promise;
+        queue.shift();
+      }
+      switch (entry[0]) {
+        case COMPLETE:
+          return { done: true, value: void 0 };
+        case THROW:
+          throw entry[1];
+        case NEXT:
+          return { done: false, value: entry[1] };
+      }
+    },
+    async return() {
+      subscription.unsubscribe();
+      return { done: true, value: void 0 };
+    },
+    async throw() {
+      subscription.unsubscribe();
+      return { done: true, value: void 0 };
+    }
+  };
+  return asyncIterableIterator;
+}
+
+export {
+  observableValues
+};
+//# sourceMappingURL=chunk-4LRYDU2Y.mjs.map

package/dist/chunk-4LRYDU2Y.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/observableValues.ts"],"sourcesContent":["import withResolvers from './private/withResolvers';\n\nimport { Observable } from './Observable';\n\nconst COMPLETE = Symbol('complete');\nconst NEXT = Symbol('next');\nconst THROW = Symbol('throw');\n\ntype Entry<T> = [typeof COMPLETE] | [typeof NEXT, T] | [typeof THROW, unknown];\n\nexport function observableValues<T>(observable: Observable<T>): AsyncIterableIterator<T> {\n  const queue: Entry<T>[] = [];\n  let deferred = withResolvers<Entry<T>>();\n\n  const push = (entry: Entry<T>) => {\n    queue.push(entry);\n    deferred.resolve(entry);\n    deferred = withResolvers();\n  };\n\n  const subscription = observable.subscribe({\n    complete() {\n      push([COMPLETE]);\n    },\n    error(err: unknown) {\n      push([THROW, err]);\n    },\n    next(value: T) {\n      push([NEXT, value]);\n    }\n  });\n\n  const asyncIterableIterator: AsyncIterableIterator<T> = {\n    [Symbol.asyncIterator]() {\n      return this;\n    },\n    async next(): Promise<IteratorResult<T>> {\n      let entry = queue.shift();\n\n      if (!entry) {\n        entry = await deferred.promise;\n        queue.shift();\n      }\n\n      switch (entry[0]) {\n        case COMPLETE:\n          return { done: true, value: undefined };\n\n        case THROW:\n          throw entry[1];\n\n        case NEXT:\n          return { done: false, value: entry[1] };\n      }\n    },\n    async return() {\n      subscription.unsubscribe();\n\n      return { done: true, value: undefined };\n    },\n    async throw() {\n      subscription.unsubscribe();\n\n      return { done: true, value: undefined };\n    }\n  };\n\n  return asyncIterableIterator;\n}\n"],"mappings":";;;;;AAIA,IAAM,WAAW,OAAO,UAAU;AAClC,IAAM,OAAO,OAAO,MAAM;AAC1B,IAAM,QAAQ,OAAO,OAAO;AAIrB,SAAS,iBAAoB,YAAqD;AACvF,QAAM,QAAoB,CAAC;AAC3B,MAAI,WAAW,cAAwB;AAEvC,QAAM,OAAO,CAAC,UAAoB;AAChC,UAAM,KAAK,KAAK;AAChB,aAAS,QAAQ,KAAK;AACtB,eAAW,cAAc;AAAA,EAC3B;AAEA,QAAM,eAAe,WAAW,UAAU;AAAA,IACxC,WAAW;AACT,WAAK,CAAC,QAAQ,CAAC;AAAA,IACjB;AAAA,IACA,MAAM,KAAc;AAClB,WAAK,CAAC,OAAO,GAAG,CAAC;AAAA,IACnB;AAAA,IACA,KAAK,OAAU;AACb,WAAK,CAAC,MAAM,KAAK,CAAC;AAAA,IACpB;AAAA,EACF,CAAC;AAED,QAAM,wBAAkD;AAAA,IACtD,CAAC,OAAO,aAAa,IAAI;AACvB,aAAO;AAAA,IACT;AAAA,IACA,MAAM,OAAmC;AACvC,UAAI,QAAQ,MAAM,MAAM;AAExB,UAAI,CAAC,OAAO;AACV,gBAAQ,MAAM,SAAS;AACvB,cAAM,MAAM;AAAA,MACd;AAEA,cAAQ,MAAM,CAAC,GAAG;AAAA,QAChB,KAAK;AACH,iBAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,QAExC,KAAK;AACH,gBAAM,MAAM,CAAC;AAAA,QAEf,KAAK;AACH,iBAAO,EAAE,MAAM,OAAO,OAAO,MAAM,CAAC,EAAE;AAAA,MAC1C;AAAA,IACF;AAAA,IACA,MAAM,SAAS;AACb,mBAAa,YAAY;AAEzB,aAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,IACxC;AAAA,IACA,MAAM,QAAQ;AACZ,mBAAa,YAAY;AAEzB,aAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,IACxC;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-EIIP7YWB.mjs

@@ -0,0 +1,27 @@
+// src/observableSubscribeAsReadable.ts
+function observableSubscribeAsReadable(observable) {
+  let subscription;
+  return new ReadableStream({
+    cancel() {
+      subscription.unsubscribe();
+    },
+    start(controller) {
+      subscription = observable.subscribe({
+        complete() {
+          controller.close();
+        },
+        error(err) {
+          controller.error(err);
+        },
+        next(value) {
+          controller.enqueue(value);
+        }
+      });
+    }
+  });
+}
+
+export {
+  observableSubscribeAsReadable
+};
+//# sourceMappingURL=chunk-EIIP7YWB.mjs.map

package/dist/chunk-EIIP7YWB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/observableSubscribeAsReadable.ts"],"sourcesContent":["import type { Observable, Subscription } from './Observable';\n\nexport function observableSubscribeAsReadable<T>(observable: Observable<T>): ReadableStream<T> {\n  let subscription: Subscription;\n\n  return new ReadableStream<T>({\n    cancel() {\n      subscription.unsubscribe();\n    },\n    start(controller) {\n      subscription = observable.subscribe({\n        complete() {\n          controller.close();\n        },\n        error(err: unknown) {\n          controller.error(err);\n        },\n        next(value) {\n          controller.enqueue(value);\n        }\n      });\n    }\n  });\n}\n"],"mappings":";AAEO,SAAS,8BAAiC,YAA8C;AAC7F,MAAI;AAEJ,SAAO,IAAI,eAAkB;AAAA,IAC3B,SAAS;AACP,mBAAa,YAAY;AAAA,IAC3B;AAAA,IACA,MAAM,YAAY;AAChB,qBAAe,WAAW,UAAU;AAAA,QAClC,WAAW;AACT,qBAAW,MAAM;AAAA,QACnB;AAAA,QACA,MAAM,KAAc;AAClB,qBAAW,MAAM,GAAG;AAAA,QACtB;AAAA,QACA,KAAK,OAAO;AACV,qBAAW,QAAQ,KAAK;AAAA,QAC1B;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-FEOLYD5R.mjs

@@ -0,0 +1,31 @@
+import {
+  Observable
+} from "./chunk-VLF6DI2U.mjs";
+
+// src/observableFromAsync.ts
+function observableFromAsync(iterable) {
+  return new Observable((subscriber) => {
+    let closed = false;
+    (async function() {
+      try {
+        for await (const value of iterable) {
+          if (closed) {
+            break;
+          }
+          subscriber.next(value);
+        }
+        subscriber.complete();
+      } catch (error) {
+        subscriber.error(error);
+      }
+    })();
+    return () => {
+      closed = true;
+    };
+  });
+}
+
+export {
+  observableFromAsync
+};
+//# sourceMappingURL=chunk-FEOLYD5R.mjs.map

package/dist/chunk-FEOLYD5R.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/observableFromAsync.ts"],"sourcesContent":["import { Observable } from './Observable';\n\nexport function observableFromAsync<T>(iterable: AsyncIterable<T>): Observable<T> {\n  return new Observable(subscriber => {\n    let closed = false;\n\n    (async function () {\n      try {\n        for await (const value of iterable) {\n          if (closed) {\n            break;\n          }\n\n          subscriber.next(value);\n        }\n\n        subscriber.complete();\n      } catch (error) {\n        subscriber.error(error);\n      }\n    })();\n\n    return () => {\n      closed = true;\n    };\n  });\n}\n"],"mappings":";;;;;AAEO,SAAS,oBAAuB,UAA2C;AAChF,SAAO,IAAI,WAAW,gBAAc;AAClC,QAAI,SAAS;AAEb,KAAC,iBAAkB;AACjB,UAAI;AACF,yBAAiB,SAAS,UAAU;AAClC,cAAI,QAAQ;AACV;AAAA,UACF;AAEA,qBAAW,KAAK,KAAK;AAAA,QACvB;AAEA,mBAAW,SAAS;AAAA,MACtB,SAAS,OAAO;AACd,mBAAW,MAAM,KAAK;AAAA,MACxB;AAAA,IACF,GAAG;AAEH,WAAO,MAAM;AACX,eAAS;AAAA,IACX;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-K5XV4W7G.mjs

@@ -0,0 +1,35 @@
+import {
+  withResolvers
+} from "./chunk-U6G4RNZ2.mjs";
+
+// 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-K5XV4W7G.mjs.map

package/dist/chunk-K5XV4W7G.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/PushAsyncIterableIterator.ts"],"sourcesContent":["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":";;;;;AAEA,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/chunk-OJMT4K3R.mjs

@@ -0,0 +1,8 @@
+// src/SymbolObservable.ts
+import CoreJSSymbolObservable from "core-js-pure/features/symbol/observable";
+var SymbolObservable = CoreJSSymbolObservable;
+
+export {
+  SymbolObservable
+};
+//# sourceMappingURL=chunk-OJMT4K3R.mjs.map

package/dist/chunk-OJMT4K3R.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/SymbolObservable.ts"],"sourcesContent":["// @ts-expect-error core-js is not typed.\nimport CoreJSSymbolObservable from 'core-js-pure/features/symbol/observable';\n\nconst SymbolObservable: unique symbol = CoreJSSymbolObservable;\n\nexport { SymbolObservable };\n"],"mappings":";AACA,OAAO,4BAA4B;AAEnC,IAAM,mBAAkC;","names":[]}

package/dist/chunk-U6G4RNZ2.mjs

@@ -0,0 +1,10 @@
+// src/private/withResolvers.ts
+import coreJSPromiseWithResolvers from "core-js-pure/full/promise/with-resolvers";
+function withResolvers() {
+  return coreJSPromiseWithResolvers();
+}
+
+export {
+  withResolvers
+};
+//# sourceMappingURL=chunk-U6G4RNZ2.mjs.map

package/dist/chunk-U6G4RNZ2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/private/withResolvers.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"],"mappings":";AACA,OAAO,gCAAgC;AAExB,SAAR,gBAA6D;AAClE,SAAO,2BAA2B;AACpC;","names":[]}

package/dist/chunk-VLF6DI2U.mjs

@@ -0,0 +1,30 @@
+import {
+  SymbolObservable
+} from "./chunk-OJMT4K3R.mjs";
+
+// src/Observable.ts
+import CoreJSObservable from "core-js-pure/full/observable";
+var Observable = class extends CoreJSObservable {
+  constructor(subscriber) {
+    super(subscriber);
+  }
+  subscribe(observerOrOnNext, onError, onComplete) {
+    return super.subscribe(observerOrOnNext, onError, onComplete);
+  }
+  /** Returns itself */
+  [SymbolObservable]() {
+    return this;
+  }
+  /** Converts items to an Observable */
+  static of(...items) {
+    return CoreJSObservable.of(...items);
+  }
+  static from(iterableOrObservable) {
+    return CoreJSObservable.from(iterableOrObservable);
+  }
+};
+
+export {
+  Observable
+};
+//# sourceMappingURL=chunk-VLF6DI2U.mjs.map

package/dist/chunk-VLF6DI2U.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Observable.ts"],"sourcesContent":["// @ts-expect-error core-js is not typed.\nimport CoreJSObservable from 'core-js-pure/full/observable';\n\nimport { SymbolObservable } from './SymbolObservable';\n\nexport interface SubscriptionObserver<T> {\n  /** Sends the next value in the sequence */\n  next(value: T): void;\n\n  /** Sends the sequence error */\n  error(errorValue: unknown): void;\n\n  /** Sends the completion notification */\n  complete(): void;\n\n  /** A boolean value indicating whether the subscription is closed */\n  get closed(): boolean;\n}\n\nexport interface Subscription {\n  /** Cancels the subscription */\n  unsubscribe(): void;\n\n  /** A boolean value indicating whether the subscription is closed */\n  get closed(): boolean;\n}\n\nexport type SubscriberFunction<T> = (observer: SubscriptionObserver<T>) => (() => void) | Subscription | void;\n\nexport type CompleteFunction = () => void;\nexport type ErrorFunction = (errorValue: unknown) => void;\nexport type NextFunction<T> = (value: T) => void;\nexport type StartFunction = (subscription: Subscription) => void;\n\nexport interface Observer<T> {\n  /** Receives a completion notification */\n  complete?(): void;\n\n  /** Receives the sequence error */\n  error?(errorValue: unknown): void;\n\n  /** Receives the next value in the sequence */\n  next?(value: T): void;\n\n  /** Receives the subscription object when `subscribe` is called */\n  start?(subscription: Subscription): void;\n}\n\nexport class Observable<T> extends CoreJSObservable {\n  constructor(subscriber: SubscriberFunction<T>) {\n    super(subscriber);\n  }\n\n  /** Subscribes to the sequence with an observer */\n  subscribe(observer: Observer<T>): Subscription;\n\n  /** Subscribes to the sequence with callbacks */\n  subscribe(\n    onNext: NextFunction<T>,\n    onError?: ErrorFunction | undefined,\n    onComplete?: CompleteFunction | undefined\n  ): Subscription;\n\n  subscribe(\n    observerOrOnNext: Observer<T> | NextFunction<T>,\n    onError?: ErrorFunction | undefined,\n    onComplete?: CompleteFunction | undefined\n  ): Subscription {\n    return super.subscribe(observerOrOnNext, onError, onComplete);\n  }\n\n  /** Returns itself */\n  [SymbolObservable](): Observable<T> {\n    return this;\n  }\n\n  /** Converts items to an Observable */\n  static of<T>(...items: T[]): Observable<T> {\n    return CoreJSObservable.of(...items);\n  }\n\n  /** Converts an iterable to an Observable */\n  static from<T>(iterable: Iterable<T>): Observable<T>;\n\n  /** Converts an observable to an Observable */\n  static from<T>(observable: Observable<T>): Observable<T>;\n\n  static from<T>(iterableOrObservable: Iterable<T> | Observable<T>): Observable<T> {\n    return CoreJSObservable.from(iterableOrObservable);\n  }\n}\n"],"mappings":";;;;;AACA,OAAO,sBAAsB;AA+CtB,IAAM,aAAN,cAA4B,iBAAiB;AAAA,EAClD,YAAY,YAAmC;AAC7C,UAAM,UAAU;AAAA,EAClB;AAAA,EAYA,UACE,kBACA,SACA,YACc;AACd,WAAO,MAAM,UAAU,kBAAkB,SAAS,UAAU;AAAA,EAC9D;AAAA;AAAA,EAGA,CAAC,gBAAgB,IAAmB;AAClC,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,MAAS,OAA2B;AACzC,WAAO,iBAAiB,GAAG,GAAG,KAAK;AAAA,EACrC;AAAA,EAQA,OAAO,KAAQ,sBAAkE;AAC/E,WAAO,iBAAiB,KAAK,oBAAoB;AAAA,EACnD;AACF;","names":[]}

package/dist/iter-fest.d.mts

@@ -1,3 +1,6 @@
+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 { iterableAt } from './iter-fest.iterableAt.mjs';
 export { iterableConcat } from './iter-fest.iterableConcat.mjs';
 export { iterableEntries } from './iter-fest.iterableEntries.mjs';
@@ -19,3 +22,8 @@ export { iterableSome } from './iter-fest.iterableSome.mjs';
 export { iterableToSpliced } from './iter-fest.iterableToSpliced.mjs';
 export { iterableToString } from './iter-fest.iterableToString.mjs';
 export { iteratorToIterable } from './iter-fest.iteratorToIterable.mjs';
+export { observableFromAsync } from './iter-fest.observableFromAsync.mjs';
+export { observableSubscribeAsReadable } from './iter-fest.observableSubscribeAsReadable.mjs';
+export { observableValues } from './iter-fest.observableValues.mjs';
+export { readerToAsyncIterableIterator } from './iter-fest.readerToAsyncIterableIterator.mjs';
+import 'core-js-pure/full/observable';

package/dist/iter-fest.d.ts

@@ -1,3 +1,6 @@
+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 { iterableAt } from './iter-fest.iterableAt.js';
 export { iterableConcat } from './iter-fest.iterableConcat.js';
 export { iterableEntries } from './iter-fest.iterableEntries.js';
@@ -19,3 +22,8 @@ export { iterableSome } from './iter-fest.iterableSome.js';
 export { iterableToSpliced } from './iter-fest.iterableToSpliced.js';
 export { iterableToString } from './iter-fest.iterableToString.js';
 export { iteratorToIterable } from './iter-fest.iteratorToIterable.js';
+export { observableFromAsync } from './iter-fest.observableFromAsync.js';
+export { observableSubscribeAsReadable } from './iter-fest.observableSubscribeAsReadable.js';
+export { observableValues } from './iter-fest.observableValues.js';
+export { readerToAsyncIterableIterator } from './iter-fest.readerToAsyncIterableIterator.js';
+import 'core-js-pure/full/observable';

package/dist/iter-fest.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,11 +17,22 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  Observable: () => Observable,
+  PushAsyncIterableIterator: () => PushAsyncIterableIterator,
+  SymbolObservable: () => SymbolObservable,
   iterableAt: () => iterableAt,
   iterableConcat: () => iterableConcat,
   iterableEntries: () => iterableEntries,
@@ -40,10 +53,75 @@ __export(src_exports, {
   iterableSome: () => iterableSome,
   iterableToSpliced: () => iterableToSpliced,
   iterableToString: () => iterableToString,
-  iteratorToIterable: () => iteratorToIterable
+  iteratorToIterable: () => iteratorToIterable,
+  observableFromAsync: () => observableFromAsync,
+  observableSubscribeAsReadable: () => observableSubscribeAsReadable,
+  observableValues: () => observableValues,
+  readerToAsyncIterableIterator: () => readerToAsyncIterableIterator
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/Observable.ts
+var import_observable2 = __toESM(require("core-js-pure/full/observable"));
+
+// src/SymbolObservable.ts
+var import_observable = __toESM(require("core-js-pure/features/symbol/observable"));
+var SymbolObservable = import_observable.default;
+
+// src/Observable.ts
+var Observable = class extends import_observable2.default {
+  constructor(subscriber) {
+    super(subscriber);
+  }
+  subscribe(observerOrOnNext, onError, onComplete) {
+    return super.subscribe(observerOrOnNext, onError, onComplete);
+  }
+  /** Returns itself */
+  [SymbolObservable]() {
+    return this;
+  }
+  /** Converts items to an Observable */
+  static of(...items) {
+    return import_observable2.default.of(...items);
+  }
+  static from(iterableOrObservable) {
+    return import_observable2.default.from(iterableOrObservable);
+  }
+};
+
+// 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/private/toIntegerOrInfinity.ts
 function toIntegerOrInfinity(value) {
   if (value === Infinity || value === -Infinity) {
@@ -361,8 +439,128 @@ function iteratorToIterable(iterator) {
   };
   return iterableIterator;
 }
+
+// src/observableFromAsync.ts
+function observableFromAsync(iterable) {
+  return new Observable((subscriber) => {
+    let closed = false;
+    (async function() {
+      try {
+        for await (const value of iterable) {
+          if (closed) {
+            break;
+          }
+          subscriber.next(value);
+        }
+        subscriber.complete();
+      } catch (error) {
+        subscriber.error(error);
+      }
+    })();
+    return () => {
+      closed = true;
+    };
+  });
+}
+
+// src/observableSubscribeAsReadable.ts
+function observableSubscribeAsReadable(observable) {
+  let subscription;
+  return new ReadableStream({
+    cancel() {
+      subscription.unsubscribe();
+    },
+    start(controller) {
+      subscription = observable.subscribe({
+        complete() {
+          controller.close();
+        },
+        error(err) {
+          controller.error(err);
+        },
+        next(value) {
+          controller.enqueue(value);
+        }
+      });
+    }
+  });
+}
+
+// src/observableValues.ts
+var COMPLETE = Symbol("complete");
+var NEXT = Symbol("next");
+var THROW = Symbol("throw");
+function observableValues(observable) {
+  const queue = [];
+  let deferred = withResolvers();
+  const push = (entry) => {
+    queue.push(entry);
+    deferred.resolve(entry);
+    deferred = withResolvers();
+  };
+  const subscription = observable.subscribe({
+    complete() {
+      push([COMPLETE]);
+    },
+    error(err) {
+      push([THROW, err]);
+    },
+    next(value) {
+      push([NEXT, value]);
+    }
+  });
+  const asyncIterableIterator = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async next() {
+      let entry = queue.shift();
+      if (!entry) {
+        entry = await deferred.promise;
+        queue.shift();
+      }
+      switch (entry[0]) {
+        case COMPLETE:
+          return { done: true, value: void 0 };
+        case THROW:
+          throw entry[1];
+        case NEXT:
+          return { done: false, value: entry[1] };
+      }
+    },
+    async return() {
+      subscription.unsubscribe();
+      return { done: true, value: void 0 };
+    },
+    async throw() {
+      subscription.unsubscribe();
+      return { done: true, value: void 0 };
+    }
+  };
+  return asyncIterableIterator;
+}
+
+// src/readerToAsyncIterableIterator.ts
+function readerToAsyncIterableIterator(reader) {
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return iterable;
+    },
+    async next() {
+      const result = await Promise.race([reader.read(), reader.closed]);
+      if (!result || result.done) {
+        return { done: true, value: void 0 };
+      }
+      return { value: result.value };
+    }
+  };
+  return iterable;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Observable,
+  PushAsyncIterableIterator,
+  SymbolObservable,
   iterableAt,
   iterableConcat,
   iterableEntries,
@@ -383,6 +581,10 @@ function iteratorToIterable(iterator) {
   iterableSome,
   iterableToSpliced,
   iterableToString,
-  iteratorToIterable
+  iteratorToIterable,
+  observableFromAsync,
+  observableSubscribeAsReadable,
+  observableValues,
+  readerToAsyncIterableIterator
 });
 //# sourceMappingURL=iter-fest.js.map