@adbayb/stack 2.40.0 → 3.0.0

package/dist/index.js

@@ -6,26 +6,25 @@ import { chmod, cp, mkdir, readFile, readdir, rename, rm, symlink, writeFile } f
 
 //#region src/helpers.ts
 const require = createRequire(import.meta.url);
-function assert(expectedCondition, createError) {
+const assert = (expectedCondition, createError) => {
 	if (!expectedCondition) throw createError();
-}
+};
 /**
 * Helper to format log messages with a welcoming bot.
+*
+* @example
+* 	botMessage({
+* 		title: "Oops, an error occurred",
+* 		description: "Keep calm and carry on with some coffee ☕️",
+* 		body: String(previousTaskError),
+* 		type: "error",
+* 	});
+*
 * @param input - Message factory.
 * @param input.title - Title input.
 * @param input.description - Description input.
 * @param input.body - Body input.
 * @param input.type - Message type.
-* @example
-* botMessage(
-*	{
-* 		title: "Oops, an error occurred",
-* 		description:
-* 			"Keep calm and carry on with some coffee ☕️",
-* 		body: String(previousTaskError),
-* 		type: "error",
-* 	},
-* );
 */
 const botMessage = (input) => {
 	const { type } = input;
@@ -45,20 +44,24 @@ ${input.body}
 };
 /**
 * Resolve a relative path to an absolute one resolved from the generated project root directory.
+*
+* @example
+* 	resolveFromWorkingDirectory(".gitignore");
+*
 * @param path - The relative path.
 * @returns The resolved absolute path.
-* @example
-* resolveFromWorkingDirectory(".gitignore");
 */
 const resolveFromWorkingDirectory = (...path) => {
 	return resolve(process.cwd(), ...path);
 };
 /**
 * Resolve a relative path to an absolute one resolved from the `stack` node module directory.
+*
+* @example
+* 	resolveFromPackageDirectory("./templates");
+*
 * @param path - The relative path.
 * @returns The resolved absolute path.
-* @example
-* resolveFromPackageDirectory("./templates");
 */
 const resolveFromPackageDirectory = (...path) => {
 	return resolve(import.meta.dirname, "../", ...path);
@@ -81,15 +84,14 @@ const getPnpmVersion = async () => {
 const getStackCommand = (command) => {
 	return `pnpm stack ${command}`;
 };
-const hasDependency = (packageName) => {
-	return Boolean(require.resolve(packageName));
-};
 const setPackageManager = async () => {
 	/**
-	* Corepack is downloaded remotely to get always up-to-date npm registry fingerprints since they're hardcoded.
+	* Corepack is downloaded remotely to get always up-to-date npm registry fingerprints since
+	* they're hardcoded.
+	*
 	* @see {@link https://github.com/nodejs/corepack/issues/613}
 	*/
-	return helpers.exec("pnx corepack enable");
+	await helpers.exec("pnx corepack enable");
 };
 const request = { async get(url, responseType) {
 	const response = await fetch(url);
@@ -97,29 +99,37 @@ const request = { async get(url, responseType) {
 		status: response.status,
 		statusText: response.statusText
 	})})`);
-	return response[responseType === "text" ? "text" : "json"]();
+	return responseType === "text" ? response.text() : response.json();
 } };
-const eslint = (options) => async (files = []) => {
-	let eslintFiles = [];
-	if (files.length === 0) eslintFiles.push(".");
-	else {
-		eslintFiles = files.filter((file) => {
-			return ESLINT_EXTENSIONS.some((extension) => file.endsWith(extension));
-		});
-		if (eslintFiles.length === 0) return;
-	}
-	const arguments_ = [
-		...eslintFiles,
-		"--cache",
-		`--cache-location ${resolveFromWorkingDirectory("node_modules/.cache/.eslintcache")}`,
-		"--no-error-on-unmatched-pattern"
-	];
-	if (options.isFixMode) arguments_.push("--fix");
-	try {
-		return await helpers.exec(`eslint ${arguments_.join(" ")}`);
-	} catch (error) {
-		throw createError("eslint", error);
-	}
+const oxlint = (options) => {
+	return async (files = []) => {
+		const args = [
+			...files,
+			"--disable-nested-config",
+			"--no-error-on-unmatched-pattern"
+		];
+		if (options.isFixMode) args.push("--fix-dangerously");
+		try {
+			return await helpers.exec(`oxlint ${args.join(" ")}`);
+		} catch (error) {
+			throw createError("oxlint", error instanceof Error ? error : new Error(String(error)));
+		}
+	};
+};
+const oxfmt = (options) => {
+	return async (files = []) => {
+		const args = [
+			...files,
+			"--disable-nested-config",
+			"--no-error-on-unmatched-pattern",
+			options.isFixMode ? "--write" : "--check"
+		];
+		try {
+			return await helpers.exec(`oxfmt ${args.join(" ")}`);
+		} catch (error) {
+			throw createError("oxfmt", error instanceof Error ? error : new Error(String(error)));
+		}
+	};
 };
 const turbo = async (command, options = {}) => {
 	try {
@@ -129,7 +139,7 @@ const turbo = async (command, options = {}) => {
 			hasLiveOutput
 		});
 	} catch (error) {
-		throw createError("turbo", error);
+		throw createError("turbo", error instanceof Error ? error : new Error(String(error)));
 	}
 };
 const logCheckableFiles = (files) => {
@@ -155,28 +165,16 @@ const changeset = async (command) => {
 	try {
 		return await helpers.exec(command, { hasLiveOutput: true });
 	} catch (error) {
-		throw createError("changeset", error);
+		throw createError("changeset", error instanceof Error ? error : new Error(String(error)));
 	}
 };
-const ESLINT_EXTENSIONS = [
-	"js",
-	"jsx",
-	"cjs",
-	"mjs",
-	"ts",
-	"tsx",
-	"cts",
-	"mts",
-	"md",
-	"mdx"
-];
 
 //#endregion
 //#region src/commands/build.ts
 const createBuildCommand = (program) => {
 	program.command({
-		description: "Build the project in production mode",
-		name: "build"
+		name: "build",
+		description: "Build the project in production mode"
 	}).task({ async handler() {
 		await turbo("build");
 	} });
@@ -184,7 +182,7 @@ const createBuildCommand = (program) => {
 
 //#endregion
 //#region src/commands/check/checkCode.ts
-const checkCode = eslint({ isFixMode: false });
+const checkCode = oxlint({ isFixMode: false });
 
 //#endregion
 //#region src/commands/check/checkCommit.ts
@@ -192,7 +190,7 @@ const checkCommit = async () => {
 	try {
 		return await helpers.exec("commitlint --extends \"@commitlint/config-conventional\" --edit");
 	} catch (error) {
-		throw createError("commitlint", error);
+		throw createError("commitlint", error instanceof Error ? error : new Error(String(error)));
 	}
 };
 
@@ -201,64 +199,68 @@ const checkCommit = async () => {
 const checkDependency = async () => {
 	const stdout = await helpers.exec("pnpm recursive ls --json");
 	const checkDependencyVersionMismatch = createPackagesVersionMismatchChecker();
-	const packages = JSON.parse(stdout).map((package_) => {
-		const packagePath = join(package_.path, "package.json");
-		assert(package_.name, () => createPackageError(`\`${packagePath}\` must have a name field.`));
+	const packages = JSON.parse(stdout).map((pkg) => {
+		const packagePath = join(pkg.path, "package.json");
+		assert(pkg.name, () => {
+			return createPackageError(`\`${packagePath}\` must have a name field.`);
+		});
 		const packageContent = require(packagePath);
 		const peerDependencies = packageContent.peerDependencies ?? {};
 		const devDependencies = packageContent.devDependencies ?? {};
+		const dependencies = packageContent.dependencies ?? {};
 		return {
-			dependencies: packageContent.dependencies ?? {},
+			name: pkg.name,
+			dependencies,
 			devDependencies,
-			name: package_.name,
 			peerDependencies
 		};
 	});
