@eslint-react/ast 3.0.0-next.9 → 3.0.0-rc.0

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { unit } from "@eslint-react/eff";
 import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
 import { TSESTree as TSESTree$1 } from "@typescript-eslint/utils";
 
@@ -34,7 +33,7 @@ type TSESTreeProperty = TSESTree$1.PropertyDefinition | TSESTree$1.TSIndexSignat
 /**
  * Represents all JSX-related nodes in TSESTree
  */
-type TSESTreeJSX = TSESTree$1.JSXAttribute | TSESTree$1.JSXChild | TSESTree$1.JSXClosingElement | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXElement | TSESTree$1.JSXEmptyExpression | TSESTree$1.JSXExpression | TSESTree$1.JSXExpressionContainer | TSESTree$1.JSXFragment | TSESTree$1.JSXIdentifier | TSESTree$1.JSXIdentifierToken | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXNamespacedName | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXSpreadAttribute | TSESTree$1.JSXSpreadChild | TSESTree$1.JSXTagNameExpression | TSESTree$1.JSXText | TSESTree$1.JSXTextToken;
+type TSESTreeJSX = TSESTree$1.JSXAttribute | TSESTree$1.JSXChild | TSESTree$1.JSXClosingElement | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXEmptyExpression | TSESTree$1.JSXIdentifierToken | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXSpreadAttribute | TSESTree$1.JSXTagNameExpression | TSESTree$1.JSXTextToken;
 /**
  * Represents JSX attribute-like nodes (attributes and spread attributes)
  */
