eslint-plugin-absolute 0.2.4 → 0.2.6

package/dist/index.js

@@ -219,55 +219,140 @@ var sortKeysFixable = {
     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;
+    const compareKeys = (keyLeft, keyRight) => {
+      let left = keyLeft;
+      let right = keyRight;
+      if (!caseSensitive) {
+        left = left.toLowerCase();
+        right = right.toLowerCase();
+      }
+      if (natural) {
+        return left.localeCompare(right, undefined, {
+          numeric: true
+        });
+      }
+      return left.localeCompare(right);
+    };
+    const addImportBindings = (statement) => {
+      if (statement.specifiers.length === 0) {
+        return;
+      }
+      for (const specifier of statement.specifiers) {
+        topLevelBindings.set(specifier.local.name, {
+          kind: "import"
+        });
+      }
+    };
+    const addVariableBinding = (declaration) => {
+      if (declaration.id.type !== "Identifier" || !declaration.init) {
+        return;
+      }
+      if (declaration.init.type === "ArrowFunctionExpression" || declaration.init.type === "FunctionExpression") {
+        topLevelBindings.set(declaration.id.name, {
+          kind: "function",
+          node: declaration.init
+        });
+        return;
+      }
+      topLevelBindings.set(declaration.id.name, {
+        kind: "value",
+        node: declaration.init
+      });
+    };
+    const addTopLevelBindings = (statement) => {
+      if (statement.type === "ImportDeclaration") {
+        addImportBindings(statement);
+        return;
       }
       if (statement.type === "FunctionDeclaration" && statement.id) {
         topLevelBindings.set(statement.id.name, {
           kind: "function",
           node: statement
         });
-        continue;
+        return;
       }
       if (statement.type !== "VariableDeclaration" || statement.kind !== "const") {
-        continue;
+        return;
       }
       for (const declaration of statement.declarations) {
-        if (declaration.id.type !== "Identifier" || !declaration.init) {
-          continue;
+        addVariableBinding(declaration);
+      }
+    };
+    for (const statement of sourceCode.ast.body) {
+      addTopLevelBindings(statement);
+    }
+    const addBoundIdentifiers = (node, stableLocals) => {
+      if (!node) {
+        return;
+      }
+      switch (node.type) {
+        case "Identifier":
+          stableLocals.add(node.name);
+          return;
+        case "AssignmentPattern":
+          addBoundIdentifiers(node.left, stableLocals);
+          return;
+        case "RestElement":
+          addBoundIdentifiers(node.argument, stableLocals);
+          return;
+        case "ArrayPattern":
+          for (const element of node.elements.filter(Boolean)) {
+            addBoundIdentifiers(element, stableLocals);
+          }
+          break;
+        case "ObjectPattern":
+          for (const property of node.properties) {
+            const bindingNode = property.type === "RestElement" ? property.argument : property.value;
+            addBoundIdentifiers(bindingNode, stableLocals);
+          }
+          break;
+        default:
+          break;
+      }
+    };
+    const addFunctionParamBindings = (functionNode, stableLocals) => {
+      for (const parameter of functionNode.params) {
+        addBoundIdentifiers(parameter, stableLocals);
+      }
+    };
+    const addAncestorConstBindings = (ancestor, node, stableLocals) => {
+      const addDeclarationBindings = (statement) => {
+        if (statement.type !== "VariableDeclaration" || statement.kind !== "const") {
+          return;
         }
-        if (declaration.init.type === "ArrowFunctionExpression" || declaration.init.type === "FunctionExpression") {
-          topLevelBindings.set(declaration.id.name, {
-            kind: "function",
-            node: declaration.init
-          });
-          continue;
+        for (const declaration of statement.declarations) {
+          addBoundIdentifiers(declaration.id, stableLocals);
         }
-        topLevelBindings.set(declaration.id.name, {
-          kind: "value",
-          node: declaration.init
-        });
+      };
+      for (const statement of ancestor.body) {
+        if (statement.range[0] >= node.range[0]) {
+          return;
+        }
+        addDeclarationBindings(statement);
       }
-    }
-    const compareKeys = (keyLeft, keyRight) => {
-      let left = keyLeft;
-      let right = keyRight;
-      if (!caseSensitive) {
-        left = left.toLowerCase();
-        right = right.toLowerCase();
+    };
+    const addAncestorBindingsForNode = (ancestor, node, stableLocals) => {
+      if (ancestor.type !== "Program" && ancestor.type !== "BlockStatement") {
+        return;
       }
-      if (natural) {
-        return left.localeCompare(right, undefined, {
-          numeric: true
-        });
+      addAncestorConstBindings(ancestor, node, stableLocals);
+    };
+    const addFunctionBindingsForAncestor = (ancestor, stableLocals) => {
+      if (ancestor.type !== "FunctionDeclaration" && ancestor.type !== "FunctionExpression" && ancestor.type !== "ArrowFunctionExpression") {
+        return;
       }
-      return left.localeCompare(right);
+      addFunctionParamBindings(ancestor, stableLocals);
+    };
+    const getStableLocalsForNode = (node) => {
+      const stableLocals = new Set;
+      const ancestors = sourceCode.getAncestors(node);
+      for (const ancestor of ancestors) {
+        addFunctionBindingsForAncestor(ancestor, stableLocals);
+      }
+      for (const ancestor of ancestors) {
+        addAncestorBindingsForNode(ancestor, node, stableLocals);
+      }
+      return stableLocals;
     };
     const getStaticMemberName = (memberExpression) => {
       if (!memberExpression.computed && memberExpression.property.type === "Identifier") {
@@ -294,6 +379,39 @@ var sortKeysFixable = {
       }
       return false;
     };
+    const isPureConstStatement = (statement, stableLocals, checkExpression) => {
+      if (statement.kind !== "const") {
+        return false;
+      }
+      for (const declaration of statement.declarations) {
+        if (declaration.id.type !== "Identifier" || !declaration.init) {
+          return false;
+        }
+        if (!checkExpression(declaration.init)) {
+          return false;
+        }
+        stableLocals.add(declaration.id.name);
+      }
+      return true;
+    };
+    const isPureFunctionStatement = (statement, stableLocals, checkExpression) => {
+      if (statement.type === "ReturnStatement") {
+        return !statement.argument || checkExpression(statement.argument);
+      }
+      if (statement.type === "VariableDeclaration") {
+        return isPureConstStatement(statement, stableLocals, checkExpression);
+      }
+      return false;
+    };
+    const isPureFunctionBody = (body, stableLocals, checkExpression) => {
+      for (const statement of body.body) {
+        const statementIsPure = isPureFunctionStatement(statement, stableLocals, checkExpression);
+        if (!statementIsPure) {
+          return false;
+        }
+      }
+      return true;
+    };
     const isPureTopLevelFunction = (functionNode) => {
       const cached = pureFunctionCache.get(functionNode);
       if (cached !== undefined) {
@@ -304,44 +422,23 @@ var sortKeysFixable = {
       }
       pureFunctionInProgress.add(functionNode);
       const stableLocals = new Set;
-      for (const parameter of functionNode.params) {
-        if (parameter.type === "Identifier") {
-          stableLocals.add(parameter.name);
-        }
-      }
-      let isPure = true;
+      addFunctionParamBindings(functionNode, stableLocals);
       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);
-      }
+      const isPure = functionNode.body.type === "BlockStatement" ? isPureFunctionBody(functionNode.body, stableLocals, checkExpression) : checkExpression(functionNode.body);
       pureFunctionInProgress.delete(functionNode);
       pureFunctionCache.set(functionNode, isPure);
       return isPure;
     };
+    const isPureIdentifierCall = (callExpression) => {
+      if (callExpression.callee.type !== "Identifier") {
+        return false;
+      }
+      if (PURE_GLOBAL_FUNCTIONS.has(callExpression.callee.name)) {
+        return true;
+      }
+      const binding = topLevelBindings.get(callExpression.callee.name);
+      return binding?.kind === "function" ? isPureTopLevelFunction(binding.node) : false;
+    };
     const isPureRuntimeExpression = (node, stableLocals) => {
       if (!node || node.type === "PrivateIdentifier") {
         return false;
@@ -405,11 +502,7 @@ var sortKeysFixable = {
             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);
+            return isPureIdentifierCall(node);
           }
           if (node.callee.type !== "MemberExpression") {
             return false;
@@ -424,8 +517,7 @@ var sortKeysFixable = {
           return false;
       }
     };
-    const isSafeToReorderExpression = (node) => isPureRuntimeExpression(node, new Set);
-    const isSafeJSXAttributeValue = (value) => {
+    const isSafeJSXAttributeValue = (value, scopeNode) => {
       if (value === null) {
         return true;
       }
@@ -438,7 +530,7 @@ var sortKeysFixable = {
       if (value.expression.type === "JSXEmptyExpression") {
         return false;
       }
-      return isSafeToReorderExpression(value.expression);
+      return isPureRuntimeExpression(value.expression, getStableLocalsForNode(scopeNode));
     };
     const isFunctionProperty = (prop) => {
       const { value } = prop;
@@ -586,7 +678,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;
@@ -685,7 +777,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]

package/package.json

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