@so1ve/eslint-plugin 4.1.8 → 4.2.0

package/dist/rules/function-style.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/function-style.d.ts
+type MessageIds = "arrow" | "declaration";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/function-style.mjs

@@ -0,0 +1,145 @@
+import { createEslintRule, getPreviousNode } from "../utils/index.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+
+//#region src/rules/function-style.ts
+const RULE_NAME = "function-style";
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce function style." },
+		fixable: "code",
+		schema: [],
+		messages: {
+			arrow: "Expected an arrow function shorthand.",
+			declaration: "Expected a function declaration."
+		}
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const sourceCode = context.sourceCode;
+		const scopeStack = [];
+		let haveThisAccess = false;
+		function getSingleReturnStatement(node) {
+			const { body } = node;
+			if (body.type !== AST_NODE_TYPES.BlockStatement) return;
+			const { body: blockBody } = body;
+			if (blockBody.length !== 1) return;
+			const [statement] = blockBody;
+			if (statement?.type !== AST_NODE_TYPES.ReturnStatement) return;
+			const allComments = sourceCode.getCommentsInside(node);
+			const statementComments = sourceCode.getCommentsInside(statement);
+			if (allComments.length !== statementComments.length) return;
+			return statement;
+		}
+		const extractFunctionInfo = (node) => ({
+			async: node.async,
+			generics: node.typeParameters ? sourceCode.getText(node.typeParameters) : "",
+			params: node.params.map((param) => sourceCode.getText(param)).join(", "),
+			returnType: node.returnType ? sourceCode.getText(node.returnType) : "",
+			body: sourceCode.getText(node.body)
+		});
+		function generateArrowFunction(name, info, returnValue, asVariable = true) {
+			const asyncKeyword = info.async ? "async " : "";
+			return `${asVariable && name ? `const ${name} = ` : ""}${asyncKeyword}${info.generics}(${info.params})${info.returnType} => ${returnValue};`;
+		}
+		function generateFunctionDeclaration(name, info) {
+			return `${info.async ? "async " : ""}function ${name}${info.generics}(${info.params})${info.returnType} ${info.body}`;
+		}
+		function setupScope(node) {
+			scopeStack.push(sourceCode.getScope(node));
+		}
+		function clearThisAccess() {
+			scopeStack.pop();
+			haveThisAccess = false;
+		}
+		function getFunctionExpressionParentNameString(node) {
+			const parent = node.parent;
+			if (parent?.id?.typeAnnotation || parent?.type !== AST_NODE_TYPES.VariableDeclarator || haveThisAccess) return null;
+			return parent.id.name;
+		}
+		function shouldConvertFunctionDeclarationToArrow(node) {
+			if (haveThisAccess) return { shouldConvert: false };
+			const previousNode = getPreviousNode(node.parent);
+			if (previousNode?.type === AST_NODE_TYPES.ExportNamedDeclaration && previousNode.declaration?.type === AST_NODE_TYPES.TSDeclareFunction) return { shouldConvert: false };
+			const returnStatement = getSingleReturnStatement(node);
+			const isExportDefault = node.parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration;
+			if (!returnStatement?.argument || !node.id?.name && !isExportDefault || node.generator) return { shouldConvert: false };
+			return {
+				shouldConvert: true,
+				returnStatement
+			};
+		}
+		return {
+			"FunctionExpression": setupScope,
+			"FunctionExpression:exit"(node) {
+				const name = getFunctionExpressionParentNameString(node);
+				if (!name) {
+					clearThisAccess();
+					return;
+				}
+				const info = extractFunctionInfo(node);
+				const grandParent = node.parent?.parent;
+				if (!grandParent) return;
+				context.report({
+					node,
+					messageId: "declaration",
+					fix: (fixer) => fixer.replaceText(grandParent, generateFunctionDeclaration(name, info))
+				});
+				clearThisAccess();
+			},
+			"FunctionDeclaration:not(TSDeclareFunction + FunctionDeclaration)": setupScope,
+			"FunctionDeclaration:not(TSDeclareFunction + FunctionDeclaration):exit"(node) {
+				if (haveThisAccess) return;
+				const { shouldConvert, returnStatement } = shouldConvertFunctionDeclarationToArrow(node);
+				if (!shouldConvert || !returnStatement?.argument) {
+					clearThisAccess();
+					return;
+				}
+				const info = extractFunctionInfo(node);
+				const isExportDefault = node.parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration;
+				const returnValue = `(${sourceCode.getText(returnStatement.argument)})`;
+				context.report({
+					node,
+					messageId: "arrow",
+					fix: (fixer) => fixer.replaceText(node, generateArrowFunction(node.id?.name ?? null, info, returnValue, !isExportDefault))
+				});
+				clearThisAccess();
+			},
+			"ArrowFunctionExpression": setupScope,
+			"ArrowFunctionExpression:exit"(node) {
+				if (haveThisAccess) return;
+				const { body, parent } = node;
+				const returnStatement = getSingleReturnStatement(node);
+				if (returnStatement?.argument) {
+					const returnValue = `(${sourceCode.getText(returnStatement.argument)})`;
+					context.report({
+						node,
+						messageId: "arrow",
+						fix: (fixer) => fixer.replaceText(node.body, returnValue)
+					});
+				} else if (body.type === AST_NODE_TYPES.BlockStatement && !parent?.id?.typeAnnotation) {
+					const { body: blockBody } = body;
+					if (blockBody.length > 0 && node.parent?.parent?.type === AST_NODE_TYPES.VariableDeclaration) {
+						const grandParent = node.parent.parent;
+						const name = node.parent.id.name;
+						const info = extractFunctionInfo(node);
+						context.report({
+							node: grandParent,
+							messageId: "declaration",
+							fix: (fixer) => fixer.replaceText(grandParent, generateFunctionDeclaration(name, info))
+						});
+					}
+				}
+				clearThisAccess();
+			},
+			ThisExpression(node) {
+				haveThisAccess = scopeStack.includes(sourceCode.getScope(node));
+			}
+		};
+	}
+});
+var function_style_default = rule;
+
+//#endregion
+export { function_style_default as default };

