@quilted/create 0.1.49 → 0.1.51

package/build/esm/index2.mjs

@@ -1,365 +1,197 @@
-import path__default from 'node:path';
-import { fileURLToPath } from 'node:url';
-import process from 'node:process';
-import fs__default, { promises } from 'node:fs';
+const flagSymbol = Symbol('arg flag');
 
-/*
-How it works:
-`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
-*/
+class ArgError extends Error {
+	constructor(msg, code) {
+		super(msg);
+		this.name = 'ArgError';
+		this.code = code;
 
-class Node {
-	value;
-	next;
-
-	constructor(value) {
-		this.value = value;
-	}
-}
-
-class Queue {
-	#head;
-	#tail;
-	#size;
-
-	constructor() {
-		this.clear();
-	}
-
-	enqueue(value) {
-		const node = new Node(value);
-
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-
-		this.#size++;
-	}
-
-	dequeue() {
-		const current = this.#head;
-		if (!current) {
-			return;
-		}
-
-		this.#head = this.#head.next;
-		this.#size--;
-		return current.value;
-	}
-
-	clear() {
-		this.#head = undefined;
-		this.#tail = undefined;
-		this.#size = 0;
-	}
-
-	get size() {
-		return this.#size;
-	}
-
-	* [Symbol.iterator]() {
-		let current = this.#head;
-
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-}
-
-function pLimit(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+		Object.setPrototypeOf(this, ArgError.prototype);
 	}
-
-	const queue = new Queue();
-	let activeCount = 0;
-
-	const next = () => {
-		activeCount--;
-
-		if (queue.size > 0) {
-			queue.dequeue()();
-		}
-	};
-
-	const run = async (fn, resolve, args) => {
-		activeCount++;
-
-		const result = (async () => fn(...args))();
-
-		resolve(result);
-
-		try {
-			await result;
-		} catch {}
-
-		next();
-	};
-
-	const enqueue = (fn, resolve, args) => {
-		queue.enqueue(run.bind(undefined, fn, resolve, args));
-
-		(async () => {
-			// This function needs to wait until the next microtask before comparing
-			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-			// when the run function is dequeued and called. The comparison in the if-statement
-			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-			await Promise.resolve();
-
-			if (activeCount < concurrency && queue.size > 0) {
-				queue.dequeue()();
-			}
-		})();
-	};
-
-	const generator = (fn, ...args) => new Promise(resolve => {
-		enqueue(fn, resolve, args);
-	});
-
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount,
-		},
-		pendingCount: {
-			get: () => queue.size,
-		},
-		clearQueue: {
-			value: () => {
-				queue.clear();
-			},
-		},
-	});
-
-	return generator;
 }
 