-	for (const package_ of packages) {
-		checkDependencyVersionMismatch(package_);
-		checkDependencyVersionRange(package_);
+	for (const pkg of packages) {
+		checkDependencyVersionMismatch(pkg);
+		checkDependencyVersionRange(pkg);
 	}
 };
-const checkDependencyVersionRange = ({ dependencies, devDependencies, name, peerDependencies }) => {
+const STARTING_WITH_DIGIT_REGEXP = /^\d/u;
+const checkDependencyVersionRange = ({ name, dependencies, devDependencies, peerDependencies }) => {
 	for (const [dependencyName, version] of Object.entries(devDependencies)) {
 		assertVersion(version, {
-			consumedBy: name,
-			name: dependencyName
+			name: dependencyName,
+			consumedBy: name
 		});
-		if (version !== "workspace:*" && !isExcluded(version) && !/^\d/.test(version)) throw createPackageError(`As a dev dependency, \`${dependencyName}\` version must be fixed (or set as "workspace:*" for local packages) to reduce accidental breaking change risks due to an implicit semver upgrade.`, {
-			consumedBy: name,
-			name: dependencyName
+		if (version !== "workspace:*" && !isExcluded(version) && !STARTING_WITH_DIGIT_REGEXP.test(version)) throw createPackageError(`As a dev dependency, \`${dependencyName}\` version must be fixed (or set as "workspace:*" for local packages) to reduce accidental breaking change risks due to an implicit semver upgrade.`, {
+			name: dependencyName,
+			consumedBy: name
 		});
 	}
 	for (const [dependencyName, version] of Object.entries(dependencies)) {
 		assertVersion(version, {
-			consumedBy: name,
-			name: dependencyName
+			name: dependencyName,
+			consumedBy: name
 		});
 		if (version !== "workspace:^" && !hasCaret(version) && !isExcluded(version)) throw createPackageError(`As a dependency, \`${dependencyName}\` version must be prefixed with a caret (or set as "workspace:^" for local packages) to optimize the size (whether of installation or bundle output) on the consumer side.`, {
-			consumedBy: name,
-			name: dependencyName
+			name: dependencyName,
+			consumedBy: name
 		});
 	}
 	for (const [dependencyName, version] of Object.entries(peerDependencies)) {
 		assertVersion(version, {
-			consumedBy: name,
-			name: dependencyName
+			name: dependencyName,
+			consumedBy: name
 		});
 		if (!hasCaret(version) && !isExcluded(version)) throw createPackageError(`As a peer dependency, \`${dependencyName}\` version must be explicit (i.e. the "workspace:^" protocol a version resolver is not allowed) and prefixed with a caret to optimize the size (whether of installation or bundle output) on the consumer side.`, {
-			consumedBy: name,
-			name: dependencyName
+			name: dependencyName,
+			consumedBy: name
 		});
 	}
 };
 const createPackagesVersionMismatchChecker = () => {
 	const monorepoDependencies = /* @__PURE__ */ new Map();
 	const monorepoDevelopmentDependencies = /* @__PURE__ */ new Map();
-	const lint = (package_, type) => {
-		const packageName = package_.name;
+	const lint = (pkg, type) => {
+		const packageName = pkg.name;
 		const isDevelopment = type === "development";
 		const store = isDevelopment ? monorepoDevelopmentDependencies : monorepoDependencies;
-		const dependencies = package_[isDevelopment ? "devDependencies" : "dependencies"];
+		const dependencies = pkg[isDevelopment ? "devDependencies" : "dependencies"];
 		for (const [dependencyName, dependencyVersion] of Object.entries(dependencies)) {
 			if (!dependencyVersion) continue;
 			const storedVersion = store.get(dependencyName);
@@ -267,40 +269,39 @@ const createPackagesVersionMismatchChecker = () => {
 				continue;
 			}
 			if (!(dependencyVersion === storedVersion)) throw createPackageError(`Mismatched versions: received version \`${dependencyVersion}\` while others use \`${storedVersion}\`. To prevent issues with singleton-like code (React contexts, …), please make sure to update all packages to use the same \`${dependencyName}\` version (either \`${storedVersion}\` or \`${dependencyVersion}\`).`, {
-				consumedBy: packageName,
-				name: dependencyName
+				name: dependencyName,
+				consumedBy: packageName
 			});
 		}
 	};
-	return (package_) => {
-		lint(package_, "development");
-		lint(package_, "production");
+	return (pkg) => {
+		lint(pkg, "development");
+		lint(pkg, "production");
 	};
 };
 const createPackageError = (message, context) => {
 	return createError("stack check", context ? `\`${context.name}\` consumed by \`${context.consumedBy}\` doesn't conform to package guidelines.\n${message}` : message);
 };
-function assertVersion(version, { consumedBy, name }) {
-	assert(version, () => createPackageError(`\`${name}\` must have a valid version specified (current version equals to \`${String(version)}\`).`, {
-		consumedBy,
-		name
-	}));
-}
+const assertVersion = (version, { name, consumedBy }) => {
+	assert(version, () => {
+		return createPackageError(`\`${name}\` must have a valid version specified (current version equals to \`${String(version)}\`).`, {
+			name,
+			consumedBy
+		});
+	});
+};
+const PRERELEASE_VERSION_REGEXP = /\d+\.\d+\.\d+-(alpha|beta|experimental|next|rc).*/u;
 const isExcluded = (version) => {
-	const isPreReleaseVersion = /\d+\.\d+\.\d+-(alpha|beta|experimental|next|rc).*/.exec(version);
+	const isPreReleaseVersion = PRERELEASE_VERSION_REGEXP.exec(version);
 	return version.startsWith("npm:") || isPreReleaseVersion;
 };
-const hasCaret = (version) => version.startsWith("^");
+const hasCaret = (version) => {
+	return version.startsWith("^");
+};
 
 //#endregion
-//#region src/commands/check/checkType.ts
-const checkType = async () => {
-	try {
-		return await helpers.exec("pnpm --parallel exec tsc --noEmit");
-	} catch (error) {
-		throw createError("tsc", error);
-	}
-};
+//#region src/commands/check/checkFormatting.ts
+const checkFormatting = oxfmt({ isFixMode: false });
 
 //#endregion
 //#region src/commands/check/check.ts
@@ -308,91 +309,94 @@ const ONLY_VALUES = [
 	"commit",
 	"code",
 	"dependency",
-	"type"
+	"formatting"
 ];
 const createCheckCommand = (program) => {
 	program.command({
-		description: "Check code health (static analysis)",
-		name: "check"
+		name: "check",
+		description: "Check code health (static analysis)"
 	}).option({
-		defaultValue: void 0,
-		description: `Filter the compliance check to run (accepted value: ${ONLY_VALUES.join(", ")})`,
 		key: "filter",
-		name: "filter"
+		name: "filter",
+		description: `Filter the compliance check to run (accepted value: ${ONLY_VALUES.join(", ")})`,
+		defaultValue: void 0
 	}).task({
 		handler(_, argv) {
 			logCheckableFiles(argv.operands);
 		},
 		skip: ifFilterDefinedAndNotEqualTo("code")
 	}).task({
+		label: label$4("Prepare the project"),
 		async handler() {
 			await turbo("build", {
 				excludeExamples: true,
 				hasLiveOutput: false
 			});
 		},
-		label: label$4("Prepare the project"),
 		skip({ filter }) {
 			return filter === "commit";
 		}
 	}).task({
+		label: label$4("Check dependency compliance"),
 		async handler() {
 			await checkDependency();
 		},
-		label: label$4("Check dependency compliance"),
 		skip: ifFilterDefinedAndNotEqualTo("dependency")
 	}).task({
+		label: label$4("Check formatting compliance"),
 		async handler(_, argv) {
 			const filenames = argv.operands;
-			await checkCode(filenames);
+			await checkFormatting(filenames);
 		},
-		label: label$4("Check code compliance"),
-		skip: ifFilterDefinedAndNotEqualTo("code")
+		skip: ifFilterDefinedAndNotEqualTo("formatting")
 	}).task({
-		async handler() {
-			await checkType();
+		label: label$4("Check code compliance"),
+		async handler(_, argv) {
+			const filenames = argv.operands;
+			await checkCode(filenames);
 		},
-		label: label$4("Check type compliance"),
-		skip(context, argv) {
-			return ifFilterDefinedAndNotEqualTo("type")(context) || !hasDependency("typescript") || argv.operands.length > 0;
-		}
+		skip: ifFilterDefinedAndNotEqualTo("code")
 	}).task({
+		label: label$4("Check commit compliance"),
 		async handler() {
 			await checkCommit();
 		},
-		label: label$4("Check commit compliance"),
 		skip(context) {
 			return context.filter !== "commit";
 		}
 	});
 };
-const label$4 = (message) => `${message} 🧐`;
-const ifFilterDefinedAndNotEqualTo = (filter) => (context) => {
-	return context.filter !== void 0 && context.filter !== filter;
+const label$4 = (message) => {
+	return `${message} 🧐`;
+};
+const ifFilterDefinedAndNotEqualTo = (filter) => {
+	return (context) => {
+		return context.filter !== void 0 && context.filter !== filter;
+	};
 };
 
 //#endregion
 //#region src/commands/clean.ts
 const createCleanCommand = (program) => {
 	program.command({
-		description: "Clean the project",
-		name: "clean"
+		name: "clean",
+		description: "Clean the project"
 	}).task({
+		key: "files",
+		label: label$3("Retrieve removable files"),
 		async handler() {
 			const cachePath = "node_modules/.cache";
 			const files = await retrieveIgnoredFiles();
 			if (isDirectoryExistAndNotEmpty(resolveFromWorkingDirectory(cachePath))) files.push(cachePath);
 			return files;
-		},
-		key: "files",
-		label: label$3("Retrieve removable files")
+		}
 	}).task({
+		label({ files }) {
+			return files.length > 0 ? label$3("Clean assets") : "Already clean ✨";
+		},
 		async handler({ files }) {
 			if (files.length === 0) return;
 			await cleanFiles(files);
-		},
-		label({ files }) {
-			return files.length > 0 ? label$3("Clean assets") : "Already clean ✨";
 		}
 	}).task({
 		handler({ files }) {
@@ -410,42 +414,54 @@ const createCleanCommand = (program) => {
 		}
 	});
 };
-const label$3 = (message) => `${message} 🧹`;
+const label$3 = (message) => {
+	return `${message} 🧹`;
+};
 const cleanFiles = async (files) => {
-	return Promise.all(files.map(async (file) => rm(file, {
-		force: true,
-		recursive: true
-	})));
+	await Promise.all(files.map(async (file) => {
+		await rm(file, {
+			force: true,
+			recursive: true
+		});
+	}));
 };
 const isDirectoryExistAndNotEmpty = (path) => {
 	return existsSync(path) && readdirSync(path).length > 0;
 };
+const LINEBREAK_REGEXP = /\n|\r\n/u;
 const retrieveIgnoredFiles = async () => {
-	return (await helpers.exec("git clean -fdXn")).split(/\n|\r\n/).filter((cleanOutput) => PRESERVE_FILES.every((excludedFile) => !cleanOutput.includes(excludedFile))).map((cleanOutput) => cleanOutput.split(" ").at(-1));
+	return (await helpers.exec("git clean -fdXn")).split(LINEBREAK_REGEXP).filter((cleanOutput) => {
+		return PRESERVE_FILES.every((excludedFile) => {
+			return !cleanOutput.includes(excludedFile);
+		});
+	}).map((cleanOutput) => {
+		return cleanOutput.split(" ").at(-1) ?? "";
+	}).filter(Boolean);
 };
 const PRESERVE_FILES = ["node_modules"];
 
 //#endregion
 //#region package.json
-var version = "2.40.0";
+var version = "3.0.0";
 
 //#endregion
 //#region src/commands/create.ts
+const REPOSITORY_REGEXP = /^(?:git@.*:|https?:\/\/.*\/)(?<repoOwner>[^/]+)\/(?<repoName>[^/]+)\.git$/u;
 const createCreateCommand = (program) => {
 	program.command({
-		description: "Scaffold a new project",
-		name: "create"
+		name: "create",
+		description: "Scaffold a new project"
 	}).task({ handler() {
 		botMessage({
-			description: "I can guarantee you a project creation in under 1 minute 🚀",
 			title: `I'm Stack v${version} 👋`,
+			description: "I can guarantee you a project creation in under 1 minute 🚀",
 			type: "information"
 		});
 	} }).task({
+		label: label$2("Check pre-requisites"),
 		async handler() {
 			await getPnpmVersion();
-		},
-		label: label$2("Check pre-requisites")
+		}
 	}).input({
 		key: "inputName",
 		label: "What's your project name?",
@@ -455,27 +471,29 @@ const createCreateCommand = (program) => {
 		label: "How would you describe it?",
 		type: "text"
 	}).input({
-		defaultValue: "git@github.com:adbayb/xxx.git",
 		key: "inputUrl",
 		label: "Where will it be stored? (Git remote URL)",
+		defaultValue: "git@github.com:adbayb/xxx.git",
 		type: "text"
 	}).input({
-		defaultValue: "single-project",
 		key: "inputTemplate",
 		label: "Which template you would like to apply?",
+		defaultValue: "single-project",
 		options: ["single-project", "multi-projects"],
 		type: "select"
 	}).task({
+		key: "data",
+		label: label$2("Check and format input"),
 		async handler({ inputDescription, inputName, inputTemplate, inputUrl }) {
 			if (!inputName) throw createError("stack create", "The project name is not optional. Make sure to provide a valid value (non-empty string).");
-			const { repoName, repoOwner } = (inputUrl.startsWith("git") ? /^git@.*:(?<repoOwner>.*)\/(?<repoName>.*)\.git$/ : /^https?:\/\/.*\/(?<repoOwner>.*)\/(?<repoName>.*)\.git$/).exec(inputUrl)?.groups ?? {};
+			const { repoName, repoOwner } = REPOSITORY_REGEXP.exec(inputUrl)?.groups ?? {};
 			if (!repoOwner || !repoName) throw createError("git", "The owner and repository name can not be extracted. Please make sure to follow either `/^git@.*:(?<repoOwner>.*)/(?<repoName>.*).git$/` or `/^https?://.*/(?<repoOwner>.*)/(?<repoName>.*).git$/` pattern.");
 			const nodeVersion = await request.get("https://resolve-node.vercel.app/lts", "text");
 			const { version: pnpmVersion } = await request.get("https://registry.npmjs.org/pnpm/latest", "json");
 			const projectName = slugify(inputName);
 			return {
 				licenseYear: (/* @__PURE__ */ new Date()).getFullYear().toString(),
-				nodeVersion: nodeVersion.replace("v", ""),
+				nodeVersion: `^${Number(nodeVersion.replace("v", "").split(".")[0])}.0.0`,
 				pnpmVersion: String(pnpmVersion),
 				projectDescription: toCapitalLetter(inputDescription),
 				projectName,
@@ -484,15 +502,13 @@ const createCreateCommand = (program) => {
 				templatePath: resolveFromPackageDirectory("templates", inputTemplate),
 				workingPath: resolveFromWorkingDirectory(projectName)
 			};
-		},
-		key: "data",
-		label: label$2("Check and format input")
+		}
 	}).input({
-		defaultValue: true,
 		key: "canRemoveExistingDirectoryInput",
 		label({ data: { projectName } }) {
 			return label$2(`\`${projectName}\` directory already exists, do you want to remove it?`);
 		},
+		defaultValue: true,
 		skip({ data: { workingPath } }) {
 			return !existsSync(workingPath);
 		},
@@ -502,6 +518,10 @@ const createCreateCommand = (program) => {
 			return createError("mkdir", `Remove or rename the \`${projectName}\` existing directory to apply the template from a clean state.`);
 		}
 	}).task({
+		key: "templateEngine",
+		label({ data: { projectName }, inputTemplate }) {
+			return label$2(`Copy \`${inputTemplate}\` template to \`${projectName}\` directory`);
+		},
 		async handler({ canRemoveExistingDirectoryInput, data: { licenseYear, nodeVersion, pnpmVersion, projectDescription, projectName, projectUrl, repoId, templatePath, workingPath }, inputTemplate }) {
 			if (canRemoveExistingDirectoryInput) await rm(workingPath, {
 				force: true,
@@ -521,31 +541,28 @@ const createCreateCommand = (program) => {
 				templateName: inputTemplate,
 				templatePath
 			});
-		},
-		key: "templateEngine",
-		label({ data: { projectName }, inputTemplate }) {
-			return label$2(`Copy \`${inputTemplate}\` template to \`${projectName}\` directory`);
 		}
 	}).task({
+		label() {
+			return label$2("Process template");
+		},
 		async handler({ templateEngine }) {
 			await templateEngine.processContents();
 			await templateEngine.processPaths();
-		},
-		label() {
-			return label$2("Process template");
 		}
 	}).task({
+		label: label$2("Initialize `git`"),
 		async handler({ data: { projectUrl } }) {
 			await helpers.exec("git init");
 			await helpers.exec(`git remote add origin ${projectUrl}`);
-		},
-		label: label$2("Initialize `git`")
+		}
 	}).task({
+		label: label$2("Set up the package manager"),
 		async handler() {
 			await setPackageManager();
-		},
-		label: label$2("Set up the package manager")
+		}
 	}).task({
+		label: label$2("Install dependencies"),
 		async handler({ data: { projectName } }) {
 			const localDevelopmentDependencies = ["quickbundle", "vitest"];
 			const globalDevelopmentDependencies = ["@adbayb/stack"];
@@ -554,32 +571,33 @@ const createCreateCommand = (program) => {
 				await helpers.exec(`pnpm add ${localDevelopmentDependencies.join(" ")} --save-dev --filter ${projectName}`);
 				await helpers.exec("pnpm install");
 			} catch (error) {
-				throw createError("pnpm", error);
+				throw createError("pnpm", error instanceof Error ? error : new Error(String(error)));
 			}
-		},
-		label: label$2("Install dependencies")
+		}
 	}).task({
+		label: label$2("Run `stack install`"),
 		async handler() {
 			await helpers.exec("stack install");
-		},
-		label: label$2("Run `stack install`")
+		}
 	}).task({
+		label: label$2("Commit"),
 		async handler() {
 			await helpers.exec("git add -A");
 			await helpers.exec("git commit -m \"chore: initial commit\"");
-		},
-		label: label$2("Commit")
+		}
 	}).task({ handler({ data: { projectName } }) {
 		botMessage({
-			description: `Run \`cd ./${projectName}\` and Enjoy 🚀`,
 			title: "The project was successfully created",
+			description: `Run \`cd ./${projectName}\` and Enjoy 🚀`,
 			type: "success"
 		});
 	} });
 };
-const label$2 = (message) => `${message} 🔨`;
+const label$2 = (message) => {
+	return `${message} 🔨`;
+};
 const slugify = (input) => {
-	return input.toLowerCase().replaceAll(/[^a-z0-9\s-]/g, "").trim().replaceAll(/\s+/g, "-").replaceAll(/-+/g, "-");
+	return input.toLowerCase().replaceAll(/[^a-z0-9\s-]/gu, "").trim().replaceAll(/\s+/gu, "-").replaceAll(/-+/gu, "-");
 };
 const toCapitalLetter = (input) => {
 	return input.charAt(0).toUpperCase() + input.slice(1);
@@ -592,21 +610,23 @@ const createTemplateEngine = async (workingPath, { projectName, templateModel, t
 	});
 	const gitignoreFile = join(workingPath, ".gitignore.tmpl");
 	if (existsSync(gitignoreFile)) await rename(gitignoreFile, join(workingPath, ".gitignore"));
-	const eslintConfigFile = join(workingPath, "eslint.config.js.tmpl");
-	if (existsSync(eslintConfigFile)) await rename(eslintConfigFile, join(workingPath, "eslint.config.js"));
 	const templateEntries = await getTemplateEntries(workingPath);
 	process.chdir(workingPath);
 	return {
 		async processContents() {
-			await Promise.all(templateEntries.filter(({ type }) => type === "content").map(async (entry) => {
-				return writeFile(entry.path, setTemplateVariables(entry, templateModel));
+			await Promise.all(templateEntries.filter(({ type }) => {
+				return type === "content";
+			}).map(async (entry) => {
+				await writeFile(entry.path, setTemplateVariables(entry, templateModel));
 			}));
 		},
 		async processPaths() {
 			const sortedDirectoryEntries = templateEntries.filter(({ content, type }) => {
 				if (type === "path.directory" || type === "path.file") return hasTemplateVariable(basename(content));
 				return false;
-			}).toSorted(({ path: pathA }, { path: pathB }) => pathB.length - pathA.length);
+			}).toSorted(({ path: pathA }, { path: pathB }) => {
+				return pathB.length - pathA.length;
+			});
 			for (const entry of sortedDirectoryEntries) {
 				const newPath = setTemplateVariables(entry, templateModel);
 				await rename(entry.path, newPath);
@@ -634,13 +654,15 @@ const getTemplateEntries = async (path) => {
 			content: await readFile(entryPath, "utf8"),
 			type: "content"
 		}]).map(({ content, type }) => {
-			if (!hasTemplateVariable(content)) return void 0;
+			if (!hasTemplateVariable(content)) return;
 			return {
 				content,
 				path: entryPath,
 				type
 			};
-		}).filter((input) => Boolean(input));
+		}).filter((input) => {
+			return Boolean(input);
+		});
 	}))).flat();
 };
 const setTemplateVariables = (entry, model) => {
@@ -648,92 +670,80 @@ const setTemplateVariables = (entry, model) => {
 		return model[dataModelKey] ?? match;
 	});
 };
