@eslint-react/ast 2.8.2-beta.0 → 2.8.2-beta.4

package/dist/index.d.ts

@@ -18,11 +18,41 @@ type TSESTreeTypeExpression = TSESTree$1.TSAsExpression | TSESTree$1.TSNonNullEx
 type TSESTreeTypeAssertionExpression = TSESTree$1.TSAsExpression | TSESTree$1.TSNonNullExpression | TSESTree$1.TSSatisfiesExpression | TSESTree$1.TSTypeAssertion;
 //#endregion
 //#region src/class-id.d.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
+ */
 declare function getClassId(node: TSESTreeClass): TSESTree.BindingName | unit;
 //#endregion
+//#region src/directive-is.d.ts
+/**
+ * Check if a node is a directive
+ * @param node The node to check
+ * @returns True if the node is a directive, false otherwise
+ */
+declare function isDirective(node: TSESTree.Node): node is TSESTree.StringLiteral;
+//#endregion
+//#region src/directive-kind.d.ts
+type DirectiveKind = "use client" | "use server" | "use memo" | "use no memo";
+/**
+ * Check if a node is a directive kind
+ * @param kind The kind to check
+ * @returns True if the kind is a directive kind, false otherwise
+ */
+declare function isDirectiveKind(kind: string): kind is DirectiveKind;
+//#endregion
+//#region src/directive-name.d.ts
+/**
+ * Check if a string is a directive name
+ * @param name The string to check
+ * @returns True if the string is a directive name, false otherwise
+ */
+declare function isDirectiveName(name: string): boolean;
+//#endregion
 //#region src/equal.d.ts
 /**
- * Determine whether node equals to another node
+ * Check if two nodes are equal
  * @param a node to compare
  * @param b node to compare
  * @returns `true` if node equal
@@ -44,11 +74,11 @@ declare function getUnderlyingExpression(node: TSESTree.Node): Exclude<TSESTree.
 //#endregion
 //#region src/expression-is.d.ts
 /**
- * Check if the given expression is a 'this' expression.
- * Unwraps any type expressions before checking.
+ * Check if the given expression is a 'this' expression
+ * Unwraps any type expressions before checking
  *
  * @param node The expression node to check
- * @returns true if the expression is a ThisExpression, false otherwise
+ * @returns True if the expression is a 'this' expression, false otherwise
  */
 declare function isThisExpressionLoose(node: TSESTree.Expression): boolean;
 //#endregion
@@ -87,7 +117,31 @@ declare const getNestedNewExpressions: (node: TSESTree.Node) => TSESTree.NewExpr
  */
 declare const getNestedCallExpressions: (node: TSESTree.Node) => TSESTree.CallExpression[];
 //#endregion
-//#region src/function-directives.d.ts
+//#region src/file-directive.d.ts
+/**
+ * Get all directive string literals from a program node
+ * @param node The program AST node
+ * @returns The array of directive string literals (e.g., "use strict")
+ */
+declare function getFileDirectives(node: TSESTree.Program): TSESTree.StringLiteral[];
+//#endregion
+//#region src/format.d.ts
+/**
+ * Convert a node type to a delimiter format string
+ * @param node The AST node
+ * @param delimiter The delimiter to use
+ * @returns The delimiter format string
+ */
+declare function toDelimiterFormat(node: TSESTree.Node, delimiter?: string): "RegExp literal" | Lowercase<string> | `JSX ${Lowercase<string>}`;
+/**
+ * Incomplete but sufficient stringification of AST nodes for common use cases
+ * @param node The AST node
+ * @param getText A function to get the text representation of a node
+ * @returns A string representation of the node
+ */
+declare function toStringFormat(node: TSESTree.Node, getText: (node: TSESTree.Node) => string): string;
+//#endregion
+//#region src/function-directive.d.ts
 /**
  * Get all directive string literals from a function node
  * @param node The function AST node
@@ -108,8 +162,8 @@ type FunctionID = ReturnType<typeof getFunctionId>;
 //#endregion
 //#region src/function-init-path.d.ts
 /**
- * Represents various AST paths for React component function declarations.
- * Each tuple type represents a specific component definition pattern.
+ * Represents various AST paths for React component function declarations
+ * Each tuple type represents a specific component definition pattern
  */
 type FunctionInitPath = readonly [TSESTree.FunctionDeclaration] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.CallExpression, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTree.CallExpression, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.ClassDeclaration, TSESTree.ClassBody, TSESTree.MethodDefinition, TSESTreeFunction] | readonly [TSESTree.ClassDeclaration, TSESTree.ClassBody, TSESTree.PropertyDefinition, TSESTreeFunction];
 /**
@@ -131,12 +185,27 @@ declare function getFunctionInitPath(node: TSESTreeFunction): unit | FunctionIni
 declare function hasCallInFunctionInitPath(callName: string, initPath: FunctionInitPath): boolean;
 //#endregion
 //#region src/function-is.d.ts
+/**
+ * Check if a function is empty
+ * @param node The function node to check
+ * @returns True if the function is empty, false otherwise
+ */
 declare function isFunctionEmpty(node: TSESTreeFunction): boolean;
