iter-fest 0.2.2-main.fdb3230 → 0.3.0

package/dist/iter-fest.js

@@ -79,7 +79,8 @@ __export(src_exports, {
   observableSubscribeAsReadable: () => observableSubscribeAsReadable,
   observableValues: () => observableValues,
   readableStreamFrom: () => readableStreamFrom,
-  readableStreamValues: () => readableStreamValues
+  readableStreamValues: () => readableStreamValues,
+  readableStreamValuesWithSignal: () => readableStreamValuesWithSignal
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -116,6 +117,7 @@ var STILL_ITERATING = Symbol();
 function asyncGeneratorWithLastValue(generator) {
   let lastValue = STILL_ITERATING;
   const asyncGeneratorWithLastValue2 = {
+    ...generator,
     [Symbol.asyncIterator]() {
       return asyncGeneratorWithLastValue2;
     },
@@ -230,6 +232,7 @@ var STILL_ITERATING2 = Symbol();
 function generatorWithLastValue(generator) {
   let lastValue = STILL_ITERATING2;
   const generatorWithLastValue2 = {
+    ...generator,
     [Symbol.iterator]() {
       return generatorWithLastValue2;
     },
@@ -648,53 +651,9 @@ function observableSubscribeAsReadable(observable) {
   });
 }
 
-// src/readableStreamValues.ts
-function readableStreamValues(readable) {
-  const reader = readable.getReader();
-  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 };
-    },
-    async return() {
-      reader.releaseLock();
-      return { done: true, value: void 0 };
-    }
-  };
-  return iterable;
-}
-
 // src/observableValues.ts
 function observableValues(observable) {
-  const readable = observableSubscribeAsReadable(observable);
-  const iterable = readableStreamValues(readable);
-  const cancellableIterable = {
-    [Symbol.asyncIterator]() {
-      return cancellableIterable;
-    },
-    next() {
-      return iterable.next();
-    },
-    return() {
-      var _a;
-      try {
-        return ((_a = iterable.return) == null ? void 0 : _a.call(iterable)) ?? Promise.resolve({ done: true, value: void 0 });
-      } finally {
-        readable.cancel();
-      }
-    },
-    throw(error) {
-      var _a;
-      return ((_a = iterable.throw) == null ? void 0 : _a.call(iterable, error)) ?? Promise.resolve({ done: true, value: void 0 });
-    }
-  };
-  return cancellableIterable;
+  return observableSubscribeAsReadable(observable).values();
 }
 
 // src/readableStreamFrom.ts
@@ -714,6 +673,202 @@ function readableStreamFrom(anyIterable) {
     }
   });
 }
