npm - @eslint-react/var - Versions diffs - 1.23.3-next.8 → 1.24.0-next.0 - Mend

@eslint-react/var 1.23.3-next.8 → 1.24.0-next.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.d.mts CHANGED Viewed

@@ -1,27 +1,17 @@
-import { O } from '@eslint-react/eff';
-import * as _typescript_eslint_scope_manager from '@typescript-eslint/scope-manager';
-import { Scope, Variable, ScopeManager } from '@typescript-eslint/scope-manager';
+import { _ } from '@eslint-react/eff';
+import { Scope, Variable } from '@typescript-eslint/scope-manager';
 import { TSESTree } from '@typescript-eslint/types';
 declare const findVariable: {
-    (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier) => O.Option<Variable>;
-    (nameOrNode: string | TSESTree.Identifier, initialScope: Scope): O.Option<Variable>;
+    (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | _) => Variable | _;
+    (nameOrNode: string | TSESTree.Identifier | _, initialScope: Scope): Variable | _;
 };
-declare function getChidScopes(scope: Scope, prev?: readonly Scope[]): readonly Scope[];
+declare function getChidScopes(scope: Scope): readonly Scope[];
-declare function getScope(node: TSESTree.Node, scopeManager: ScopeManager): _typescript_eslint_scope_manager.Scope | null;
+declare function getVariableDeclaratorId(node: TSESTree.Node | _, prev?: TSESTree.Node): TSESTree.BindingName | TSESTree.Expression | _;
-declare function getStaticValue(node: TSESTree.Node, initialScope: Scope): O.Option<unknown>;
-declare function getVariableDeclaratorID(node: TSESTree.Node, prev?: TSESTree.Node): O.Option<TSESTree.BindingName | TSESTree.Expression>;
-/**
- * Get the init node of the nth definition of a variable
- * @param at The index number of def in defs
- * @returns A function that takes a variable and returns the init node of the nth definition of that variable
- */
-declare function getVariableNode(at: number): (variable: Variable) => O.Option<TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName>;
+declare function getVariableNode(variable: Variable | _, at: number): _ | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
 /**
  * Get all variables from the given scope up to the global scope
@@ -51,10 +41,33 @@ declare function isNodeValueEqual(a: TSESTree.Node, b: TSESTree.Node, initialSco
     bScope: Scope
 ]): boolean;
-type ValueConstruction = {
-    kind: "None";
+type StaticValue = {
+    kind: "lazy";
+    node: TSESTree.Node;
+    initialScope: Scope | _;
+} | {
+    kind: "none";
     node: TSESTree.Node;
+    initialScope: Scope | _;
 } | {
+    kind: "some";
+    node: TSESTree.Node;
+    value: unknown;
+    initialScope: Scope | _;
+};
+declare function toResolved(sv: StaticValue): {
+    readonly kind: "none";
+    readonly node: TSESTree.Node;
+    readonly initialScope: Scope | undefined;
+    readonly value?: never;
+} | {
+    readonly kind: "some";
+    readonly node: TSESTree.Node;
+    readonly initialScope: Scope | undefined;
+    readonly value: unknown;
+};
+type ValueConstruction = {
     kind: "ArrayExpression";
     node: TSESTree.ArrayExpression;
 } | {
@@ -93,6 +106,6 @@ declare const ValueConstructionHint: {
  * @param hint The hint to use when detecting the construction
  * @returns A function that detects the construction of a given node
  */
-declare function getValueConstruction(node: TSESTree.Node, initialScope: Scope, hint?: bigint): ValueConstruction;
+declare function getValueConstruction(node: TSESTree.Node | _, initialScope: Scope, hint?: bigint): ValueConstruction | _;
-export { type ValueConstruction, ValueConstructionHint, findVariable, getChidScopes, getScope, getStaticValue, getValueConstruction, getVariableDeclaratorID, getVariableNode, getVariables, isInitializedFromSource, isNodeValueEqual };
+export { type StaticValue, type ValueConstruction, ValueConstructionHint, findVariable, getChidScopes, getValueConstruction, getVariableDeclaratorId, getVariableNode, getVariables, isInitializedFromSource, isNodeValueEqual, toResolved };

package/dist/index.d.ts CHANGED Viewed

@@ -1,27 +1,17 @@
-import { O } from '@eslint-react/eff';
-import * as _typescript_eslint_scope_manager from '@typescript-eslint/scope-manager';
-import { Scope, Variable, ScopeManager } from '@typescript-eslint/scope-manager';
+import { _ } from '@eslint-react/eff';
+import { Scope, Variable } from '@typescript-eslint/scope-manager';
 import { TSESTree } from '@typescript-eslint/types';
 declare const findVariable: {
-    (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier) => O.Option<Variable>;
-    (nameOrNode: string | TSESTree.Identifier, initialScope: Scope): O.Option<Variable>;
+    (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | _) => Variable | _;
+    (nameOrNode: string | TSESTree.Identifier | _, initialScope: Scope): Variable | _;
 };