+/**
+ * Check if a function is immediately invoked
+ * @param node The function node to check
+ * @returns True if the function is immediately invoked, false otherwise
+ */
 declare function isFunctionImmediatelyInvoked(node: TSESTreeFunction): boolean;
 //#endregion
 //#region src/identifier-is.d.ts
-declare function isNaN(node: TSESTree.Node | null | unit): node is TSESTree.Identifier;
-declare function isUndefined(node: TSESTree.Node | null | unit): node is TSESTree.Identifier;
+/**
+ * Check if the given node is an identifier
+ * @param node The node to check
+ * @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;
 //#endregion
 //#region src/identifier-name.d.ts
 declare function isIdentifierName(name: string): boolean;
@@ -171,33 +240,19 @@ 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/misc.d.ts
+//#region src/location.d.ts
 /**
- * Check if a node is multiline
+ * Check if a node spans multiple lines
  * @param node The AST node to check
- * @returns  `true` if the node is multiline
+ * @returns `true` if the node spans multiple lines, `false` otherwise
  */
 declare function isMultiLine(node: TSESTree.Node): boolean;
 /**
- * Check if a node is a line break
+ * Check if a node is a line break (whitespace spanning multiple lines)
  * @param node The AST node to check
- * @returns boolean
+ * @returns `true` if the node is a line break, `false` otherwise
  */
 declare function isLineBreak(node: TSESTree.Node): boolean;
-/**
- * Convert a node type to a delimiter format string
- * @param node The AST node
- * @param delimiter The delimiter to use
- * @returns The delimiter format string
- */
-declare function toDelimiterFormat(node: TSESTree.Node, delimiter?: string): "RegExp literal" | Lowercase<string> | `JSX ${Lowercase<string>}`;
-/**
- * Incomplete but sufficient stringification of AST nodes for common use cases
- * @param node The AST node
- * @param getText A function to get the text representation of a node
- * @returns A string representation of the node
- */
-declare function toStringFormat(node: TSESTree.Node, getText: (node: TSESTree.Node) => string): string;
 //#endregion
 //#region src/process-env-node-env.d.ts
 /**
@@ -215,14 +270,6 @@ declare function isProcessEnvNodeEnv(node: TSESTree.Node | null | unit): node is
  */
 declare function isProcessEnvNodeEnvCompare(node: TSESTree.Node | null | unit, operator: "===" | "!==", value: "development" | "production"): node is TSESTree.BinaryExpression;
 //#endregion
-//#region src/program-directives.d.ts
-/**
- * Get all directive string literals from a program node
- * @param node The program AST node
- * @returns The array of directive string literals (e.g., "use strict")
- */
-declare function getProgramDirectives(node: TSESTree.Program): TSESTree.StringLiteral[];
-//#endregion
 //#region src/property-name.d.ts
 declare function getPropertyName(node: TSESTree.Node): string | unit;
 //#endregion
@@ -280,4 +327,4 @@ declare function isViMock(node: TSESTree.Node | null | unit): node is TSESTree.M
  */
 declare function isViMockCallback(node: TSESTree.Node | null | unit): boolean;
 //#endregion
