@eslint-react/var 2.0.0-next.17 → 2.0.0-next.170

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 (3) hide show
  1. package/dist/index.d.ts +52 -75
  2. package/dist/index.js +227 -242
  3. package/package.json +9 -10
package/dist/index.d.ts CHANGED
@@ -1,50 +1,43 @@
1
- import { Scope, Variable } from '@typescript-eslint/scope-manager';
2
- import { TSESTree } from '@typescript-eslint/types';
3
- import { _ } from '@eslint-react/eff';
4
-
5
- /**
6
- * Get all variables from the given scope up to the global scope
7
- * @param initialScope The scope to start from
8
- * @returns All variables from the given scope up to the global scope
9
- */
10
- declare function getVariables(initialScope: Scope): Variable[];
11
- declare const findVariable: {
12
- (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | _) => Variable | _;
13
- (nameOrNode: string | TSESTree.Identifier | _, initialScope: Scope): Variable | _;
14
- };
15
- declare function findPropertyInProperties(name: string, properties: (TSESTree.Property | TSESTree.RestElement | TSESTree.SpreadElement)[], initialScope: Scope, seen?: Set<string>): (typeof properties)[number] | _;
1
+ import { TSESTree } from "@typescript-eslint/types";
2
+ import { unit } from "@eslint-react/eff";
3
+ import { Scope, Variable } from "@typescript-eslint/scope-manager";
16
4
 
5
+ //#region src/misc.d.ts
6
+ declare function getChildScopes(scope: Scope): readonly Scope[];
7
+ declare function findProperty(name: string, properties: (TSESTree.Property | TSESTree.RestElement | TSESTree.SpreadElement)[], initialScope: Scope, seen?: Set<string>): (typeof properties)[number] | unit;
8
+ //#endregion
9
+ //#region src/value-construction.d.ts
17
10
  declare const ConstructionDetectionHint: {
18
- None: bigint;
19
- StrictCallExpression: bigint;
11
+ None: bigint;
12
+ StrictCallExpression: bigint;
20
13
  };
21
14
  type Construction = {
22
- kind: "ArrayExpression";
23
- node: TSESTree.ArrayExpression;
15
+ kind: "ArrayExpression";
16
+ node: TSESTree.ArrayExpression;
24
17
  } | {
25
- kind: "CallExpression";
26
- node: TSESTree.CallExpression;
18
+ kind: "CallExpression";
19
+ node: TSESTree.CallExpression;
27
20
  } | {
28
- kind: "ClassExpression";
29
- node: TSESTree.ClassExpression;
21
+ kind: "ClassExpression";
22
+ node: TSESTree.ClassExpression;
30
23
  } | {
31
- kind: "FunctionDeclaration";
32
- node: TSESTree.FunctionDeclaration;
24
+ kind: "FunctionDeclaration";
25
+ node: TSESTree.FunctionDeclaration;
33
26
  } | {
34
- kind: "FunctionExpression";
35
- node: TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
27
+ kind: "FunctionExpression";
28
+ node: TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
36
29
  } | {
37
- kind: "JSXElement";
38
- node: TSESTree.JSXElement | TSESTree.JSXFragment;
30
+ kind: "JSXElement";
31
+ node: TSESTree.JSXElement | TSESTree.JSXFragment;
39
32
  } | {
40
- kind: "NewExpression";
41
- node: TSESTree.NewExpression;
33
+ kind: "NewExpression";
34
+ node: TSESTree.NewExpression;
42
35
  } | {
43
- kind: "ObjectExpression";
44
- node: TSESTree.ObjectExpression;
36
+ kind: "ObjectExpression";
37
+ node: TSESTree.ObjectExpression;
45
38
  } | {
46
- kind: "RegExpLiteral";
47
- node: TSESTree.RegExpLiteral;
39
+ kind: "RegExpLiteral";
40
+ node: TSESTree.RegExpLiteral;
48
41
  };
