iter-fest 0.1.1-main.cfcce86 → 0.1.1-main.dd552c2

package/dist/iter-fest.js

@@ -9,11 +9,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
   }
   return to;
 };
@@ -30,33 +30,41 @@ 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,
   iterableEntries: () => iterableEntries,
-  iterableEvery: () => iterableEvery,
-  iterableFilter: () => iterableFilter,
-  iterableFind: () => iterableFind,
   iterableFindIndex: () => iterableFindIndex,
   iterableFindLast: () => iterableFindLast,
   iterableFindLastIndex: () => iterableFindLastIndex,
-  iterableForEach: () => iterableForEach,
-  iterableGetReadable: () => iterableGetReadable,
   iterableIncludes: () => iterableIncludes,
   iterableIndexOf: () => iterableIndexOf,
   iterableJoin: () => iterableJoin,
   iterableKeys: () => iterableKeys,
-  iterableMap: () => iterableMap,
-  iterableReduce: () => iterableReduce,
   iterableSlice: () => iterableSlice,
-  iterableSome: () => iterableSome,
   iterableToSpliced: () => iterableToSpliced,
   iterableToString: () => iterableToString,
+  iteratorDrop: () => iteratorDrop,
+  iteratorEvery: () => iteratorEvery,
+  iteratorFilter: () => iteratorFilter,
+  iteratorFind: () => iteratorFind,
+  iteratorFlatMap: () => iteratorFlatMap,
+  iteratorForEach: () => iteratorForEach,
+  iteratorFrom: () => iteratorFrom,
+  iteratorMap: () => iteratorMap,
+  iteratorReduce: () => iteratorReduce,
+  iteratorSome: () => iteratorSome,
+  iteratorTake: () => iteratorTake,
+  iteratorToArray: () => iteratorToArray,
   iteratorToIterable: () => iteratorToIterable,
   observableFromAsync: () => observableFromAsync,
   observableSubscribeAsReadable: () => observableSubscribeAsReadable,
+  readableStreamFrom: () => readableStreamFrom,
   readerValues: () => readerValues
 });
 module.exports = __toCommonJS(src_exports);
@@ -89,38 +97,78 @@ 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/asyncGeneratorWithLastValue.ts
+var STILL_ITERATING = Symbol();
+function asyncGeneratorWithLastValue(generator) {
+  let lastValue = STILL_ITERATING;
+  const asyncGeneratorWithLastValue2 = {
+    [Symbol.asyncIterator]() {
+      return asyncGeneratorWithLastValue2;
+    },
+    lastValue() {
+      if (lastValue === STILL_ITERATING) {
+        throw new Error("Iteration has not complete yet, cannot get last value.");
+      }
+      return lastValue;
+    },
+    async next(next) {
+      const result = await generator.next(next);
+      if (result.done) {
+        lastValue = result.value;
+      }
+      return result;
+    },
+    return(value) {
+      return generator.return(value);
+    },
+    throw(error) {
+      return generator.throw(error);
+    }
+  };
+  return asyncGeneratorWithLastValue2;
 }
 
-// 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/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) {
+  let lastValue = STILL_ITERATING2;
+  const generatorWithLastValue2 = {
+    [Symbol.iterator]() {
+      return generatorWithLastValue2;
+    },
+    lastValue() {
+      if (lastValue === STILL_ITERATING2) {
+        throw new Error("Iteration has not complete yet, cannot get last value.");
+      }
+      return lastValue;
+    },
+    next(next) {
+      const result = generator.next(next);
+      if (result.done) {
+        lastValue = result.value;
+      }
+      return result;
+    },
+    return(value) {
+      return generator.return(value);
+    },
+    throw(error) {
+      return generator.throw(error);
     }
-  }
-};
+  };
+  return generatorWithLastValue2;
+}
 
 // src/private/toIntegerOrInfinity.ts
 function toIntegerOrInfinity(value) {
@@ -168,50 +216,6 @@ function* iterableEntries(iterable) {
   }
 }
 
