@goast/typescript 0.9.0-beta.2 → 0.9.1

package/dist/src/ast/nodes/enum-value.d.ts

@@ -8,15 +8,52 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     name: string;
     value?: Nullable<TsString<TBuilder> | BasicAppendValue<TBuilder>>;
 }>;
+/**
+ * Represents a member of an enum, such as `Active = 1`.
+ *
+ * Written in this order: the doc comment, the name, then ` = ` and the value when one is set. The enclosing enum
+ * separates its members with commas and line breaks.
+ *
+ * @template TBuilder The type of the source builder the enum value is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsEnumValue
+ */
 export declare class TsEnumValue<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The doc comment written above the member, or `null` to omit it.
+     */
     doc: TsDoc<TBuilder> | null;
+    /**
+     * The name of the member, written verbatim before the value.
+     */
     name: string;
+    /**
+     * The value written after ` = `, or `null` to write the member without a value, so that TypeScript assigns it. Nodes
+     * are written with their own output, and other values are appended as they are.
+     */
     value: TsString<TBuilder> | BasicAppendValue<TBuilder> | null;
+    /**
+     * Initializes a new instance of the TsEnumValue class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createEnumValue: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsEnumValue<TBuilder>;
 declare const writeEnumValues: <TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<TsEnumValue<TBuilder> | AppendValue<TBuilder>>>) => void;
+/**
+ * Factory for creating enum member nodes. The `write` function writes one or more members to a builder, separated by
+ * commas and line breaks.
+ *
+ * @param name The name of the member.
+ * @param options The settings of the member. See `TsEnumValue` for the available properties.
+ * @example
+ * ```ts
+ * tsEnumValue('Active', { value: '1' });
+ * // Emits:
+ * // Active = 1
+ * ```
+ */
 export declare const tsEnumValue: typeof createEnumValue & {
     write: typeof writeEnumValues;
 };

package/dist/src/ast/nodes/enum-value.js

@@ -1,9 +1,33 @@
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a member of an enum, such as `Active = 1`.
+ *
+ * Written in this order: the doc comment, the name, then ` = ` and the value when one is set. The enclosing enum
+ * separates its members with commas and line breaks.
+ *
+ * @template TBuilder The type of the source builder the enum value is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsEnumValue
+ */
 export class TsEnumValue extends TsNode {
+    /**
+     * The doc comment written above the member, or `null` to omit it.
+     */
     doc;
+    /**
+     * The name of the member, written verbatim before the value.
+     */
     name;
+    /**
+     * The value written after ` = `, or `null` to write the member without a value, so that TypeScript assigns it. Nodes
+     * are written with their own output, and other values are appended as they are.
+     */
     value;
+    /**
+     * Initializes a new instance of the TsEnumValue class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -27,6 +51,19 @@ const createEnumValue = (name, options) => new TsEnumValue({ ...options, name })
 const writeEnumValues = (builder, nodes) => {
     writeTsNodes(builder, nodes, { separator: ',\n' });
 };
+/**
+ * Factory for creating enum member nodes. The `write` function writes one or more members to a builder, separated by
+ * commas and line breaks.
+ *
+ * @param name The name of the member.
+ * @param options The settings of the member. See `TsEnumValue` for the available properties.
+ * @example
+ * ```ts
+ * tsEnumValue('Active', { value: '1' });
+ * // Emits:
+ * // Active = 1
+ * ```
+ */
 export const tsEnumValue = Object.assign(createEnumValue, {
     write: writeEnumValues,
 });

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

@@ -11,16 +11,63 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     name: string;
     members?: Nullable<Nullable<TsEnumValue<TBuilder>>[]>;
 }>;
+/**
+ * Represents an enum declaration.
+ *
+ * Written in this order: the doc comment, the `export` and `const` keywords, then `enum`, the name, and the members in
+ * braces, followed by a line break.
+ *
+ * @template TBuilder The type of the source builder the enum is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsEnum
+ */
 export declare class TsEnum<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The doc comment written above the enum, or `null` to omit it.
