es-toolkit 1.51.0-dev.2069 → 1.51.0-dev.2070

package/dist/fp/iterator/cartesianProduct.d.mts

@@ -0,0 +1,23 @@
+//#region src/fp/iterator/cartesianProduct.d.ts
+/**
+ * Creates a function that lazily takes the Cartesian product of the piped
+ * iterator and `other`, for use with {@link pipe}. Every element of the piped
+ * iterator is paired with every element of `other`, with `other` advancing
+ * fastest. `other` is buffered into an array when iteration starts, while the
+ * piped iterator is consumed lazily, so it may be infinite.
+ *
+ * @template T - The type of elements produced by the piped iterator.
+ * @template U - The type of elements produced by `other`.
+ * @param other - The iterator to take the product with.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { cartesianProduct, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2].values(), cartesianProduct(['a', 'b'].values()), toArray());
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+declare function cartesianProduct<T, U>(other: Iterator<U>): (source: Iterator<T>) => IteratorObject<[T, U], undefined>;
+//#endregion
+export { cartesianProduct };

package/dist/fp/iterator/cartesianProduct.d.ts

@@ -0,0 +1,23 @@
+//#region src/fp/iterator/cartesianProduct.d.ts
+/**
+ * Creates a function that lazily takes the Cartesian product of the piped
+ * iterator and `other`, for use with {@link pipe}. Every element of the piped
+ * iterator is paired with every element of `other`, with `other` advancing
+ * fastest. `other` is buffered into an array when iteration starts, while the
+ * piped iterator is consumed lazily, so it may be infinite.
+ *
+ * @template T - The type of elements produced by the piped iterator.
+ * @template U - The type of elements produced by `other`.
+ * @param other - The iterator to take the product with.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { cartesianProduct, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2].values(), cartesianProduct(['a', 'b'].values()), toArray());
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+declare function cartesianProduct<T, U>(other: Iterator<U>): (source: Iterator<T>) => IteratorObject<[T, U], undefined>;
+//#endregion
+export { cartesianProduct };

package/dist/fp/iterator/cartesianProduct.js

@@ -0,0 +1,28 @@
+const require_cartesianProduct = require("../../iterator/cartesianProduct.js");
+//#region src/fp/iterator/cartesianProduct.ts
+/**
+* Creates a function that lazily takes the Cartesian product of the piped
+* iterator and `other`, for use with {@link pipe}. Every element of the piped
+* iterator is paired with every element of `other`, with `other` advancing
+* fastest. `other` is buffered into an array when iteration starts, while the
+* piped iterator is consumed lazily, so it may be infinite.
+*
+* @template T - The type of elements produced by the piped iterator.
+* @template U - The type of elements produced by `other`.
+* @param other - The iterator to take the product with.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { cartesianProduct, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2].values(), cartesianProduct(['a', 'b'].values()), toArray());
+* // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+*/
+function cartesianProduct(other) {
+	return function cartesianProductInIterator(source) {
+		return require_cartesianProduct.cartesianProduct(source, other);
+	};
+}
+//#endregion
+exports.cartesianProduct = cartesianProduct;

package/dist/fp/iterator/cartesianProduct.mjs

@@ -0,0 +1,28 @@
+import { cartesianProduct as cartesianProduct$1 } from "../../iterator/cartesianProduct.mjs";
+//#region src/fp/iterator/cartesianProduct.ts
+/**
+* Creates a function that lazily takes the Cartesian product of the piped
+* iterator and `other`, for use with {@link pipe}. Every element of the piped
+* iterator is paired with every element of `other`, with `other` advancing
+* fastest. `other` is buffered into an array when iteration starts, while the
+* piped iterator is consumed lazily, so it may be infinite.
+*
+* @template T - The type of elements produced by the piped iterator.
+* @template U - The type of elements produced by `other`.
+* @param other - The iterator to take the product with.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { cartesianProduct, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2].values(), cartesianProduct(['a', 'b'].values()), toArray());
+* // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+*/
+function cartesianProduct(other) {
+	return function cartesianProductInIterator(source) {
+		return cartesianProduct$1(source, other);
+	};
+}
+//#endregion
+export { cartesianProduct };

package/dist/fp/iterator/index.d.mts

@@ -1,3 +1,4 @@
+import { cartesianProduct } from "./cartesianProduct.mjs";
 import { chunk } from "./chunk.mjs";
 import { count } from "./count.mjs";
 import { drop } from "./drop.mjs";
@@ -18,4 +19,4 @@ import { takeWhile } from "./takeWhile.mjs";
 import { toArray } from "./toArray.mjs";
 import { uniqBy } from "./uniqBy.mjs";
 import { zip } from "./zip.mjs";
-export { chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };
+export { cartesianProduct, chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };

package/dist/fp/iterator/index.d.ts