49
42
  /**
50
43
  * Detects the construction type of a given node.
@@ -53,40 +46,9 @@ type Construction = {
53
46
  * @param hint Optional hint to control the detection behavior.
54
47
  * @returns The construction type of the node, or `_` if not found.
55
48
  */
56
- declare function getConstruction(node: TSESTree.Node | _, initialScope: Scope, hint?: bigint): Construction | _;
57
-
58
- declare function getVariableDeclaratorId(node: TSESTree.Node | _, prev?: TSESTree.Node): TSESTree.BindingName | TSESTree.Expression | _;
59
-
60
- declare function getVariableInitNode(variable: Variable | _, at: number): _ | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
61
-
62
- declare function getChidScopes(scope: Scope): readonly Scope[];
63
-
64
- type LazyValue = {
65
- kind: "lazy";
66
- node: TSESTree.Node;
67
- initialScope: Scope | _;
68
- } | {
69
- kind: "none";
70
- node: TSESTree.Node;
71
- initialScope: Scope | _;
72
- } | {
73
- kind: "some";
74
- node: TSESTree.Node;
75
- value: unknown;
76
- initialScope: Scope | _;
77
- };
78
- declare function toStaticValue(lazyValue: LazyValue): {
79
- readonly kind: "none";
80
- readonly node: TSESTree.Node;
81
- readonly initialScope: Scope | undefined;
82
- readonly value?: never;
83
- } | {
84
- readonly kind: "some";
85
- readonly node: TSESTree.Node;
86
- readonly initialScope: Scope | undefined;
87
- readonly value: unknown;
88
- };
89
-
49
+ declare function getConstruction(node: TSESTree.Node | unit, initialScope: Scope, hint?: bigint): Construction | unit;
50
+ //#endregion
51
+ //#region src/value-equal.d.ts
90
52
  /**
91
53
  * Determines whether node value equals to another node value
92
54
  * @param a node to compare
@@ -94,9 +56,24 @@ declare function toStaticValue(lazyValue: LazyValue): {
94
56
  * @param initialScopes initial scopes of the two nodes
95
57
  * @returns `true` if node value equal
96
58
  */
97
- declare function isNodeValueEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [
98
- aScope: Scope,
99
- bScope: Scope
100
- ]): boolean;
101
-
102
- export { type Construction, ConstructionDetectionHint, type LazyValue, findPropertyInProperties, findVariable, getChidScopes, getConstruction, getVariableDeclaratorId, getVariableInitNode, getVariables, isNodeValueEqual, toStaticValue };
59
+ declare function isNodeValueEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [aScope: Scope, bScope: Scope]): boolean;
60
+ //#endregion
61
+ //#region src/variable-assignment.d.ts
62
+ declare function findAssignmentTarget(node: TSESTree.Node | unit, prev?: TSESTree.Node): TSESTree.BindingName | TSESTree.Expression | unit;
63
+ //#endregion
64
+ //#region src/variable-extractor.d.ts
65
+ /**
66
+ * Get all variables from the given scope up to the global scope
67
+ * @param initialScope The scope to start from
68
+ * @returns All variables from the given scope up to the global scope
69
+ */
70
+ declare function getVariables(initialScope: Scope): Variable[];
71
+ declare const findVariable: {
72
+ (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | unit) => Variable | unit;
73
+ (nameOrNode: string | TSESTree.Identifier | unit, initialScope: Scope): Variable | unit;
74
+ };
75
+ //#endregion
76
+ //#region src/variable-resolver.d.ts
77
+ declare function getVariableDefinitionNode(variable: Variable | unit, at: number): unit | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
78
+ //#endregion
79
+ export { Construction, ConstructionDetectionHint, findAssignmentTarget, findProperty, findVariable, getChildScopes, getConstruction, getVariableDefinitionNode, getVariables, isNodeValueEqual };
package/dist/index.js CHANGED
@@ -1,256 +1,241 @@
1
- import { dual, _ } from '@eslint-react/eff';
2
- import { DefinitionType, ScopeType } from '@typescript-eslint/scope-manager';
3
- import { AST_NODE_TYPES } from '@typescript-eslint/types';
4
- import * as ASTUtils from '@typescript-eslint/utils/ast-utils';
5
- import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
6
- import * as AST from '@eslint-react/ast';
1
+ import { AST_NODE_TYPES } from "@typescript-eslint/types";
2
+ import { dual, unit } from "@eslint-react/eff";
3
+ import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
4
+ import * as ASTUtils from "@typescript-eslint/utils/ast-utils";
5
+ import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
6
+ import * as AST from "@eslint-react/ast";
7
7
 