-const TEMPLATE_VARIABLE_MATCHER = /* @__PURE__ */ new RegExp(/{{(.*?)}}/g, "gi");
+const TEMPLATE_VARIABLE_MATCHER = /\{\{(.*?)\}\}/giu;
 const hasTemplateVariable = (input) => {
 	/**
-	* TemplateVariableMatcher.test() is not used since the `RegExp` is stateful when the global is used leading to some unstable results
-	* (relying on latest `lastIndex` set (lastIndex specifies the index at which to start the next match)).
-	* String.search is stateless.
+	* TemplateVariableMatcher.test() is not used since the `RegExp` is stateful when the global is
+	* used leading to some unstable results (relying on latest `lastIndex` set (lastIndex specifies
+	* the index at which to start the next match)). String.search is stateless.
+	*
 	* @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test MDN documentation}.
 	*/
 	return input.search(TEMPLATE_VARIABLE_MATCHER) >= 0;
 };
 
 //#endregion
-//#region src/commands/fix/fixFormatting.ts
-const PRETTIER_IGNORE_FILES = ["pnpm-lock.yaml"];
-const fixFormatting = async (files) => {
-	let prettierFiles = [];
-	if (files.length === 0) prettierFiles.push(`"**/!(${PRETTIER_IGNORE_FILES.join("|")})"`);
-	else {
-		prettierFiles = files.filter((file) => {
-			return PRETTIER_IGNORE_FILES.every((filename) => !file.endsWith(filename));
-		});
-		if (prettierFiles.length === 0) return;
-	}
-	const arguments_ = [...prettierFiles];
-	if (existsSync(resolveFromWorkingDirectory(".gitignore"))) arguments_.push("--ignore-path .gitignore");
-	arguments_.push("--write", "--ignore-unknown", "--no-error-on-unmatched-pattern");
-	try {
-		return await helpers.exec(`prettier ${arguments_.join(" ")}`);
-	} catch (error) {
-		throw createError("prettier", error);
-	}
-};
+//#region src/commands/fix/fixCode.ts
+const fixCode = oxlint({ isFixMode: true });
 
 //#endregion
