@borela-tech/eslint-config 2.2.0 → 2.2.1

package/dist/index.mjs

@@ -0,0 +1,872 @@
+import eslint from "@eslint/js";
+import react from "eslint-plugin-react";
+import reactHooks from "eslint-plugin-react-hooks";
+import stylistic from "@stylistic/eslint-plugin";
+import typescript from "typescript-eslint";
+//#region src/rules/importsAndReExportsAtTop/getStatementType.ts
+function getStatementType(statement) {
+	if (statement.type === "ImportDeclaration") return "import";
+	if (statement.type === "ExportAllDeclaration") return "re-export";
+	if (statement.type === "ExportNamedDeclaration") {
+		if (statement.source !== null) return "re-export";
+	}
+	return "other";
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/isImportDeclaration.ts
+function isImportDeclaration(statement) {
+	return statement.type === "ImportDeclaration";
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/isReExport.ts
+function isReExport(statement) {
+	if (statement.type === "ExportAllDeclaration") return true;
+	if (statement.type === "ExportNamedDeclaration") return statement.source !== null;
+	return false;
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/categorizeStatements.ts
+function categorizeStatements(statements) {
+	const result = {
+		imports: [],
+		reExports: [],
+		other: []
+	};
+	for (const statement of statements) {
+		const type = getStatementType(statement);
+		if (type === "import" && isImportDeclaration(statement)) result.imports.push(statement);
+		else if (type === "re-export" && isReExport(statement)) result.reExports.push(statement);
+		else result.other.push(statement);
+	}
+	return result;
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/findStatementIndices.ts
+function findStatementIndices(statements) {
+	let firstRegularStatement = -1;
+	let lastImport = -1;
+	let lastReExport = -1;
+	for (let i = 0; i < statements.length; i++) {
+		const type = getStatementType(statements[i]);
+		if (type === "import") lastImport = i;
+		else if (type === "re-export") lastReExport = i;
+		else if (type === "other" && firstRegularStatement === -1) firstRegularStatement = i;
+	}
+	return {
+		firstRegularStatement,
+		lastImport,
+		lastReExport
+	};
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/generateSortedText.ts
+function generateSortedText(context, categories) {
+	return [
+		...categories.imports,
+		...categories.reExports,
+		...categories.other
+	].map((node) => context.sourceCode.getText(node)).join("\n");
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/hasViolation.ts
+function hasViolation(indices, categories) {
+	const { firstRegularStatement, lastImport, lastReExport } = indices;
+	if (categories.imports.length === 0 && categories.reExports.length === 0) return false;
+	const hasImportAfterRegularStatement = categories.imports.length > 0 && firstRegularStatement !== -1 && lastImport > firstRegularStatement;
+	const hasReExportAfterRegularStatement = categories.reExports.length > 0 && firstRegularStatement !== -1 && lastReExport > firstRegularStatement;
+	return hasImportAfterRegularStatement || hasReExportAfterRegularStatement;
+}
+//#endregion
+//#region src/rules/importsAndReExportsAtTop/index.ts
+const importsAndReExportsAtTop = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce imports and re-exports at the top of the file" },
+		fixable: "code",
+		messages: { importsAndReExportsAtTop: "Imports and re-exports should be at the top of the file." },
+		schema: []
+	},
+	create(context) {
+		return { Program(node) {
+			const statements = node.body;
+			const categories = categorizeStatements(statements);
+			if (!hasViolation(findStatementIndices(statements), categories)) return;
+			context.report({
+				node,
+				messageId: "importsAndReExportsAtTop",
+				fix(fixer) {
+					const sortedText = generateSortedText(context, categories);
+					return fixer.replaceText(node, sortedText);
+				}
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/individualImports.ts
+const individualImports = {
+	meta: {
+		docs: { description: "Enforce individual imports instead of grouped imports" },
+		fixable: "code",
+		messages: { individualImports: "Use individual imports instead of grouped imports." },
+		schema: [],
+		type: "suggestion"
+	},
+	create(context) {
+		return { ImportDeclaration(node) {
+			if (node.specifiers.length <= 1) return;
+			context.report({
+				node,
+				messageId: "individualImports",
+				fix(fixer) {
+					const source = node.source.raw;
+					const specifiers = node.specifiers.filter((s) => s.type === "ImportSpecifier").map((s) => `import {${s.local.name}} from ${source}`).join("\n");
+					return fixer.replaceText(node, specifiers);
+				}
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/individualReExports.ts
+const individualReExports = {
+	meta: {
+		docs: { description: "Enforce individual exports instead of grouped exports" },
+		fixable: "code",
+		messages: { individualReExports: "Use individual exports instead of grouped exports." },
+		schema: [],
+		type: "suggestion"
+	},
+	create(context) {
+		return { ExportNamedDeclaration(node) {
+			if (!node.source || node.specifiers.length <= 1) return;
+			context.report({
+				node,
+				messageId: "individualReExports",
+				fix(fixer) {
+					const source = node.source.value;
+					const typeKeyword = node.exportKind === "type" ? "type " : "";
+					const specifiers = node.specifiers.map((s) => {
+						const localName = s.local.type === "Identifier" ? s.local.name : s.local.value;
+						const exportedName = s.exported.type === "Identifier" ? s.exported.name : s.exported.value;
+						return `export ${typeKeyword}{${localName === exportedName ? localName : `${localName} as ${exportedName}`}} from '${source}'`;
+					}).join("\n");
+					return fixer.replaceText(node, specifiers);
+				}
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/multilineUnionTypes/createFix.ts
+function createFix$4(fixer, node, sourceCode) {
+	const result = `\n${node.types.map((t) => sourceCode.getText(t)).map((t) => `  | ${t}`).join("\n")}`;
+	return fixer.replaceText(node, result);
+}
+//#endregion
+//#region src/rules/multilineUnionTypes/isMultiline.ts
+function isMultiline$2(unionType) {
+	const { start, end } = unionType.loc ?? {};
+	return start?.line !== end?.line;
+}
+//#endregion
+//#region src/rules/multilineUnionTypes/index.ts
+const multilineUnionTypes = {
+	meta: {
+		docs: { description: "Enforce union types with multiple members to be on multiple lines" },
+		fixable: "code",
+		messages: {
+			singleLine: "Union types with multiple members should be on multiple lines",
+			missingPipes: "Multiline union types should have leading pipes on each member"
+		},
+		schema: [],
+		type: "layout"
+	},
+	create(context) {
+		return { TSUnionType(node) {
+			if (node.types.length < 2) return;
+			const sourceCode = context.sourceCode;
+			if (sourceCode.getText(node).trim().startsWith("|")) return;
+			if (!isMultiline$2(node)) {
+				context.report({
+					node,
+					messageId: "singleLine",
+					fix: (fixer) => createFix$4(fixer, node, sourceCode)
+				});
+				return;
+			}
+			context.report({
+				node,
+				messageId: "missingPipes",
+				fix: (fixer) => createFix$4(fixer, node, sourceCode)
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/singleLineImports/formatAttributes.ts
+function formatAttributes(attributes) {
+	if (attributes.length === 0) return "";
+	return ` with {${attributes.map((attr) => {
+		return `${attr.key.type === "Identifier" ? attr.key.name : attr.key.value}: '${attr.value.value}'`;
+	}).join(", ")}}`;
+}
+//#endregion
+//#region src/rules/singleLineImports/formatNamed.ts
+function formatNamed(specifiers, sourceCode) {
+	return specifiers.map((s) => sourceCode.getText(s)).join(", ");
+}
+//#endregion
+//#region src/rules/singleLineImports/formatSpecifiers.ts
+function formatSpecifiers(declaration, sourceCode) {
+	const defaultSpecifier = declaration.specifiers.find((s) => s.type === "ImportDefaultSpecifier");
+	const namespaceSpecifier = declaration.specifiers.find((s) => s.type === "ImportNamespaceSpecifier");
+	const namedSpecifiers = declaration.specifiers.filter((s) => s.type === "ImportSpecifier");
+	if (namespaceSpecifier) return `* as ${namespaceSpecifier.local.name}`;
+	if (defaultSpecifier && namedSpecifiers.length > 0) return `${defaultSpecifier.local.name}, {${formatNamed(namedSpecifiers, sourceCode)}}`;
+	if (defaultSpecifier) return defaultSpecifier.local.name;
+	if (namedSpecifiers.length === 0) return "";
+	return `{${formatNamed(namedSpecifiers, sourceCode)}}`;
+}
+//#endregion
+//#region src/rules/singleLineImports/createFix.ts
+function createFix$3(fixer, declaration, sourceCode) {
+	const source = declaration.source.value;
+	const prefix = declaration.importKind === "type" ? "import type " : "import ";
+	const specifiers = formatSpecifiers(declaration, sourceCode);
+	const attributes = formatAttributes(declaration.attributes);
+	if (specifiers === "") {
+		const result = `${prefix}'${source}'${attributes}`;
+		return fixer.replaceText(declaration, result);
+	}
+	const result = `${prefix}${specifiers} from '${source}'${attributes}`;
+	return fixer.replaceText(declaration, result);
+}
+//#endregion
+//#region src/rules/singleLineImports/isMultiline.ts
+function isMultiline$1(declaration) {
+	const { start, end } = declaration.loc ?? {};
+	return start?.line !== end?.line;
+}
+//#endregion
+//#region src/rules/singleLineImports/index.ts
+const singleLineImports = {
+	meta: {
+		docs: { description: "Enforce imports to be on a single line" },
+		fixable: "code",
+		messages: { multiline: "Import should be on a single line" },
+		schema: [],
+		type: "layout"
+	},
+	create(context) {
+		return { ImportDeclaration(node) {
+			if (!isMultiline$1(node)) return;
+			context.report({
+				node,
+				messageId: "multiline",
+				fix: (fixer) => createFix$3(fixer, node, context.sourceCode)
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/singleLineReExports/createFix.ts
+function createFix$2(fixer, declaration, sourceCode) {
+	const source = declaration.source.value;
+	if (declaration.type === "ExportAllDeclaration") {
+		const result = `export ${declaration.exported ? `* as ${sourceCode.getText(declaration.exported)}` : "*"} from '${source}'${formatAttributes(declaration.attributes)}`;
+		return fixer.replaceText(declaration, result);
+	}
+	const result = `${declaration.exportKind === "type" ? "export type " : "export "}{${declaration.specifiers.map((s) => sourceCode.getText(s)).join(", ")}} from '${source}'${formatAttributes(declaration.attributes)}`;
+	return fixer.replaceText(declaration, result);
+}
+//#endregion
+//#region src/rules/singleLineReExports/isMultiline.ts
+function isMultiline(declaration) {
+	const { start, end } = declaration.loc ?? {};
+	return start?.line !== end?.line;
+}
+//#endregion
+//#region src/rules/singleLineReExports/index.ts
+const singleLineReExports = {
+	meta: {
+		docs: { description: "Enforce re-exports to be on a single line" },
+		fixable: "code",
+		messages: { multiline: "Re-export should be on a single line" },
+		schema: [],
+		type: "layout"
+	},
+	create(context) {
+		const checkDeclaration = (node, declaration) => {
+			if (!declaration.source) return;
+			if (!isMultiline(declaration)) return;
+			context.report({
+				node,
+				messageId: "multiline",
+				fix: (fixer) => createFix$2(fixer, declaration, context.sourceCode)
+			});
+		};
+		return {
+			ExportNamedDeclaration: (node) => checkDeclaration(node, node),
+			ExportAllDeclaration: (node) => checkDeclaration(node, node)
+		};
+	}
+};
+//#endregion
+//#region src/rules/sortedImports/categorizeImport.ts
+function categorizeImport(declaration) {
+	if (declaration.importKind === "type") return "type";
+	if (declaration.specifiers.length === 0) return "side-effect";
+	if (declaration.specifiers.some((s) => s.type === "ImportNamespaceSpecifier")) return "namespace";
+	if (declaration.specifiers.some((s) => s.type === "ImportDefaultSpecifier")) return "default";
+	return "named";
+}
+//#endregion
+//#region src/rules/sortedImports/getSortKey.ts
+function getSortKey$1(declaration) {
+	const group = categorizeImport(declaration);
+	if (group === "side-effect") return declaration.source.value;
+	if (group === "namespace") return `*${declaration.specifiers.find((s) => s.type === "ImportNamespaceSpecifier")?.local.name ?? ""}`;
+	if (group === "default") return declaration.specifiers.find((s) => s.type === "ImportDefaultSpecifier")?.local.name ?? "";
+	return declaration.specifiers[0].local.name;
+}
+//#endregion
+//#region src/rules/sortedImports/categorizeImports.ts
+function categorizeImports(declarations) {
+	return declarations.map((declaration) => ({
+		declaration,
+		group: categorizeImport(declaration),
+		sortKey: getSortKey$1(declaration)
+	}));
+}
+//#endregion
+//#region src/lib/compare.ts
+function compare(a, b) {
+	return a.localeCompare(b, "en", { sensitivity: "case" });
+}
+//#endregion
+//#region src/rules/sortedImports/ImportGroupOrder.ts
+const importGroupOrder = [
+	"side-effect",
+	"namespace",
+	"default",
+	"named",
+	"type"
+];
+//#endregion
+//#region src/rules/sortedImports/checkAlphabeticalSorting.ts
+function checkAlphabeticalSorting$1(categorized) {
+	const errors = [];
+	for (const group of importGroupOrder) {
+		const groupImports = categorized.filter((c) => c.group === group);
+		const sorted = [...groupImports].sort((a, b) => compare(a.sortKey, b.sortKey));
+		for (let i = 0; i < groupImports.length; i++) if (groupImports[i] !== sorted[i]) errors.push({
+			node: groupImports[i].declaration,
+			messageId: "sortedImports"
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedImports/checkGroupOrdering.ts
+function checkGroupOrdering$1(categorized) {
+	const errors = [];
+	let currentGroupIndex = -1;
+	for (const { declaration, group } of categorized) {
+		const groupIndex = importGroupOrder.indexOf(group);
+		if (groupIndex < currentGroupIndex) errors.push({
+			node: declaration,
+			messageId: "wrongGroup"
+		});
+		else currentGroupIndex = groupIndex;
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedImports/getSpecifierName.ts
+function getSpecifierName$1(specifier) {
+	return specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+}
+//#endregion
+//#region src/rules/sortedImports/areSpecifiersSorted.ts
+function areSpecifiersSorted$1(specifiers) {
+	const names = specifiers.map((s) => getSpecifierName$1(s));
+	const sorted = [...names].sort((a, b) => compare(a, b));
+	return names.every((name, i) => name === sorted[i]);
+}
+//#endregion
+//#region src/rules/sortedImports/getNamedSpecifiers.ts
+function getNamedSpecifiers$1(declaration) {
+	return declaration.specifiers.filter((s) => s.type === "ImportSpecifier");
+}
+//#endregion
+//#region src/rules/sortedImports/checkSpecifiersSorting.ts
+function checkSpecifiersSorting$1(categorized) {
+	const errors = [];
+	const namedImports = categorized.filter((c) => c.group === "named");
+	for (const { declaration } of namedImports) {
+		const specifiers = getNamedSpecifiers$1(declaration);
+		if (specifiers.length > 1 && !areSpecifiersSorted$1(specifiers)) errors.push({
+			node: declaration,
+			messageId: "sortedNames"
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedImports/sortSpecifiersText.ts
+function sortSpecifiersText$1(specifiers, sourceCode) {
+	return [...specifiers].sort((a, b) => {
+		return compare(getSpecifierName$1(a), getSpecifierName$1(b));
+	}).map((s) => sourceCode.getText(s)).join(", ");
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/formatNamedImport.ts
+function formatNamedImport(declaration, sourceCode) {
+	const specifiers = getNamedSpecifiers$1(declaration);
+	if (specifiers.length > 1 && !areSpecifiersSorted$1(specifiers)) {
+		const sortedSpecifiers = sortSpecifiersText$1(specifiers, sourceCode);
+		const source = declaration.source.value;
+		return `${declaration.importKind === "type" ? "import type " : "import "}{${sortedSpecifiers}} from '${source}'`;
+	}
+	return sourceCode.getText(declaration);
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/buildSortedCode.ts
+function buildSortedCode$1(grouped, sourceCode) {
+	const sortedCode = [];
+	for (const group of importGroupOrder) for (const { declaration } of grouped[group]) if (group === "named" || group === "type") sortedCode.push(formatNamedImport(declaration, sourceCode));
+	else sortedCode.push(sourceCode.getText(declaration));
+	return sortedCode;
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/groupImportsByType.ts
+function groupImportsByType(categorized) {
+	const grouped = {
+		"side-effect": [],
+		namespace: [],
+		default: [],
+		named: [],
+		type: []
+	};
+	for (const item of categorized) grouped[item.group].push(item);
+	return grouped;
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/sortImportGroups.ts
+function sortImportGroups(grouped) {
+	grouped["side-effect"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["namespace"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["default"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["named"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["type"].sort((a, b) => compare(a.sortKey, b.sortKey));
+}
+//#endregion
+//#region src/rules/sortedImports/createFix/index.ts
+function createFixForGroup$1(fixer, importDeclarations, sourceCode) {
+	if (importDeclarations.length === 0) return null;
+	const grouped = groupImportsByType(categorizeImports(importDeclarations));
+	sortImportGroups(grouped);
+	const sortedCode = buildSortedCode$1(grouped, sourceCode).join("\n");
+	const firstImport = importDeclarations[0];
+	const lastImport = importDeclarations[importDeclarations.length - 1];
+	return fixer.replaceTextRange([firstImport.range[0], lastImport.range[1]], sortedCode);
+}
+function createFix$1(fixer, importGroups, sourceCode) {
+	const fixes = [];
+	for (const group of importGroups) {
+		const fix = createFixForGroup$1(fixer, group, sourceCode);
+		if (fix) fixes.push(fix);
+	}
+	return fixes;
+}
+//#endregion
+//#region src/rules/sortedImports/getImportGroups.ts
+function getImportGroups(programBody) {
+	const groups = [];
+	let currentGroup = [];
+	for (const statement of programBody) {
+		if (statement.type === "ImportDeclaration") {
+			currentGroup.push(statement);
+			continue;
+		}
+		if (currentGroup.length > 0) {
+			groups.push(currentGroup);
+			currentGroup = [];
+		}
+	}
+	if (currentGroup.length > 0) groups.push(currentGroup);
+	return groups;
+}
+//#endregion
+//#region src/rules/sortedImports/index.ts
+const sortedImports = {
+	meta: {
+		docs: { description: "Enforce sorted imports alphabetically" },
+		fixable: "code",
+		messages: {
+			sortedImports: "Imports should be sorted alphabetically",
+			sortedNames: "Named imports should be sorted alphabetically",
+			wrongGroup: "Import is in wrong group"
+		},
+		schema: [],
+		type: "suggestion"
+	},
+	create(context) {
+		return { Program(node) {
+			const body = node.body;
+			const importGroups = getImportGroups(body);
+			if (importGroups.length === 0) return;
+			const allErrors = [];
+			for (const group of importGroups) {
+				const categorized = categorizeImports(group);
+				const errors = [
+					...checkGroupOrdering$1(categorized),
+					...checkAlphabeticalSorting$1(categorized),
+					...checkSpecifiersSorting$1(categorized)
+				];
+				allErrors.push(...errors);
+			}
+			for (const error of allErrors) context.report({
+				node: error.node,
+				messageId: error.messageId,
+				fix(fixer) {
+					const sourceCode = context.sourceCode;
+					return createFix$1(fixer, importGroups, sourceCode);
+				}
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/sortedReExports/categorizeReExport.ts
+function categorizeReExport(declaration) {
+	if (declaration.type === "ExportAllDeclaration") {
+		if (declaration.exported) return "re-export-namespace";
+		return "re-export-all";
+	}
+	if (declaration.exportKind === "type") return "re-export-type";
+	return "re-export-named";
+}
+//#endregion
+//#region src/rules/sortedReExports/getSortKey.ts
+function getSortKey(declaration) {
+	const group = categorizeReExport(declaration);
+	if (declaration.type === "ExportAllDeclaration") {
+		if (group === "re-export-namespace") {
+			if (declaration.exported?.type === "Identifier") return `*${declaration.exported.name}`;
+		}
+		return declaration.source.value;
+	}
+	const specifier = declaration.specifiers[0];
+	if (!specifier) return "";
+	return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
+}
+//#endregion
+//#region src/rules/sortedReExports/categorizeReExports.ts
+function categorizeReExports(declarations) {
+	return declarations.map((declaration) => {
+		return {
+			declaration,
+			group: categorizeReExport(declaration),
+			sortKey: getSortKey(declaration)
+		};
+	});
+}
+//#endregion
+//#region src/rules/sortedReExports/ReExportGroupOrder.ts
+const reExportGroupOrder = [
+	"re-export-all",
+	"re-export-namespace",
+	"re-export-named",
+	"re-export-type"
+];
+//#endregion
+//#region src/rules/sortedReExports/checkAlphabeticalSorting.ts
+function checkAlphabeticalSorting(categorized) {
+	const errors = [];
+	for (const group of reExportGroupOrder) {
+		const groupReExports = categorized.filter((c) => c.group === group);
+		const sorted = [...groupReExports].sort((a, b) => compare(a.sortKey, b.sortKey));
+		for (let i = 0; i < groupReExports.length; i++) if (groupReExports[i] !== sorted[i]) errors.push({
+			node: groupReExports[i].declaration,
+			messageId: "sortedReExports"
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedReExports/checkGroupOrdering.ts
+function checkGroupOrdering(categorized) {
+	const errors = [];
+	let currentGroupIndex = -1;
+	for (const { declaration, group } of categorized) {
+		const groupIndex = reExportGroupOrder.indexOf(group);
+		if (groupIndex < currentGroupIndex) errors.push({
+			node: declaration,
+			messageId: "wrongGroup"
+		});
+		else currentGroupIndex = groupIndex;
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedReExports/getSpecifierName.ts
+function getSpecifierName(specifier) {
+	return specifier.local.type === "Identifier" ? specifier.local.name : String(specifier.local.value);
+}
+//#endregion
+//#region src/rules/sortedReExports/areSpecifiersSorted.ts
+function areSpecifiersSorted(specifiers) {
+	const names = specifiers.map((s) => getSpecifierName(s));
+	const sorted = [...names].sort((a, b) => compare(a, b));
+	return names.every((name, i) => name === sorted[i]);
+}
+//#endregion
+//#region src/rules/sortedReExports/getNamedSpecifiers.ts
+function getNamedSpecifiers(declaration) {
+	return declaration.specifiers.filter((s) => s.type === "ExportSpecifier" && s.local.type === "Identifier");
+}
+//#endregion
+//#region src/rules/sortedReExports/isNamedReExport.ts
+function isNamedReExport(x) {
+	return x.group !== "re-export-all" && x.group !== "re-export-namespace";
+}
+//#endregion
+//#region src/rules/sortedReExports/checkSpecifiersSorting.ts
+function checkSpecifiersSorting(categorized) {
+	const errors = [];
+	const namedReExports = categorized.filter(isNamedReExport);
+	for (const { declaration } of namedReExports) {
+		const specifiers = getNamedSpecifiers(declaration);
+		const isSorted = areSpecifiersSorted(specifiers);
+		if (specifiers.length > 1 && !isSorted) errors.push({
+			node: declaration,
+			messageId: "sortedNames"
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region src/rules/sortedReExports/sortSpecifiersText.ts
+function sortSpecifiersText(specifiers, sourceCode) {
+	return [...specifiers].sort((a, b) => {
+		return compare(getSpecifierName(a), getSpecifierName(b));
+	}).map((s) => sourceCode.getText(s)).join(", ");
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/formatNamedReExport.ts
+function formatNamedReExport(declaration, sourceCode) {
+	const specifiers = getNamedSpecifiers(declaration);
+	if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+		const sortedSpecifiers = sortSpecifiersText(specifiers, sourceCode);
+		const source = declaration.source.value;
+		return `${declaration.exportKind === "type" ? "export type " : "export "}{${sortedSpecifiers}} from '${source}'`;
+	}
+	return sourceCode.getText(declaration);
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/buildSortedCode.ts
+function buildSortedCode(grouped, sourceCode) {
+	const sortedCode = [];
+	for (const group of reExportGroupOrder) for (const item of grouped[group]) if (isNamedReExport(item)) sortedCode.push(formatNamedReExport(item.declaration, sourceCode));
+	else sortedCode.push(sourceCode.getText(item.declaration));
+	return sortedCode;
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/groupReExportsByType.ts
+function groupReExportsByType(categorized) {
+	const grouped = {
+		"re-export-all": [],
+		"re-export-namespace": [],
+		"re-export-named": [],
+		"re-export-type": []
+	};
+	for (const item of categorized) grouped[item.group].push(item);
+	return grouped;
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/sortExportGroups.ts
+function sortExportGroups(grouped) {
+	grouped["re-export-all"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["re-export-namespace"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["re-export-named"].sort((a, b) => compare(a.sortKey, b.sortKey));
+	grouped["re-export-type"].sort((a, b) => compare(a.sortKey, b.sortKey));
+}
+//#endregion
+//#region src/rules/sortedReExports/createFix/index.ts
+function createFixForGroup(fixer, reExportDeclarations, sourceCode) {
+	if (reExportDeclarations.length === 0) return null;
+	const grouped = groupReExportsByType(categorizeReExports(reExportDeclarations));
+	sortExportGroups(grouped);
+	const sortedCode = buildSortedCode(grouped, sourceCode).join("\n");
+	const firstReExport = reExportDeclarations[0];
+	const lastReExport = reExportDeclarations[reExportDeclarations.length - 1];
+	return fixer.replaceTextRange([firstReExport.range[0], lastReExport.range[1]], sortedCode);
+}
+function createFix(fixer, reExportGroups, sourceCode) {
+	const fixes = [];
+	for (const group of reExportGroups) {
+		const fix = createFixForGroup(fixer, group, sourceCode);
+		if (fix) fixes.push(fix);
+	}
+	return fixes;
+}
+//#endregion
+//#region src/rules/sortedReExports/getReExportGroups.ts
+function isReExportDeclaration(statement) {
+	return statement.type === "ExportNamedDeclaration" && statement.source !== null || statement.type === "ExportAllDeclaration";
+}
+function getReExportGroups(programBody) {
+	const groups = [];
+	let currentGroup = [];
+	for (const statement of programBody) {
+		if (isReExportDeclaration(statement)) {
+			currentGroup.push(statement);
+			continue;
+		}
+		if (currentGroup.length > 0) {
+			groups.push(currentGroup);
+			currentGroup = [];
+		}
+	}
+	if (currentGroup.length > 0) groups.push(currentGroup);
+	return groups;
+}
+//#endregion
+//#region src/rules/sortedReExports/index.ts
+const sortedReExports = {
+	meta: {
+		docs: { description: "Enforce sorted exports alphabetically" },
+		fixable: "code",
+		messages: {
+			sortedReExports: "Exports should be sorted alphabetically",
+			sortedNames: "Named exports should be sorted alphabetically",
+			wrongGroup: "Export is in wrong group"
+		},
+		schema: [],
+		type: "suggestion"
+	},
+	create(context) {
+		return { Program(node) {
+			const body = node.body;
+			const reExportGroups = getReExportGroups(body);
+			if (reExportGroups.length === 0) return;
+			const allErrors = [];
+			for (const group of reExportGroups) {
+				const categorized = categorizeReExports(group);
+				const errors = [
+					...checkGroupOrdering(categorized),
+					...checkAlphabeticalSorting(categorized),
+					...checkSpecifiersSorting(categorized)
+				];
+				allErrors.push(...errors);
+			}
+			for (const error of allErrors) context.report({
+				node: error.node,
+				messageId: error.messageId,
+				fix(fixer) {
+					const sourceCode = context.sourceCode;
+					return createFix(fixer, reExportGroups, sourceCode);
+				}
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/index.ts
+const CONFIG = [
+	{ ignores: [
+		"src/graphql/sdk.ts",
+		"**/node_modules/**",
+		"**/dist/**"
+	] },
+	{ settings: { react: { version: "19" } } },
+	eslint.configs.recommended,
+	react.configs.flat.recommended,
+	stylistic.configs.recommended,
+	...typescript.configs.recommended,
+	...typescript.configs.stylistic,
+	{
+		plugins: { "react-hooks": reactHooks },
+		rules: reactHooks.configs.recommended.rules
+	},
+	{
+		plugins: { "@borela-tech": { rules: {
+			"imports-and-re-exports-at-top": importsAndReExportsAtTop,
+			"individual-imports": individualImports,
+			"individual-re-exports": individualReExports,
+			"multiline-union-types": multilineUnionTypes,
+			"single-line-imports": singleLineImports,
+			"single-line-re-exports": singleLineReExports,
+			"sorted-imports": sortedImports,
+			"sorted-re-exports": sortedReExports
+		} } },
+		rules: {
+			"@borela-tech/imports-and-re-exports-at-top": "error",
+			"@borela-tech/individual-imports": "error",
+			"@borela-tech/individual-re-exports": "error",
+			"@borela-tech/multiline-union-types": "error",
+			"@borela-tech/single-line-imports": "error",
+			"@borela-tech/single-line-re-exports": "error",
+			"@borela-tech/sorted-imports": "error",
+			"@borela-tech/sorted-re-exports": "error"
+		}
+	},
+	{ rules: {
+		"capitalized-comments": [
+			"error",
+			"always",
+			{ ignoreConsecutiveComments: true }
+		],
+		"react/react-in-jsx-scope": "off",
+		"@stylistic/arrow-parens": ["error", "as-needed"],
+		"@stylistic/array-bracket-newline": ["error", "consistent"],
+		"@stylistic/array-bracket-spacing": ["error", "never"],
+		"@stylistic/array-element-newline": ["error", "consistent"],
+		"@stylistic/block-spacing": "off",
+		"@stylistic/brace-style": [
+			"error",
+			"1tbs",
+			{ allowSingleLine: true }
+		],
+		"@stylistic/indent": [
+			"error",
+			2,
+			{ ignoredNodes: ["TSMappedType > *"] }
+		],
+		"@stylistic/jsx-tag-spacing": ["error", {
+			afterOpening: "never",
+			beforeClosing: "never",
+			beforeSelfClosing: "never",
+			closingSlash: "never"
+		}],
+		"@stylistic/jsx-wrap-multilines": "off",
+		"@stylistic/lines-between-class-members": "off",
+		"@stylistic/object-curly-newline": ["error", { consistent: true }],
+		"@stylistic/object-curly-spacing": ["error", "never"],
+		"@stylistic/operator-linebreak": [
+			"error",
+			"before",
+			{ overrides: { "=": "after" } }
+		],
+		"@stylistic/quotes": [
+			"error",
+			"single",
+			{ avoidEscape: true }
+		],
+		"@stylistic/quote-props": ["error", "as-needed"],
+		"@stylistic/semi": [
+			"error",
+			"never",
+			{ beforeStatementContinuationChars: "always" }
+		],
+		"@typescript-eslint/no-empty-function": "off",
+		"@typescript-eslint/consistent-indexed-object-style": "off",
+		"@typescript-eslint/consistent-type-imports": ["error", { fixStyle: "separate-type-imports" }]
+	} }
+];
+//#endregion
+export { CONFIG };
+
+//# sourceMappingURL=index.mjs.map