-export { DisplayNameAssignmentExpression, FunctionID, FunctionInitPath, ImplicitReturnArrowFunctionExpression, ObjectDestructuringVariableDeclarator, SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, TSESTreeArrayTupleType, TSESTreeClass, TSESTreeDestructuringPattern, TSESTreeFunction, TSESTreeFunctionType, TSESTreeJSX, TSESTreeJSXAttributeLike, TSESTreeLoop, TSESTreeMethodOrProperty, TSESTreeProperty, TSESTreeTypeAssertionExpression, TSESTreeTypeDeclaration, TSESTreeTypeExpression, findParentNode, getClassId, getFunctionDirectives, getFunctionId, getFunctionInitPath, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getProgramDirectives, getPropertyName, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isFunction, isFunctionEmpty, isFunctionImmediatelyInvoked, isFunctionType, isIdentifierName, isJSX, isJSXElement, isJSXFragment, isJSXTagNameExpression, isLineBreak, isLiteral, isLoop, isMethodOrProperty, isMultiLine, isNaN, isNodeEqual, isOneOf, isProcessEnvNodeEnv, isProcessEnvNodeEnvCompare, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression, isUndefined, isViMock, isViMockCallback, toDelimiterFormat, toStringFormat };
+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, TSESTreeFunction, TSESTreeFunctionType, TSESTreeJSX, TSESTreeJSXAttributeLike, TSESTreeLoop, TSESTreeMethodOrProperty, TSESTreeProperty, TSESTreeTypeAssertionExpression, TSESTreeTypeDeclaration, TSESTreeTypeExpression, findParentNode, getClassId, getFileDirectives, getFunctionDirectives, getFunctionId, getFunctionInitPath, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getPropertyName, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isDirective, isDirectiveKind, 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, toDelimiterFormat, toStringFormat };

package/dist/index.js

@@ -5,12 +5,64 @@ import { simpleTraverse } from "@typescript-eslint/typescript-estree";
 import { delimiterCase, replace, toLowerCase } from "string-ts";
 
 //#region src/class-id.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
+*/
 function getClassId(node) {
 	if (node.id != null) return node.id;
 	if (node.parent.type === AST_NODE_TYPES.VariableDeclarator) return node.parent.id;
 	return unit;
 }
 
+//#endregion
+//#region src/directive-name.ts
+/**
+* Check if a string is a directive name
+* @param name The string to check
+* @returns True if the string is a directive name, false otherwise
+*/
+function isDirectiveName(name) {
+	return name.startsWith("use ") && name.length > 4;
+}
+
+//#endregion
+//#region src/literal.ts
+function isLiteral(node, type) {
+	if (node.type !== AST_NODE_TYPES.Literal) return false;
+	if (type == null) return true;
+	switch (type) {
+		case "boolean": return typeof node.value === "boolean";
+		case "null": return node.value === null;
+		case "number": return typeof node.value === "number";
+		case "regexp": return "regex" in node;
+		case "string": return typeof node.value === "string";
+	}
+}
+
+//#endregion
+//#region src/directive-is.ts
+/**
+* Check if a node is a directive
+* @param node The node to check
+* @returns True if the node is a directive, false otherwise
+*/
+function isDirective(node) {
+	return isLiteral(node, "string") && isDirectiveName(node.value);
+}
+
+//#endregion
+//#region src/directive-kind.ts
+/**
+* Check if a node is a directive kind
+* @param kind The kind to check
+* @returns True if the kind is a directive kind, false otherwise
+*/
+function isDirectiveKind(kind) {
+	return kind === "use client" || kind === "use server" || kind === "use memo" || kind === "use no memo";
+}
+
 //#endregion
 //#region src/is.ts
 const is = ASTUtils.isNodeOfType;
