eslint-plugin-absolute 0.2.5 → 0.2.7

package/dist/index.js

@@ -187,6 +187,23 @@ var explicitObjectTypes = {
 // src/rules/sort-keys-fixable.ts
 var SORT_BEFORE = -1;
 var PURE_CONSTRUCTORS = new Set(["Date"]);
+var PURE_GLOBAL_IDENTIFIERS = new Set([
+  "Array",
+  "BigInt",
+  "Boolean",
+  "Date",
+  "Function",
+  "Map",
+  "Number",
+  "Object",
+  "Promise",
+  "RegExp",
+  "Set",
+  "String",
+  "Symbol",
+  "URL",
+  "undefined"
+]);
 var PURE_GLOBAL_FUNCTIONS = new Set(["Boolean", "Number", "String"]);
 var PURE_MEMBER_METHODS = new Set([
   "getDay",
@@ -219,42 +236,6 @@ 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;
-      }
-      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;
@@ -269,63 +250,124 @@ var sortKeysFixable = {
       }
       return left.localeCompare(right);
     };
-    const addBoundIdentifiers = (node, stableLocals) => {
-      if (!node) {
+    const addImportBindings = (statement) => {
+      if (statement.specifiers.length === 0) {
         return;
       }
-      if (node.type === "Identifier") {
-        stableLocals.add(node.name);
+      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 (node.type === "AssignmentPattern") {
-        addBoundIdentifiers(node.left, stableLocals);
+      if (declaration.init.type === "ArrowFunctionExpression" || declaration.init.type === "FunctionExpression") {
+        topLevelBindings.set(declaration.id.name, {
+          kind: "function",
+          node: declaration.init
+        });
         return;
       }
-      if (node.type === "RestElement") {
-        addBoundIdentifiers(node.argument, stableLocals);
+      topLevelBindings.set(declaration.id.name, {
+        kind: "value",
+        node: declaration.init
+      });
+    };
+    const addTopLevelBindings = (statement) => {
+      if (statement.type === "ImportDeclaration") {
+        addImportBindings(statement);
         return;
       }
-      if (node.type === "ArrayPattern") {
-        for (const element of node.elements) {
-          if (!element) {
-            continue;
-          }
-          addBoundIdentifiers(element, stableLocals);
-        }
+      if (statement.type === "FunctionDeclaration" && statement.id) {
+        topLevelBindings.set(statement.id.name, {
+          kind: "function",
+          node: statement
+        });
+        return;
+      }
+      if (statement.type !== "VariableDeclaration" || statement.kind !== "const") {
+        return;
+      }
+      for (const declaration of statement.declarations) {
+        addVariableBinding(declaration);
+      }
+    };
+    for (const statement of sourceCode.ast.body) {
+      addTopLevelBindings(statement);
+    }
+    const addBoundIdentifiers = (node, stableLocals) => {
+      if (!node) {
         return;
       }
-      if (node.type === "ObjectPattern") {
-        for (const property of node.properties) {
-          if (property.type === "RestElement") {
-            addBoundIdentifiers(property.argument, stableLocals);
-            continue;
+      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);
           }
-          addBoundIdentifiers(property.value, 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;
         }
+        for (const declaration of statement.declarations) {
+          addBoundIdentifiers(declaration.id, stableLocals);
+        }
+      };
+      for (const statement of ancestor.body) {
+        if (statement.range[0] >= node.range[0]) {
+          return;
+        }
+        addDeclarationBindings(statement);
+      }
+    };
+    const addAncestorBindingsForNode = (ancestor, node, stableLocals) => {
+      if (ancestor.type !== "Program" && ancestor.type !== "BlockStatement") {
+        return;
+      }
+      addAncestorConstBindings(ancestor, node, stableLocals);
+    };
+    const addFunctionBindingsForAncestor = (ancestor, stableLocals) => {
+      if (ancestor.type !== "FunctionDeclaration" && ancestor.type !== "FunctionExpression" && ancestor.type !== "ArrowFunctionExpression") {
+        return;
       }
+      addFunctionParamBindings(ancestor, 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);
-          }
-        }
+        addFunctionBindingsForAncestor(ancestor, 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);
-          }
-        }
+        addAncestorBindingsForNode(ancestor, node, stableLocals);
       }
       return stableLocals;
     };
@@ -339,6 +381,9 @@ var sortKeysFixable = {
       return null;
     };
     const isStableIdentifier = (name, stableLocals) => {
+      if (PURE_GLOBAL_IDENTIFIERS.has(name)) {
+        return true;
+      }
       if (stableLocals.has(name)) {
         return true;
       }
@@ -354,6 +399,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) {
@@ -364,44 +442,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;
@@ -465,11 +522,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;
@@ -484,7 +537,6 @@ var sortKeysFixable = {
           return false;
       }
     };
-    const isSafeToReorderExpression = (node) => isPureRuntimeExpression(node, new Set);
     const isSafeJSXAttributeValue = (value, scopeNode) => {
       if (value === null) {
         return true;

package/package.json

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