package/dist/rules/html-spaced-comment.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/html-spaced-comment.d.ts
+type MessageIds = "expectedSpaceBefore" | "expectedSpaceAfter";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/html-spaced-comment.mjs

@@ -0,0 +1,41 @@
+import { createEslintRule } from "../utils/index.mjs";
+
+//#region src/rules/html-spaced-comment.ts
+const RULE_NAME = "html-spaced-comment";
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce consistent spacing in HTML comments" },
+		fixable: "whitespace",
+		schema: [],
+		messages: {
+			expectedSpaceBefore: "Expected space after '<!--'.",
+			expectedSpaceAfter: "Expected space before '-->'."
+		}
+	},
+	defaultOptions: [],
+	create: (context) => ({ Comment(node) {
+		if (node.value?.type !== "CommentContent") return;
+		const rawValue = node.value.value;
+		if (rawValue.trim().length === 0) return;
+		if (!rawValue.startsWith(" ") && !rawValue.startsWith("\n")) context.report({
+			node: node.value,
+			messageId: "expectedSpaceBefore",
+			fix(fixer) {
+				return fixer.insertTextBefore(node.value, " ");
+			}
+		});
+		if (!rawValue.endsWith(" ") && !rawValue.endsWith("\n")) context.report({
+			node: node.value,
+			messageId: "expectedSpaceAfter",
+			fix(fixer) {
+				return fixer.insertTextAfter(node.value, " ");
+			}
+		});
+	} })
+});
+var html_spaced_comment_default = rule;
+
+//#endregion
+export { html_spaced_comment_default as default };

package/dist/rules/import-dedupe.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/import-dedupe.d.ts
+type MessageIds = "importDedupe";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/import-dedupe.mjs

@@ -0,0 +1,42 @@
+import { createEslintRule } from "../utils/index.mjs";
+
+//#region src/rules/import-dedupe.ts
+const RULE_NAME = "import-dedupe";
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Fix duplication in imports." },
+		fixable: "code",
+		schema: [],
+		messages: { importDedupe: "Expect no duplication in imports." }
+	},
+	defaultOptions: [],
+	create: (context) => ({ ImportDeclaration(node) {
+		if (node.specifiers.length <= 1) return;
+		const names = /* @__PURE__ */ new Set();
+		for (const n of node.specifiers) {
+			const id = n.local.name;
+			if (names.has(id)) context.report({
+				node,
+				loc: {
+					start: n.loc.end,
+					end: n.loc.start
+				},
+				messageId: "importDedupe",
+				fix(fixer) {
+					const start = n.range[0];
+					let end = n.range[1];
+					const nextToken = context.sourceCode.getTokenAfter(n);
+					if (nextToken?.value === ",") end = nextToken.range[1];
+					return fixer.removeRange([start, end]);
+				}
+			});
+			names.add(id);
+		}
+	} })
+});
+var import_dedupe_default = rule;
+
+//#endregion
+export { import_dedupe_default as default };