+     */
     doc: TsDoc<TBuilder> | null;
+    /**
+     * Whether the enum is written with the `export` keyword.
+     * @default false
+     */
     export: boolean;
+    /**
+     * Whether the enum is written as a `const enum`. The `const` keyword is placed after `export` when both are set.
+     * @default false
+     */
     const: boolean;
+    /**
+     * The name of the enum, written after the `enum` keyword.
+     */
     name: string;
+    /**
+     * The members written in the body, one per line and separated by commas. The last member has no trailing comma, and
+     * the braces are written empty when there are no members.
+     */
     members: TsEnumValue<TBuilder>[];
+    /**
+     * Initializes a new instance of the TsEnum class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createEnum: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsEnum<TBuilder>;
+/**
+ * Factory for creating enum nodes. The `write` function writes one or more enums to a builder.
+ *
+ * @param name The name of the enum.
+ * @param options The settings of the enum. See `TsEnum` for the available properties.
+ * @example
+ * ```ts
+ * tsEnum('Color', { export: true, members: [tsEnumValue('Red'), tsEnumValue('Green')] });
+ * // Emits:
+ * // export enum Color {
+ * //   Red,
+ * //   Green
+ * // }
+ * ```
+ */
 export declare const tsEnum: typeof createEnum & {
     write: typeof writeTsNodes;
 };

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

@@ -2,12 +2,44 @@ import { notNullish } from '@goast/core';
 import { TsNode } from '../node.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
 import { tsEnumValue } from './enum-value.js';
+/**
+ * Represents an enum declaration.
+ *
+ * Written in this order: the doc comment, the `export` and `const` keywords, then `enum`, the name, and the members in
+ * braces, followed by a line break.
+ *
+ * @template TBuilder The type of the source builder the enum is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsEnum
+ */
 export class TsEnum extends TsNode {
+    /**
+     * The doc comment written above the enum, or `null` to omit it.
+     */
     doc;
+    /**
+     * Whether the enum is written with the `export` keyword.
+     * @default false
+     */
     export;
+    /**
+     * Whether the enum is written as a `const enum`. The `const` keyword is placed after `export` when both are set.
+     * @default false
+     */
     const;
+    /**
+     * The name of the enum, written after the `enum` keyword.
+     */
     name;
+    /**
+     * The members written in the body, one per line and separated by commas. The last member has no trailing comma, and
+     * the braces are written empty when there are no members.
+     */
     members;
+    /**
+     * Initializes a new instance of the TsEnum class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.doc = options.doc ?? null;
@@ -40,6 +72,21 @@ export class TsEnum extends TsNode {
     }
 }
 const createEnum = (name, options) => new TsEnum({ ...options, name });
+/**
+ * Factory for creating enum nodes. The `write` function writes one or more enums to a builder.
+ *
+ * @param name The name of the enum.
+ * @param options The settings of the enum. See `TsEnum` for the available properties.
+ * @example
+ * ```ts
+ * tsEnum('Color', { export: true, members: [tsEnumValue('Red'), tsEnumValue('Green')] });
+ * // Emits:
+ * // export enum Color {
+ * //   Red,
+ * //   Green
+ * // }
+ * ```
+ */
 export const tsEnum = Object.assign(createEnum, {
     write: writeTsNodes,
 });

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

@@ -8,14 +8,65 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     filePath: string;
     kind?: Nullable<TypeScriptExportType>;
 }>;
+/**
+ * Represents a re-export of a symbol from another module, such as `export { X } from './x';`.
+ *
+ * In a `TypeScriptFileBuilder` the export is not written in place. The file collects it and writes it together with its
+ * other exports, grouped by module path. Any other builder receives the export statement as text, followed by a line
+ * break.
+ *
+ * @template TBuilder The type of the source builder the export is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsExport
+ */
 export declare class TsExport<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the exported symbol, written inside the braces, such as `X` in `export { X } from './x';`.
+     */
     name: string;
+    /**
+     * The module path that the symbol is re-exported from, such as `./x`. The file builder groups exports by this path.
+     */
     filePath: string;
