@goast/typescript 0.9.0-beta.2 → 0.9.1

package/dist/src/ast/nodes/reference.d.ts

@@ -17,29 +17,101 @@ type _AddImportHandler<T> = {
     builderClass: abstract new (...args: any[]) => T;
     handler: (builder: T, reference: TsReference<any>) => void;
 };
+/**
+ * Represents a reference to a named type or value, such as `Foo` or `Foo<T, U>`. A reference can also name the module
+ * that exports it. Writing such a reference adds an import for it to the file that is being written.
+ *
+ * The reference is written as its name, followed by the generic arguments in angle brackets when there are any. When a
+ * module is set and the reference is written to a `TypeScriptFileBuilder`, the name is also registered as an import of
+ * that file. The import is registered when the reference is written, so a reference that is never written adds no
+ * import. Imports from the same module are combined into one statement.
+ *
+ * How the import is written depends on `importType`. A value import is written as `import { X } from 'module';`, a type
+ * import as `import type { X } from 'module';`, and a `js-doc` import as an `@import` tag in a JSDoc comment, which is
+ * used for JavaScript output. Other builders can handle imports as well, see `registerAddImportHandler`.
+ *
+ * @template TBuilder The type of the source builder the reference is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsReference
+ * @see TypeScriptFileBuilder
+ */
 export declare class TsReference<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
     private static readonly addImportHandlers;
+    /**
+     * The name of the referenced type or value, written verbatim. When a module is set, the same name is imported
+     * from it, so it has to be the name that the module exports.
+     */
     name: string;
+    /**
+     * The module name, such as `'@angular/core'`, or the path of a file that exports the name, such as
+     * `'./models/foo.ts'`. `null` makes the reference local, so no import is added. A path that ends in `.ts`, `.js`
+     * or `.json` is a file path, which is written relative to the generated file when that file's path is known.
+     */
     moduleNameOrfilePath: string | null;
+    /**
+     * The generic arguments written in angle brackets after the name, such as `<T, U>`. Null entries are skipped, and an
+     * empty list writes the bare name. With more than two arguments, each one is written on its own line.
+     */
     generics: TsType<TBuilder>[];
+    /**
+     * The kind of import that is added for `moduleNameOrfilePath`: `'import'` for a value import, `'type-import'` for a
+     * type-only import, or `'js-doc'` for an `@import` tag in a JSDoc comment. It has no effect without a module.
+     * @default 'import'
+     */
     importType: TypeScriptImportType;
+    /**
+     * Initializes a new instance of the TsReference class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
+    /**
+     * Registers a handler that adds the import of a reference to builders of the given class. The handler is called
+     * when a reference with a module is written to a builder that is an instance of `builderClass`. Handlers are tried
+     * in the order they were registered, and the first one that matches is used. The default handler for
+     * `TypeScriptFileBuilder` is registered first, so a handler for that class, or a subclass of it, is never reached.
+     * @param builderClass The class of the builders that the handler applies to. Matched with `instanceof`.
+     * @param handler Adds the import of the reference to the builder. It receives the builder and the reference.
+     */
     static registerAddImportHandler<TBuilder extends SourceBuilder>(builderClass: _AddImportHandler<TBuilder>['builderClass'], handler: _AddImportHandler<TBuilder>['handler']): void;
 }
 declare const createReference: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], moduleNameOrfilePath?: Options<TBuilder>['moduleNameOrfilePath'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'moduleNameOrfilePath'>>) => TsReference<TBuilder>;
+/**
+ * A function that creates references with a fixed name and module, as returned by `tsReference.factory`. Calling it
+ * creates a reference with the given options. The properties `refName` and `moduleNameOrfilePath` expose the name and
+ * the module that the factory was created with.
+ * @see tsReference.factory
+ */
 export type TsReferenceFactory = (<TBuilder extends SourceBuilder>(options?: FactoryOptions<TBuilder>) => TsReference<TBuilder>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
 };
+/**
+ * A reference factory that was created with a module, so its `moduleNameOrfilePath` is always a string.
+ * @see TsReferenceFactory
+ */
 export type TsModuleReferenceFactory = TsReferenceFactory & {
     moduleNameOrfilePath: string;
 };
