@eslint-react/var 3.0.0-next.6 → 3.0.0-next.61

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { TSESTree } from "@typescript-eslint/types";
 import { Scope, Variable } from "@typescript-eslint/scope-manager";
 import { RuleContext } from "@eslint-react/shared";
 
-//#region src/var-assignment-target.d.ts
+//#region src/find-enclosing-assignment-target.d.ts
 /**
  * Finds the enclosing assignment target (variable, property, etc.) for a given node
  *
@@ -16,54 +16,23 @@ declare function findEnclosingAssignmentTarget(node: TSESTree.Node): TSESTree.Ar
  * Type representing the possible assignment targets returned by `findEnclosingAssignmentTarget`
  */
 type AssignmentTarget = ReturnType<typeof findEnclosingAssignmentTarget>;
-/**
- * Check if two assignment targets are equal
- * Compares nodes directly or by their values
- * @param context The rule context
- * @param a The first node to compare
- * @param b The second node to compare
- * @returns True if the assignment targets are equal
- * @internal
- */
-declare function isAssignmentTargetEqual(context: RuleContext, a: TSESTree.Node, b: TSESTree.Node): boolean;
-//#endregion
-//#region src/var-definition.d.ts
-/**
- * Get the definition node of a variable at a specific definition index
- * @param variable The variable to get the definition node from
- * @param at The index of the definition to retrieve (negative index supported)
- * @returns The definition node or unit if not found
- */
-declare function getVariableDefinitionNode(variable: Variable | unit, at: number): unit | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
-/**
- * Get the definition node of a variable at a specific definition index (loose version)
- * Also returns the function node if the definition is a parameter
- * @param variable The variable to get the definition node from
- * @param at The index of the definition to retrieve
- * @returns The definition node or unit if not found
- */
-declare function getVariableDefinitionNodeLoose(variable: Variable | unit, at: number): unit | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
 //#endregion
-//#region src/var-import-source.d.ts
+//#region src/find-variable.d.ts
 /**
- * Find the import source of a variable
- * @param name The variable name
- * @param initialScope The initial scope to search
- * @returns The import source or undefined if not found
- */
-declare function findImportSource(name: string, initialScope: Scope): string | undefined;
-//#endregion
-//#region src/var-node-equality.d.ts
-/**
- * Determine whether node value equals to another node value
- * @param a node to compare
- * @param b node to compare
- * @param initialScopes initial scopes of the two nodes
- * @returns `true` if node value equal
+ * Find a variable by name or identifier node in the scope chain
+ * @param initialScope The scope to start searching from
+ * @returns The found variable or unit if not found
+ * @overload
+ * @param nameOrNode The variable name or identifier node to find
+ * @param initialScope The scope to start searching from
+ * @returns The found variable or unit if not found
  */
-declare function isNodeEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [aScope: Scope, bScope: Scope]): boolean;
+declare const findVariable: {
+  (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | unit) => Variable | unit;
+  (nameOrNode: string | TSESTree.Identifier | unit, initialScope: Scope): Variable | unit;
+};
 //#endregion
-//#region src/var-object-type.d.ts
+//#region src/get-object-type.d.ts
 /**
  * Represents the type classification of an object node
  */
@@ -101,43 +70,26 @@ type ObjectType = {
  */
 declare function getObjectType(node: TSESTree.Node | unit, initialScope: Scope): ObjectType | unit;
 //#endregion
-//#region src/var-property.d.ts
+//#region src/is-assignment-target-equal.d.ts
 /**
- * Find a property by name in an array of properties
- * Handles spread elements by recursively resolving the referenced object
- * @param name The property name to find
- * @param properties The array of properties to search
- * @param initialScope The scope to use for variable resolution
- * @param seen Set of already seen variable names to prevent circular references
- * @returns The found property or unit if not found
+ * Check if two assignment targets are equal
+ * Compares nodes directly or by their values
+ * @param context The rule context
+ * @param a The first node to compare
+ * @param b The second node to compare
+ * @returns True if the assignment targets are equal
+ * @internal
  */
-declare function findProperty(name: string, properties: (TSESTree.Property | TSESTree.RestElement | TSESTree.SpreadElement)[], initialScope: Scope, seen?: Set<string>): (typeof properties)[number] | unit;
+declare function isAssignmentTargetEqual(context: RuleContext, a: TSESTree.Node, b: TSESTree.Node): boolean;
 //#endregion
-//#region src/var-scope.d.ts
-/**
- * Get all variables from the given scope up to the global scope
- * @param initialScope The scope to start from
- * @returns All variables from the given scope up to the global scope
- */
-declare function getVariables(initialScope: Scope): Variable[];
+//#region src/is-value-equal.d.ts
 /**
- * Find a variable by name or identifier node in the scope chain
- * @param initialScope The scope to start searching from
- * @returns The found variable or unit if not found
- * @overload
- * @param nameOrNode The variable name or identifier node to find
- * @param initialScope The scope to start searching from
- * @returns The found variable or unit if not found
- */
-declare const findVariable: {
-  (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | unit) => Variable | unit;
-  (nameOrNode: string | TSESTree.Identifier | unit, initialScope: Scope): Variable | unit;
-};
-/**
- * Get all child scopes recursively from a given scope
- * @param scope The scope to get child scopes from
- * @returns Array of all child scopes including the input scope
+ * Determine whether node value equals to another node value
+ * @param a node to compare
+ * @param b node to compare
+ * @param initialScopes initial scopes of the two nodes
+ * @returns `true` if node value equal
  */
-declare function getChildScopes(scope: Scope): readonly Scope[];
+declare function isValueEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [aScope: Scope, bScope: Scope]): boolean;
 //#endregion
-export { AssignmentTarget, ObjectType, findEnclosingAssignmentTarget, findImportSource, findProperty, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, getVariableDefinitionNodeLoose, getVariables, isAssignmentTargetEqual, isNodeEqual };
+export { AssignmentTarget, ObjectType, findEnclosingAssignmentTarget, findVariable, getObjectType, isAssignmentTargetEqual, isValueEqual };

package/dist/index.js

@@ -1,154 +1,11 @@
-import * as ast from "@eslint-react/ast";
-import { dual, identity, unit } from "@eslint-react/eff";
+import { dual, unit } from "@eslint-react/eff";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import * as astUtils from "@typescript-eslint/utils/ast-utils";
 import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