-//#region src/commands/fix/fixLinter.ts
-const fixLinter = eslint({ isFixMode: true });
+//#region src/commands/fix/fixFormatting.ts
+const fixFormatting = oxfmt({ isFixMode: true });
 
 //#endregion
 //#region src/commands/fix/fix.ts
 const createFixCommand = (program) => {
 	program.command({
-		description: "Fix auto-fixable issues",
-		name: "fix"
+		name: "fix",
+		description: "Fix auto-fixable issues"
 	}).task({ handler(_, argv) {
 		logCheckableFiles(argv.operands);
 	} }).task({
+		label: label$1("Prepare the project"),
 		async handler() {
 			await turbo("build", {
 				excludeExamples: true,
 				hasLiveOutput: false
 			});
-		},
-		label: label$1("Prepare the project")
+		}
 	}).task({
+		label: label$1("Fix formatting issues"),
 		async handler(_, argv) {
-			await fixLinter(argv.operands);
-		},
-		label: label$1("Fix linter issues")
+			await fixFormatting(argv.operands);
+		}
 	}).task({
+		label: label$1("Fix code issues"),
 		async handler(_, argv) {
-			await fixFormatting(argv.operands);
-		},
-		label: label$1("Fix formatting issues")
+			await fixCode(argv.operands);
+		}
 	});
 };
