eslint-plugin-absolute 0.3.0 → 0.5.0

package/dist/index.js

@@ -194,7 +194,9 @@ var PURE_GLOBAL_IDENTIFIERS = new Set([
   "Boolean",
   "Date",
   "Function",
+  "JSON",
   "Map",
+  "Math",
   "Number",
   "Object",
   "Promise",
@@ -203,16 +205,131 @@ var PURE_GLOBAL_IDENTIFIERS = new Set([
   "String",
   "Symbol",
   "URL",
+  "globalThis",
   "undefined"
 ]);
-var PURE_GLOBAL_FUNCTIONS = new Set(["Boolean", "Number", "String"]);
+var PURE_GLOBAL_FUNCTIONS = new Set([
+  "Boolean",
+  "Number",
+  "String",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt"
+]);
 var PURE_MEMBER_METHODS = new Set([
+  "toString",
+  "valueOf",
+  "at",
+  "charAt",
+  "charCodeAt",
+  "codePointAt",
+  "endsWith",
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "match",
+  "matchAll",
+  "normalize",
+  "padEnd",
+  "padStart",
+  "repeat",
+  "replace",
+  "replaceAll",
+  "search",
+  "slice",
+  "split",
+  "startsWith",
+  "substr",
+  "substring",
+  "toLocaleLowerCase",
+  "toLocaleUpperCase",
+  "toLowerCase",
+  "toUpperCase",
+  "trim",
+  "trimEnd",
+  "trimStart",
+  "toExponential",
+  "toFixed",
+  "toPrecision",
+  "isInteger",
+  "isSafeInteger",
+  "getDate",
   "getDay",
+  "getFullYear",
   "getHours",
   "getMilliseconds",
   "getMinutes",
+  "getMonth",
   "getSeconds",
-  "padStart"
+  "getTime",
+  "getTimezoneOffset",
+  "getUTCDate",
+  "getUTCDay",
+  "getUTCFullYear",
+  "getUTCHours",
+  "getUTCMilliseconds",
+  "getUTCMinutes",
+  "getUTCMonth",
+  "getUTCSeconds",
+  "toDateString",
+  "toISOString",
+  "toJSON",
+  "toLocaleDateString",
+  "toLocaleString",
+  "toLocaleTimeString",
+  "toTimeString",
+  "toUTCString",
+  "abs",
+  "acos",
+  "acosh",
+  "asin",
+  "asinh",
+  "atan",
+  "atan2",
+  "atanh",
+  "cbrt",
+  "ceil",
+  "clz32",
+  "cos",
+  "cosh",
+  "exp",
+  "expm1",
+  "floor",
+  "fround",
+  "hypot",
+  "log",
+  "log10",
+  "log1p",
+  "log2",
+  "max",
+  "min",
+  "pow",
+  "round",
+  "sign",
+  "sin",
+  "sinh",
+  "sqrt",
+  "tan",
+  "tanh",
+  "trunc",
+  "entries",
+  "fromEntries",
+  "getOwnPropertyNames",
+  "getOwnPropertySymbols",
+  "getPrototypeOf",
+  "hasOwn",
+  "isArray",
+  "keys",
+  "values",
+  "concat",
+  "join",
+  "parse",
+  "stringify"
 ]);
 var hasDuplicateNames = (names) => {
   const seen = new Set;
@@ -225,6 +342,37 @@ var hasDuplicateNames = (names) => {
   }
   return false;
 };
+var hasDuplicatePropertyNames = (properties) => {
+  const kindsByName = new Map;
+  for (const property of properties) {
+    if (property.type !== "Property") {
+      continue;
+    }
+    let keyName = null;
+    if (property.key.type === "Identifier") {
+      keyName = property.key.name;
+    } else if (property.key.type === "Literal") {
+      const { value } = property.key;
+      keyName = typeof value === "string" ? value : String(value);
+    }
+    if (keyName === null) {
+      continue;
+    }
+    const kinds = kindsByName.get(keyName) ?? [];
+    kinds.push(property.kind);
+    kindsByName.set(keyName, kinds);
+  }
+  for (const kinds of kindsByName.values()) {
+    if (kinds.length === 1) {
+      continue;
+    }
+    if (kinds.length === 2 && kinds.includes("get") && kinds.includes("set")) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+};
 var sortKeysFixable = {
   create(context) {
     const { sourceCode } = context;
@@ -342,7 +490,7 @@ var sortKeysFixable = {
     };
     const addAncestorConstBindings = (ancestor, node, stableLocals) => {
       const addDeclarationBindings = (statement) => {
-        if (statement.type !== "VariableDeclaration" || statement.kind !== "const") {
+        if (statement.type !== "VariableDeclaration") {
           return;
         }
         for (const declaration of statement.declarations) {
@@ -377,6 +525,7 @@ var sortKeysFixable = {
       for (const ancestor of ancestors) {
         addAncestorBindingsForNode(ancestor, node, stableLocals);
       }
+      stableLocals.add("this");
       return stableLocals;
     };
     const getStaticMemberName = (memberExpression) => {
@@ -796,10 +945,66 @@ var sortKeysFixable = {
       }
       return isPureImportedCallExpression(callExpression);
     };
+    const getCallReturnTypeSymbol = (node) => {
+      if (!tsChecker || !esTreeNodeToTSNodeMap)
+        return;
+      const tsNode = esTreeNodeToTSNodeMap.get(node);
+      if (!tsNode)
+        return;
+      const type = tsChecker.getTypeAtLocation(tsNode);
+      return type.symbol ?? type.aliasSymbol;
+    };
+    const callReturnsNominalInstance = (node) => {
+      const symbol = getCallReturnTypeSymbol(node);
+      if (!symbol)
+        return false;
+      const declarations = symbol.declarations;
+      if (!declarations)
+        return false;
+      return declarations.some((declaration) => ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration) || ts.isInterfaceDeclaration(declaration));
+    };
+    const isEncapsulatedFreshExpression = (node, stableLocals) => {
+      if (!node)
+        return false;
+      if (node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSInstantiationExpression") {
+        return isEncapsulatedFreshExpression(node.expression, stableLocals);
+      }
+      if (node.type === "ObjectExpression" || node.type === "ArrayExpression") {
+        return isPureRuntimeExpression(node, stableLocals);
+      }
+      if (node.type === "NewExpression") {
+        return node.arguments.every((argument) => {
+          if (argument.type === "SpreadElement") {
+            return isPureRuntimeExpression(argument.argument, stableLocals);
+          }
+          return isPureRuntimeExpression(argument, stableLocals);
+        });
+      }
+      if (node.type === "CallExpression") {
+        const argsArePure = node.arguments.every((argument) => {
+          if (argument.type === "SpreadElement") {
+            return isPureRuntimeExpression(argument.argument, stableLocals);
+          }
+          return isPureRuntimeExpression(argument, stableLocals);
+        });
+        if (!argsArePure)
+          return false;
+        if (node.callee.type === "MemberExpression") {
+          return isEncapsulatedFreshExpression(node.callee.object, stableLocals);
+        }
+        if (node.callee.type === "Identifier") {
+          return callReturnsNominalInstance(node);
+        }
+      }
+      return false;
+    };
     const isPureRuntimeExpression = (node, stableLocals) => {
       if (!node || node.type === "PrivateIdentifier") {
         return false;
       }
+      if (node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSInstantiationExpression") {
+        return isPureRuntimeExpression(node.expression, stableLocals);
+      }
       switch (node.type) {
         case "Identifier":
           return isStableIdentifier(node.name, stableLocals);
@@ -823,9 +1028,12 @@ var sortKeysFixable = {
           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") {
+            if (!element) {
               return false;
             }
+            if (element.type === "SpreadElement") {
+              return isPureRuntimeExpression(element.argument, stableLocals);
+            }
             return isPureRuntimeExpression(element, stableLocals);
           });
         case "ObjectExpression":
@@ -865,7 +1073,10 @@ var sortKeysFixable = {
             return true;
           }
           if (node.callee.type === "Identifier") {
-            return isPureIdentifierCall(node);
+            if (isPureIdentifierCall(node)) {
+              return true;
+            }
+            return callReturnsNominalInstance(node);
           }
           if (node.callee.type !== "MemberExpression") {
             return false;
@@ -874,6 +1085,12 @@ var sortKeysFixable = {
           if (memberName && PURE_MEMBER_METHODS.has(memberName)) {
             return isPureRuntimeExpression(node.callee.object, stableLocals);
           }
+          if (isEncapsulatedFreshExpression(node.callee.object, stableLocals)) {
+            return true;
+          }
+          if (isPureRuntimeExpression(node.callee.object, stableLocals) && callReturnsNominalInstance(node)) {
+            return true;
+          }
           return isPureImportedCallExpression(node);
         }
         default:
@@ -1038,7 +1255,7 @@ ${indent}`;
           node: prop
         };
       });
-      if (hasDuplicateNames(keys.map((key) => key.keyName))) {
+      if (hasDuplicatePropertyNames(node.properties)) {
         autoFixable = false;
       }
       if (autoFixable) {

package/package.json

@@ -40,5 +40,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.3.0"
+	"version": "0.5.0"
 }