+/**
+ * A function that creates references to a generic type, as returned by `tsReference.genericFactory`. It takes the
+ * generic arguments as a tuple, whose length is given by `TGenericCount`. The `infer` function creates a reference to
+ * the same name without generic arguments.
+ *
+ * @template TGenericCount The number of generic arguments that are required, or an array of the accepted counts.
+ * @see tsReference.genericFactory
+ */
 export type TsGenericReferenceFactory<TGenericCount extends number | number[]> = (<TBuilder extends SourceBuilder>(generics: TupleWithCount<TsType<TBuilder>, TGenericCount>, options?: FactoryOptions<TBuilder>) => TsReference<TBuilder>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
     infer: <TBuilder extends SourceBuilder>() => TsReference<TBuilder>;
 };
+/**
+ * A generic reference factory that was created with a module, so its `moduleNameOrfilePath` is always a string.
+ *
+ * @template TGenericCount The number of generic arguments that are required, or an array of the accepted counts.
+ * @see TsGenericReferenceFactory
+ */
 export type TsGenericModuleReferenceFactory<TGenericCount extends number | number[]> = TsGenericReferenceFactory<TGenericCount> & {
     moduleNameOrfilePath: string;
 };
@@ -55,6 +127,24 @@ declare function createGenericFactory<TGenericCount extends number | number[]>(n
 declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
     importType?: Nullable<TypeScriptImportType>;
 }): TsGenericReferenceFactory<TGenericCount>;