+    /**
+     * Whether the symbol is re-exported as a value with `export`, or as a type with `export type`.
+     * @default 'export'
+     */
     kind: TypeScriptExportType;
+    /**
+     * Initializes a new instance of the TsExport class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
+/**
+ * Creates a re-export node. The `tsExport` factory creates the same node and also provides a `write` function.
+ *
+ * @param name The name of the exported symbol.
+ * @param filePath The module path to re-export from.
+ * @param options The settings of the export. See `TsExport` for the available properties.
+ * @example
+ * ```ts
+ * createExport('myFunction', './my-function');
+ * // Emits (outside a TypeScriptFileBuilder):
+ * // export { myFunction } from './my-function';
+ * ```
+ */
 export declare const createExport: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], filePath: Options<TBuilder>['filePath'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'filePath'>>) => TsExport<TBuilder>;
+/**
+ * Factory for creating re-export nodes. The `write` function writes one or more re-exports to a builder.
+ *
+ * @param name The name of the exported symbol.
+ * @param filePath The module path to re-export from.
+ * @param options The settings of the export. See `TsExport` for the available properties.
+ * @example
+ * ```ts
+ * tsExport('myFunction', './my-function');
+ * // Emits (outside a TypeScriptFileBuilder):
+ * // export { myFunction } from './my-function';
+ * ```
+ */
 export declare const tsExport: typeof createExport & {
     write: typeof writeTsNodes;
 };

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

@@ -1,10 +1,35 @@
 import { TypeScriptFileBuilder } from '../../file-builder.js';
 import { TsNode } from '../node.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a re-export of a symbol from another module, such as `export { X } from './x';`.
+ *
+ * In a `TypeScriptFileBuilder` the export is not written in place. The file collects it and writes it together with its
+ * other exports, grouped by module path. Any other builder receives the export statement as text, followed by a line
+ * break.
+ *
+ * @template TBuilder The type of the source builder the export is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsExport
+ */
 export class TsExport extends TsNode {
+    /**
+     * The name of the exported symbol, written inside the braces, such as `X` in `export { X } from './x';`.
+     */
     name;
+    /**
+     * The module path that the symbol is re-exported from, such as `./x`. The file builder groups exports by this path.
+     */
     filePath;
+    /**
+     * Whether the symbol is re-exported as a value with `export`, or as a type with `export type`.
+     * @default 'export'
+     */
     kind;
+    /**
+     * Initializes a new instance of the TsExport class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -20,7 +45,33 @@ export class TsExport extends TsNode {
         }
     }
 }
+/**
+ * Creates a re-export node. The `tsExport` factory creates the same node and also provides a `write` function.
+ *
+ * @param name The name of the exported symbol.
+ * @param filePath The module path to re-export from.
+ * @param options The settings of the export. See `TsExport` for the available properties.
+ * @example
+ * ```ts
+ * createExport('myFunction', './my-function');
+ * // Emits (outside a TypeScriptFileBuilder):
+ * // export { myFunction } from './my-function';
+ * ```
+ */
 export const createExport = (name, filePath, options) => new TsExport({ ...options, name, filePath });
+/**
+ * Factory for creating re-export nodes. The `write` function writes one or more re-exports to a builder.
+ *
+ * @param name The name of the exported symbol.
+ * @param filePath The module path to re-export from.
+ * @param options The settings of the export. See `TsExport` for the available properties.
+ * @example
+ * ```ts
+ * tsExport('myFunction', './my-function');
+ * // Emits (outside a TypeScriptFileBuilder):
+ * // export { myFunction } from './my-function';
+ * ```
+ */
 export const tsExport = Object.assign(createExport, {
     write: writeTsNodes,
 });

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

@@ -10,14 +10,49 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     parameters?: Nullable<Nullable<TsParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
     returnType?: Nullable<TsType<TBuilder>>;
 }>;