package/dist/rules/import-export-newline.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/import-export-newline.d.ts
+type MessageIds = "newlineAfterLastImport" | "newlineBeforeExport" | "newlineAfterExport";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/import-export-newline.mjs

@@ -0,0 +1,98 @@
+import { createEslintRule, getNextNode, getPreviousNode } from "../utils/index.mjs";
+
+//#region src/rules/import-export-newline.ts
+const RULE_NAME = "import-export-newline";
+const isExportDeclaration = (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration";
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce spacing between imports and exports." },
+		fixable: "code",
+		schema: [],
+		messages: {
+			newlineAfterLastImport: "Expected a blank line after the last import.",
+			newlineBeforeExport: "Expected a blank line before the export.",
+			newlineAfterExport: "Expected a blank line after the export."
+		}
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const sourceCode = context.sourceCode;
+		let lastImportNode = null;
+		const exportNodes = [];
+		function checkExport(node) {
+			exportNodes.push(node);
+		}
+		function checkNewline(node, direction) {
+			let token;
+			let expectedLine;
+			let tokenLine;
+			if (direction === "after") {
+				const endNode = sourceCode.getCommentsAfter(node).find((c) => c.loc.start.line === node.loc.end.line) ?? node;
+				token = sourceCode.getTokenAfter(endNode);
+				const nextComment = sourceCode.getCommentsAfter(endNode)[0];
+				expectedLine = endNode.loc.end.line + 1;
+				tokenLine = token?.loc.start.line;
+				const commentLine = nextComment?.loc.start.line;
+				if (token && (expectedLine === tokenLine || expectedLine === commentLine || tokenLine === endNode.loc.end.line) && token.value !== "}" && token.value !== "<\/script>") return endNode;
+				return null;
+			}
+			const startNode = sourceCode.getCommentsBefore(node)[0] || node;
+			token = sourceCode.getTokenBefore(startNode);
+			expectedLine = startNode.loc.start.line - 1;
+			tokenLine = token?.loc.end.line;
+			if (token && expectedLine === tokenLine) return startNode;
+			return null;
+		}
+		return {
+			ImportDeclaration(node) {
+				lastImportNode = node;
+			},
+			ExportNamedDeclaration: checkExport,
+			ExportDefaultDeclaration: checkExport,
+			ExportAllDeclaration: checkExport,
+			"Program:exit"() {
+				if (lastImportNode) {
+					const parent = lastImportNode.parent;
+					const nextNode = getNextNode(lastImportNode);
+					const isLastInBlock = parent && "body" in parent && Array.isArray(parent.body) && parent.body[parent.body.length - 1] === lastImportNode;
+					if (nextNode && !isLastInBlock) {
+						const lastImportFixNode = checkNewline(lastImportNode, "after");
+						if (lastImportFixNode) context.report({
+							node: lastImportNode,
+							messageId: "newlineAfterLastImport",
+							fix: (fixer) => fixer.insertTextAfter(lastImportFixNode, "\n")
+						});
+					}
+				}
+				for (const node of exportNodes) {
+					const prevNode = getPreviousNode(node);
+					const parent = node.parent;
+					const isFirstInBlock = parent && "body" in parent && Array.isArray(parent.body) && parent.body[0] === node;
+					if ((!prevNode || !isExportDeclaration(prevNode)) && (!lastImportNode || prevNode !== lastImportNode) && !isFirstInBlock) {
+						const beforeFixNode = checkNewline(node, "before");
+						if (beforeFixNode) context.report({
+							node,
+							messageId: "newlineBeforeExport",
+							fix: (fixer) => fixer.insertTextBefore(beforeFixNode, "\n")
+						});
+					}
+					const nextNode = getNextNode(node);
+					if (nextNode && !isExportDeclaration(nextNode)) {
+						const afterFixNode = checkNewline(node, "after");
+						if (afterFixNode) context.report({
+							node,
+							messageId: "newlineAfterExport",
+							fix: (fixer) => fixer.insertTextAfter(afterFixNode, "\n")
+						});
+					}
+				}
+			}
+		};
+	}
+});
+var import_export_newline_default = rule;
+
+//#endregion
+export { import_export_newline_default as default };