@@ -1,3 +1,4 @@
+import { cartesianProduct } from "./cartesianProduct.js";
 import { chunk } from "./chunk.js";
 import { count } from "./count.js";
 import { drop } from "./drop.js";
@@ -18,4 +19,4 @@ import { takeWhile } from "./takeWhile.js";
 import { toArray } from "./toArray.js";
 import { uniqBy } from "./uniqBy.js";
 import { zip } from "./zip.js";
-export { chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };
+export { cartesianProduct, chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };

package/dist/fp/iterator/index.js

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_cartesianProduct = require("./cartesianProduct.js");
 const require_chunk = require("./chunk.js");
 const require_count = require("./count.js");
 const require_drop = require("./drop.js");
@@ -19,6 +20,7 @@ const require_takeWhile = require("./takeWhile.js");
 const require_toArray = require("./toArray.js");
 const require_uniqBy = require("./uniqBy.js");
 const require_zip = require("./zip.js");
+exports.cartesianProduct = require_cartesianProduct.cartesianProduct;
 exports.chunk = require_chunk.chunk;
 exports.count = require_count.count;
 exports.drop = require_drop.drop;

package/dist/fp/iterator/index.mjs

@@ -1,3 +1,4 @@
+import { cartesianProduct } from "./cartesianProduct.mjs";
 import { chunk } from "./chunk.mjs";
 import { count } from "./count.mjs";
 import { drop } from "./drop.mjs";
@@ -18,4 +19,4 @@ import { takeWhile } from "./takeWhile.mjs";
 import { toArray } from "./toArray.mjs";
 import { uniqBy } from "./uniqBy.mjs";
 import { zip } from "./zip.mjs";
-export { chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };
+export { cartesianProduct, chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };

package/dist/iterator/cartesianProduct.d.mts

@@ -0,0 +1,33 @@
+//#region src/iterator/cartesianProduct.d.ts
+type IteratorValue<T> = T extends Iterator<infer V> ? V : never;
+/**
+ * Lazily computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
+ * of the source iterators, yielding every possible tuple formed by picking one
+ * element from each source, in lexicographic order — the rightmost source
+ * advances fastest, like the digits of an odometer.
+ *
+ * Because every source except the first is traversed many times, those sources
+ * are buffered into arrays when iteration starts. The first source is consumed
+ * lazily, one element at a time, so it may be infinite. When iteration ends —
+ * because the first source ran out, a buffered source was empty, or the
+ * consumer terminated early — every source is closed via its `return` method.
+ *
+ * If no sources are passed, a single empty tuple is yielded, matching the
+ * array `cartesianProduct`. If any source is empty, nothing is yielded.
+ *
+ * @template T - A tuple of the source iterator types.
+ * @param sources - The iterators to take the product of.
+ * @returns A lazy iterator over tuples representing the Cartesian product.
+ *
+ * @example
+ * cartesianProduct([1, 2].values(), ['a', 'b'].values()).toArray();
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ *
+ * @example
+ * // The first source may be infinite; elements are produced on demand.
+ * cartesianProduct(range(0, Infinity), ['a', 'b'].values()).take(3).toArray();
+ * // => [[0, 'a'], [0, 'b'], [1, 'a']]
+ */
+declare function cartesianProduct<T extends Array<Iterator<unknown>>>(...sources: T): IteratorObject<{ [K in keyof T]: IteratorValue<T[K]> }, undefined>;
+//#endregion
+export { cartesianProduct };

package/dist/iterator/cartesianProduct.d.ts

@@ -0,0 +1,33 @@
+//#region src/iterator/cartesianProduct.d.ts
+type IteratorValue<T> = T extends Iterator<infer V> ? V : never;
+/**
+ * Lazily computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
+ * of the source iterators, yielding every possible tuple formed by picking one
+ * element from each source, in lexicographic order — the rightmost source
+ * advances fastest, like the digits of an odometer.
+ *
+ * Because every source except the first is traversed many times, those sources
+ * are buffered into arrays when iteration starts. The first source is consumed
+ * lazily, one element at a time, so it may be infinite. When iteration ends —
+ * because the first source ran out, a buffered source was empty, or the
+ * consumer terminated early — every source is closed via its `return` method.
+ *
+ * If no sources are passed, a single empty tuple is yielded, matching the
+ * array `cartesianProduct`. If any source is empty, nothing is yielded.
+ *
+ * @template T - A tuple of the source iterator types.
+ * @param sources - The iterators to take the product of.
+ * @returns A lazy iterator over tuples representing the Cartesian product.
+ *
+ * @example
+ * cartesianProduct([1, 2].values(), ['a', 'b'].values()).toArray();
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ *
+ * @example
+ * // The first source may be infinite; elements are produced on demand.
+ * cartesianProduct(range(0, Infinity), ['a', 'b'].values()).take(3).toArray();
+ * // => [[0, 'a'], [0, 'b'], [1, 'a']]
+ */
+declare function cartesianProduct<T extends Array<Iterator<unknown>>>(...sources: T): IteratorObject<{ [K in keyof T]: IteratorValue<T[K]> }, undefined>;
+//#endregion
+export { cartesianProduct };