-const label$1 = (message) => `${message} 🚑`;
+const label$1 = (message) => {
+	return `${message} 🚑`;
+};
 
 //#endregion
 //#region src/commands/install.ts
 const createInstallCommand = (program) => {
 	program.command({
-		description: "Install required setup",
-		name: "install"
+		name: "install",
+		description: "Install required setup"
 	}).task({
+		label: label("Install `git.pre-commit` hook"),
 		async handler() {
-			await installGitHook("pre-commit", `${getStackCommand(`fix $(node -e 'console.log(require("child_process").execSync("git status --porcelain", {encoding: "utf8"}).split(/${String.raw`\n|\r\n`}/).filter(Boolean).map(item => item.split(" ").at(-1)).join(" "))')`)} && git add -A`);
-		},
-		label: label("Install `git.pre-commit` hook")
+			const stackCommand = getStackCommand(`fix $(node -e 'console.log(require("child_process").execSync("git status --porcelain", {encoding: "utf8"}).split(/${String.raw`\n|\r\n`}/).filter(Boolean).map(item => item.split(" ").at(-1)).join(" "))')`);
+			await installGitHook("pre-commit", `${stackCommand} && git add -A`);
+		}
 	}).task({
+		label: label("Install `git.commit-msg` hook"),
 		async handler() {
 			await installGitHook("commit-msg", getStackCommand("check --filter commit"));
-		},
-		label: label("Install `git.commit-msg` hook")
+		}
 	});
 };
