pncat/dist/p-map-D6mIQARQ.mjs

A unified cli tool that enhances package managers catalogs feature.

import { n as __esmMin } from "./chunk-6qLfnLNH.mjs";

//#region node_modules/.pnpm/p-map@7.0.3/node_modules/p-map/index.js
async function pMap(iterable, mapper, { concurrency = Number.POSITIVE_INFINITY, stopOnError = true, signal } = {}) {
	return new Promise((resolve_, reject_) => {
		if (iterable[Symbol.iterator] === void 0 && iterable[Symbol.asyncIterator] === void 0) throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
		if (typeof mapper !== "function") throw new TypeError("Mapper function is required");
		if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
		const result = [];
		const errors = [];
		const skippedIndexesMap = /* @__PURE__ */ new Map();
		let isRejected = false;
		let isResolved = false;
		let isIterableDone = false;
		let resolvingCount = 0;
		let currentIndex = 0;
		const iterator = iterable[Symbol.iterator] === void 0 ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
		const signalListener = () => {
			reject(signal.reason);
		};
		const cleanup = () => {
			signal?.removeEventListener("abort", signalListener);
		};
		const resolve = (value) => {
			resolve_(value);
			cleanup();
		};
		const reject = (reason) => {
			isRejected = true;
			isResolved = true;
			reject_(reason);
			cleanup();
		};
		if (signal) {
			if (signal.aborted) reject(signal.reason);
			signal.addEventListener("abort", signalListener, { once: true });
		}
		const next = async () => {
			if (isResolved) return;
			const nextItem = await iterator.next();
			const index = currentIndex;
			currentIndex++;
			if (nextItem.done) {
				isIterableDone = true;
				if (resolvingCount === 0 && !isResolved) {
					if (!stopOnError && errors.length > 0) {
						reject(new AggregateError(errors));
						return;
					}
					isResolved = true;
					if (skippedIndexesMap.size === 0) {
						resolve(result);
						return;
					}
					const pureResult = [];
					for (const [index$1, value] of result.entries()) {
						if (skippedIndexesMap.get(index$1) === pMapSkip) continue;
						pureResult.push(value);
					}
					resolve(pureResult);
				}
				return;
			}
			resolvingCount++;
			(async () => {
				try {
					const element = await nextItem.value;
					if (isResolved) return;
					const value = await mapper(element, index);
					if (value === pMapSkip) skippedIndexesMap.set(index, value);
					result[index] = value;
					resolvingCount--;
					await next();
				} catch (error) {
					if (stopOnError) reject(error);
					else {
						errors.push(error);
						resolvingCount--;
						try {
							await next();
						} catch (error$1) {
							reject(error$1);
						}
					}
				}
			})();
		};
		(async () => {
			for (let index = 0; index < concurrency; index++) {
				try {
					await next();
				} catch (error) {
					reject(error);
					break;
				}
				if (isIterableDone || isRejected) break;
			}
		})();
	});
}
var pMapSkip;
var init_p_map = __esmMin((() => {
	pMapSkip = Symbol("skip");
}));

//#endregion
init_p_map();
export { pMap as default };