@soybeanjs/oxc-config 0.0.5 → 0.1.0

package/dist/index.js

@@ -207,12 +207,19 @@ const lint = {
 		"import",
 		"vue"
 	],
-	jsPlugins: ["@soybeanjs/oxc-config/import-type-order"],
+	jsPlugins: ["@soybeanjs/oxc-config/plugins/import"],
 	rules: {
+		"soybeanjs-import/merge-duplicates": "warn",
+		"soybeanjs-import/no-inline-type-import": "warn",
+		"soybeanjs-import/type-after-value": "warn",
+		"import/newline-after-import": "warn",
 		"import/no-unassigned-import": "off",
-		"import-type-order/type-after-value": "warn",
 		"no-underscore-dangle": "off",
-		"no-unused-vars": "off",
+		"typescript/consistent-type-imports": ["error", {
+			disallowTypeAnnotations: false,
+			prefer: "type-imports",
+			fixStyle: "separate-type-imports"
+		}],
 		"unicorn/consistent-function-scoping": "off",
 		"unicorn/no-array-reverse": "off",
 		"unicorn/no-array-sort": "off",

package/dist/plugins/import.d.ts

@@ -0,0 +1,67 @@
+//#region src/plugins/import/shared/types.d.ts
+interface Position {
+  line: number;
+}
+interface SourceLocation {
+  start: Position;
+  end: Position;
+}
+interface BaseNode {
+  type: string;
+  range: [number, number];
+  loc: SourceLocation;
+}
+interface CommentNode {
+  range: [number, number];
+}
+interface ProgramNode extends BaseNode {
+  body: BaseNode[];
+}
+interface SourceCodeLike {
+  text: string;
+  ast: ProgramNode;
+  getText(node?: {
+    range: [number, number];
+  } | null): string;
+  getCommentsBefore(node: BaseNode): CommentNode[];
+}
+interface FixerLike {
+  replaceTextRange(range: [number, number], text: string): unknown;
+  replaceText(node: BaseNode, text: string): unknown;
+}
+interface ReportDescriptor {
+  node: BaseNode;
+  messageId: string;
+  data?: Record<string, string>;
+  fix?: (fixer: FixerLike) => unknown;
+}
+interface RuleContextLike {
+  sourceCode: SourceCodeLike;
+  report(descriptor: ReportDescriptor): void;
+}
+type VisitorLike = Record<string, ((node: any) => void) | undefined>;
+interface RuleMetaLike {
+  type: string;
+  fixable?: 'code';
+  docs?: {
+    description: string;
+    url?: string;
+  };
+  messages?: Record<string, string>;
+  schema?: unknown[];
+}
+interface RuleLike {
+  meta?: RuleMetaLike;
+  create: (context: RuleContextLike) => VisitorLike;
+}
+interface PluginLike {
+  meta: {
+    name: string;
+  };
+  rules: Record<string, RuleLike>;
+}
+//#endregion
+//#region src/plugins/import/index.d.ts
+declare const plugin: PluginLike;
+//#endregion
+export { plugin as default };

package/dist/plugins/import.js

@@ -0,0 +1,288 @@
+//#region src/plugins/import/shared/imports.ts
+function isTypeKind(kind) {
+	return kind === "type" || kind === "typeof";
+}
+function isImportDeclaration(node) {
+	return Boolean(node) && typeof node === "object" && node.type === "ImportDeclaration";
+}
+function isTypeImport(node) {
+	return isTypeKind(node.importKind);
+}
+function isInlineTypeSpecifier(node) {
+	return node.type === "ImportSpecifier" && isTypeKind(node.importKind);
+}
+function getInlineTypeSpecifiers(node) {
+	return (node.specifiers ?? []).filter(isInlineTypeSpecifier);
+}
+function hasInlineTypeSpecifier(node) {
+	return !isTypeImport(node) && getInlineTypeSpecifiers(node).length > 0;
+}
+function stripInlineTypeKeyword(text) {
+	return text.replace(/^type\s+/, "");
+}
+function buildImportStatement(options) {
+	const { importKeyword, specifierTexts, sourceText } = options;
+	return `${importKeyword} ${specifierTexts.join(", ")} from ${sourceText};`;
+}
+function buildNamedImportText(specifiers, sourceCode, options = {}) {
+	return `{ ${specifiers.map((specifier) => {
+		const text = sourceCode.getText(specifier);
+		return options.stripTypeKeyword ? stripInlineTypeKeyword(text) : text;
+	}).join(", ")} }`;
+}
+function buildValueImportStatement(node, sourceCode) {
+	const specifiers = node.specifiers ?? [];
+	const defaultSpecifiers = specifiers.filter((specifier) => {
+		return specifier.type === "ImportDefaultSpecifier";
+	}).map((specifier) => sourceCode.getText(specifier));
+	const namespaceSpecifiers = specifiers.filter((specifier) => {
+		return specifier.type === "ImportNamespaceSpecifier";
+	}).map((specifier) => sourceCode.getText(specifier));
+	const namedSpecifiers = specifiers.filter((specifier) => specifier.type === "ImportSpecifier" && !isInlineTypeSpecifier(specifier));
+	const specifierTexts = [...defaultSpecifiers, ...namespaceSpecifiers];
+	if (namedSpecifiers.length > 0) specifierTexts.push(buildNamedImportText(namedSpecifiers, sourceCode));
+	if (specifierTexts.length === 0) return null;
+	return buildImportStatement({
+		importKeyword: "import",
+		specifierTexts,
+		sourceText: sourceCode.getText(node.source)
+	});
+}
+function buildTypeImportStatement(node, sourceCode) {
+	const inlineTypeSpecifiers = getInlineTypeSpecifiers(node);
+	if (inlineTypeSpecifiers.length === 0) return null;
+	return buildImportStatement({
+		importKeyword: "import type",
+		specifierTexts: [buildNamedImportText(inlineTypeSpecifiers, sourceCode, { stripTypeKeyword: true })],
+		sourceText: sourceCode.getText(node.source)
+	});
+}
+function canFixInlineTypeImport(node) {
+	return !isTypeImport(node) && node.specifiers != null && hasInlineTypeSpecifier(node) && node.withClause == null;
+}
+function createImportStatementParts() {
+	return {
+		defaultImports: [],
+		namespaceImports: [],
+		namedImports: []
+	};
+}
+function pushUnique(values, text) {
+	if (!values.includes(text)) values.push(text);
+}
+function appendSpecifierText(target, specifier, sourceCode) {
+	if (specifier.type === "ImportDefaultSpecifier") {
+		pushUnique(target.defaultImports, sourceCode.getText(specifier));
+		return;
+	}
+	if (specifier.type === "ImportNamespaceSpecifier") {
+		pushUnique(target.namespaceImports, sourceCode.getText(specifier));
+		return;
+	}
+	pushUnique(target.namedImports, stripInlineTypeKeyword(sourceCode.getText(specifier)));
+}
+function canBuildSingleImport(parts) {
+	if (parts.defaultImports.length > 1 || parts.namespaceImports.length > 1) return false;
+	if (parts.namespaceImports.length > 0 && parts.namedImports.length > 0) return false;
+	return true;
+}
+function buildImportFromParts(parts, sourceText, importKeyword) {
+	if (!canBuildSingleImport(parts)) return null;
+	const specifierTexts = [...parts.defaultImports, ...parts.namespaceImports];
+	if (parts.namedImports.length > 0) specifierTexts.push(`{ ${parts.namedImports.join(", ")} }`);
+	if (specifierTexts.length === 0) return null;
+	return buildImportStatement({
+		importKeyword,
+		specifierTexts,
+		sourceText
+	});
+}
+function mergeImportGroup(group, sourceCode) {
+	if (group.length < 2) return null;
+	const valueParts = createImportStatementParts();
+	const typeParts = createImportStatementParts();
+	const sourceText = sourceCode.getText(group[0].node.source);
+	for (const item of group) {
+		if (item.node.withClause != null || (item.node.specifiers?.length ?? 0) === 0) return null;
+		if (sourceCode.getCommentsBefore(item.node).length > 0 && item !== group[0]) return null;
+		for (const specifier of item.node.specifiers ?? []) if (isTypeImport(item.node) || isInlineTypeSpecifier(specifier)) appendSpecifierText(typeParts, specifier, sourceCode);
+		else appendSpecifierText(valueParts, specifier, sourceCode);
+	}
+	const mergedStatements = [buildImportFromParts(valueParts, sourceText, "import"), buildImportFromParts(typeParts, sourceText, "import type")].filter((statement) => Boolean(statement));
+	if (mergedStatements.length === 0 || mergedStatements.length >= group.length) return null;
+	return mergedStatements;
+}
+function collectImportGroups(sourceCode) {
+	const allImports = [];
+	for (let index = 0; index < sourceCode.ast.body.length; index += 1) {
+		const node = sourceCode.ast.body[index];
+		if (isImportDeclaration(node)) allImports.push({
+			node,
+			bodyIndex: index
+		});
+	}
+	if (allImports.length < 2) return [];
+	const groups = [];
+	let currentGroup = [allImports[0]];
+	for (let index = 1; index < allImports.length; index += 1) {
+		const previous = allImports[index - 1];
+		const current = allImports[index];
+		const linesBetween = current.node.loc.start.line - previous.node.loc.end.line;
+		if (previous.node.source.value === current.node.source.value && linesBetween <= 1) currentGroup.push(current);
+		else {
+			groups.push(currentGroup);
+			currentGroup = [current];
+		}
+	}
+	groups.push(currentGroup);
+	return groups;
+}
+
+//#endregion
+//#region src/plugins/import/shared/source.ts
+function getStartWithComments(node, sourceCode) {
+	const comments = sourceCode.getCommentsBefore(node);
+	if (comments.length > 0) return comments[0].range[0];
+	return node.range[0];
+}
+
+//#endregion
+//#region src/plugins/import/rules/merge-duplicates.ts
+const mergeDuplicatesRule = {
+	meta: {
+		type: "layout",
+		fixable: "code",
+		docs: {
+			description: "Merge duplicate imports from the same module into at most one value import and one type import.",
+			url: "https://github.com/soybeanjs/oxc-config/blob/main/src/plugins/import/rules/merge-duplicates.ts"
+		},
+		messages: { mergeDuplicates: "Imports from \"{{source}}\" should be merged into at most one value import and one type import." },
+		schema: []
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return { "Program:exit"() {
+			const groups = collectImportGroups(sourceCode);
+			for (const group of groups) {
+				const mergedStatements = mergeImportGroup(group, sourceCode);
+				if (!mergedStatements) continue;
+				const firstNode = group[0].node;
+				const lastNode = group[group.length - 1].node;
+				context.report({
+					node: firstNode,
+					messageId: "mergeDuplicates",
+					data: { source: firstNode.source.value },
+					fix(fixer) {
+						return fixer.replaceTextRange([getStartWithComments(firstNode, sourceCode), lastNode.range[1]], mergedStatements.join("\n"));
+					}
+				});
+			}
+		} };
+	}
+};
+
+//#endregion
+//#region src/plugins/import/rules/no-inline-type-import.ts
+const noInlineTypeImportRule = {
+	meta: {
+		type: "layout",
+		fixable: "code",
+		docs: {
+			description: "Prefer top-level `import type` over inline `type` specifiers, including mixed value/type imports.",
+			url: "https://github.com/soybeanjs/oxc-config/blob/main/src/plugins/import/rules/no-inline-type-import.ts"
+		},
+		messages: { noInlineTypeImport: "Inline type import from \"{{source}}\" should use top-level `import type` declarations instead." },
+		schema: []
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return { ImportDeclaration(node) {
+			if (!canFixInlineTypeImport(node)) return;
+			context.report({
+				node,
+				messageId: "noInlineTypeImport",
+				data: { source: node.source.value },
+				fix(fixer) {
+					const parts = [buildValueImportStatement(node, sourceCode), buildTypeImportStatement(node, sourceCode)].filter(Boolean);
+					return fixer.replaceText(node, parts.join("\n"));
+				}
+			});
+		} };
+	}
+};
+
+//#endregion
+//#region src/plugins/import/rules/type-after-value.ts
+const typeAfterValueRule = {
+	meta: {
+		type: "layout",
+		fixable: "code",
+		docs: {
+			description: "Ensure value imports come before type imports for the same module source.",
+			url: "https://github.com/soybeanjs/oxc-config/blob/main/src/plugins/import/rules/type-after-value.ts"
+		},
+		messages: { typeBeforeValue: "Type import from \"{{source}}\" must be placed after its value import." },
+		schema: []
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return { "Program:exit"() {
+			const groups = collectImportGroups(sourceCode);
+			for (const group of groups) {
+				if (group.length < 2) continue;
+				if (!group.some((item, index) => {
+					if (!isTypeImport(item.node)) return false;
+					for (let cursor = index + 1; cursor < group.length; cursor += 1) if (!isTypeImport(group[cursor].node)) return true;
+					return false;
+				})) continue;
+				const sorted = [...group].sort((left, right) => {
+					const leftIsType = isTypeImport(left.node);
+					if (leftIsType === isTypeImport(right.node)) return 0;
+					return leftIsType ? 1 : -1;
+				});
+				const firstNode = group[0].node;
+				const lastNode = group[group.length - 1].node;
+				context.report({
+					node: firstNode,
+					messageId: "typeBeforeValue",
+					data: { source: firstNode.source.value },
+					fix(fixer) {
+						const parts = [];
+						for (let index = 0; index < sorted.length; index += 1) {
+							const item = sorted[index];
+							const previousItem = index > 0 ? sorted[index - 1] : null;
+							const start = getStartWithComments(item.node, sourceCode);
+							const text = sourceCode.text.slice(start, item.node.range[1]);
+							if (index > 0 && previousItem) {
+								const previousOriginalIndex = group.findIndex((candidate) => candidate === previousItem);
+								const currentOriginalIndex = group.findIndex((candidate) => candidate === item);
+								if (Math.abs(currentOriginalIndex - previousOriginalIndex) === 1) {
+									const earlier = group[Math.min(previousOriginalIndex, currentOriginalIndex)];
+									const later = group[Math.max(previousOriginalIndex, currentOriginalIndex)];
+									const separator = sourceCode.text.slice(earlier.node.range[1], getStartWithComments(later.node, sourceCode));
+									parts.push(separator);
+								} else parts.push("\n");
+							}
+							parts.push(text);
+						}
+						return fixer.replaceTextRange([getStartWithComments(firstNode, sourceCode), lastNode.range[1]], parts.join(""));
+					}
+				});
+			}
+		} };
+	}
+};
+
+//#endregion
+//#region src/plugins/import/index.ts
+const plugin = {
+	meta: { name: "soybeanjs-import" },
+	rules: {
+		"merge-duplicates": mergeDuplicatesRule,
+		"no-inline-type-import": noInlineTypeImportRule,
+		"type-after-value": typeAfterValueRule
+	}
+};
+
+//#endregion
+export { plugin as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soybeanjs/oxc-config",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "description": "SoybeanJS's oxlint and oxfmt config",
   "keywords": [
     "eslint",
@@ -35,9 +35,10 @@
       "import": "./dist/index.js",
       "require": "./dist/index.js"
     },
-    "./import-type-order": {
-      "import": "./dist/import-type-order.js",
-      "require": "./dist/import-type-order.js"
+    "./plugins/*": {
+      "types": "./dist/plugins/*.d.ts",
+      "import": "./dist/plugins/*.js",
+      "require": "./dist/plugins/*.js"
     }
   },
   "publishConfig": {
@@ -47,7 +48,7 @@
   "devDependencies": {
     "@soybeanjs/cli": "^1.7.2",
     "@soybeanjs/oxc-config": "link:dist",
-    "@types/node": "^25.9.0",
+    "@types/node": "^25.9.1",
     "lint-staged": "^17.0.5",
     "oxfmt": "^0.51.0",
     "oxlint": "^1.66.0",

package/dist/import-type-order.js

@@ -1,112 +0,0 @@
-//#region src/import-type-order.js
-/**
-* oxlint JS plugin: import-type-order
-*
-* 确保同一模块的 `import type` 始终在 `import` (value import) 之后。
-* 与 oxfmt 的 sortImports 配合使用：oxfmt 负责分组排序，此插件负责同模块 value-before-type。
-*
-* 基于 eslint-plugin-simple-import-sort 的核心思路实现。
-*/
-/**
-* 判断 import 是否为 type-only import（`import type { X } from '...'`）
-* 也兼容 `import typeof`（Flow 语法）。
-*/
-function isTypeImport(node) {
-	return node.importKind === "type" || node.importKind === "typeof";
-}
-/**
-* 获取 import 声明前附着的注释的起始位置。
-* 如果没有前导注释，返回节点自身的起始位置。
-*/
-function getStartWithComments(node, sourceCode) {
-	const comments = sourceCode.getCommentsBefore(node);
-	if (comments.length > 0) return comments[0].range[0];
-	return node.range[0];
-}
-const plugin = {
-	meta: { name: "import-type-order" },
-	rules: { "type-after-value": {
-		meta: {
-			type: "layout",
-			fixable: "code",
-			docs: {
-				description: "Ensure value imports come before type imports for the same module source.",
-				url: "https://github.com/soybeanjs/oxfmt-import-order"
-			},
-			messages: { typeBeforeValue: "Type import from \"{{source}}\" must be placed after its value import." },
-			schema: []
-		},
-		create(context) {
-			const sourceCode = context.sourceCode;
-			return { "Program:exit"() {
-				const body = sourceCode.ast.body;
-				const allImports = [];
-				for (let i = 0; i < body.length; i++) if (body[i].type === "ImportDeclaration") allImports.push({
-					node: body[i],
-					bodyIndex: i
-				});
-				if (allImports.length < 2) return;
-				const groups = [];
-				let currentGroup = [allImports[0]];
-				for (let i = 1; i < allImports.length; i++) {
-					const prev = allImports[i - 1];
-					const curr = allImports[i];
-					const linesBetween = curr.node.loc.start.line - prev.node.loc.end.line;
-					if (prev.node.source.value === curr.node.source.value && linesBetween <= 1) currentGroup.push(curr);
-					else {
-						groups.push(currentGroup);
-						currentGroup = [curr];
-					}
-				}
-				groups.push(currentGroup);
-				for (const group of groups) {
-					if (group.length < 2) continue;
-					if (!group.some((item, i) => {
-						if (!isTypeImport(item.node)) return false;
-						for (let j = i + 1; j < group.length; j++) if (!isTypeImport(group[j].node)) return true;
-						return false;
-					})) continue;
-					const sorted = [...group].sort((a, b) => {
-						const aIsType = isTypeImport(a.node);
-						if (aIsType === isTypeImport(b.node)) return 0;
-						return aIsType ? 1 : -1;
-					});
-					const firstNode = group[0].node;
-					const lastNode = group[group.length - 1].node;
-					const source = firstNode.source.value;
-					context.report({
-						node: firstNode,
-						messageId: "typeBeforeValue",
-						data: { source },
-						fix(fixer) {
-							const parts = [];
-							for (let i = 0; i < sorted.length; i++) {
-								const item = sorted[i];
-								const prevItem = i > 0 ? sorted[i - 1] : null;
-								const start = getStartWithComments(item.node, sourceCode);
-								const text = sourceCode.text.slice(start, item.node.range[1]);
-								if (i > 0) {
-									const prevOriginalIndex = group.findIndex((g) => g === prevItem);
-									const currOriginalIndex = group.findIndex((g) => g === item);
-									if (Math.abs(currOriginalIndex - prevOriginalIndex) === 1) {
-										const earlier = group[Math.min(prevOriginalIndex, currOriginalIndex)];
-										const later = group[Math.max(prevOriginalIndex, currOriginalIndex)];
-										const sep = sourceCode.text.slice(earlier.node.range[1], getStartWithComments(later.node, sourceCode));
-										parts.push(sep);
-									} else parts.push("\n");
-								}
-								parts.push(text);
-							}
-							const rangeStart = getStartWithComments(firstNode, sourceCode);
-							const rangeEnd = lastNode.range[1];
-							return fixer.replaceTextRange([rangeStart, rangeEnd], parts.join(""));
-						}
-					});
-				}
-			} };
-		}
-	} }
-};
-
-//#endregion
-export { plugin as default };