eslint-plugin-absolute 0.2.0 → 0.2.2

package/src/rules/sort-exports.ts

@@ -30,52 +30,225 @@ type ExportItem = {
 	text: string;
 };
 
-export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Enforce that top-level export declarations are sorted by exported name and, optionally, that variable exports come before function exports"
-		},
-		fixable: "code",
-		schema: [
-			{
-				type: "object",
-				properties: {
-					order: {
-						type: "string",
-						enum: ["asc", "desc"]
-					},
-					caseSensitive: {
-						type: "boolean"
-					},
-					natural: {
-						type: "boolean"
-					},
-					minKeys: {
-						type: "integer",
-						minimum: 2
-					},
-					variablesBeforeFunctions: {
-						type: "boolean"
-					}
-				},
-				additionalProperties: false
-			}
-		],
-		messages: {
-			alphabetical:
-				"Export declarations are not sorted alphabetically. Expected order: {{expectedOrder}}.",
-			variablesBeforeFunctions:
-				"Non-function exports should come before function exports."
+const SORT_BEFORE = Number.parseInt("-1", 10);
+
+const hasStringTypeProperty = (value: object) => {
+	const maybeType = Reflect.get(value, "type");
+	return typeof maybeType === "string";
+};
+
+const isNodeLike = (value: unknown): value is TSESTree.Node =>
+	value !== null &&
+	value !== undefined &&
+	typeof value === "object" &&
+	"type" in value &&
+	hasStringTypeProperty(value);
+
+const shouldSkipNodeEntry = (key: string, value: unknown) =>
+	key === "parent" || value === null || value === undefined;
+
+const visitNodeArray = (
+	values: unknown[],
+	visit: (node: TSESTree.Node | null | undefined) => void
+) => values.filter(isNodeLike).forEach(visit);
+
+const visitNodeEntryValue = (
+	value: unknown,
+	visit: (node: TSESTree.Node | null | undefined) => void
+) => {
+	if (Array.isArray(value)) {
+		visitNodeArray(value, visit);
+		return;
+	}
+
+	if (isNodeLike(value)) {
+		visit(value);
+	}
+};
+
+const visitNodeEntries = (
+	current: TSESTree.Node,
+	visit: (node: TSESTree.Node | null | undefined) => void
+) =>
+	Object.entries(current)
+		.filter(([key, value]) => !shouldSkipNodeEntry(key, value))
+		.forEach(([, value]) => {
+			visitNodeEntryValue(value, visit);
+		});
+
+const getVariableDeclaratorName = (
+	declaration: TSESTree.VariableDeclaration
+) => {
+	if (declaration.declarations.length !== 1) {
+		return null;
+	}
+	const [firstDeclarator] = declaration.declarations;
+	if (firstDeclarator && firstDeclarator.id.type === "Identifier") {
+		return firstDeclarator.id.name;
+	}
+	return null;
+};
+
+const getDeclarationName = (
+	declaration: TSESTree.ExportNamedDeclaration["declaration"]
+) => {
+	if (!declaration) {
+		return null;
+	}
+
+	if (declaration.type === "VariableDeclaration") {
+		return getVariableDeclaratorName(declaration);
+	}
+
+	if (
+		(declaration.type === "FunctionDeclaration" ||
+			declaration.type === "ClassDeclaration") &&
+		declaration.id &&
+		declaration.id.type === "Identifier"
+	) {
+		return declaration.id.name;
+	}
+
+	return null;
+};
+
+const getSpecifierName = (node: TSESTree.ExportNamedDeclaration) => {
+	if (node.specifiers.length !== 1) {
+		return null;
+	}
+	const [spec] = node.specifiers;
+	if (!spec) {
+		return null;
+	}
+	if (spec.exported.type === "Identifier") {
+		return spec.exported.name;
+	}
+	if (
+		spec.exported.type === "Literal" &&
+		typeof spec.exported.value === "string"
+	) {
+		return spec.exported.value;
+	}
+	return null;
+};
+
+const getExportName = (node: TSESTree.ExportNamedDeclaration) =>
+	getDeclarationName(node.declaration) ?? getSpecifierName(node);
+
+const isFixableExport = (exportNode: TSESTree.ExportNamedDeclaration) => {
+	const { declaration } = exportNode;
+
+	if (!declaration) {
+		return exportNode.specifiers.length === 1;
+	}
+
+	if (
+		declaration.type === "VariableDeclaration" &&
+		declaration.declarations.length === 1
+	) {
+		const [firstDecl] = declaration.declarations;
+		return firstDecl !== undefined && firstDecl.id.type === "Identifier";
+	}
+
+	return (
+		(declaration.type === "FunctionDeclaration" ||
+			declaration.type === "ClassDeclaration") &&
+		declaration.id !== null &&
+		declaration.id.type === "Identifier"
+	);
+};
+
+const visitImmediateReferences = (
+	node: TSESTree.Node | null | undefined,
+	onReference: (name: string) => void
+) => {
+	if (!node) {
+		return;
+	}
+
+	const visit = (current: TSESTree.Node | null | undefined) => {
+		if (!current) {
+			return;
 		}
-	},
 
-	defaultOptions: [{}],
+		switch (current.type) {
+			case "Identifier":
+				onReference(current.name);
+				return;
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+				return;
+			case "MemberExpression":
+				visit(current.object);
+				if (current.computed) {
+					visit(current.property);
+				}
+				return;
+			case "Property":
+				if (current.computed) {
+					visit(current.key);
+				}
+				visit(current.value);
+				return;
+			case "PropertyDefinition":
+				if (current.computed) {
+					visit(current.key);
+				}
+				if (current.static) {
+					visit(current.value);
+				}
+				return;
+			case "MethodDefinition":
+				if (current.computed) {
+					visit(current.key);
+				}
+				return;
+			case "StaticBlock":
+				for (const statement of current.body) {
+					visit(statement);
+				}
+				return;
+		}
+
+		visitNodeEntries(current, visit);
+	};
 
+	visit(node);
+};
+
+const getImmediateDependencyNames = (node: TSESTree.ExportNamedDeclaration) => {
+	const names = new Set<string>();
+	const { declaration } = node;
+	const addName = names.add.bind(names);
+	const addDeclaratorDependencies = (
+		declarator: TSESTree.VariableDeclarator
+	) => visitImmediateReferences(declarator.init, addName);
+	const addClassElementDependencies = (
+		element: TSESTree.ClassElement | TSESTree.StaticBlock
+	) => visitImmediateReferences(element, addName);
+
+	if (!declaration) {
+		return names;
+	}
+
+	if (declaration.type === "VariableDeclaration") {
+		declaration.declarations.forEach(addDeclaratorDependencies);
+		return names;
+	}
+
+	if (declaration.type === "ClassDeclaration") {
+		visitImmediateReferences(declaration.superClass, addName);
+		declaration.body.body.forEach(addClassElementDependencies);
+	}
+
+	return names;
+};
+
+export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 	create(context) {
-		const sourceCode = context.sourceCode;
-		const option = context.options[0];
+		const { sourceCode } = context;
+		const [option] = context.options;
 
 		const order: "asc" | "desc" =
 			option && option.order ? option.order : "asc";
@@ -98,217 +271,170 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 				? option.variablesBeforeFunctions
 				: false;
 
-		function generateExportText(node: TSESTree.ExportNamedDeclaration) {
-			return sourceCode
+		const generateExportText = (node: TSESTree.ExportNamedDeclaration) =>
+			sourceCode
 				.getText(node)
 				.trim()
 				.replace(/\s*;?\s*$/, ";");
-		}
 
-		function compareStrings(a: string, b: string) {
-			let strA = a;
-			let strB = b;
+		const compareStrings = (strLeft: string, strRight: string) => {
+			let left = strLeft;
+			let right = strRight;
 
 			if (!caseSensitive) {
-				strA = strA.toLowerCase();
-				strB = strB.toLowerCase();
+				left = left.toLowerCase();
+				right = right.toLowerCase();
 			}
 
 			const cmp = natural
-				? strA.localeCompare(strB, undefined, { numeric: true })
-				: strA.localeCompare(strB);
+				? left.localeCompare(right, undefined, { numeric: true })
+				: left.localeCompare(right);
 
 			return order === "asc" ? cmp : -cmp;
-		}
-
-		function getExportName(
-			node: TSESTree.ExportNamedDeclaration
-		): string | null {
-			const declaration = node.declaration;
-
-			if (declaration) {
-				if (declaration.type === "VariableDeclaration") {
-					if (declaration.declarations.length === 1) {
-						const firstDeclarator = declaration.declarations[0];
-						if (
-							firstDeclarator &&
-							firstDeclarator.id.type === "Identifier"
-						) {
-							return firstDeclarator.id.name;
-						}
-					}
-				} else if (
-					declaration.type === "FunctionDeclaration" ||
-					declaration.type === "ClassDeclaration"
-				) {
-					const id = declaration.id;
-					if (id && id.type === "Identifier") {
-						return id.name;
-					}
-				}
-			} else if (node.specifiers.length === 1) {
-				const spec = node.specifiers[0];
-				if (!spec) {
-					return null;
-				}
-				if (spec.exported.type === "Identifier") {
-					return spec.exported.name;
-				}
-				if (
-					spec.exported.type === "Literal" &&
-					typeof spec.exported.value === "string"
-				) {
-					return spec.exported.value;
-				}
-			}
-
-			return null;
-		}
+		};
 
-		function isFunctionExport(node: TSESTree.ExportNamedDeclaration) {
-			const declaration = node.declaration;
+		const isFunctionExport = (node: TSESTree.ExportNamedDeclaration) => {
+			const { declaration } = node;
 
 			if (!declaration) {
 				return false;
 			}
 
-			if (declaration.type === "VariableDeclaration") {
-				if (declaration.declarations.length === 1) {
-					const firstDeclarator = declaration.declarations[0];
-					if (!firstDeclarator) {
-						return false;
-					}
-					const init = firstDeclarator.init;
-					if (!init) {
-						return false;
-					}
-					return (
-						init.type === "FunctionExpression" ||
-						init.type === "ArrowFunctionExpression"
-					);
-				}
-				return false;
-			}
-
 			if (declaration.type === "FunctionDeclaration") {
 				return true;
 			}
 
-			return false;
-		}
-
-		function sortComparator(a: ExportItem, b: ExportItem) {
-			const kindA = a.node.exportKind ?? "value";
-			const kindB = b.node.exportKind ?? "value";
-
-			if (kindA !== kindB) {
-				return kindA === "type" ? -1 : 1;
+			if (declaration.type !== "VariableDeclaration") {
+				return false;
 			}
 
-			if (variablesBeforeFunctions) {
-				if (a.isFunction !== b.isFunction) {
-					return a.isFunction ? 1 : -1;
-				}
+			if (declaration.declarations.length !== 1) {
+				return false;
 			}
 
-			return compareStrings(a.name, b.name);
-		}
-
-		/**
-		 * Very lightweight dependency check: look at the text of the node and see
-		 * if it references any of the later export names. This avoids reordering
-		 * when there might be a forward dependency.
-		 */
-		function hasForwardDependency(
-			node: TSESTree.Node,
-			laterNames: Set<string>
-		) {
-			const text = sourceCode.getText(node);
-			for (const name of laterNames) {
-				if (text.includes(name)) {
-					return true;
-				}
+			const [firstDeclarator] = declaration.declarations;
+			if (!firstDeclarator) {
+				return false;
 			}
-			return false;
-		}
-
-		function processExportBlock(block: TSESTree.ExportNamedDeclaration[]) {
-			if (block.length < minKeys) {
-				return;
+			const { init } = firstDeclarator;
+			if (!init) {
+				return false;
 			}
+			return (
+				init.type === "FunctionExpression" ||
+				init.type === "ArrowFunctionExpression"
+			);
+		};
 
-			const items: ExportItem[] = [];
+		const sortComparator = (left: ExportItem, right: ExportItem) => {
+			const kindA = left.node.exportKind ?? "value";
+			const kindB = right.node.exportKind ?? "value";
 
-			for (const node of block) {
-				const name = getExportName(node);
-				if (!name) {
-					continue;
-				}
-
-				items.push({
-					name,
-					node,
-					isFunction: isFunctionExport(node),
-					text: sourceCode.getText(node)
-				});
+			if (kindA !== kindB) {
+				return kindA === "type" ? SORT_BEFORE : 1;
 			}
 
-			if (items.length < minKeys) {
-				return;
+			if (
+				variablesBeforeFunctions &&
+				left.isFunction !== right.isFunction
+			) {
+				return left.isFunction ? 1 : SORT_BEFORE;
 			}
 
-			const sortedItems = items.slice().sort(sortComparator);
+			return compareStrings(left.name, right.name);
+		};
 
-			let reportNeeded = false;
+		const buildItems = (block: TSESTree.ExportNamedDeclaration[]) =>
+			block
+				.map((node) => {
+					const name = getExportName(node);
+					if (!name) {
+						return null;
+					}
+					const item: ExportItem = {
+						isFunction: isFunctionExport(node),
+						name,
+						node,
+						text: sourceCode.getText(node)
+					};
+					return item;
+				})
+				.filter((item): item is ExportItem => item !== null);
+
+		const findFirstUnsorted = (items: ExportItem[]) => {
 			let messageId: MessageIds = "alphabetical";
 
-			for (let i = 1; i < items.length; i++) {
-				const prev = items[i - 1];
-				const current = items[i];
-
-				if (!prev || !current) {
-					continue;
+			const unsorted = items.some((current, idx) => {
+				if (idx === 0) {
+					return false;
 				}
+				const prev = items[idx - 1];
+				if (!prev) {
+					return false;
+				}
+				if (sortComparator(prev, current) <= 0) {
+					return false;
+				}
+				if (
+					variablesBeforeFunctions &&
+					prev.isFunction &&
+					!current.isFunction
+				) {
+					messageId = "variablesBeforeFunctions";
+				}
+				return true;
+			});
 
-				if (sortComparator(prev, current) > 0) {
-					reportNeeded = true;
+			return unsorted ? messageId : null;
+		};
 
-					if (
-						variablesBeforeFunctions &&
-						prev.isFunction &&
-						!current.isFunction
-					) {
-						messageId = "variablesBeforeFunctions";
+		const checkForwardDependencies = (items: ExportItem[]) => {
+			const exportNames = items.map((item) => item.name);
+			return items.some((item, idx) => {
+				const laterNames = new Set(exportNames.slice(idx + 1));
+				if (laterNames.size === 0) {
+					return false;
+				}
+
+				const dependencies = getImmediateDependencyNames(item.node);
+				for (const dependency of dependencies) {
+					if (laterNames.has(dependency)) {
+						return true;
 					}
-					break;
 				}
-			}
+				return false;
+			});
+		};
 
-			if (!reportNeeded) {
+		const processExportBlock = (
+			block: TSESTree.ExportNamedDeclaration[]
+		) => {
+			if (block.length < minKeys) {
 				return;
 			}
 
-			const exportNames = items.map((item) => item.name);
+			const items = buildItems(block);
 
-			for (let i = 0; i < items.length; i++) {
-				const item = items[i];
-				if (!item) {
-					continue;
-				}
-				const laterNames = new Set(exportNames.slice(i + 1));
-				const nodeToCheck: TSESTree.Node =
-					item.node.declaration ?? item.node;
+			if (items.length < minKeys) {
+				return;
+			}
 
-				if (hasForwardDependency(nodeToCheck, laterNames)) {
-					return;
-				}
+			const messageId = findFirstUnsorted(items);
+			if (!messageId) {
+				return;
+			}
+
+			if (checkForwardDependencies(items)) {
+				return;
 			}
 
+			const sortedItems = items.slice().sort(sortComparator);
+
 			const expectedOrder = sortedItems
 				.map((item) => item.name)
 				.join(", ");
 
-			const firstNode = block[0];
+			const [firstNode] = block;
 			const lastNode = block[block.length - 1];
 
 			if (!firstNode || !lastNode) {
@@ -316,49 +442,11 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 			}
 
 			context.report({
-				node: firstNode,
-				messageId,
 				data: {
 					expectedOrder
 				},
 				fix(fixer) {
-					const fixableNodes: TSESTree.ExportNamedDeclaration[] = [];
-
-					for (const n of block) {
-						const declaration = n.declaration;
-
-						if (declaration) {
-							if (
-								declaration.type === "VariableDeclaration" &&
-								declaration.declarations.length === 1
-							) {
-								const firstDecl = declaration.declarations[0];
-								if (
-									firstDecl &&
-									firstDecl.id.type === "Identifier"
-								) {
-									fixableNodes.push(n);
-									continue;
-								}
-							}
-
-							if (
-								(declaration.type === "FunctionDeclaration" ||
-									declaration.type === "ClassDeclaration") &&
-								declaration.id &&
-								declaration.id.type === "Identifier"
-							) {
-								fixableNodes.push(n);
-								continue;
-							}
-
-							continue;
-						}
-
-						if (n.specifiers.length === 1) {
-							fixableNodes.push(n);
-						}
-					}
+					const fixableNodes = block.filter(isFixableExport);
 
 					if (fixableNodes.length < minKeys) {
 						return null;
@@ -368,8 +456,8 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 						.map((item) => generateExportText(item.node))
 						.join("\n");
 
-					const rangeStart = firstNode.range[0];
-					const rangeEnd = lastNode.range[1];
+					const [rangeStart] = firstNode.range;
+					const [, rangeEnd] = lastNode.range;
 
 					const fullText = sourceCode.getText();
 					const originalText = fullText.slice(rangeStart, rangeEnd);
@@ -382,39 +470,77 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 						[rangeStart, rangeEnd],
 						sortedText
 					);
-				}
+				},
+				messageId,
+				node: firstNode
 			});
-		}
+		};
 
 		return {
 			"Program:exit"(node: TSESTree.Program) {
-				const body = node.body;
+				const { body } = node;
 				const block: TSESTree.ExportNamedDeclaration[] = [];
 
-				for (let i = 0; i < body.length; i++) {
-					const stmt = body[i];
-					if (!stmt) {
-						continue;
-					}
-
+				body.forEach((stmt) => {
 					if (
 						stmt.type === "ExportNamedDeclaration" &&
 						!stmt.source &&
 						getExportName(stmt) !== null
 					) {
 						block.push(stmt);
-					} else {
-						if (block.length > 0) {
-							processExportBlock(block);
-							block.length = 0;
-						}
+						return;
 					}
-				}
+
+					if (block.length > 0) {
+						processExportBlock(block);
+						block.length = 0;
+					}
+				});
 
 				if (block.length > 0) {
 					processExportBlock(block);
 				}
 			}
 		};
+	},
+	defaultOptions: [{}],
+	meta: {
+		docs: {
+			description:
+				"Enforce that top-level export declarations are sorted by exported name and, optionally, that variable exports come before function exports"
+		},
+		fixable: "code",
+		messages: {
+			alphabetical:
+				"Export declarations are not sorted alphabetically. Expected order: {{expectedOrder}}.",
+			variablesBeforeFunctions:
+				"Non-function exports should come before function exports."
+		},
+		schema: [
+			{
+				additionalProperties: false,
+				properties: {
+					caseSensitive: {
+						type: "boolean"
+					},
+					minKeys: {
+						minimum: 2,
+						type: "integer"
+					},
+					natural: {
+						type: "boolean"
+					},
+					order: {
+						enum: ["asc", "desc"],
+						type: "string"
+					},
+					variablesBeforeFunctions: {
+						type: "boolean"
+					}
+				},
+				type: "object"
+			}
+		],
+		type: "suggestion"
 	}
 };