@eslint-react/ast 5.2.3-next.1 → 5.2.4-beta.0

package/dist/index.d.ts

@@ -13,7 +13,7 @@ type TSESTreeDirective = TSESTree.ExpressionStatement & {
 };
 type TSESTreeTypeExpression = 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 };
+  export { is, isClass, isDirective, isFunction, isIdentifier, isJSX, isJSXElement, isJSXFragment, isJSXLike, isJSXTagNameExpression, isLiteral, isMethodOrProperty, isOneOf, isProperty, isTypeAssertionExpression, isTypeExpression };
 }
 declare const is: <NodeType extends AST_NODE_TYPES>(nodeType: NodeType) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.Node, {
   type: NodeType;
@@ -21,14 +21,14 @@ declare const is: <NodeType extends AST_NODE_TYPES>(nodeType: NodeType) => (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];
 }>;
-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 function isLiteral(): (node: TSESTree.Node) => node is TSESTree.Literal;
+declare function isLiteral(kind: "boolean"): (node: TSESTree.Node) => node is TSESTree.BooleanLiteral;
+declare function isLiteral(kind: "null"): (node: TSESTree.Node) => node is TSESTree.NullLiteral;
+declare function isLiteral(kind: "number"): (node: TSESTree.Node) => node is TSESTree.NumberLiteral;
+declare function isLiteral(kind: "regexp"): (node: TSESTree.Node) => node is TSESTree.RegExpLiteral;
+declare function isLiteral(kind: "string"): (node: TSESTree.Node) => node is TSESTree.StringLiteral;
+declare function isDirective(name: string): (node: TSESTree.Node) => node is TSESTreeDirective;
+declare function isIdentifier(name: string): (node: TSESTree.Node) => node is TSESTree.Identifier;
 declare const isFunction: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression;
 declare const isClass: (node: TSESTree.Node | null | undefined) => node is TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.ClassExpression;
 declare const isMethodOrProperty: (node: TSESTree.Node | null | undefined) => node is TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName | TSESTree.PropertyDefinitionComputedName | TSESTree.PropertyDefinitionNonComputedName;
@@ -40,9 +40,8 @@ declare const isJSXTagNameExpression: (node: TSESTree.Node | null | undefined) =
 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;
 declare const isTypeExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion;
 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 TSESTreeDirective;
 declare namespace compare_d_exports {
-  export { areEqual };
+  export { isEqual };
 }
 /**
  * Check if two nodes are equal
@@ -51,24 +50,24 @@ declare namespace compare_d_exports {
  * @returns `true` if node equal
  * @see https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/isNodeEqual.ts
  */