package/dist/iterator/cartesianProduct.js

@@ -0,0 +1,95 @@
+const require_iterator = require("./_internal/iterator.js");
+//#region src/iterator/cartesianProduct.ts
+/**
+* Lazily computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
+* of the source iterators, yielding every possible tuple formed by picking one
+* element from each source, in lexicographic order — the rightmost source
+* advances fastest, like the digits of an odometer.
+*
+* Because every source except the first is traversed many times, those sources
+* are buffered into arrays when iteration starts. The first source is consumed
+* lazily, one element at a time, so it may be infinite. When iteration ends —
+* because the first source ran out, a buffered source was empty, or the
+* consumer terminated early — every source is closed via its `return` method.
+*
+* If no sources are passed, a single empty tuple is yielded, matching the
+* array `cartesianProduct`. If any source is empty, nothing is yielded.
+*
+* @template T - A tuple of the source iterator types.
+* @param sources - The iterators to take the product of.
+* @returns A lazy iterator over tuples representing the Cartesian product.
+*
+* @example
+* cartesianProduct([1, 2].values(), ['a', 'b'].values()).toArray();
+* // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+*
+* @example
+* // The first source may be infinite; elements are produced on demand.
+* cartesianProduct(range(0, Infinity), ['a', 'b'].values()).take(3).toArray();
+* // => [[0, 'a'], [0, 'b'], [1, 'a']]
+*/
+function cartesianProduct(...sources) {
+	const pools = [];
+	const indices = [];
+	let firstValue;
+	let state = "initial";
+	return require_iterator.iterator(function() {
+		if (state === "done") return {
+			value: void 0,
+			done: true
+		};
+		if (state === "initial") {
+			state = "active";
+			if (sources.length === 0) {
+				state = "done";
+				return {
+					value: [],
+					done: false
+				};
+			}
+			for (let index = 1; index < sources.length; index++) {
+				const pool = [];
+				let step = sources[index].next();
+				while (!step.done) {
+					pool.push(step.value);
+					step = sources[index].next();
+				}
+				pools.push(pool);
+			}
+			if (pools.some((pool) => pool.length === 0)) return {
+				value: void 0,
+				done: true
+			};
+			const step = sources[0].next();
+			if (step.done) return {
+				value: void 0,
+				done: true
+			};
+			firstValue = step.value;
+			for (let index = 0; index < pools.length; index++) indices.push(0);
+		}
+		const tuple = new Array(sources.length);
+		tuple[0] = firstValue;
+		for (let index = 0; index < indices.length; index++) tuple[index + 1] = pools[index][indices[index]];
+		let position = indices.length - 1;
+		while (position >= 0) {
+			indices[position]++;
+			if (indices[position] < pools[position].length) break;
+			indices[position] = 0;
+			position--;
+		}
+		if (position < 0) {
+			const step = sources[0].next();
+			if (step.done) state = "done";
+			else firstValue = step.value;
+		}
+		return {
+			value: tuple,
+			done: false
+		};
+	}, () => {
+		for (const source of sources) source.return?.();
+	});
+}
+//#endregion
+exports.cartesianProduct = cartesianProduct;

package/dist/iterator/cartesianProduct.mjs