-// src/iterableEvery.ts
-function iterableEvery(iterable, predicate, thisArg = void 0) {
-  let index = 0;
-  if (typeof predicate !== "function") {
-    throw new TypeError(`${predicate} is not a function`);
-  }
-  const boundPredicate = predicate.bind(thisArg);
-  for (const value of iterable) {
-    if (!boundPredicate(value, index++, iterable)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// src/iterableFilter.ts
-function* iterableFilter(iterable, predicate, thisArg) {
-  let index = 0;
-  if (typeof predicate !== "function") {
-    throw new TypeError(`${predicate} is not a function`);
-  }
-  const boundPredicate = predicate.bind(thisArg);
-  for (const value of iterable) {
-    if (boundPredicate(value, index++, iterable)) {
-      yield value;
-    }
-  }
-}
-
-// src/iterableFind.ts
-function iterableFind(iterable, predicate, thisArg) {
-  let index = 0;
-  if (typeof predicate !== "function") {
-    throw new TypeError(`${predicate} is not a function`);
-  }
-  const boundPredicate = predicate.bind(thisArg);
-  for (const value of iterable) {
-    if (boundPredicate(value, index++, iterable)) {
-      return value;
-    }
-  }
-  return void 0;
-}
-
 // src/iterableFindIndex.ts
 function iterableFindIndex(iterable, predicate, thisArg) {
   let index = 0;
@@ -261,36 +265,6 @@ function iterableFindLastIndex(iterable, predicate, thisArg) {
   return lastIndex;
 }
 
-// src/iterableForEach.ts
-function iterableForEach(iterable, callbackfn, thisArg) {
-  let index = 0;
-  if (typeof callbackfn !== "function") {
-    throw new TypeError(`${callbackfn} is not a function`);
-  }
-  const boundCallbackfn = callbackfn.bind(thisArg);
-  for (const value of iterable) {
-    boundCallbackfn(value, index++, iterable);
-  }
-}
-
-// 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;
@@ -352,30 +326,6 @@ function* iterableKeys(iterable) {
   }
 }
 
-// src/iterableMap.ts
-function* iterableMap(iterable, callbackfn, thisArg) {
-  let index = 0;
-  if (typeof callbackfn !== "function") {
-    throw new TypeError(`${callbackfn} is not a function`);
-  }
-  for (const value of iterable) {
-    yield callbackfn.call(thisArg, value, index++, iterable);
-  }
-}
-
-// src/iterableReduce.ts
-function iterableReduce(iterable, callbackfn, initialValue) {
-  let index = 0;
-  let previousValue = initialValue;
-  if (typeof callbackfn !== "function") {
-    throw new TypeError(`${callbackfn} is not a function`);
-  }
-  for (const currentValue of iterable) {
-    previousValue = callbackfn(previousValue, currentValue, index++, iterable);
-  }
-  return previousValue;
-}
-
 // src/iterableSlice.ts
 function* iterableSlice(iterable, start = 0, end = Infinity) {
   let index = 0;
@@ -403,21 +353,6 @@ function* iterableSlice(iterable, start = 0, end = Infinity) {
   }
 }
 
-// src/iterableSome.ts
-function iterableSome(iterable, predicate, thisArg = void 0) {
-  let index = 0;
-  if (typeof predicate !== "function") {
-    throw new TypeError(`${predicate} is not a function`);
-  }
-  const boundPredicate = predicate.bind(thisArg);
-  for (const value of iterable) {
-    if (boundPredicate(value, index++, iterable)) {
-      return true;
-    }
-  }
-  return false;
-}
-
 // src/iterableToSpliced.ts
 function* iterableToSpliced(iterable, start = 0, deleteCount = 0, ...items) {
   let index = 0;
@@ -447,6 +382,120 @@ 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/iteratorDrop.ts
+var import_drop = __toESM(require("core-js-pure/full/iterator/drop"));
+function iteratorDrop(iterator, limit) {
+  return (0, import_drop.default)(iterator, limit);
+}
+
+// src/iteratorEvery.ts
+var import_every = __toESM(require("core-js-pure/full/iterator/every"));
+function iteratorEvery(iterator, predicate) {
+  return (0, import_every.default)(iterator, predicate);
+}
+
+// src/iteratorFilter.ts
+var import_filter = __toESM(require("core-js-pure/full/iterator/filter"));
+function iteratorFilter(iterator, predicate) {
+  return (0, import_filter.default)(iterator, predicate);
+}
+
+// src/iteratorFind.ts
+var import_find = __toESM(require("core-js-pure/full/iterator/find"));
+function iteratorFind(iterator, predicate) {
+  return (0, import_find.default)(iterator, predicate);
+}
+
+// src/iteratorFlatMap.ts
+var import_flat_map = __toESM(require("core-js-pure/full/iterator/flat-map"));
+function iteratorFlatMap(iterable, mapperFn) {
+  return (0, import_flat_map.default)(iterable, mapperFn);
+}
+
+// src/iteratorForEach.ts
+var import_for_each = __toESM(require("core-js-pure/full/iterator/for-each"));
+function iteratorForEach(iterator, callbackfn) {
+  (0, import_for_each.default)(iterator, callbackfn);
+}
+
+// src/iteratorFrom.ts
+var import_from = __toESM(require("core-js-pure/full/iterator/from"));
+function iteratorFrom(iteratorLike) {
+  return (0, import_from.default)(iteratorLike);
+}
+
+// src/iteratorMap.ts
+var import_map = __toESM(require("core-js-pure/full/iterator/map"));
+function iteratorMap(iterator, callbackfn) {
+  return (0, import_map.default)(iterator, callbackfn);
+}
+
+// src/iteratorReduce.ts
+var import_reduce = __toESM(require("core-js-pure/full/iterator/reduce"));
+function iteratorReduce(iterator, callbackfn, initialValue) {
+  return (0, import_reduce.default)(iterator, callbackfn, initialValue);
+}
+
+// src/iteratorSome.ts
+var import_some = __toESM(require("core-js-pure/full/iterator/some"));
+function iteratorSome(iterator, predicate) {
+  return (0, import_some.default)(iterator, predicate);
+}
+
+// src/iteratorTake.ts
+var import_take = __toESM(require("core-js-pure/full/iterator/take"));
+function iteratorTake(iterator, limit) {
+  return (0, import_take.default)(iterator, limit);
+}
+
+// src/iteratorToArray.ts
+var import_to_array = __toESM(require("core-js-pure/full/iterator/to-array"));
+function iteratorToArray(iteratorLike) {
+  return (0, import_to_array.default)(iteratorLike);
+}
+
 // src/iteratorToIterable.ts
 function iteratorToIterable(iterator) {
   const iterableIterator = {
@@ -504,6 +553,24 @@ 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 = {
@@ -526,33 +593,41 @@ 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,
   iterableEntries,
-  iterableEvery,
-  iterableFilter,
-  iterableFind,
   iterableFindIndex,
   iterableFindLast,
   iterableFindLastIndex,
-  iterableForEach,
-  iterableGetReadable,
   iterableIncludes,
   iterableIndexOf,
   iterableJoin,
   iterableKeys,
-  iterableMap,
-  iterableReduce,
   iterableSlice,
-  iterableSome,
   iterableToSpliced,
   iterableToString,
+  iteratorDrop,
+  iteratorEvery,
+  iteratorFilter,
+  iteratorFind,
+  iteratorFlatMap,
+  iteratorForEach,
+  iteratorFrom,
+  iteratorMap,
+  iteratorReduce,
+  iteratorSome,
+  iteratorTake,
+  iteratorToArray,
   iteratorToIterable,
   observableFromAsync,
   observableSubscribeAsReadable,
+  readableStreamFrom,
   readerValues
 });
 //# sourceMappingURL=iter-fest.js.map