feat: wrap TypeQueryNode

I need it.

Author: dsherret

deno/ts_morph.d.ts

@@ -4396,6 +4396,11 @@ export declare class Node<NodeType extends ts.Node = ts.Node> {
      * @param node - Node to check.
      */
     static isTypePredicateNode(node: Node | undefined): node is TypePredicateNode;
+    /**
+     * Gets if the node is a TypeQueryNode.
+     * @param node - Node to check.
+     */
+    static isTypeQueryNode(node: Node | undefined): node is TypeQueryNode;
     /**
      * Gets if the node is a TypeReferenceNode.
      * @param node - Node to check.
@@ -6514,6 +6519,7 @@ export interface ImplementedKindToNodeMappings {
     [SyntaxKind.TypeOperator]: TypeOperatorTypeNode;
     [SyntaxKind.TypeParameter]: TypeParameterDeclaration;
     [SyntaxKind.TypePredicate]: TypePredicateNode;
+    [SyntaxKind.TypeQuery]: TypeQueryNode;
     [SyntaxKind.TypeReference]: TypeReferenceNode;
     [SyntaxKind.UnionType]: UnionTypeNode;
     [SyntaxKind.VariableDeclaration]: VariableDeclaration;
@@ -8804,6 +8810,15 @@ export declare class TypePredicateNode extends TypeNode<ts.TypePredicateNode> {
     getParentOrThrow(): NonNullable<NodeParentType<ts.TypePredicateNode>>;
 }
 
+export declare class TypeQueryNode extends TypeNode<ts.TypeQueryNode> {
+    /** Gets the expression name. */
+    getExprName(): EntityName;
+    /** @inheritdoc **/
+    getParent(): NodeParentType<ts.TypeQueryNode>;
+    /** @inheritdoc **/
+    getParentOrThrow(): NonNullable<NodeParentType<ts.TypeQueryNode>>;
+}
+
 export declare class TypeReferenceNode extends TypeNode<ts.TypeReferenceNode> {
     /** Gets the type name. */
     getTypeName(): EntityName;

deno/ts_morph.js

@@ -4396,6 +4396,11 @@ export declare class Node<NodeType extends ts.Node = ts.Node> {
      * @param node - Node to check.
      */
     static isTypePredicateNode(node: Node | undefined): node is TypePredicateNode;
+    /**
+     * Gets if the node is a TypeQueryNode.
+     * @param node - Node to check.
+     */
+    static isTypeQueryNode(node: Node | undefined): node is TypeQueryNode;
     /**
      * Gets if the node is a TypeReferenceNode.
      * @param node - Node to check.
@@ -6514,6 +6519,7 @@ export interface ImplementedKindToNodeMappings {
     [SyntaxKind.TypeOperator]: TypeOperatorTypeNode;
     [SyntaxKind.TypeParameter]: TypeParameterDeclaration;
     [SyntaxKind.TypePredicate]: TypePredicateNode;
+    [SyntaxKind.TypeQuery]: TypeQueryNode;
     [SyntaxKind.TypeReference]: TypeReferenceNode;
     [SyntaxKind.UnionType]: UnionTypeNode;
     [SyntaxKind.VariableDeclaration]: VariableDeclaration;
@@ -8804,6 +8810,15 @@ export declare class TypePredicateNode extends TypeNode<ts.TypePredicateNode> {
     getParentOrThrow(): NonNullable<NodeParentType<ts.TypePredicateNode>>;
 }
 
+export declare class TypeQueryNode extends TypeNode<ts.TypeQueryNode> {
+    /** Gets the expression name. */
+    getExprName(): EntityName;
+    /** @inheritdoc **/
+    getParent(): NodeParentType<ts.TypeQueryNode>;
+    /** @inheritdoc **/
+    getParentOrThrow(): NonNullable<NodeParentType<ts.TypeQueryNode>>;
+}
+
 export declare class TypeReferenceNode extends TypeNode<ts.TypeReferenceNode> {
     /** Gets the type name. */
     getTypeName(): EntityName;

packages/ts-morph/lib/ts-morph.d.ts

@@ -4175,6 +4175,7 @@ export class Node<NodeType extends ts.Node = ts.Node> {
             case SyntaxKind.TypeLiteral:
             case SyntaxKind.TypeOperator:
             case SyntaxKind.TypePredicate:
+            case SyntaxKind.TypeQuery:
             case SyntaxKind.TypeReference:
             case SyntaxKind.UnionType:
                 return true;
@@ -4237,6 +4238,14 @@ export class Node<NodeType extends ts.Node = ts.Node> {
         return node?.getKind() === SyntaxKind.TypePredicate;
     }
 
+    /**
+     * Gets if the node is a TypeQueryNode.
+     * @param node - Node to check.
+     */
+    static isTypeQueryNode(node: compiler.Node | undefined): node is compiler.TypeQueryNode {
+        return node?.getKind() === SyntaxKind.TypeQuery;
+    }
+
     /**
      * Gets if the node is a TypeReferenceNode.
      * @param node - Node to check.

packages/ts-morph/src/compiler/ast/common/Node.ts

@@ -166,6 +166,7 @@ export interface ImplementedKindToNodeMappings {
     [SyntaxKind.TypeOperator]: compiler.TypeOperatorTypeNode;
     [SyntaxKind.TypeParameter]: compiler.TypeParameterDeclaration;
     [SyntaxKind.TypePredicate]: compiler.TypePredicateNode;
+    [SyntaxKind.TypeQuery]: compiler.TypeQueryNode;
     [SyntaxKind.TypeReference]: compiler.TypeReferenceNode;
     [SyntaxKind.UnionType]: compiler.UnionTypeNode;
     [SyntaxKind.VariableDeclaration]: compiler.VariableDeclaration;

packages/ts-morph/src/compiler/ast/kindToNodeMappings.ts

@@ -0,0 +1,12 @@
+import { ts } from "@ts-morph/common";
+import { EntityName } from "../aliases";
+import { TypeNode } from "./TypeNode";
+
+export class TypeQueryNode extends TypeNode<ts.TypeQueryNode> {
+    /**
+     * Gets the expression name.
+     */
+    getExprName(): EntityName {
+        return this._getNodeFromCompilerNode(this.compilerNode.exprName);
+    }
+}

packages/ts-morph/src/compiler/ast/type/TypeQueryNode.ts

@@ -21,5 +21,6 @@ export * from "./TypeNode";
 export * from "./TypeOperatorTypeNode";
 export * from "./TypeParameterDeclaration";
 export * from "./TypePredicateNode";
+export * from "./TypeQueryNode";
 export * from "./TypeReferenceNode";
 export * from "./UnionTypeNode";

packages/ts-morph/src/compiler/ast/type/index.ts

@@ -167,6 +167,7 @@ export const kindToWrapperMappings: { [key: number]: unknown; } = {
     [SyntaxKind.TypeOperator]: compiler.TypeOperatorTypeNode,
     [SyntaxKind.TypeParameter]: compiler.TypeParameterDeclaration,
     [SyntaxKind.TypePredicate]: compiler.TypePredicateNode,
+    [SyntaxKind.TypeQuery]: compiler.TypeQueryNode,
     [SyntaxKind.TypeReference]: compiler.TypeReferenceNode,
     [SyntaxKind.UnionType]: compiler.UnionTypeNode,
     [SyntaxKind.VariableDeclaration]: compiler.VariableDeclaration,

packages/ts-morph/src/factories/kindToWrapperMappings.ts

@@ -0,0 +1,17 @@
+import { SyntaxKind } from "@ts-morph/common";
+import { expect } from "chai";
+import { TypeQueryNode } from "../../../../compiler";
+import { getInfoFromText } from "../../testHelpers";
+
+describe(nameof(TypeQueryNode), () => {
+    function getTypeQueryNode(text: string) {
+        const { sourceFile } = getInfoFromText(text);
+        return sourceFile.getFirstDescendantByKindOrThrow(SyntaxKind.TypeQuery);
+    }
+
+    describe(nameof<TypeQueryNode>(n => n.getExprName), () => {
+        it("should get", () => {
+            expect(getTypeQueryNode("const test: typeof Test").getExprName().getText(), "Test");
+        });
+    });
+});

packages/ts-morph/src/tests/compiler/ast/type/typeQueryNodeTests.ts

@@ -6,7 +6,7 @@ The disadvantage to a node not being wrapped is that it won't have helper method
 
 ## Exist
 
-**Total:** 204
+**Total:** 205
 
 * [ArrayBindingPattern](src/compiler/ast/binding/ArrayBindingPattern.ts)
     * :heavy_check_mark: elements
@@ -486,6 +486,8 @@ The disadvantage to a node not being wrapped is that it won't have helper method
     * :heavy_check_mark: assertsModifier
     * :heavy_check_mark: parameterName
     * :heavy_check_mark: type
+* [TypeQueryNode](src/compiler/ast/type/TypeQueryNode.ts)
+    * :heavy_check_mark: exprName
 * [TypeReferenceNode](src/compiler/ast/type/TypeReferenceNode.ts)
     * :heavy_check_mark: typeName
 * [UnaryExpression](src/compiler/ast/expression/UnaryExpression.ts)
@@ -514,7 +516,7 @@ The disadvantage to a node not being wrapped is that it won't have helper method
 
 ## Not Exist
 
-**Total:** 56
+**Total:** 55
 
 * Bundle
 * CallChain
@@ -565,7 +567,6 @@ The disadvantage to a node not being wrapped is that it won't have helper method
 * TransientIdentifier
 * TsConfigSourceFile
 * TypeOperatorNode
-* TypeQueryNode
 * UnparsedPrepend
 * UnparsedPrologue
 * UnparsedSection