-import { P, match } from "ts-pattern";
-
-//#region src/var-definition.ts
-/**
-* Get the definition node of a variable at a specific definition index
-* @param variable The variable to get the definition node from
-* @param at The index of the definition to retrieve (negative index supported)
-* @returns The definition node or unit if not found
-*/
-function getVariableDefinitionNode(variable, at) {
-	if (variable == null) return unit;
-	const def = variable.defs.at(at);
-	if (def == null) return unit;
-	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 "init" in def.node && def.node.init != null && !("declarations" in def.node.init): return def.node.init;
-		default: return unit;
-	}
-}
-/**
-* Get the definition node of a variable at a specific definition index (loose version)
-* Also returns the function node if the definition is a parameter
-* @param variable The variable to get the definition node from
-* @param at The index of the definition to retrieve
-* @returns The definition node or unit if not found
-*/
-function getVariableDefinitionNodeLoose(variable, at) {
-	if (variable == null) return unit;
-	const node = getVariableDefinitionNode(variable, at);
-	if (node != null) return node;
-	const def = variable.defs.at(at);
-	if (def?.type === DefinitionType.Parameter && ast.isFunction(def.node)) return def.node;
-	return unit;
-}
-
-//#endregion
-//#region src/var-scope.ts
-/**
-* Get all variables from the given scope up to the global scope
-* @param initialScope The scope to start from
-* @returns All variables from the given scope up to the global scope
-*/
-function getVariables(initialScope) {
-	let scope = initialScope;
-	const variables = [...scope.variables];
-	while (scope.type !== ScopeType.global) {
-		scope = scope.upper;
-		variables.push(...scope.variables);
-	}
-	return variables.reverse();
-}
-/**
-* Find a variable by name or identifier node in the scope chain
-* @param initialScope The scope to start searching from
-* @returns The found variable or unit if not found
-* @overload
-* @param nameOrNode The variable name or identifier node to find
-* @param initialScope The scope to start searching from
-* @returns The found variable or unit if not found
-*/
-const findVariable = dual(2, (nameOrNode, initialScope) => {
-	if (nameOrNode == null) return unit;
-	return astUtils.findVariable(initialScope, nameOrNode) ?? unit;
-});
-/**
-* Get all child scopes recursively from a given scope
-* @param scope The scope to get child scopes from
-* @returns Array of all child scopes including the input scope
-*/
-function getChildScopes(scope) {
-	const scopes = [scope];
-	for (const childScope of scope.childScopes) scopes.push(...getChildScopes(childScope));
-	return scopes;
-}
-
-//#endregion
-//#region src/var-node-equality.ts
-const thisBlockTypes = [
-	AST_NODE_TYPES.FunctionDeclaration,
-	AST_NODE_TYPES.FunctionExpression,
-	AST_NODE_TYPES.ClassBody,
-	AST_NODE_TYPES.Program
-];
-/**
-* Determine whether node value equals to another node value
-* @param a node to compare
-* @param b node to compare
-* @param initialScopes initial scopes of the two nodes
-* @returns `true` if node value equal
-*/
-function isNodeEqual(a, b, initialScopes) {
-	a = ast.isTypeExpression(a) ? ast.getUnderlyingExpression(a) : a;
-	b = ast.isTypeExpression(b) ? ast.getUnderlyingExpression(b) : b;
-	const [aScope, bScope] = initialScopes;
-	switch (true) {
-		case a === b: return true;
-		case a.type === AST_NODE_TYPES.Literal && b.type === AST_NODE_TYPES.Literal: return a.value === b.value;
-		case a.type === AST_NODE_TYPES.TemplateElement && b.type === AST_NODE_TYPES.TemplateElement: return a.value.cooked === b.value.cooked;
-		case a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier: {
-			const aVar = findVariable(a, aScope);
-			const bVar = findVariable(b, bScope);
-			const aVarNode = getVariableDefinitionNodeLoose(aVar, 0);
-			const bVarNode = getVariableDefinitionNodeLoose(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 aVarNodeParent?.type === AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === AST_NODE_TYPES.CallExpression && ast.isFunction(aVarNode) && ast.isFunction(bVarNode): {
-					if (!ast.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) return false;
-					const aParams = aVarNode.params;
-					const bParams = bVarNode.params;
-					const aPos = aParams.findIndex((x) => ast.isNodeEqual(x, a));
-					const bPos = bParams.findIndex((x) => ast.isNodeEqual(x, b));
-					return aPos !== -1 && bPos !== -1 && aPos === bPos;
-				}
-				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 ast.isNodeEqual(aRight, bRight);
-				}
-				default: return aVar != null && bVar != null && aVar === bVar;
-			}
-		}
-		case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return ast.isNodeEqual(a.property, b.property) && isNodeEqual(a.object, b.object, initialScopes);
-		case a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression:
-			if (aScope.block === bScope.block) return true;
-			return ast.findParentNode(a, ast.isOneOf(thisBlockTypes)) === ast.findParentNode(b, ast.isOneOf(thisBlockTypes));
-		default: {
-			const aStatic = getStaticValue(a, aScope);
-			const bStatic = getStaticValue(b, bScope);
-			return aStatic != null && bStatic != null && aStatic.value === bStatic.value;
-		}
-	}
-}
+import { DefinitionType } from "@typescript-eslint/scope-manager";
+import * as ast from "@eslint-react/ast";
 
-//#endregion
-//#region src/var-assignment-target.ts
-/** eslint-disable jsdoc/require-param */
+//#region src/find-enclosing-assignment-target.ts
 /**
 * Finds the enclosing assignment target (variable, property, etc.) for a given node
 *
@@ -165,63 +22,25 @@ function findEnclosingAssignmentTarget(node) {
 		default: return findEnclosingAssignmentTarget(node.parent);
 	}
 }
-/**
-* Check if two assignment targets are equal
-* Compares nodes directly or by their values
-* @param context The rule context
-* @param a The first node to compare
-* @param b The second node to compare
-* @returns True if the assignment targets are equal
-* @internal
-*/
-function isAssignmentTargetEqual(context, a, b) {
-	return ast.isNodeEqual(a, b) || isNodeEqual(a, b, [context.sourceCode.getScope(a), context.sourceCode.getScope(b)]);
-}
 
 //#endregion
-//#region src/var-import-source.ts
+//#region src/find-variable.ts
 /**
-* Get the arguments of a require expression
-* @param node The node to match
-* @returns The require expression arguments or undefined if the node is not a require expression
-*/
-function getRequireExpressionArguments(node) {
-	return match(node).with({
-		type: AST_NODE_TYPES.CallExpression,
-		arguments: P.select(),
-		callee: {
-			type: AST_NODE_TYPES.Identifier,
-			name: "require"
-		}
-	}, identity).with({
-		type: AST_NODE_TYPES.MemberExpression,
-		object: P.select()
-	}, getRequireExpressionArguments).otherwise(() => null);
-}
-/**
-* Find the import source of a variable
-* @param name The variable name
-* @param initialScope The initial scope to search
-* @returns The import source or undefined if not found
+* Find a variable by name or identifier node in the scope chain
+* @param initialScope The scope to start searching from
+* @returns The found variable or unit if not found
+* @overload
+* @param nameOrNode The variable name or identifier node to find
+* @param initialScope The scope to start searching from
+* @returns The found variable or unit if not found
 */