@@ -102,7 +154,7 @@ function getUnderlyingExpression(node) {
 //#endregion
 //#region src/equal.ts
 /**
-* Determine whether node equals to another node
+* Check if two nodes are equal
 * @param a node to compare
 * @param b node to compare
 * @returns `true` if node equal
@@ -143,11 +195,11 @@ const isNodeEqual = dual(2, (a, b) => {
 //#endregion
 //#region src/expression-is.ts
 /**
-* Check if the given expression is a 'this' expression.
-* Unwraps any type expressions before checking.
+* Check if the given expression is a 'this' expression
+* Unwraps any type expressions before checking
 *
 * @param node The expression node to check
-* @returns true if the expression is a ThisExpression, false otherwise
+* @returns True if the expression is a 'this' expression, false otherwise
 */
 function isThisExpressionLoose(node) {
 	return getUnderlyingExpression(node).type === AST_NODE_TYPES.ThisExpression;
@@ -349,21 +401,62 @@ const getNestedNewExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.NewExp
 const getNestedCallExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.CallExpression);
 
 //#endregion
-//#region src/literal.ts
-function isLiteral(node, type) {
-	if (node.type !== AST_NODE_TYPES.Literal) return false;
-	if (type == null) return true;
-	switch (type) {
-		case "boolean": return typeof node.value === "boolean";
-		case "null": return node.value === null;
-		case "number": return typeof node.value === "number";
-		case "regexp": return "regex" in node;
-		case "string": return typeof node.value === "string";
+//#region src/file-directive.ts
+/**
+* Get all directive string literals from a program 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 (stmt.type !== AST_NODE_TYPES.ExpressionStatement) continue;
+		const expr = getUnderlyingExpression(stmt.expression);
+		if (!isDirective(expr)) continue;
+		directives.push(expr);
 	}
+	return directives;
 }
 
 //#endregion
-//#region src/function-directives.ts
+//#region src/format.ts
+/**
+* Convert a node type to a delimiter format string
+* @param node The AST node
+* @param delimiter The delimiter to use
+* @returns The delimiter format string
+*/
+function toDelimiterFormat(node, delimiter = " ") {
+	if (node.type === AST_NODE_TYPES.Literal) {
+		if ("regex" in node) return "RegExp literal";
+		if (node.value === null) return "null literal";
+		return `${typeof node.value} literal`;
+	}
+	if (isJSX(node)) return `JSX ${toLowerCase(delimiterCase(replace(node.type, "JSX", ""), delimiter))}`;
+	return toLowerCase(delimiterCase(node.type, delimiter));
+}
+/**
+* Incomplete but sufficient stringification of AST nodes for common use cases
+* @param node The AST node
+* @param getText A function to get the text representation of a node
+* @returns A string representation of the node
+*/
+function toStringFormat(node, getText) {
+	switch (node.type) {
+		case AST_NODE_TYPES.Identifier:
+		case AST_NODE_TYPES.JSXIdentifier:
+		case AST_NODE_TYPES.PrivateIdentifier: return node.name;
+		case AST_NODE_TYPES.MemberExpression:
+		case AST_NODE_TYPES.JSXMemberExpression: return `${toStringFormat(node.object, getText)}.${toStringFormat(node.property, getText)}`;
+		case AST_NODE_TYPES.JSXNamespacedName: return `${node.namespace.name}:${node.name.name}`;
+		case AST_NODE_TYPES.JSXText: return node.value;
+		case AST_NODE_TYPES.Literal: return node.raw;
+		default: return getText(node);
+	}
+}
+
+//#endregion
+//#region src/function-directive.ts
 /**
 * Get all directive string literals from a function node
 * @param node The function AST node
@@ -375,7 +468,7 @@ function getFunctionDirectives(node) {
 	for (const stmt of node.body.body) {
 		if (stmt.type !== AST_NODE_TYPES.ExpressionStatement) continue;
 		const expr = getUnderlyingExpression(stmt.expression);
-		if (!isLiteral(expr, "string")) continue;
+		if (!isDirective(expr)) continue;
 		directives.push(expr);
 	}
 	return directives;
@@ -476,20 +569,33 @@ function hasCallInFunctionInitPath(callName, initPath) {
 
 //#endregion
 //#region src/function-is.ts
+/**
+* Check if a function is empty
+* @param node The function node to check
+* @returns True if the function is empty, false otherwise
+*/
 function isFunctionEmpty(node) {
 	return node.body.type === AST_NODE_TYPES.BlockStatement && node.body.body.length === 0;
 }
+/**
+* Check if a function is immediately invoked
+* @param node The function node to check
+* @returns True if the function is immediately invoked, false otherwise
+*/
 function isFunctionImmediatelyInvoked(node) {
 	return node.type !== AST_NODE_TYPES.FunctionDeclaration && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node;
 }
 
 //#endregion
 //#region src/identifier-is.ts
-function isNaN(node) {
-	return node != null && node.type === AST_NODE_TYPES.Identifier && node.name === "NaN";
-}
-function isUndefined(node) {
-	return node != null && node.type === AST_NODE_TYPES.Identifier && node.name === "undefined";
+/**
+* Check if the given node is an identifier
+* @param node The node to check
+* @param name The name to check
+* @returns True if the node is an identifier, false otherwise
+*/
+function isIdentifier(node, name) {
+	return node != null && node.type === AST_NODE_TYPES.Identifier && (name == null || node.name === name);
 }
 
 //#endregion
@@ -499,65 +605,23 @@ function isIdentifierName(name) {
 }
 
 //#endregion
-//#region src/misc.ts
+//#region src/location.ts
 /**
-* Check if a node is multiline
+* Check if a node spans multiple lines
 * @param node The AST node to check
-* @returns  `true` if the node is multiline
+* @returns `true` if the node spans multiple lines, `false` otherwise
 */
 function isMultiLine(node) {
 	return node.loc.start.line !== node.loc.end.line;
 }
 /**
-* Check if a node is a line break
+* Check if a node is a line break (whitespace spanning multiple lines)
 * @param node The AST node to check
-* @returns boolean
+* @returns `true` if the node is a line break, `false` otherwise
 */
 function isLineBreak(node) {
 	return isOneOf([AST_NODE_TYPES.Literal, AST_NODE_TYPES.JSXText])(node) && typeof node.value === "string" && node.value.trim() === "" && isMultiLine(node);
 }
-/**
-* Get the type of a literal value
-* @param input The literal value
-* @returns The type of the literal value
-*/
-function getLiteralValueType(input) {
-	if (input === null) return "null";
-	return typeof input;
-}
-/**
-* Convert a node type to a delimiter format string
-* @param node The AST node
-* @param delimiter The delimiter to use
-* @returns The delimiter format string
-*/
-function toDelimiterFormat(node, delimiter = " ") {
-	if (node.type === AST_NODE_TYPES.Literal) {
-		if ("regex" in node) return "RegExp literal";
-		return `${getLiteralValueType(node.value)} literal`;
-	}
-	if (isJSX(node)) return `JSX ${toLowerCase(delimiterCase(replace(node.type, "JSX", ""), delimiter))}`;
-	return toLowerCase(delimiterCase(node.type, delimiter));
-}
-/**
-* Incomplete but sufficient stringification of AST nodes for common use cases
-* @param node The AST node
-* @param getText A function to get the text representation of a node
-* @returns A string representation of the node
-*/
-function toStringFormat(node, getText) {
-	switch (node.type) {
-		case AST_NODE_TYPES.Identifier:
-		case AST_NODE_TYPES.JSXIdentifier:
-		case AST_NODE_TYPES.PrivateIdentifier: return node.name;
-		case AST_NODE_TYPES.MemberExpression:
-		case AST_NODE_TYPES.JSXMemberExpression: return `${toStringFormat(node.object, getText)}.${toStringFormat(node.property, getText)}`;
-		case AST_NODE_TYPES.JSXNamespacedName: return `${node.namespace.name}:${node.name.name}`;
-		case AST_NODE_TYPES.JSXText: return node.value;
-		case AST_NODE_TYPES.Literal: return node.raw;
-		default: return getText(node);
-	}
-}
 
 //#endregion
 //#region src/process-env-node-env.ts
@@ -585,24 +649,6 @@ function isProcessEnvNodeEnvCompare(node, operator, value) {
 	return false;
 }
 
-//#endregion
-//#region src/program-directives.ts
-/**
-* Get all directive string literals from a program node
-* @param node The program AST node
-* @returns The array of directive string literals (e.g., "use strict")
-*/
-function getProgramDirectives(node) {
-	const directives = [];
-	for (const stmt of node.body) {
-		if (stmt.type !== AST_NODE_TYPES.ExpressionStatement) continue;
-		const expr = getUnderlyingExpression(stmt.expression);
-		if (!isLiteral(expr, "string")) continue;
-		directives.push(expr);
-	}
-	return directives;
-}
-
 //#endregion
 //#region src/property-name.ts
 function getPropertyName(node) {
@@ -650,4 +696,4 @@ function isViMockCallback(node) {
 }
 
 //#endregion
-export { SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, findParentNode, getClassId, getFunctionDirectives, getFunctionId, getFunctionInitPath, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getProgramDirectives, getPropertyName, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isFunction, isFunctionEmpty, isFunctionImmediatelyInvoked, isFunctionType, isIdentifierName, isJSX, isJSXElement, isJSXFragment, isJSXTagNameExpression, isLineBreak, isLiteral, isLoop, isMethodOrProperty, isMultiLine, isNaN, isNodeEqual, isOneOf, isProcessEnvNodeEnv, isProcessEnvNodeEnvCompare, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression, isUndefined, isViMock, isViMockCallback, toDelimiterFormat, toStringFormat };
+export { SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, findParentNode, getClassId, getFileDirectives, getFunctionDirectives, getFunctionId, getFunctionInitPath, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getPropertyName, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isDirective, isDirectiveKind, 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, toDelimiterFormat, toStringFormat };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/ast",
-  "version": "2.8.2-beta.0",
+  "version": "2.8.2-beta.4",
   "description": "ESLint React's TSESTree AST utility module.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -34,7 +34,7 @@
     "@typescript-eslint/typescript-estree": "^8.54.0",
     "@typescript-eslint/utils": "^8.54.0",
     "string-ts": "^2.3.1",
-    "@eslint-react/eff": "2.8.2-beta.0"
+    "@eslint-react/eff": "2.8.2-beta.4"
   },
   "devDependencies": {
     "tsdown": "^0.20.1",