-declare const areEqual: {
+declare const isEqual: {
   (a: TSESTree.Node): (b: TSESTree.Node) => boolean;
   (a: TSESTree.Node, b: TSESTree.Node): boolean;
 };
 declare namespace extract_d_exports {
-  export { fullyQualifiedName, humanReadableKind, propertyName, rootIdentifier, unwrapped };
+  export { getFullyQualifiedName, getHumanReadableKind, getPropertyName, getRootIdentifier, unwrap };
 }
-declare function unwrapped(from: TSESTree.Node): Exclude<TSESTree.Node, TSESTreeTypeExpression>;
-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 function unwrap(node: TSESTree.Node): Exclude<TSESTree.Node, TSESTreeTypeExpression>;
+declare function getRootIdentifier(node: TSESTree.Expression | TSESTree.PrivateIdentifier): TSESTree.Identifier | null;
+declare function getPropertyName(node: TSESTree.Node): string | null;
+declare function getFullyQualifiedName(node: TSESTree.Node, getText: (node: TSESTree.Node) => string): string;
+declare function getHumanReadableKind(node: TSESTree.Node): "regexp literal" | "null literal" | "string literal" | "number literal" | "bigint literal" | "boolean literal" | "symbol literal" | "undefined literal" | "object literal" | "function literal" | "decorator" | "identifier" | "program" | "property" | "super" | "accessor property" | "array expression" | "array pattern" | "function expression" | "arrow function expression" | "assignment expression" | "assignment pattern" | "await expression" | "binary expression" | "block statement" | "break statement" | "call expression" | "catch clause" | "chain expression" | "class body" | "class declaration" | "class expression" | "conditional expression" | "continue statement" | "debugger statement" | "while statement" | "do while statement" | "empty statement" | "export all declaration" | "export default declaration" | "export named declaration" | "export specifier" | "expression statement" | "for in statement" | "for of statement" | "for statement" | "function declaration" | "if statement" | "import attribute" | "import declaration" | "import default specifier" | "import expression" | "import namespace specifier" | "import specifier" | "jsx attribute" | "jsx closing element" | "jsx closing fragment" | "jsx element" | "jsx empty expression" | "jsx expression container" | "jsx fragment" | "jsx identifier" | "member expression" | "jsx member expression" | "jsx namespaced name" | "jsx opening element" | "jsx opening fragment" | "jsx spread attribute" | "jsx spread child" | "jsx text" | "labeled statement" | "logical expression" | "meta property" | "method definition" | "new expression" | "object expression" | "object pattern" | "private identifier" | "property definition" | "rest element" | "return statement" | "sequence expression" | "spread element" | "static block" | "switch case" | "switch statement" | "tagged template expression" | "template element" | "template literal" | "this expression" | "throw statement" | "try statement" | "unary expression" | "update expression" | "variable declaration" | "variable declarator" | "with statement" | "yield expression" | "ts abstract accessor property" | "ts abstract keyword" | "ts abstract method definition" | "ts abstract property definition" | "ts any keyword" | "ts array type" | "ts as expression" | "ts async keyword" | "ts big int keyword" | "ts boolean keyword" | "ts call signature declaration" | "ts class implements" | "ts conditional type" | "ts constructor type" | "ts construct signature declaration" | "ts declare function" | "ts declare keyword" | "ts empty body function expression" | "ts enum body" | "ts enum declaration" | "ts enum member" | "ts export assignment" | "ts export keyword" | "ts external module reference" | "ts function type" | "ts import equals declaration" | "ts import type" | "ts indexed access type" | "ts index signature" | "ts infer type" | "ts instantiation expression" | "ts interface body" | "ts interface declaration" | "ts interface heritage" | "ts intersection type" | "ts intrinsic keyword" | "ts literal type" | "ts mapped type" | "ts method signature" | "ts module block" | "ts module declaration" | "ts named tuple member" | "ts namespace export declaration" | "ts never keyword" | "ts non null expression" | "ts null keyword" | "ts number keyword" | "ts object keyword" | "ts optional type" | "ts parameter property" | "ts private keyword" | "ts property signature" | "ts protected keyword" | "ts public keyword" | "ts qualified name" | "ts readonly keyword" | "ts rest type" | "ts satisfies expression" | "ts static keyword" | "ts string keyword" | "ts symbol keyword" | "ts template literal type" | "ts this type" | "ts tuple type" | "ts type alias declaration" | "ts type annotation" | "ts type assertion" | "ts type literal" | "ts type operator" | "ts type parameter" | "ts type parameter declaration" | "ts type parameter instantiation" | "ts type predicate" | "ts type query" | "ts type reference" | "ts undefined keyword" | "ts union type" | "ts unknown keyword" | "ts void keyword";
 declare namespace traverse_d_exports {
-  export { NodePredicate, Predicate, findParent };
+  export { findParent };
 }
 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 findParent<T extends TSESTree.Node>(node: TSESTree.Node | null, test: Predicate<T>): T | null;
+declare function findParent(node: TSESTree.Node | null, test: NodePredicate): TSESTree.Node | null;
 //#endregion
 export { check_d_exports as Check, compare_d_exports as Compare, extract_d_exports as Extract, TSESTreeClass, TSESTreeDirective, TSESTreeFunction, TSESTreeJSX, TSESTreeJSXAttributeLike, TSESTreeJSXElementLike, TSESTreeMethodOrPropertyDefinition, TSESTreeTypeExpression, traverse_d_exports as Traverse, is, isOneOf };

package/dist/index.js

@@ -1,47 +1,48 @@
 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";
+import { delimiterCase, toLowerCase } from "string-ts";
 
 //#region src/check.ts
 var check_exports = /* @__PURE__ */ __exportAll({
-	directive: () => directive,
-	identifier: () => identifier,
 	is: () => is,
 	isClass: () => isClass,
+	isDirective: () => isDirective,
 	isFunction: () => isFunction,
+	isIdentifier: () => isIdentifier,
 	isJSX: () => isJSX,
 	isJSXElement: () => isJSXElement,
 	isJSXFragment: () => isJSXFragment,
 	isJSXLike: () => isJSXLike,
 	isJSXTagNameExpression: () => isJSXTagNameExpression,
+	isLiteral: () => isLiteral,
 	isMethodOrProperty: () => isMethodOrProperty,
 	isOneOf: () => isOneOf,
 	isProperty: () => isProperty,
 	isTypeAssertionExpression: () => isTypeAssertionExpression,
-	isTypeExpression: () => isTypeExpression,
-	literal: () => literal,
-	thisExpression: () => thisExpression
+	isTypeExpression: () => isTypeExpression
 });
 const is = ASTUtils.isNodeOfType;
 const isOneOf = ASTUtils.isNodeOfTypes;
-function identifier(node, named) {
-	return node?.type === AST_NODE_TYPES.Identifier && (named == null || node.name === named);
+function isLiteral(kind) {
+	return (node) => {
+		if (node.type !== AST_NODE_TYPES.Literal) return false;
+		if (kind == null) return true;
+		switch (kind) {
+			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 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 isDirective(name) {
+	return (node) => node.type === AST_NODE_TYPES.ExpressionStatement && node.directive === name;
 }
-function thisExpression(expression) {
-	return expression.type === AST_NODE_TYPES.ThisExpression;
+function isIdentifier(name) {
+	return (node) => node.type === AST_NODE_TYPES.Identifier && node.name === name;
 }
 const isFunction = isOneOf([
 	AST_NODE_TYPES.ArrowFunctionExpression,
@@ -94,9 +95,6 @@ const isTypeAssertionExpression = isOneOf([
 	AST_NODE_TYPES.TSNonNullExpression,
 	AST_NODE_TYPES.TSSatisfiesExpression
 ]);
-function directive(node) {
-	return node.type === AST_NODE_TYPES.ExpressionStatement && node.directive != null;
-}
 
 //#endregion
 //#region ../../.pkgs/eff/dist/index.js
@@ -219,55 +217,54 @@ const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 //#endregion
 //#region src/extract.ts
 var extract_exports = /* @__PURE__ */ __exportAll({
-	fullyQualifiedName: () => fullyQualifiedName,
-	humanReadableKind: () => humanReadableKind,
-	propertyName: () => propertyName,
-	rootIdentifier: () => rootIdentifier,
-	unwrapped: () => unwrapped
+	getFullyQualifiedName: () => getFullyQualifiedName,
+	getHumanReadableKind: () => getHumanReadableKind,
+	getPropertyName: () => getPropertyName,
+	getRootIdentifier: () => getRootIdentifier,
+	unwrap: () => unwrap
 });
-function unwrapped(from) {
-	if (isTypeExpression(from)) return unwrapped(from.expression);
-	return from;
+function unwrap(node) {
+	if (isTypeExpression(node)) return unwrap(node.expression);
+	return node;
 }
-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);
+function getRootIdentifier(node) {
+	const expr = unwrap(node);
+	if (expr.type === AST_NODE_TYPES.Identifier) return expr;
+	if (expr.type === AST_NODE_TYPES.MemberExpression) return getRootIdentifier(expr.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;
+function getPropertyName(node) {
+	if (isTypeExpression(node)) return getPropertyName(unwrap(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;
 }
-function fullyQualifiedName(from, using) {
-	switch (from.type) {
+function getFullyQualifiedName(node, getText) {
+	switch (node.type) {
 		case AST_NODE_TYPES.Identifier:
 		case AST_NODE_TYPES.JSXIdentifier:
-		case AST_NODE_TYPES.PrivateIdentifier: return from.name;
+		case AST_NODE_TYPES.PrivateIdentifier: return node.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);
+		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);
 	}
 }
-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`;
+function getHumanReadableKind(node) {
+	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(of)) return `JSX ${toLowerCase(delimiterCase(replace(of.type, "JSX", ""), delimiter))}`;
-	return toLowerCase(delimiterCase(of.type, delimiter));
+	return toLowerCase(delimiterCase(node.type, " "));
 }
 
 //#endregion
 //#region src/compare.ts
-var compare_exports = /* @__PURE__ */ __exportAll({ areEqual: () => areEqual });
+var compare_exports = /* @__PURE__ */ __exportAll({ isEqual: () => isEqual });
 /**
 * Check if two nodes are equal
 * @param a node to compare
@@ -275,9 +272,9 @@ var compare_exports = /* @__PURE__ */ __exportAll({ areEqual: () => areEqual });
 * @returns `true` if node equal
 * @see https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/isNodeEqual.ts
 */
-const areEqual = dual(2, (a, b) => {
-	a = isTypeExpression(a) ? unwrapped(a) : a;
-	b = isTypeExpression(b) ? unwrapped(b) : b;
+const isEqual = dual(2, (a, b) => {
+	a = isTypeExpression(a) ? unwrap(a) : a;
+	b = isTypeExpression(b) ? unwrap(b) : b;
 	switch (true) {
 		case a === b: return true;
 		case a.type !== b.type: return false;
@@ -291,20 +288,20 @@ const areEqual = dual(2, (a, b) => {
 			while (i--) {
 				const exprA = a.expressions[i];
 				const exprB = b.expressions[i];
-				if (!areEqual(exprA, exprB)) return false;
+				if (!isEqual(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 areEqual(a.property, b.property) && areEqual(a.object, b.object);
+		case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return isEqual(a.property, b.property) && isEqual(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 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.JSXNamespacedName && b.type === AST_NODE_TYPES.JSXNamespacedName: return isEqual(a.namespace, b.namespace) && isEqual(a.name, b.name);
+		case a.type === AST_NODE_TYPES.JSXMemberExpression && b.type === AST_NODE_TYPES.JSXMemberExpression: return isEqual(a.object, b.object) && isEqual(a.property, b.property);
 		case a.type === AST_NODE_TYPES.JSXAttribute && b.type === AST_NODE_TYPES.JSXAttribute:
-			if (!areEqual(a.name, b.name)) return false;
+			if (!isEqual(a.name, b.name)) return false;
 			if (a.value == null || b.value == null) return a.value === b.value;
-			return areEqual(a.value, b.value);
+			return isEqual(a.value, b.value);
 		case a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression: return true;
 		default: return false;
 	}
@@ -313,12 +310,12 @@ const areEqual = dual(2, (a, b) => {
 //#endregion
 //#region src/traverse.ts
 var traverse_exports = /* @__PURE__ */ __exportAll({ findParent: () => findParent });
-function findParent(of, where) {
-	if (of == null) return null;
-	let parent = of.parent;
+function findParent(node, test) {
+	if (node == null) return null;
+	let parent = node.parent;
 	while (parent?.type !== AST_NODE_TYPES.Program) {
 		if (parent == null) return null;
-		if (where(parent)) return parent;
+		if (test(parent)) return parent;
 		parent = parent.parent;
 	}
 	return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/ast",
-  "version": "5.2.3-next.1",
+  "version": "5.2.4-beta.0",
   "description": "ESLint React's TSESTree AST utility module.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {