@so1ve/eslint-plugin 3.20.1 → 3.21.0

package/dist/index.d.ts

@@ -1,27 +1,62 @@
-import * as _typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import { ESLintUtils } from "@typescript-eslint/utils";
 
 //#region src/rules/function-style.d.ts
-type MessageIds = "arrow" | "declaration";
+type MessageIds$9 = "arrow" | "declaration";
+declare const rule: ESLintUtils.RuleModule<MessageIds$9>;
+//#endregion
+//#region src/rules/import-dedupe.d.ts
+type MessageIds$8 = "importDedupe";
+declare const rule$1: ESLintUtils.RuleModule<MessageIds$8>;
+//#endregion
+//#region src/rules/no-import-promises-as.d.ts
+type MessageIds$7 = "noImportPromisesAs";
+declare const rule$2: ESLintUtils.RuleModule<MessageIds$7>;
+//#endregion
+//#region src/rules/no-inline-type-import.d.ts
+type MessageIds$6 = "noInlineTypeImport";
+declare const rule$3: ESLintUtils.RuleModule<MessageIds$6>;
+//#endregion
+//#region src/rules/no-negated-comparison.d.ts
+type MessageIds$5 = "noNegatedComparison";
+declare const rule$4: ESLintUtils.RuleModule<MessageIds$5>;
+//#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>;
+//#endregion
+//#region src/rules/prefer-ts-expect-error.d.ts
+type MessageIds$2 = "preferExpectErrorComment";
+declare const rule$7: ESLintUtils.RuleModule<MessageIds$2>;
+//#endregion
+//#region src/rules/require-async-with-await.d.ts
+type MessageIds$1 = "requireAsyncWithAwait";
+declare const rule$8: ESLintUtils.RuleModule<MessageIds$1>;
 //#endregion
 //#region src/rules/vue-root-element-sort-attributes.d.ts
+type MessageIds = "wrongOrder";
 type Options = [{
   script?: string[];
   [otherElement: string]: string[] | undefined;
 }];
+declare const rule$9: ESLintUtils.RuleModule<MessageIds, Options>;
 //#endregion
 //#region src/index.d.ts
 declare const _default: {
   rules: {
-    "function-style": _typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds, [], unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
-    "import-dedupe": _typescript_eslint_utils_ts_eslint0.RuleModule<"importDedupe", [], 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>;
-    "no-inline-type-import": _typescript_eslint_utils_ts_eslint0.RuleModule<"noInlineTypeImport", [], unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
-    "no-negated-comparison": _typescript_eslint_utils_ts_eslint0.RuleModule<"noNegatedComparison", [], unknown, _typescript_eslint_utils_ts_eslint0.RuleListener>;
-    "no-useless-template-string": _typescript_eslint_utils_ts_eslint0.RuleModule<"noUselessTemplateString", [], 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>;
+    "function-style": typeof rule;
+    "import-dedupe": typeof rule$1;
+    "no-import-promises-as": typeof rule$2;
+    "no-inline-type-import": typeof rule$3;
+    "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;
   };
 };
 //#endregion

package/dist/index.js