-class EndError extends Error {
-	constructor(value) {
-		super();
-		this.value = value;
-	}
-}
-
-// The input can also be a promise, so we await it.
-const testElement = async (element, tester) => tester(await element);
-
-// The input can also be a promise, so we `Promise.all()` them both.
-const finder = async element => {
-	const values = await Promise.all(element);
-	if (values[1] === true) {
-		throw new EndError(values[0]);
-	}
-
-	return false;
-};
-
-async function pLocate(
-	iterable,
-	tester,
+function arg(
+	opts,
 	{
-		concurrency = Number.POSITIVE_INFINITY,
-		preserveOrder = true,
-	} = {},
+		argv = process.argv.slice(2),
+		permissive = false,
+		stopAtPositional = false
+	} = {}
 ) {
-	const limit = pLimit(concurrency);
-
-	// Start all the promises concurrently with optional limit.
-	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
-
-	// Check the promises either serially or concurrently.
-	const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
-
-	try {
-		await Promise.all(items.map(element => checkLimit(finder, element)));
-	} catch (error) {
-		if (error instanceof EndError) {
-			return error.value;
-		}
-
-		throw error;
+	if (!opts) {
+		throw new ArgError(
+			'argument specification object is required',
+			'ARG_CONFIG_NO_SPEC'
+		);
 	}
-}
 
-const typeMappings = {
-	directory: 'isDirectory',
-	file: 'isFile',
-};
-
-function checkType(type) {
-	if (type in typeMappings) {
-		return;
-	}
-
-	throw new Error(`Invalid type specified: ${type}`);
-}
-
-const matchType = (type, stat) => type === undefined || stat[typeMappings[type]]();
-
-const toPath$1 = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-async function locatePath(
-	paths,
-	{
-		cwd = process.cwd(),
-		type = 'file',
-		allowSymlinks = true,
-		concurrency,
-		preserveOrder,
-	} = {},
-) {
-	checkType(type);
-	cwd = toPath$1(cwd);
+	const result = { _: [] };
 
-	const statFunction = allowSymlinks ? promises.stat : promises.lstat;
+	const aliases = {};
+	const handlers = {};
 
-	return pLocate(paths, async path_ => {
-		try {
-			const stat = await statFunction(path__default.resolve(cwd, path_));
-			return matchType(type, stat);
-		} catch {
-			return false;
+	for (const key of Object.keys(opts)) {
+		if (!key) {
+			throw new ArgError(
+				'argument key cannot be an empty string',
+				'ARG_CONFIG_EMPTY_KEY'
+			);
 		}
-	}, {concurrency, preserveOrder});
-}
-
-function locatePathSync(
-	paths,
-	{
-		cwd = process.cwd(),
-		type = 'file',
-		allowSymlinks = true,
-	} = {},
-) {
-	checkType(type);
-	cwd = toPath$1(cwd);
-
-	const statFunction = allowSymlinks ? fs__default.statSync : fs__default.lstatSync;
-
-	for (const path_ of paths) {
-		try {
-			const stat = statFunction(path__default.resolve(cwd, path_));
-
-			if (matchType(type, stat)) {
-				return path_;
-			}
-		} catch {}
-	}
-}
-
-const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-const findUpStop = Symbol('findUpStop');
 
-async function findUpMultiple(name, options = {}) {
-	let directory = path__default.resolve(toPath(options.cwd) || '');
-	const {root} = path__default.parse(directory);
-	const stopAt = path__default.resolve(directory, options.stopAt || root);
-	const limit = options.limit || Number.POSITIVE_INFINITY;
-	const paths = [name].flat();
-
-	const runMatcher = async locateOptions => {
-		if (typeof name !== 'function') {
-			return locatePath(paths, locateOptions);
+		if (key[0] !== '-') {
+			throw new ArgError(
+				`argument key must start with '-' but found: '${key}'`,
+				'ARG_CONFIG_NONOPT_KEY'
+			);
 		}
 
-		const foundPath = await name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePath([foundPath], locateOptions);
+		if (key.length === 1) {
+			throw new ArgError(
+				`argument key must have a name; singular '-' keys are not allowed: ${key}`,
+				'ARG_CONFIG_NONAME_KEY'
+			);
 		}
 
-		return foundPath;
-	};
-
-	const matches = [];
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		// eslint-disable-next-line no-await-in-loop
-		const foundPath = await runMatcher({...options, cwd: directory});
-
-		if (foundPath === findUpStop) {
-			break;
+		if (typeof opts[key] === 'string') {
+			aliases[key] = opts[key];
+			continue;
 		}
 
-		if (foundPath) {
-			matches.push(path__default.resolve(directory, foundPath));
-		}
-
-		if (directory === stopAt || matches.length >= limit) {
-			break;
-		}
-
-		directory = path__default.dirname(directory);
-	}
-
-	return matches;
-}
-
-function findUpMultipleSync(name, options = {}) {
-	let directory = path__default.resolve(toPath(options.cwd) || '');
-	const {root} = path__default.parse(directory);
-	const stopAt = options.stopAt || root;
-	const limit = options.limit || Number.POSITIVE_INFINITY;
-	const paths = [name].flat();
+		let type = opts[key];
+		let isFlag = false;
 
-	const runMatcher = locateOptions => {
-		if (typeof name !== 'function') {
-			return locatePathSync(paths, locateOptions);
+		if (
+			Array.isArray(type) &&
+			type.length === 1 &&
+			typeof type[0] === 'function'
+		) {
+			const [fn] = type;
+			type = (value, name, prev = []) => {
+				prev.push(fn(value, name, prev[prev.length - 1]));
+				return prev;
+			};
+			isFlag = fn === Boolean || fn[flagSymbol] === true;
+		} else if (typeof type === 'function') {
+			isFlag = type === Boolean || type[flagSymbol] === true;
+		} else {
+			throw new ArgError(
+				`type missing or not a function or valid array type: ${key}`,
+				'ARG_CONFIG_VAD_TYPE'
+			);
 		}
 
-		const foundPath = name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePathSync([foundPath], locateOptions);
+		if (key[1] !== '-' && key.length > 2) {
+			throw new ArgError(
+				`short argument keys (with a single hyphen) must have only one character: ${key}`,
+				'ARG_CONFIG_SHORTOPT_TOOLONG'
+			);
 		}
 
-		return foundPath;
-	};
+		handlers[key] = [type, isFlag];
+	}
 
-	const matches = [];
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		const foundPath = runMatcher({...options, cwd: directory});
+	for (let i = 0, len = argv.length; i < len; i++) {
+		const wholeArg = argv[i];
 
-		if (foundPath === findUpStop) {
+		if (stopAtPositional && result._.length > 0) {
+			result._ = result._.concat(argv.slice(i));
 			break;
 		}
 
-		if (foundPath) {
-			matches.push(path__default.resolve(directory, foundPath));
-		}
-
-		if (directory === stopAt || matches.length >= limit) {
+		if (wholeArg === '--') {
+			result._ = result._.concat(argv.slice(i + 1));
 			break;
 		}
 
-		directory = path__default.dirname(directory);
+		if (wholeArg.length > 1 && wholeArg[0] === '-') {
+			/* eslint-disable operator-linebreak */
+			const separatedArguments =
+				wholeArg[1] === '-' || wholeArg.length === 2
+					? [wholeArg]
+					: wholeArg
+							.slice(1)
+							.split('')
+							.map((a) => `-${a}`);
+			/* eslint-enable operator-linebreak */
+
+			for (let j = 0; j < separatedArguments.length; j++) {
+				const arg = separatedArguments[j];
+				const [originalArgName, argStr] =
+					arg[1] === '-' ? arg.split(/=(.*)/, 2) : [arg, undefined];
+
+				let argName = originalArgName;
+				while (argName in aliases) {
+					argName = aliases[argName];
+				}
+
+				if (!(argName in handlers)) {
+					if (permissive) {
+						result._.push(arg);
+						continue;
+					} else {
+						throw new ArgError(
+							`unknown or unexpected option: ${originalArgName}`,
+							'ARG_UNKNOWN_OPTION'
+						);
+					}
+				}
+
+				const [type, isFlag] = handlers[argName];
+
+				if (!isFlag && j + 1 < separatedArguments.length) {
+					throw new ArgError(
+						`option requires argument (but was followed by another short argument): ${originalArgName}`,
+						'ARG_MISSING_REQUIRED_SHORTARG'
+					);
+				}
+
+				if (isFlag) {
+					result[argName] = type(true, argName, result[argName]);
+				} else if (argStr === undefined) {
+					if (
+						argv.length < i + 2 ||
+						(argv[i + 1].length > 1 &&
+							argv[i + 1][0] === '-' &&
+							!(
+								argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) &&
+								(type === Number ||
+									// eslint-disable-next-line no-undef
+									(typeof BigInt !== 'undefined' && type === BigInt))
+							))
+					) {
+						const extended =
+							originalArgName === argName ? '' : ` (alias for ${argName})`;
+						throw new ArgError(
+							`option requires argument: ${originalArgName}${extended}`,
+							'ARG_MISSING_REQUIRED_LONGARG'
+						);
+					}
+
+					result[argName] = type(argv[i + 1], argName, result[argName]);
+					++i;
+				} else {
+					result[argName] = type(argStr, argName, result[argName]);
+				}
+			}
+		} else {
+			result._.push(wholeArg);
+		}
 	}
 
-	return matches;
+	return result;
 }
 
-async function findUp(name, options = {}) {
-	const matches = await findUpMultiple(name, {...options, limit: 1});
-	return matches[0];
-}
+arg.flag = (fn) => {
+	fn[flagSymbol] = true;
+	return fn;
+};
 
-function findUpSync(name, options = {}) {
-	const matches = findUpMultipleSync(name, {...options, limit: 1});
-	return matches[0];
-}
+// Utility types
+arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
 
-async function packageDirectory({cwd} = {}) {
-	const filePath = await findUp('package.json', {cwd});
-	return filePath && path__default.dirname(filePath);
-}
+// Expose error class
+arg.ArgError = ArgError;
 
-function packageDirectorySync({cwd} = {}) {
-	const filePath = findUpSync('package.json', {cwd});
-	return filePath && path__default.dirname(filePath);
-}
+var arg_1 = arg;
 
-export { packageDirectory, packageDirectorySync };
+export { arg_1 as a };