eslint-plugin-absolute 0.2.2 → 0.2.4

package/dist/index.js

@@ -186,6 +186,16 @@ var explicitObjectTypes = {
 
 // src/rules/sort-keys-fixable.ts
 var SORT_BEFORE = -1;
+var PURE_CONSTRUCTORS = new Set(["Date"]);
+var PURE_GLOBAL_FUNCTIONS = new Set(["Boolean", "Number", "String"]);
+var PURE_MEMBER_METHODS = new Set([
+  "getDay",
+  "getHours",
+  "getMilliseconds",
+  "getMinutes",
+  "getSeconds",
+  "padStart"
+]);
 var hasDuplicateNames = (names) => {
   const seen = new Set;
   const nonNullNames = names.flatMap((name) => name === null ? [] : [name]);
@@ -197,73 +207,54 @@ var hasDuplicateNames = (names) => {
   }
   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;
     const [option] = context.options;
+    const topLevelBindings = new Map;
+    const pureFunctionCache = new Map;
+    const pureFunctionInProgress = new Set;
     const order = option && option.order ? option.order : "asc";
     const caseSensitive = option && typeof option.caseSensitive === "boolean" ? option.caseSensitive : false;
     const natural = option && typeof option.natural === "boolean" ? option.natural : false;
     const minKeys = option && typeof option.minKeys === "number" ? option.minKeys : 2;
     const variablesBeforeFunctions = option && typeof option.variablesBeforeFunctions === "boolean" ? option.variablesBeforeFunctions : false;
+    for (const statement of sourceCode.ast.body) {
+      if (statement.type === "ImportDeclaration" && statement.specifiers.length > 0) {
+        for (const specifier of statement.specifiers) {
+          topLevelBindings.set(specifier.local.name, {
+            kind: "import"
+          });
+        }
+        continue;
+      }
+      if (statement.type === "FunctionDeclaration" && statement.id) {
+        topLevelBindings.set(statement.id.name, {
+          kind: "function",
+          node: statement
+        });
+        continue;
+      }
+      if (statement.type !== "VariableDeclaration" || statement.kind !== "const") {
+        continue;
+      }
+      for (const declaration of statement.declarations) {
+        if (declaration.id.type !== "Identifier" || !declaration.init) {
+          continue;
+        }
+        if (declaration.init.type === "ArrowFunctionExpression" || declaration.init.type === "FunctionExpression") {
+          topLevelBindings.set(declaration.id.name, {
+            kind: "function",
+            node: declaration.init
+          });
+          continue;
+        }
+        topLevelBindings.set(declaration.id.name, {
+          kind: "value",
+          node: declaration.init
+        });
+      }
+    }
     const compareKeys = (keyLeft, keyRight) => {
       let left = keyLeft;
       let right = keyRight;
@@ -278,6 +269,177 @@ var sortKeysFixable = {
       }
       return left.localeCompare(right);
     };
+    const getStaticMemberName = (memberExpression) => {
+      if (!memberExpression.computed && memberExpression.property.type === "Identifier") {
+        return memberExpression.property.name;
+      }
+      if (memberExpression.computed && memberExpression.property.type === "Literal" && typeof memberExpression.property.value === "string") {
+        return memberExpression.property.value;
+      }
+      return null;
+    };
+    const isStableIdentifier = (name, stableLocals) => {
+      if (stableLocals.has(name)) {
+        return true;
+      }
+      const binding = topLevelBindings.get(name);
+      if (!binding) {
+        return false;
+      }
+      if (binding.kind === "import") {
+        return true;
+      }
+      if (binding.kind === "value") {
+        return isPureRuntimeExpression(binding.node, stableLocals);
+      }
+      return false;
+    };
+    const isPureTopLevelFunction = (functionNode) => {
+      const cached = pureFunctionCache.get(functionNode);
+      if (cached !== undefined) {
+        return cached;
+      }
+      if (pureFunctionInProgress.has(functionNode)) {
+        return false;
+      }
+      pureFunctionInProgress.add(functionNode);
+      const stableLocals = new Set;
+      for (const parameter of functionNode.params) {
+        if (parameter.type === "Identifier") {
+          stableLocals.add(parameter.name);
+        }
+      }
+      let isPure = true;
+      const checkExpression = (expression) => isPureRuntimeExpression(expression, stableLocals);
+      if (functionNode.body.type === "BlockStatement") {
+        for (const statement of functionNode.body.body) {
+          if (statement.type === "ReturnStatement") {
+            if (statement.argument && !checkExpression(statement.argument)) {
+              isPure = false;
+            }
+            continue;
+          }
+          if (statement.type === "VariableDeclaration" && statement.kind === "const") {
+            for (const declaration of statement.declarations) {
+              if (declaration.id.type !== "Identifier" || !declaration.init || !checkExpression(declaration.init)) {
+                isPure = false;
+                break;
+              }
+              stableLocals.add(declaration.id.name);
+            }
+            if (!isPure) {
+              break;
+            }
+            continue;
+          }
+          isPure = false;
+          break;
+        }
+      } else {
+        isPure = checkExpression(functionNode.body);
+      }
+      pureFunctionInProgress.delete(functionNode);
+      pureFunctionCache.set(functionNode, isPure);
+      return isPure;
+    };
+    const isPureRuntimeExpression = (node, stableLocals) => {
+      if (!node || node.type === "PrivateIdentifier") {
+        return false;
+      }
+      switch (node.type) {
+        case "Identifier":
+          return isStableIdentifier(node.name, stableLocals);
+        case "Literal":
+        case "FunctionExpression":
+        case "ArrowFunctionExpression":
+        case "ClassExpression":
+          return true;
+        case "ThisExpression":
+          return stableLocals.has("this");
+        case "TemplateLiteral":
+          return node.expressions.every((expression) => isPureRuntimeExpression(expression, stableLocals));
+        case "UnaryExpression":
+          return isPureRuntimeExpression(node.argument, stableLocals);
+        case "BinaryExpression":
+        case "LogicalExpression":
+          return isPureRuntimeExpression(node.left, stableLocals) && isPureRuntimeExpression(node.right, stableLocals);
+        case "ConditionalExpression":
+          return isPureRuntimeExpression(node.test, stableLocals) && isPureRuntimeExpression(node.consequent, stableLocals) && isPureRuntimeExpression(node.alternate, stableLocals);
+        case "ArrayExpression":
+          return node.elements.every((element) => {
+            if (!element || element.type === "SpreadElement") {
+              return false;
+            }
+            return isPureRuntimeExpression(element, stableLocals);
+          });
+        case "ObjectExpression":
+          return node.properties.every((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 isPureRuntimeExpression(property.value, stableLocals);
+          });
+        case "MemberExpression":
+          return isPureRuntimeExpression(node.object, stableLocals) && (!node.computed || isPureRuntimeExpression(node.property, stableLocals));
+        case "NewExpression":
+          return node.callee.type === "Identifier" && PURE_CONSTRUCTORS.has(node.callee.name) && node.arguments.every((argument) => {
+            if (argument.type === "SpreadElement") {
+              return false;
+            }
+            return isPureRuntimeExpression(argument, stableLocals);
+          });
+        case "CallExpression": {
+          const argsArePure = node.arguments.every((argument) => {
+            if (argument.type === "SpreadElement") {
+              return false;
+            }
+            return isPureRuntimeExpression(argument, stableLocals);
+          });
+          if (!argsArePure) {
+            return false;
+          }
+          if (node.callee.type === "Identifier") {
+            if (PURE_GLOBAL_FUNCTIONS.has(node.callee.name)) {
+              return true;
+            }
+            const binding = topLevelBindings.get(node.callee.name);
+            return binding?.kind === "function" && isPureTopLevelFunction(binding.node);
+          }
+          if (node.callee.type !== "MemberExpression") {
+            return false;
+          }
+          const memberName = getStaticMemberName(node.callee);
+          if (!memberName || !PURE_MEMBER_METHODS.has(memberName)) {
+            return false;
+          }
+          return isPureRuntimeExpression(node.callee.object, stableLocals);
+        }
+        default:
+          return false;
+      }
+    };
+    const isSafeToReorderExpression = (node) => isPureRuntimeExpression(node, new Set);
+    const 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);
+    };
     const isFunctionProperty = (prop) => {
       const { value } = prop;
       return Boolean(value) && (value.type === "FunctionExpression" || value.type === "ArrowFunctionExpression" || prop.method === true);
@@ -1114,7 +1276,7 @@ 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));
@@ -1130,6 +1292,23 @@ var sortExports = {
         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) {
+          const dependencyIndex = exportNames.has(dependency) ? sortedIndices.get(dependency) : undefined;
+          if (dependencyIndex !== undefined && itemIndex < dependencyIndex)
+            return true;
+        }
+        return false;
+      });
+    };
     const processExportBlock = (block) => {
       if (block.length < minKeys) {
         return;
@@ -1142,10 +1321,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/package.json

@@ -30,5 +30,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.2.2"
+	"version": "0.2.4"
 }

package/src/rules/sort-exports.ts

@@ -388,7 +388,7 @@ 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));
@@ -406,6 +406,37 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 			});
 		};
 
+		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) {
+					const dependencyIndex = exportNames.has(dependency)
+						? sortedIndices.get(dependency)
+						: undefined;
+					if (
+						dependencyIndex !== undefined &&
+						itemIndex < dependencyIndex
+					)
+						return true;
+				}
+
+				return false;
+			});
+		};
+
 		const processExportBlock = (
 			block: TSESTree.ExportNamedDeclaration[]
 		) => {
@@ -424,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(", ");