eslint-plugin-function 0.2.4 → 0.2.8

package/dist/index.js

@@ -4,13 +4,12 @@ import { P, isMatching, match } from "ts-pattern";
 import ts from "typescript";
 import * as AST from "@eslint-react/ast";
 import { toRegExp } from "@eslint-react/shared";
-import "@let/eff";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 
 //#region package.json
 var name = "eslint-plugin-function";
-var version = "0.2.3";
+var version = "0.2.7";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -142,6 +141,119 @@ function create$1(context) {
 	return {};
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+let__eff@0.1.2/node_modules/@jsr/let__eff/src/index.js
+/**
+* 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`.
+*
+* @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/rules/function-return-boolean.ts
 const RULE_NAME = "function-return-boolean";
@@ -190,20 +302,24 @@ function create(context, [opts]) {
 	}
 	return {
 		[":function"](node) {
-			const functionName = AST.getFunctionId(node)?.name;
-			const isMatched = functionName != null && pattern.test(functionName);
+			const functionId = AST.getFunctionId(node);
 			functionEntries.push({
-				functionName,
-				functionNode: node,
-				isMatched
+				functionId,
+				functionNode: node
 			});
 		},
 		[":function:exit"]() {
 			functionEntries.pop();
 		},
 		["ArrowFunctionExpression"](node) {
-			const { functionName, isMatched = false } = functionEntries.at(-1) ?? {};
-			if (functionName == null || !isMatched) return;
+			const { functionId, functionNode } = functionEntries.at(-1) ?? {};
+			if (functionId == null || functionNode == null) return;
+			const functionName = match(functionId).with({ type: AST_NODE_TYPES.Identifier }, (id) => id.name).with({
+				type: AST_NODE_TYPES.MemberExpression,
+				property: { type: AST_NODE_TYPES.Identifier }
+			}, (me) => me.property.name).otherwise(() => null);
+			if (functionName == null) return;
+			if (!pattern.test(functionName)) return;
 			if (node.body.type === AST_NODE_TYPES.BlockStatement) return;
 			handleReturnExpression(context, node.body, (expr, data) => {
 				context.report({
@@ -217,17 +333,21 @@ function create(context, [opts]) {
 			});
 		},
 		["ReturnStatement"](node) {
-			const { functionName, functionNode, isMatched = false } = functionEntries.at(-1) ?? {};
-			if (functionName == null || functionNode == null || !isMatched) return;
+			const { functionId, functionNode } = functionEntries.at(-1) ?? {};
+			if (functionId == null || functionNode == null) return;
 			handleReturnExpression(context, node.argument, (expr, data) => {
-				const functionName$1 = AST.getFunctionId(functionNode)?.name;
-				if (functionName$1 == null) return;
+				const functionName = match(functionId).with({ type: AST_NODE_TYPES.Identifier }, (id) => id.name).with({
+					type: AST_NODE_TYPES.MemberExpression,
+					property: { type: AST_NODE_TYPES.Identifier }
+				}, (me) => me.property.name).otherwise(() => null);
+				if (functionName == null) return;
+				if (!pattern.test(functionName)) return;
 				context.report({
 					messageId: "functionReturnBoolean",
 					node: expr ?? node.argument ?? node,
 					data: {
 						...data,
-						functionName: functionName$1
+						functionName
 					}
 				});
 			});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-function",
-  "version": "0.2.4",
+  "version": "0.2.8",
   "private": false,
   "description": "(WIP) An ESLint plugin for function-related rules.",
   "homepage": "https://github.com/Rel1cx/dx",
@@ -27,23 +27,23 @@
     "package.json"
   ],
   "dependencies": {
-    "@eslint-react/ast": "^2.5.3",
-    "@eslint-react/shared": "^2.5.3",
-    "@let/eff": "npm:@jsr/let__eff@^0.1.2",
-    "@typescript-eslint/scope-manager": "^8.52.0",
-    "@typescript-eslint/type-utils": "^8.52.0",
-    "@typescript-eslint/types": "^8.52.0",
-    "@typescript-eslint/utils": "^8.52.0",
+    "@eslint-react/ast": "^2.7.2",
+    "@eslint-react/shared": "^2.7.2",
+    "@typescript-eslint/scope-manager": "^8.53.0",
+    "@typescript-eslint/type-utils": "^8.53.0",
+    "@typescript-eslint/types": "^8.53.0",
+    "@typescript-eslint/utils": "^8.53.0",
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.4.0",
     "ts-pattern": "^5.9.0"
   },
   "devDependencies": {
-    "@types/node": "^25.0.3",
-    "@typescript-eslint/rule-tester": "^8.52.0",
+    "@let/eff": "npm:@jsr/let__eff@^0.1.2",
+    "@types/node": "^25.0.9",
+    "@typescript-eslint/rule-tester": "^8.53.0",
     "dedent": "^1.7.1",
     "eslint": "^9.39.2",
-    "tsdown": "^0.19.0-beta.5",
+    "tsdown": "^0.20.0-beta.3",
     "tsl": "^1.0.28"
   },
   "peerDependencies": {