-declare function getChidScopes(scope: Scope, prev?: readonly Scope[]): readonly Scope[];
+declare function getChidScopes(scope: Scope): readonly Scope[];
-declare function getScope(node: TSESTree.Node, scopeManager: ScopeManager): _typescript_eslint_scope_manager.Scope | null;
+declare function getVariableDeclaratorId(node: TSESTree.Node | _, prev?: TSESTree.Node): TSESTree.BindingName | TSESTree.Expression | _;
-declare function getStaticValue(node: TSESTree.Node, initialScope: Scope): O.Option<unknown>;
-declare function getVariableDeclaratorID(node: TSESTree.Node, prev?: TSESTree.Node): O.Option<TSESTree.BindingName | TSESTree.Expression>;
-/**
- * Get the init node of the nth definition of a variable
- * @param at The index number of def in defs
- * @returns A function that takes a variable and returns the init node of the nth definition of that variable
- */
-declare function getVariableNode(at: number): (variable: Variable) => O.Option<TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName>;
+declare function getVariableNode(variable: Variable | _, at: number): _ | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
 /**
  * Get all variables from the given scope up to the global scope
@@ -51,10 +41,33 @@ declare function isNodeValueEqual(a: TSESTree.Node, b: TSESTree.Node, initialSco
     bScope: Scope
 ]): boolean;
-type ValueConstruction = {
-    kind: "None";
+type StaticValue = {
+    kind: "lazy";
+    node: TSESTree.Node;
+    initialScope: Scope | _;
+} | {
+    kind: "none";
     node: TSESTree.Node;
+    initialScope: Scope | _;
 } | {
+    kind: "some";
+    node: TSESTree.Node;
+    value: unknown;
+    initialScope: Scope | _;
+};
+declare function toResolved(sv: StaticValue): {
+    readonly kind: "none";
+    readonly node: TSESTree.Node;
+    readonly initialScope: Scope | undefined;
+    readonly value?: never;
+} | {
+    readonly kind: "some";
+    readonly node: TSESTree.Node;
+    readonly initialScope: Scope | undefined;
+    readonly value: unknown;
+};
+type ValueConstruction = {
     kind: "ArrayExpression";
     node: TSESTree.ArrayExpression;
 } | {
@@ -93,6 +106,6 @@ declare const ValueConstructionHint: {
  * @param hint The hint to use when detecting the construction
  * @returns A function that detects the construction of a given node
  */
-declare function getValueConstruction(node: TSESTree.Node, initialScope: Scope, hint?: bigint): ValueConstruction;
+declare function getValueConstruction(node: TSESTree.Node | _, initialScope: Scope, hint?: bigint): ValueConstruction | _;
-export { type ValueConstruction, ValueConstructionHint, findVariable, getChidScopes, getScope, getStaticValue, getValueConstruction, getVariableDeclaratorID, getVariableNode, getVariables, isInitializedFromSource, isNodeValueEqual };
+export { type StaticValue, type ValueConstruction, ValueConstructionHint, findVariable, getChidScopes, getValueConstruction, getVariableDeclaratorId, getVariableNode, getVariables, isInitializedFromSource, isNodeValueEqual, toResolved };

package/dist/index.js CHANGED Viewed

@@ -28,65 +28,48 @@ var ASTUtils__namespace = /*#__PURE__*/_interopNamespace(ASTUtils);
 var AST3__namespace = /*#__PURE__*/_interopNamespace(AST3);
 // src/find-variable.ts