+/**
+ * Factory for creating reference nodes. The `write` function writes one or more reference nodes to a builder.
+ *
+ * `factory` creates a reusable function for a name and module, with default options. `genericFactory` does the same
+ * for a generic type, and takes the generic arguments as its first parameter.
+ *
+ * @param name The name of the referenced type or value. See `TsReference.name`.
+ * @param moduleNameOrfilePath The module or file that exports the name, or `null` for a local name.
+ * @param options The settings of the reference. See `TsReference` for the available properties.
+ * @example
+ * ```ts
+ * tsReference('X', 'module', { generics: ['T', 'U'] });
+ * // Output, with the import added to the file:
+ * // import { X } from 'module';
+ * // X<T, U>
+ * ```
+ * @see TsReference
+ */
 export declare const tsReference: typeof createReference & {
     factory: typeof createFactory;
     genericFactory: typeof createGenericFactory;

package/dist/src/ast/nodes/reference.js

@@ -3,6 +3,24 @@ import { TypeScriptFileBuilder } from '../../file-builder.js';
 import { TsNode } from '../node.js';
 import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a reference to a named type or value, such as `Foo` or `Foo<T, U>`. A reference can also name the module
+ * that exports it. Writing such a reference adds an import for it to the file that is being written.
+ *
+ * The reference is written as its name, followed by the generic arguments in angle brackets when there are any. When a
+ * module is set and the reference is written to a `TypeScriptFileBuilder`, the name is also registered as an import of
+ * that file. The import is registered when the reference is written, so a reference that is never written adds no
+ * import. Imports from the same module are combined into one statement.
+ *
+ * How the import is written depends on `importType`. A value import is written as `import { X } from 'module';`, a type
+ * import as `import type { X } from 'module';`, and a `js-doc` import as an `@import` tag in a JSDoc comment, which is
+ * used for JavaScript output. Other builders can handle imports as well, see `registerAddImportHandler`.
+ *
+ * @template TBuilder The type of the source builder the reference is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsReference
+ * @see TypeScriptFileBuilder
+ */
 export class TsReference extends TsNode {
     static addImportHandlers = [
         {
@@ -14,10 +32,32 @@ export class TsReference extends TsNode {
             },
         },
     ];
+    /**
+     * The name of the referenced type or value, written verbatim. When a module is set, the same name is imported
+     * from it, so it has to be the name that the module exports.
+     */
     name;
+    /**
+     * The module name, such as `'@angular/core'`, or the path of a file that exports the name, such as
+     * `'./models/foo.ts'`. `null` makes the reference local, so no import is added. A path that ends in `.ts`, `.js`
+     * or `.json` is a file path, which is written relative to the generated file when that file's path is known.
+     */
     moduleNameOrfilePath;
+    /**
+     * The generic arguments written in angle brackets after the name, such as `<T, U>`. Null entries are skipped, and an
+     * empty list writes the bare name. With more than two arguments, each one is written on its own line.
+     */
     generics;
+    /**
+     * The kind of import that is added for `moduleNameOrfilePath`: `'import'` for a value import, `'type-import'` for a
+     * type-only import, or `'js-doc'` for an `@import` tag in a JSDoc comment. It has no effect without a module.
+     * @default 'import'
+     */
     importType;
+    /**
+     * Initializes a new instance of the TsReference class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -35,6 +75,14 @@ export class TsReference extends TsNode {
             }
         }
     }
+    /**
+     * Registers a handler that adds the import of a reference to builders of the given class. The handler is called
+     * when a reference with a module is written to a builder that is an instance of `builderClass`. Handlers are tried
+     * in the order they were registered, and the first one that matches is used. The default handler for
+     * `TypeScriptFileBuilder` is registered first, so a handler for that class, or a subclass of it, is never reached.
+     * @param builderClass The class of the builders that the handler applies to. Matched with `instanceof`.
+     * @param handler Adds the import of the reference to the builder. It receives the builder and the reference.
+     */
     static registerAddImportHandler(builderClass, handler) {
         TsReference.addImportHandlers.push({ builderClass, handler });
     }
@@ -59,6 +107,24 @@ function _createGenericFactory(name, moduleNameOrfilePath, defaultOptions) {
 function createGenericFactory(name, moduleNameOrfilePath, defaultOptions) {
     return _createGenericFactory(name, moduleNameOrfilePath, defaultOptions);
 }
+/**
+ * Factory for creating reference nodes. The `write` function writes one or more reference nodes to a builder.
+ *
+ * `factory` creates a reusable function for a name and module, with default options. `genericFactory` does the same
+ * for a generic type, and takes the generic arguments as its first parameter.
+ *
+ * @param name The name of the referenced type or value. See `TsReference.name`.
+ * @param moduleNameOrfilePath The module or file that exports the name, or `null` for a local name.
+ * @param options The settings of the reference. See `TsReference` for the available properties.
+ * @example
+ * ```ts
+ * tsReference('X', 'module', { generics: ['T', 'U'] });
+ * // Output, with the import added to the file:
+ * // import { X } from 'module';
+ * // X<T, U>
+ * ```
+ * @see TsReference
+ */
 export const tsReference = Object.assign(createReference, {
     factory: createFactory,
     genericFactory: createGenericFactory,

package/dist/src/ast/nodes/string.d.ts

@@ -6,13 +6,48 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     value: string;
     template?: Nullable<boolean>;
 }>;
+/**
+ * Represents a string literal, such as `'X'`.
+ *
+ * The value is written as a quoted literal with the escapes that a string literal needs. Strings use single quotes
+ * unless the `useSingleQuotes` option of the builder is turned off, in which case they use double quotes. When
+ * `template` is set, the value is written as a template literal between backticks instead.
+ *
+ * @template TBuilder The type of the source builder the string is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsString
+ */
 export declare class TsString<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The text of the string, escaped for a quoted literal. In template mode, backticks are escaped but `${` is written
+     * as it is, so it still starts an interpolation.
+     */
     value: string;
+    /**
+     * Whether the value is written as a template literal between backticks instead of a quoted string.
+     * @default false
+     */
     template: boolean;
+    /**
+     * Initializes a new instance of the TsString class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createString: <TBuilder extends SourceBuilder>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => TsString<TBuilder>;
+/**
+ * Factory for creating string nodes. The `write` function writes one or more string nodes to a builder.
+ *
+ * @param value The text of the string. See `TsString.value`.
+ * @param options The settings of the string. See `TsString` for the available properties.
+ * @example
+ * ```ts
+ * tsString('X', { template: true });
+ * // Emits:
+ * // `X`
+ * ```
+ */
 export declare const tsString: typeof createString & {
     write: typeof writeTsNodes;
 };

package/dist/src/ast/nodes/string.js

@@ -1,9 +1,32 @@
 import { TsNode } from '../node.js';
 import { getTypeScriptBuilderOptions } from '../utils/get-type-script-builder-options.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a string literal, such as `'X'`.
+ *
+ * The value is written as a quoted literal with the escapes that a string literal needs. Strings use single quotes
+ * unless the `useSingleQuotes` option of the builder is turned off, in which case they use double quotes. When
+ * `template` is set, the value is written as a template literal between backticks instead.
+ *
+ * @template TBuilder The type of the source builder the string is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsString
+ */
 export class TsString extends TsNode {
+    /**
+     * The text of the string, escaped for a quoted literal. In template mode, backticks are escaped but `${` is written
+     * as it is, so it still starts an interpolation.
+     */
     value;
+    /**
+     * Whether the value is written as a template literal between backticks instead of a quoted string.
+     * @default false
+     */
     template;
+    /**
+     * Initializes a new instance of the TsString class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.value = options.value;
@@ -22,6 +45,18 @@ export class TsString extends TsNode {
     }
 }
 const createString = (value, options) => new TsString({ ...options, value });
+/**
+ * Factory for creating string nodes. The `write` function writes one or more string nodes to a builder.
+ *
+ * @param value The text of the string. See `TsString.value`.
+ * @param options The settings of the string. See `TsString` for the available properties.
+ * @example
+ * ```ts
+ * tsString('X', { template: true });
+ * // Emits:
+ * // `X`
+ * ```
+ */
 export const tsString = Object.assign(createString, {
     write: writeTsNodes,
 });

package/dist/src/ast/nodes/tuple.d.ts

@@ -7,13 +7,46 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     elements: Nullable<TsType<TBuilder> | TsValue<TBuilder>>[];
     asConst?: Nullable<boolean>;
 }>;
+/**
+ * Represents a tuple, which is a fixed list of types or values, such as `[string, number]`.
+ *
+ * Written as the elements in square brackets, separated by commas. Tuples of more than three elements are written with
+ * one element per line. An empty tuple is written as `[]`, and ` as const` is appended when `asConst` is set.
+ *
+ * @template TBuilder The type of the source builder the tuple is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsTuple
+ */
 export declare class TsTuple<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The types or values of the elements, in the given order. Null entries are skipped.
+     */
     elements: (TsType<TBuilder> | TsValue<TBuilder>)[];
+    /**
+     * Whether ` as const` is appended after the brackets, such as `[string, number] as const`.
+     * @default false
+     */
     asConst: boolean;
+    /**
+     * Initializes a new instance of the TsTuple class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createTuple: <TBuilder extends SourceBuilder>(elements: Options<TBuilder>['elements'], options?: Prettify<Omit<Options<TBuilder>, 'elements'>>) => TsTuple<TBuilder>;
+/**
+ * Factory for creating tuple nodes. The `write` function writes one or more tuple nodes to a builder.
+ *
+ * @param elements The types or values of the elements. See `TsTuple.elements`.
+ * @param options The settings of the tuple. See `TsTuple` for the available properties.
+ * @example
+ * ```ts
+ * tsTuple(['string', 'number'], { asConst: true });
+ * // Emits:
+ * // [string, number] as const
+ * ```
+ */
 export declare const tsTuple: typeof createTuple & {
     write: typeof writeTsNodes;
 };

package/dist/src/ast/nodes/tuple.js

@@ -1,9 +1,30 @@
 import { notNullish } from '@goast/core';
 import { TsNode } from '../node.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a tuple, which is a fixed list of types or values, such as `[string, number]`.
+ *
+ * Written as the elements in square brackets, separated by commas. Tuples of more than three elements are written with
+ * one element per line. An empty tuple is written as `[]`, and ` as const` is appended when `asConst` is set.
+ *
+ * @template TBuilder The type of the source builder the tuple is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsTuple
+ */
 export class TsTuple extends TsNode {
+    /**
+     * The types or values of the elements, in the given order. Null entries are skipped.
+     */
     elements;
+    /**
+     * Whether ` as const` is appended after the brackets, such as `[string, number] as const`.
+     * @default false
+     */
     asConst;
+    /**
+     * Initializes a new instance of the TsTuple class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.elements = options.elements.filter(notNullish);
@@ -25,6 +46,18 @@ export class TsTuple extends TsNode {
     }
 }
 const createTuple = (elements, options) => new TsTuple({ ...options, elements });
+/**
+ * Factory for creating tuple nodes. The `write` function writes one or more tuple nodes to a builder.
+ *
+ * @param elements The types or values of the elements. See `TsTuple.elements`.
+ * @param options The settings of the tuple. See `TsTuple` for the available properties.
+ * @example
+ * ```ts
+ * tsTuple(['string', 'number'], { asConst: true });
+ * // Emits:
+ * // [string, number] as const
+ * ```
+ */
 export const tsTuple = Object.assign(createTuple, {
     write: writeTsNodes,
 });

package/dist/src/ast/nodes/type-alias.d.ts

@@ -12,16 +12,60 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     type: TsType<TBuilder>;
     export?: Nullable<boolean>;
 }>;
+/**
+ * Represents a type alias declaration, such as `export type X<T> = T | null;`.
+ *
+ * Written in this order: doc comment, `export` keyword, `type`, name, generics, ` = `, the type, and a semicolon. A
+ * type that spans several lines is indented. Unlike classes and methods, the doc comment is written as it is, so the
+ * descriptions of the generic parameters are not added to it as `@template` tags.
+ *
+ * @template TBuilder The type of the source builder the type alias is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsTypeAlias
+ */
 export declare class TsTypeAlias<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the type alias, written verbatim after the `type` keyword.
+     */
     name: string;
+    /**
+     * The doc comment written above the declaration, or `null` to omit it. It is written as given.
+     */
     doc: TsDoc<TBuilder> | null;
+    /**
+     * The type parameters written in angle brackets after the name, such as `<T, U>`. Null entries are skipped.
+     */
     generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The aliased type, written after ` = `. It is required.
+     */
     type: TsType<TBuilder>;
+    /**
+     * Whether the declaration is written with the `export` keyword.
+     * @default false
+     */
     export: boolean;
+    /**
+     * Initializes a new instance of the TsTypeAlias class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createTypeAlias: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], type: Options<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type'>>) => TsTypeAlias<TBuilder>;
+/**
+ * Factory for creating type alias nodes. The `write` function writes one or more type alias nodes to a builder.
+ *
+ * @param name The name of the type alias. See `TsTypeAlias.name`.
+ * @param type The aliased type. See `TsTypeAlias.type`.
+ * @param options The settings of the type alias. See `TsTypeAlias` for the available properties.
+ * @example
+ * ```ts
+ * tsTypeAlias('X', 'number', { export: true });
+ * // Emits:
+ * // export type X = number;
+ * ```
+ */
 export declare const tsTypeAlias: typeof createTypeAlias & {
     write: typeof writeTsNodes;
 };

package/dist/src/ast/nodes/type-alias.js

@@ -2,12 +2,43 @@ import { notNullish, } from '@goast/core';
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
 import { tsGenericParameter } from './generic-parameter.js';
+/**
+ * Represents a type alias declaration, such as `export type X<T> = T | null;`.
+ *
+ * Written in this order: doc comment, `export` keyword, `type`, name, generics, ` = `, the type, and a semicolon. A
+ * type that spans several lines is indented. Unlike classes and methods, the doc comment is written as it is, so the
+ * descriptions of the generic parameters are not added to it as `@template` tags.
+ *
+ * @template TBuilder The type of the source builder the type alias is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsTypeAlias
+ */
 export class TsTypeAlias extends TsNode {
+    /**
+     * The name of the type alias, written verbatim after the `type` keyword.
+     */
     name;
+    /**
+     * The doc comment written above the declaration, or `null` to omit it. It is written as given.
+     */
     doc;
+    /**
+     * The type parameters written in angle brackets after the name, such as `<T, U>`. Null entries are skipped.
+     */
     generics;
+    /**
+     * The aliased type, written after ` = `. It is required.
+     */
     type;
+    /**
+     * Whether the declaration is written with the `export` keyword.
+     * @default false
+     */
     export;
+    /**
+     * Initializes a new instance of the TsTypeAlias class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -33,6 +64,19 @@ export class TsTypeAlias extends TsNode {
     }
 }
 const createTypeAlias = (name, type, options) => new TsTypeAlias({ ...options, name, type });
+/**
+ * Factory for creating type alias nodes. The `write` function writes one or more type alias nodes to a builder.
+ *
+ * @param name The name of the type alias. See `TsTypeAlias.name`.
+ * @param type The aliased type. See `TsTypeAlias.type`.
+ * @param options The settings of the type alias. See `TsTypeAlias` for the available properties.
+ * @example
+ * ```ts
+ * tsTypeAlias('X', 'number', { export: true });
+ * // Emits:
+ * // export type X = number;
+ * ```
+ */
 export const tsTypeAlias = Object.assign(createTypeAlias, {
     write: writeTsNodes,
 });

package/dist/src/ast/nodes/typeof.d.ts

@@ -6,12 +6,53 @@ type Injects = 'value';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     value: TsValue<TBuilder>;
 }>;
+/**
+ * Represents a `typeof` type query, which takes the type of a value, such as `typeof foo`.
+ *
+ * Written as the keyword `typeof` followed by the value. The injection points `beforeValue` and `afterValue` wrap the
+ * value.
+ *
+ * @template TBuilder The type of the source builder the type query is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsTypeof
+ */
 export declare class TsTypeof<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The value whose type is queried, written after `typeof`, such as `foo`.
+     */
     value: TsValue<TBuilder>;
+    /**
+     * Initializes a new instance of the TsTypeof class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
+/**
+ * Creates a `typeof` type query node. This is the function that `tsTypeof` wraps, and `tsTypeof` also provides `write`.
+ *
+ * @param value The value whose type is queried. See `TsTypeof.value`.
+ * @param options The settings of the type query. See `TsTypeof` for the available properties.
+ * @example
+ * ```ts
+ * createTypeof('foo');
+ * // Emits:
+ * // typeof foo
+ * ```
+ */
 export declare const createTypeof: <TBuilder extends SourceBuilder>(value: Options<TBuilder>['value'], options?: Omit<Options<TBuilder>, 'value'>) => TsTypeof<TBuilder>;
+/**
+ * Factory for creating `typeof` type query nodes. The `write` function writes one or more of them to a builder.
+ *
+ * @param value The value whose type is queried. See `TsTypeof.value`.
+ * @param options The settings of the type query. See `TsTypeof` for the available properties.
+ * @example
+ * ```ts
+ * tsTypeof('foo');
+ * // Emits:
+ * // typeof foo
+ * ```
+ */
 export declare const tsTypeof: typeof createTypeof & {
     write: typeof writeTsNodes;
 };

package/dist/src/ast/nodes/typeof.js

@@ -1,7 +1,24 @@
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a `typeof` type query, which takes the type of a value, such as `typeof foo`.
+ *
+ * Written as the keyword `typeof` followed by the value. The injection points `beforeValue` and `afterValue` wrap the
+ * value.
+ *
+ * @template TBuilder The type of the source builder the type query is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsTypeof
+ */
 export class TsTypeof extends TsNode {
+    /**
+     * The value whose type is queried, written after `typeof`, such as `foo`.
+     */
     value;
+    /**
+     * Initializes a new instance of the TsTypeof class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.value = options.value;
@@ -13,7 +30,31 @@ export class TsTypeof extends TsNode {
         builder.append(this.inject.afterValue);
     }
 }
+/**
+ * Creates a `typeof` type query node. This is the function that `tsTypeof` wraps, and `tsTypeof` also provides `write`.
+ *
+ * @param value The value whose type is queried. See `TsTypeof.value`.
+ * @param options The settings of the type query. See `TsTypeof` for the available properties.
+ * @example
+ * ```ts
+ * createTypeof('foo');
+ * // Emits:
+ * // typeof foo
+ * ```
+ */
 export const createTypeof = (value, options) => new TsTypeof({ ...options, value });
+/**
+ * Factory for creating `typeof` type query nodes. The `write` function writes one or more of them to a builder.
+ *
+ * @param value The value whose type is queried. See `TsTypeof.value`.
+ * @param options The settings of the type query. See `TsTypeof` for the available properties.
+ * @example
+ * ```ts
+ * tsTypeof('foo');
+ * // Emits:
+ * // typeof foo
+ * ```
+ */
 export const tsTypeof = Object.assign(createTypeof, {
     write: writeTsNodes,
 });