@eslint-react/var 5.24.0 → 5.24.2

package/dist/index.js

@@ -5,44 +5,6 @@ import { DefinitionType } from "@typescript-eslint/scope-manager";
 import { P, isMatching } from "ts-pattern";
 
 //#region ../../.pkgs/eff/dist/index.js
-/**
-* Applies a `pipe` method's variadic arguments to an initial value from left
-* to right.
-*
-* **When to use**
-*
-* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
-* object.
-*
-* **Details**
-*
-* This helper is intended for implementing `Pipeable.pipe` methods that
-* receive JavaScript's `arguments` object. With no functions it returns the
-* original value; otherwise it feeds each result into the next function.
-*
-* **Example** (Implementing a pipe method)
-*
-* ```ts
-* import { Pipeable } from "effect"
-*
-* class NumberBox {
-*   constructor(readonly value: number) {}
-*
-*   pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
-*     return Pipeable.pipeArguments(this.value, arguments) as number
-*   }
-* }
-*
-* const result = new NumberBox(5).pipe(
-*   (n) => n + 2,
-*   (n) => n * 3
-* )
-* console.log(result) // 21
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const pipeArguments = (self, args) => {
 	switch (args.length) {
 		case 0: return self;
@@ -62,110 +24,14 @@ const pipeArguments = (self, args) => {
 		}
 	}
 };
-/**
-* Reusable prototype that implements `Pipeable.pipe`.
-*
-* **When to use**
-*
-* Use when classes or object prototypes can reuse this value when they need the
-* standard pipe implementation backed by `pipeArguments`.
-*
-* @category prototypes
-* @since 3.15.0
-*/
 const Prototype = { pipe() {
 	return pipeArguments(this, arguments);
 } };
-/**
-* Provides a base constructor whose instances implement the standard `Pipeable.pipe`
-* method.
-*
-* **When to use**
-*
-* Use when you need to define a class that supports Effect-style method
-* chaining through `.pipe(...)`.
-*
-* @category constructors
-* @since 3.15.0
-*/
 const Class = (function() {
 	function PipeableBase() {}
 	PipeableBase.prototype = Prototype;
 	return PipeableBase;
 })();
-/**
-* Provides small helpers for defining and reusing TypeScript functions.
-*
-* The main helpers are `pipe` and `flow` for left-to-right composition and
-* `dual` for APIs that support both direct and pipe-friendly call styles. The
-* module also contains small identity, constant, tuple, type-level, and
-* memoization helpers used across the library.
-*
-* @since 2.0.0
-*/
-/**
-* Creates a function that can be called in data-first style or data-last
-* (`pipe`-friendly) style.
-*
-* **When to use**
-*
-* Use to expose one implementation through both direct and `pipe`-friendly
-* call styles.
-*
-* **Details**
-*
-* Pass either the arity of the uncurried function or a predicate that decides
-* whether the current call is data-first. Arity is the common case. Use a
-* predicate when optional arguments make arity ambiguous.
-*
-* **Example** (Selecting data-first or data-last style by arity)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Defining overloads with call signatures)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = Function.dual(2, (self: number, that: number): number => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Selecting data-first or data-last style with a predicate)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const dual = function(arity, body) {
 	if (typeof arity === "function") return function() {
 		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
@@ -194,323 +60,55 @@ const dual = function(arity, body) {
 		};
 	}
 };
-/**
-* Returns its input argument unchanged.
-*
-* **When to use**
-*
-* Use to return a value unchanged where a function is required.
-*
-* **Example** (Returning the same value)
-*
-* ```ts
-* import { identity } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(identity(5), 5)
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const identity = (a) => a;
-/**
-* Returns the input value with a different static type.
-*
-* **When to use**
-*
-* Use when you need an explicit type-level cast and accept that the value is
-* returned unchanged at runtime.
-*
-* **Gotchas**
-*
-* This is a type-level cast only; it performs no runtime validation or
-* conversion.
-*
-* @see {@link satisfies} for checking assignability without changing the resulting type
-*
-* @category utility types
-* @since 4.0.0
-*/
 const cast = identity;
