@so1ve/eslint-plugin 3.20.2 → 3.22.0

package/dist/index.d.ts

@@ -1,40 +1,54 @@
 import { ESLintUtils } from "@typescript-eslint/utils";
 
 //#region src/rules/function-style.d.ts
-type MessageIds$9 = "arrow" | "declaration";
-declare const rule: ESLintUtils.RuleModule<MessageIds$9>;
+type MessageIds$10 = "arrow" | "declaration";
+type Options$10 = [];
+declare const rule$10: ESLintUtils.RuleModule<MessageIds$10, Options$10>;
+//#endregion
+//#region src/rules/html-spaced-comment.d.ts
+type MessageIds$9 = "expectedSpaceBefore" | "expectedSpaceAfter";
+type Options$9 = [];
+declare const rule$9: ESLintUtils.RuleModule<MessageIds$9, Options$9>;
 //#endregion
 //#region src/rules/import-dedupe.d.ts
 type MessageIds$8 = "importDedupe";
-declare const rule$1: ESLintUtils.RuleModule<MessageIds$8>;
+type Options$8 = [];
+declare const rule$8: ESLintUtils.RuleModule<MessageIds$8, Options$8>;
+//#endregion
+//#region src/rules/import-export-newline.d.ts
+type MessageIds$7 = "newlineAfterLastImport" | "newlineBeforeExport" | "newlineAfterExport";
+type Options$7 = [];
+declare const rule$7: ESLintUtils.RuleModule<MessageIds$7, Options$7>;
 //#endregion
 //#region src/rules/no-import-promises-as.d.ts
-type MessageIds$7 = "noImportPromisesAs";
-declare const rule$2: ESLintUtils.RuleModule<MessageIds$7>;
+type MessageIds$6 = "noImportPromisesAs";
+type Options$6 = [];
+declare const rule$6: ESLintUtils.RuleModule<MessageIds$6, Options$6>;
 //#endregion
 //#region src/rules/no-inline-type-import.d.ts
-type MessageIds$6 = "noInlineTypeImport";
-declare const rule$3: ESLintUtils.RuleModule<MessageIds$6>;
+type MessageIds$5 = "noInlineTypeImport";
+type Options$5 = [];
+declare const rule$5: ESLintUtils.RuleModule<MessageIds$5, Options$5>;
 //#endregion
 //#region src/rules/no-negated-comparison.d.ts
-type MessageIds$5 = "noNegatedComparison";
-declare const rule$4: ESLintUtils.RuleModule<MessageIds$5>;
+type MessageIds$4 = "noNegatedComparison";
+type Options$4 = [];
+declare const rule$4: ESLintUtils.RuleModule<MessageIds$4, Options$4>;
 //#endregion
 //#region src/rules/no-useless-template-string.d.ts
-type MessageIds$4 = "noUselessTemplateString";
-declare const rule$5: ESLintUtils.RuleModule<MessageIds$4>;
-//#endregion
-//#region src/rules/pad-after-last-import.d.ts
-type MessageIds$3 = "padAfterLastImport";
-declare const rule$6: ESLintUtils.RuleModule<MessageIds$3>;
+type MessageIds$3 = "noUselessTemplateString";
+type Options$3 = [];
+declare const rule$3: ESLintUtils.RuleModule<MessageIds$3, Options$3>;
 //#endregion
 //#region src/rules/prefer-ts-expect-error.d.ts
 type MessageIds$2 = "preferExpectErrorComment";
-declare const rule$7: ESLintUtils.RuleModule<MessageIds$2>;
+type Options$2 = [];
+declare const rule$2: ESLintUtils.RuleModule<MessageIds$2, Options$2>;
 //#endregion
 //#region src/rules/require-async-with-await.d.ts
 type MessageIds$1 = "requireAsyncWithAwait";
-declare const rule$8: ESLintUtils.RuleModule<MessageIds$1>;
+type Options$1 = [];
+declare const rule$1: ESLintUtils.RuleModule<MessageIds$1, Options$1>;
 //#endregion
 //#region src/rules/vue-root-element-sort-attributes.d.ts
 type MessageIds = "wrongOrder";
@@ -42,21 +56,22 @@ type Options = [{
   script?: string[];
   [otherElement: string]: string[] | undefined;
 }];
