@rzl-zone/build-tools 0.0.10 → 0.0.12-beta.0

package/dist/index.js

@@ -2,22 +2,22 @@
 * ========================================================================
 *  @rzl-zone/build-tools
 * ------------------------------------------------------------------------
-*  Version: `0.0.10`
+*  Version: `0.0.12-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
 * ========================================================================
 */
 
-import { S as toStringSet, _ as isUndefined, a as isError, d as isNumber, g as isString, h as isSet, i as isBoolean, l as isNonEmptyString, m as isRegExp, n as flattenStrings, p as isPlainObject, r as isArray, v as normalizeSpaces, x as toObjectSet, y as safeStableStringify } from "./helper-CWU8QYq3.js";
-import { a as resolvePatternOptions, i as defaultPatternOptions, n as fsExtra, o as sourceOfPatternOptions, r as ICONS, t as fastGlob } from "./server-BA7ruG1h.js";
-import { t as CommandIdentity } from "./identity-xuDCNgfm.js";
-import { a as joinInline, i as formatOptionValue, l as picocolors, n as EOL, o as joinLines, s as joinLinesLoose, u as plural } from "./client-BmfdVI22.js";
-import { n as getPackageJson, t as generatePackageBanner } from "./package-banner-BmLNyezO.js";
+import { C as isString, E as safeStableStringify, O as toObjectSet, S as isSet, _ as isNonEmptyString, b as isPlainObject, c as picocolors, d as flattenStrings, f as isArray, i as joinInline, k as toStringSet, l as plural, o as joinLinesLoose, p as isBoolean, r as formatOptionValue, t as EOL, w as isUndefined, x as isRegExp, y as isNumber } from "./formatter-BS3omf7k.js";
+import { c as resolvePatternOptions, i as sourceOf, l as sourceOfPatternOptions, n as fsExtra, r as BUILD_LOGGER, s as defaultPatternOptions, t as fastGlob } from "./server-Owi9-DW1.js";
+import { t as CommandIdentity } from "./identity-Cznri5bj.js";
+import { n as getPackageJson, t as generatePackageBanner } from "./package-banner-Jw1DuF8v.js";
 import "@rzl-zone/node-only";
 import * as t from "@babel/types";
 import { parse } from "@babel/parser";
 import traverseImport from "@babel/traverse";
 import path from "node:path";
+import { parse as parse$2 } from "shell-quote";
 import { ChildProcess, spawn } from "node:child_process";
 import * as acorn from "acorn";
 function isLogLevel(value) {
@@ -186,58 +186,6 @@ function stripUseStrict(content, { trimStart = true, trimEnd = false } = {}) {
 	if (trimEnd) result.trimEnd();
 	return result;
 }
-const sourceOf = (value, defaultValue) => {
-	return Object.is(value, defaultValue) ? "default" : "overridden";
-};
-const BUILD_LOGGER = {
-	SOURCE_OF: sourceOf,
-	OPTIONS(label, value, source, isRequired) {
-		const sourceLabel = !isRequired && source ? source === "default" ? picocolors.blueBright(` (${source})`) : picocolors.yellowBright(` (${source})`) : "";
-		console.log(picocolors.dim("  - ") + normalizeSpaces(picocolors.bold(label || "`⚠️ Label Unset!!!`") + picocolors.dim(": ") + formatOptionValue(value) + picocolors.italic(sourceLabel)));
-	},
-	SECTION(title, options = {}) {
-		const { icon = ICONS.config, indent = "" } = options;
-		console.log(picocolors.bold(`${indent}${picocolors.whiteBright(icon)} ${picocolors.underline(picocolors.cyanBright(title || "`⚠️ Unset Title!!!`"))}:`));
-	},
-	NEW_LINE(value = "") {
-		return console.log(value);
-	},
-	ON_STARTING: (options) => {
-		const { actionName, textDirectAction = "to" } = options;
-		console.log(picocolors.bold(`${picocolors.whiteBright(ICONS.start)} ${picocolors.cyanBright("Starting")} ${normalizeSpaces(`${textDirectAction} ${picocolors.underline(picocolors.blueBright(actionName))}`)}.`));
-	},
-	ON_FINISH: (options) => {
-		const { actionName, count, typeCount = "file", progress, textSuccess = "Success" } = options;
-		console.log(picocolors.bold(`${picocolors.greenBright(ICONS.success)} ${picocolors.greenBright(textSuccess)} ${normalizeSpaces(`${picocolors.underline(picocolors.blueBright(actionName))} (${picocolors.yellowBright(`${isNonEmptyString(progress) ? progress : count} ${typeCount}${count > 1 ? "(s)" : ""}`)}`)}).`));
-	},
-	ON_SKIPPING: (options) => {
-		const { actionName, reasonEndText, reasonSkipAction = "nothing left", reasonTitle = "because", reasonType = "files", textDirectAction = "to" } = options;
-		console.log(picocolors.bold(`${picocolors.yellowBright(ICONS.warn)} ${picocolors.yellowBright("Skipping")} ${normalizeSpaces(`${picocolors.underline(picocolors.blueBright(actionName))} ${picocolors.white(reasonTitle)} ${picocolors.redBright(reasonSkipAction)} ${reasonType} ${textDirectAction} ${picocolors.redBright(reasonEndText)}`)}.`));
-	},
-	ON_ERROR: (options) => {
-		const { actionName, textDirectAction = "to", error } = options;
-		const errorMsg = isError(error) ? error.message : "Something went wrong";
-		console.error(picocolors.bold(`${picocolors.redBright(ICONS.error)} ${picocolors.redBright("Error")} ${normalizeSpaces(`${textDirectAction} ${picocolors.underline(picocolors.blueBright(actionName))},`)} ${joinLines("because: ", "", `  ${picocolors.bold(picocolors.red(ICONS.arrowRight))} ${picocolors.inverse(picocolors.red(normalizeSpaces(errorMsg)))}`)}`));
-	},
-	ON_PROCESS: (options) => {
-		const { actionName, count, nameDirect, textDirectFolder = "in" } = options;
-		console.log(`${picocolors.bold("  " + picocolors.whiteBright(ICONS.bullet))} ${picocolors.italic(`${picocolors.white(count + ".")} ${normalizeSpaces(`${picocolors.white(actionName)} ${picocolors.magentaBright(textDirectFolder)} ${picocolors.bold(picocolors.underline(picocolors.blue(nameDirect)))}.`)}`)}`);
-	},
-	ON_PROCESS_COPY: (options) => {
-		const { actionName, count, copyTo, copyFrom, textFrom = "from", textArrow = "➔" } = options;
-		console.log(`${picocolors.bold("  " + picocolors.whiteBright(ICONS.bullet))} ${picocolors.italic(`${picocolors.white(count + ".")} ${normalizeSpaces(`${picocolors.white(actionName)} ${picocolors.yellow(textFrom)} '${picocolors.bold(picocolors.underline(picocolors.cyanBright(copyFrom)))}' ${picocolors.bold(picocolors.gray(textArrow))} '${picocolors.bold(picocolors.underline(picocolors.cyanBright(copyTo)))}'.`)}`)}`);
-	},
-	ON_PROCESS_COPY_ERROR: (options) => {
-		const { actionName, count, errorReason, copyFrom, index, indexKey, textFrom = "from", textReason = "because" } = options;
-		const errorReasonText = isError(errorReason) ? errorReason.message : String(errorReason);
-		const atIndexText = isNumber(index) ? picocolors.blueBright(` (at${isNonEmptyString(indexKey) ? ` '${indexKey}' ` : " "}index: ${picocolors.magentaBright(index)}) `) : " ";
-		console.log(`${picocolors.bold("  " + picocolors.whiteBright(ICONS.bullet))} ${picocolors.italic(`${picocolors.white(count + ".")} ${normalizeSpaces(`${picocolors.redBright(actionName)} ${picocolors.yellow(textFrom)} '${picocolors.bold(picocolors.underline(picocolors.cyanBright(copyFrom)))}'${atIndexText}${picocolors.bold(picocolors.gray(textReason))} ${picocolors.redBright(errorReasonText)}.`)}`)}`);
-	},
-	ON_PROCESS_REFERENCING: (options) => {
-		const { actionName, count, referenceTo, referenceFrom, textFrom = "from", textArrow = "➔" } = options;
-		console.log(`${picocolors.bold("  " + picocolors.whiteBright(ICONS.bullet))} ${picocolors.italic(`${picocolors.white(count + ".")} ${normalizeSpaces(`${picocolors.white(actionName)} ${picocolors.magentaBright(textFrom)} ${picocolors.bold(picocolors.underline(picocolors.cyanBright(referenceFrom)))} ${picocolors.bold(picocolors.gray(textArrow))} ${picocolors.bold(picocolors.underline(picocolors.blueBright(referenceTo)))}.`)}`)}`);
-	}
-};
 function stripLineArtifacts(line, options) {
 	let out = line.replace(/^[ \t]*\/\/\s*(?:\.\.\/|\.\/)*[^ \n]*?(?:src|node_modules)\/[^\n]*\n?/gm, "").replace(/\/\/\s*eslint[^\n]*/g, "");
 	if (options.removeSourceMap) out = out.replace(/^[ \t]*\/\/[#@]\s*sourceMappingURL\s*=\s*\S+/gm, "");
@@ -1155,31 +1103,44 @@ const normalizeJsBuildNewlines = async (pattern, options = {}) => {
 	}
 };
 function runCommand(command, argsOrOptions = [], maybeOptions = {}) {
-	assertValidCommand(command);
-	let args;
-	let options;
-	if (Array.isArray(argsOrOptions)) {
-		args = argsOrOptions;
-		options = maybeOptions;
-	} else {
-		args = [];
-		options = argsOrOptions;
-	}
 	return new Promise((resolve, reject) => {
-		const { shell = true, stdio = "inherit", argv0: _argv0, useColors = true, ...restOption } = options;
-		const { child, setupLifecycle, cmdStringPlain } = spawnWithLifecycle(command, args, {
-			...restOption,
-			stdio,
-			useColors,
-			shell
-		}, { rejectOnNonZero: true });
-		setupLifecycle({
-			onSuccess: (code) => {
-				if (code === 0) resolve(child);
-				else reject(/* @__PURE__ */ new Error(`${cmdStringPlain} exited with code ${code}`));
-			},
-			onError: reject
-		});
+		try {
+			let args;
+			let options;
+			const isArgsArray = isArray(argsOrOptions);
+			if (isArgsArray) {
+				args = argsOrOptions;
+				options = maybeOptions;
+			} else {
+				args = [];
+				options = argsOrOptions;
+			}
+			assertValidCommand(command, {
+				apiType: "runCommand",
+				useColors: options.useColors,
+				allowInline: !isArgsArray
+			});
+			const { shell = true, stdio = "inherit", argv0: _argv0, useColors = true, ...restOption } = options;
+			const { child, setupLifecycle, cmdStringPlain } = spawnWithLifecycle(command, args, {
+				...restOption,
+				stdio,
+				useColors,
+				shell
+			}, { rejectOnNonZero: true });
+			setupLifecycle({
+				onSuccess: (code) => {
+					if (code === 0) resolve(child);
+					else reject(/* @__PURE__ */ new Error(`${cmdStringPlain} exited with code ${code}`));
+				},
+				onError: reject
+			});
+		} catch (err) {
+			const e = err instanceof Error ? err : new Error(String(err));
+			const cleanedBase = stripInternalStack(((/* @__PURE__ */ new Error()).stack?.split(EOL).slice(1) ?? []).filter((line) => !line.includes("runCommand")));
+			e.stack = [e.message, ...cleanedBase].join(EOL);
+			reject(e);
+			return;
+		}
 	});
 }
 function normalizeChunk(chunk) {
@@ -1188,74 +1149,89 @@ function normalizeChunk(chunk) {
 	return String(chunk);
 }
 function runCommandCapture(command, argsOrOptions = [], maybeOptions = {}) {
-	assertValidCommand(command);
-	let args;
-	let options;
-	if (Array.isArray(argsOrOptions)) {
-		args = argsOrOptions;
-		options = maybeOptions;
-	} else {
-		args = [];
-		options = argsOrOptions;
-	}
-	const { shell = true, signal, timeout, forceKill, useColors = true, argv0: _argv0, ...restOption } = options;
 	return new Promise((resolve, reject) => {
-		const { child, setupLifecycle } = spawnWithLifecycle(command, args, {
-			...restOption,
-			stdio: "pipe",
-			shell,
-			signal,
-			timeout,
-			forceKill,
-			useColors
-		}, { rejectOnNonZero: false });
-		let stdout = "";
-		let stderr = "";
-		child.stdout?.on("data", (chunk) => {
-			stdout += normalizeChunk(chunk);
-		});
-		child.stderr?.on("data", (chunk) => {
-			stderr += normalizeChunk(chunk);
-		});
-		setupLifecycle({
-			onSuccess: (code) => {
-				resolve({
-					stdout: stdout.trimEnd(),
-					stderr: stderr.trimEnd(),
-					exitCode: code,
-					ok: code === 0
-				});
-			},
-			onError: reject
-		});
+		try {
+			let args;
+			let options;
+			const isArgsArray = isArray(argsOrOptions);
+			if (isArgsArray) {
+				args = argsOrOptions;
+				options = maybeOptions;
+			} else {
+				args = [];
+				options = argsOrOptions;
+			}
+			assertValidCommand(command, {
+				apiType: "runCommandCapture",
+				useColors: options.useColors,
+				allowInline: !isArgsArray
+			});
+			const { shell = true, signal, timeout, forceKill, useColors = true, argv0: _argv0, ...restOption } = options;
+			const { child, setupLifecycle } = spawnWithLifecycle(command, args, {
+				...restOption,
+				stdio: "pipe",
+				shell,
+				signal,
+				timeout,
+				forceKill,
+				useColors
+			}, { rejectOnNonZero: false });
+			let stdout = "";
+			let stderr = "";
+			child.stdout?.on("data", (chunk) => {
+				stdout += normalizeChunk(chunk);
+			});
+			child.stderr?.on("data", (chunk) => {
+				stderr += normalizeChunk(chunk);
+			});
+			setupLifecycle({
+				onSuccess: (code) => {
+					resolve({
+						stdout: stdout.trimEnd(),
+						stderr: formatMessageColor(stderr.trimEnd(), useColors),
+						exitCode: code,
+						ok: code === 0
+					});
+				},
+				onError: reject
+			});
+		} catch (err) {
+			const e = err instanceof Error ? err : new Error(String(err));
+			const cleanedBase = stripInternalStack(((/* @__PURE__ */ new Error()).stack?.split(EOL).slice(1) ?? []).filter((line) => !line.includes("runCommandCapture")));
+			e.stack = [e.message, ...cleanedBase].join(EOL);
+			reject(e);
+			return;
+		}
 	});
 }
+const formatMessageColor = (message, useColors = true) => {
+	return useColors ? picocolors.redBright(message) : message;
+};
 function formatCommand(command, args, { useColors = true } = {}) {
 	const hasArgs = args.length > 0;
 	const argsString = hasArgs ? args.map((a) => safeStableStringify(a)).join(" ") : "";
-	if (useColors) {
-		const cmd = picocolors.cyanBright(command);
-		return hasArgs ? `${cmd} ${picocolors.gray(argsString)}` : cmd;
-	}
-	return hasArgs ? `${command} ${argsString}` : command;
+	if (!hasArgs) return formatMessageColor(command, useColors);
+	if (useColors) return `${picocolors.cyanBright(command)} ${picocolors.gray(argsString)}`;
+	return `${command} ${argsString}`;
 }
-function assertValidCommand(command, { useColors = true } = {}) {
-	if (typeof command !== "string") {
+function assertValidCommand(command, options) {
+	const { useColors = true, allowInline = false, apiType } = options || {};
+	if (!isString(command)) {
 		const errorMsg = `Invalid command: expected a string, received ${safeStableStringify(command)}`;
-		throw new TypeError(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+		throw new TypeError(formatMessageColor(errorMsg, useColors));
 	}
 	const trimmed = command.trim();
-	if (trimmed.length === 0) {
-		const errorMsg = "Invalid command: command cannot be empty";
-		throw new Error(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+	if (trimmed.length === 0) throw new Error(formatMessageColor("Invalid command: command cannot be empty", useColors));
+	const hasSpace = /\s/.test(trimmed);
+	if (hasShellSyntax(trimmed)) {
+		const errorMsg = joinLinesLoose(`Invalid command: "${trimmed}"`, "Shell operators are not supported in this context (e.g. &&, ||, |, >).", "This utility only supports a single command with arguments.");
+		throw new Error(formatMessageColor(errorMsg, useColors));
 	}
-	const hasSpace = trimmed.includes(" ");
-	const hasQuotes = /['"`]/.test(trimmed);
-	const hasShellOps = /[|&;<>(){}$]/.test(trimmed);
-	if (hasSpace || hasQuotes || hasShellOps) {
+	if (!allowInline && hasSpace) {
 		const [cmd, ...rest] = trimmed.split(/\s+/);
-		const errorMsg = joinLinesLoose(`Invalid command: "${trimmed}"`, "Do not pass a full shell command.", `Use arguments instead: runCommand("${cmd}", ${safeStableStringify(rest)})`);
-		throw new Error(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+		if (!cmd) throw new Error("Invalid command: unable to resolve executable.");
+		const errorMsg = joinLinesLoose(`Invalid command: "${trimmed}"`, "Do not include arguments in the command when passing them separately.", `Use: ${apiType}("${cmd}", ${safeStableStringify(rest)})`);
+		throw new Error(formatMessageColor(errorMsg, useColors));
 	}
 }
 function stripInternalStack(lines) {
@@ -1267,8 +1243,10 @@ function stripInternalStack(lines) {
 		"createProcessError",
 		"formatError",
 		"spawnWithLifecycle",
+		"assertValidCommand",
 		"setupLifecycle",
-		"node:internal"
+		"node:internal",
+		"node:internal/process/promises"
 	];
 	return lines.filter((line) => {
 		if (blacklist.some((key) => line.includes(key))) return false;
@@ -1335,29 +1313,70 @@ var CommandProcessError = class extends Error {
 function isCommandProcessError(err) {
 	return err instanceof CommandProcessError;
 }
+function hasShellSyntax(str) {
+	return /(\|\||&&|[|&;<>\n])/.test(str);
+}
+function resolveCommand(input, useColors = true) {
+	const tokens = parse$2(input);
+	const normalized = [];
+	for (const t of tokens) {
+		if (typeof t === "string") {
+			normalized.push(t);
+			continue;
+		}
+		if ("comment" in t) continue;
+		if ("pattern" in t) {
+			normalized.push(t.pattern);
+			continue;
+		}
+		if ("op" in t) throw new Error(formatMessageColor("Unsupported shell operator detected.", useColors));
+		throw new Error(formatMessageColor("Unknown token in command.", useColors));
+	}
+	if (normalized.length === 0) throw new Error(formatMessageColor("Invalid command: empty after parsing.", useColors));
+	const [cmd, ...args] = normalized;
+	if (!cmd) throw new Error(formatMessageColor("Invalid command: empty after parsing.", useColors));
+	return {
+		command: cmd,
+		args
+	};
+}
 function spawnWithLifecycle(command, args, options, config) {
-	const { useColors = true, timeout, forceKill, signal: abortSignal, ...restOption } = options;
+	const { useColors = true, timeout, forceKill, signal: abortSignal, shell = false, ...restOption } = options;
+	let cmd = command;
+	let finalArgs = [...args];
+	const isInline = finalArgs.length === 0 && /\s/.test(cmd);
 	const baseStack = (/* @__PURE__ */ new Error()).stack;
-	const cmdString = formatCommand(command, args, { useColors });
-	const cmdStringPlain = formatCommand(command, args, { useColors: false });
 	const formatError = config?.formatError ?? ((msg, meta) => {
 		const metaCommand = meta.command.trim();
-		const argsString = meta.args.length > 0 ? meta.args.map((a) => safeStableStringify(a).trim()).join(" ") : "";
+		const hasArgs = meta.args.length > 0;
+		const argsString = hasArgs ? meta.args.map((a) => safeStableStringify(a).trim()).join(" ") : "";
+		const commandString = hasArgs ? `${metaCommand} ${argsString}` : metaCommand;
 		if (meta.useColors) {
 			const cmd = picocolors.magentaBright(metaCommand);
-			const args = argsString ? picocolors.yellowBright(argsString) : "";
+			const args = hasArgs ? picocolors.yellowBright(argsString) : "";
 			return createProcessError(`${cmd}${args ? " " + args : ""} ${picocolors.redBright(msg)}`, {
 				...meta,
-				command: `${metaCommand} ${argsString}`
+				command: commandString
 			}, baseStack);
 		}
-		return createProcessError(`${metaCommand}${isNonEmptyString(argsString) ? " " + argsString : ""} ${msg}`, {
+		return createProcessError(`${commandString} ${msg}`, {
 			...meta,
-			command: `${metaCommand} ${argsString}`
+			command: commandString
 		}, baseStack);
 	});
 	const rejectOnNonZero = config?.rejectOnNonZero ?? false;
-	const child = spawn(command, [...args], restOption);
+	if (isInline) {
+		const resolved = resolveCommand(cmd, useColors);
+		cmd = resolved.command;
+		finalArgs = resolved.args;
+	}
+	for (const arg of finalArgs) if (hasShellSyntax(arg)) throw new Error(formatMessageColor(`Invalid argument: "${arg}" contains unsupported shell syntax`, useColors));
+	const cmdString = formatCommand(cmd, finalArgs, { useColors });
+	const cmdStringPlain = formatCommand(cmd, finalArgs, { useColors: false });
+	const child = spawn(cmd, finalArgs, {
+		shell,
+		...restOption
+	});
 	let finished = false;
 	const kill = () => {
 		try {
@@ -1382,8 +1401,8 @@ function spawnWithLifecycle(command, args, options, config) {
 				kill();
 				fail(formatError(`timed out after ${timeout}ms`, {
 					reason: "timeout",
-					command,
-					args,
+					command: cmd,
+					args: finalArgs,
 					useColors
 				}));
 			}, timeout) : null;
@@ -1407,8 +1426,8 @@ function spawnWithLifecycle(command, args, options, config) {
 				kill();
 				fail(formatError("aborted by signal", {
 					reason: "abort",
-					command,
-					args,
+					command: cmd,
+					args: finalArgs,
 					useColors
 				}));
 			};
@@ -1426,8 +1445,8 @@ function spawnWithLifecycle(command, args, options, config) {
 						reason: "signal",
 						signal,
 						exitCode: code ?? void 0,
-						command,
-						args,
+						command: cmd,
+						args: finalArgs,
 						useColors
 					}));
 					return;
@@ -1437,8 +1456,8 @@ function spawnWithLifecycle(command, args, options, config) {
 					fail(formatError(`exited with code ${exitCode}`, {
 						reason: "non-zero exit code",
 						exitCode,
-						command,
-						args,
+						command: cmd,
+						args: finalArgs,
 						useColors
 					}));
 					return;