-function findImportSource(name, initialScope) {
-	const latestDef = findVariable(name, initialScope)?.defs.at(-1);
-	if (latestDef == null) return unit;
-	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) return findImportSource(init.object.name, initialScope);
-		if (init.type === AST_NODE_TYPES.Identifier) return findImportSource(init.name, initialScope);
-		const arg0 = getRequireExpressionArguments(init)?.[0];
-		if (arg0 == null || !ast.isLiteral(arg0, "string")) return unit;
-		return arg0.value;
-	}
-	if (parent?.type === AST_NODE_TYPES.ImportDeclaration) return parent.source.value;
-	return unit;
-}
+const findVariable = dual(2, (nameOrNode, initialScope) => {
+	if (nameOrNode == null) return unit;
+	return astUtils.findVariable(initialScope, nameOrNode) ?? unit;
+});
 
 //#endregion
-//#region src/var-object-type.ts
+//#region src/get-object-type.ts
 /**
 * Detect the ObjectType of a given node
 * @param node The node to check
@@ -265,9 +84,20 @@ function getObjectType(node, initialScope) {
 				node
 			};
 			return unit;
-		case AST_NODE_TYPES.Identifier:
-			if (!("name" in node) || typeof node.name !== "string") return unit;
-			return getObjectType(getVariableDefinitionNode(initialScope.set.get(node.name), -1), initialScope);
+		case AST_NODE_TYPES.Identifier: {
+			function resolve(v) {
+				if (v == null) return unit;
+				const def = v.defs.at(-1);
+				if (def == null) return unit;
+				if (def.type === DefinitionType.Variable) return def.node.init;
+				if (def.type === DefinitionType.Parameter) return unit;
+				if (def.type === DefinitionType.ImportBinding) return unit;
+				return def.node;
+			}
+			const initNode = resolve(initialScope.set.get(node.name));
+			if (initNode == null) return unit;
+			return getObjectType(initNode, initialScope);
+		}
 		case AST_NODE_TYPES.MemberExpression:
 			if (!("object" in node)) return unit;
 			return getObjectType(node.object, initialScope);
@@ -292,35 +122,96 @@ function getObjectType(node, initialScope) {
 }
 
 //#endregion
-//#region src/var-property.ts
+//#region src/is-value-equal.ts
+const thisBlockTypes = [
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.FunctionExpression,
+	AST_NODE_TYPES.ClassBody,
+	AST_NODE_TYPES.Program
+];
 /**
-* Find a property by name in an array of properties
-* Handles spread elements by recursively resolving the referenced object
-* @param name The property name to find
-* @param properties The array of properties to search
-* @param initialScope The scope to use for variable resolution
-* @param seen Set of already seen variable names to prevent circular references
-* @returns The found property or unit if not found
+* Determine whether node value equals to another node value
+* @param a node to compare
+* @param b node to compare
+* @param initialScopes initial scopes of the two nodes
+* @returns `true` if node value equal
 */