@@ -56,7 +55,7 @@ type TSESTreeTypeExpression = TSESTree$1.TSAsExpression | TSESTree$1.TSNonNullEx
  */
 type TSESTreeTypeAssertionExpression = TSESTree$1.TSAsExpression | TSESTree$1.TSNonNullExpression | TSESTree$1.TSSatisfiesExpression | TSESTree$1.TSTypeAssertion;
 /**
- * Represents a directive expression statement in TSESTree (e.g., "use strict";)
+ * Represents a directive expression statement in TSESTree (ex: "use strict";)
  */
 type TSESTreeDirective = TSESTree$1.ExpressionStatement & {
   directive: string;
@@ -73,37 +72,9 @@ type TSESTreeDirectiveLike = TSESTree$1.ExpressionStatement & {
 /**
  * Get the class identifier of a class node
  * @param node The class node to get the identifier from
- * @returns The class identifier or unit if not found
+ * @returns The class identifier or null if not found
  */
-declare function getClassId(node: TSESTreeClass): TSESTree.BindingName | unit;
-//#endregion
-//#region src/directive-helper.d.ts
-/**
- * Get all directive expression statements from the top of a program AST node
- * @param node The program AST node
- * @returns The array of directive string literals (e.g., "use strict")
- */
-declare function getFileDirectives(node: TSESTree.Program): TSESTreeDirective[];
-/**
- * Get all directive expression statements from the top of a function AST node
- * @param node The function AST node
- * @returns The array of directive string literals (e.g., "use memo", "use no memo")
- */
-declare function getFunctionDirectives(node: TSESTreeFunction): TSESTreeDirective[];
-/**
- * Check if a directive with the given name exists in the file or function directives
- * @param node The program or function AST node
- * @param name The directive name to check (e.g., "use strict", "use memo", "use no memo")
- * @returns True if the directive exists, false otherwise
- */
-declare function isDirectiveInFile(node: TSESTree.Program, name: string): boolean;
-/**
- * Check if a directive with the given name exists in the function directives
- * @param node The function AST node
- * @param name The directive name to check (e.g., "use memo", "use no memo")
- * @returns True if the directive exists, false otherwise
- */
-declare function isDirectiveInFunction(node: TSESTreeFunction, name: string): boolean;
+declare function getClassId(node: TSESTreeClass): TSESTree.BindingName | null;
 //#endregion
 //#region src/directive-is.d.ts
 /**
@@ -136,15 +107,6 @@ declare function isDirectiveKind(kind: string): kind is DirectiveKind;
  */
 declare function isDirectiveName(name: string): boolean;
 //#endregion
-//#region src/expression-base.d.ts
-/**
- * Unwraps any type expressions to get the underlying JavaScript expression node.
- * Recursively processes nodes until a non-type expression is found.
- * @param node The AST node to unwrap
- * @returns The underlying JavaScript expression node
- */
-declare function getUnderlyingExpression(node: TSESTree.Node): Exclude<TSESTree.Node, TSESTreeTypeExpression>;
-//#endregion
 //#region src/expression-is.d.ts
 /**
  * Check if the given expression is a 'this' expression
@@ -190,6 +152,36 @@ declare const getNestedNewExpressions: (node: TSESTree.Node) => TSESTree.NewExpr
  */
 declare const getNestedCallExpressions: (node: TSESTree.Node) => TSESTree.CallExpression[];
 //#endregion
+//#region src/file-directive.d.ts
+/**
+ * Get all directive expression statements from the top of a program AST node
+ * @param node The program AST node
+ * @returns The array of directive string literals (ex: "use strict")
+ */
+declare function getFileDirectives(node: TSESTree.Program): TSESTreeDirective[];
+/**
+ * Check if a directive with the given name exists in the file or function directives
+ * @param node The program or function AST node
+ * @param name The directive name to check (ex: "use strict", "use memo", "use no memo")
+ * @returns True if the directive exists, false otherwise
+ */
+declare function isDirectiveInFile(node: TSESTree.Program, name: string): boolean;
+//#endregion
+//#region src/function-directive.d.ts
+/**
+ * Get all directive expression statements from the top of a function AST node
+ * @param node The function AST node
+ * @returns The array of directive string literals (ex: "use memo", "use no memo")
+ */
+declare function getFunctionDirectives(node: TSESTreeFunction): TSESTreeDirective[];
+/**
+ * Check if a directive with the given name exists in the function directives
+ * @param node The function AST node
+ * @param name The directive name to check (ex: "use memo", "use no memo")
+ * @returns True if the directive exists, false otherwise
+ */
+declare function isDirectiveInFunction(node: TSESTreeFunction, name: string): boolean;
+//#endregion
 //#region src/function-id.d.ts
 /**
  * Gets the static name of a function AST node. For function declarations it is
@@ -198,7 +190,7 @@ declare const getNestedCallExpressions: (node: TSESTree.Node) => TSESTree.CallEx
  * where JS gives anonymous function expressions names. We roughly detect the
  * same AST nodes with some exceptions to better fit our use case.
  */
-declare function getFunctionId(node: TSESTree.Expression | TSESTreeFunction): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | undefined;
+declare function getFunctionId(node: TSESTree.Expression | TSESTreeFunction): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | null;
 /**
  * Type representing the return type of getFunctionId
  */
@@ -215,14 +207,14 @@ type FunctionInitPath = readonly [TSESTree.FunctionDeclaration] | readonly [TSES
  * Determine what kind of component declaration pattern the function belongs to.
  *
  * @param node The function node to analyze
- * @returns The function initialization path or unit if not identifiable
+ * @returns The function initialization path or null if not identifiable
  */
-declare function getFunctionInitPath(node: TSESTreeFunction): unit | FunctionInitPath;
+declare function getFunctionInitPath(node: TSESTreeFunction): null | FunctionInitPath;
 /**
  * Check if a specific function call exists in the function initialization path.
  * Useful for detecting HOCs like React.memo, React.forwardRef, etc.
  *
- * @param callName The name of the call to check for (e.g., "memo", "forwardRef")
+ * @param callName The name of the call to check for (ex: "memo", "forwardRef")
  * @param initPath The function initialization path to search in
  * @returns True if the call exists in the path, false otherwise
  */
@@ -249,7 +241,7 @@ declare function isFunctionImmediatelyInvoked(node: TSESTreeFunction): boolean;
  * @param name The name to check
  * @returns True if the node is an identifier, false otherwise
  */
-declare function isIdentifier(node: TSESTree.Node | null | unit, name?: string): node is TSESTree.Identifier;
+declare function isIdentifier(node: TSESTree.Node | null, name?: string): node is TSESTree.Identifier;
 //#endregion
 //#region src/identifier-name.d.ts
 /**
@@ -259,6 +251,15 @@ declare function isIdentifier(node: TSESTree.Node | null | unit, name?: string):
  */
 declare function isIdentifierName(name: string): boolean;
 //#endregion
+//#region src/identifier-traverse.d.ts
+/**
+ * Get the root identifier of a (possibly nested) member expression.
+ * For `a.b.c`, returns the `a` Identifier node.
+ * @param node The expression to analyze
+ * @returns The root Identifier node, or null if it cannot be determined (ex: non-identifier root)
+ */
+declare function getRootIdentifier(node: TSESTree.Expression | TSESTree.PrivateIdentifier): TSESTree.Identifier | null;
+//#endregion
 //#region src/literal-is.d.ts
 /**
  * Check if a node is a literal value
@@ -272,7 +273,7 @@ declare function isLiteral(node: TSESTree.Node, type: "number"): node is TSESTre
 declare function isLiteral(node: TSESTree.Node, type: "regexp"): node is TSESTree.RegExpLiteral;
 declare function isLiteral(node: TSESTree.Node, type: "string"): node is TSESTree.StringLiteral;
 //#endregion
-//#region src/node-equal.d.ts
+//#region src/node-equality.d.ts
 /**
  * Check if two nodes are equal
  * @param a node to compare
@@ -442,24 +443,33 @@ declare const SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION: string;
  * Find the parent node that satisfies the test function
  * @param node The AST node
  * @param test The test function
- * @returns The parent node that satisfies the test function or `_` if not found
+ * @returns The parent node that satisfies the test function or `null` if not found
  */
-declare function findParentNode<A extends TSESTree.Node>(node: TSESTree.Node | unit, test: (n: TSESTree.Node) => n is A): A | unit;
+declare function findParentNode<A extends TSESTree.Node>(node: TSESTree.Node | null, test: (n: TSESTree.Node) => n is A): A | null;
 /**
- * Find the parent node that satisfies the test function or `_` if not found
+ * Find the parent node that satisfies the test function or `null` if not found
  * @param node The AST node
  * @param test The test function
  * @returns The parent node that satisfies the test function
  */
-declare function findParentNode(node: TSESTree.Node | unit, test: (node: TSESTree.Node) => boolean): TSESTree.Node | unit;
+declare function findParentNode(node: TSESTree.Node | null, test: (node: TSESTree.Node) => boolean): TSESTree.Node | null;
 //#endregion
-//#region src/process-env-node-env.d.ts
+//#region src/node-unwrap.d.ts
+/**
+ * Unwraps any type expressions to get the underlying JavaScript expression node.
+ * Recursively processes nodes until a non-type expression is found.
+ * @param node The AST node to unwrap
+ * @returns The underlying JavaScript expression node
+ */
+declare function getUnderlyingExpression(node: TSESTree.Node): Exclude<TSESTree.Node, TSESTreeTypeExpression>;
+//#endregion
+//#region src/pattern-process-env-node-env.d.ts
 /**
  * Check if the given node is a member expression that accesses `process.env.NODE_ENV`
  * @param node The AST node
  * @returns True if the node is a member expression that accesses `process.env.NODE_ENV`, false otherwise
  */
-declare function isProcessEnvNodeEnv(node: TSESTree.Node | null | unit): node is TSESTree.MemberExpression;
+declare function isProcessEnvNodeEnv(node: TSESTree.Node | null): node is TSESTree.MemberExpression;
 /**
  * Check if the given node is a binary expression that compares `process.env.NODE_ENV` with a string literal.
  * @param node The AST node
@@ -467,31 +477,40 @@ declare function isProcessEnvNodeEnv(node: TSESTree.Node | null | unit): node is
  * @param value The string literal value to compare against
  * @returns True if the node is a binary expression that compares `process.env.NODE_ENV` with the specified value, false otherwise
  */
-declare function isProcessEnvNodeEnvCompare(node: TSESTree.Node | null | unit, operator: "===" | "!==", value: "development" | "production"): node is TSESTree.BinaryExpression;
-//#endregion
-//#region src/property-name.d.ts
-/**
- * Get the name of a property from a node
- * Handles identifiers, private identifiers, literals, and template literals
- * @param node The node to get the property name from
- * @returns The property name or unit if not determinable
- */
-declare function getPropertyName(node: TSESTree.Node): string | unit;
+declare function isProcessEnvNodeEnvCompare(node: TSESTree.Node | null, operator: "===" | "!==", value: "development" | "production"): node is TSESTree.BinaryExpression;
 //#endregion
-//#region src/vitest-mock.d.ts
+//#region src/pattern-vitest-mock.d.ts
 /**
  * Check if the given node is a `vi.mock`.
  * @param node The node to check
  * @returns `true` if the node is a `vi.mock`, otherwise `false`.
  * @internal
  */
-declare function isViMock(node: TSESTree.Node | null | unit): node is TSESTree.MemberExpression;
+declare function isViMock(node: TSESTree.Node | null): node is TSESTree.MemberExpression;
 /**
  * Check if the given node is a `vi.mock` callback.
  * @param node The node to check
  * @returns `true` if the node is a `vi.mock` callback, otherwise `false`.
  * @internal
  */
-declare function isViMockCallback(node: TSESTree.Node | null | unit): boolean;
+declare function isViMockCallback(node: TSESTree.Node | null): boolean;
+//#endregion
+//#region src/property-name.d.ts
+/**
+ * Get the name of a property from a node
+ * Handles identifiers, private identifiers, literals, and template literals
+ * @param node The node to get the property name from
+ * @returns The property name or null if not determinable
+ */
+declare function getPropertyName(node: TSESTree.Node): string | null;
+//#endregion
+//#region src/property-traverse.d.ts
+/**
+ * Recursively traverses an object expression's properties to find a property with the specified name
+ * @param properties The properties of the object expression to traverse
+ * @param name The name of the property to find
+ * @returns The matching property node, or null if not found
+ */
+declare function findProperty(properties: TSESTree.ObjectLiteralElement[], name: string): TSESTree.Property | null;
 //#endregion
-export { DirectiveKind, DisplayNameAssignmentExpression, FunctionID, FunctionInitPath, ImplicitReturnArrowFunctionExpression, ObjectDestructuringVariableDeclarator, SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, TSESTreeArrayTupleType, TSESTreeClass, TSESTreeDestructuringPattern, TSESTreeDirective, TSESTreeDirectiveLike, TSESTreeFunction, TSESTreeFunctionType, TSESTreeJSX, TSESTreeJSXAttributeLike, TSESTreeLoop, TSESTreeMethodOrProperty, TSESTreeProperty, TSESTreeTypeAssertionExpression, TSESTreeTypeDeclaration, TSESTreeTypeExpression, findParentNode, getClassId, getFileDirectives, getFullyQualifiedName, getFunctionDirectives, getFunctionId, getFunctionInitPath, getHumanReadableKind, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getPropertyName, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isDirective, isDirectiveInFile, isDirectiveInFunction, isDirectiveKind, isDirectiveLike, isDirectiveName, isFunction, isFunctionEmpty, isFunctionImmediatelyInvoked, isFunctionType, isIdentifier, isIdentifierName, isJSX, isJSXElement, isJSXFragment, isJSXTagNameExpression, isLineBreak, isLiteral, isLoop, isMethodOrProperty, isMultiLine, isNodeEqual, isOneOf, isProcessEnvNodeEnv, isProcessEnvNodeEnvCompare, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression, isViMock, isViMockCallback };
+export { DirectiveKind, DisplayNameAssignmentExpression, FunctionID, FunctionInitPath, ImplicitReturnArrowFunctionExpression, ObjectDestructuringVariableDeclarator, SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, TSESTreeArrayTupleType, TSESTreeClass, TSESTreeDestructuringPattern, TSESTreeDirective, TSESTreeDirectiveLike, TSESTreeFunction, TSESTreeFunctionType, TSESTreeJSX, TSESTreeJSXAttributeLike, TSESTreeLoop, TSESTreeMethodOrProperty, TSESTreeProperty, TSESTreeTypeAssertionExpression, TSESTreeTypeDeclaration, TSESTreeTypeExpression, findParentNode, findProperty, getClassId, getFileDirectives, getFullyQualifiedName, getFunctionDirectives, getFunctionId, getFunctionInitPath, getHumanReadableKind, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getPropertyName, getRootIdentifier, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isDirective, isDirectiveInFile, isDirectiveInFunction, isDirectiveKind, isDirectiveLike, isDirectiveName, isFunction, isFunctionEmpty, isFunctionImmediatelyInvoked, isFunctionType, isIdentifier, isIdentifierName, isJSX, isJSXElement, isJSXFragment, isJSXTagNameExpression, isLineBreak, isLiteral, isLoop, isMethodOrProperty, isMultiLine, isNodeEqual, isOneOf, isProcessEnvNodeEnv, isProcessEnvNodeEnvCompare, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression, isViMock, isViMockCallback };

package/dist/index.js

@@ -1,5 +1,4 @@
-import { dual, or, unit } from "@eslint-react/eff";
-import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
 import { ASTUtils } from "@typescript-eslint/utils";
 import { simpleTraverse } from "@typescript-eslint/typescript-estree";
 import { delimiterCase, replace, toLowerCase } from "string-ts";
@@ -8,12 +7,12 @@ import { delimiterCase, replace, toLowerCase } from "string-ts";
 /**
 * Get the class identifier of a class node
 * @param node The class node to get the identifier from
-* @returns The class identifier or unit if not found
+* @returns The class identifier or null if not found
 */
 function getClassId(node) {
 	if (node.id != null) return node.id;
 	if (node.parent.type === AST_NODE_TYPES.VariableDeclarator) return node.parent.id;
-	return unit;
+	return null;
 }
 
 //#endregion
@@ -60,54 +59,6 @@ function isDirectiveLike(node) {
 	return node.type === AST_NODE_TYPES.ExpressionStatement && isLiteral(node.expression, "string") && isDirectiveName(node.expression.value);
 }
 
-//#endregion
-//#region src/directive-helper.ts
-/**
-* Get all directive expression statements from the top of a program AST node
-* @param node The program AST node
-* @returns The array of directive string literals (e.g., "use strict")
-*/
-function getFileDirectives(node) {
-	const directives = [];
-	for (const stmt of node.body) {
-		if (!isDirective(stmt)) continue;
-		directives.push(stmt);
-	}
-	return directives;
-}
-/**
-* Get all directive expression statements from the top of a function AST node
-* @param node The function AST node
-* @returns The array of directive string literals (e.g., "use memo", "use no memo")
-*/
-function getFunctionDirectives(node) {
-	const directives = [];
-	if (node.body.type !== AST_NODE_TYPES.BlockStatement) return directives;
-	for (const stmt of node.body.body) {
-		if (!isDirective(stmt)) continue;
-		directives.push(stmt);
-	}
-	return directives;
-}
-/**
-* Check if a directive with the given name exists in the file or function directives
-* @param node The program or function AST node
-* @param name The directive name to check (e.g., "use strict", "use memo", "use no memo")
-* @returns True if the directive exists, false otherwise
-*/
-function isDirectiveInFile(node, name) {
-	return getFileDirectives(node).some((d) => d.directive === name);
-}
-/**
-* Check if a directive with the given name exists in the function directives
-* @param node The function AST node
-* @param name The directive name to check (e.g., "use memo", "use no memo")
-* @returns True if the directive exists, false otherwise
-*/
-function isDirectiveInFunction(node, name) {
-	return getFunctionDirectives(node).some((d) => d.directive === name);
-}
-
 //#endregion
 //#region src/directive-kind.ts
 /**
@@ -119,6 +70,127 @@ function isDirectiveKind(kind) {
 	return kind === "use client" || kind === "use server" || kind === "use memo" || kind === "use no memo";
 }
 
+//#endregion
+//#region ../../../.pkgs/eff/dist/index.js
+function or(a, b) {
+	return (data) => a(data) || b(data);
+}
+/**
+* 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/node-is.ts
 /**
@@ -275,7 +347,7 @@ const isTypeAssertionExpression = isOneOf([
 ]);
 
 //#endregion
-//#region src/expression-base.ts
+//#region src/node-unwrap.ts
 /**
 * Unwraps any type expressions to get the underlying JavaScript expression node.
 * Recursively processes nodes until a non-type expression is found.
@@ -303,13 +375,13 @@ function isThisExpressionLoose(node) {
 //#endregion
 //#region src/node-traverse.ts
 function findParentNode(node, test) {
-	if (node == null) return unit;
+	if (node == null) return null;
 	let parent = node.parent;
 	while (parent != null && parent.type !== AST_NODE_TYPES.Program) {
 		if (test(parent)) return parent;
 		parent = parent.parent;
 	}
-	return unit;
+	return null;
 }
 
 //#endregion
@@ -495,6 +567,57 @@ const getNestedNewExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.NewExp
 */
 const getNestedCallExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.CallExpression);
 
+//#endregion
+//#region src/file-directive.ts
+/**
+* Get all directive expression statements from the top of a program AST node
+* @param node The program AST node
+* @returns The array of directive string literals (ex: "use strict")
+*/
+function getFileDirectives(node) {
+	const directives = [];
+	for (const stmt of node.body) {
+		if (!isDirective(stmt)) continue;
+		directives.push(stmt);
+	}
+	return directives;
+}
+/**
+* Check if a directive with the given name exists in the file or function directives
+* @param node The program or function AST node
+* @param name The directive name to check (ex: "use strict", "use memo", "use no memo")
+* @returns True if the directive exists, false otherwise
+*/
+function isDirectiveInFile(node, name) {
+	return getFileDirectives(node).some((d) => d.directive === name);
+}
+
+//#endregion
+//#region src/function-directive.ts
+/**
+* Get all directive expression statements from the top of a function AST node
+* @param node The function AST node
+* @returns The array of directive string literals (ex: "use memo", "use no memo")
+*/
+function getFunctionDirectives(node) {
+	const directives = [];
+	if (node.body.type !== AST_NODE_TYPES.BlockStatement) return directives;
+	for (const stmt of node.body.body) {
+		if (!isDirective(stmt)) continue;
+		directives.push(stmt);
+	}
+	return directives;
+}
+/**
+* Check if a directive with the given name exists in the function directives
+* @param node The function AST node
+* @param name The directive name to check (ex: "use memo", "use no memo")
+* @returns True if the directive exists, false otherwise
+*/
+function isDirectiveInFunction(node, name) {
+	return getFunctionDirectives(node).some((d) => d.directive === name);
+}
+
 //#endregion
 //#region src/function-id.ts
 /**
@@ -515,7 +638,7 @@ function getFunctionId(node) {
 		case node.parent.type === AST_NODE_TYPES.ConditionalExpression: return getFunctionId(node.parent);
 		case isTypeAssertionExpression(node.parent): return getFunctionId(node.parent);
 	}
-	return unit;
+	return null;
 }
 
 //#endregion
@@ -525,11 +648,12 @@ function getFunctionId(node) {
 * Determine what kind of component declaration pattern the function belongs to.
 *
 * @param node The function node to analyze
-* @returns The function initialization path or unit if not identifiable
+* @returns The function initialization path or null if not identifiable
 */
 function getFunctionInitPath(node) {
 	if (node.type === AST_NODE_TYPES.FunctionDeclaration) return [node];
-	const { parent } = node;
+	let parent = node.parent;
+	while (isTypeExpression(parent)) parent = parent.parent;
 	switch (true) {
 		case parent.type === AST_NODE_TYPES.VariableDeclarator: return [
 			parent.parent,
@@ -569,13 +693,13 @@ function getFunctionInitPath(node) {
 			node
 		];
 	}
-	return unit;
+	return null;
 }
 /**
 * Check if a specific function call exists in the function initialization path.
 * Useful for detecting HOCs like React.memo, React.forwardRef, etc.
 *
-* @param callName The name of the call to check for (e.g., "memo", "forwardRef")
+* @param callName The name of the call to check for (ex: "memo", "forwardRef")
 * @param initPath The function initialization path to search in
 * @returns True if the call exists in the path, false otherwise
 */
@@ -632,7 +756,24 @@ function isIdentifierName(name) {
 }
 
 //#endregion
-//#region src/node-equal.ts
+//#region src/identifier-traverse.ts
+/**
+* Get the root identifier of a (possibly nested) member expression.
+* For `a.b.c`, returns the `a` Identifier node.
+* @param node The expression to analyze
+* @returns The root Identifier node, or null if it cannot be determined (ex: non-identifier root)
+*/
+function getRootIdentifier(node) {
+	const expr = getUnderlyingExpression(node);
+	switch (expr.type) {
+		case AST_NODE_TYPES.Identifier: return expr;
+		case AST_NODE_TYPES.MemberExpression: return getRootIdentifier(expr.object);
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/node-equality.ts
 /**
 * Check if two nodes are equal
 * @param a node to compare
@@ -734,7 +875,7 @@ const SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION = [
 ].join("");
 
 //#endregion
-//#region src/process-env-node-env.ts
+//#region src/pattern-process-env-node-env.ts
 /**
 * Check if the given node is a member expression that accesses `process.env.NODE_ENV`
 * @param node The AST node
@@ -760,23 +901,7 @@ function isProcessEnvNodeEnvCompare(node, operator, value) {
 }
 
 //#endregion
-//#region src/property-name.ts
-/**
-* Get the name of a property from a node
-* Handles identifiers, private identifiers, literals, and template literals
-* @param node The node to get the property name from
-* @returns The property name or unit if not determinable
-*/
-function getPropertyName(node) {
-	if (isTypeExpression(node)) return getPropertyName(getUnderlyingExpression(node));
-	if (node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier) return node.name;
-	if (node.type === AST_NODE_TYPES.Literal) return String(node.value);
-	if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) return node.quasis[0]?.value.raw;
-	return unit;
-}
-
-//#endregion
-//#region src/vitest-mock.ts
+//#region src/pattern-vitest-mock.ts
 /**
 * Check if the given node is a `vi.mock`.
 * @param node The node to check
@@ -797,4 +922,39 @@ function isViMockCallback(node) {
 }
 
 //#endregion
-export { SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, findParentNode, getClassId, getFileDirectives, getFullyQualifiedName, getFunctionDirectives, getFunctionId, getFunctionInitPath, getHumanReadableKind, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getPropertyName, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isDirective, isDirectiveInFile, isDirectiveInFunction, isDirectiveKind, isDirectiveLike, isDirectiveName, isFunction, isFunctionEmpty, isFunctionImmediatelyInvoked, isFunctionType, isIdentifier, isIdentifierName, isJSX, isJSXElement, isJSXFragment, isJSXTagNameExpression, isLineBreak, isLiteral, isLoop, isMethodOrProperty, isMultiLine, isNodeEqual, isOneOf, isProcessEnvNodeEnv, isProcessEnvNodeEnvCompare, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression, isViMock, isViMockCallback };
+//#region src/property-name.ts
+/**
+* Get the name of a property from a node
+* Handles identifiers, private identifiers, literals, and template literals
+* @param node The node to get the property name from
+* @returns The property name or null if not determinable
+*/
+function getPropertyName(node) {
+	if (isTypeExpression(node)) return getPropertyName(getUnderlyingExpression(node));
+	if (node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier) return node.name;
+	if (node.type === AST_NODE_TYPES.Literal) return String(node.value);
+	if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
+	return null;
+}
+
+//#endregion
+//#region src/property-traverse.ts
+/**
+* Recursively traverses an object expression's properties to find a property with the specified name
+* @param properties The properties of the object expression to traverse
+* @param name The name of the property to find
+* @returns The matching property node, or null if not found
+*/
+function findProperty(properties, name) {
+	for (const prop of properties) {
+		if (prop.type === AST_NODE_TYPES.Property && getPropertyName(prop.key) === name) return prop;
+		if (prop.type === AST_NODE_TYPES.SpreadElement && prop.argument.type === AST_NODE_TYPES.ObjectExpression) {
+			const found = findProperty(prop.argument.properties, name);
+			if (found != null) return found;
+		}
+	}
+	return null;
+}
+
+//#endregion
+export { SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, findParentNode, findProperty, getClassId, getFileDirectives, getFullyQualifiedName, getFunctionDirectives, getFunctionId, getFunctionInitPath, getHumanReadableKind, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getPropertyName, getRootIdentifier, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isDirective, isDirectiveInFile, isDirectiveInFunction, isDirectiveKind, isDirectiveLike, isDirectiveName, isFunction, isFunctionEmpty, isFunctionImmediatelyInvoked, isFunctionType, isIdentifier, isIdentifierName, isJSX, isJSXElement, isJSXFragment, isJSXTagNameExpression, isLineBreak, isLiteral, isLoop, isMethodOrProperty, isMultiLine, isNodeEqual, isOneOf, isProcessEnvNodeEnv, isProcessEnvNodeEnvCompare, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression, isViMock, isViMockCallback };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/ast",
-  "version": "3.0.0-next.9",
+  "version": "3.0.0-rc.0",
   "description": "ESLint React's TSESTree AST utility module.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -33,16 +33,16 @@
     "@typescript-eslint/types": "canary",
     "@typescript-eslint/typescript-estree": "canary",
     "@typescript-eslint/utils": "canary",
-    "string-ts": "^2.3.1",
-    "@eslint-react/eff": "3.0.0-next.9"
+    "string-ts": "^2.3.1"
   },
   "devDependencies": {
-    "tsdown": "^0.20.3",
-    "@local/configs": "0.0.0"
+    "tsdown": "^0.21.0",
+    "@local/configs": "0.0.0",
+    "@local/eff": "3.0.0-beta.72"
   },
   "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"
@@ -50,6 +50,6 @@
   "scripts": {
     "build": "tsdown --dts-resolve",
     "lint:publish": "publint",
-    "lint:ts": "tsc --noEmit"
+    "lint:ts": "tsl"
   }
 }