@eslint-react/var 4.2.5-beta.0 → 5.0.0-beta.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { Scope } from "@typescript-eslint/scope-manager";
 import { TSESTree } from "@typescript-eslint/types";
 import { RuleContext } from "@eslint-react/shared";
 
@@ -52,6 +53,15 @@ declare function findEnclosingAssignmentTarget(node: TSESTree.Node): TSESTree.Ar
  */
 type AssignmentTarget = ReturnType<typeof findEnclosingAssignmentTarget>;
 //#endregion
+//#region src/get-require-expression-arguments.d.ts
+/**
+ * Get the arguments of a require expression
+ * @param node The node to match
+ * @returns The require expression arguments or null if the node is not a require expression
+ * @internal
+ */
+declare function getRequireExpressionArguments(node: TSESTree.Node): TSESTree.CallExpressionArgument[] | null;
+//#endregion
 //#region src/is-assignment-target-equal.d.ts
 /**
  * Check if two assignment targets are equal
@@ -110,4 +120,7 @@ declare function resolve(context: RuleContext, node: TSESTree.Identifier, option
   localOnly: boolean;
 }>): TSESTree.Node | null;
 //#endregion
-export { AssignmentTarget, ObjectType, computeObjectType, findEnclosingAssignmentTarget, isAssignmentTargetEqual, isValueEqual, resolve };
+//#region src/resolve-import-source.d.ts
+declare function resolveImportSource(name: string, initialScope: Scope, visited?: Set<string>): string | null;
+//#endregion
+export { AssignmentTarget, ObjectType, computeObjectType, findEnclosingAssignmentTarget, getRequireExpressionArguments, isAssignmentTargetEqual, isValueEqual, resolve, resolveImportSource };

package/dist/index.js

@@ -3,6 +3,7 @@ import { isIdentifier } 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
 /**
@@ -191,6 +192,155 @@ function findEnclosingAssignmentTarget(node) {
 	}
 }
 
+//#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
+/**
+* Get the arguments of a require expression
+* @param node The node to match
+* @returns The require expression arguments or null if the node is not a require expression
+* @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);
+}
+
 //#endregion
 //#region src/is-value-equal.ts
 const thisBlockTypes = [
@@ -275,4 +425,24 @@ function isAssignmentTargetEqual(context, a, b) {
 }
 
 //#endregion
-export { computeObjectType, findEnclosingAssignmentTarget, isAssignmentTargetEqual, isValueEqual, resolve };
+//#region src/resolve-import-source.ts
+function resolveImportSource(name, initialScope, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(name)) return null;
+	visited.add(name);
+	const latestDef = findVariable(initialScope, name)?.defs.at(-1);
+	if (latestDef == null) return null;
+	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 resolveImportSource(init.object.name, initialScope, visited);
+		if (init.type === AST_NODE_TYPES.Identifier) return resolveImportSource(init.name, initialScope, visited);
+		const arg0 = getRequireExpressionArguments(init)?.[0];
+		if (arg0 == null || !ast.isLiteral(arg0, "string")) return null;
+		return arg0.value;
+	}
+	if (parent?.type === AST_NODE_TYPES.ImportDeclaration) return parent.source.value;
+	return null;
+}
+
+//#endregion
+export { computeObjectType, findEnclosingAssignmentTarget, getRequireExpressionArguments, isAssignmentTargetEqual, isValueEqual, resolve, resolveImportSource };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/var",
-  "version": "4.2.5-beta.0",
+  "version": "5.0.0-beta.0",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -34,8 +34,8 @@
     "@typescript-eslint/types": "^8.58.0",
     "@typescript-eslint/utils": "^8.58.0",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "4.2.5-beta.0",
-    "@eslint-react/shared": "4.2.5-beta.0"
+    "@eslint-react/ast": "5.0.0-beta.0",
+    "@eslint-react/shared": "5.0.0-beta.0"
   },
   "devDependencies": {
     "@typescript-eslint/typescript-estree": "^8.58.0",