-const label = (message) => `${message} 📲`;
+const label = (message) => {
+	return `${message} 📲`;
+};
 const installGitHook = async (hook, content) => {
 	const filename = resolveFromWorkingDirectory(`.git/hooks/${hook}`);
 	await writeFile(filename, content);
@@ -744,24 +754,24 @@ const installGitHook = async (hook, content) => {
 //#region src/commands/release.ts
 const createReleaseCommand = (program) => {
 	program.command({
-		description: "Log, version, and publish package(s)",
-		name: "release"
+		name: "release",
+		description: "Log, version, and publish package(s)"
 	}).option({
-		description: "Add a new changelog entry",
 		key: "log",
-		name: "log"
+		name: "log",
+		description: "Add a new changelog entry"
 	}).option({
-		description: "Add an empty changelog entry",
 		key: "emptyLog",
-		name: "empty-log"
+		name: "empty-log",
+		description: "Add an empty changelog entry"
 	}).option({
-		description: "Bump the package(s) version",
 		key: "tag",
-		name: "tag"
+		name: "tag",
+		description: "Bump the package(s) version"
 	}).option({
-		description: "Publish package(s) to the registry",
 		key: "publish",
-		name: "publish"
+		name: "publish",
+		description: "Publish package(s) to the registry"
 	}).task({
 		async handler() {
 			helpers.message("New changelog entry\n");
@@ -788,16 +798,18 @@ const createReleaseCommand = (program) => {
 		skip: ifNotEqualTo("publish")
 	});
 };
-const ifNotEqualTo = (validOption) => (context) => {
-	return !context[validOption];
+const ifNotEqualTo = (validOption) => {
+	return (context) => {
+		return !context[validOption];
+	};
 };
 
 //#endregion
 //#region src/commands/start.ts
 const createStartCommand = (program) => {
 	program.command({
-		description: "Start the project in production mode",
-		name: "start"
+		name: "start",
+		description: "Start the project in production mode"
 	}).task({ async handler() {
 		await turbo("start");
 	} });
@@ -807,8 +819,8 @@ const createStartCommand = (program) => {
 //#region src/commands/test.ts
 const createTestCommand = (program) => {
 	program.command({
-		description: "Test the code execution",
-		name: "test"
+		name: "test",
+		description: "Test the code execution"
 	}).task({ async handler() {
 		await turbo("test");
 	} });
@@ -818,8 +830,8 @@ const createTestCommand = (program) => {
 //#region src/commands/watch.ts
 const createWatchCommand = (program) => {
 	program.command({
-		description: "Build and start the project in development mode",
-		name: "watch"
+		name: "watch",
+		description: "Build and start the project in development mode"
 	}).task({ async handler() {
 		await turbo("watch");
 	} });
@@ -829,12 +841,12 @@ const createWatchCommand = (program) => {
 //#region src/index.ts
 const createProgram = (...commandFactories) => {
 	const program = termost({
-		description: "Toolbox to easily scaffold and maintain a project",
 		name: "stack",
+		description: "Toolbox to easily scaffold and maintain a project",
 		onException() {
 			botMessage({
-				description: "Keep calm and carry on with some coffee ☕️",
 				title: "Oops, an error occurred",
+				description: "Keep calm and carry on with some coffee ☕️",
 				type: "error"
 			});
 		},