8
- // src/var-collect.ts
9
- function getVariableInitNode(variable, at) {
10
- if (variable == null) return _;
11
- const def = variable.defs.at(at);
12
- if (def == null) return _;
13
- switch (true) {
14
- case (def.type === DefinitionType.FunctionName && def.node.type === AST_NODE_TYPES.FunctionDeclaration):
15
- return def.node;
16
- case (def.type === DefinitionType.ClassName && def.node.type === AST_NODE_TYPES.ClassDeclaration):
17
- return def.node;
18
- case ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)):
19
- return def.node.init;
20
- default:
21
- return _;
22
- }
23
- }
24
-
25
- // src/var-collect.ts
8
+ //#region src/variable-extractor.ts
9
+ /**
10
+ * Get all variables from the given scope up to the global scope
11
+ * @param initialScope The scope to start from
12
+ * @returns All variables from the given scope up to the global scope
13
+ */
26
14
  function getVariables(initialScope) {
27
- let scope = initialScope;
28
- const variables = [...scope.variables];
29
- while (scope.type !== ScopeType.global) {
30
- scope = scope.upper;
31
- variables.push(...scope.variables);
32
- }
33
- return variables.reverse();
15
+ let scope = initialScope;
16
+ const variables = [...scope.variables];
17
+ while (scope.type !== ScopeType.global) {
18
+ scope = scope.upper;
19
+ variables.push(...scope.variables);
20
+ }
21
+ return variables.reverse();
34
22
  }
