@whoj/eslint-config 2.4.1 → 7.4.30

package/bin/index.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli.mjs';

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,444 @@
+import process from "node:process";
+import fs from "node:fs/promises";
+import fs$1 from "node:fs";
+import path from "node:path";
+import c, { green } from "ansis";
+import { cac } from "cac";
+import * as p from "@clack/prompts";
+import { execSync } from "node:child_process";
+import parse from "parse-gitignore";
+import { deepMerge } from "@whoj/utils-core";
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+
+//#region src/cli/utils.ts
+function isGitClean() {
+	try {
+		execSync("git diff-index --quiet HEAD --");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getEslintConfigContent(mainConfig, additionalConfigs) {
+	return `
+import whoj from '@whoj/eslint-config'
+
+export default whoj({
+${mainConfig}
+}${additionalConfigs?.map((config) => `,{\n${config}\n}`)})
+`.trimStart();
+}
+function getJetbrainsEslintConfigContent(configFrom) {
+	return `
+import whoj from "${configFrom}"
+
+export default whoj.clone().overrides({
+  'whoj/javascript/rules': {
+    rules: {
+      'prefer-const': 'warn',
+      'unused-imports/no-unused-imports': 'warn',
+    },
+  },
+  'whoj/test/rules': {
+    rules: {
+      'test/no-only-tests': 'warn',
+      'test/consistent-test-it': ['error', { fn: 'it', withinDescribe: 'it' }],
+    },
+  },
+}).disableRulesFix([
+  'unused-imports/no-unused-imports',
+  'test/no-only-tests',
+  'prefer-const',
+], {
+  builtinRules: () => import(['eslint', 'use-at-your-own-risk'].join('/')).then(r => r.builtinRules),
+})
+`.trimStart();
+}
+
+//#endregion
+//#region src/cli/stages/update-eslint-files.ts
+async function updateEslintFiles(result) {
+	const cwd = process.cwd();
+	const pathESLintIgnore = path.join(cwd, ".eslintignore");
+	const pathPackageJSON = path.join(cwd, "package.json");
+	const pkgContent = await fs.readFile(pathPackageJSON, "utf-8");
+	const configFileName = JSON.parse(pkgContent).type === "module" ? "eslint.config.js" : "eslint.config.mjs";
+	const pathFlatConfig = path.join(cwd, configFileName);
+	const eslintIgnores = [];
+	if (fs$1.existsSync(pathESLintIgnore)) {
+		p.log.step(c.cyan`Migrating existing .eslintignore`);
+		const globs = parse(await fs.readFile(pathESLintIgnore, "utf-8")).globs();
+		for (const glob of globs) if (glob.type === "ignore") eslintIgnores.push(...glob.patterns);
+		else if (glob.type === "unignore") eslintIgnores.push(...glob.patterns.map((pattern) => `!${pattern}`));
+	}
+	const configLines = [];
+	if (eslintIgnores.length) configLines.push(`ignores: ${JSON.stringify(eslintIgnores)},`);
+	if (result.extra.includes("formatter")) configLines.push("formatters: true,");
+	if (result.extra.includes("unocss")) configLines.push("unocss: true,");
+	for (const framework of result.frameworks) configLines.push(`${framework}: true,`);
+	const eslintConfigContent = getEslintConfigContent(configLines.map((i) => `  ${i}`).join("\n"), []);
+	await fs.writeFile(pathFlatConfig, eslintConfigContent);
+	p.log.success(c.green`Created ${configFileName}`);
+	const files = fs$1.readdirSync(cwd);
+	const legacyConfig = [];
+	files.forEach((file) => {
+		if (/eslint|prettier/.test(file) && !/eslint\.config\./.test(file)) legacyConfig.push(file);
+	});
+	if (legacyConfig.length) p.note(c.dim(legacyConfig.join(", ")), "You can now remove those files manually");
+	return configFileName;
+}
+
+//#endregion
+//#region src/cli/constants.ts
+const vscodeSettingsString = `
+  // Disable the default formatter, use eslint instead
+  "prettier.enable": false,
+  "editor.formatOnSave": false,
+
+  // Auto fix
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit",
+    "source.organizeImports": "never"
+  },
+
+  // Silent the stylistic rules in your IDE, but still auto fix them
+  "eslint.rules.customizations": [
+    { "rule": "style/*", "severity": "off", "fixable": true },
+    { "rule": "format/*", "severity": "off", "fixable": true },
+    { "rule": "*-indent", "severity": "off", "fixable": true },
+    { "rule": "*-spacing", "severity": "off", "fixable": true },
+    { "rule": "*-spaces", "severity": "off", "fixable": true },
+    { "rule": "*-order", "severity": "off", "fixable": true },
+    { "rule": "*-dangle", "severity": "off", "fixable": true },
+    { "rule": "*-newline", "severity": "off", "fixable": true },
+    { "rule": "*quotes", "severity": "off", "fixable": true },
+    { "rule": "*semi", "severity": "off", "fixable": true }
+  ],
+
+  // Enable eslint for all supported languages
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "typescript",
+    "typescriptreact",
+    "vue",
+    "html",
+    "markdown",
+    "json",
+    "json5",
+    "jsonc",
+    "yaml",
+    "toml",
+    "xml",
+    "gql",
+    "graphql",
+    "astro",
+    "svelte",
+    "css",
+    "less",
+    "scss",
+    "pcss",
+    "postcss"
+  ]
+`;
+const frameworkOptions = [
+	{
+		value: "vue",
+		label: c.green("Vue")
+	},
+	{
+		value: "react",
+		label: c.cyan("React")
+	},
+	{
+		value: "svelte",
+		label: c.red("Svelte")
+	},
+	{
+		value: "astro",
+		label: c.magenta("Astro")
+	},
+	{
+		value: "solid",
+		label: c.cyan("Solid")
+	},
+	{
+		value: "slidev",
+		label: c.blue("Slidev")
+	}
+];
+const frameworks = frameworkOptions.map(({ value }) => value);
+const extraOptions = [{
+	value: "formatter",
+	label: c.red("Formatter"),
+	hint: "Use external formatters (Prettier and/or dprint) to format files that ESLint cannot handle yet (.css, .html, etc)"
+}, {
+	value: "unocss",
+	label: c.cyan("UnoCSS")
+}];
+const extra = extraOptions.map(({ value }) => value);
+const dependenciesMap = {
+	vue: [],
+	solid: ["eslint-plugin-solid"],
+	unocss: ["@unocss/eslint-plugin"],
+	slidev: ["prettier-plugin-slidev"],
+	formatter: ["eslint-plugin-format"],
+	nextjs: ["@next/eslint-plugin-next"],
+	formatterAstro: ["prettier-plugin-astro"],
+	astro: ["eslint-plugin-astro", "astro-eslint-parser"],
+	svelte: ["eslint-plugin-svelte", "svelte-eslint-parser"],
+	react: [
+		"@eslint-react/eslint-plugin",
+		"eslint-plugin-react-hooks",
+		"eslint-plugin-react-refresh"
+	]
+};
+const jetbrainsSettingsObj = {
+	"?xml": {
+		version: "1.0",
+		encoding: "UTF-8"
+	},
+	"project": {
+		version: "4",
+		component: {
+			"name": "EslintConfiguration",
+			"extra-options": { value: "--cache" },
+			"option": {
+				value: "true",
+				name: "fix-on-save"
+			},
+			"custom-configuration-file": {
+				used: "true",
+				path: "$PROJECT_DIR$/eslint.config.js"
+			}
+		}
+	}
+};
+
+//#endregion
+//#region package.json
+var version = "7.4.30";
+
+//#endregion
+//#region src/cli/constants-generated.ts
+const versionsMap = {
+	"@eslint-react/eslint-plugin": "^2.12.4",
+	"@next/eslint-plugin-next": "^16.1.6",
+	"@unocss/eslint-plugin": "^66.6.0",
+	"astro-eslint-parser": "^1.2.2",
+	"eslint": "^9.39.2",
+	"eslint-plugin-astro": "^1.5.0",
+	"eslint-plugin-format": "^1.4.0",
+	"eslint-plugin-react-hooks": "^7.0.1",
+	"eslint-plugin-react-refresh": "^0.5.0",
+	"eslint-plugin-solid": "^0.14.5",
+	"eslint-plugin-svelte": "^3.15.0",
+	"prettier-plugin-astro": "^0.14.1",
+	"prettier-plugin-slidev": "^1.0.5",
+	"svelte-eslint-parser": "^1.4.1"
+};
+
+//#endregion
+//#region src/cli/stages/update-package-json.ts
+async function updatePackageJson(result) {
+	const cwd = process.cwd();
+	const pathPackageJSON = path.join(cwd, "package.json");
+	p.log.step(c.cyan`Bumping @whoj/eslint-config to v${version}`);
+	const pkgContent = await fs.readFile(pathPackageJSON, "utf-8");
+	const pkg = JSON.parse(pkgContent);
+	pkg.devDependencies ??= {};
+	pkg.devDependencies["@whoj/eslint-config"] = `^${version}`;
+	pkg.devDependencies.eslint ??= versionsMap.eslint;
+	const addedPackages = [];
+	if (result.extra.length) result.extra.forEach((item) => {
+		switch (item) {
+			case "unocss":
+				dependenciesMap.unocss.forEach((f) => {
+					pkg.devDependencies[f] = versionsMap[f];
+					addedPackages.push(f);
+				});
+				break;
+			case "formatter":
+				[...dependenciesMap.formatter, ...result.frameworks.includes("astro") ? dependenciesMap.formatterAstro : []].forEach((f) => {
+					if (!f) return;
+					pkg.devDependencies[f] = versionsMap[f];
+					addedPackages.push(f);
+				});
+				break;
+		}
+	});
+	for (const framework of result.frameworks) {
+		const deps = dependenciesMap[framework];
+		if (deps) deps.forEach((f) => {
+			pkg.devDependencies[f] = versionsMap[f];
+			addedPackages.push(f);
+		});
+	}
+	if (addedPackages.length) p.note(c.dim(addedPackages.join(", ")), "Added packages");
+	await fs.writeFile(pathPackageJSON, JSON.stringify(pkg, null, 2));
+	p.log.success(c.green`Changes wrote to package.json`);
+}
+
+//#endregion
+//#region src/cli/stages/update-jetbrains-idea.ts
+async function updateJetbrainsIdea(result, configFileName) {
+	if (!result.updateJetbrainsIdea) return;
+	const xmlParser = new XMLParser({
+		ignoreAttributes: false,
+		attributeNamePrefix: ""
+	});
+	const xmlBuilder = new XMLBuilder({
+		format: true,
+		ignoreAttributes: false,
+		attributeNamePrefix: "",
+		suppressEmptyNode: true
+	});
+	const cwd = process.cwd();
+	const ideaDir = path.join(cwd, ".idea");
+	const jsLintersDir = path.join(ideaDir, "jsLinters");
+	if (!fs$1.existsSync(ideaDir)) fs$1.mkdirSync(ideaDir, { recursive: true });
+	if (!fs$1.existsSync(jsLintersDir)) fs$1.mkdirSync(jsLintersDir, { recursive: true });
+	const eslintXmlPath = path.join(jsLintersDir, "eslint.xml");
+	let settings;
+	if (fs$1.existsSync(eslintXmlPath)) {
+		const content = fs$1.readFileSync(eslintXmlPath, "utf-8");
+		settings = deepMerge(xmlParser.parse(content), jetbrainsSettingsObj);
+		p.log.step(c.cyan`Updating existing JetBrains ESLint configuration`);
+	} else {
+		settings = { ...jetbrainsSettingsObj };
+		p.log.step(c.cyan`Creating new JetBrains ESLint configuration`);
+	}
+	settings.project.component["custom-configuration-file"] = {
+		used: "true",
+		path: `$PROJECT_DIR$/.idea/jsLinters/${configFileName}`
+	};
+	const xml = xmlBuilder.build(settings);
+	fs$1.writeFileSync(eslintXmlPath, xml, "utf-8");
+	const jetbrainsConfigPath = path.join(jsLintersDir, configFileName);
+	const configContent = getJetbrainsEslintConfigContent(path.relative(jsLintersDir, path.join(cwd, configFileName)));
+	fs$1.writeFileSync(jetbrainsConfigPath, configContent, "utf-8");
+	p.log.success(c.green`JetBrains ESLint configuration updated`);
+}
+
+//#endregion
+//#region src/cli/stages/update-vscode-settings.ts
+async function updateVscodeSettings(result) {
+	const cwd = process.cwd();
+	if (!result.updateVscodeSettings) return;
+	const dotVscodePath = path.join(cwd, ".vscode");
+	const settingsPath = path.join(dotVscodePath, "settings.json");
+	if (!fs$1.existsSync(dotVscodePath)) await fs.mkdir(dotVscodePath, { recursive: true });
+	if (!fs$1.existsSync(settingsPath)) {
+		await fs.writeFile(settingsPath, `{${vscodeSettingsString}}\n`, "utf-8");
+		p.log.success(green`Created .vscode/settings.json`);
+	} else {
+		let settingsContent = await fs.readFile(settingsPath, "utf8");
+		settingsContent = settingsContent.trim().replace(/\s*\}$/, "");
+		settingsContent += settingsContent.endsWith(",") || settingsContent.endsWith("{") ? "" : ",";
+		settingsContent += `${vscodeSettingsString}}\n`;
+		await fs.writeFile(settingsPath, settingsContent, "utf-8");
+		p.log.success(green`Updated .vscode/settings.json`);
+	}
+}
+
+//#endregion
+//#region src/cli/run.ts
+async function run({ jetbrains, ...options } = {}) {
+	const argSkipPrompt = !!process.env.SKIP_PROMPT || options.yes;
+	const argTemplate = options.frameworks?.map((m) => m?.trim()).filter(Boolean);
+	const argExtra = options.extra?.map((m) => m?.trim()).filter(Boolean);
+	if (fs$1.existsSync(path.join(process.cwd(), "eslint.config.js"))) {
+		p.log.warn(c.yellow`eslint.config.js already exists, migration wizard exited.`);
+		return process.exit(1);
+	}
+	let result = {
+		extra: argExtra ?? [],
+		frameworks: argTemplate ?? [],
+		uncommittedConfirmed: false,
+		updateJetbrainsIdea: jetbrains ?? true,
+		updateVscodeSettings: true
+	};
+	if (!argSkipPrompt) {
+		result = await p.group({
+			uncommittedConfirmed: () => {
+				if (argSkipPrompt || isGitClean()) return Promise.resolve(true);
+				return p.confirm({
+					initialValue: false,
+					message: "There are uncommitted changes in the current repository, are you sure to continue?"
+				});
+			},
+			frameworks: ({ results }) => {
+				const isArgTemplateValid = typeof argTemplate === "string" && !!frameworks.includes(argTemplate);
+				if (!results.uncommittedConfirmed || isArgTemplateValid) return;
+				const message = !isArgTemplateValid && argTemplate ? `"${argTemplate}" isn't a valid template. Please choose from below: ` : "Select a framework:";
+				return p.multiselect({
+					message: c.reset(message),
+					options: frameworkOptions,
+					required: false
+				});
+			},
+			extra: ({ results }) => {
+				const isArgExtraValid = argExtra?.length && !argExtra.filter((element) => !extra.includes(element)).length;
+				if (!results.uncommittedConfirmed || isArgExtraValid) return;
+				const message = !isArgExtraValid && argExtra ? `"${argExtra}" isn't a valid extra util. Please choose from below: ` : "Select a extra utils:";
+				return p.multiselect({
+					message: c.reset(message),
+					options: extraOptions,
+					required: false
+				});
+			},
+			updateJetbrainsIdea: ({ results }) => {
+				if (!results.uncommittedConfirmed) return;
+				return p.confirm({
+					initialValue: true,
+					message: "Update JetBrain IDE's eslint configuration for better experience WebStorm / PhpStorm?"
+				});
+			},
+			updateVscodeSettings: ({ results }) => {
+				if (!results.uncommittedConfirmed) return;
+				return p.confirm({
+					initialValue: true,
+					message: "Update .vscode/settings.json for better VS Code experience?"
+				});
+			}
+		}, { onCancel: () => {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		} });
+		if (!result.uncommittedConfirmed) return process.exit(1);
+	}
+	await updatePackageJson(result);
+	const configFileName = await updateEslintFiles(result);
+	await updateJetbrainsIdea(result, configFileName);
+	await updateVscodeSettings(result);
+	p.log.success(c.green`Setup completed`);
+	p.outro(`Now you can update the dependencies by run ${c.blue("pnpm install")} and run ${c.blue("eslint --fix")}\n`);
+}
+
+//#endregion
+//#region src/cli/index.ts
+function header() {
+	console.log("\n");
+	p.intro(`${c.green`@whoj/eslint-config `}${c.dim`v${version}`}`);
+}
+const cli = cac("@whoj/eslint-config");
+cli.command("", "Run the initialization or migration").option("--yes, -y", "Skip prompts and use default values", { default: false }).option("--template, -t <template>", "Use the framework template for optimal customization: vue / react / svelte / astro", { type: [] }).option("--extra, -e <extra>", "Use the extra utils: formatter / perfectionist / unocss", { type: [] }).option("--jetbrains", "Configure eslint settings for better Jetbrains IDE. (WebStorm / PhpStorm) experience.", {
+	default: true,
+	type: "boolean",
+	alias: ["idea", "j"]
+}).action(async (args) => {
+	header();
+	try {
+		await run(args);
+	} catch (error) {
+		p.log.error(c.inverse.red(" Failed to migrate "));
+		p.log.error(c.red`✘ ${String(error)}`);
+		process.exit(1);
+	}
+});
+cli.help();
+cli.version(version);
+cli.parse();
+
+//#endregion
+export {  };