@eslint-react/ast 5.2.1-next.3 → 5.2.2-next.0

package/dist/chunk-BYypO7fO.js

@@ -0,0 +1,18 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/dist/index.d.ts

@@ -1,205 +1,77 @@
-import { TSESTree } from "@typescript-eslint/types";
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
 
-//#region src/expression-is.d.ts
-/**
- * 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 'this' expression, false otherwise
- */
-declare function isThisExpressionLoose(node: TSESTree.Expression): boolean;
-//#endregion
-//#region src/file.d.ts
-/**
- * Check if a directive with the given name exists in the file directives
- * @param node The program 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 isFileHasDirective(node: TSESTree.Program, name: string): boolean;
-//#endregion
-//#region src/identifier-is.d.ts
-/**
- * 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, name?: string): node is TSESTree.Identifier;
-//#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
- * @param node The node to check
- * @returns True if the node is a literal
- */
-declare function isLiteral(node: TSESTree.Node): node is TSESTree.Literal;
-declare function isLiteral(node: TSESTree.Node, type: "boolean"): node is TSESTree.BooleanLiteral;
-declare function isLiteral(node: TSESTree.Node, type: "null"): node is TSESTree.NullLiteral;
-declare function isLiteral(node: TSESTree.Node, type: "number"): node is TSESTree.NumberLiteral;
-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-equality.d.ts
-/**
- * Check if two nodes are equal
- * @param a node to compare
- * @param b node to compare
- * @returns `true` if node equal
- * @see https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/isNodeEqual.ts
- */
-declare const isNodeEqual: {
-  (a: TSESTree.Node): (b: TSESTree.Node) => boolean;
-  (a: TSESTree.Node, b: TSESTree.Node): boolean;
-};
-//#endregion
-//#region src/node-types.d.ts
-/**
- * Represents function expressions and declarations in TSESTree
- */
-type TSESTreeFunction = TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression;
-/**
- * Represents class declarations and expressions in TSESTree
- */
-type TSESTreeClass = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
-/**
- * Represents method definitions and property definitions in classes
- */
-type TSESTreeMethodOrProperty = TSESTree.PropertyDefinition | TSESTree.MethodDefinition;
-/**
- * Represents all JSX-related nodes in TSESTree
- * Note: This type is for type-level operations. The isJSX() runtime guard in node-is.ts
- * has a slightly different set of nodes as it includes JSXExpressionContainer which is
- * commonly needed for runtime checks but not included in this type union.
- */
-type TSESTreeJSX = TSESTree.JSXAttribute | TSESTree.JSXChild | TSESTree.JSXClosingElement | TSESTree.JSXClosingFragment | TSESTree.JSXEmptyExpression | TSESTree.JSXIdentifierToken | TSESTree.JSXOpeningElement | TSESTree.JSXOpeningFragment | TSESTree.JSXSpreadAttribute | TSESTree.JSXTagNameExpression | TSESTree.JSXTextToken;
-type TSESTreeJSXElementLike = TSESTree.JSXElement | TSESTree.JSXFragment;
-/**
- * Represents JSX attribute-like nodes (attributes and spread attributes)
- */
-type TSESTreeJSXAttributeLike = TSESTree.JSXAttribute | TSESTree.JSXSpreadAttribute;
-/**
- * Represents a directive expression statement in TSESTree (ex: "use strict";)
- */
-type TSESTreeDirective = TSESTree.ExpressionStatement & {
+//#region src/types.d.ts
+type Node = TSESTree.Node;
+type Program = TSESTree.Program;
+type Expression = TSESTree.Expression;
+type Statement = TSESTree.Statement;
+type Identifier = TSESTree.Identifier;
+type FunctionExpression = TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression;
+type ClassExpression = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
+type MethodOrPropertyDefinition = TSESTree.PropertyDefinition | TSESTree.MethodDefinition;
+type JSXNode = TSESTree.JSXAttribute | TSESTree.JSXChild | TSESTree.JSXClosingElement | TSESTree.JSXClosingFragment | TSESTree.JSXEmptyExpression | TSESTree.JSXIdentifierToken | TSESTree.JSXOpeningElement | TSESTree.JSXOpeningFragment | TSESTree.JSXSpreadAttribute | TSESTree.JSXTagNameExpression | TSESTree.JSXTextToken;
+type JSXElementLike = TSESTree.JSXElement | TSESTree.JSXFragment;
+type JSXAttributeLike = TSESTree.JSXAttribute | TSESTree.JSXSpreadAttribute;
+type Directive = TSESTree.ExpressionStatement & {
   directive: string;
   expression: TSESTree.StringLiteral;
 };
-type TSESTreeTypeExpression = TSESTree.TSAsExpression | TSESTree.TSTypeAssertion | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSInstantiationExpression;
-//#endregion
-//#region src/node-is.d.ts
-/**
- * Type guard to check if a node is of a specific AST node type
- * @param nodeType The AST node type to check against
- * @returns A type guard function that narrows the node type
- */
-declare const is: <NodeType extends TSESTree.AST_NODE_TYPES>(nodeType: NodeType) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.Node, {
+type TypeExpression = TSESTree.TSAsExpression | TSESTree.TSTypeAssertion | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSInstantiationExpression;
+declare namespace check_d_exports {
+  export { directive, identifier, is, isClass, isFunction, isJSX, isJSXElement, isJSXFragment, isJSXLike, isJSXTagNameExpression, isMethodOrProperty, isOneOf, isProperty, isTypeAssertionExpression, isTypeExpression, literal, thisExpression };
+}
+declare const is: <NodeType extends AST_NODE_TYPES>(nodeType: NodeType) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.Node, {
   type: NodeType;
 }>;
-/**
- * Type guard to check if a node is one of multiple AST node types
- * @param nodeTypes Array of AST node types to check against
- * @returns A type guard function that narrows the node type
- */
-declare const isOneOf: <NodeTypes extends readonly TSESTree.AST_NODE_TYPES[]>(nodeTypes: NodeTypes) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.Node, {
+declare const isOneOf: <NodeTypes extends readonly AST_NODE_TYPES[]>(nodeTypes: NodeTypes) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.Node, {
   type: NodeTypes[number];
 }>;
-/**
- * Check if a node is a function (arrow, declaration, or expression)
- * @param node The node to check
- * @returns True if the node is a function
- */
+declare function identifier(node: TSESTree.Node | null, named?: string): node is TSESTree.Identifier;
+declare function literal(node: TSESTree.Node): node is TSESTree.Literal;
+declare function literal(node: TSESTree.Node, ofKind: "boolean"): node is TSESTree.BooleanLiteral;
+declare function literal(node: TSESTree.Node, ofKind: "null"): node is TSESTree.NullLiteral;
+declare function literal(node: TSESTree.Node, ofKind: "number"): node is TSESTree.NumberLiteral;
+declare function literal(node: TSESTree.Node, ofKind: "regexp"): node is TSESTree.RegExpLiteral;
+declare function literal(node: TSESTree.Node, ofKind: "string"): node is TSESTree.StringLiteral;
+declare function thisExpression(expression: TSESTree.Expression): boolean;
 declare const isFunction: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression;
-/**
- * Check if a node is a class declaration or expression
- * @param node The node to check
- * @returns True if the node is a class
- */
 declare const isClass: (node: TSESTree.Node | null | undefined) => node is TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.ClassExpression;
-/**
- * Check if a node is a method or property definition
- * @param node The node to check
- * @returns True if the node is a method or property definition
- */
 declare const isMethodOrProperty: (node: TSESTree.Node | null | undefined) => node is TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName | TSESTree.PropertyDefinitionComputedName | TSESTree.PropertyDefinitionNonComputedName;
-/**
- * Check if a node is a property-like node (including TypeScript property signatures)
- * @param node The node to check
- * @returns True if the node is a property
- */
 declare const isProperty: (node: TSESTree.Node | null | undefined) => node is TSESTree.PropertyDefinitionComputedName | TSESTree.PropertyDefinitionNonComputedName | TSESTree.TSIndexSignature | TSESTree.TSParameterProperty | TSESTree.TSPropertySignatureComputedName | TSESTree.TSPropertySignatureNonComputedName;
-/**
- * Check if a node is a JSX element
- * @param node The node to check
- * @returns True if the node is a JSX element
- */
 declare const isJSXElement: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXElement;
-/**
- * Check if a node is a JSX element or JSX fragment
- */
-declare const isJSXElementLike: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXElement | TSESTree.JSXFragment;
-/**
- * Check if a node is a JSX tag name expression (identifier, member expression, or namespaced name)
- * @param node The node to check
- * @returns True if the node is a JSX tag name expression
- */
+declare const isJSXFragment: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXFragment;
+declare const isJSXLike: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXElement | TSESTree.JSXFragment;
 declare const isJSXTagNameExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXIdentifier | TSESTree.JSXMemberExpression | TSESTree.JSXNamespacedName;
-/**
- * Check if a node is a JSX-related node
- * Note: This runtime guard includes JSXExpressionContainer which is commonly needed
- * for AST traversals but not included in the TSESTreeJSX type union.
- * @param node The node to check
- * @returns True if the node is a JSX node
- * @see TSESTreeJSX
- */
 declare const isJSX: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXAttribute | TSESTree.JSXClosingElement | TSESTree.JSXClosingFragment | TSESTree.JSXElement | TSESTree.JSXEmptyExpression | TSESTree.JSXExpressionContainer | TSESTree.JSXFragment | TSESTree.JSXIdentifier | TSESTree.JSXMemberExpression | TSESTree.JSXNamespacedName | TSESTree.JSXOpeningElement | TSESTree.JSXOpeningFragment | TSESTree.JSXSpreadAttribute | TSESTree.JSXSpreadChild | TSESTree.JSXText;
-/**
- * Check if a node is a TypeScript type expression
- * @param node The node to check
- * @returns True if the node is a type expression
- */
 declare const isTypeExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion;
-/**
- * Check if a node is a TypeScript type assertion expression
- * @param node The node to check
- * @returns True if the node is a type assertion expression
- */
 declare const isTypeAssertionExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion;
+declare function directive(node: TSESTree.Node): node is Directive;
+declare namespace compare_d_exports {
+  export { areEqual };
+}
 /**
- * Check if a node is a directive expression statement
- * @param node The node to check
- * @returns True if the node is a directive, false otherwise
- */
-declare function isDirective(node: TSESTree.Node): node is TSESTreeDirective;
-//#endregion
-//#region src/node-kind.d.ts
-declare function getHumanReadableKind(node: TSESTree.Node, delimiter?: string): "RegExp literal" | Lowercase<string> | `JSX ${Lowercase<string>}`;
-//#endregion
-//#region src/node-name.d.ts
-declare function getFullyQualifiedName(node: TSESTree.Node, getText: (node: TSESTree.Node) => string): string;
-//#endregion
-//#region src/node-selectors.d.ts
-/**
- * Represents a variable declarator with object destructuring and an identifier initializer
+ * Check if two nodes are equal
+ * @param a node to compare
+ * @param b node to compare
+ * @returns `true` if node equal
+ * @see https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/isNodeEqual.ts
  */
-type ObjectDestructuringVariableDeclarator = TSESTree.VariableDeclarator & {
-  id: TSESTree.ObjectPattern;
-  init: TSESTree.Identifier;
+declare const areEqual: {
+  (a: TSESTree.Node): (b: TSESTree.Node) => boolean;
+  (a: TSESTree.Node, b: TSESTree.Node): boolean;
 };
-/**
- * Represents an assignment expression that assigns to a displayName property
- */
-type DisplayNameAssignmentExpression = TSESTree.AssignmentExpression & {
+declare namespace extract_d_exports {
+  export { fullyQualifiedName, humanReadableKind, propertyName, rootIdentifier, unwrapped };
+}
+declare function unwrapped(from: TSESTree.Node): Exclude<TSESTree.Node, TypeExpression>;
+declare function rootIdentifier(from: TSESTree.Expression | TSESTree.PrivateIdentifier): TSESTree.Identifier | null;
+declare function propertyName(from: TSESTree.Node): string | null;
+declare function fullyQualifiedName(from: TSESTree.Node, using: (node: TSESTree.Node) => string): string;
+declare function humanReadableKind(of: TSESTree.Node, delimiter?: string): string;
+declare namespace select_d_exports {
+  export { DisplayNameAssignment, displayNameAssignment };
+}
+type DisplayNameAssignment = TSESTree.AssignmentExpression & {
   left: TSESTree.MemberExpression & {
     property: TSESTree.Identifier & {
       name: "displayName";
@@ -208,58 +80,14 @@ type DisplayNameAssignmentExpression = TSESTree.AssignmentExpression & {
   operator: "=";
   right: TSESTree.Literal;
 };
-/**
- * Selector for variable declarators with object destructuring
- */
-declare const SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR: string;
-/**
- * Selector for assignment expressions that set displayName
- */
-declare const SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION: string;
-//#endregion
-//#region src/node-traverse.d.ts
-/**
- * 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 `null` if not found
- */
-declare function findParent<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 `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 findParent(node: TSESTree.Node | null, test: (node: TSESTree.Node) => boolean): TSESTree.Node | null;
-//#endregion
-//#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/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
- * Note: This only handles inline object literals in spread elements. Properties from variables
- * (e.g., `{...props}` where props is a variable) are not resolved.
- * @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;
+declare const displayNameAssignment: string;
+declare namespace traverse_d_exports {
+  export { NodePredicate, Predicate, findParent, findProperty };
+}
+type Predicate<T extends TSESTree.Node> = (node: TSESTree.Node) => node is T;
+type NodePredicate = (node: TSESTree.Node) => boolean;
+declare function findParent<T extends TSESTree.Node>(of: TSESTree.Node | null, where: Predicate<T>): T | null;
+declare function findParent(of: TSESTree.Node | null, where: NodePredicate): TSESTree.Node | null;
+declare function findProperty(in_: TSESTree.ObjectLiteralElement[], named: string): TSESTree.Property | null;
 //#endregion
-export { DisplayNameAssignmentExpression, ObjectDestructuringVariableDeclarator, SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, TSESTreeClass, TSESTreeDirective, TSESTreeFunction, TSESTreeJSX, TSESTreeJSXAttributeLike, TSESTreeJSXElementLike, TSESTreeMethodOrProperty, TSESTreeTypeExpression, findParent, findProperty, getFullyQualifiedName, getHumanReadableKind, getPropertyName, getRootIdentifier, getUnderlyingExpression, is, isClass, isDirective, isFileHasDirective, isFunction, isIdentifier, isJSX, isJSXElement, isJSXElementLike, isJSXTagNameExpression, isLiteral, isMethodOrProperty, isNodeEqual, isOneOf, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression };
+export { check_d_exports as Check, ClassExpression, compare_d_exports as Compare, Directive, Expression, extract_d_exports as Extract, FunctionExpression, Identifier, JSXAttributeLike, JSXElementLike, JSXNode, MethodOrPropertyDefinition, Node, Program, select_d_exports as Select, Statement, traverse_d_exports as Traverse, TypeExpression, is, isOneOf };

package/dist/index.js

@@ -1,81 +1,69 @@
-import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
+import { t as __exportAll } from "./chunk-BYypO7fO.js";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { ASTUtils } from "@typescript-eslint/utils";
 import { delimiterCase, replace, toLowerCase } from "string-ts";
 
-//#region src/node-is.ts
-/**
-* Type guard to check if a node is of a specific AST node type
-* @param nodeType The AST node type to check against
-* @returns A type guard function that narrows the node type
-*/
+//#region src/check.ts
+var check_exports = /* @__PURE__ */ __exportAll({
+	directive: () => directive,
+	identifier: () => identifier,
+	is: () => is,
+	isClass: () => isClass,
+	isFunction: () => isFunction,
+	isJSX: () => isJSX,
+	isJSXElement: () => isJSXElement,
+	isJSXFragment: () => isJSXFragment,
+	isJSXLike: () => isJSXLike,
+	isJSXTagNameExpression: () => isJSXTagNameExpression,
+	isMethodOrProperty: () => isMethodOrProperty,
+	isOneOf: () => isOneOf,
+	isProperty: () => isProperty,
+	isTypeAssertionExpression: () => isTypeAssertionExpression,
+	isTypeExpression: () => isTypeExpression,
+	literal: () => literal,
+	thisExpression: () => thisExpression
+});
 const is = ASTUtils.isNodeOfType;
-/**
-* Type guard to check if a node is one of multiple AST node types
-* @param nodeTypes Array of AST node types to check against
-* @returns A type guard function that narrows the node type
-*/
 const isOneOf = ASTUtils.isNodeOfTypes;
-/**
-* Check if a node is a function (arrow, declaration, or expression)
-* @param node The node to check
-* @returns True if the node is a function
-*/
+function identifier(node, named) {
+	return node?.type === AST_NODE_TYPES.Identifier && (named == null || node.name === named);
+}
+function literal(node, ofKind) {
+	if (node.type !== AST_NODE_TYPES.Literal) return false;
+	if (ofKind == null) return true;
+	switch (ofKind) {
+		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";
+		default: return false;
+	}
+}
+function thisExpression(expression) {
+	return expression.type === AST_NODE_TYPES.ThisExpression;
+}
 const isFunction = isOneOf([
 	AST_NODE_TYPES.ArrowFunctionExpression,
 	AST_NODE_TYPES.FunctionDeclaration,
 	AST_NODE_TYPES.FunctionExpression
 ]);
-/**
-* Check if a node is a class declaration or expression
-* @param node The node to check
-* @returns True if the node is a class
-*/
 const isClass = isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]);
-/**
-* Check if a node is a method or property definition
-* @param node The node to check
-* @returns True if the node is a method or property definition
-*/
 const isMethodOrProperty = isOneOf([AST_NODE_TYPES.PropertyDefinition, AST_NODE_TYPES.MethodDefinition]);
-/**
-* Check if a node is a property-like node (including TypeScript property signatures)
-* @param node The node to check
-* @returns True if the node is a property
-*/
 const isProperty = isOneOf([
 	AST_NODE_TYPES.PropertyDefinition,
 	AST_NODE_TYPES.TSIndexSignature,
 	AST_NODE_TYPES.TSParameterProperty,
 	AST_NODE_TYPES.TSPropertySignature
 ]);
-/**
-* Check if a node is a JSX element
-* @param node The node to check
-* @returns True if the node is a JSX element
-*/
 const isJSXElement = is(AST_NODE_TYPES.JSXElement);
-/**
-* Check if a node is a JSX element or JSX fragment
-*/
-const isJSXElementLike = isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment]);
-/**
-* Check if a node is a JSX tag name expression (identifier, member expression, or namespaced name)
-* @param node The node to check
-* @returns True if the node is a JSX tag name expression
-*/
+const isJSXFragment = is(AST_NODE_TYPES.JSXFragment);
+const isJSXLike = isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment]);
 const isJSXTagNameExpression = isOneOf([
 	AST_NODE_TYPES.JSXIdentifier,
 	AST_NODE_TYPES.JSXMemberExpression,
 	AST_NODE_TYPES.JSXNamespacedName
 ]);
-/**
-* Check if a node is a JSX-related node
-* Note: This runtime guard includes JSXExpressionContainer which is commonly needed
-* for AST traversals but not included in the TSESTreeJSX type union.
-* @param node The node to check
-* @returns True if the node is a JSX node
-* @see TSESTreeJSX
-*/
 const isJSX = isOneOf([
 	AST_NODE_TYPES.JSXAttribute,
 	AST_NODE_TYPES.JSXClosingElement,
@@ -93,11 +81,6 @@ const isJSX = isOneOf([
 	AST_NODE_TYPES.JSXSpreadChild,
 	AST_NODE_TYPES.JSXText
 ]);
-/**
-* Check if a node is a TypeScript type expression
-* @param node The node to check
-* @returns True if the node is a type expression
-*/
 const isTypeExpression = isOneOf([
 	AST_NODE_TYPES.TSAsExpression,
 	AST_NODE_TYPES.TSTypeAssertion,
@@ -105,108 +88,16 @@ const isTypeExpression = isOneOf([
 	AST_NODE_TYPES.TSSatisfiesExpression,
 	AST_NODE_TYPES.TSInstantiationExpression
 ]);
-/**
-* Check if a node is a TypeScript type assertion expression
-* @param node The node to check
-* @returns True if the node is a type assertion expression
-*/
 const isTypeAssertionExpression = isOneOf([
 	AST_NODE_TYPES.TSAsExpression,
 	AST_NODE_TYPES.TSTypeAssertion,
 	AST_NODE_TYPES.TSNonNullExpression,
 	AST_NODE_TYPES.TSSatisfiesExpression
 ]);
-/**
-* Check if a node is a directive expression statement
-* @param node The node to check
-* @returns True if the node is a directive, false otherwise
-*/
-function isDirective(node) {
+function directive(node) {
 	return node.type === AST_NODE_TYPES.ExpressionStatement && node.directive != null;
 }
 
-//#endregion
-//#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.
-* @param node The AST node to unwrap
-* @returns The underlying JavaScript expression node
-*/
-function getUnderlyingExpression(node) {
-	if (isTypeExpression(node)) return getUnderlyingExpression(node.expression);
-	return node;
-}
-
-//#endregion
-//#region src/expression-is.ts
-/**
-* 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 'this' expression, false otherwise
-*/
-function isThisExpressionLoose(node) {
-	return getUnderlyingExpression(node).type === AST_NODE_TYPES.ThisExpression;
-}
-
-//#endregion
-//#region src/file.ts
-/**
-* Check if a directive with the given name exists in the file directives
-* @param node The program 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 isFileHasDirective(node, name) {
-	for (const stmt of node.body) if (isDirective(stmt) && stmt.directive === name) return true;
-	return false;
-}
-
-//#endregion
-//#region src/identifier-is.ts
-/**
-* 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
-//#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/literal-is.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 ../../.pkgs/eff/dist/index.js
 /**
@@ -326,7 +217,57 @@ const dual = function(arity, body) {
 const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 
 //#endregion
-//#region src/node-equality.ts
+//#region src/extract.ts
+var extract_exports = /* @__PURE__ */ __exportAll({
+	fullyQualifiedName: () => fullyQualifiedName,
+	humanReadableKind: () => humanReadableKind,
+	propertyName: () => propertyName,
+	rootIdentifier: () => rootIdentifier,
+	unwrapped: () => unwrapped
+});
+function unwrapped(from) {
+	if (isTypeExpression(from)) return unwrapped(from.expression);
+	return from;
+}
+function rootIdentifier(from) {
+	const node = unwrapped(from);
+	if (node.type === AST_NODE_TYPES.Identifier) return node;
+	if (node.type === AST_NODE_TYPES.MemberExpression) return rootIdentifier(node.object);
+	return null;
+}
+function propertyName(from) {
+	if (isTypeExpression(from)) return propertyName(unwrapped(from));
+	if (from.type === AST_NODE_TYPES.Identifier || from.type === AST_NODE_TYPES.PrivateIdentifier) return from.name;
+	if (from.type === AST_NODE_TYPES.Literal) return String(from.value);
+	if (from.type === AST_NODE_TYPES.TemplateLiteral && from.expressions.length === 0) return from.quasis[0]?.value.cooked ?? from.quasis[0]?.value.raw ?? null;
+	return null;
+}
+function fullyQualifiedName(from, using) {
+	switch (from.type) {
+		case AST_NODE_TYPES.Identifier:
+		case AST_NODE_TYPES.JSXIdentifier:
+		case AST_NODE_TYPES.PrivateIdentifier: return from.name;
+		case AST_NODE_TYPES.MemberExpression:
+		case AST_NODE_TYPES.JSXMemberExpression: return `${fullyQualifiedName(from.object, using)}.${fullyQualifiedName(from.property, using)}`;
+		case AST_NODE_TYPES.JSXNamespacedName: return `${from.namespace.name}:${from.name.name}`;
+		case AST_NODE_TYPES.JSXText: return from.value;
+		case AST_NODE_TYPES.Literal: return from.raw;
+		default: return using(from);
+	}
+}
+function humanReadableKind(of, delimiter = " ") {
+	if (of.type === AST_NODE_TYPES.Literal) {
+		if ("regex" in of) return "RegExp literal";
+		if (of.value === null) return "null literal";
+		return `${typeof of.value} literal`;
+	}
+	if (isJSX(of)) return `JSX ${toLowerCase(delimiterCase(replace(of.type, "JSX", ""), delimiter))}`;
+	return toLowerCase(delimiterCase(of.type, delimiter));
+}
+
+//#endregion
+//#region src/compare.ts
+var compare_exports = /* @__PURE__ */ __exportAll({ areEqual: () => areEqual });
 /**
 * Check if two nodes are equal
 * @param a node to compare
@@ -334,9 +275,9 @@ const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 * @returns `true` if node equal
 * @see https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/isNodeEqual.ts
 */
-const isNodeEqual = dual(2, (a, b) => {
-	a = isTypeExpression(a) ? getUnderlyingExpression(a) : a;
-	b = isTypeExpression(b) ? getUnderlyingExpression(b) : b;
+const areEqual = dual(2, (a, b) => {
+	a = isTypeExpression(a) ? unwrapped(a) : a;
+	b = isTypeExpression(b) ? unwrapped(b) : b;
 	switch (true) {
 		case a === b: return true;
 		case a.type !== b.type: return false;
@@ -350,67 +291,29 @@ const isNodeEqual = dual(2, (a, b) => {
 			while (i--) {
 				const exprA = a.expressions[i];
 				const exprB = b.expressions[i];
-				if (!isNodeEqual(exprA, exprB)) return false;
+				if (!areEqual(exprA, exprB)) return false;
 			}
 			return true;
 		}
 		case a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier: return a.name === b.name;
 		case a.type === AST_NODE_TYPES.PrivateIdentifier && b.type === AST_NODE_TYPES.PrivateIdentifier: return a.name === b.name;
-		case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return isNodeEqual(a.property, b.property) && isNodeEqual(a.object, b.object);
+		case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return areEqual(a.property, b.property) && areEqual(a.object, b.object);
 		case a.type === AST_NODE_TYPES.JSXIdentifier && b.type === AST_NODE_TYPES.JSXIdentifier: return a.name === b.name;
-		case a.type === AST_NODE_TYPES.JSXNamespacedName && b.type === AST_NODE_TYPES.JSXNamespacedName: return isNodeEqual(a.namespace, b.namespace) && isNodeEqual(a.name, b.name);
-		case a.type === AST_NODE_TYPES.JSXMemberExpression && b.type === AST_NODE_TYPES.JSXMemberExpression: return isNodeEqual(a.object, b.object) && isNodeEqual(a.property, b.property);
+		case a.type === AST_NODE_TYPES.JSXNamespacedName && b.type === AST_NODE_TYPES.JSXNamespacedName: return areEqual(a.namespace, b.namespace) && areEqual(a.name, b.name);
+		case a.type === AST_NODE_TYPES.JSXMemberExpression && b.type === AST_NODE_TYPES.JSXMemberExpression: return areEqual(a.object, b.object) && areEqual(a.property, b.property);
 		case a.type === AST_NODE_TYPES.JSXAttribute && b.type === AST_NODE_TYPES.JSXAttribute:
-			if (!isNodeEqual(a.name, b.name)) return false;
+			if (!areEqual(a.name, b.name)) return false;
 			if (a.value == null || b.value == null) return a.value === b.value;
-			return isNodeEqual(a.value, b.value);
+			return areEqual(a.value, b.value);
 		case a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression: return true;
 		default: return false;
 	}
 });
 
 //#endregion
-//#region src/node-kind.ts
-function getHumanReadableKind(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));
-}
-
-//#endregion
-//#region src/node-name.ts
-function getFullyQualifiedName(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 `${getFullyQualifiedName(node.object, getText)}.${getFullyQualifiedName(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/node-selectors.ts
-/**
-* Selector for variable declarators with object destructuring
-*/
-const SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR = [
-	"VariableDeclarator",
-	"[id.type='ObjectPattern']",
-	"[init.type='Identifier']"
-].join("");
-/**
-* Selector for assignment expressions that set displayName
-*/
-const SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION = [
+//#region src/select.ts
+var select_exports = /* @__PURE__ */ __exportAll({ displayNameAssignment: () => displayNameAssignment });
+const displayNameAssignment = [
 	"AssignmentExpression",
 	"[operator='=']",
 	"[left.type='MemberExpression']",
@@ -418,48 +321,26 @@ const SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION = [
 ].join("");
 
 //#endregion
-//#region src/node-traverse.ts
-function findParent(node, test) {
-	if (node == null) return null;
-	let parent = node.parent;
-	while (parent != null && parent.type !== AST_NODE_TYPES.Program) {
-		if (test(parent)) return parent;
+//#region src/traverse.ts
+var traverse_exports = /* @__PURE__ */ __exportAll({
+	findParent: () => findParent,
+	findProperty: () => findProperty
+});
+function findParent(of, where) {
+	if (of == null) return null;
+	let parent = of.parent;
+	while (parent?.type !== AST_NODE_TYPES.Program) {
+		if (parent == null) return null;
+		if (where(parent)) return parent;
 		parent = parent.parent;
 	}
 	return null;
 }
-
-//#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 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
-* Note: This only handles inline object literals in spread elements. Properties from variables
-* (e.g., `{...props}` where props is a variable) are not resolved.
-* @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);
+function findProperty(in_, named) {
+	for (const property of in_) {
+		if (property.type === AST_NODE_TYPES.Property && propertyName(property.key) === named) return property;
+		if (property.type === AST_NODE_TYPES.SpreadElement && property.argument.type === AST_NODE_TYPES.ObjectExpression) {
+			const found = findProperty(property.argument.properties, named);
 			if (found != null) return found;
 		}
 	}
@@ -467,4 +348,4 @@ function findProperty(properties, name) {
 }
 
 //#endregion
-export { SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, findParent, findProperty, getFullyQualifiedName, getHumanReadableKind, getPropertyName, getRootIdentifier, getUnderlyingExpression, is, isClass, isDirective, isFileHasDirective, isFunction, isIdentifier, isJSX, isJSXElement, isJSXElementLike, isJSXTagNameExpression, isLiteral, isMethodOrProperty, isNodeEqual, isOneOf, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression };
+export { check_exports as Check, compare_exports as Compare, extract_exports as Extract, select_exports as Select, traverse_exports as Traverse, is, isOneOf };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/ast",
-  "version": "5.2.1-next.3",
+  "version": "5.2.2-next.0",
   "description": "ESLint React's TSESTree AST utility module.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -52,6 +52,7 @@
   },
   "scripts": {
     "build": "tsdown --dts-resolve",
+    "build:docs": "typedoc",
     "lint:publish": "publint",
     "lint:ts": "tsl"
   }