eslint-plugin-absolute 0.2.1 → 0.2.3

package/dist/index.js

@@ -186,6 +186,75 @@ var explicitObjectTypes = {
 
 // src/rules/sort-keys-fixable.ts
 var SORT_BEFORE = -1;
+var hasDuplicateNames = (names) => {
+  const seen = new Set;
+  const nonNullNames = names.flatMap((name) => name === null ? [] : [name]);
+  for (const name of nonNullNames) {
+    if (seen.has(name)) {
+      return true;
+    }
+    seen.add(name);
+  }
+  return false;
+};
+var isSafeStaticTemplate = (node) => node.expressions.length === 0;
+var isSafeArrayElement = (node) => {
+  if (!node || node.type === "SpreadElement") {
+    return false;
+  }
+  return isSafeToReorderExpression(node);
+};
+var isSafeObjectProperty = (property) => {
+  if (property.type !== "Property" || property.computed || property.kind !== "init") {
+    return false;
+  }
+  if (property.key.type !== "Identifier" && property.key.type !== "Literal") {
+    return false;
+  }
+  if (property.method) {
+    return true;
+  }
+  return isSafeToReorderExpression(property.value);
+};
+var isSafeToReorderExpression = (node) => {
+  if (!node || node.type === "PrivateIdentifier") {
+    return false;
+  }
+  switch (node.type) {
+    case "Identifier":
+    case "Literal":
+    case "ThisExpression":
+    case "FunctionExpression":
+    case "ArrowFunctionExpression":
+    case "ClassExpression":
+      return true;
+    case "TemplateLiteral":
+      return isSafeStaticTemplate(node);
+    case "UnaryExpression":
+      return isSafeToReorderExpression(node.argument);
+    case "ArrayExpression":
+      return node.elements.every(isSafeArrayElement);
+    case "ObjectExpression":
+      return node.properties.every(isSafeObjectProperty);
+    default:
+      return false;
+  }
+};
+var isSafeJSXAttributeValue = (value) => {
+  if (value === null) {
+    return true;
+  }
+  if (value.type === "Literal") {
+    return true;
+  }
+  if (value.type !== "JSXExpressionContainer") {
+    return false;
+  }
+  if (value.expression.type === "JSXEmptyExpression") {
+    return false;
+  }
+  return isSafeToReorderExpression(value.expression);
+};
 var sortKeysFixable = {
   create(context) {
     const { sourceCode } = context;
@@ -352,6 +421,12 @@ ${indent}`;
           node: prop
         };
       });
+      if (hasDuplicateNames(keys.map((key) => key.keyName))) {
+        autoFixable = false;
+      }
+      if (autoFixable && keys.some((key) => key.node.type === "Property" && !isSafeToReorderExpression(key.node.value))) {
+        autoFixable = false;
+      }
       let fixProvided = false;
       const createReportWithFix = (curr, shouldFix) => {
         context.report({
@@ -441,6 +516,20 @@ ${indent}`;
       if (!isOutOfOrder(names)) {
         return;
       }
+      if (hasDuplicateNames(names)) {
+        context.report({
+          messageId: "unsorted",
+          node: attrs[0].type === "JSXAttribute" ? attrs[0].name : attrs[0]
+        });
+        return;
+      }
+      if (attrs.some((attr) => attr.type === "JSXAttribute" && !isSafeJSXAttributeValue(attr.value))) {
+        context.report({
+          messageId: "unsorted",
+          node: attrs[0].type === "JSXAttribute" ? attrs[0].name : attrs[0]
+        });
+        return;
+      }
       const braceConflict = attrs.find((currAttr, idx) => {
         if (idx === 0) {
           return false;
@@ -797,7 +886,26 @@ var noUnnecessaryKey = {
 };
 
 // src/rules/sort-exports.ts
-var SORT_BEFORE2 = -1;
+var SORT_BEFORE2 = Number.parseInt("-1", 10);
+var hasStringTypeProperty = (value) => {
+  const maybeType = Reflect.get(value, "type");
+  return typeof maybeType === "string";
+};
+var isNodeLike = (value) => value !== null && value !== undefined && typeof value === "object" && ("type" in value) && hasStringTypeProperty(value);
+var shouldSkipNodeEntry = (key, value) => key === "parent" || value === null || value === undefined;
+var visitNodeArray = (values, visit) => values.filter(isNodeLike).forEach(visit);
+var visitNodeEntryValue = (value, visit) => {
+  if (Array.isArray(value)) {
+    visitNodeArray(value, visit);
+    return;
+  }
+  if (isNodeLike(value)) {
+    visit(value);
+  }
+};
+var visitNodeEntries = (current, visit) => Object.entries(current).filter(([key, value]) => !shouldSkipNodeEntry(key, value)).forEach(([, value]) => {
+  visitNodeEntryValue(value, visit);
+});
 var getVariableDeclaratorName = (declaration) => {
   if (declaration.declarations.length !== 1) {
     return null;
@@ -848,6 +956,76 @@ var isFixableExport = (exportNode) => {
   }
   return (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id !== null && declaration.id.type === "Identifier";
 };
+var visitImmediateReferences = (node, onReference) => {
+  if (!node) {
+    return;
+  }
+  const visit = (current) => {
+    if (!current) {
+      return;
+    }
+    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);
+};
+var getImmediateDependencyNames = (node) => {
+  const names = new Set;
+  const { declaration } = node;
+  const addName = names.add.bind(names);
+  const addDeclaratorDependencies = (declarator) => visitImmediateReferences(declarator.init, addName);
+  const addClassElementDependencies = (element) => 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;
+};
 var sortExports = {
   create(context) {
     const { sourceCode } = context;
@@ -903,15 +1081,6 @@ var sortExports = {
       }
       return compareStrings(left.name, right.name);
     };
-    const hasForwardDependency = (node, laterNames) => {
-      const text = sourceCode.getText(node);
-      for (const name of laterNames) {
-        if (text.includes(name)) {
-          return true;
-        }
-      }
-      return false;
-    };
     const buildItems = (block) => block.map((node) => {
       const name = getExportName(node);
       if (!name) {
@@ -945,12 +1114,41 @@ var sortExports = {
       });
       return unsorted ? messageId : null;
     };
-    const checkForwardDependencies = (items) => {
+    const hasForwardDependenciesInOrder = (items) => {
       const exportNames = items.map((item) => item.name);
       return items.some((item, idx) => {
         const laterNames = new Set(exportNames.slice(idx + 1));
-        const nodeToCheck = item.node.declaration ?? item.node;
-        return hasForwardDependency(nodeToCheck, laterNames);
+        if (laterNames.size === 0) {
+          return false;
+        }
+        const dependencies = getImmediateDependencyNames(item.node);
+        for (const dependency of dependencies) {
+          if (laterNames.has(dependency)) {
+            return true;
+          }
+        }
+        return false;
+      });
+    };
+    const wouldCreateForwardDependencies = (items, sortedItems) => {
+      const sortedIndices = new Map(sortedItems.map((item, idx) => [item.name, idx]));
+      const exportNames = new Set(items.map((item) => item.name));
+      return items.some((item) => {
+        const itemIndex = sortedIndices.get(item.name);
+        if (itemIndex === undefined) {
+          return false;
+        }
+        const dependencies = getImmediateDependencyNames(item.node);
+        for (const dependency of dependencies) {
+          if (!exportNames.has(dependency)) {
+            continue;
+          }
+          const dependencyIndex = sortedIndices.get(dependency);
+          if (dependencyIndex !== undefined && itemIndex < dependencyIndex) {
+            return true;
+          }
+        }
+        return false;
       });
     };
     const processExportBlock = (block) => {
@@ -965,10 +1163,13 @@ var sortExports = {
       if (!messageId) {
         return;
       }
-      if (checkForwardDependencies(items)) {
+      if (hasForwardDependenciesInOrder(items)) {
         return;
       }
       const sortedItems = items.slice().sort(sortComparator);
+      if (wouldCreateForwardDependencies(items, sortedItems)) {
+        return;
+      }
       const expectedOrder = sortedItems.map((item) => item.name).join(", ");
       const [firstNode] = block;
       const lastNode = block[block.length - 1];

package/eslint.config.mjs

@@ -30,7 +30,7 @@ export default defineConfig([
 		}
 	},
 	{
-		files: ["**/*.{ts,js,mjs}"],
+		files: ["**/*.{ts,js,mjs,json}"],
 		plugins: {
 			absolute: absolutePlugin
 		},
@@ -92,7 +92,7 @@ export default defineConfig([
 		}
 	},
 	{
-		files: ["eslint.config.mjs"],
+		files: ["eslint.config.mjs", "package.json", "tsconfig.json"],
 		rules: {
 			"@typescript-eslint/no-unused-expressions": "off"
 		}

package/package.json

@@ -1,27 +1,9 @@
 {
-	"name": "eslint-plugin-absolute",
-	"version": "0.2.1",
-	"description": "ESLint plugin for AbsoluteJS",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/absolutejs/eslint-plugin-absolute.git"
-	},
-	"type": "module",
-	"main": "./dist/index.js",
-	"license": "CC BY-NC 4.0",
 	"author": "Alex Kahn",
-	"scripts": {
-		"test": "bun test tests/",
-		"build": "rm -rf dist && bun build src/index.ts --outdir dist --splitting --target=bun --external eslint --external @typescript-eslint/utils",
-		"format": "absolutejs prettier --write",
-		"release": "bun run format && bun run build && bun publish",
-		"prune": "ts-prune --error",
-		"lint": "bun run build && bun run absolutejs eslint",
-		"typecheck": "bun run tsc --noEmit"
-	},
+	"description": "ESLint plugin for AbsoluteJS",
 	"devDependencies": {
-		"@types/bun": "1.3.3",
 		"@absolutejs/absolute": "0.16.10",
+		"@types/bun": "1.3.3",
 		"@types/react": "19.2.14",
 		"@typescript-eslint/rule-tester": "8.56.0",
 		"@typescript-eslint/utils": "8.56.0",
@@ -30,5 +12,23 @@
 		"ts-prune": "0.10.3",
 		"typescript": "5.9.3",
 		"typescript-eslint": "8.56.0"
-	}
+	},
+	"license": "CC BY-NC 4.0",
+	"main": "./dist/index.js",
+	"name": "eslint-plugin-absolute",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/absolutejs/eslint-plugin-absolute.git"
+	},
+	"scripts": {
+		"build": "rm -rf dist && bun build src/index.ts --outdir dist --splitting --target=bun --external eslint --external @typescript-eslint/utils",
+		"format": "absolutejs prettier --write",
+		"lint": "bun run build && bun run absolutejs eslint",
+		"prune": "ts-prune --error",
+		"release": "bun run format && bun run build && bun publish",
+		"test": "bun test tests/",
+		"typecheck": "bun run tsc --noEmit"
+	},
+	"type": "module",
+	"version": "0.2.3"
 }

package/src/rules/sort-exports.ts

@@ -30,7 +30,51 @@ type ExportItem = {
 	text: string;
 };
 
-const SORT_BEFORE: -1 = -1;
+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
@@ -114,6 +158,93 @@ const isFixableExport = (exportNode: TSESTree.ExportNamedDeclaration) => {
 	);
 };
 
+const visitImmediateReferences = (
+	node: TSESTree.Node | null | undefined,
+	onReference: (name: string) => void
+) => {
+	if (!node) {
+		return;
+	}
+
+	const visit = (current: TSESTree.Node | null | undefined) => {
+		if (!current) {
+			return;
+		}
+
+		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;
@@ -213,23 +344,6 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 			return compareStrings(left.name, right.name);
 		};
 
-		/**
-		 * Very lightweight dependency check: look at the text of the node and see
-		 * if it references any of the later export names.
-		 */
-		const hasForwardDependency = (
-			node: TSESTree.Node,
-			laterNames: Set<string>
-		) => {
-			const text = sourceCode.getText(node);
-			for (const name of laterNames) {
-				if (text.includes(name)) {
-					return true;
-				}
-			}
-			return false;
-		};
-
 		const buildItems = (block: TSESTree.ExportNamedDeclaration[]) =>
 			block
 				.map((node) => {
@@ -274,13 +388,52 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 			return unsorted ? messageId : null;
 		};
 
-		const checkForwardDependencies = (items: ExportItem[]) => {
+		const hasForwardDependenciesInOrder = (items: ExportItem[]) => {
 			const exportNames = items.map((item) => item.name);
 			return items.some((item, idx) => {
 				const laterNames = new Set(exportNames.slice(idx + 1));
-				const nodeToCheck: TSESTree.Node =
-					item.node.declaration ?? item.node;
-				return hasForwardDependency(nodeToCheck, laterNames);
+				if (laterNames.size === 0) {
+					return false;
+				}
+
+				const dependencies = getImmediateDependencyNames(item.node);
+				for (const dependency of dependencies) {
+					if (laterNames.has(dependency)) {
+						return true;
+					}
+				}
+				return false;
+			});
+		};
+
+		const wouldCreateForwardDependencies = (
+			items: ExportItem[],
+			sortedItems: ExportItem[]
+		) => {
+			const sortedIndices = new Map(
+				sortedItems.map((item, idx) => [item.name, idx])
+			);
+			const exportNames = new Set(items.map((item) => item.name));
+
+			return items.some((item) => {
+				const itemIndex = sortedIndices.get(item.name);
+				if (itemIndex === undefined) {
+					return false;
+				}
+
+				const dependencies = getImmediateDependencyNames(item.node);
+				for (const dependency of dependencies) {
+					if (!exportNames.has(dependency)) {
+						continue;
+					}
+
+					const dependencyIndex = sortedIndices.get(dependency);
+					if (dependencyIndex !== undefined && itemIndex < dependencyIndex) {
+						return true;
+					}
+				}
+
+				return false;
 			});
 		};
 
@@ -302,12 +455,16 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 				return;
 			}
 
-			if (checkForwardDependencies(items)) {
+			if (hasForwardDependenciesInOrder(items)) {
 				return;
 			}
 
 			const sortedItems = items.slice().sort(sortComparator);
 
+			if (wouldCreateForwardDependencies(items, sortedItems)) {
+				return;
+			}
+
 			const expectedOrder = sortedItems
 				.map((item) => item.name)
 				.join(", ");