35
- var findVariable2 = dual(2, (nameOrNode, initialScope) => {
36
- if (nameOrNode == null) return _;
37
- return ASTUtils.findVariable(initialScope, nameOrNode) ?? _;
23
+ const findVariable = dual(2, (nameOrNode, initialScope) => {
24
+ if (nameOrNode == null) return unit;
25
+ return ASTUtils.findVariable(initialScope, nameOrNode) ?? unit;
38
26
  });
39
- function findPropertyInProperties(name, properties, initialScope, seen = /* @__PURE__ */ new Set()) {
40
- return properties.findLast((prop) => {
41
- if (prop.type === AST_NODE_TYPES.Property) {
42
- return "name" in prop.key && prop.key.name === name;
43
- }
44
- if (prop.type === AST_NODE_TYPES.SpreadElement) {
45
- switch (prop.argument.type) {
46
- case AST_NODE_TYPES.Identifier: {
47
- if (seen.has(prop.argument.name)) return false;
48
- const variable = findVariable2(prop.argument.name, initialScope);
49
- const variableNode = getVariableInitNode(variable, 0);
50
- if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) {
51
- seen.add(prop.argument.name);
52
- return findPropertyInProperties(
53
- name,
54
- variableNode.properties,
55
- initialScope,
56
- seen
57
- ) != null;
58
- }
59
- return false;
60
- }
61
- case AST_NODE_TYPES.ObjectExpression: {
62
- return findPropertyInProperties(
63
- name,
64
- prop.argument.properties,
65
- initialScope,
66
- seen
67
- ) != null;
68
- }
69
- default:
70
- return false;
71
- }
72
- }
73
- return false;
74
- });
27
+
28
+ //#endregion
29
+ //#region src/variable-resolver.ts
30
+ function getVariableDefinitionNode(variable, at) {
31
+ if (variable == null) return unit;
32
+ const def = variable.defs.at(at);
33
+ if (def == null) return unit;
34
+ switch (true) {
35
+ case def.type === DefinitionType.FunctionName && def.node.type === AST_NODE_TYPES.FunctionDeclaration: return def.node;
36
+ case def.type === DefinitionType.ClassName && def.node.type === AST_NODE_TYPES.ClassDeclaration: return def.node;
37
+ case "init" in def.node && def.node.init != null && !("declarations" in def.node.init): return def.node.init;
38
+ default: return unit;
39
+ }
75
40
  }
76
- var ConstructionDetectionHint = {
77
- None: 0n,
78
- StrictCallExpression: 1n << 0n
79
- };
80
- function getConstruction(node, initialScope, hint = ConstructionDetectionHint.None) {
81
- if (node == null) return _;
82
- switch (node.type) {
83
- case AST_NODE_TYPES.JSXElement:
84
- case AST_NODE_TYPES.JSXFragment:
85
- return { kind: "JSXElement", node };
86
- case AST_NODE_TYPES.ArrayExpression:
87
- return { kind: "ArrayExpression", node };
88
- case AST_NODE_TYPES.ObjectExpression:
89
- return { kind: "ObjectExpression", node };
90
- case AST_NODE_TYPES.ClassExpression:
91
- return { kind: "ClassExpression", node };
92
- case AST_NODE_TYPES.NewExpression:
93
- return { kind: "NewExpression", node };
94
- case AST_NODE_TYPES.FunctionExpression:
95
- case AST_NODE_TYPES.ArrowFunctionExpression:
96
- return { kind: "FunctionExpression", node };
97
- case AST_NODE_TYPES.CallExpression: {
98
- if (hint & ConstructionDetectionHint.StrictCallExpression) {
99
- return { kind: "CallExpression", node };
100
- }
101
- return _;
102
- }
103
- case AST_NODE_TYPES.MemberExpression: {
104
- if (!("object" in node)) return _;
105
- return getConstruction(node.object, initialScope, hint);
106
- }
107
- case AST_NODE_TYPES.AssignmentExpression:
108
- case AST_NODE_TYPES.AssignmentPattern: {
109
- if (!("right" in node)) return _;
110
- return getConstruction(node.right, initialScope, hint);
111
- }
112
- case AST_NODE_TYPES.LogicalExpression: {
113
- const lvc = getConstruction(node.left, initialScope, hint);
114
- if (lvc == null) return _;
115
- return getConstruction(node.right, initialScope, hint);
116
- }
117
- case AST_NODE_TYPES.ConditionalExpression: {
118
- const cvc = getConstruction(node.consequent, initialScope, hint);
119
- if (cvc == null) return _;
120
- return getConstruction(node.alternate, initialScope, hint);
121
- }
122
- case AST_NODE_TYPES.Identifier: {
123
- if (!("name" in node) || typeof node.name !== "string") {
124
- return _;
125
- }
126
- const variable = initialScope.set.get(node.name);
127
- const variableNode = getVariableInitNode(variable, -1);
128
- return getConstruction(variableNode, initialScope, hint);
129
- }
130
- case AST_NODE_TYPES.Literal: {
131
- if ("regex" in node) {
132
- return { kind: "RegExpLiteral", node };
133
- }
134
- return _;
135
- }
136
- default: {
137
- if (!("expression" in node) || typeof node.expression !== "object") {
138
- return _;
139
- }
140
- return getConstruction(node.expression, initialScope, hint);
141
- }
142
- }
41
+
42
+ //#endregion
43
+ //#region src/misc.ts
44
+ function getChildScopes(scope) {
45
+ const scopes = [scope];
46
+ for (const childScope of scope.childScopes) scopes.push(...getChildScopes(childScope));
47
+ return scopes;
143
48
  }
144
- function getVariableDeclaratorId(node, prev) {
145
- if (node == null) return _;
146
- switch (true) {
147
- case (node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev):
148
- return node.id;
149
- case (node.type === AST_NODE_TYPES.AssignmentExpression && node.right === prev):
150
- return node.left;
151
- case (node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node):
152
- return _;
153
- default:
154
- return getVariableDeclaratorId(node.parent, node);
155
- }
49
+ function findProperty(name, properties, initialScope, seen = /* @__PURE__ */ new Set()) {
50
+ return properties.findLast((prop) => {
51
+ if (prop.type === AST_NODE_TYPES.Property) return "name" in prop.key && prop.key.name === name;
52
+ if (prop.type === AST_NODE_TYPES.SpreadElement) switch (prop.argument.type) {
53
+ case AST_NODE_TYPES.Identifier: {
54
+ if (seen.has(prop.argument.name)) return false;
55
+ const variable = findVariable(prop.argument.name, initialScope);
56
+ const variableNode = getVariableDefinitionNode(variable, 0);
57
+ if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) {
58
+ seen.add(prop.argument.name);
59
+ return findProperty(name, variableNode.properties, initialScope, seen) != null;
60
+ }
61
+ return false;
62
+ }
63
+ case AST_NODE_TYPES.ObjectExpression: return findProperty(name, prop.argument.properties, initialScope, seen) != null;
64
+ default: return false;
65
+ }
66
+ return false;
67
+ });
156
68
  }
157
69
 
158
- // src/var-scope.ts
159
- function getChidScopes(scope) {
160
- const scopes = [scope];
161
- for (const childScope of scope.childScopes) {
162
- scopes.push(...getChidScopes(childScope));
163
- }
164
- return scopes;
165
- }
166
- function toStaticValue(lazyValue) {
167
- const { kind, node, initialScope } = lazyValue;
168
- if (kind !== "lazy") {
169
- return lazyValue;
170
- }
171
- const staticValue = initialScope == null ? getStaticValue(node) : getStaticValue(node, initialScope);
172
- return staticValue == null ? { kind: "none", node, initialScope } : { kind: "some", node, initialScope, value: staticValue.value };
70
+ //#endregion
71
+ //#region src/value-construction.ts
72
+ const ConstructionDetectionHint = {
73
+ None: 0n,
74
+ StrictCallExpression: 1n << 0n
75
+ };
76
+ /**
77
+ * Detects the construction type of a given node.
78
+ * @param node The node to check.
79
+ * @param initialScope The initial scope to check for variable declarations.
80
+ * @param hint Optional hint to control the detection behavior.
81
+ * @returns The construction type of the node, or `_` if not found.
82
+ */
83
+ function getConstruction(node, initialScope, hint = ConstructionDetectionHint.None) {
84
+ if (node == null) return unit;
85
+ switch (node.type) {
86
+ case AST_NODE_TYPES.JSXElement:
87
+ case AST_NODE_TYPES.JSXFragment: return {
88
+ kind: "JSXElement",
89
+ node
90
+ };
91
+ case AST_NODE_TYPES.ArrayExpression: return {
92
+ kind: "ArrayExpression",
93
+ node
94
+ };
95
+ case AST_NODE_TYPES.ObjectExpression: return {
96
+ kind: "ObjectExpression",
97
+ node
98
+ };
99
+ case AST_NODE_TYPES.ClassExpression: return {
100
+ kind: "ClassExpression",
101
+ node
102
+ };
103
+ case AST_NODE_TYPES.NewExpression: return {
104
+ kind: "NewExpression",
105
+ node
106
+ };
107
+ case AST_NODE_TYPES.FunctionExpression:
108
+ case AST_NODE_TYPES.ArrowFunctionExpression: return {
109
+ kind: "FunctionExpression",
110
+ node
111
+ };
112
+ case AST_NODE_TYPES.CallExpression:
113
+ if (hint & ConstructionDetectionHint.StrictCallExpression) return {
114
+ kind: "CallExpression",
115
+ node
116
+ };
117
+ return unit;
118
+ case AST_NODE_TYPES.MemberExpression:
119
+ if (!("object" in node)) return unit;
120
+ return getConstruction(node.object, initialScope, hint);
121
+ case AST_NODE_TYPES.AssignmentExpression:
122
+ case AST_NODE_TYPES.AssignmentPattern:
123
+ if (!("right" in node)) return unit;
124
+ return getConstruction(node.right, initialScope, hint);
125
+ case AST_NODE_TYPES.LogicalExpression: {
126
+ const lvc = getConstruction(node.left, initialScope, hint);
127
+ if (lvc == null) return unit;
128
+ return getConstruction(node.right, initialScope, hint);
129
+ }
130
+ case AST_NODE_TYPES.ConditionalExpression: {
131
+ const cvc = getConstruction(node.consequent, initialScope, hint);
132
+ if (cvc == null) return unit;
133
+ return getConstruction(node.alternate, initialScope, hint);
134
+ }
135
+ case AST_NODE_TYPES.Identifier: {
136
+ if (!("name" in node) || typeof node.name !== "string") return unit;
137
+ const variable = initialScope.set.get(node.name);
138
+ const variableNode = getVariableDefinitionNode(variable, -1);
139
+ return getConstruction(variableNode, initialScope, hint);
140
+ }
141
+ case AST_NODE_TYPES.Literal:
142
+ if ("regex" in node) return {
143
+ kind: "RegExpLiteral",
144
+ node
145
+ };
146
+ return unit;
147
+ default:
148
+ if (!("expression" in node) || typeof node.expression !== "object") return unit;
149
+ return getConstruction(node.expression, initialScope, hint);
150
+ }
173
151
  }
174
- var thisBlockTypes = [
175
- AST_NODE_TYPES.FunctionDeclaration,
176
- AST_NODE_TYPES.FunctionExpression,
177
- AST_NODE_TYPES.ClassBody,
178
- AST_NODE_TYPES.Program
152
+
153
+ //#endregion
154
+ //#region src/value-equal.ts
155
+ const thisBlockTypes = [
156
+ AST_NODE_TYPES.FunctionDeclaration,
157
+ AST_NODE_TYPES.FunctionExpression,
158
+ AST_NODE_TYPES.ClassBody,
159
+ AST_NODE_TYPES.Program
179
160
  ];
161
+ /**
162
+ * Determines whether node value equals to another node value
163
+ * @param a node to compare
164
+ * @param b node to compare
165
+ * @param initialScopes initial scopes of the two nodes
166
+ * @returns `true` if node value equal
167
+ */
180
168
  function isNodeValueEqual(a, b, initialScopes) {
181
- const [aScope, bScope] = initialScopes;
182
- switch (true) {
183
- case a === b: {
184
- return true;
185
- }
186
- case (a.type === AST_NODE_TYPES.Literal && b.type === AST_NODE_TYPES.Literal): {
187
- return a.value === b.value;
188
- }
189
- case (a.type === AST_NODE_TYPES.TemplateElement && b.type === AST_NODE_TYPES.TemplateElement): {
190
- return a.value.cooked === b.value.cooked;
191
- }
192
- case (a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier): {
193
- const aVar = findVariable2(a, aScope);
194
- const bVar = findVariable2(b, bScope);
195
- const aVarNode = getVariableInitNodeLoose(aVar, 0);
196
- const bVarNode = getVariableInitNodeLoose(bVar, 0);
197
- const aVarNodeParent = aVarNode?.parent;
198
- const bVarNodeParent = bVarNode?.parent;
199
- const aDef = aVar?.defs.at(0);
200
- const bDef = bVar?.defs.at(0);
201
- const aDefParentParent = aDef?.parent?.parent;
202
- const bDefParentParent = bDef?.parent?.parent;
203
- switch (true) {
204
- case (aVarNodeParent?.type === AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === AST_NODE_TYPES.CallExpression && AST.isFunction(aVarNode) && AST.isFunction(bVarNode)): {
205
- if (!AST.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) {
206
- return false;
207
- }
208
- const aParams = aVarNode.params;
209
- const bParams = bVarNode.params;
210
- const aPos = aParams.findIndex((x) => AST.isNodeEqual(x, a));
211
- const bPos = bParams.findIndex((x) => AST.isNodeEqual(x, b));
212
- return aPos !== -1 && bPos !== -1 && aPos === bPos;
213
- }
214
- case (aDefParentParent?.type === AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === AST_NODE_TYPES.ForOfStatement): {
215
- const aLeft = aDefParentParent.left;
216
- const bLeft = bDefParentParent.left;
217
- if (aLeft.type !== bLeft.type) {
218
- return false;
219
- }
220
- const aRight = aDefParentParent.right;
221
- const bRight = bDefParentParent.right;
222
- return AST.isNodeEqual(aRight, bRight);
223
- }
224
- default: {
225
- return aVar != null && bVar != null && aVar === bVar;
226
- }
227
- }
228
- }
229
- case (a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression): {
230
- return AST.isNodeEqual(a.property, b.property) && isNodeValueEqual(a.object, b.object, initialScopes);
231
- }
232
- case (a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression): {
233
- if (aScope.block === bScope.block) {
234
- return true;
235
- }
236
- const aFunction = AST.findParentNode(a, AST.isOneOf(thisBlockTypes));
237
- const bFunction = AST.findParentNode(b, AST.isOneOf(thisBlockTypes));
238
- return aFunction === bFunction;
239
- }
240
- default: {
241
- const aStatic = toStaticValue({ kind: "lazy", node: a, initialScope: aScope });
242
- const bStatic = toStaticValue({ kind: "lazy", node: b, initialScope: bScope });
243
- return aStatic.kind !== "none" && bStatic.kind !== "none" && aStatic.value === bStatic.value;
244
- }
245
- }
169
+ const [aScope, bScope] = initialScopes;
170
+ switch (true) {
171
+ case a === b: return true;
172
+ case a.type === AST_NODE_TYPES.Literal && b.type === AST_NODE_TYPES.Literal: return a.value === b.value;
173
+ case a.type === AST_NODE_TYPES.TemplateElement && b.type === AST_NODE_TYPES.TemplateElement: return a.value.cooked === b.value.cooked;
174
+ case a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier: {
175
+ const aVar = findVariable(a, aScope);
176
+ const bVar = findVariable(b, bScope);
177
+ const aVarNode = getVariableDefinitionNodeLoose(aVar, 0);
178
+ const bVarNode = getVariableDefinitionNodeLoose(bVar, 0);
179
+ const aVarNodeParent = aVarNode?.parent;
180
+ const bVarNodeParent = bVarNode?.parent;
181
+ const aDef = aVar?.defs.at(0);
182
+ const bDef = bVar?.defs.at(0);
183
+ const aDefParentParent = aDef?.parent?.parent;
184
+ const bDefParentParent = bDef?.parent?.parent;
185
+ switch (true) {
186
+ case aVarNodeParent?.type === AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === AST_NODE_TYPES.CallExpression && AST.isFunction(aVarNode) && AST.isFunction(bVarNode): {
187
+ if (!AST.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) return false;
188
+ const aParams = aVarNode.params;
189
+ const bParams = bVarNode.params;
190
+ const aPos = aParams.findIndex((x) => AST.isNodeEqual(x, a));
191
+ const bPos = bParams.findIndex((x) => AST.isNodeEqual(x, b));
192
+ return aPos !== -1 && bPos !== -1 && aPos === bPos;
193
+ }
194
+ case aDefParentParent?.type === AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === AST_NODE_TYPES.ForOfStatement: {
195
+ const aLeft = aDefParentParent.left;
196
+ const bLeft = bDefParentParent.left;
197
+ if (aLeft.type !== bLeft.type) return false;
198
+ const aRight = aDefParentParent.right;
199
+ const bRight = bDefParentParent.right;
200
+ return AST.isNodeEqual(aRight, bRight);
201
+ }
202
+ default: return aVar != null && bVar != null && aVar === bVar;
203
+ }
204
+ }
205
+ case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return AST.isNodeEqual(a.property, b.property) && isNodeValueEqual(a.object, b.object, initialScopes);
206
+ case a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression: {
207
+ if (aScope.block === bScope.block) return true;
208
+ const aFunction = AST.findParentNode(a, AST.isOneOf(thisBlockTypes));
209
+ const bFunction = AST.findParentNode(b, AST.isOneOf(thisBlockTypes));
210
+ return aFunction === bFunction;
211
+ }
212
+ default: {
213
+ const aStatic = getStaticValue(a, aScope);
214
+ const bStatic = getStaticValue(b, bScope);
215
+ return aStatic != null && bStatic != null && aStatic.value === bStatic.value;
216
+ }
217
+ }
218
+ }
219
+ function getVariableDefinitionNodeLoose(variable, at) {
220
+ if (variable == null) return unit;
221
+ const node = getVariableDefinitionNode(variable, at);
222
+ if (node != null) return node;
223
+ const def = variable.defs.at(at);
224
+ if (def?.type === DefinitionType.Parameter && AST.isFunction(def.node)) return def.node;
225
+ return unit;
246
226
  }
247
- function getVariableInitNodeLoose(variable, at) {
248
- if (variable == null) return _;
249
- const node = getVariableInitNode(variable, at);
250
- if (node != null) return node;
251
- const def = variable.defs.at(at);
252
- if (def?.type === DefinitionType.Parameter && AST.isFunction(def.node)) return def.node;
253
- return _;
227
+
228
+ //#endregion
229
+ //#region src/variable-assignment.ts
230
+ function findAssignmentTarget(node, prev) {
231
+ if (node == null) return unit;
232
+ switch (true) {
233
+ case node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev: return node.id;
234
+ case node.type === AST_NODE_TYPES.AssignmentExpression && node.right === prev: return node.left;
235
+ case node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node: return unit;
236
+ default: return findAssignmentTarget(node.parent, node);
237
+ }
254
238
  }
255
239
 
256
- export { ConstructionDetectionHint, findPropertyInProperties, findVariable2 as findVariable, getChidScopes, getConstruction, getVariableDeclaratorId, getVariableInitNode, getVariables, isNodeValueEqual, toStaticValue };
240
+ //#endregion
241
+ export { ConstructionDetectionHint, findAssignmentTarget, findProperty, findVariable, getChildScopes, getConstruction, getVariableDefinitionNode, getVariables, isNodeValueEqual };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@eslint-react/var",
3
- "version": "2.0.0-next.17",
3
+ "version": "2.0.0-next.170",
4
4
  "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
5
5
  "homepage": "https://github.com/Rel1cx/eslint-react",
6
6
  "bugs": {
@@ -27,24 +27,23 @@
27
27
  "./package.json"
28
28
  ],
29
29
  "dependencies": {
30
- "@typescript-eslint/scope-manager": "^8.32.0",
31
- "@typescript-eslint/types": "^8.32.0",
32
- "@typescript-eslint/utils": "^8.32.0",
30
+ "@typescript-eslint/scope-manager": "^8.42.0",
31
+ "@typescript-eslint/types": "^8.42.0",
32
+ "@typescript-eslint/utils": "^8.42.0",
33
33
  "string-ts": "^2.2.1",
34
- "ts-pattern": "^5.7.0",
35
- "@eslint-react/eff": "2.0.0-next.17",
36
- "@eslint-react/ast": "2.0.0-next.17"
34
+ "ts-pattern": "^5.8.0",
35
+ "@eslint-react/ast": "2.0.0-next.170",
36
+ "@eslint-react/eff": "2.0.0-next.170"
37
37
  },
38
38
  "devDependencies": {
39
- "tsup": "^8.4.0",
39
+ "tsdown": "^0.14.2",
40
40
  "@local/configs": "0.0.0"
41
41
  },
42
42
  "engines": {
43
- "bun": ">=1.0.15",
44
43
  "node": ">=20.19.0"
45
44
  },
46
45
  "scripts": {
47
- "build": "tsup",
46
+ "build": "tsdown --dts-resolve",
48
47
  "lint:publish": "publint",
49
48
  "lint:ts": "tsc --noEmit"
50
49
  }