-declare const rule$9: ESLintUtils.RuleModule<MessageIds, Options>;
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
 //#endregion
 //#region src/index.d.ts
 declare const _default: {
   rules: {
-    "function-style": typeof rule;
-    "import-dedupe": typeof rule$1;
-    "no-import-promises-as": typeof rule$2;
-    "no-inline-type-import": typeof rule$3;
+    "function-style": typeof rule$10;
+    "html-spaced-comment": typeof rule$9;
+    "import-dedupe": typeof rule$8;
+    "import-export-newline": typeof rule$7;
+    "no-import-promises-as": typeof rule$6;
+    "no-inline-type-import": typeof rule$5;
     "no-negated-comparison": typeof rule$4;
-    "no-useless-template-string": typeof rule$5;
-    "pad-after-last-import": typeof rule$6;
-    "prefer-ts-expect-error": typeof rule$7;
-    "require-async-with-await": typeof rule$8;
-    "vue-root-element-sort-attributes": typeof rule$9;
+    "no-useless-template-string": typeof rule$3;
+    "prefer-ts-expect-error": typeof rule$2;
+    "require-async-with-await": typeof rule$1;
+    "vue-root-element-sort-attributes": typeof rule;
   };
 };
 //#endregion

package/dist/index.js

@@ -16,9 +16,9 @@ function getPreviousNode(node) {
 
 //#endregion
 //#region src/rules/function-style.ts
-const RULE_NAME$8 = "function-style";
-const rule$9 = createEslintRule({
-	name: RULE_NAME$8,
+const RULE_NAME$9 = "function-style";
+const rule$10 = createEslintRule({
+	name: RULE_NAME$9,
 	meta: {
 		type: "problem",
 		docs: { description: "Enforce function style." },
@@ -153,7 +153,45 @@ const rule$9 = createEslintRule({
 		};
 	}
 });
-var function_style_default = rule$9;
+var function_style_default = rule$10;
+
+//#endregion
+//#region src/rules/html-spaced-comment.ts
+const RULE_NAME$8 = "html-spaced-comment";
+const rule$9 = createEslintRule({
+	name: RULE_NAME$8,
+	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(" ")) context.report({
+			node: node.value,
+			messageId: "expectedSpaceBefore",
+			fix(fixer) {
+				return fixer.insertTextBefore(node.value, " ");
+			}
+		});
+		if (!rawValue.endsWith(" ")) context.report({
+			node: node.value,
+			messageId: "expectedSpaceAfter",
+			fix(fixer) {
+				return fixer.insertTextAfter(node.value, " ");
+			}
+		});
+	} })
+});
+var html_spaced_comment_default = rule$9;
 
 //#endregion
 //#region src/rules/import-dedupe.ts
@@ -194,17 +232,101 @@ const rule$8 = createEslintRule({
 });
 var import_dedupe_default = rule$8;
 
+//#endregion
+//#region src/rules/import-export-newline.ts
+const RULE_NAME$6 = "import-export-newline";
+const isExportDeclaration = (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration";
+function getSiblingNode(node, direction) {
+	const parent = node.parent;
+	if (!parent || !("body" in parent) || !Array.isArray(parent.body)) return null;
+	const body = parent.body;
+	const index = body.indexOf(node);
+	if (index === -1) return null;
+	return direction === "prev" ? index > 0 ? body[index - 1] : null : index < body.length - 1 ? body[index + 1] : null;
+}
+const rule$7 = createEslintRule({
+	name: RULE_NAME$6,
+	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 shouldHaveNewline(node, direction) {
+			let token;
+			let commentLine;
+			let expectedLine;
+			let tokenLine;
+			if (direction === "after") {
+				token = sourceCode.getTokenAfter(node);
+				commentLine = sourceCode.getCommentsAfter(node)[0]?.loc.start.line;
+				expectedLine = node.loc.end.line + 1;
+				tokenLine = token?.loc.start.line;
+			} else {
+				token = sourceCode.getTokenBefore(node);
+				commentLine = sourceCode.getCommentsBefore(node)[0]?.loc.end.line;
+				expectedLine = node.loc.start.line - 1;
+				tokenLine = token?.loc.end.line;
+			}
+			return token && (expectedLine === tokenLine || expectedLine === commentLine) && (direction === "after" ? token.value !== "}" && token.value !== "<\/script>" : true);
+		}
+		return {
+			ImportDeclaration(node) {
+				lastImportNode = node;
+			},
+			ExportNamedDeclaration: checkExport,
+			ExportDefaultDeclaration: checkExport,
+			ExportAllDeclaration: checkExport,
+			"Program:exit"() {
+				if (lastImportNode && shouldHaveNewline(lastImportNode, "after")) context.report({
+					node: lastImportNode,
+					messageId: "newlineAfterLastImport",
+					fix: (fixer) => fixer.insertTextAfter(lastImportNode, "\n")
+				});
+				for (const node of exportNodes) {
+					const prevNode = getSiblingNode(node, "prev");
+					if ((!prevNode || !isExportDeclaration(prevNode)) && !(lastImportNode && prevNode === lastImportNode) && shouldHaveNewline(node, "before")) context.report({
+						node,
+						messageId: "newlineBeforeExport",
+						fix: (fixer) => fixer.insertTextBefore(node, "\n")
+					});
+					const nextNode = getSiblingNode(node, "next");
+					if (nextNode && !isExportDeclaration(nextNode) && shouldHaveNewline(node, "after")) context.report({
+						node,
+						messageId: "newlineAfterExport",
+						fix: (fixer) => fixer.insertTextAfter(node, "\n")
+					});
+				}
+			}
+		};
+	}
+});
+var import_export_newline_default = rule$7;
+
 //#endregion
 //#region src/rules/no-import-promises-as.ts
