eslint-plugin-import-lite 0.1.1 → 0.3.0

package/README.md

@@ -1,13 +1,21 @@
 # eslint-plugin-import-lite
 
+> [!WARNING]
+>
+> WIP
+>
+> This plugin is still newly born and willing to accept useful import-related rules.
+>
+> Feel free to open an issue to share your ideas!
+
 [![npm version][npm-version-src]][npm-version-href]
 [![npm bundle size][npm-bundle-size-src]][npm-bundle-size-href]
 [![License][license-src]][license-href]
 
 ## Feature
 
-- Port some useful rules from [`eslint-plugin-import-x`](https://github.com/un-ts/eslint-plugin-import-x).
-- No need resolver and settings in [`eslint-plugin-import-x`](https://github.com/un-ts/eslint-plugin-import-x).
+- Port some useful rules that don’t require a resolver from [`eslint-plugin-import-x`](https://github.com/un-ts/eslint-plugin-import-x).
+- No need for a resolver and settings like those in [`eslint-plugin-import-x`](https://github.com/un-ts/eslint-plugin-import-x).
 - Drop babel and flow support.
 
 See all rules in [`src/rules`](./src/rules)
@@ -24,7 +32,8 @@ But there are some useful rules and [some people (include me) want to bring the
 
 ## Credits
 
-[eslint-plugin-import-x](https://github.com/un-ts/eslint-plugin-import-x) - [MIT](https://github.com/un-ts/eslint-plugin-import-x/blob/master/LICENSE)
+- [eslint-plugin-import-x](https://github.com/un-ts/eslint-plugin-import-x) - source codes [MIT](https://github.com/un-ts/eslint-plugin-import-x/blob/master/LICENSE)
+- [eslint-stylistic](https://github.com/eslint-stylistic/eslint-stylistic) - project structure and scripts [MIT](https://github.com/eslint-stylistic/eslint-stylistic/blob/main/LICENSE)
 
 ## License
 
@@ -32,9 +41,9 @@ But there are some useful rules and [some people (include me) want to bring the
 
 <!-- Badges -->
 
-[npm-version-src]: https://img.shields.io/npm/v/eslint-plugin-import-lite
+[npm-version-src]: https://img.shields.io/npm/v/eslint-plugin-import-lite?color=00a3e0
 [npm-version-href]: https://npmjs.com/package/eslint-plugin-import-lite
-[npm-bundle-size-src]: https://img.shields.io/npm/unpacked-size/eslint-plugin-import-lite
+[npm-bundle-size-src]: https://img.shields.io/npm/unpacked-size/eslint-plugin-import-lite?color=00a3e0
 [npm-bundle-size-href]: https://npmjs.com/package/eslint-plugin-import-lite
-[license-src]: https://img.shields.io/npm/l/eslint-plugin-import-lite
+[license-src]: https://img.shields.io/npm/l/eslint-plugin-import-lite?color=00a3e0
 [license-href]: https://opensource.org/licenses/MIT

package/dist/index.d.ts

@@ -1,6 +1,10 @@
-import { ESLintRuleModule } from "./index2.js";
-import { Linter } from "eslint";
+import { Linter, Rule } from "eslint";
 
+//#region src/utils/index.d.ts
+interface ESLintRuleModule<T extends readonly unknown[], TMessageIds extends string> extends Rule.RuleModule {
+  defaultOptions: T;
+}
+//#endregion
 //#region src/index.d.ts
 declare const _default: {
   rules: Record<string, ESLintRuleModule<unknown[], string>>;

package/dist/index.js

@@ -1,27 +1,37 @@
+import { __esm } from "./rolldown-runtime.js";
+import "./vender.js";
 import "./utils.js";
-import "./ast.js";
-import { consistent_type_specifier_style_default } from "./rules/consistent-type-specifier-style2.js";
-import { first_default } from "./rules/first2.js";
-import { newline_after_import_default } from "./rules/newline-after-import2.js";
-import { no_default_export_default } from "./rules/no-default-export2.js";
-import { no_duplicates_default } from "./rules/no-duplicates2.js";
-import { no_mutable_exports_default } from "./rules/no-mutable-exports2.js";
-import { no_named_default_default } from "./rules/no-named-default2.js";
+import { consistent_type_specifier_style_default, init_consistent_type_specifier_style } from "./rules/consistent-type-specifier-style.js";
+import { first_default, init_first } from "./rules/first.js";
+import { init_newline_after_import, newline_after_import_default } from "./rules/newline-after-import.js";
+import { init_no_default_export, no_default_export_default } from "./rules/no-default-export.js";
+import { init_no_duplicates, no_duplicates_default } from "./rules/no-duplicates.js";
+import { init_no_mutable_exports, no_mutable_exports_default } from "./rules/no-mutable-exports.js";
+import { init_no_named_default, no_named_default_default } from "./rules/no-named-default.js";
 
 //#region src/rules/index.ts
-const rules = {
-	"consistent-type-specifier-style": consistent_type_specifier_style_default,
-	"first": first_default,
-	"newline-after-import": newline_after_import_default,
-	"no-default-export": no_default_export_default,
-	"no-duplicates": no_duplicates_default,
-	"no-mutable-exports": no_mutable_exports_default,
-	"no-named-default": no_named_default_default
-};
+var rules;
+var init_rules = __esm({ "src/rules/index.ts"() {
+	init_consistent_type_specifier_style();
+	init_first();
+	init_newline_after_import();
+	init_no_default_export();
+	init_no_duplicates();
+	init_no_mutable_exports();
+	init_no_named_default();
+	rules = {
+		"consistent-type-specifier-style": consistent_type_specifier_style_default,
+		"first": first_default,
+		"newline-after-import": newline_after_import_default,
+		"no-default-export": no_default_export_default,
+		"no-duplicates": no_duplicates_default,
+		"no-mutable-exports": no_mutable_exports_default,
+		"no-named-default": no_named_default_default
+	};
+} });
 
 //#endregion
 //#region src/index.ts
-const pluginName = "import-lite";
 function generateConfig(name, filter) {
 	let ruleMeta = Object.entries(rules).filter(([_, rule]) => !rule.meta?.deprecated);
 	if (filter) ruleMeta = ruleMeta.filter(([ruleName, rule]) => filter(ruleName, rule));
@@ -31,16 +41,22 @@ function generateConfig(name, filter) {
 			name: pluginName,
 			rules
 		} },
-		rules: Object.fromEntries(ruleMeta.map((ruleName) => [`${pluginName}/${ruleName}`, "error"]))
+		rules: Object.fromEntries(ruleMeta.map(([ruleName]) => [`${pluginName}/${ruleName}`, "error"]))
 	};
 }
-var src_default = {
-	rules,
-	configs: {
-		recommended: generateConfig("recommended", ([_, rule]) => rule.meta?.recommended),
-		all: generateConfig("all")
-	}
-};
+var pluginName, src_default;
+var init_src = __esm({ "src/index.ts"() {
+	init_rules();
+	pluginName = "import-lite";
+	src_default = {
+		rules,
+		configs: {
+			recommended: generateConfig("recommended", (_, rule) => !!rule.meta?.docs?.recommended),
+			all: generateConfig("all")
+		}
+	};
+} });
 
 //#endregion
+init_src();
 export { src_default as default };

package/dist/rolldown-runtime.js

@@ -0,0 +1,40 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __commonJS, __esm, __export, __reExport, __require, __toESM };

package/dist/rules/consistent-type-specifier-style.js

@@ -1,5 +1,106 @@
-import "../utils.js";
-import "../ast.js";
-import { consistent_type_specifier_style_default } from "./consistent-type-specifier-style2.js";
+import { __esm } from "../rolldown-runtime.js";
+import { ast_exports, createRule, getValue, init_ast, init_utils } from "../utils.js";
 
-export { consistent_type_specifier_style_default as default };
+//#region src/rules/consistent-type-specifier-style/consistent-type-specifier-style.ts
+function getImportText(node, sourceCode, specifiers) {
+	const sourceString = sourceCode.getText(node.source);
+	if (specifiers.length === 0) return "";
+	const names = specifiers.map((s) => {
+		const importedName = getValue(s.imported);
+		if (importedName === s.local.name) return importedName;
+		return `${importedName} as ${s.local.name}`;
+	});
+	return `import type {${names.join(", ")}} from ${sourceString};`;
+}
+var consistent_type_specifier_style_default;
+var init_consistent_type_specifier_style = __esm({ "src/rules/consistent-type-specifier-style/consistent-type-specifier-style.ts"() {
+	init_utils();
+	init_ast();
+	consistent_type_specifier_style_default = createRule({
+		name: "consistent-type-specifier-style",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Enforce or ban the use of inline type-only markers for named imports." },
+			fixable: "code",
+			schema: [{
+				type: "string",
+				enum: [
+					"top-level",
+					"inline",
+					"prefer-top-level"
+				],
+				default: "top-level"
+			}],
+			messages: {
+				inline: "Prefer using inline {{kind}} specifiers instead of a top-level {{kind}}-only import.",
+				topLevel: "Prefer using a top-level {{kind}}-only import instead of inline {{kind}} specifiers."
+			}
+		},
+		defaultOptions: ["top-level"],
+		create(context, [options]) {
+			const { sourceCode } = context;
+			if (options === "inline") return { ImportDeclaration(node) {
+				if (node.importKind === "value" || node.importKind == null) return;
+				if (node.specifiers.length === 0 || node.specifiers.length === 1 && (node.specifiers[0].type === "ImportDefaultSpecifier" || node.specifiers[0].type === "ImportNamespaceSpecifier")) return;
+				context.report({
+					node,
+					messageId: "inline",
+					data: { kind: node.importKind },
+					fix(fixer) {
+						const kindToken = sourceCode.getFirstToken(node, { skip: 1 });
+						return [kindToken ? fixer.remove(kindToken) : [], node.specifiers.map((specifier) => fixer.insertTextBefore(specifier, `${node.importKind} `))].flat();
+					}
+				});
+			} };
+			return { ImportDeclaration(node) {
+				if (node.importKind === "type" || node.specifiers.length === 0 || node.specifiers.length === 1 && (node.specifiers[0].type === "ImportDefaultSpecifier" || node.specifiers[0].type === "ImportNamespaceSpecifier")) return;
+				const typeSpecifiers = [];
+				const valueSpecifiers = [];
+				let defaultSpecifier = null;
+				for (const specifier of node.specifiers) {
+					if (specifier.type === "ImportDefaultSpecifier") {
+						defaultSpecifier = specifier;
+						continue;
+					}
+					if (!("importKind" in specifier)) continue;
+					if (specifier.importKind === "type") typeSpecifiers.push(specifier);
+					else if (specifier.importKind === "value" || specifier.importKind == null) valueSpecifiers.push(specifier);
+				}
+				const typeImport = getImportText(node, sourceCode, typeSpecifiers);
+				if (typeSpecifiers.length === node.specifiers.length) context.report({
+					node,
+					messageId: "topLevel",
+					data: { kind: "type" },
+					fix(fixer) {
+						return fixer.replaceText(node, typeImport);
+					}
+				});
+				else if (options === "top-level") for (const specifier of typeSpecifiers) context.report({
+					node: specifier,
+					messageId: "topLevel",
+					data: { kind: specifier.importKind },
+					fix(fixer) {
+						const fixes = [];
+						if (valueSpecifiers.length > 0) {
+							for (const specifier$1 of typeSpecifiers) {
+								const token = sourceCode.getTokenAfter(specifier$1);
+								if (token && (0, ast_exports.isCommaToken)(token)) fixes.push(fixer.remove(token));
+								fixes.push(fixer.remove(specifier$1));
+							}
+							const maybeComma = sourceCode.getTokenAfter(valueSpecifiers[valueSpecifiers.length - 1]);
+							if ((0, ast_exports.isCommaToken)(maybeComma)) fixes.push(fixer.remove(maybeComma));
+						} else if (defaultSpecifier) {
+							const comma = sourceCode.getTokenAfter(defaultSpecifier, ast_exports.isCommaToken);
+							const closingBrace = sourceCode.getTokenAfter(node.specifiers[node.specifiers.length - 1], (token) => token.type === "Punctuator" && token.value === "}");
+							fixes.push(fixer.removeRange([comma.range[0], closingBrace.range[1]]));
+						}
+						return [...fixes, fixer.insertTextAfter(node, `\n${typeImport}`)];
+					}
+				});
+			} };
+		}
+	});
+} });
+
+//#endregion
+export { consistent_type_specifier_style_default, init_consistent_type_specifier_style };

package/dist/rules/first.js

@@ -1,4 +1,107 @@
-import "../utils.js";
-import { first_default } from "./first2.js";
+import { __esm } from "../rolldown-runtime.js";
+import { createRule, init_utils } from "../utils.js";
 
-export { first_default as default };
+//#region src/rules/first/first.ts
+function getImportValue(node) {
+	return node.type === "ImportDeclaration" ? node.source.value : "moduleReference" in node && "expression" in node.moduleReference && "value" in node.moduleReference.expression && node.moduleReference.expression.value;
+}
+function isPossibleDirective(node) {
+	return node.type === "ExpressionStatement" && node.expression.type === "Literal" && typeof node.expression.value === "string";
+}
+var first_default;
+var init_first = __esm({ "src/rules/first/first.ts"() {
+	init_utils();
+	first_default = createRule({
+		name: "first",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Ensure all imports appear before other statements." },
+			fixable: "code",
+			schema: [{
+				type: "string",
+				enum: ["absolute-first", "disable-absolute-first"]
+			}],
+			messages: {
+				absolute: "Absolute imports should come before relative imports.",
+				order: "Import in body of module; reorder to top."
+			}
+		},
+		defaultOptions: [],
+		create(context, options) {
+			return { Program(n) {
+				const body = n.body;
+				if (!body?.length) return;
+				const absoluteFirst = options[0] === "absolute-first";
+				const { sourceCode } = context;
+				const originSourceCode = sourceCode.getText();
+				let nonImportCount = 0;
+				let anyExpressions = false;
+				let anyRelative = false;
+				let lastLegalImp = null;
+				const errorInfos = [];
+				let shouldSort = true;
+				let lastSortNodesIndex = 0;
+				for (const [index, node] of body.entries()) {
+					if (!anyExpressions && isPossibleDirective(node)) continue;
+					anyExpressions = true;
+					if (node.type === "ImportDeclaration" || node.type === "TSImportEqualsDeclaration") {
+						if (absoluteFirst) {
+							const importValue = getImportValue(node);
+							if (typeof importValue === "string" && /^\./.test(importValue)) anyRelative = true;
+							else if (anyRelative) context.report({
+								node: node.type === "ImportDeclaration" ? node.source : node.moduleReference,
+								messageId: "absolute"
+							});
+						}
+						if (nonImportCount > 0) {
+							/** @see https://eslint.org/docs/next/use/migrate-to-9.0.0#-removed-multiple-context-methods */
+							for (const variable of sourceCode.getDeclaredVariables(node)) {
+								if (!shouldSort) break;
+								for (const reference of variable.references) if (reference.identifier.range[0] < node.range[1]) {
+									shouldSort = false;
+									break;
+								}
+							}
+							if (shouldSort) lastSortNodesIndex = errorInfos.length;
+							errorInfos.push({
+								node,
+								range: [body[index - 1].range[1], node.range[1]]
+							});
+						} else lastLegalImp = node;
+					} else nonImportCount++;
+				}
+				if (errorInfos.length === 0) return;
+				for (const [index, { node }] of errorInfos.entries()) {
+					let fix;
+					if (index < lastSortNodesIndex) fix = (fixer) => fixer.insertTextAfter(node, "");
+					else if (index === lastSortNodesIndex) {
+						const sortNodes = errorInfos.slice(0, lastSortNodesIndex + 1);
+						fix = (fixer) => {
+							const removeFixers = sortNodes.map(({ range: range$1 }) => fixer.removeRange(range$1));
+							const range = [0, removeFixers[removeFixers.length - 1].range[1]];
+							let insertSourceCode = sortNodes.map(({ range: range$1 }) => {
+								const nodeSourceCode = originSourceCode.slice(...range$1);
+								if (/\S/.test(nodeSourceCode[0])) return `\n${nodeSourceCode}`;
+								return nodeSourceCode;
+							}).join("");
+							let replaceSourceCode = "";
+							if (!lastLegalImp) insertSourceCode = insertSourceCode.trim() + insertSourceCode.match(/^(\s+)/)[0];
+							const insertFixer = lastLegalImp ? fixer.insertTextAfter(lastLegalImp, insertSourceCode) : fixer.insertTextBefore(body[0], insertSourceCode);
+							const fixers = [insertFixer, ...removeFixers];
+							for (const [i, computedFixer] of fixers.entries()) replaceSourceCode += originSourceCode.slice(fixers[i - 1] ? fixers[i - 1].range[1] : 0, computedFixer.range[0]) + computedFixer.text;
+							return fixer.replaceTextRange(range, replaceSourceCode);
+						};
+					}
+					context.report({
+						node,
+						messageId: "order",
+						fix
+					});
+				}
+			} };
+		}
+	});
+} });
+
+//#endregion
+export { first_default, init_first };

package/dist/rules/newline-after-import.js

@@ -1,4 +1,174 @@
-import "../utils.js";
-import { newline_after_import_default } from "./newline-after-import2.js";
+import { __esm } from "../rolldown-runtime.js";
+import { createRule, init_utils } from "../utils.js";
 
-export { newline_after_import_default as default };
+//#region src/rules/newline-after-import/newline-after-import.ts
+function isStaticRequire(node) {
+	return node && node.callee && node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0].type === "Literal" && typeof node.arguments[0].value === "string";
+}
+function containsNodeOrEqual(outerNode, innerNode) {
+	return outerNode.range[0] <= innerNode.range[0] && outerNode.range[1] >= innerNode.range[1];
+}
+function getScopeBody(scope) {
+	if (scope.block.type === "SwitchStatement") {
+		console.log("SwitchStatement scopes not supported");
+		return [];
+	}
+	const body = "body" in scope.block ? scope.block.body : null;
+	if (body && "type" in body && body.type === "BlockStatement") return body.body;
+	return Array.isArray(body) ? body : [];
+}
+function findNodeIndexInScopeBody(body, nodeToFind) {
+	return body.findIndex((node) => containsNodeOrEqual(node, nodeToFind));
+}
+function getLineDifference(node, nextNode) {
+	return nextNode.loc.start.line - node.loc.end.line;
+}
+function isClassWithDecorator(node) {
+	return node.type === "ClassDeclaration" && !!node.decorators?.length;
+}
+function isExportDefaultClass(node) {
+	return node.type === "ExportDefaultDeclaration" && node.declaration.type === "ClassDeclaration";
+}
+function isExportNameClass(node) {
+	return node.type === "ExportNamedDeclaration" && node.declaration?.type === "ClassDeclaration";
+}
+var newline_after_import_default;
+var init_newline_after_import = __esm({ "src/rules/newline-after-import/newline-after-import.ts"() {
+	init_utils();
+	newline_after_import_default = createRule({
+		name: "newline-after-import",
+		meta: {
+			type: "layout",
+			docs: { description: "Enforce a newline after import statements." },
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					count: {
+						type: "integer",
+						minimum: 1
+					},
+					exactCount: { type: "boolean" },
+					considerComments: { type: "boolean" }
+				},
+				additionalProperties: false
+			}],
+			messages: { newline: "Expected {{count}} empty line{{lineSuffix}} after {{type}} statement not followed by another {{type}}." }
+		},
+		defaultOptions: [{
+			count: 1,
+			exactCount: false,
+			considerComments: false
+		}],
+		create(context, [options]) {
+			let level = 0;
+			const requireCalls = [];
+			function checkForNewLine(node, nextNode, type) {
+				if (isExportDefaultClass(nextNode) || isExportNameClass(nextNode)) {
+					const classNode = nextNode.declaration;
+					if (isClassWithDecorator(classNode)) nextNode = classNode.decorators[0];
+				} else if (isClassWithDecorator(nextNode)) nextNode = nextNode.decorators[0];
+				const lineDifference = getLineDifference(node, nextNode);
+				const EXPECTED_LINE_DIFFERENCE = options.count + 1;
+				if (lineDifference < EXPECTED_LINE_DIFFERENCE || options.exactCount && lineDifference !== EXPECTED_LINE_DIFFERENCE) {
+					let column = node.loc.start.column;
+					if (node.loc.start.line !== node.loc.end.line) column = 0;
+					context.report({
+						loc: {
+							line: node.loc.end.line,
+							column
+						},
+						messageId: "newline",
+						data: {
+							count: options.count,
+							lineSuffix: options.count > 1 ? "s" : "",
+							type
+						},
+						fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? void 0 : (fixer) => fixer.insertTextAfter(node, "\n".repeat(EXPECTED_LINE_DIFFERENCE - lineDifference))
+					});
+				}
+			}
+			function commentAfterImport(node, nextComment, type) {
+				const lineDifference = getLineDifference(node, nextComment);
+				const EXPECTED_LINE_DIFFERENCE = options.count + 1;
+				if (lineDifference < EXPECTED_LINE_DIFFERENCE) {
+					let column = node.loc.start.column;
+					if (node.loc.start.line !== node.loc.end.line) column = 0;
+					context.report({
+						loc: {
+							line: node.loc.end.line,
+							column
+						},
+						messageId: "newline",
+						data: {
+							count: options.count,
+							lineSuffix: options.count > 1 ? "s" : "",
+							type
+						},
+						fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? void 0 : (fixer) => fixer.insertTextAfter(node, "\n".repeat(EXPECTED_LINE_DIFFERENCE - lineDifference))
+					});
+				}
+			}
+			function incrementLevel() {
+				level++;
+			}
+			function decrementLevel() {
+				level--;
+			}
+			function checkImport(node) {
+				const { parent } = node;
+				if (!parent || !("body" in parent) || !parent.body) return;
+				const root = parent;
+				const nodePosition = root.body.indexOf(node);
+				const nextNode = root.body[nodePosition + 1];
+				const endLine = node.loc.end.line;
+				let nextComment;
+				if (root.comments !== void 0 && options.considerComments) nextComment = root.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);
+				if (node.type === "TSImportEqualsDeclaration" && node.isExport) return;
+				if (nextComment) commentAfterImport(node, nextComment, "import");
+				else if (nextNode && nextNode.type !== "ImportDeclaration" && (nextNode.type !== "TSImportEqualsDeclaration" || nextNode.isExport)) checkForNewLine(node, nextNode, "import");
+			}
+			return {
+				"ImportDeclaration": checkImport,
+				"TSImportEqualsDeclaration": checkImport,
+				CallExpression(node) {
+					if (isStaticRequire(node) && level === 0) requireCalls.push(node);
+				},
+				"Program:exit": function(node) {
+					const scopeBody = getScopeBody(context.sourceCode.getScope(node));
+					for (const [index, node$1] of requireCalls.entries()) {
+						const nodePosition = findNodeIndexInScopeBody(scopeBody, node$1);
+						const statementWithRequireCall = scopeBody[nodePosition];
+						const nextStatement = scopeBody[nodePosition + 1];
+						const nextRequireCall = requireCalls[index + 1];
+						if (nextRequireCall && containsNodeOrEqual(statementWithRequireCall, nextRequireCall)) continue;
+						if (nextStatement && (!nextRequireCall || !containsNodeOrEqual(nextStatement, nextRequireCall))) {
+							let nextComment;
+							if ("comments" in statementWithRequireCall.parent && statementWithRequireCall.parent.comments !== void 0 && options.considerComments) {
+								const endLine = node$1.loc.end.line;
+								nextComment = statementWithRequireCall.parent.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);
+							}
+							if (nextComment && nextComment !== void 0) commentAfterImport(statementWithRequireCall, nextComment, "require");
+							else checkForNewLine(statementWithRequireCall, nextStatement, "require");
+						}
+					}
+				},
+				"FunctionDeclaration": incrementLevel,
+				"FunctionExpression": incrementLevel,
+				"ArrowFunctionExpression": incrementLevel,
+				"BlockStatement": incrementLevel,
+				"ObjectExpression": incrementLevel,
+				"Decorator": incrementLevel,
+				"FunctionDeclaration:exit": decrementLevel,
+				"FunctionExpression:exit": decrementLevel,
+				"ArrowFunctionExpression:exit": decrementLevel,
+				"BlockStatement:exit": decrementLevel,
+				"ObjectExpression:exit": decrementLevel,
+				"Decorator:exit": decrementLevel
+			};
+		}
+	});
+} });
+
+//#endregion
+export { init_newline_after_import, newline_after_import_default };