package/dist/rules/no-import-promises-as.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/no-import-promises-as.d.ts
+type MessageIds = "noImportPromisesAs";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/no-import-promises-as.mjs

@@ -0,0 +1,45 @@
+import { createEslintRule } from "../utils/index.mjs";
+
+//#region src/rules/no-import-promises-as.ts
+const RULE_NAME = "no-import-promises-as";
+const POSSIBLE_IMPORT_SOURCES = [
+	"dns",
+	"fs",
+	"readline",
+	"stream"
+].flatMap((s) => [s, `node:${s}`]);
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow import promises as." },
+		fixable: "code",
+		schema: [],
+		messages: { noImportPromisesAs: "Expect no import promises as." }
+	},
+	defaultOptions: [],
+	create: (context) => {
+		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");
+			const as = promisesSpecifier?.local.name;
+			if (!promisesSpecifier || !as) return;
+			context.report({
+				node,
+				messageId: "noImportPromisesAs",
+				*fix(fixer) {
+					const s = promisesSpecifier.range[0];
+					let e = promisesSpecifier.range[1];
+					if (text[e] === ",") e += 1;
+					yield fixer.removeRange([s, e]);
+					yield fixer.insertTextAfter(node, `\nimport ${as} from "${node.source.value}/promises";`);
+				}
+			});
+		} };
+	}
+});
+var no_import_promises_as_default = rule;
+
+//#endregion
+export { no_import_promises_as_default as default };

package/dist/rules/no-inline-type-modifier.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/no-inline-type-modifier.d.ts
+type MessageIds = "noInlineTypeModifier";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/no-inline-type-modifier.mjs

@@ -0,0 +1,86 @@
+import { createEslintRule } from "../utils/index.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+
+//#region src/rules/no-inline-type-modifier.ts
+const RULE_NAME = "no-inline-type-modifier";
+const getName = (node) => node.type === AST_NODE_TYPES.Identifier ? node.name : node.raw;
+function getSpecifierText(s) {
+	const isExport = s.type === AST_NODE_TYPES.ExportSpecifier;
+	const name1 = getName(isExport ? s.local : s.imported);
+	const name2 = getName(isExport ? s.exported : s.local);
+	return name1 === name2 ? name1 : `${name1} as ${name2}`;
+}
+function generateSpecifiersText(specifiers) {
+	return `{ ${specifiers.map(getSpecifierText).join(", ")} }`;
+}
+const generateTypeText = (specifiers) => `type ${generateSpecifiersText(specifiers)}`;
+function generateValueText(valueSpecifiers, defaultSpecifier) {
+	const parts = [];
+	if (defaultSpecifier) parts.push(defaultSpecifier.local.name);
+	if (valueSpecifiers.length > 0) parts.push(generateSpecifiersText(valueSpecifiers));
+	return parts.join(", ");
+}
+function classifySpecifiers(specifiers) {
+	const typeSpecifiers = [];
+	const valueSpecifiers = [];
+	let defaultSpecifier;
+	for (const s of specifiers) if (s.type === AST_NODE_TYPES.ImportDefaultSpecifier) defaultSpecifier = s;
+	else if (s.type === AST_NODE_TYPES.ImportSpecifier) if (s.importKind === "type") typeSpecifiers.push(s);
+	else valueSpecifiers.push(s);
+	else if (s.type === AST_NODE_TYPES.ExportSpecifier) if (s.exportKind === "type") typeSpecifiers.push(s);
+	else valueSpecifiers.push(s);
+	return {
+		typeSpecifiers,
+		valueSpecifiers,
+		defaultSpecifier
+	};
+}
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "layout",
+		docs: { description: "Disallow inline type modifiers in import/export." },
+		fixable: "code",
+		schema: [],
+		messages: { noInlineTypeModifier: "Expected no inline type modifier." }
+	},
+	defaultOptions: [],
+	create: (context) => ({
+		ImportDeclaration: (node) => {
+			const { typeSpecifiers, valueSpecifiers, defaultSpecifier } = classifySpecifiers(node.specifiers);
+			if (typeSpecifiers.length === 0) return;
+			const texts = [];
+			texts.push(generateTypeText(typeSpecifiers));
+			if (defaultSpecifier || valueSpecifiers.length > 0) texts.push(generateValueText(valueSpecifiers, defaultSpecifier));
+			const textToReport = texts.map((text) => `import ${text} from "${node.source.value}";`).join("\n");
+			context.report({
+				node,
+				messageId: "noInlineTypeModifier",
+				fix(fixer) {
+					return fixer.replaceText(node, textToReport);
+				}
+			});
+		},
+		ExportNamedDeclaration: (node) => {
+			if (node.declaration || node.exportKind === "type") return;
+			const { typeSpecifiers, valueSpecifiers } = classifySpecifiers(node.specifiers);
+			if (typeSpecifiers.length === 0) return;
+			const fromText = node.source ? ` from "${node.source.value}"` : "";
+			const texts = [];
+			texts.push(generateTypeText(typeSpecifiers));
+			if (valueSpecifiers.length > 0) texts.push(generateValueText(valueSpecifiers));
+			const textToReport = texts.map((text) => `export ${text}${fromText};`).join("\n");
+			context.report({
+				node,
+				messageId: "noInlineTypeModifier",
+				fix(fixer) {
+					return fixer.replaceText(node, textToReport);
+				}
+			});
+		}
+	})
+});
+var no_inline_type_modifier_default = rule;
+
+//#endregion
+export { no_inline_type_modifier_default as default };