@@ -0,0 +1,95 @@
+import { iterator } from "./_internal/iterator.mjs";
+//#region src/iterator/cartesianProduct.ts
+/**
+* Lazily computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
+* of the source iterators, yielding every possible tuple formed by picking one
+* element from each source, in lexicographic order — the rightmost source
+* advances fastest, like the digits of an odometer.
+*
+* Because every source except the first is traversed many times, those sources
+* are buffered into arrays when iteration starts. The first source is consumed
+* lazily, one element at a time, so it may be infinite. When iteration ends —
+* because the first source ran out, a buffered source was empty, or the
+* consumer terminated early — every source is closed via its `return` method.
+*
+* If no sources are passed, a single empty tuple is yielded, matching the
+* array `cartesianProduct`. If any source is empty, nothing is yielded.
+*
+* @template T - A tuple of the source iterator types.
+* @param sources - The iterators to take the product of.
+* @returns A lazy iterator over tuples representing the Cartesian product.
+*
+* @example
+* cartesianProduct([1, 2].values(), ['a', 'b'].values()).toArray();
+* // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+*
+* @example
+* // The first source may be infinite; elements are produced on demand.
+* cartesianProduct(range(0, Infinity), ['a', 'b'].values()).take(3).toArray();
+* // => [[0, 'a'], [0, 'b'], [1, 'a']]
+*/
+function cartesianProduct(...sources) {
+	const pools = [];
+	const indices = [];
+	let firstValue;
+	let state = "initial";
+	return iterator(function() {
+		if (state === "done") return {
+			value: void 0,
+			done: true
+		};
+		if (state === "initial") {
+			state = "active";
+			if (sources.length === 0) {
+				state = "done";
+				return {
+					value: [],
+					done: false
+				};
+			}
+			for (let index = 1; index < sources.length; index++) {
+				const pool = [];
+				let step = sources[index].next();
+				while (!step.done) {
+					pool.push(step.value);
+					step = sources[index].next();
+				}
+				pools.push(pool);
+			}
+			if (pools.some((pool) => pool.length === 0)) return {
+				value: void 0,
+				done: true
+			};
+			const step = sources[0].next();
+			if (step.done) return {
+				value: void 0,
+				done: true
+			};
+			firstValue = step.value;
+			for (let index = 0; index < pools.length; index++) indices.push(0);
+		}
+		const tuple = new Array(sources.length);
+		tuple[0] = firstValue;
+		for (let index = 0; index < indices.length; index++) tuple[index + 1] = pools[index][indices[index]];
+		let position = indices.length - 1;
+		while (position >= 0) {
+			indices[position]++;
+			if (indices[position] < pools[position].length) break;
+			indices[position] = 0;
+			position--;
+		}
+		if (position < 0) {
+			const step = sources[0].next();
+			if (step.done) state = "done";
+			else firstValue = step.value;
+		}
+		return {
+			value: tuple,
+			done: false
+		};
+	}, () => {
+		for (const source of sources) source.return?.();
+	});
+}
+//#endregion
+export { cartesianProduct };

package/dist/iterator/index.d.mts

@@ -1,3 +1,4 @@
+import { cartesianProduct } from "./cartesianProduct.mjs";
 import { chunk } from "./chunk.mjs";
 import { count } from "./count.mjs";
 import { dropWhile } from "./dropWhile.mjs";
@@ -9,4 +10,4 @@ import { scan } from "./scan.mjs";
 import { takeWhile } from "./takeWhile.mjs";
 import { uniqBy } from "./uniqBy.mjs";
 import { zip } from "./zip.mjs";
-export { chunk, count, dropWhile, head, iterate, partition, range, scan, takeWhile, uniqBy, zip };
+export { cartesianProduct, chunk, count, dropWhile, head, iterate, partition, range, scan, takeWhile, uniqBy, zip };

package/dist/iterator/index.d.ts

@@ -1,3 +1,4 @@
+import { cartesianProduct } from "./cartesianProduct.js";
 import { chunk } from "./chunk.js";
 import { count } from "./count.js";
 import { dropWhile } from "./dropWhile.js";
@@ -9,4 +10,4 @@ import { scan } from "./scan.js";
 import { takeWhile } from "./takeWhile.js";
 import { uniqBy } from "./uniqBy.js";
 import { zip } from "./zip.js";
-export { chunk, count, dropWhile, head, iterate, partition, range, scan, takeWhile, uniqBy, zip };
+export { cartesianProduct, chunk, count, dropWhile, head, iterate, partition, range, scan, takeWhile, uniqBy, zip };

package/dist/iterator/index.js

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_cartesianProduct = require("./cartesianProduct.js");
 const require_chunk = require("./chunk.js");
 const require_count = require("./count.js");
 const require_dropWhile = require("./dropWhile.js");
@@ -10,6 +11,7 @@ const require_uniqBy = require("./uniqBy.js");
 const require_zip = require("./zip.js");
 const require_iterate = require("./iterate.js");
 const require_range = require("./range.js");
+exports.cartesianProduct = require_cartesianProduct.cartesianProduct;
 exports.chunk = require_chunk.chunk;
 exports.count = require_count.count;
 exports.dropWhile = require_dropWhile.dropWhile;

package/dist/iterator/index.mjs

@@ -1,3 +1,4 @@
+import { cartesianProduct } from "./cartesianProduct.mjs";
 import { chunk } from "./chunk.mjs";
 import { count } from "./count.mjs";
 import { dropWhile } from "./dropWhile.mjs";
@@ -9,4 +10,4 @@ import { uniqBy } from "./uniqBy.mjs";
 import { zip } from "./zip.mjs";
 import { iterate } from "./iterate.mjs";
 import { range } from "./range.mjs";
-export { chunk, count, dropWhile, head, iterate, partition, range, scan, takeWhile, uniqBy, zip };
+export { cartesianProduct, chunk, count, dropWhile, head, iterate, partition, range, scan, takeWhile, uniqBy, zip };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.51.0-dev.2069+2ca4fda3",
+  "version": "1.51.0-dev.2070+912e8324",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",