-/**
-* Creates a zero-argument function that always returns the provided value.
-*
-* **When to use**
-*
-* Use when you need a thunk or callback that returns the same value on every
-* invocation.
-*
-* **Example** (Creating a constant thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* const constNull = Function.constant(null)
-*
-* assert.deepStrictEqual(constNull(), null)
-* assert.deepStrictEqual(constNull(), null)
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
 const constant = (value) => () => value;
-/**
-* Returns `true` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `true` on every invocation.
-*
-* **Example** (Returning true from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constTrue(), true)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constTrue = constant(true);
-/**
-* Returns `false` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `false` on every invocation.
-*
-* **Example** (Returning false from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constFalse(), false)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constFalse = constant(false);
-/**
-* Returns `null` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `null` on every invocation.
-*
-* **Example** (Returning null from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constNull(), null)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constNull = constant(null);
-/**
-* Returns `undefined` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `undefined` on every invocation.
-*
-* **Example** (Returning undefined from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constUndefined(), undefined)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constUndefined = constant(void 0);
-/**
-* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
-* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
-*
-* **When to use**
-*
-* Use to compose exactly two unary functions into a reusable unary function.
-*
-* **Example** (Composing two functions)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* const increment = (n: number) => n + 1
-* const square = (n: number) => n * n
-*
-* assert.strictEqual(Function.compose(increment, square)(2), 9)
-* ```
-*
-* @see {@link flow} for composing a left-to-right sequence of functions
-* @see {@link pipe} for applying a value through a left-to-right sequence immediately
-*
-* @category combinators
-* @since 2.0.0
-*/
 const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
-/**
-* Marks an impossible branch by accepting a `never` value and returning any
-* type.
-*
-* **When to use**
-*
-* Use when you need a return value in a branch that exhaustive checks prove
-* cannot be reached.
-*
-* **Gotchas**
-*
-* Calling `absurd` throws, because a value of type `never` should be
-* impossible at runtime.
-*
-* **Example** (Handling impossible values)
-*
-* ```ts
-* import { absurd } from "effect"
-*
-* const handleNever = (value: never) => {
-*   return absurd(value) // This will throw an error if called
-* }
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
 const absurd = (_) => {
 	throw new Error("Called `absurd` function which should be uncallable");
 };
-/**
-* Creates a compile-time placeholder for a value of any type.
-*
-* **When to use**
-*
-* Use as a temporary typed placeholder while developing incomplete code.
-*
-* **Gotchas**
-*
-* `hole` is intended for temporary development use. If the placeholder is
-* evaluated at runtime, it throws.
-*
-* **Example** (Creating a development placeholder)
-*
-* ```ts
-* import { hole } from "effect"
-*
-* // Intentionally not called: `hole` throws if the placeholder is evaluated.
-* const buildUser = (id: number): { readonly id: number; readonly name: string } => ({
-*   id,
-*   name: hole<string>()
-* })
-*
-* console.log(typeof buildUser) // "function"
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
 const hole = cast(absurd);
+const and = dual(2, (a, b) => (data) => a(data) && b(data));
+const or = dual(2, (a, b) => (data) => a(data) || b(data));
+const xor = dual(2, (a, b) => (data) => a(data) !== b(data));
+const eqv = dual(2, (a, b) => (data) => a(data) === b(data));
+const implies = dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
+const nor = dual(2, (a, b) => (data) => !a(data) && !b(data));
+const nand = dual(2, (a, b) => (data) => !a(data) || !b(data));
+function isFunction(input) {
+	return typeof input === "function";
+}
+function isObjectKeyword(input) {
+	return typeof input === "object" && input !== null || isFunction(input);
+}
+const hasProperty = dual(2, (data, property) => isObjectKeyword(data) && property in data);
 function getOrInsertComputed(map, key, callback) {
 	if (map.has(key)) return map.get(key);
 	const value = callback(key);
 	map.set(key, value);
 	return value;
 }
-/**
-* Drops the longest prefix of elements from an array that satisfy the given predicate.
-*
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
-*
-* @param pred - The predicate to test each element with.
-* @returns A new array without the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { dropWhile, pipe } from "@local/eff"
-*
-* // data-first
-* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
-*
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
-* ```
-* @category array
-*/
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+const dropWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(idx);
 });