package/dist/rules/no-negated-comparison.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/no-negated-comparison.d.ts
+type MessageIds = "noNegatedComparison";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/no-negated-comparison.mjs

@@ -0,0 +1,45 @@
+import { createEslintRule } from "../utils/index.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+
+//#region src/rules/no-negated-comparison.ts
+const RULE_NAME = "no-negated-comparison";
+const negatedToPositive = {
+	"==": "!=",
+	"===": "!==",
+	"!=": "==",
+	"!==": "===",
+	"<": ">=",
+	"<=": ">",
+	">": "<=",
+	">=": "<"
+};
+const negatives = Object.keys(negatedToPositive);
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow negated comparison." },
+		fixable: "code",
+		schema: [],
+		messages: { noNegatedComparison: "Expect no negated comparison." }
+	},
+	defaultOptions: [],
+	create: (context) => ({ BinaryExpression(node) {
+		const { parent, left, right, operator } = node;
+		if (!parent) return;
+		if (negatives.includes(operator) && parent.type === AST_NODE_TYPES.UnaryExpression && parent.operator === "!") context.report({
+			node,
+			messageId: "noNegatedComparison",
+			*fix(fixer) {
+				const operatorRange = [left.range[1], right.range[0]];
+				const fixedOperator = negatedToPositive[operator];
+				yield fixer.replaceTextRange(operatorRange, fixedOperator);
+				yield fixer.removeRange([parent.range[0], parent.range[0] + 1]);
+			}
+		});
+	} })
+});
+var no_negated_comparison_default = rule;
+
+//#endregion
+export { no_negated_comparison_default as default };

package/dist/rules/no-useless-template-string.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/no-useless-template-string.d.ts
+type MessageIds = "noUselessTemplateString";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/no-useless-template-string.mjs

@@ -0,0 +1,30 @@
+import { createEslintRule } from "../utils/index.mjs";
+
+//#region src/rules/no-useless-template-string.ts
+const RULE_NAME = "no-useless-template-string";
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "No useless template string." },
+		fixable: "code",
+		schema: [],
+		messages: { noUselessTemplateString: "No useless template string." }
+	},
+	defaultOptions: [],
+	create: (context) => ({ "TemplateLiteral:not(TaggedTemplateExpression > TemplateLiteral)"(node) {
+		const { quasis } = node;
+		const isSafe = !quasis.some(({ value: { raw } }) => raw.includes("\"") || raw.includes("'") || raw.includes("\n"));
+		if (node.expressions.length === 0 && isSafe) context.report({
+			node,
+			messageId: "noUselessTemplateString",
+			fix(fixer) {
+				return fixer.replaceTextRange(node.range, `"${node.quasis[0].value.raw}"`);
+			}
+		});
+	} })
+});
+var no_useless_template_string_default = rule;
+
+//#endregion
+export { no_useless_template_string_default as default };

package/dist/rules/prefer-ts-expect-error.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/prefer-ts-expect-error.d.ts
+type MessageIds = "preferExpectErrorComment";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/prefer-ts-expect-error.mjs

@@ -0,0 +1,46 @@
+import { createEslintRule } from "../utils/index.mjs";
+import { AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+
+//#region src/rules/prefer-ts-expect-error.ts
+const rule = 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
+				});
+			}
+		} };
+	}
+});
+var prefer_ts_expect_error_default = rule;
+
+//#endregion
+export { prefer_ts_expect_error_default as default };