@eslint-react/var 5.5.6-next.0 → 5.6.0-beta.2

package/dist/index.js

@@ -2,7 +2,6 @@ import { Check, Compare, Extract, Traverse, isOneOf } from "@eslint-react/ast";
 import { DefinitionType } from "@typescript-eslint/scope-manager";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { P, match } from "ts-pattern";
 
 //#region src/resolve.ts
 /**
@@ -125,27 +124,28 @@ function computeObjectType(context, node) {
 		case AST_NODE_TYPES.SequenceExpression:
 			if (node.expressions.length === 0) return null;
 			return computeObjectType(context, node.expressions[node.expressions.length - 1] ?? null);
-		case AST_NODE_TYPES.CallExpression:
+		case AST_NODE_TYPES.CallExpression: {
+			const callee = Extract.unwrap(node.callee);
 			switch (true) {
-				case Check.isIdentifier("Boolean")(node.callee): return null;
-				case Check.isIdentifier("String")(node.callee): return null;
-				case Check.isIdentifier("Number")(node.callee): return null;
-				case Check.isIdentifier("Object")(node.callee): return {
+				case Check.isIdentifier("Boolean")(callee): return null;
+				case Check.isIdentifier("String")(callee): return null;
+				case Check.isIdentifier("Number")(callee): return null;
+				case Check.isIdentifier("Object")(callee): return {
 					kind: "plain",
 					node
 				};
-				case Check.isIdentifier("Array")(node.callee): return {
+				case Check.isIdentifier("Array")(callee): return {
 					kind: "array",
 					node
 				};
-				case Check.isIdentifier("RegExp")(node.callee): return {
+				case Check.isIdentifier("RegExp")(callee): return {
 					kind: "regexp",
 					node
 				};
 			}
-			if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier) {
-				const objName = node.callee.object.name;
-				const methodName = node.callee.property.name;
+			if (callee.type === AST_NODE_TYPES.MemberExpression && callee.object.type === AST_NODE_TYPES.Identifier && callee.property.type === AST_NODE_TYPES.Identifier) {
+				const objName = callee.object.name;
+				const methodName = callee.property.name;
 				switch (objName) {
 					case "Array":
 						if (methodName === "from" || methodName === "of") return {
@@ -166,139 +166,13 @@ function computeObjectType(context, node) {
 				node,
 				reason: "call-expression"
 			};
+		}
 		default:
 			if (!("expression" in node) || typeof node.expression !== "object") return null;
 			return computeObjectType(context, node.expression);
 	}
 }
 
-//#endregion
-//#region ../../.pkgs/eff/dist/index.js
-/**
-* Returns its argument.
-*
-* @param x - The value to return.
-* @returns The input value unchanged.
-*/
-function identity(x) {
-	return x;
-}
-/**
-* Creates a function that can be used in a data-last (aka `pipe`able) or
-* data-first style.
-*
-* The first parameter to `dual` is either the arity of the uncurried function
-* or a predicate that determines if the function is being used in a data-first
-* or data-last style.
-*
-* Using the arity is the most common use case, but there are some cases where
-* you may want to use a predicate. For example, if you have a function that
-* takes an optional argument, you can use a predicate to determine if the
-* function is being used in a data-first or data-last style.
-*
-* You can pass either the arity of the uncurried function or a predicate
-* which determines if the function is being used in a data-first or
-* data-last style.
-*
-* **Example** (Using arity to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = 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** (Using call signatures to define the overloads)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = dual(2, (self: number, that: number): number => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using a predicate to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = 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
-* ```
-*
-* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
-* @param body - The function to be curried.
-* @since 1.0.0
-*/
-const dual = function(arity, body) {
-	if (typeof arity === "function") return function() {
-		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
-	};
-	switch (arity) {
-		case 0:
-		case 1: throw new RangeError(`Invalid arity ${arity}`);
-		case 2: return function(a, b) {
-			if (arguments.length >= 2) return body(a, b);
-			return function(self) {
-				return body(self, a);
-			};
-		};
-		case 3: return function(a, b, c) {
-			if (arguments.length >= 3) return body(a, b, c);
-			return function(self) {
-				return body(self, a, b);
-			};
-		};
-		default: return function() {
-			if (arguments.length >= arity) return body.apply(this, arguments);
-			const args = arguments;
-			return function(self) {
-				return body(self, ...args);
-			};
-		};
-	}
-};
-/**
-* 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`.
-*
-* @param self - The first function to apply (or the composed function in data-last style).
-* @param bc - The second function to apply.
-* @returns A composed function that applies both functions in sequence.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { compose } from "effect/Function"
-*
-* const increment = (n: number) => n + 1;
-* const square = (n: number) => n * n;
-*
-* assert.strictEqual(compose(increment, square)(2), 9);
-* ```
-*
-* @since 1.0.0
-*/
-const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
-
 //#endregion
 //#region src/get-require-expression-arguments.ts
 /**
@@ -308,17 +182,13 @@ const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 * @internal
 */
 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);
+	const unwrapped = Extract.unwrap(node);
+	if (unwrapped.type === AST_NODE_TYPES.CallExpression) {
+		const callee = Extract.unwrap(unwrapped.callee);
+		if (callee.type === AST_NODE_TYPES.Identifier && callee.name === "require") return unwrapped.arguments;
+	}
+	if (unwrapped.type === AST_NODE_TYPES.MemberExpression) return getRequireExpressionArguments(unwrapped.object);
+	return null;
 }
 
 //#endregion
@@ -432,7 +302,7 @@ function resolveImportSource(name, initialScope, visited = /* @__PURE__ */ new S
 	if (latestDef == null) return null;
 	const { node, parent } = latestDef;
 	if (node.type === AST_NODE_TYPES.VariableDeclarator && node.init != null) {
-		const { init } = node;
+		const init = Extract.unwrap(node.init);
 		if (init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier) return resolveImportSource(init.object.name, initialScope, visited);
 		if (init.type === AST_NODE_TYPES.Identifier) return resolveImportSource(init.name, initialScope, visited);
 		const arg0 = getRequireExpressionArguments(init)?.[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/var",
-  "version": "5.5.6-next.0",
+  "version": "5.6.0-beta.2",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -33,8 +33,8 @@
     "@typescript-eslint/types": "^8.59.1",
     "@typescript-eslint/utils": "^8.59.1",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.5.6-next.0",
-    "@eslint-react/eslint": "5.5.6-next.0"
+    "@eslint-react/ast": "5.6.0-beta.2",
+    "@eslint-react/eslint": "5.6.0-beta.2"
   },
   "devDependencies": {
     "@typescript-eslint/parser": "^8.59.1",