@isentinel/eslint-config 3.0.0-beta.3 → 3.0.0-beta.5

package/README.md

@@ -117,6 +117,20 @@ set:
 }
 ```
 
+Alternatively, you can install `@isentinel/tsconfig` from pnpm:
+
+```bash
+pnpm install --save-dev @isentinel/tsconfig
+```
+
+And use it in your `tsconfig.json`:
+
+```json
+{
+	"extends": "@isentinel/tsconfig/roblox"
+}
+```
+
 ### ESLint
 
 The `ts/no-non-null-assertion` rule is enabled by default, which will warn you

package/dist/cli.js

@@ -6,12 +6,12 @@ import { hideBin } from "yargs/helpers";
 import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
-import parse from "parse-gitignore-ts";
+import { existsSync, readFileSync } from "fs";
 import { execSync } from "node:child_process";
 
 //#region package.json
 var name = "@isentinel/eslint-config";
-var version = "3.0.0-beta.3";
+var version = "3.0.0-beta.5";
 var description = "iSentinel's ESLint config";
 var keywords = [
 	"eslint-config",
@@ -59,6 +59,7 @@ var dependencies = {
 	"@eslint/markdown": "catalog:prod",
 	"@isentinel/dict-rbxts": "catalog:prod",
 	"@isentinel/dict-roblox": "catalog:prod",
+	"@isentinel/eslint-plugin-comment-length": "catalog:prod",
 	"@prettier/plugin-oxc": "catalog:prod",
 	"@shopify/eslint-plugin": "catalog:prod",
 	"@stylistic/eslint-plugin": "catalog:prod",
@@ -73,13 +74,11 @@ var dependencies = {
 	"eslint-plugin-antfu": "catalog:prod",
 	"eslint-plugin-arrow-return-style-x": "catalog:prod",
 	"eslint-plugin-better-max-params": "catalog:prod",
-	"eslint-plugin-comment-length": "catalog:prod",
 	"eslint-plugin-de-morgan": "catalog:prod",
 	"eslint-plugin-format-lua": "catalog:prod",
 	"eslint-plugin-import-lite": "catalog:prod",
 	"eslint-plugin-jsdoc": "catalog:prod",
 	"eslint-plugin-jsonc": "catalog:prod",
-	"eslint-plugin-n": "catalog:peer",
 	"eslint-plugin-no-only-tests": "catalog:prod",
 	"eslint-plugin-package-json": "catalog:prod",
 	"eslint-plugin-perfectionist": "catalog:prod",
@@ -94,13 +93,10 @@ var dependencies = {
 	"eslint-plugin-yml": "catalog:prod",
 	"jsonc-eslint-parser": "catalog:prod",
 	"local-pkg": "catalog:prod",
-	"parse-gitignore-ts": "catalog:prod",
 	"prettier": "catalog:prod",
 	"prettier-plugin-jsdoc": "catalog:prod",
 	"prompts": "catalog:prod",
 	"toml-eslint-parser": "catalog:prod",
-	"tsdown": "catalog:dev",
-	"type-fest": "catalog:prod",
 	"yaml-eslint-parser": "catalog:prod",
 	"yargs": "catalog:prod"
 };
@@ -109,6 +105,7 @@ var devDependencies = {
 	"@eslint-react/eslint-plugin": "catalog:peer",
 	"@eslint/config-inspector": "catalog:dev",
 	"@isentinel/eslint-config": "workspace:*",
+	"@isentinel/tsconfig": "catalog:dev",
 	"@stylistic/eslint-plugin-migrate": "catalog:dev",
 	"@types/fs-extra": "catalog:dev",
 	"@types/node": "catalog:dev",
@@ -119,8 +116,9 @@ var devDependencies = {
 	"eslint": "catalog:peer",
 	"eslint-plugin-eslint-plugin": "catalog:peer",
 	"eslint-plugin-jest": "catalog:peer",
-	"eslint-plugin-pnpm": "catalog:prod",
+	"eslint-plugin-n": "catalog:peer",
 	"eslint-plugin-react-roblox-hooks": "catalog:peer",
+	"eslint-plugin-unused-imports": "catalog:dev",
 	"eslint-typegen": "catalog:dev",
 	"esno": "catalog:dev",
 	"execa": "catalog:dev",
@@ -128,9 +126,12 @@ var devDependencies = {
 	"fs-extra": "catalog:dev",
 	"jiti": "catalog:dev",
 	"lint-staged": "catalog:dev",
+	"parse-gitignore-ts": "catalog:dev",
 	"pnpm-workspace-yaml": "catalog:dev",
 	"rimraf": "catalog:dev",
 	"simple-git-hooks": "catalog:dev",
+	"tsdown": "catalog:dev",
+	"type-fest": "catalog:dev",
 	"typescript": "catalog:dev"
 };
 var peerDependencies = {
@@ -150,8 +151,8 @@ var peerDependenciesMeta = {
 	"eslint-plugin-n": { "optional": true },
 	"eslint-plugin-react-roblox-hooks": { "optional": true }
 };
-var packageManager = "pnpm@10.14.0";
-var engines = { "node": ">=22.1.0" };
+var packageManager = "pnpm@10.15.1";
+var engines = { "node": ">=22.16.0" };
 var publishConfig = { "access": "public" };
 var package_default = {
 	name,
@@ -233,6 +234,218 @@ const dependenciesMap = {
 	test: ["eslint-plugin-jest"]
 };
 
+//#endregion
+//#region node_modules/.pnpm/parse-gitignore-ts@1.0.0/node_modules/parse-gitignore-ts/dist/index.mjs
+var isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var INVALID_PATH_CHARS_REGEX = /[<>:"|?*\n\r\t\f\x00-\x1F]/;
+var GLOBSTAR_REGEX = /(?:^|\/)[*]{2}($|\/)/;
+var MAX_PATH_LENGTH = 248;
+var isValidPath = (input) => {
+	if (typeof input === "string") return input.length <= MAX_PATH_LENGTH && !INVALID_PATH_CHARS_REGEX.test(input);
+	return false;
+};
+var split = (str) => String(str).split(/\r\n?|\n/);
+var isComment = (str) => str.startsWith("#");
+var isParsed = (input) => isObject(input) && "patterns" in input && "sections" in input;
+var patterns = (input) => {
+	return split(input).map((l) => l.trim()).filter((line) => line !== "" && !isComment(line));
+};
+var parse = (input, options = {}) => {
+	let filepath = options.path;
+	if (isParsed(input)) return input;
+	if (isValidPath(input) && existsSync(input)) {
+		filepath = input;
+		input = readFileSync(input);
+	}
+	const lines = split(input);
+	const names = /* @__PURE__ */ new Map();
+	const parsed = {
+		sections: [],
+		patterns: []
+	};
+	let section = {
+		name: "default",
+		patterns: []
+	};
+	let prev = null;
+	for (const line of lines) {
+		const value = line.trim();
+		if (value.startsWith("#")) {
+			const match = /^#+\s*(.*)\s*$/.exec(value);
+			const name$1 = match ? match[1] : "";
+			if (prev) {
+				names.delete(prev.name);
+				prev.comment = prev.comment ? `${prev.comment}
+${value}` : value;
+				prev.name = name$1 ? `${prev.name.trim()}
+${name$1.trim()}` : prev.name.trim();
+				names.set(prev.name.toLowerCase().trim(), prev);
+				continue;
+			}
+			section = {
+				name: name$1.trim(),
+				comment: value,
+				patterns: []
+			};
+			names.set(section.name.toLowerCase(), section);
+			parsed.sections.push(section);
+			prev = section;
+			continue;
+		}
+		if (value !== "") {
+			section.patterns.push(value);
+			parsed.patterns.push(value);
+		}
+		prev = null;
+	}
+	if (options.dedupe === true || options.unique === true) return dedupe(parsed, {
+		...options,
+		format: false
+	});
+	parsed.path = filepath;
+	parsed.input = Buffer.from(input.toString());
+	const result = parsed;
+	result.format = (opts = {}) => format(result, {
+		...options,
+		...opts
+	});
+	result.dedupe = (opts = {}) => dedupe(result, {
+		...options,
+		...opts
+	});
+	result.globs = (opts = {}) => globs(result, {
+		path: filepath,
+		...options,
+		...opts
+	});
+	return result;
+};
+var parseFile = (filepath, options = {}) => {
+	return parse(readFileSync(filepath, "utf8"), options);
+};
+var dedupe = (input, options = {}) => {
+	const parsed = parse(input, {
+		...options,
+		dedupe: false
+	});
+	const names = /* @__PURE__ */ new Map();
+	const res = {
+		sections: [],
+		patterns: []
+	};
+	const patternsSet = /* @__PURE__ */ new Set();
+	let current;
+	for (const section of parsed.sections) {
+		const { name: name$1 = "", comment, patterns: patterns2 } = section;
+		const key = name$1.trim().toLowerCase();
+		for (const pattern of patterns2) patternsSet.add(pattern);
+		if (name$1 && names.has(key)) {
+			current = names.get(key);
+			current.patterns = [...current.patterns, ...patterns2];
+		} else {
+			current = {
+				name: name$1,
+				comment,
+				patterns: patterns2
+			};
+			res.sections.push(current);
+			names.set(key, current);
+		}
+	}
+	for (const section of res.sections) section.patterns = [...new Set(section.patterns)];
+	res.patterns = [...patternsSet];
+	const result = res;
+	result.format = (opts = {}) => format(result, {
+		...options,
+		...opts
+	});
+	result.dedupe = (opts = {}) => dedupe(result, {
+		...options,
+		...opts
+	});
+	result.globs = (opts = {}) => globs(result, {
+		path: parsed.path,
+		...options,
+		...opts
+	});
+	return result;
+};
+var glob = (pattern, options) => {
+	if (GLOBSTAR_REGEX.test(pattern)) return pattern;
+	let relative = false;
+	if (pattern.startsWith("/")) {
+		pattern = pattern.slice(1);
+		relative = true;
+	} else if (pattern.slice(1, pattern.length - 1).includes("/")) relative = true;
+	pattern += pattern.endsWith("/") ? "**/" : "/**";
+	return relative ? pattern : `**/${pattern}`;
+};
+var globs = (input, options = {}) => {
+	const parsed = parse(input, options);
+	const result = [];
+	let index = 0;
+	const inputPatterns = parsed.patterns.concat(options.ignore || []).concat((options.unignore || []).map((p) => !p.startsWith("!") ? "!" + p : p));
+	const push = (prefix, pattern) => {
+		const prev = result[result.length - 1];
+		const type$1 = prefix ? "unignore" : "ignore";
+		if (prev && prev.type === type$1) {
+			if (!prev.patterns.includes(pattern)) prev.patterns.push(pattern);
+		} else {
+			result.push({
+				type: type$1,
+				path: options.path || null,
+				patterns: [pattern],
+				index
+			});
+			index++;
+		}
+	};
+	for (let pattern of inputPatterns) {
+		let prefix = "";
+		if (pattern.startsWith("!")) {
+			pattern = pattern.slice(1);
+			prefix = "!";
+		}
+		push(prefix, pattern.startsWith("/") ? pattern.slice(1) : pattern);
+		push(prefix, glob(pattern));
+	}
+	return result;
+};
+var formatSection = (section = {
+	name: "",
+	patterns: []
+}) => {
+	const output = [section.comment || ""];
+	if (section.patterns?.length) {
+		output.push(section.patterns.join("\n"));
+		output.push("");
+	}
+	return output.join("\n");
+};
+var format = (input, options = {}) => {
+	const parsed = parse(input, options);
+	const fn = options.formatSection || formatSection;
+	const sections = parsed.sections || parsed;
+	const output = [];
+	for (const section of [].concat(sections)) output.push(fn(section));
+	return output.join("\n");
+};
+var parseGitignore = parse;
+parseGitignore.file = parseFile;
+parseGitignore.parse = parse;
+parseGitignore.dedupe = dedupe;
+parseGitignore.format = format;
+parseGitignore.globs = globs;
+parseGitignore.formatSection = formatSection;
+parseGitignore.patterns = patterns;
+var index_default = parseGitignore;
+/*!
+* parse-gitignore-ts
+* TypeScript version of parse-gitignore <https://github.com/jonschlinkert/parse-gitignore>
+* Original Copyright (c) 2015-present, Jon Schlinkert.
+* Released under the MIT License.
+*/
+
 //#endregion
 //#region src/cli/utils.ts
 function getEslintConfigContent(mainConfig, additionalConfigs) {
@@ -260,24 +473,21 @@ async function updateEslintFiles(result) {
 	const pathESLintIgnore = path.join(cwd, ".eslintignore");
 	const pathPackageJSON = path.join(cwd, "package.json");
 	const packageContent = await fsp.readFile(pathPackageJSON, "utf-8");
-	const parsedPackage = JSON.parse(packageContent);
-	const configFileName = parsedPackage.type === "module" ? "eslint.config.js" : "eslint.config.mjs";
+	const configFileName = JSON.parse(packageContent)["type"] === "module" ? "eslint.config.js" : "eslint.config.mjs";
 	const pathFlatConfig = path.join(cwd, configFileName);
 	const eslintIgnores = [];
 	if (fs.existsSync(pathESLintIgnore)) {
 		log.step(ansis.cyan("Migrating existing .eslintignore"));
 		const content = await fsp.readFile(pathESLintIgnore, "utf-8");
-		const parsed = parse(content);
-		const globs = parsed.globs();
-		for (const glob of globs) if (glob.type === "ignore") eslintIgnores.push(...glob.patterns);
-		else eslintIgnores.push(...glob.patterns.map((pattern) => `!${pattern}`));
+		const globs$1 = index_default(content).globs();
+		for (const glob$1 of globs$1) if (glob$1.type === "ignore") eslintIgnores.push(...glob$1.patterns);
+		else eslintIgnores.push(...glob$1.patterns.map((pattern) => `!${pattern}`));
 	}
 	const configLines = [];
 	if (eslintIgnores.length) configLines.push(`ignores: ${JSON.stringify(eslintIgnores)},`);
 	for (const framework of result.frameworks) configLines.push(`${framework}: true,`);
 	const mainConfig = configLines.map((index) => `  ${index}`).join("\n");
-	const additionalConfig = [];
-	const eslintConfigContent = getEslintConfigContent(mainConfig, additionalConfig);
+	const eslintConfigContent = getEslintConfigContent(mainConfig, []);
 	await fsp.writeFile(pathFlatConfig, eslintConfigContent);
 	log.success(ansis.green(`Created ${configFileName}`));
 	const files$1 = fs.readdirSync(cwd);
@@ -305,7 +515,7 @@ async function updatePackageJson(result) {
 	const parsedPackage = JSON.parse(packageContent);
 	parsedPackage.devDependencies ??= {};
 	parsedPackage.devDependencies["@isentinel/eslint-config"] = `^${version}`;
-	parsedPackage.devDependencies.eslint ??= versionsMap.eslint;
+	parsedPackage.devDependencies["eslint"] ??= versionsMap.eslint;
 	const addedPackages = [];
 	for (const framework of result.frameworks) if (framework in dependenciesMap) for (const dep of dependenciesMap[framework]) {
 		parsedPackage.devDependencies[dep] = versionsMap[dep];
@@ -340,7 +550,7 @@ async function updateVscodeSettings(result) {
 //#endregion
 //#region src/cli/run.ts
 async function run(options = {}) {
-	const argumentSkipPrompt = !!(process.env.SKIP_PROMPT ?? "") || options.yes;
+	const argumentSkipPrompt = !!(process.env["SKIP_PROMPT"] ?? "") || options.yes;
 	const argumentTemplate = options.frameworks?.map((framework) => framework.trim()).filter((framework) => {
 		return frameworks.includes(framework);
 	});
@@ -401,7 +611,7 @@ function header() {
 	const versionText = `v${package_default.version}`;
 	intro(introText + ansis.dim(versionText));
 }
-const instance = yargs(hideBin(process.argv)).scriptName("@isentinel/eslint-config").usage("").command("*", "Run the initialization or migration", (args) => {
+yargs(hideBin(process.argv)).scriptName("@isentinel/eslint-config").usage("").command("*", "Run the initialization or migration", (args) => {
 	return args.option("yes", {
 		alias: "y",
 		description: "Skip prompts and use default values",
@@ -423,8 +633,7 @@ const instance = yargs(hideBin(process.argv)).scriptName("@isentinel/eslint-conf
 		log.error(ansis.red(`✘ ${String(err)}`));
 		process.exit(1);
 	}
-}).showHelpOnFail(false).alias("h", "help").version("version", package_default.version).alias("v", "version");
-instance.help().argv;
+}).showHelpOnFail(false).alias("h", "help").version("version", package_default.version).alias("v", "version").help().argv;
 
 //#endregion
 export {  };

package/dist/dist-CRJXXCjc.js

@@ -0,0 +1,96 @@
+import { createRequire } from "module";
+
+//#region node_modules/.pnpm/eslint-plugin-unused-imports@4.2.0_@typescript-eslint+eslint-plugin@8.39.1_@typescript-_d725b5966c09a4e636f423644baea633/node_modules/eslint-plugin-unused-imports/dist/index.mjs
+var commaFilter = { filter: (token) => token.value === "," };
+var includeCommentsFilter = { includeComments: true };
+function makePredicate(isImport, addFixer) {
+	return (problem, context) => {
+		const sourceCode = context.sourceCode || context.getSourceCode();
+		const { parent } = problem.node ?? sourceCode.getNodeByRangeIndex(sourceCode.getIndexFromLoc(problem.loc.start));
+		return parent ? /^Import(|Default|Namespace)Specifier$/.test(parent.type) == isImport ? Object.assign(problem, addFixer?.(parent, sourceCode)) : false : isImport ? false : problem;
+	};
+}
+var unusedVarsPredicate = makePredicate(false);
+var unusedImportsPredicate = makePredicate(true, (parent, sourceCode) => ({ fix(fixer) {
+	const grandParent = parent.parent;
+	if (!grandParent) return null;
+	if (grandParent.specifiers.length === 1) {
+		const nextToken = sourceCode.getTokenAfter(grandParent, includeCommentsFilter);
+		const newLinesBetween = nextToken ? nextToken.loc.start.line - grandParent.loc.start.line : 0;
+		const endOfReplaceRange = nextToken ? nextToken.range[0] : grandParent.range[1];
+		const count = Math.max(0, newLinesBetween - 1);
+		return [fixer.remove(grandParent), fixer.replaceTextRange([grandParent.range[1], endOfReplaceRange], "\n".repeat(count))];
+	}
+	if (parent !== grandParent.specifiers[grandParent.specifiers.length - 1]) {
+		const comma = sourceCode.getTokenAfter(parent, commaFilter);
+		const prevNode = sourceCode.getTokenBefore(parent);
+		return [
+			fixer.removeRange([prevNode.range[1], parent.range[0]]),
+			fixer.remove(parent),
+			fixer.remove(comma)
+		];
+	}
+	if (grandParent.specifiers.filter((specifier) => specifier.type === "ImportSpecifier").length === 1) {
+		const start = sourceCode.getTokenBefore(parent, commaFilter);
+		const end = sourceCode.getTokenAfter(parent, { filter: (token) => token.value === "}" });
+		return fixer.removeRange([start.range[0], end.range[1]]);
+	}
+	return fixer.removeRange([sourceCode.getTokenBefore(parent, commaFilter).range[0], parent.range[1]]);
+} }));
+function createRuleWithPredicate(name, baseRule, predicate) {
+	return {
+		...baseRule,
+		meta: {
+			...baseRule.meta,
+			fixable: "code",
+			docs: {
+				...baseRule.meta?.docs,
+				url: `https://github.com/sweepline/eslint-plugin-unused-imports/blob/master/docs/rules/${name}.md`
+			}
+		},
+		create(context) {
+			return baseRule.create(Object.create(context, { report: {
+				enumerable: true,
+				value(problem) {
+					const result = predicate(problem, context);
+					if (result) context.report(result);
+				}
+			} }));
+		}
+	};
+}
+var rule;
+var require2 = createRequire(import.meta.url);
+function getBaseRule() {
+	if (!rule) rule = getRuleFromTSLintPlugin() ?? getRuleFromTSLint() ?? getESLintBaseRule();
+	return rule;
+}
+function getRuleFromTSLintPlugin() {
+	try {
+		return require2("@typescript-eslint/eslint-plugin").rules["no-unused-vars"];
+	} catch (_) {
+		return null;
+	}
+}
+function getRuleFromTSLint() {
+	try {
+		return require2("typescript-eslint").plugin.rules["no-unused-vars"];
+	} catch (_) {
+		return null;
+	}
+}
+function getESLintBaseRule() {
+	return new (require2("eslint")).Linter({ configType: "eslintrc" }).getRules().get("no-unused-vars");
+}
+var no_unused_vars_default = createRuleWithPredicate("no-unused-vars", getBaseRule(), unusedVarsPredicate);
+var no_unused_imports_default = createRuleWithPredicate("no-unused-imports", getBaseRule(), unusedImportsPredicate);
+var index_default = {
+	meta: { name: "unused-imports" },
+	rules: {
+		"no-unused-vars": no_unused_vars_default,
+		"no-unused-imports": no_unused_imports_default
+	}
+};
+
+//#endregion
+export { index_default as default };