-/**
-* Takes the longest prefix of elements from an array that satisfy the given predicate.
-*
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
-*
-* @param pred - The predicate to test each element with.
-* @returns A new array containing only the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { pipe, takeWhile } from "@local/eff"
-*
-* // data-first
-* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
-*
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
-* ```
-* @category array
-*/
-const takeWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+const takeWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(0, idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(0, idx);
 });
 
 //#endregion
 //#region src/create-import-lookup.ts
-/**
-* Create a lookup of local import bindings from a source by scanning the
-* top-level imports of a program.
-*
-* Entries are kept in source order, and both indexes (by local name and by
-* imported name) are built during the same scan, so every query works
-* immediately after creation. Aliases (`import { flushSync as fs }`) are
-* handled naturally: the alias is the entry's local name.
-*
-* @param program - The program whose top-level import declarations to scan.
-* @param options - The source to track and optional builtin namespaces.
-* @returns An {@link ImportLookup} over the matching import bindings.
-*
-* @example
-* ```typescript
-* const imports = createImportLookup(context.sourceCode.ast, { source: "react-dom" });
-* return {
-*   CallExpression(node) {
-*     const callee = Extract.unwrap(node.callee);
-*     if (Check.isIdentifier(callee) && imports.has(callee.name, "flushSync")) {
-*       // ...
-*     }
-*   },
-* };
-* ```
-*/
 function createImportLookup(program, options) {
 	const { builtinNamespaces = [], source } = options;
 	const entries = [];
@@ -584,47 +182,6 @@ function createImportLookup(program, options) {
 
 //#endregion
 //#region src/resolve-origin.ts
-/**
-* Resolve an identifier to the AST node its value **originates from**,
-* suitable for origin/pedigree tracking in ESLint rule analysis.
-*
-* The resolution follows these rules per definition type:
-*
-* | Definition type          | `def.node`                                   | Returns                            |
-* |--------------------------|----------------------------------------------|------------------------------------|
-* | `CatchClause`            | `CatchClause`                                | `null`                             |
-* | `ClassName`              | `ClassDeclaration` / `ClassExpression`       | `def.node`                         |
-* | `FunctionName`           | `FunctionDeclaration` / `FunctionExpression` | `def.node`                         |
-* | `ImplicitGlobalVariable` | any node                                     | `null`                             |
-* | `ImportBinding`          | import specifier                             | `def.node` (the import specifier)  |
-* | `Parameter`              | containing function node                     | `def.node` (if a real function)    |
-* | `TSEnumMember`           | `TSEnumMember`                               | `def.node.initializer` (or `null`) |
-* | `TSEnumName`             | `TSEnumDeclaration`                          | `def.node`                         |
-* | `TSModuleName`           | `TSModuleDeclaration`                        | `null`                             |
-* | `Type`                   | type alias node                              | `null`                             |
-* | `Variable`               | `VariableDeclarator`                         | `def.node.init` (or `null`), including for destructured bindings |
-*
-* Unlike {@link resolve}, a binding declared through a destructuring
-* pattern (e.g. `setState` in `const [state, setState] = useState()`) resolves to the
-* declarator's initializer (the `useState()` call), i.e. the source expression the
-* binding derives from rather than the binding's own value; and a parameter resolves
-* to the containing function node (the binding's declaration site) instead of `null`;
-* and an import binding resolves to its import specifier (whose parent
-* `ImportDeclaration` carries the module source) instead of `null`.
-*
-* Use this for origin/pedigree tracking ("what produced this value?"); use
-* {@link resolve} when the precise value of the binding is needed.
-*
-* @param context The ESLint rule context.
-* @param node The identifier to resolve.
-* @param options Optional settings:
-* - `at`: Index of the definition to resolve (default: `0` for the first definition).
-* - `localOnly`: If `true`, only consider variables declared in the same scope as the identifier
-*   (this will miss variables declared in an outer scope). When `false` (default), traverse the
-*   scope chain upward via `findVariable` so that references to outer-scope bindings are resolved
-*   correctly.
-* @returns The resolved origin node, or `null` if the identifier cannot be resolved.
-*/
 function resolveOrigin(context, node, options) {
 	const { at = 0, localOnly = false } = options ?? {};
 	const scope = context.sourceCode.getScope(node);
@@ -638,7 +195,7 @@ function resolveOrigin(context, node, options) {
 		case DefinitionType.Variable: {
 			const { init } = def.node;
 			if (init == null) return null;
-			if ("declarations" in init) return null;
+			if (hasProperty(init, "declarations")) return null;
 			return init;
 		}
 		case DefinitionType.Parameter: return Check.isFunction(def.node) ? def.node : null;
@@ -661,13 +218,6 @@ const thisBlockTypes = [
 	AST_NODE_TYPES.ClassBody,
 	AST_NODE_TYPES.Program
 ];
-/**
-* Check if two nodes have equal values.
-* @param context The ESLint rule context.
-* @param a The first node to compare.
-* @param b The second node to compare.
-* @returns `true` if the two nodes have equal values.
-*/
 function isValueEqual(context, a, b) {
 	a = Check.isTypeExpression(a) ? Extract.unwrap(a) : a;
 	b = Check.isTypeExpression(b) ? Extract.unwrap(b) : b;
@@ -723,14 +273,6 @@ function isValueEqual(context, a, b) {
 
 //#endregion
 //#region src/is-assignment-target-equal.ts
-/**
-* Check if two assignment targets are equal, either directly or by their values.
-* @param context The ESLint 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) {
 	const unwrappedA = Check.isTypeExpression(a) ? Extract.unwrap(a) : a;
 	const unwrappedB = Check.isTypeExpression(b) ? Extract.unwrap(b) : b;
@@ -740,11 +282,6 @@ function isAssignmentTargetEqual(context, a, b) {
 
 //#endregion
 //#region src/resolve-import-source.ts
-/**
-* Get the arguments of a require expression.
-* @param node The node to check.
-* @returns The require expression arguments, or `null` when the node is not a require expression.
-*/
 function getRequireExpressionArguments(node) {
 	const expr = Extract.unwrap(node);
 	if (expr.type === AST_NODE_TYPES.CallExpression) {
@@ -755,13 +292,6 @@ function getRequireExpressionArguments(node) {
 	if (expr.type === AST_NODE_TYPES.MemberExpression) return getRequireExpressionArguments(expr.object);
 	return null;
 }
-/**
-* Resolve the import source of a variable by walking its latest definition.
-* @param name The variable name.
-* @param initialScope The initial scope.
-* @param seen The set of already visited variable names (for cycle detection).
-* @returns The import source, or `null` when it cannot be resolved.
-*/
 function resolveImportSource(name, initialScope, seen = /* @__PURE__ */ new Set()) {
 	if (seen.has(name)) return null;
 	seen.add(name);
@@ -785,28 +315,12 @@ function resolveImportSource(name, initialScope, seen = /* @__PURE__ */ new Set(
 
 //#endregion
 //#region src/is-initialized-from-react.ts
-/**
-* Check if a variable is initialized from a React import.
-* @param name The variable name.
-* @param initialScope The initial scope.
-* @param importSource Alternative import source of React (ex: "preact/compat").
-* @returns `true` if the variable is initialized or derived from a React import.
-* @internal
-*/
 function isInitializedFromReact(name, initialScope, importSource = "react") {
 	return name.toLowerCase() === "react" || Boolean(resolveImportSource(name, initialScope)?.startsWith(importSource));
 }
 
 //#endregion
 //#region src/is-initialized-from-react-native.ts
-/**
-* Check if a variable is initialized from a React Native import.
-* @param name The variable name.
-* @param initialScope The initial scope.
-* @param importSource Alternative import source of React Native (ex: "react-native-web").
-* @returns `true` if the variable is initialized or derived from a React Native import.
-* @internal
-*/
 function isInitializedFromReactNative(name, initialScope, importSource = "react-native") {
 	return [
 		"react_native",
@@ -817,39 +331,6 @@ function isInitializedFromReactNative(name, initialScope, importSource = "react-
 
 //#endregion
 //#region src/resolve.ts
-/**
-* Resolve an identifier to the AST node that represents its value,
-* suitable for use in ESLint rule analysis.
-*
-* The resolution follows these rules per definition type:
-*
-* | Definition type          | `def.node`                                   | Returns                            |
-* |--------------------------|----------------------------------------------|------------------------------------|
-* | `CatchClause`            | `CatchClause`                                | `null`                             |
-* | `ClassName`              | `ClassDeclaration` / `ClassExpression`       | `def.node`                         |
-* | `FunctionName`           | `FunctionDeclaration` / `FunctionExpression` | `def.node`                         |
-* | `ImplicitGlobalVariable` | any node                                     | `null`                             |
-* | `ImportBinding`          | import specifier                             | `null`                             |
-* | `Parameter`              | containing function node                     | `null` (the value is supplied by the caller) |
-* | `TSEnumMember`           | `TSEnumMember`                               | `def.node.initializer` (or `null`) |
-* | `TSEnumName`             | `TSEnumDeclaration`                          | `def.node`                         |
-* | `TSModuleName`           | `TSModuleDeclaration`                        | `null`                             |
-* | `Type`                   | type alias node                              | `null`                             |
-* | `Variable`               | `VariableDeclarator`                         | `def.node.init` for a plain identifier binding; `null` for destructured bindings or missing init |
-*
-* @param context The ESLint rule context.
-* @param node The identifier to resolve.
-* @param options Optional settings:
-* - `at`: Index of the definition to resolve (default: `0` for the first definition).
-* - `localOnly`: If `true`, only consider variables declared in the same scope as the identifier
-*   (this will miss variables declared in an outer scope). When `false` (default), traverse the
-*   scope chain upward via `findVariable` so that references to outer-scope bindings are resolved
-*   correctly.
-* @returns The resolved node, or `null` if the identifier cannot be resolved to a value node.
-*
-* For origin/pedigree tracking that maps destructured bindings to the declarator's
-* initializer, see {@link resolveOrigin}.
-*/
 function resolve(context, node, options) {
 	const { at = 0, localOnly = false } = options ?? {};
 	const scope = context.sourceCode.getScope(node);
@@ -864,7 +345,7 @@ function resolve(context, node, options) {
 			const { id, init } = def.node;
 			if (id !== def.name) return null;
 			if (init == null) return null;
-			if ("declarations" in init) return null;
+			if (hasProperty(init, "declarations")) return null;
 			return init;
 		}
 		case DefinitionType.Parameter: return null;
@@ -881,11 +362,6 @@ function resolve(context, node, options) {
 
 //#endregion
 //#region src/resolve-enclosing-assignment-target.ts
-/**
-* Resolve the enclosing assignment target (variable, property, etc.) of the node.
-* @param node The starting node for the upward search.
-* @returns The enclosing assignment target node, or `null` when not found.
-*/
 function resolveEnclosingAssignmentTarget(node) {
 	switch (node.type) {
 		case AST_NODE_TYPES.VariableDeclarator: return node.id;
@@ -900,12 +376,6 @@ function resolveEnclosingAssignmentTarget(node) {
 
 //#endregion
 //#region src/resolve-object-type.ts
-/**
-* Resolve the object type of the node.
-* @param context The ESLint rule context.
-* @param node The node to resolve.
-* @returns The object type of the node, or `null` when it cannot be resolved.
-*/
 function resolveObjectType(context, node) {
 	if (node == null) return null;
 	switch (node.type) {
@@ -938,7 +408,7 @@ function resolveObjectType(context, node) {
 			node
 		};
 		case AST_NODE_TYPES.Literal:
-			if ("regex" in node) return {
+			if (hasProperty(node, "regex")) return {
 				kind: "regexp",
 				node
 			};
@@ -1002,7 +472,7 @@ function resolveObjectType(context, node) {
 			};
 		}
 		default:
-			if (!("expression" in node) || typeof node.expression !== "object") return null;
+			if (!hasProperty(node, "expression") || typeof node.expression !== "object") return null;
 			return resolveObjectType(context, node.expression);
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/var",
-  "version": "5.24.0",
+  "version": "5.24.2",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -29,8 +29,8 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.24.0",
-    "@eslint-react/eslint": "5.24.0",
+    "@eslint-react/ast": "5.24.2",
+    "@eslint-react/eslint": "5.24.2",
     "@typescript-eslint/scope-manager": "^8.71.0",
     "@typescript-eslint/types": "^8.71.0",
     "@typescript-eslint/utils": "^8.71.0",
@@ -41,7 +41,7 @@
     "@local/eff": "0.0.0",
     "@local/testkit": "0.0.0",
     "@typescript-eslint/typescript-estree": "^8.71.0",
-    "eslint": "^10.11.0",
+    "eslint": "^10.12.0",
     "tsdown": "^0.23.0",
     "typescript": "6.0.3",
     "vitest": "^5.0.3"