@adbayb/stack 2.39.0 → 2.40.0-next-7baa8ed

package/dist/index.js

@@ -1,9 +1,8 @@
 import { helpers, termost } from "termost";
 import { createRequire } from "node:module";
-import { join, resolve } from "node:path";
-import { cpSync, existsSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { chmod, mkdir, rm, symlink, writeFile } from "node:fs/promises";
-import { fdir } from "fdir";
+import { basename, join, resolve } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+import { chmod, cp, mkdir, readFile, readdir, rename, rm, symlink, writeFile } from "node:fs/promises";
 
 //#region src/helpers.ts
 const require = createRequire(import.meta.url);
@@ -12,21 +11,20 @@ function assert(expectedCondition, 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;
@@ -46,23 +44,27 @@ ${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
-* resolveFromProjectDirectory(".gitignore");
 */
-const resolveFromProjectDirectory = (path) => {
-	return resolve(process.cwd(), path);
+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
-* resolveFromStackDirectory("./templates");
 */
-const resolveFromStackDirectory = (path) => {
-	return resolve(import.meta.dirname, "../", path);
+const resolveFromPackageDirectory = (...path) => {
+	return resolve(import.meta.dirname, "../", ...path);
 };
 const createError = (bin, error) => {
 	const errorMessage = `\`${bin}\` command failed.\n${String(error)}`;
@@ -72,7 +74,7 @@ const createError = (bin, error) => {
 	}
 	return new Error(errorMessage);
 };
-const getNpmVersion = async () => {
+const getPnpmVersion = async () => {
 	try {
 		return await helpers.exec("pnpm -v");
 	} catch {
@@ -82,15 +84,14 @@ const getNpmVersion = 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("npx corepack enable");
+	return helpers.exec("pnx corepack enable");
 };
 const request = { async get(url, responseType) {
 	const response = await fetch(url);
@@ -100,26 +101,30 @@ const request = { async get(url, responseType) {
 	})})`);
 	return response[responseType === "text" ? "text" : "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 oxlint = (options) => async (files = []) => {
 	const arguments_ = [
-		...eslintFiles,
-		"--cache",
-		`--cache-location ${resolveFromProjectDirectory("node_modules/.cache/.eslintcache")}`,
+		...files,
+		"--disable-nested-config",
 		"--no-error-on-unmatched-pattern"
 	];
 	if (options.isFixMode) arguments_.push("--fix");
 	try {
-		return await helpers.exec(`eslint ${arguments_.join(" ")}`);
+		return await helpers.exec(`oxlint ${arguments_.join(" ")}`);
+	} catch (error) {
+		throw createError("oxlint", error);
+	}
+};
+const oxfmt = (options) => async (files = []) => {
+	const arguments_ = [
+		...files,
+		"--disable-nested-config",
+		"--no-error-on-unmatched-pattern",
+		options.isFixMode ? "--write" : "--check"
+	];
+	try {
+		return await helpers.exec(`oxfmt ${arguments_.join(" ")}`);
 	} catch (error) {
-		throw createError("eslint", error);
+		throw createError("oxfmt", error);
 	}
 };
 const turbo = async (command, options = {}) => {
@@ -159,18 +164,6 @@ const changeset = async (command) => {
 		throw createError("changeset", error);
 	}
 };
-const ESLINT_EXTENSIONS = [
-	"js",
-	"jsx",
-	"cjs",
-	"mjs",
-	"ts",
-	"tsx",
-	"cts",
-	"mts",
-	"md",
-	"mdx"
-];
 
 //#endregion
 //#region src/commands/build.ts
@@ -185,7 +178,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
@@ -294,14 +287,8 @@ const isExcluded = (version) => {
 const hasCaret = (version) => 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
@@ -309,7 +296,7 @@ const ONLY_VALUES = [
 	"commit",
 	"code",
 	"dependency",
-	"type"
+	"formatting"
 ];
 const createCheckCommand = (program) => {
 	program.command({
@@ -342,6 +329,13 @@ const createCheckCommand = (program) => {
 		},
 		label: label$4("Check dependency compliance"),
 		skip: ifFilterDefinedAndNotEqualTo("dependency")
+	}).task({
+		async handler(_, argv) {
+			const filenames = argv.operands;
+			await checkFormatting(filenames);
+		},
+		label: label$4("Check formatting compliance"),
+		skip: ifFilterDefinedAndNotEqualTo("formatting")
 	}).task({
 		async handler(_, argv) {
 			const filenames = argv.operands;
@@ -349,14 +343,6 @@ const createCheckCommand = (program) => {
 		},
 		label: label$4("Check code compliance"),
 		skip: ifFilterDefinedAndNotEqualTo("code")
-	}).task({
-		async handler() {
-			await checkType();
-		},
-		label: label$4("Check type compliance"),
-		skip(context, argv) {
-			return ifFilterDefinedAndNotEqualTo("type")(context) || !hasDependency("typescript") || argv.operands.length > 0;
-		}
 	}).task({
 		async handler() {
 			await checkCommit();
@@ -382,7 +368,7 @@ const createCleanCommand = (program) => {
 		async handler() {
 			const cachePath = "node_modules/.cache";
 			const files = await retrieveIgnoredFiles();
-			if (isDirectoryExistAndNotEmpty(resolveFromProjectDirectory(cachePath))) files.push(cachePath);
+			if (isDirectoryExistAndNotEmpty(resolveFromWorkingDirectory(cachePath))) files.push(cachePath);
 			return files;
 		},
 		key: "files",
@@ -428,7 +414,7 @@ const PRESERVE_FILES = ["node_modules"];
 
 //#endregion
 //#region package.json
-var version = "2.39.0";
+var version = "2.40.0-next-7baa8ed";
 
 //#endregion
 //#region src/commands/create.ts
@@ -439,12 +425,12 @@ const createCreateCommand = (program) => {
 	}).task({ handler() {
 		botMessage({
 			description: "I can guarantee you a project creation in under 1 minute 🚀",
-			title: `I'm Stack v${version}, your bot assistant`,
+			title: `I'm Stack v${version} 👋`,
 			type: "information"
 		});
 	} }).task({
 		async handler() {
-			await getNpmVersion();
+			await getPnpmVersion();
 		},
 		label: label$2("Check pre-requisites")
 	}).input({
@@ -467,61 +453,92 @@ const createCreateCommand = (program) => {
 		options: ["single-project", "multi-projects"],
 		type: "select"
 	}).task({
-		async handler({ inputDescription, inputName, inputUrl }) {
+		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 ?? {};
 			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: npmVersion } = await request.get("https://registry.npmjs.org/pnpm/latest", "json");
+			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", ""),
-				npmVersion: String(npmVersion),
-				projectDescription: inputDescription.charAt(0).toUpperCase() + inputDescription.slice(1),
-				projectName: inputName.toLowerCase(),
+				pnpmVersion: String(pnpmVersion),
+				projectDescription: toCapitalLetter(inputDescription),
+				projectName,
 				projectUrl: inputUrl,
-				repoId: `${repoOwner}/${repoName}`
+				repoId: `${repoOwner}/${repoName}`,
+				templatePath: resolveFromPackageDirectory("templates", inputTemplate),
+				workingPath: resolveFromWorkingDirectory(projectName)
 			};
 		},
 		key: "data",
 		label: label$2("Check and format input")
-	}).task({
-		async handler({ data }) {
-			const projectPath = resolve(process.cwd(), data.projectName);
-			await mkdir(projectPath);
-			process.chdir(projectPath);
+	}).input({
+		defaultValue: true,
+		key: "canRemoveExistingDirectoryInput",
+		label({ data: { projectName } }) {
+			return label$2(`\`${projectName}\` directory already exists, do you want to remove it?`);
 		},
-		label({ data }) {
-			return label$2(`Create \`${data.projectName}\` folder`);
+		skip({ data: { workingPath } }) {
+			return !existsSync(workingPath);
+		},
+		type: "confirm",
+		validate({ canRemoveExistingDirectoryInput, data: { projectName } }) {
+			if (canRemoveExistingDirectoryInput) return;
+			return createError("mkdir", `Remove or rename the \`${projectName}\` existing directory to apply the template from a clean state.`);
 		}
 	}).task({
-		async handler({ data }) {
-			await helpers.exec("git init");
-			await helpers.exec(`git remote add origin ${data.projectUrl}`);
+		async handler({ canRemoveExistingDirectoryInput, data: { licenseYear, nodeVersion, pnpmVersion, projectDescription, projectName, projectUrl, repoId, templatePath, workingPath }, inputTemplate }) {
+			if (canRemoveExistingDirectoryInput) await rm(workingPath, {
+				force: true,
+				recursive: true
+			});
+			return createTemplateEngine(workingPath, {
+				projectName,
+				templateModel: {
+					licenseYear,
+					nodeVersion,
+					pnpmVersion,
+					projectDescription,
+					projectName,
+					projectUrl,
+					repoId
+				},
+				templateName: inputTemplate,
+				templatePath
+			});
 		},
-		label: label$2("Initialize `git`")
+		key: "templateEngine",
+		label({ data: { projectName }, inputTemplate }) {
+			return label$2(`Copy \`${inputTemplate}\` template to \`${projectName}\` directory`);
+		}
 	}).task({
-		handler({ data, inputTemplate }) {
-			applyTemplate(inputTemplate, data);
+		async handler({ templateEngine }) {
+			await templateEngine.processContents();
+			await templateEngine.processPaths();
 		},
-		label: label$2("Apply template")
+		label() {
+			return label$2("Process template");
+		}
 	}).task({
-		async handler({ data: { projectName }, inputTemplate }) {
-			await symlink(join(inputTemplate === "single-project" ? projectName : join("libraries", projectName), "README.md"), "./README.md");
+		async handler({ data: { projectUrl } }) {
+			await helpers.exec("git init");
+			await helpers.exec(`git remote add origin ${projectUrl}`);
 		},
-		label: label$2("Create a symlink to `README.md` file")
+		label: label$2("Initialize `git`")
 	}).task({
 		async handler() {
 			await setPackageManager();
 		},
 		label: label$2("Set up the package manager")
 	}).task({
-		async handler({ data }) {
+		async handler({ data: { projectName } }) {
 			const localDevelopmentDependencies = ["quickbundle", "vitest"];
 			const globalDevelopmentDependencies = ["@adbayb/stack"];
 			try {
 				await helpers.exec(`pnpm add ${globalDevelopmentDependencies.join(" ")} --save-dev --ignore-workspace-root-check`);
-				await helpers.exec(`pnpm add ${localDevelopmentDependencies.join(" ")} --save-dev --filter ${data.projectName}`);
+				await helpers.exec(`pnpm add ${localDevelopmentDependencies.join(" ")} --save-dev --filter ${projectName}`);
 				await helpers.exec("pnpm install");
 			} catch (error) {
 				throw createError("pnpm", error);
@@ -539,79 +556,104 @@ const createCreateCommand = (program) => {
 			await helpers.exec("git commit -m \"chore: initial commit\"");
 		},
 		label: label$2("Commit")
-	}).task({ handler({ data }) {
+	}).task({ handler({ data: { projectName } }) {
 		botMessage({
-			description: `Run \`cd ./${data.projectName}\` and Enjoy 🚀`,
+			description: `Run \`cd ./${projectName}\` and Enjoy 🚀`,
 			title: "The project was successfully created",
 			type: "success"
 		});
 	} });
 };
 const label$2 = (message) => `${message} 🔨`;
-/**
-* A simple template engine to evaluate dynamic expressions and apply side effets (such as hydrating a content with values from an input object) on impacted template files.
-* @param template - The selected template.
-* @param dataModel - Data model mapping the template expression key with its corresponding value.
-* @example
-* applyTemplate(
-* 	{ toReplace: "value" },
-* );
-*/
-const applyTemplate = (template, dataModel) => {
-	const templateExtension = ".tmpl";
-	const templateRootPath = resolveFromStackDirectory(join("./templates", template));
-	const projectRootPath = resolveFromProjectDirectory("./");
-	const templateExpressionRegExp = /{{(.*?)}}/g;
-	const evaluate = (content) => {
-		return content.replaceAll(templateExpressionRegExp, (_, key) => dataModel[key] || "");
-	};
-	/** Copy the template before mutations. */
-	cpSync(templateRootPath, projectRootPath, {
+const slugify = (input) => {
+	return input.toLowerCase().replaceAll(/[^a-z0-9\s-]/g, "").trim().replaceAll(/\s+/g, "-").replaceAll(/-+/g, "-");
+};
+const toCapitalLetter = (input) => {
+	return input.charAt(0).toUpperCase() + input.slice(1);
+};
+const createTemplateEngine = async (workingPath, { projectName, templateModel, templateName, templatePath }) => {
+	if (!existsSync(workingPath)) await mkdir(workingPath);
+	await cp(templatePath, workingPath, {
 		force: true,
 		recursive: true
 	});
-	/** Template file mutations. */
-	new fdir().withBasePath().glob(`**/*${templateExtension}`).crawl(projectRootPath).sync().forEach((templateFilePath) => {
-		const projectFilePath = templateFilePath.slice(0, templateFilePath.lastIndexOf(templateExtension));
-		const content = evaluate(readFileSync(templateFilePath, "utf8"));
-		renameSync(templateFilePath, projectFilePath);
-		writeFileSync(projectFilePath, content, "utf8");
+	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));
+			}));
+		},
+		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);
+			for (const entry of sortedDirectoryEntries) {
+				const newPath = setTemplateVariables(entry, templateModel);
+				await rename(entry.path, newPath);
+			}
+			await symlink(join(templateName === "single-project" ? projectName : join("libraries", projectName), "README.md"), "./README.md");
+		}
+	};
+};
+const getTemplateEntries = async (path) => {
+	const entries = await readdir(path, {
+		recursive: true,
+		withFileTypes: true
 	});
-	/** Template folder mutations. */
-	new fdir().withBasePath().onlyDirs().filter((path) => {
-		return templateExpressionRegExp.test(path);
-	}).crawl(projectRootPath).sync().toSorted((a, b) => b.length - a.length).forEach((templateFolderPath) => {
-		renameSync(templateFolderPath, templateFolderPath.replaceAll(templateExpressionRegExp, (_, dataModelKey) => {
-			return dataModel[dataModelKey];
-		}));
+	return (await Promise.all(entries.map(async (entry) => {
+		const isDirectory = entry.isDirectory();
+		if (!isDirectory && !entry.isFile()) return [];
+		const entryPath = resolve(entry.parentPath, entry.name);
+		return (isDirectory ? [{
+			content: entryPath,
+			type: "path.directory"
+		}] : [{
+			content: entryPath,
+			type: "path.file"
+		}, {
+			content: await readFile(entryPath, "utf8"),
+			type: "content"
+		}]).map(({ content, type }) => {
+			if (!hasTemplateVariable(content)) return void 0;
+			return {
+				content,
+				path: entryPath,
+				type
+			};
+		}).filter((input) => Boolean(input));
+	}))).flat();
+};
+const setTemplateVariables = (entry, model) => {
+	return entry.content.replaceAll(TEMPLATE_VARIABLE_MATCHER, (match, dataModelKey) => {
+		return model[dataModelKey] ?? match;
 	});
 };
+const TEMPLATE_VARIABLE_MATCHER = /* @__PURE__ */ new RegExp(/{{(.*?)}}/g, "gi");
+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.
+	*
+	* @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(resolveFromProjectDirectory(".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
@@ -631,14 +673,14 @@ const createFixCommand = (program) => {
 		label: label$1("Prepare the project")
 	}).task({
 		async handler(_, argv) {
-			await fixLinter(argv.operands);
+			await fixFormatting(argv.operands);
 		},
-		label: label$1("Fix linter issues")
+		label: label$1("Fix formatting issues")
 	}).task({
 		async handler(_, argv) {
-			await fixFormatting(argv.operands);
+			await fixCode(argv.operands);
 		},
-		label: label$1("Fix formatting issues")
+		label: label$1("Fix code issues")
 	});
 };
 const label$1 = (message) => `${message} 🚑`;
@@ -663,7 +705,7 @@ const createInstallCommand = (program) => {
 };
 const label = (message) => `${message} 📲`;
 const installGitHook = async (hook, content) => {
-	const filename = resolveFromProjectDirectory(`.git/hooks/${hook}`);
+	const filename = resolveFromWorkingDirectory(`.git/hooks/${hook}`);
 	await writeFile(filename, content);
 	return chmod(filename, "0755");
 };

package/package.json

@@ -1,33 +1,23 @@
 {
   "name": "@adbayb/stack",
-  "version": "2.39.0",
+  "version": "2.40.0-next-7baa8ed",
   "description": "My opinionated JavaScript-based toolchain",
   "keywords": [
-    "stack",
+    "development",
     "scripts",
-    "toolchain",
-    "development"
+    "stack",
+    "toolchain"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/adbayb/stack.git",
-    "directory": "applications/stack"
-  },
   "license": "MIT",
   "author": {
     "name": "Ayoub Adib",
     "email": "adbayb@gmail.com",
     "url": "https://twitter.com/adbayb"
   },
-  "type": "module",
-  "exports": {
-    ".": {
-      "source": "./src/index.ts",
-      "default": "./dist/index.js"
-    },
-    "./eslint": "./configs/eslint/index.js",
-    "./prettier": "./configs/prettier/index.js",
-    "./typescript": "./configs/typescript/index.json"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adbayb/stack.git",
+    "directory": "applications/stack"
   },
   "bin": {
     "stack": "./bin/index.js"
@@ -38,44 +28,36 @@
     "dist",
     "templates"
   ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./oxfmt": "./configs/oxfmt/index.ts",
+    "./oxlint": "./configs/oxlint/index.ts",
+    "./typescript": "./configs/typescript/index.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
   "dependencies": {
     "@changesets/changelog-github": "^0.7.0",
     "@changesets/cli": "^2.31.0",
     "@commitlint/cli": "^21.0.2",
     "@commitlint/config-conventional": "^21.0.2",
-    "@eslint-react/eslint-plugin": "^5.9.1",
-    "@eslint/compat": "^2.1.0",
-    "@stylistic/eslint-plugin": "^5.10.0",
-    "@vitest/eslint-plugin": "^1.6.20",
-    "eslint": "^10.5.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-import-resolver-typescript": "^4.4.5",
-    "eslint-plugin-depend": "^1.5.0",
-    "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsdoc": "^63.0.6",
-    "eslint-plugin-mdx": "^3.8.1",
-    "eslint-plugin-n": "^18.1.0",
-    "eslint-plugin-perfectionist": "^5.9.1",
-    "eslint-plugin-prettier": "^5.5.6",
-    "eslint-plugin-sonarjs": "^4.1.0",
-    "eslint-plugin-unicorn": "^68.0.0",
-    "fdir": "^6.5.0",
-    "globals": "^17.6.0",
-    "prettier": "^3.8.4",
-    "prettier-plugin-packagejson": "^3.0.2",
+    "oxfmt": "^0.57.0",
+    "oxlint": "^1.72.0",
+    "oxlint-tsgolint": "^0.24.0",
     "termost": "^1.9.1",
     "turbo": "^2.9.18",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.61.1"
+    "typescript": "^6.0.3"
   },
   "devDependencies": {
     "@types/node": "24.13.2",
     "quickbundle": "3.0.0"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
   "scripts": {
     "build": "quickbundle build",
     "prestart": "pnpm build",