eslint-plugin-absolute 0.2.1 → 0.2.2

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) {
@@ -949,8 +1118,16 @@ var sortExports = {
       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 processExportBlock = (block) => {

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.2"
 }

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) => {
@@ -278,9 +392,17 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 			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;
 			});
 		};
 

package/src/rules/sort-keys-fixable.ts

@@ -36,6 +36,101 @@ type KeyInfo = {
 
 const SORT_BEFORE = -1;
 
+const hasDuplicateNames = (names: Array<string | null>) => {
+	const seen = new Set<string>();
+	const nonNullNames = names.flatMap((name) => (name === null ? [] : [name]));
+
+	for (const name of nonNullNames) {
+		if (seen.has(name)) {
+			return true;
+		}
+		seen.add(name);
+	}
+
+	return false;
+};
+
+const isSafeStaticTemplate = (node: TSESTree.TemplateLiteral) =>
+	node.expressions.length === 0;
+
+const isSafeArrayElement: (node: TSESTree.Node | null) => boolean = (node) => {
+	if (!node || node.type === "SpreadElement") {
+		return false;
+	}
+
+	return isSafeToReorderExpression(node);
+};
+
+const isSafeObjectProperty: (
+	property: TSESTree.ObjectExpression["properties"][number]
+) => boolean = (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);
+};
+
+const isSafeToReorderExpression: (node: TSESTree.Node | null) => boolean = (
+	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;
+	}
+};
+
+const isSafeJSXAttributeValue = (value: TSESTree.JSXAttribute["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);
+};
+
 export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 	create(context) {
 		const { sourceCode } = context;
@@ -367,6 +462,21 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				};
 			});
 
+			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: KeyInfo, shouldFix: boolean) => {
@@ -538,6 +648,34 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				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;
+			}
+
 			// Be conservative: only fix if there are no JSX comments/braces between attributes.
 			const braceConflict = attrs.find((currAttr, idx) => {
 				if (idx === 0) {

package/tsconfig.json

@@ -2,15 +2,15 @@
 	"compilerOptions": {
 		"esModuleInterop": true,
 		"forceConsistentCasingInFileNames": true,
+		"incremental": true,
 		"jsx": "react-jsx",
 		"lib": ["DOM", "DOM.Iterable", "ESNext"],
 		"module": "ESNext",
 		"moduleResolution": "bundler",
+		"noUncheckedIndexedAccess": true,
 		"skipLibCheck": true,
 		"strict": true,
 		"target": "ESNext",
-		"noUncheckedIndexedAccess": true,
-		"incremental": true,
 		"tsBuildInfoFile": ".absolutejs/tsconfig.tsbuildinfo",
 		"types": ["bun-types"]
 	}