eslint-plugin-absolute 0.2.3 → 0.2.5

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,237 @@ var sortKeysFixable = {
       }
       return left.localeCompare(right);
     };
+    const addBoundIdentifiers = (node, stableLocals) => {
+      if (!node) {
+        return;
+      }
+      if (node.type === "Identifier") {
+        stableLocals.add(node.name);
+        return;
+      }
+      if (node.type === "AssignmentPattern") {
+        addBoundIdentifiers(node.left, stableLocals);
+        return;
+      }
+      if (node.type === "RestElement") {
+        addBoundIdentifiers(node.argument, stableLocals);
+        return;
+      }
+      if (node.type === "ArrayPattern") {
+        for (const element of node.elements) {
+          if (!element) {
+            continue;
+          }
+          addBoundIdentifiers(element, stableLocals);
+        }
+        return;
+      }
+      if (node.type === "ObjectPattern") {
+        for (const property of node.properties) {
+          if (property.type === "RestElement") {
+            addBoundIdentifiers(property.argument, stableLocals);
+            continue;
+          }
+          addBoundIdentifiers(property.value, stableLocals);
+        }
+      }
+    };
+    const getStableLocalsForNode = (node) => {
+      const stableLocals = new Set;
+      const ancestors = sourceCode.getAncestors(node);
+      for (const ancestor of ancestors) {
+        if (ancestor.type === "FunctionDeclaration" || ancestor.type === "FunctionExpression" || ancestor.type === "ArrowFunctionExpression") {
+          for (const parameter of ancestor.params) {
+            addBoundIdentifiers(parameter, stableLocals);
+          }
+        }
+      }
+      for (const ancestor of ancestors) {
+        if (ancestor.type !== "Program" && ancestor.type !== "BlockStatement") {
+          continue;
+        }
+        for (const statement of ancestor.body) {
+          if (statement.range[0] >= node.range[0] || statement.type !== "VariableDeclaration" || statement.kind !== "const") {
+            break;
+          }
+          for (const declaration of statement.declarations) {
+            addBoundIdentifiers(declaration.id, stableLocals);
+          }
+        }
+      }
+      return stableLocals;
+    };
+    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, scopeNode) => {
+      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 isPureRuntimeExpression(value.expression, getStableLocalsForNode(scopeNode));
+    };
     const isFunctionProperty = (prop) => {
       const { value } = prop;
       return Boolean(value) && (value.type === "FunctionExpression" || value.type === "ArrowFunctionExpression" || prop.method === true);
@@ -424,7 +646,7 @@ ${indent}`;
       if (hasDuplicateNames(keys.map((key) => key.keyName))) {
         autoFixable = false;
       }
-      if (autoFixable && keys.some((key) => key.node.type === "Property" && !isSafeToReorderExpression(key.node.value))) {
+      if (autoFixable && keys.some((key) => key.node.type === "Property" && !isPureRuntimeExpression(key.node.value, getStableLocalsForNode(key.node)))) {
         autoFixable = false;
       }
       let fixProvided = false;
@@ -523,7 +745,7 @@ ${indent}`;
         });
         return;
       }
-      if (attrs.some((attr) => attr.type === "JSXAttribute" && !isSafeJSXAttributeValue(attr.value))) {
+      if (attrs.some((attr) => attr.type === "JSXAttribute" && !isSafeJSXAttributeValue(attr.value, attr))) {
         context.report({
           messageId: "unsorted",
           node: attrs[0].type === "JSXAttribute" ? attrs[0].name : attrs[0]
@@ -1140,13 +1362,9 @@ var sortExports = {
         }
         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) {
+          const dependencyIndex = exportNames.has(dependency) ? sortedIndices.get(dependency) : undefined;
+          if (dependencyIndex !== undefined && itemIndex < dependencyIndex)
             return true;
-          }
         }
         return false;
       });

package/package.json

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

package/src/rules/sort-exports.ts

@@ -423,14 +423,14 @@ export const sortExports: TSESLint.RuleModule<MessageIds, Options> = {
 
 				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) {
+					const dependencyIndex = exportNames.has(dependency)
+						? sortedIndices.get(dependency)
+						: undefined;
+					if (
+						dependencyIndex !== undefined &&
+						itemIndex < dependencyIndex
+					)
 						return true;
-					}
 				}
 
 				return false;