@eslint-react/core 3.0.0-next.70 → 3.0.0-next.74

package/dist/index.d.ts

@@ -627,14 +627,14 @@ declare function isHookName(name: string): boolean;
 type JsxAttributeValue = {
   kind: "missing";
   node: TSESTree.JSXEmptyExpression;
-  toStatic(): "{}";
+  toStatic(): null;
 } | {
   kind: "boolean";
   toStatic(): true;
 } | {
   kind: "element";
   node: TSESTree.JSXElement;
-  toStatic(): unknown;
+  toStatic(): null;
 } | {
   kind: "literal";
   node: TSESTree.Literal;
@@ -647,12 +647,12 @@ type JsxAttributeValue = {
   kind: "spreadProps";
   getProperty(name: string): unknown;
   node: TSESTree.JSXSpreadAttribute["argument"];
-  toStatic(): unknown;
+  toStatic(): null;
 } | {
   kind: "spreadChild";
   getChildren(at: number): unknown;
   node: TSESTree.JSXSpreadChild["expression"];
-  toStatic(): unknown;
+  toStatic(): null;
 };
 //#endregion
 //#region src/jsx/jsx-config.d.ts
@@ -786,9 +786,8 @@ declare class JsxInspector {
    * later props win), or `undefined` if not found.
    * @param node The JSX element to search for the attribute.
    * @param name The name of the attribute to find (e.g. `"className"`).
-   * @param initialScope An optional scope to use for resolving spread attributes. If not provided,
    */
-  findAttribute(node: TSESTree.JSXElement, name: string, initialScope?: Scope): ast.TSESTreeJSXAttributeLike | undefined;
+  findAttribute(node: TSESTree.JSXElement, name: string): ast.TSESTreeJSXAttributeLike | undefined;
   /**
    * Get the stringified name of a `JSXAttribute` node
    * (e.g. `"className"`, `"aria-label"`, `"xml:space"`).
@@ -810,10 +809,9 @@ declare class JsxInspector {
    * cannot be statically determined.
    * @param node The JSX element to search for the attribute.
    * @param name The name of the attribute to resolve (e.g. `"className"`).
-   * @param initialScope An optional scope to use for resolving spread attributes. If not provided, the scope will be determined from the context of the attribute node.
    * @returns The static value of the attribute, or `undefined` if not found or not statically resolvable.
    */
-  getAttributeStaticValue(node: TSESTree.JSXElement, name: string, initialScope?: Scope): unknown;
+  getAttributeStaticValue(node: TSESTree.JSXElement, name: string): unknown;
   /**
    * **All-in-one helper** – find an attribute by name on an element *and*
    * resolve its value in a single call.
@@ -821,10 +819,9 @@ declare class JsxInspector {
    * Returns `undefined` when the attribute is not present.
    * @param node The JSX element to search for the attribute.
    * @param name The name of the attribute to find and resolve (e.g. `"className"`).
-   * @param initialScope An optional scope to use for resolving spread attributes. If not provided, the scope will be determined from the context of the attribute node.
    * @returns A descriptor of the attribute's value that can be further inspected, or `undefined` if the attribute is not found.
    */
-  getAttributeValue(node: TSESTree.JSXElement, name: string, initialScope?: Scope): JsxAttributeValue | undefined;
+  getAttributeValue(node: TSESTree.JSXElement, name: string): JsxAttributeValue | undefined;
   /**
    * Get the **self name** (last segment) of a JSX element type.
    *
@@ -848,10 +845,9 @@ declare class JsxInspector {
    * Shorthand: check whether an attribute exists on the element.
    * @param node The JSX element to check for the attribute.
    * @param name The name of the attribute to check for (e.g. `"className"`).
-   * @param initialScope An optional scope to use for resolving spread attributes. If not provided, the scope will be determined from the context of the attribute node.
    * @returns `true` if the attribute exists on the element, `false` otherwise.
    */
-  hasAttribute(node: TSESTree.JSXElement, name: string, initialScope?: Scope): boolean;
+  hasAttribute(node: TSESTree.JSXElement, name: string): boolean;
   /**
    * Whether the node is a React **Fragment** element (either `<Fragment>` /
    * `<React.Fragment>` or the shorthand `<>` syntax).
@@ -887,7 +883,7 @@ declare class JsxInspector {
   } | {
     readonly kind: "missing";
     readonly node: TSESTree.JSXEmptyExpression;
-    readonly toStatic: () => "{}";
+    readonly toStatic: () => null;
     readonly getChildren?: never;
   } | {
     readonly kind: "expression";
@@ -901,14 +897,14 @@ declare class JsxInspector {
     readonly getChildren?: never;
   } | {
     readonly kind: "spreadChild";
-    readonly getChildren: (_at: number) => null;
     readonly node: TSESTree.JSXEmptyExpression | TSESTree.Expression;
-    readonly toStatic: () => unknown;
+    readonly toStatic: () => null;
+    readonly getChildren: (_at: number) => null;
   } | {
     readonly kind: "spreadProps";
-    readonly getProperty: (name: string) => unknown;
     readonly node: TSESTree.Expression;
-    readonly toStatic: () => unknown;
+    readonly toStatic: () => null;
+    readonly getProperty: (name: string) => unknown;
   };
 }
 //#endregion

package/dist/index.js

@@ -1,5 +1,4 @@
 import * as ast from "@eslint-react/ast";
-import { constFalse, dual, flip, getOrElseUpdate, identity } from "@eslint-react/eff";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { P, match } from "ts-pattern";
@@ -7,6 +6,165 @@ import { IdGenerator, RE_ANNOTATION_JSX, RE_ANNOTATION_JSX_FRAG, RE_ANNOTATION_J
 import { resolve } from "@eslint-react/var";
 import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from "@typescript-eslint/utils";
 
+//#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);
+			};
+		};
+	}
+};
+/**
+* Do nothing and return `false`.
+*
+* @returns false
+*/
+function constFalse() {
+	return false;
+}
+/**
+* Reverses the order of arguments for a curried function.
+*
+* @param f - The function to flip.
+* @returns A new function with the argument order reversed.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { flip } from "effect/Function"
+*
+* const f = (a: number) => (b: string) => a - b.length
+*
+* assert.deepStrictEqual(flip(f)('aaa')(2), -1)
+* ```
+*
+* @since 1.0.0
+*/
+const flip = (f) => (...b) => (...a) => f(...a)(...b);
+/**
+* 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)));
+function getOrElseUpdate(map, key, callback) {
+	if (map.has(key)) return map.get(key);
+	const value = callback();
+	map.set(key, value);
+	return value;
+}
+
+//#endregion
 //#region src/api/find-import-source.ts
 /**
 * Get the arguments of a require expression
@@ -596,10 +754,8 @@ var JsxInspector = class JsxInspector {
 	* later props win), or `undefined` if not found.
 	* @param node The JSX element to search for the attribute.
 	* @param name The name of the attribute to find (e.g. `"className"`).
-	* @param initialScope An optional scope to use for resolving spread attributes. If not provided,
 	*/
-	findAttribute(node, name, initialScope) {
-		initialScope ?? this.context.sourceCode.getScope(node);
+	findAttribute(node, name) {
 		return node.openingElement.attributes.findLast((attr) => {
 			if (attr.type === AST_NODE_TYPES.JSXAttribute) return stringifyJsx(attr.name) === name;
 			switch (attr.argument.type) {
@@ -636,11 +792,10 @@ var JsxInspector = class JsxInspector {
 	* cannot be statically determined.
 	* @param node The JSX element to search for the attribute.
 	* @param name The name of the attribute to resolve (e.g. `"className"`).
-	* @param initialScope An optional scope to use for resolving spread attributes. If not provided, the scope will be determined from the context of the attribute node.
 	* @returns The static value of the attribute, or `undefined` if not found or not statically resolvable.
 	*/
-	getAttributeStaticValue(node, name, initialScope) {
-		const attr = this.findAttribute(node, name, initialScope);
+	getAttributeStaticValue(node, name) {
+		const attr = this.findAttribute(node, name);
 		if (attr == null) return void 0;
 		const resolved = this.resolveAttributeValue(attr);
 		if (resolved.kind === "spreadProps") return resolved.getProperty(name);
@@ -653,11 +808,10 @@ var JsxInspector = class JsxInspector {
 	* Returns `undefined` when the attribute is not present.
 	* @param node The JSX element to search for the attribute.
 	* @param name The name of the attribute to find and resolve (e.g. `"className"`).
-	* @param initialScope An optional scope to use for resolving spread attributes. If not provided, the scope will be determined from the context of the attribute node.
 	* @returns A descriptor of the attribute's value that can be further inspected, or `undefined` if the attribute is not found.
 	*/
-	getAttributeValue(node, name, initialScope) {
-		const attr = this.findAttribute(node, name, initialScope);
+	getAttributeValue(node, name) {
+		const attr = this.findAttribute(node, name);
 		if (attr == null) return void 0;
 		return this.resolveAttributeValue(attr);
 	}
@@ -689,11 +843,10 @@ var JsxInspector = class JsxInspector {
 	* Shorthand: check whether an attribute exists on the element.
 	* @param node The JSX element to check for the attribute.
 	* @param name The name of the attribute to check for (e.g. `"className"`).
-	* @param initialScope An optional scope to use for resolving spread attributes. If not provided, the scope will be determined from the context of the attribute node.
 	* @returns `true` if the attribute exists on the element, `false` otherwise.
 	*/
-	hasAttribute(node, name, initialScope) {
-		return this.findAttribute(node, name, initialScope) != null;
+	hasAttribute(node, name) {
+		return this.findAttribute(node, name) != null;
 	}
 	/**
 	* Whether the node is a React **Fragment** element (either `<Fragment>` /
@@ -725,11 +878,11 @@ var JsxInspector = class JsxInspector {
 	* @returns A descriptor of the attribute's value that can be further inspected.
 	*/
 	resolveAttributeValue(attribute) {
-		const initialScope = this.context.sourceCode.getScope(attribute);
-		if (attribute.type === AST_NODE_TYPES.JSXAttribute) return this.#resolveJsxAttribute(attribute, initialScope);
-		return this.#resolveJsxSpreadAttribute(attribute, initialScope);
+		if (attribute.type === AST_NODE_TYPES.JSXAttribute) return this.#resolveJsxAttribute(attribute);
+		return this.#resolveJsxSpreadAttribute(attribute);
 	}
-	#resolveJsxAttribute(node, initialScope) {
+	#resolveJsxAttribute(node) {
+		const scope = this.context.sourceCode.getScope(node);
 		if (node.value == null) return {
 			kind: "boolean",
 			toStatic() {
@@ -753,14 +906,14 @@ var JsxInspector = class JsxInspector {
 					kind: "missing",
 					node: expr,
 					toStatic() {
-						return "{}";
+						return null;
 					}
 				};
 				return {
 					kind: "expression",
 					node: expr,
 					toStatic() {
-						return getStaticValue(expr, initialScope)?.value;
+						return getStaticValue(expr, scope)?.value;
 					}
 				};
 			}
@@ -771,30 +924,30 @@ var JsxInspector = class JsxInspector {
 					return null;
 				}
 			};
-			case AST_NODE_TYPES.JSXSpreadChild: {
-				const expr = node.value.expression;
+			case AST_NODE_TYPES.JSXSpreadChild:
+				node.value.expression;
 				return {
 					kind: "spreadChild",
-					getChildren(_at) {
-						return null;
-					},
 					node: node.value.expression,
 					toStatic() {
-						return getStaticValue(expr, initialScope)?.value;
+						return null;
+					},
+					getChildren(_at) {
+						return null;
 					}
 				};
-			}
 		}
 	}
-	#resolveJsxSpreadAttribute(node, initialScope) {
+	#resolveJsxSpreadAttribute(node) {
+		const scope = this.context.sourceCode.getScope(node);
 		return {
 			kind: "spreadProps",
-			getProperty(name) {
-				return match(getStaticValue(node.argument, initialScope)?.value).with({ [name]: P.select(P.any) }, identity).otherwise(() => null);
-			},
 			node: node.argument,
 			toStatic() {
-				return getStaticValue(node.argument, initialScope)?.value;
+				return null;
+			},
+			getProperty(name) {
+				return match(getStaticValue(node.argument, scope)?.value).with({ [name]: P.select(P.any) }, identity).otherwise(() => null);
 			}
 		};
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "3.0.0-next.70",
+  "version": "3.0.0-next.74",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -34,18 +34,18 @@
     "@typescript-eslint/types": "canary",
     "@typescript-eslint/utils": "canary",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-next.70",
-    "@eslint-react/eff": "3.0.0-next.70",
-    "@eslint-react/var": "3.0.0-next.70",
-    "@eslint-react/shared": "3.0.0-next.70"
+    "@eslint-react/ast": "3.0.0-next.74",
+    "@eslint-react/shared": "3.0.0-next.74",
+    "@eslint-react/var": "3.0.0-next.74",
+    "@local/eff": "3.0.0-beta.72"
   },
   "devDependencies": {
     "tsdown": "^0.21.0-beta.2",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
-    "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-    "typescript": ">=4.8.4 <6.0.0"
+    "eslint": "^10.0.0",
+    "typescript": "*"
   },
   "engines": {
     "node": ">=22.0.0"