-function findProperty(name, properties, initialScope, seen = /* @__PURE__ */ new Set()) {
-	return properties.findLast((prop) => {
-		if (prop.type === AST_NODE_TYPES.Property) return "name" in prop.key && prop.key.name === name;
-		if (prop.type === AST_NODE_TYPES.SpreadElement) switch (prop.argument.type) {
-			case AST_NODE_TYPES.Identifier: {
-				if (seen.has(prop.argument.name)) return false;
-				const variableNode = getVariableDefinitionNode(findVariable(prop.argument.name, initialScope), 0);
-				if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) {
-					seen.add(prop.argument.name);
-					return findProperty(name, variableNode.properties, initialScope, seen) != null;
+function isValueEqual(a, b, initialScopes) {
+	a = ast.isTypeExpression(a) ? ast.getUnderlyingExpression(a) : a;
+	b = ast.isTypeExpression(b) ? ast.getUnderlyingExpression(b) : b;
+	const [aScope, bScope] = initialScopes;
+	switch (true) {
+		case a === b: return true;
+		case a.type === AST_NODE_TYPES.Literal && b.type === AST_NODE_TYPES.Literal: return a.value === b.value;
+		case a.type === AST_NODE_TYPES.TemplateElement && b.type === AST_NODE_TYPES.TemplateElement: return a.value.cooked === b.value.cooked;
+		case a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier: {
+			const aVar = findVariable(a, aScope);
+			const bVar = findVariable(b, bScope);
+			const resolve = (variable) => {
+				if (variable == null) return unit;
+				const def = variable.defs.at(0);
+				if (def != null) 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 "init" in def.node && def.node.init != null && !("declarations" in def.node.init): return def.node.init;
 				}
-				return false;
+				if (def?.type === DefinitionType.Parameter && ast.isFunction(def.node)) return def.node;
+				return unit;
+			};
+			const aVarInit = resolve(aVar);
+			const bVarInit = resolve(bVar);
+			const aVarInitParent = aVarInit?.parent;
+			const bVarInitParent = bVarInit?.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 aVarInitParent?.type === AST_NODE_TYPES.CallExpression && bVarInitParent?.type === AST_NODE_TYPES.CallExpression && ast.isFunction(aVarInit) && ast.isFunction(bVarInit): {
+					if (!ast.isNodeEqual(aVarInitParent.callee, bVarInitParent.callee)) return false;
+					const aParams = aVarInit.params;
+					const bParams = bVarInit.params;
+					const aPos = aParams.findIndex((x) => ast.isNodeEqual(x, a));
+					const bPos = bParams.findIndex((x) => ast.isNodeEqual(x, b));
+					return aPos !== -1 && bPos !== -1 && aPos === bPos;
+				}
+				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 ast.isNodeEqual(aRight, bRight);
+				}
+				default: return aVar != null && bVar != null && aVar === bVar;
 			}
-			case AST_NODE_TYPES.ObjectExpression: return findProperty(name, prop.argument.properties, initialScope, seen) != null;
-			default: return false;
 		}
-		return false;
-	});
+		case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return ast.isNodeEqual(a.property, b.property) && isValueEqual(a.object, b.object, initialScopes);
+		case a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression:
+			if (aScope.block === bScope.block) return true;
+			return ast.findParentNode(a, ast.isOneOf(thisBlockTypes)) === ast.findParentNode(b, ast.isOneOf(thisBlockTypes));
+		default: {
+			const aStatic = getStaticValue(a, aScope);
+			const bStatic = getStaticValue(b, bScope);
+			return aStatic != null && bStatic != null && aStatic.value === bStatic.value;
+		}
+	}
+}
+
+//#endregion
+//#region src/is-assignment-target-equal.ts
+/**
+* Check if two assignment targets are equal
+* Compares nodes directly or by their values
+* @param context The rule context
+* @param a The first node to compare
+* @param b The second node to compare
+* @returns True if the assignment targets are equal
+* @internal
+*/
+function isAssignmentTargetEqual(context, a, b) {
+	return ast.isNodeEqual(a, b) || isValueEqual(a, b, [context.sourceCode.getScope(a), context.sourceCode.getScope(b)]);
 }
 
 //#endregion
-export { findEnclosingAssignmentTarget, findImportSource, findProperty, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, getVariableDefinitionNodeLoose, getVariables, isAssignmentTargetEqual, isNodeEqual };
+export { findEnclosingAssignmentTarget, findVariable, getObjectType, isAssignmentTargetEqual, isValueEqual };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/var",
-  "version": "3.0.0-next.6",
+  "version": "3.0.0-next.61",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -34,12 +34,12 @@
     "@typescript-eslint/types": "canary",
     "@typescript-eslint/utils": "canary",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-next.6",
-    "@eslint-react/eff": "3.0.0-next.6",
-    "@eslint-react/shared": "3.0.0-next.6"
+    "@eslint-react/shared": "3.0.0-next.61",
+    "@eslint-react/eff": "3.0.0-next.61",
+    "@eslint-react/ast": "3.0.0-next.61"
   },
   "devDependencies": {
-    "tsdown": "^0.20.3",
+    "tsdown": "^0.21.0-beta.2",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
@@ -52,6 +52,6 @@
   "scripts": {
     "build": "tsdown --dts-resolve",
     "lint:publish": "publint",
-    "lint:ts": "tsc --noEmit"
+    "lint:ts": "tsl"
   }
 }