@so1ve/eslint-plugin 3.9.0 → 3.10.0

package/dist/index.d.ts

@@ -19,6 +19,7 @@ declare const _default: {
     "no-useless-template-string": _typescript_eslint_utils_ts_eslint0.RuleModule<"noUselessTemplateString", [], unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
     "no-import-promises-as": _typescript_eslint_utils_ts_eslint0.RuleModule<"noImportPromisesAs", [], unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
     "pad-after-last-import": _typescript_eslint_utils_ts_eslint0.RuleModule<"padAfterLastImport", [], unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+    "prefer-ts-expect-error": _typescript_eslint_utils_ts_eslint0.RuleModule<"preferExpectErrorComment", [], unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
     "require-async-with-await": _typescript_eslint_utils_ts_eslint0.RuleModule<"requireAsyncWithAwait", [], unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
     "vue-root-element-sort-attributes": _typescript_eslint_utils_ts_eslint0.RuleModule<"wrongOrder", Options, unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
   };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
-import { ESLintUtils } from "@typescript-eslint/utils";
+import { AST_TOKEN_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
 //#region src/utils/index.ts
 const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
@@ -55,12 +55,10 @@ var function_style_default = createEslintRule({
 		});
 		function generateArrowFunction(name, info, returnValue, asVariable = true) {
 			const asyncKeyword = info.async ? "async " : "";
-			const variableDeclaration = asVariable && name ? `const ${name} = ` : "";
-			return `${variableDeclaration}${asyncKeyword}${info.generics}(${info.params})${info.returnType} => ${returnValue};`;
+			return `${asVariable && name ? `const ${name} = ` : ""}${asyncKeyword}${info.generics}(${info.params})${info.returnType} => ${returnValue};`;
 		}
 		function generateFunctionDeclaration(name, info) {
-			const asyncKeyword = info.async ? "async " : "";
-			return `${asyncKeyword}function ${name}${info.generics}(${info.params})${info.returnType} ${info.body}`;
+			return `${info.async ? "async " : ""}function ${name}${info.generics}(${info.params})${info.returnType} ${info.body}`;
 		}
 		function setupScope(node) {
 			scopeStack.push(sourceCode.getScope(node));
@@ -185,7 +183,7 @@ var import_dedupe_default = createEslintRule({
 					const start = n.range[0];
 					let end = n.range[1];
 					const nextToken = context.sourceCode.getTokenAfter(n);
-					if (nextToken && nextToken.value === ",") end = nextToken.range[1];
+					if (nextToken?.value === ",") end = nextToken.range[1];
 					return fixer.removeRange([start, end]);
 				}
 			});
@@ -214,8 +212,7 @@ var no_import_promises_as_default = createEslintRule({
 	},
 	defaultOptions: [],
 	create: (context) => {
-		const sourceCode = context.sourceCode;
-		const { text } = sourceCode;
+		const { text } = context.sourceCode;
 		return { ImportDeclaration(node) {
 			if (!POSSIBLE_IMPORT_SOURCES.includes(node.source.value)) return;
 			const promisesSpecifier = node.specifiers.find((s) => s.type === "ImportSpecifier" && s.imported.type === "Identifier" && s.imported.name === "promises" && s.local.name !== "promises");
@@ -249,35 +246,32 @@ var no_inline_type_import_default = createEslintRule({
 		messages: { noInlineTypeImport: "Expected no inline type import." }
 	},
 	defaultOptions: [],
-	create: (context) => {
-		const sourceCode = context.sourceCode;
-		return { ImportDeclaration: (node) => {
-			const { specifiers } = node;
-			const typeSpecifiers = specifiers.filter((s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "type");
-			const valueSpecifiers = specifiers.filter((s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "value");
-			const defaultImportSpecifier = specifiers.find((s) => s.type === AST_NODE_TYPES.ImportDefaultSpecifier);
-			if (typeSpecifiers.length > 0 && valueSpecifiers.length > 0) context.report({
-				node,
-				messageId: "noInlineTypeImport",
-				fix(fixer) {
-					const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
-					const valueSpecifiersText = valueSpecifiers.map((s) => sourceCode.getText(s)).join(", ");
-					const defaultImportSpecifierText = sourceCode.getText(defaultImportSpecifier);
-					const defaultAndValueSpecifiersText = defaultImportSpecifier ? `import ${defaultImportSpecifierText}, { ${valueSpecifiersText} } from "${node.source.value}";` : `import { ${valueSpecifiersText} } from "${node.source.value}";`;
-					const texts = [`import type { ${typeSpecifiersText} } from "${node.source.value}";`, defaultAndValueSpecifiersText];
-					return fixer.replaceText(node, texts.join("\n"));
-				}
-			});
-			else if (typeSpecifiers.length > 0) context.report({
-				node,
-				messageId: "noInlineTypeImport",
-				fix(fixer) {
-					const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
-					return fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";`);
-				}
-			});
-		} };
-	}
+	create: (context) => ({ ImportDeclaration: (node) => {
+		const { specifiers } = node;
+		const typeSpecifiers = specifiers.filter((s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "type");
+		const valueSpecifiers = specifiers.filter((s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "value");
+		const defaultImportSpecifier = specifiers.find((s) => s.type === AST_NODE_TYPES.ImportDefaultSpecifier);
+		if (typeSpecifiers.length > 0) if (valueSpecifiers.length > 0) context.report({
+			node,
+			messageId: "noInlineTypeImport",
+			fix(fixer) {
+				const typeSpecifiersText = typeSpecifiers.map((s) => s.local.name).join(", ");
+				const valueSpecifiersText = valueSpecifiers.map((s) => s.local.name).join(", ");
+				const defaultImportSpecifierText = defaultImportSpecifier?.local.name;
+				const defaultAndValueSpecifiersText = defaultImportSpecifier ? `import ${defaultImportSpecifierText}, { ${valueSpecifiersText} } from "${node.source.value}";` : `import { ${valueSpecifiersText} } from "${node.source.value}";`;
+				const texts = [`import type { ${typeSpecifiersText} } from "${node.source.value}";`, defaultAndValueSpecifiersText];
+				return fixer.replaceText(node, texts.join("\n"));
+			}
+		});
+		else context.report({
+			node,
+			messageId: "noInlineTypeImport",
+			fix(fixer) {
+				const typeSpecifiersText = typeSpecifiers.map((s) => s.local.name).join(", ");
+				return fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";`);
+			}
+		});
+	} })
 });
 
 //#endregion
@@ -383,6 +377,47 @@ var pad_after_last_import_default = createEslintRule({
 	}
 });
 
+//#endregion
+//#region src/rules/prefer-ts-expect-error.ts
+var prefer_ts_expect_error_default = createEslintRule({
+	name: "prefer-ts-expect-error",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce using `@ts-expect-error` over `@ts-ignore`" },
+		fixable: "code",
+		messages: { preferExpectErrorComment: "Use \"@ts-expect-error\" to ensure an error is actually being suppressed." },
+		replacedBy: ["@typescript-eslint/ban-ts-comment"],
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const tsIgnoreRegExpSingleLine = /^\s*(?:\/\s*)?@ts-ignore/;
+		const tsIgnoreRegExpMultiLine = /^\s*(?:(?:\/|\*)+\s*)?@ts-ignore/;
+		const isLineComment = (comment) => comment.type === AST_TOKEN_TYPES.Line;
+		function getLastCommentLine(comment) {
+			if (isLineComment(comment)) return comment.value;
+			const commentlines = comment.value.split("\n");
+			return commentlines[commentlines.length - 1];
+		}
+		function isValidTsIgnorePresent(comment) {
+			const line = getLastCommentLine(comment);
+			return isLineComment(comment) ? tsIgnoreRegExpSingleLine.test(line) : tsIgnoreRegExpMultiLine.test(line);
+		}
+		return { Program() {
+			const comments = context.sourceCode.getAllComments();
+			for (const comment of comments) if (isValidTsIgnorePresent(comment)) {
+				const lineCommentRuleFixer = (fixer) => fixer.replaceText(comment, `//${comment.value.replace("@ts-ignore", "@ts-expect-error")}`);
+				const blockCommentRuleFixer = (fixer) => fixer.replaceText(comment, `/*${comment.value.replace("@ts-ignore", "@ts-expect-error")}*/`);
+				context.report({
+					node: comment,
+					messageId: "preferExpectErrorComment",
+					fix: isLineComment(comment) ? lineCommentRuleFixer : blockCommentRuleFixer
+				});
+			}
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/require-async-with-await.ts
 const RULE_NAME$1 = "require-async-with-await";
@@ -501,6 +536,7 @@ var src_default = { rules: {
 	"no-useless-template-string": no_useless_template_string_default,
 	"no-import-promises-as": no_import_promises_as_default,
 	"pad-after-last-import": pad_after_last_import_default,
+	"prefer-ts-expect-error": prefer_ts_expect_error_default,
 	"require-async-with-await": require_async_with_await_default,
 	"vue-root-element-sort-attributes": vue_root_element_sort_attributes_default
 } };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@so1ve/eslint-plugin",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve/)",
   "type": "module",
   "keywords": [
@@ -33,8 +33,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/types": "^8.40.0",
-    "@typescript-eslint/utils": "^8.40.0"
+    "@typescript-eslint/types": "^8.46.1",
+    "@typescript-eslint/utils": "^8.46.1"
   },
   "devDependencies": {
     "vue-eslint-parser": "^10.2.0"