-const RULE_NAME$6 = "no-import-promises-as";
+const RULE_NAME$5 = "no-import-promises-as";
 const POSSIBLE_IMPORT_SOURCES = [
 	"dns",
 	"fs",
 	"readline",
 	"stream"
 ].flatMap((s) => [s, `node:${s}`]);
-const rule$7 = createEslintRule({
-	name: RULE_NAME$6,
+const rule$6 = createEslintRule({
+	name: RULE_NAME$5,
 	meta: {
 		type: "problem",
 		docs: { description: "Disallow import promises as." },
@@ -234,13 +356,39 @@ const rule$7 = createEslintRule({
 		} };
 	}
 });
-var no_import_promises_as_default = rule$7;
+var no_import_promises_as_default = rule$6;
 
 //#endregion
 //#region src/rules/no-inline-type-import.ts
-const RULE_NAME$5 = "no-inline-type-import";
-const rule$6 = createEslintRule({
-	name: RULE_NAME$5,
+const RULE_NAME$4 = "no-inline-type-import";
+function generateImportsText(specifiers) {
+	let text = "{ ";
+	const texts = [];
+	for (const s of specifiers) {
+		const importedName = s.imported.type === AST_NODE_TYPES.Identifier ? s.imported.name : s.imported.raw;
+		texts.push(importedName === s.local.name ? s.local.name : `${importedName} as ${s.local.name}`);
+	}
+	text += texts.join(", ");
+	text += " }";
+	return text;
+}
+function generateTypeImportText(typeSpecifiers) {
+	let text = "type ";
+	text += generateImportsText(typeSpecifiers);
+	return text;
+}
+function generateValueImportText(defaultImportSpecifier, valueSpecifiers) {
+	const hasValueImport = valueSpecifiers.length > 0;
+	let text = "";
+	if (defaultImportSpecifier) {
+		text += defaultImportSpecifier.local.name;
+		if (hasValueImport) text += ", ";
+	}
+	if (hasValueImport) text += generateImportsText(valueSpecifiers);
+	return text;
+}
+const rule$5 = createEslintRule({
+	name: RULE_NAME$4,
 	meta: {
 		type: "layout",
 		docs: { description: "Disallow inline type import." },
@@ -254,51 +402,28 @@ const rule$6 = createEslintRule({
 		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({
+		const hasDefaultImport = !!defaultImportSpecifier;
+		const hasTypeImport = typeSpecifiers.length > 0;
+		const hasValueImport = valueSpecifiers.length > 0;
+		if (!hasTypeImport) return;
+		const texts = [];
+		texts.push(generateTypeImportText(typeSpecifiers));
+		if (hasDefaultImport || hasValueImport) texts.push(generateValueImportText(defaultImportSpecifier, valueSpecifiers));
+		const textToReport = texts.map((text) => `import ${text} from "${node.source.value}";`).join("\n");
+		context.report({
 			node,
 			messageId: "noInlineTypeImport",
 			fix(fixer) {
-				const typeSpecifiersText = typeSpecifiers.map((s) => {
-					if (s.type === AST_NODE_TYPES.ImportSpecifier) {
-						const importedName = s.imported.type === AST_NODE_TYPES.Identifier ? s.imported.name : s.imported.value;
-						return importedName === s.local.name ? s.local.name : `${importedName} as ${s.local.name}`;
-					}
-					return s.local.name;
-				}).join(", ");
-				const valueSpecifiersText = valueSpecifiers.map((s) => {
-					if (s.type === AST_NODE_TYPES.ImportSpecifier) {
-						const importedName = s.imported.type === AST_NODE_TYPES.Identifier ? s.imported.name : s.imported.value;
-						return importedName === s.local.name ? s.local.name : `${importedName} as ${s.local.name}`;
-					}
-					return 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) => {
-					if (s.type === AST_NODE_TYPES.ImportSpecifier) {
-						const importedName = s.imported.type === AST_NODE_TYPES.Identifier ? s.imported.name : s.imported.value;
-						return importedName === s.local.name ? s.local.name : `${importedName} as ${s.local.name}`;
-					}
-					return s.local.name;
-				}).join(", ");
-				return fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";`);
+				return fixer.replaceText(node, textToReport);
 			}
 		});
 	} })
 });
-var no_inline_type_import_default = rule$6;
+var no_inline_type_import_default = rule$5;
 
 //#endregion
 //#region src/rules/no-negated-comparison.ts
-const RULE_NAME$4 = "no-negated-comparison";
+const RULE_NAME$3 = "no-negated-comparison";
 const negatedToPositive = {
 	"==": "!=",
 	"===": "!==",
@@ -310,8 +435,8 @@ const negatedToPositive = {
 	">=": "<"
 };
 const negatives = Object.keys(negatedToPositive);
-const rule$5 = createEslintRule({
-	name: RULE_NAME$4,
+const rule$4 = createEslintRule({
+	name: RULE_NAME$3,
 	meta: {
 		type: "problem",
 		docs: { description: "Disallow negated comparison." },
@@ -335,13 +460,13 @@ const rule$5 = createEslintRule({
 		});
 	} })
 });
-var no_negated_comparison_default = rule$5;
+var no_negated_comparison_default = rule$4;
 
 //#endregion
 //#region src/rules/no-useless-template-string.ts
-const RULE_NAME$3 = "no-useless-template-string";
-const rule$4 = createEslintRule({
-	name: RULE_NAME$3,
+const RULE_NAME$2 = "no-useless-template-string";
+const rule$3 = createEslintRule({
+	name: RULE_NAME$2,
 	meta: {
 		type: "problem",
 		docs: { description: "No useless template string." },
@@ -362,45 +487,7 @@ const rule$4 = createEslintRule({
 		});
 	} })
 });
-var no_useless_template_string_default = rule$4;
-
-//#endregion
-//#region src/rules/pad-after-last-import.ts
-const RULE_NAME$2 = "pad-after-last-import";
-const rule$3 = createEslintRule({
-	name: RULE_NAME$2,
-	meta: {
-		type: "problem",
-		docs: { description: "Pad after the last import." },
-		fixable: "code",
-		schema: [],
-		messages: { padAfterLastImport: "Expected a blank line after the last import." }
-	},
-	defaultOptions: [],
-	create: (context) => {
-		const sourceCode = context.sourceCode;
-		let lastImportNode = null;
-		return {
-			ImportDeclaration(node) {
-				lastImportNode = node;
-			},
-			"Program:exit"() {
-				if (lastImportNode) {
-					const nextToken = sourceCode.getTokenAfter(lastImportNode);
-					const firstCommentAfterTokenStartLine = sourceCode.getCommentsAfter(lastImportNode)[0]?.loc.start.line;
-					const expectedLine = lastImportNode.loc.end.line + 1;
-					const nextTokenStartLine = nextToken?.loc.start.line;
-					if (nextToken && nextToken.value !== "<\/script>" && (expectedLine === nextTokenStartLine || expectedLine === firstCommentAfterTokenStartLine)) context.report({
-						node: lastImportNode,
-						messageId: "padAfterLastImport",
-						fix: (fixer) => fixer.insertTextAfter(lastImportNode, "\n")
-					});
-				}
-			}
-		};
-	}
-});
-var pad_after_last_import_default = rule$3;
+var no_useless_template_string_default = rule$3;
 
 //#endregion
 //#region src/rules/prefer-ts-expect-error.ts
@@ -558,12 +645,13 @@ var vue_root_element_sort_attributes_default = rule;
 //#region src/index.ts
 var src_default = { rules: {
 	"function-style": function_style_default,
+	"html-spaced-comment": html_spaced_comment_default,
 	"import-dedupe": import_dedupe_default,
+	"import-export-newline": import_export_newline_default,
 	"no-import-promises-as": no_import_promises_as_default,
 	"no-inline-type-import": no_inline_type_import_default,
 	"no-negated-comparison": no_negated_comparison_default,
 	"no-useless-template-string": no_useless_template_string_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.20.2",
+  "version": "3.22.0",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve/)",
   "type": "module",
   "keywords": [
@@ -33,10 +33,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/types": "^8.47.0",
-    "@typescript-eslint/utils": "^8.47.0"
+    "@typescript-eslint/types": "^8.50.1",
+    "@typescript-eslint/utils": "^8.50.1"
   },
   "devDependencies": {
+    "@html-eslint/parser": "^0.52.0",
     "vue-eslint-parser": "^10.2.0"
   }
 }