+
+// src/readableStreamValues.ts
+function readableStreamValues(readable, options) {
+  return readable.values(options);
+}
+
+// src/private/CriticalSection.ts
+var CriticalSection = class {
+  #callbacks = [];
+  enter(fn) {
+    const fnResolver = Promise.withResolvers();
+    const callback = async () => {
+      var _a, _b;
+      try {
+        fnResolver.resolve(await fn());
+      } catch (error) {
+        fnResolver.reject(error);
+      }
+      if (this.#callbacks.shift() !== callback) {
+        throw new Error("ASSERTION: The first resolver must be self.");
+      }
+      (_b = (_a = this.#callbacks)[0]) == null ? void 0 : _b.call(_a);
+    };
+    this.#callbacks.push(callback);
+    this.#callbacks[0] === callback && callback();
+    return fnResolver.promise;
+  }
+};
+
+// src/private/AsyncIteratorMachinery.ts
+var AsyncIteratorMachinery = class {
+  constructor(iterator) {
+    this.#criticalSection = new CriticalSection();
+    this.#done = false;
+    const enter = this.#criticalSection.enter.bind(this.#criticalSection);
+    const return_ = iterator.return && iterator.return.bind(iterator);
+    const throw_ = iterator.throw && iterator.throw.bind(iterator);
+    this.next = (...[value]) => enter(async () => {
+      if (this.#done) {
+        return Promise.resolve({ done: true, value: void 0 });
+      }
+      const result = await iterator.next(...value ? [value] : []);
+      if (result.done) {
+        this.#done = true;
+      }
+      return result;
+    });
+    if (return_) {
+      this.return = (value) => enter(async () => {
+        if (this.#done) {
+          return {
+            done: true,
+            value: typeof value === "undefined" ? value : await value
+          };
+        }
+        this.#done = true;
+        return return_(value);
+      });
+    }
+    if (throw_) {
+      this.throw = (reason) => enter(() => {
+        if (this.#done) {
+          return Promise.reject(reason);
+        }
+        this.#done = true;
+        return throw_(reason);
+      });
+    }
+  }
+  #criticalSection;
+  #done;
+  async [Symbol.asyncDispose]() {
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  next;
+  return;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  throw;
+};
+
+// src/private/createAbortError.ts
+var ERROR_MESSAGE = "The operation is aborted";
+var ERROR_NAME = "AbortError";
+function createAbortError() {
+  if (typeof globalThis.DOMException === "undefined") {
+    const error = new Error(ERROR_MESSAGE);
+    error.name = ERROR_NAME;
+    return error;
+  } else {
+    return new DOMException(ERROR_MESSAGE, ERROR_NAME);
+  }
+}
+
+// src/readableStreamValuesWithSignal.ts
+var ReadableStreamIterator = class {
+  // The asynchronous iterator initialization steps for a ReadableStream, given stream, iterator, and args, are:
+  constructor(stream, args) {
+    var _a;
+    const reader = stream.getReader();
+    this.#reader = reader;
+    const preventCancel = !!args[0].preventCancel;
+    this.#preventCancel = preventCancel;
+    this.#signal = args[0].signal;
+    (_a = this.#signal) == null ? void 0 : _a.addEventListener(
+      "abort",
+      async () => {
+        this.#preventCancel || reader.cancel(createAbortError());
+        reader.releaseLock();
+      },
+      { once: true }
+    );
+  }
+  #preventCancel;
+  #reader;
+  #readRequests = [];
+  #signal;
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  async [Symbol.asyncDispose]() {
+  }
+  // The get the next iteration result steps for a ReadableStream, given stream and iterator, are:
+  // next(...[value]: [] | [any]): Promise<IteratorResult<T, any>> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  next = () => {
+    var _a;
+    if ((_a = this.#signal) == null ? void 0 : _a.aborted) {
+      return Promise.reject(createAbortError());
+    }
+    const nextResolvers = Promise.withResolvers();
+    const reader = this.#reader;
+    const resolvers = Promise.withResolvers();
+    const request = {
+      // chunk steps, given chunk
+      chunk(value) {
+        resolvers.resolve({ done: false, value });
+      },
+      // close steps
+      close() {
+        reader.releaseLock();
+        resolvers.resolve({ done: true, value: void 0 });
+      },
+      // error steps, given e
+      error(reason) {
+        reader.releaseLock();
+        resolvers.reject(reason);
+      }
+    };
+    this.#readRequests.push(request);
+    (async () => {
+      var _a2, _b;
+      try {
+        const result = await reader.read();
+        if (result.done) {
+          if ((_a2 = this.#signal) == null ? void 0 : _a2.aborted) {
+            request.error(createAbortError());
+          }
+          request.close();
+        } else {
+          request.chunk(result.value);
+        }
+      } catch (error) {
+        if ((_b = this.#signal) == null ? void 0 : _b.aborted) {
+          request.error(createAbortError());
+        } else {
+          request.error(error);
+        }
+      } finally {
+        nextResolvers.resolve();
+      }
+    })();
+    return resolvers.promise;
+  };
+  // The asynchronous iterator return steps for a ReadableStream, given stream, iterator, and arg, are:
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async return(value) {
+    var _a;
+    if ((_a = this.#signal) == null ? void 0 : _a.aborted) {
+      return Promise.reject(createAbortError());
+    }
+    const reader = this.#reader;
+    if (!this.#preventCancel) {
+      const cancelPromise = reader.cancel(value);
+      reader.releaseLock();
+      await cancelPromise;
+      return { done: true, value };
+    }
+    reader.releaseLock();
+    return { done: true, value };
+  }
+};
+function readableStreamValuesWithSignal(stream, options) {
+  return new AsyncIteratorMachinery(new ReadableStreamIterator(stream, [options || {}]));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   IterableWritableStream,
@@ -765,6 +920,7 @@ function readableStreamFrom(anyIterable) {
   observableSubscribeAsReadable,
   observableValues,
   readableStreamFrom,
-  readableStreamValues
+  readableStreamValues,
+  readableStreamValuesWithSignal
 });
 //# sourceMappingURL=iter-fest.js.map