@@ -17,7 +17,7 @@ function getPreviousNode(node) {
 //#endregion
 //#region src/rules/function-style.ts
 const RULE_NAME$8 = "function-style";
-var function_style_default = createEslintRule({
+const rule$9 = createEslintRule({
 	name: RULE_NAME$8,
 	meta: {
 		type: "problem",
@@ -153,11 +153,12 @@ var function_style_default = createEslintRule({
 		};
 	}
 });
+var function_style_default = rule$9;
 
 //#endregion
 //#region src/rules/import-dedupe.ts
 const RULE_NAME$7 = "import-dedupe";
-var import_dedupe_default = createEslintRule({
+const rule$8 = createEslintRule({
 	name: RULE_NAME$7,
 	meta: {
 		type: "problem",
@@ -191,6 +192,7 @@ var import_dedupe_default = createEslintRule({
 		}
 	} })
 });
+var import_dedupe_default = rule$8;
 
 //#endregion
 //#region src/rules/no-import-promises-as.ts
@@ -201,7 +203,7 @@ const POSSIBLE_IMPORT_SOURCES = [
 	"readline",
 	"stream"
 ].flatMap((s) => [s, `node:${s}`]);
-var no_import_promises_as_default = createEslintRule({
+const rule$7 = createEslintRule({
 	name: RULE_NAME$6,
 	meta: {
 		type: "problem",
@@ -232,11 +234,38 @@ var no_import_promises_as_default = createEslintRule({
 		} };
 	}
 });
+var no_import_promises_as_default = rule$7;
 
 //#endregion
 //#region src/rules/no-inline-type-import.ts
 const RULE_NAME$5 = "no-inline-type-import";
-var no_inline_type_import_default = createEslintRule({
+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$6 = createEslintRule({
 	name: RULE_NAME$5,
 	meta: {
 		type: "layout",
@@ -251,28 +280,24 @@ var no_inline_type_import_default = 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({
-			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({
+		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) => 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;
 
 //#endregion
 //#region src/rules/no-negated-comparison.ts
@@ -288,7 +313,7 @@ const negatedToPositive = {
 	">=": "<"
 };
 const negatives = Object.keys(negatedToPositive);
-var no_negated_comparison_default = createEslintRule({
+const rule$5 = createEslintRule({
 	name: RULE_NAME$4,
 	meta: {
 		type: "problem",
@@ -313,11 +338,12 @@ var no_negated_comparison_default = createEslintRule({
 		});
 	} })
 });
+var no_negated_comparison_default = rule$5;
 
 //#endregion
 //#region src/rules/no-useless-template-string.ts
 const RULE_NAME$3 = "no-useless-template-string";
-var no_useless_template_string_default = createEslintRule({
+const rule$4 = createEslintRule({
 	name: RULE_NAME$3,
 	meta: {
 		type: "problem",
@@ -339,11 +365,12 @@ var no_useless_template_string_default = 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";
-var pad_after_last_import_default = createEslintRule({
+const rule$3 = createEslintRule({
 	name: RULE_NAME$2,
 	meta: {
 		type: "problem",
@@ -376,10 +403,11 @@ var pad_after_last_import_default = createEslintRule({
 		};
 	}
 });
+var pad_after_last_import_default = rule$3;
 
 //#endregion
 //#region src/rules/prefer-ts-expect-error.ts
-var prefer_ts_expect_error_default = createEslintRule({
+const rule$2 = createEslintRule({
 	name: "prefer-ts-expect-error",
 	meta: {
 		type: "problem",
@@ -417,11 +445,12 @@ var prefer_ts_expect_error_default = createEslintRule({
 		} };
 	}
 });
+var prefer_ts_expect_error_default = rule$2;
 
 //#endregion
 //#region src/rules/require-async-with-await.ts
 const RULE_NAME$1 = "require-async-with-await";
-var require_async_with_await_default = createEslintRule({
+const rule$1 = createEslintRule({
 	name: RULE_NAME$1,
 	meta: {
 		type: "problem",
@@ -463,12 +492,13 @@ var require_async_with_await_default = createEslintRule({
 		};
 	}
 });
+var require_async_with_await_default = rule$1;
 
 //#endregion
 //#region src/rules/vue-root-element-sort-attributes.ts
 const RULE_NAME = "vue-root-element-sort-attributes";
 const defaultOptions = { script: ["setup", "lang"] };
-var vue_root_element_sort_attributes_default = createEslintRule({
+const rule = createEslintRule({
 	name: RULE_NAME,
 	meta: {
 		type: "layout",
@@ -525,6 +555,7 @@ var vue_root_element_sort_attributes_default = createEslintRule({
 		} };
 	}
 });
+var vue_root_element_sort_attributes_default = rule;
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@so1ve/eslint-plugin",
-  "version": "3.20.1",
+  "version": "3.21.0",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve/)",
   "type": "module",
   "keywords": [
@@ -38,10 +38,5 @@
   },
   "devDependencies": {
     "vue-eslint-parser": "^10.2.0"
-  },
-  "scripts": {
-    "build": "tsdown",
-    "test": "vitest",
-    "watch": "tsdown --watch"
   }
 }