+/**
+ * Represents a function type, such as `(x: number) => string`.
+ *
+ * Written in this order: the generics, the parameters in parentheses, ` => `, then the return type. The return type is
+ * written as `void` when it is not set.
+ *
+ * @template TBuilder The type of the source builder the function type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsFunctionType
+ */
 export declare class TsFunctionType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The type parameters written in angle brackets before the parameters, such as `<T, U>`. Nothing is written when
+     * there are none.
+     */
     generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The parameters written in parentheses, such as `(x, y)`. More than two parameters are written one per line.
+     */
     parameters: (TsParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The return type written after ` => `, or `void` when it is `null`.
+     */
     returnType: TsType<TBuilder> | null;
+    /**
+     * Initializes a new instance of the TsFunctionType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createFunctionType: <TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsFunctionType<TBuilder>;
+/**
+ * Factory for creating function type nodes. The `write` function writes one or more function types to a builder.
+ *
+ * @param options The settings of the function type. See `TsFunctionType` for the available properties.
+ * @example
+ * ```ts
+ * tsFunctionType({ parameters: [tsParameter('x', { type: 'number' })], returnType: 'string' });
+ * // Emits:
+ * // (x: number) => string
+ * ```
+ */
 export declare const tsFunctionType: typeof createFunctionType & {
     write: typeof writeTsNodes;
 };

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

@@ -3,10 +3,34 @@ import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
 import { tsGenericParameter } from './generic-parameter.js';
 import { tsParameter } from './parameter.js';
+/**
+ * Represents a function type, such as `(x: number) => string`.
+ *
+ * Written in this order: the generics, the parameters in parentheses, ` => `, then the return type. The return type is
+ * written as `void` when it is not set.
+ *
+ * @template TBuilder The type of the source builder the function type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsFunctionType
+ */
 export class TsFunctionType extends TsNode {
+    /**
+     * The type parameters written in angle brackets before the parameters, such as `<T, U>`. Nothing is written when
+     * there are none.
+     */
     generics;
+    /**
+     * The parameters written in parentheses, such as `(x, y)`. More than two parameters are written one per line.
+     */
     parameters;
+    /**
+     * The return type written after ` => `, or `void` when it is `null`.
+     */
     returnType;
+    /**
+     * Initializes a new instance of the TsFunctionType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.generics = options.generics?.filter(notNullish) ?? [];
@@ -27,6 +51,17 @@ export class TsFunctionType extends TsNode {
     }
 }
 const createFunctionType = (options) => new TsFunctionType(options ?? {});
+/**
+ * Factory for creating function type nodes. The `write` function writes one or more function types to a builder.
+ *
+ * @param options The settings of the function type. See `TsFunctionType` for the available properties.
+ * @example
+ * ```ts
+ * tsFunctionType({ parameters: [tsParameter('x', { type: 'number' })], returnType: 'string' });
+ * // Emits:
+ * // (x: number) => string
+ * ```
+ */
 export const tsFunctionType = Object.assign(createFunctionType, {
     write: writeTsNodes,
 });

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

@@ -17,19 +17,80 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     returnType?: Nullable<TsType<TBuilder>>;
     body?: Nullable<AppendValue<TBuilder>>;
 }>;
+/**
+ * Represents a function declaration.
+ *
+ * Written in this order: the doc comment, the decorators, the `export` keyword, the name, the generics, the parameters,
+ * the return type, then the body in braces, followed by a line break.
+ *
+ * @template TBuilder The type of the source builder the function is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsFunction
+ */
 export declare class TsFunction<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The doc comment written above the function, or `null` to omit it. Descriptions of generic parameters are merged
+     * into it as `@template` tags. Parameter descriptions are not written for functions, so add `@param` tags to the doc
+     * instead.
+     */
     doc: TsDoc<TBuilder> | null;
+    /**
+     * The decorators written above the function, each on its own line.
+     */
     decorators: TsDecorator<TBuilder>[];
+    /**
+     * Whether the function is written with the `export` keyword.
+     * @default false
+     */
     export: boolean;
+    /**
+     * The name of the function, written after the `function` keyword.
+     */
     name: string;
+    /**
+     * The type parameters written in angle brackets after the name, such as `<T, U>`. Nothing is written when empty.
+     */
     generics: TsGenericParameter<TBuilder>[];
+    /**
+     * The parameters written in parentheses after the name. More than two parameters are written one per line.
+     */
     parameters: TsParameter<TBuilder>[];
+    /**
+     * The return type written after the parameters as `: Type`, or `null` to omit it.
+     */
     returnType: TsType<TBuilder> | null;
+    /**
+     * The statements written in the body, on their own indented lines, or `null` to write empty braces `{}`.
+     */
     body: AppendValue<TBuilder> | null;
+    /**
+     * Initializes a new instance of the TsFunction class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createFunction: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsFunction<TBuilder>;
+/**
+ * Factory for creating function declaration nodes. The `write` function writes one or more functions to a builder.
+ *
+ * @param name The name of the function.
+ * @param options The settings of the function. See `TsFunction` for the available properties.
+ * @example
+ * ```ts
+ * tsFunction('add', {
+ *   export: true,
+ *   generics: [tsGenericParameter('T')],
+ *   parameters: [tsParameter('a', { type: 'T' }), tsParameter('b', { type: 'T' })],
+ *   returnType: 'T',
+ *   body: 'return a;',
+ * });
+ * // Emits:
+ * // export function add<T>(a: T, b: T): T {
+ * //   return a;
+ * // }
+ * ```
+ */
 export declare const tsFunction: typeof createFunction & {
     write: typeof writeTsNodes;
 };

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

@@ -5,15 +5,56 @@ import { tsDecorator } from './decorator.js';
 import { tsDoc } from './doc.js';
 import { tsGenericParameter } from './generic-parameter.js';
 import { tsParameter } from './parameter.js';
+/**
+ * Represents a function declaration.
+ *
+ * Written in this order: the doc comment, the decorators, the `export` keyword, the name, the generics, the parameters,
+ * the return type, then the body in braces, followed by a line break.
+ *
+ * @template TBuilder The type of the source builder the function is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsFunction
+ */
 export class TsFunction extends TsNode {
+    /**
+     * The doc comment written above the function, or `null` to omit it. Descriptions of generic parameters are merged
+     * into it as `@template` tags. Parameter descriptions are not written for functions, so add `@param` tags to the doc
+     * instead.
+     */
     doc;
+    /**
+     * The decorators written above the function, each on its own line.
+     */
     decorators;
+    /**
+     * Whether the function is written with the `export` keyword.
+     * @default false
+     */
     export;
+    /**
+     * The name of the function, written after the `function` keyword.
+     */
     name;
+    /**
+     * The type parameters written in angle brackets after the name, such as `<T, U>`. Nothing is written when empty.
+     */
     generics;
+    /**
+     * The parameters written in parentheses after the name. More than two parameters are written one per line.
+     */
     parameters;
+    /**
+     * The return type written after the parameters as `: Type`, or `null` to omit it.
+     */
     returnType;
+    /**
+     * The statements written in the body, on their own indented lines, or `null` to write empty braces `{}`.
+     */
     body;
+    /**
+     * Initializes a new instance of the TsFunction class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.doc = options.doc ?? null;
@@ -58,6 +99,26 @@ export class TsFunction extends TsNode {
     }
 }
 const createFunction = (name, options) => new TsFunction({ ...options, name });
+/**
+ * Factory for creating function declaration nodes. The `write` function writes one or more functions to a builder.
+ *
+ * @param name The name of the function.
+ * @param options The settings of the function. See `TsFunction` for the available properties.
+ * @example
+ * ```ts
+ * tsFunction('add', {
+ *   export: true,
+ *   generics: [tsGenericParameter('T')],
+ *   parameters: [tsParameter('a', { type: 'T' }), tsParameter('b', { type: 'T' })],
+ *   returnType: 'T',
+ *   body: 'return a;',
+ * });
+ * // Emits:
+ * // export function add<T>(a: T, b: T): T {
+ * //   return a;
+ * // }
+ * ```
+ */
 export const tsFunction = Object.assign(createFunction, {
     write: writeTsNodes,
 });