-var findVariable2 = eff.F.dual(2, (nameOrNode, initialScope) => {
-  return eff.O.fromNullable(ASTUtils__namespace.findVariable(initialScope, nameOrNode));
+var findVariable2 = eff.dual(2, (nameOrNode, initialScope) => {
+  if (nameOrNode === eff._) return eff._;
+  return ASTUtils__namespace.findVariable(initialScope, nameOrNode) ?? eff._;
 });
 // src/get-child-scopes.ts
-function getChidScopes(scope, prev = []) {
-  return [scope, ...scope.childScopes.reduce((acc, prev2) => getChidScopes(prev2, [...acc, prev2]), prev)];
-}
-function getScope(node, scopeManager) {
-  const { type, parent } = node;
-  const inner = type !== types.AST_NODE_TYPES.Program;
-  const scope = scopeManager.acquire(node, inner);
-  if (scope != null) {
-    return scope;
-  }
-  if (parent != null) {
-    return getScope(parent, scopeManager);
+function getChidScopes(scope) {
+  const scopes = [scope];
+  for (const childScope of scope.childScopes) {
+    scopes.push(...getChidScopes(childScope));
   }
-  return null;
-}
-function getStaticValue2(node, initialScope) {
-  return eff.F.pipe(
-    eff.O.fromNullable(ASTUtils__namespace.getStaticValue(node, initialScope)),
-    eff.O.map((v) => v.value)
-  );
+  return scopes;
 }
-function getVariableDeclaratorID(node, prev) {
+function getVariableDeclaratorId(node, prev) {
+  if (node === eff._) return eff._;
   switch (true) {
     case (node.type === types.AST_NODE_TYPES.VariableDeclarator && node.init === prev):
-      return eff.O.some(node.id);
+      return node.id;
     case (node.type === types.AST_NODE_TYPES.AssignmentExpression && node.right === prev):
-      return eff.O.some(node.left);
+      return node.left;
     case (node.type === types.AST_NODE_TYPES.BlockStatement || node.type === types.AST_NODE_TYPES.Program || node.parent === node):
-      return eff.O.none();
+      return eff._;
     default:
-      return getVariableDeclaratorID(node.parent, node);
+      return getVariableDeclaratorId(node.parent, node);
   }
 }
-function getVariableNode(at) {
-  return (variable) => {
-    return eff.F.pipe(
-      eff.O.some(variable),
-      eff.O.flatMapNullable((v) => v.defs.at(at)),
-      eff.O.flatMapNullable((def) => {
-        switch (true) {
-          case (def.type === scopeManager.DefinitionType.FunctionName && def.node.type === types.AST_NODE_TYPES.FunctionDeclaration):
-            return def.node;
-          case (def.type === scopeManager.DefinitionType.ClassName && def.node.type === types.AST_NODE_TYPES.ClassDeclaration):
-            return def.node;
-          case (def.type === scopeManager.DefinitionType.Parameter && AST3__namespace.isFunction(def.node)):
-            return def.node;
-          case ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)):
-            return def.node.init;
-          default:
-            return null;
-        }
-      })
-    );
-  };
+function getVariableNode(variable, at) {
+  if (variable === eff._) return eff._;
+  const def = variable.defs.at(at);
+  if (def === eff._) return eff._;
+  switch (true) {
+    case (def.type === scopeManager.DefinitionType.FunctionName && def.node.type === types.AST_NODE_TYPES.FunctionDeclaration):
+      return def.node;
+    case (def.type === scopeManager.DefinitionType.ClassName && def.node.type === types.AST_NODE_TYPES.ClassDeclaration):
+      return def.node;
+    case (def.type === scopeManager.DefinitionType.Parameter && AST3__namespace.isFunction(def.node)):
+      return def.node;
+    case ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)):
+      return def.node.init;
+    default:
+      return eff._;
+  }
 }
 function getVariables(initialScope) {
   let scope = initialScope;
@@ -98,11 +81,9 @@ function getVariables(initialScope) {
   return variables.reverse();
 }
 function isInitializedFromSource(name, source, initialScope) {
-  const latestDef = eff.O.flatMapNullable(findVariable2(name, initialScope), (v) => v.defs.at(-1));
-  if (eff.O.isNone(latestDef)) {
-    return false;
-  }
-  const { node, parent } = latestDef.value;
+  const latestDef = findVariable2(name, initialScope)?.defs.at(-1);
+  if (latestDef === eff._) return false;
+  const { node, parent } = latestDef;
   if (node.type === types.AST_NODE_TYPES.VariableDeclarator && node.init != null) {
     const { init } = node;
     if (init.type === types.AST_NODE_TYPES.MemberExpression && init.object.type === types.AST_NODE_TYPES.Identifier) {
@@ -111,13 +92,12 @@ function isInitializedFromSource(name, source, initialScope) {
     if (init.type === types.AST_NODE_TYPES.Identifier) {
       return isInitializedFromSource(init.name, source, initialScope);
     }
-    return eff.F.pipe(
-      getRequireExpressionArguments(init),
-      eff.O.flatMapNullable((args) => args[0]),
-      eff.O.filter(AST3__namespace.isStringLiteral),
-      // check for: `require('source')` or `require('source/...')`
-      eff.O.exists((arg) => arg.value === source || arg.value.startsWith(`${source}/`))
-    );
+    const args = getRequireExpressionArguments(init);
+    const arg0 = args?.[0];
+    if (arg0 == null || !AST3__namespace.isStringLiteral(arg0)) {
+      return false;
+    }
+    return arg0.value === source || arg0.value.startsWith(`${source}/`);
   }
   return parent?.type === types.AST_NODE_TYPES.ImportDeclaration && parent.source.value === source;
 }
@@ -125,15 +105,25 @@ function getRequireExpressionArguments(node) {
   switch (true) {
     // require('source')
     case (node.type === types.AST_NODE_TYPES.CallExpression && node.callee.type === types.AST_NODE_TYPES.Identifier && node.callee.name === "require"): {
-      return eff.O.some(node.arguments);
+      return node.arguments;
     }
     // require('source').variable
     case node.type === types.AST_NODE_TYPES.MemberExpression: {
       return getRequireExpressionArguments(node.object);
     }
   }
-  return eff.O.none();
+  return eff._;
 }
+function toResolved(sv) {
+  const { kind, node, initialScope } = sv;
+  if (kind !== "lazy") {
+    return sv;
+  }
+  const resolvedValue = initialScope === eff._ ? ASTUtils.getStaticValue(node) : ASTUtils.getStaticValue(node, initialScope);
+  return resolvedValue == null ? { kind: "none", node, initialScope } : { kind: "some", node, initialScope, value: resolvedValue.value };
+}
+// src/is-node-value-equal.ts
 var thisBlockTypes = [
   types.AST_NODE_TYPES.FunctionDeclaration,
   types.AST_NODE_TYPES.FunctionExpression,
@@ -155,48 +145,37 @@ function isNodeValueEqual(a, b, initialScopes) {
     case (a.type === types.AST_NODE_TYPES.Identifier && b.type === types.AST_NODE_TYPES.Identifier): {
       const aVar = findVariable2(a, aScope);
       const bVar = findVariable2(b, bScope);
-      const aVarNode = eff.O.flatMap(aVar, getVariableNode(0));
-      const bVarNode = eff.O.flatMap(bVar, getVariableNode(0));
-      const aVarNodeParent = eff.O.flatMapNullable(aVarNode, (n) => n.parent);
-      const bVarNodeParent = eff.O.flatMapNullable(bVarNode, (n) => n.parent);
-      const aDef = eff.O.flatMapNullable(aVar, (v) => v.defs.at(0));
-      const bDef = eff.O.flatMapNullable(bVar, (v) => v.defs.at(0));
-      const aDefParentParent = eff.O.flatMapNullable(aDef, (d) => d.parent?.parent);
-      const bDefParentParent = eff.O.flatMapNullable(bDef, (d) => d.parent?.parent);
+      const aVarNode = getVariableNode(aVar, 0);
+      const bVarNode = getVariableNode(bVar, 0);
+      const aVarNodeParent = aVarNode?.parent;
+      const bVarNodeParent = bVarNode?.parent;
+      const aDef = aVar?.defs.at(0);
+      const bDef = bVar?.defs.at(0);
+      const aDefParentParent = aDef?.parent?.parent;
+      const bDefParentParent = bDef?.parent?.parent;
       switch (true) {
-        case (eff.O.exists(aVarNodeParent, AST3__namespace.is(types.AST_NODE_TYPES.CallExpression)) && eff.O.exists(bVarNodeParent, AST3__namespace.is(types.AST_NODE_TYPES.CallExpression)) && eff.O.exists(aVarNode, AST3__namespace.isFunction) && eff.O.exists(bVarNode, AST3__namespace.isFunction)): {
-          const hasSameCallee = eff.F.pipe(
-            eff.O.Do,
-            eff.O.bind("aCallee", () => eff.O.map(aVarNodeParent, (n) => n.callee)),
-            eff.O.bind("bCallee", () => eff.O.map(bVarNodeParent, (n) => n.callee)),
-            eff.O.exists(({ aCallee, bCallee }) => AST3__namespace.isNodeEqual(aCallee, bCallee))
-          );
-          if (!hasSameCallee) {
+        case (aVarNodeParent?.type === types.AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === types.AST_NODE_TYPES.CallExpression && AST3__namespace.isFunction(aVarNode) && AST3__namespace.isFunction(bVarNode)): {
+          if (!AST3__namespace.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) {
             return false;
           }
-          return eff.F.pipe(
-            eff.O.Do,
-            eff.O.bind("aParams", () => eff.O.map(aVarNode, (n) => n.params)),
-            eff.O.bind("bParams", () => eff.O.map(bVarNode, (n) => n.params)),
-            eff.O.let("aPos", ({ aParams }) => aParams.findIndex(AST3__namespace.isNodeEqual(a))),
-            eff.O.let("bPos", ({ bParams }) => bParams.findIndex(AST3__namespace.isNodeEqual(b))),
-            eff.O.filter(({ aPos, bPos }) => aPos !== -1 && bPos !== -1),
-            eff.O.exists(({ aPos, bPos }) => aPos === bPos)
-          );
+          const aParams = aVarNode.params;
+          const bParams = bVarNode.params;
+          const aPos = aParams.findIndex((x) => AST3__namespace.isNodeEqual(x, a));
+          const bPos = bParams.findIndex((x) => AST3__namespace.isNodeEqual(x, b));
+          return aPos !== -1 && bPos !== -1 && aPos === bPos;
         }
-        case (eff.O.exists(aDefParentParent, AST3__namespace.is(types.AST_NODE_TYPES.ForOfStatement)) && eff.O.exists(bDefParentParent, AST3__namespace.is(types.AST_NODE_TYPES.ForOfStatement))): {
-          return eff.F.pipe(
-            eff.O.Do,
-            eff.O.bind("aLeft", () => eff.O.map(aDefParentParent, (d) => d.left)),
-            eff.O.bind("bLeft", () => eff.O.map(bDefParentParent, (d) => d.left)),
-            eff.O.filter(({ aLeft, bLeft }) => aLeft.type === bLeft.type),
-            eff.O.bind("aRight", () => eff.O.map(aDefParentParent, (d) => d.right)),
-            eff.O.bind("bRight", () => eff.O.map(bDefParentParent, (d) => d.right)),
-            eff.O.exists(({ aRight, bRight }) => AST3__namespace.isNodeEqual(aRight, bRight))
-          );
+        case (aDefParentParent?.type === types.AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === types.AST_NODE_TYPES.ForOfStatement): {
+          const aLeft = aDefParentParent.left;
+          const bLeft = bDefParentParent.left;
+          if (aLeft.type !== bLeft.type) {
+            return false;
+          }
+          const aRight = aDefParentParent.right;
+          const bRight = bDefParentParent.right;
+          return AST3__namespace.isNodeEqual(aRight, bRight);
         }
         default: {
-          return eff.O.isSome(aVar) && eff.O.isSome(bVar) && aVar.value === bVar.value;
+          return aVar !== eff._ && bVar !== eff._ && aVar === bVar;
         }
       }
     }
@@ -207,20 +186,14 @@ function isNodeValueEqual(a, b, initialScopes) {
       if (aScope.block === bScope.block) {
         return true;
       }
-      return eff.F.pipe(
-        eff.O.Do,
-        eff.O.bind("aFunction", () => AST3__namespace.findParentNode(a, AST3__namespace.isOneOf(thisBlockTypes))),
-        eff.O.bind("bFunction", () => AST3__namespace.findParentNode(b, AST3__namespace.isOneOf(thisBlockTypes))),
-        eff.O.exists(({ aFunction, bFunction }) => aFunction === bFunction)
-      );
+      const aFunction = AST3__namespace.findParentNode(a, AST3__namespace.isOneOf(thisBlockTypes));
+      const bFunction = AST3__namespace.findParentNode(b, AST3__namespace.isOneOf(thisBlockTypes));
+      return aFunction === bFunction;
     }
     default: {
-      return eff.F.pipe(
-        eff.O.Do,
-        eff.O.bind("aStatic", () => getStaticValue2(a, aScope)),
-        eff.O.bind("bStatic", () => getStaticValue2(b, bScope)),
-        eff.O.exists(({ aStatic, bStatic }) => aStatic === bStatic)
-      );
+      const aStatic = toResolved({ kind: "lazy", node: a, initialScope: aScope });
+      const bStatic = toResolved({ kind: "lazy", node: b, initialScope: bScope });
+      return aStatic.kind !== "none" && bStatic.kind !== "none" && aStatic.value === bStatic.value;
     }
   }
 }
@@ -229,6 +202,7 @@ var ValueConstructionHint = {
   StrictCallExpression: 1n << 0n
 };
 function getValueConstruction(node, initialScope, hint = ValueConstructionHint.None) {
+  if (node === eff._) return eff._;
   switch (node.type) {
     case types.AST_NODE_TYPES.JSXElement:
     case types.AST_NODE_TYPES.JSXFragment: {
@@ -254,61 +228,44 @@ function getValueConstruction(node, initialScope, hint = ValueConstructionHint.N
       if (hint & ValueConstructionHint.StrictCallExpression) {
         return { kind: "CallExpression", node };
       }
-      return { kind: "None", node };
+      return eff._;
     }
     case types.AST_NODE_TYPES.MemberExpression: {
-      if (!("object" in node)) {
-        return { kind: "None", node };
-      }
+      if (!("object" in node)) return eff._;
       return getValueConstruction(node.object, initialScope, hint);
     }
     case types.AST_NODE_TYPES.AssignmentExpression:
     case types.AST_NODE_TYPES.AssignmentPattern: {
-      if (!("right" in node)) {
-        return { kind: "None", node };
-      }
+      if (!("right" in node)) return eff._;
       return getValueConstruction(node.right, initialScope, hint);
     }
     case types.AST_NODE_TYPES.LogicalExpression: {
       const lvc = getValueConstruction(node.left, initialScope, hint);
-      if (lvc.kind !== "None") {
-        return lvc;
-      }
+      if (lvc === eff._) return eff._;
       return getValueConstruction(node.right, initialScope, hint);
     }
     case types.AST_NODE_TYPES.ConditionalExpression: {
       const cvc = getValueConstruction(node.consequent, initialScope, hint);
-      if (cvc.kind !== "None") {
-        return cvc;
-      }
+      if (cvc === eff._) return eff._;
       return getValueConstruction(node.alternate, initialScope, hint);
     }
     case types.AST_NODE_TYPES.Identifier: {
-      if (!("name" in node && eff.isString(node.name))) {
-        return { kind: "None", node };
-      }
-      const construction = eff.F.pipe(
-        eff.O.fromNullable(initialScope.set.get(node.name)),
-        eff.O.flatMap(getVariableNode(-1)),
-        eff.O.map((node2) => getValueConstruction(node2, initialScope, hint)),
-        eff.O.filter((vc) => vc.kind !== "None")
-      );
-      if (eff.O.isNone(construction)) {
-        return { kind: "None", node };
+      if (!("name" in node && typeof node.name === "string")) {
+        return eff._;
       }
-      return {
-        ...construction.value
-      };
+      const variable = initialScope.set.get(node.name);
+      const variableNode = getVariableNode(variable, -1);
+      return getValueConstruction(variableNode, initialScope, hint);
     }
     case types.AST_NODE_TYPES.Literal: {
       if ("regex" in node) {
         return { kind: "RegExpLiteral", node };
       }
-      return { kind: "None", node };
+      return eff._;
     }
     default: {
-      if (!("expression" in node && eff.isObject(node.expression))) {
-        return { kind: "None", node };
+      if (!("expression" in node && typeof node.expression === "object")) {
+        return eff._;
       }
       return getValueConstruction(node.expression, initialScope, hint);
     }
@@ -318,11 +275,10 @@ function getValueConstruction(node, initialScope, hint = ValueConstructionHint.N
 exports.ValueConstructionHint = ValueConstructionHint;
 exports.findVariable = findVariable2;
 exports.getChidScopes = getChidScopes;
-exports.getScope = getScope;
-exports.getStaticValue = getStaticValue2;
 exports.getValueConstruction = getValueConstruction;
-exports.getVariableDeclaratorID = getVariableDeclaratorID;
+exports.getVariableDeclaratorId = getVariableDeclaratorId;
 exports.getVariableNode = getVariableNode;
 exports.getVariables = getVariables;
 exports.isInitializedFromSource = isInitializedFromSource;
 exports.isNodeValueEqual = isNodeValueEqual;
+exports.toResolved = toResolved;

package/dist/index.mjs CHANGED Viewed

@@ -1,69 +1,53 @@
-import { F, O, isObject, isString } from '@eslint-react/eff';
+import { dual, _ } from '@eslint-react/eff';
 import * as ASTUtils from '@typescript-eslint/utils/ast-utils';
+import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import * as AST3 from '@eslint-react/ast';
 import { DefinitionType, ScopeType } from '@typescript-eslint/scope-manager';
 // src/find-variable.ts
-var findVariable2 = F.dual(2, (nameOrNode, initialScope) => {
-  return O.fromNullable(ASTUtils.findVariable(initialScope, nameOrNode));
+var findVariable2 = dual(2, (nameOrNode, initialScope) => {
+  if (nameOrNode === _) return _;
+  return ASTUtils.findVariable(initialScope, nameOrNode) ?? _;
 });
 // src/get-child-scopes.ts
-function getChidScopes(scope, prev = []) {
-  return [scope, ...scope.childScopes.reduce((acc, prev2) => getChidScopes(prev2, [...acc, prev2]), prev)];
-}
-function getScope(node, scopeManager) {
-  const { type, parent } = node;
-  const inner = type !== AST_NODE_TYPES.Program;
-  const scope = scopeManager.acquire(node, inner);
-  if (scope != null) {
-    return scope;
-  }
-  if (parent != null) {
-    return getScope(parent, scopeManager);
+function getChidScopes(scope) {
+  const scopes = [scope];
+  for (const childScope of scope.childScopes) {
+    scopes.push(...getChidScopes(childScope));
   }
-  return null;
-}
-function getStaticValue2(node, initialScope) {
-  return F.pipe(
-    O.fromNullable(ASTUtils.getStaticValue(node, initialScope)),
-    O.map((v) => v.value)
-  );
+  return scopes;
 }
-function getVariableDeclaratorID(node, prev) {
+function getVariableDeclaratorId(node, prev) {
+  if (node === _) return _;
   switch (true) {
     case (node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev):
-      return O.some(node.id);
+      return node.id;
     case (node.type === AST_NODE_TYPES.AssignmentExpression && node.right === prev):
-      return O.some(node.left);
+      return node.left;
     case (node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node):
-      return O.none();
+      return _;
     default:
-      return getVariableDeclaratorID(node.parent, node);
+      return getVariableDeclaratorId(node.parent, node);
   }
 }
-function getVariableNode(at) {
-  return (variable) => {
-    return F.pipe(
-      O.some(variable),
-      O.flatMapNullable((v) => v.defs.at(at)),
-      O.flatMapNullable((def) => {
-        switch (true) {
-          case (def.type === DefinitionType.FunctionName && def.node.type === AST_NODE_TYPES.FunctionDeclaration):
-            return def.node;
-          case (def.type === DefinitionType.ClassName && def.node.type === AST_NODE_TYPES.ClassDeclaration):
-            return def.node;
-          case (def.type === DefinitionType.Parameter && AST3.isFunction(def.node)):
-            return def.node;
-          case ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)):
-            return def.node.init;
-          default:
-            return null;
-        }
-      })
-    );
-  };
+function getVariableNode(variable, at) {
+  if (variable === _) return _;
+  const def = variable.defs.at(at);
+  if (def === _) return _;
+  switch (true) {
+    case (def.type === DefinitionType.FunctionName && def.node.type === AST_NODE_TYPES.FunctionDeclaration):
+      return def.node;
+    case (def.type === DefinitionType.ClassName && def.node.type === AST_NODE_TYPES.ClassDeclaration):
+      return def.node;
+    case (def.type === DefinitionType.Parameter && AST3.isFunction(def.node)):
+      return def.node;
+    case ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)):
+      return def.node.init;
+    default:
+      return _;
+  }
 }
 function getVariables(initialScope) {
   let scope = initialScope;
@@ -75,11 +59,9 @@ function getVariables(initialScope) {
   return variables.reverse();
 }
 function isInitializedFromSource(name, source, initialScope) {
-  const latestDef = O.flatMapNullable(findVariable2(name, initialScope), (v) => v.defs.at(-1));
-  if (O.isNone(latestDef)) {
-    return false;
-  }
-  const { node, parent } = latestDef.value;
+  const latestDef = findVariable2(name, initialScope)?.defs.at(-1);
+  if (latestDef === _) return false;
+  const { node, parent } = latestDef;
   if (node.type === AST_NODE_TYPES.VariableDeclarator && node.init != null) {
     const { init } = node;
     if (init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier) {
@@ -88,13 +70,12 @@ function isInitializedFromSource(name, source, initialScope) {
     if (init.type === AST_NODE_TYPES.Identifier) {
       return isInitializedFromSource(init.name, source, initialScope);
     }
-    return F.pipe(
-      getRequireExpressionArguments(init),
-      O.flatMapNullable((args) => args[0]),
-      O.filter(AST3.isStringLiteral),
-      // check for: `require('source')` or `require('source/...')`
-      O.exists((arg) => arg.value === source || arg.value.startsWith(`${source}/`))
-    );
+    const args = getRequireExpressionArguments(init);
+    const arg0 = args?.[0];
+    if (arg0 == null || !AST3.isStringLiteral(arg0)) {
+      return false;
+    }
+    return arg0.value === source || arg0.value.startsWith(`${source}/`);
   }
   return parent?.type === AST_NODE_TYPES.ImportDeclaration && parent.source.value === source;
 }
@@ -102,15 +83,25 @@ function getRequireExpressionArguments(node) {
   switch (true) {
     // require('source')
     case (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === "require"): {
-      return O.some(node.arguments);
+      return node.arguments;
     }
     // require('source').variable
     case node.type === AST_NODE_TYPES.MemberExpression: {
       return getRequireExpressionArguments(node.object);
     }
   }
-  return O.none();
+  return _;
 }
+function toResolved(sv) {
+  const { kind, node, initialScope } = sv;
+  if (kind !== "lazy") {
+    return sv;
+  }
+  const resolvedValue = initialScope === _ ? getStaticValue(node) : getStaticValue(node, initialScope);
+  return resolvedValue == null ? { kind: "none", node, initialScope } : { kind: "some", node, initialScope, value: resolvedValue.value };
+}
+// src/is-node-value-equal.ts
 var thisBlockTypes = [
   AST_NODE_TYPES.FunctionDeclaration,
   AST_NODE_TYPES.FunctionExpression,
@@ -132,48 +123,37 @@ function isNodeValueEqual(a, b, initialScopes) {
     case (a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier): {
       const aVar = findVariable2(a, aScope);
       const bVar = findVariable2(b, bScope);
-      const aVarNode = O.flatMap(aVar, getVariableNode(0));
-      const bVarNode = O.flatMap(bVar, getVariableNode(0));
-      const aVarNodeParent = O.flatMapNullable(aVarNode, (n) => n.parent);
-      const bVarNodeParent = O.flatMapNullable(bVarNode, (n) => n.parent);
-      const aDef = O.flatMapNullable(aVar, (v) => v.defs.at(0));
-      const bDef = O.flatMapNullable(bVar, (v) => v.defs.at(0));
-      const aDefParentParent = O.flatMapNullable(aDef, (d) => d.parent?.parent);
-      const bDefParentParent = O.flatMapNullable(bDef, (d) => d.parent?.parent);
+      const aVarNode = getVariableNode(aVar, 0);
+      const bVarNode = getVariableNode(bVar, 0);
+      const aVarNodeParent = aVarNode?.parent;
+      const bVarNodeParent = bVarNode?.parent;
+      const aDef = aVar?.defs.at(0);
+      const bDef = bVar?.defs.at(0);
+      const aDefParentParent = aDef?.parent?.parent;
+      const bDefParentParent = bDef?.parent?.parent;
       switch (true) {
-        case (O.exists(aVarNodeParent, AST3.is(AST_NODE_TYPES.CallExpression)) && O.exists(bVarNodeParent, AST3.is(AST_NODE_TYPES.CallExpression)) && O.exists(aVarNode, AST3.isFunction) && O.exists(bVarNode, AST3.isFunction)): {
-          const hasSameCallee = F.pipe(
-            O.Do,
-            O.bind("aCallee", () => O.map(aVarNodeParent, (n) => n.callee)),
-            O.bind("bCallee", () => O.map(bVarNodeParent, (n) => n.callee)),
-            O.exists(({ aCallee, bCallee }) => AST3.isNodeEqual(aCallee, bCallee))
-          );
-          if (!hasSameCallee) {
+        case (aVarNodeParent?.type === AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === AST_NODE_TYPES.CallExpression && AST3.isFunction(aVarNode) && AST3.isFunction(bVarNode)): {
+          if (!AST3.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) {
             return false;
           }
-          return F.pipe(
-            O.Do,
-            O.bind("aParams", () => O.map(aVarNode, (n) => n.params)),
-            O.bind("bParams", () => O.map(bVarNode, (n) => n.params)),
-            O.let("aPos", ({ aParams }) => aParams.findIndex(AST3.isNodeEqual(a))),
-            O.let("bPos", ({ bParams }) => bParams.findIndex(AST3.isNodeEqual(b))),
-            O.filter(({ aPos, bPos }) => aPos !== -1 && bPos !== -1),
-            O.exists(({ aPos, bPos }) => aPos === bPos)
-          );
+          const aParams = aVarNode.params;
+          const bParams = bVarNode.params;
+          const aPos = aParams.findIndex((x) => AST3.isNodeEqual(x, a));
+          const bPos = bParams.findIndex((x) => AST3.isNodeEqual(x, b));
+          return aPos !== -1 && bPos !== -1 && aPos === bPos;
         }
-        case (O.exists(aDefParentParent, AST3.is(AST_NODE_TYPES.ForOfStatement)) && O.exists(bDefParentParent, AST3.is(AST_NODE_TYPES.ForOfStatement))): {
-          return F.pipe(
-            O.Do,
-            O.bind("aLeft", () => O.map(aDefParentParent, (d) => d.left)),
-            O.bind("bLeft", () => O.map(bDefParentParent, (d) => d.left)),
-            O.filter(({ aLeft, bLeft }) => aLeft.type === bLeft.type),
-            O.bind("aRight", () => O.map(aDefParentParent, (d) => d.right)),
-            O.bind("bRight", () => O.map(bDefParentParent, (d) => d.right)),
-            O.exists(({ aRight, bRight }) => AST3.isNodeEqual(aRight, bRight))
-          );
+        case (aDefParentParent?.type === AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === AST_NODE_TYPES.ForOfStatement): {
+          const aLeft = aDefParentParent.left;
+          const bLeft = bDefParentParent.left;
+          if (aLeft.type !== bLeft.type) {
+            return false;
+          }
+          const aRight = aDefParentParent.right;
+          const bRight = bDefParentParent.right;
+          return AST3.isNodeEqual(aRight, bRight);
         }
         default: {
-          return O.isSome(aVar) && O.isSome(bVar) && aVar.value === bVar.value;
+          return aVar !== _ && bVar !== _ && aVar === bVar;
         }
       }
     }
@@ -184,20 +164,14 @@ function isNodeValueEqual(a, b, initialScopes) {
       if (aScope.block === bScope.block) {
         return true;
       }
-      return F.pipe(
-        O.Do,
-        O.bind("aFunction", () => AST3.findParentNode(a, AST3.isOneOf(thisBlockTypes))),
-        O.bind("bFunction", () => AST3.findParentNode(b, AST3.isOneOf(thisBlockTypes))),
-        O.exists(({ aFunction, bFunction }) => aFunction === bFunction)
-      );
+      const aFunction = AST3.findParentNode(a, AST3.isOneOf(thisBlockTypes));
+      const bFunction = AST3.findParentNode(b, AST3.isOneOf(thisBlockTypes));
+      return aFunction === bFunction;
     }
     default: {
-      return F.pipe(
-        O.Do,
-        O.bind("aStatic", () => getStaticValue2(a, aScope)),
-        O.bind("bStatic", () => getStaticValue2(b, bScope)),
-        O.exists(({ aStatic, bStatic }) => aStatic === bStatic)
-      );
+      const aStatic = toResolved({ kind: "lazy", node: a, initialScope: aScope });
+      const bStatic = toResolved({ kind: "lazy", node: b, initialScope: bScope });
+      return aStatic.kind !== "none" && bStatic.kind !== "none" && aStatic.value === bStatic.value;
     }
   }
 }
@@ -206,6 +180,7 @@ var ValueConstructionHint = {
   StrictCallExpression: 1n << 0n
 };
 function getValueConstruction(node, initialScope, hint = ValueConstructionHint.None) {
+  if (node === _) return _;
   switch (node.type) {
     case AST_NODE_TYPES.JSXElement:
     case AST_NODE_TYPES.JSXFragment: {
@@ -231,65 +206,48 @@ function getValueConstruction(node, initialScope, hint = ValueConstructionHint.N
       if (hint & ValueConstructionHint.StrictCallExpression) {
         return { kind: "CallExpression", node };
       }
-      return { kind: "None", node };
+      return _;
     }
     case AST_NODE_TYPES.MemberExpression: {
-      if (!("object" in node)) {
-        return { kind: "None", node };
-      }
+      if (!("object" in node)) return _;
       return getValueConstruction(node.object, initialScope, hint);
     }
     case AST_NODE_TYPES.AssignmentExpression:
     case AST_NODE_TYPES.AssignmentPattern: {
-      if (!("right" in node)) {
-        return { kind: "None", node };
-      }
+      if (!("right" in node)) return _;
       return getValueConstruction(node.right, initialScope, hint);
     }
     case AST_NODE_TYPES.LogicalExpression: {
       const lvc = getValueConstruction(node.left, initialScope, hint);
-      if (lvc.kind !== "None") {
-        return lvc;
-      }
+      if (lvc === _) return _;
       return getValueConstruction(node.right, initialScope, hint);
     }
     case AST_NODE_TYPES.ConditionalExpression: {
       const cvc = getValueConstruction(node.consequent, initialScope, hint);
-      if (cvc.kind !== "None") {
-        return cvc;
-      }
+      if (cvc === _) return _;
       return getValueConstruction(node.alternate, initialScope, hint);
     }
     case AST_NODE_TYPES.Identifier: {
-      if (!("name" in node && isString(node.name))) {
-        return { kind: "None", node };
-      }
-      const construction = F.pipe(
-        O.fromNullable(initialScope.set.get(node.name)),
-        O.flatMap(getVariableNode(-1)),
-        O.map((node2) => getValueConstruction(node2, initialScope, hint)),
-        O.filter((vc) => vc.kind !== "None")
-      );
-      if (O.isNone(construction)) {
-        return { kind: "None", node };
+      if (!("name" in node && typeof node.name === "string")) {
+        return _;
       }
-      return {
-        ...construction.value
-      };
+      const variable = initialScope.set.get(node.name);
+      const variableNode = getVariableNode(variable, -1);
+      return getValueConstruction(variableNode, initialScope, hint);
     }
     case AST_NODE_TYPES.Literal: {
       if ("regex" in node) {
         return { kind: "RegExpLiteral", node };
       }
-      return { kind: "None", node };
+      return _;
     }
     default: {
-      if (!("expression" in node && isObject(node.expression))) {
-        return { kind: "None", node };
+      if (!("expression" in node && typeof node.expression === "object")) {
+        return _;
       }
       return getValueConstruction(node.expression, initialScope, hint);
     }
   }
 }
-export { ValueConstructionHint, findVariable2 as findVariable, getChidScopes, getScope, getStaticValue2 as getStaticValue, getValueConstruction, getVariableDeclaratorID, getVariableNode, getVariables, isInitializedFromSource, isNodeValueEqual };
+export { ValueConstructionHint, findVariable2 as findVariable, getChidScopes, getValueConstruction, getVariableDeclaratorId, getVariableNode, getVariables, isInitializedFromSource, isNodeValueEqual, toResolved };

package/package.json CHANGED Viewed

@@ -1,14 +1,14 @@
 {
   "name": "@eslint-react/var",
-  "version": "1.23.3-next.8",
+  "version": "1.24.0-next.0",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables",
-  "homepage": "https://github.com/rEl1cx/eslint-react",
+  "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
-    "url": "https://github.com/rEl1cx/eslint-react/issues"
+    "url": "https://github.com/Rel1cx/eslint-react/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/rEl1cx/eslint-react.git",
+    "url": "git+https://github.com/Rel1cx/eslint-react.git",
     "directory": "packages/utilities/var"
   },
   "license": "MIT",
@@ -38,9 +38,9 @@
     "@typescript-eslint/utils": "^8.19.1",
     "string-ts": "^2.2.0",
     "ts-pattern": "^5.6.0",
-    "@eslint-react/ast": "1.23.3-next.8",
-    "@eslint-react/eff": "1.23.3-next.8",
-    "@eslint-react/types": "1.23.3-next.8"
+    "@eslint-react/ast": "1.24.0-next.0",
+    "@eslint-react/types": "1.24.0-next.0",
+    "@eslint-react/eff": "1.24.0-next.0"
   },
   "devDependencies": {
     "tsup": "^8.3.5",