package/dist/rules/no-default-export.js

@@ -1,5 +1,55 @@
-import "../utils.js";
-import "../ast.js";
-import { no_default_export_default } from "./no-default-export2.js";
+import { __esm } from "../rolldown-runtime.js";
+import { createRule, getValue, init_ast, init_utils, sourceType } from "../utils.js";
 
-export { no_default_export_default as default };
+//#region src/rules/no-default-export/no-default-export.ts
+var no_default_export_default;
+var init_no_default_export = __esm({ "src/rules/no-default-export/no-default-export.ts"() {
+	init_utils();
+	init_ast();
+	no_default_export_default = createRule({
+		name: "no-default-export",
+		meta: {
+			type: "suggestion",
+			docs: { description: "Forbid default exports." },
+			schema: [],
+			messages: {
+				preferNamed: "Prefer named exports.",
+				noAliasDefault: "Do not alias `{{local}}` as `default`. Just export `{{local}}` itself instead."
+			}
+		},
+		defaultOptions: [],
+		create(context) {
+			if (sourceType(context) !== "module") return {};
+			const { sourceCode } = context;
+			return {
+				ExportDefaultDeclaration(node) {
+					const { loc } = sourceCode.getFirstTokens(node)[1] || {};
+					context.report({
+						node,
+						messageId: "preferNamed",
+						loc
+					});
+				},
+				ExportNamedDeclaration(node) {
+					for (const specifier of node.specifiers.filter((specifier$1) => getValue(specifier$1.exported) === "default")) {
+						const { loc } = sourceCode.getFirstTokens(node)[1] || {};
+						if (specifier.type === "ExportDefaultSpecifier") context.report({
+							node,
+							messageId: "preferNamed",
+							loc
+						});
+						else if (specifier.type === "ExportSpecifier") context.report({
+							node,
+							messageId: "noAliasDefault",
+							data: { local: getValue(specifier.local) },
+							loc
+						});
+					}
+				}
+			};
+		}
+	});
+} });
+
+//#endregion
+export { init_no_default_export, no_default_export_default };