@goast/typescript 0.9.0 → 0.9.1

package/dist/src/ast/nodes/generic-parameter.d.ts

@@ -10,16 +10,60 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     constraint?: Nullable<TsType<TBuilder>>;
     default?: Nullable<TsType<TBuilder>>;
 }>;
+/**
+ * Represents a type parameter, such as `const T extends number = 4711`.
+ *
+ * Written in this order: the `const` modifier, the name, the constraint and the default type. The description is not
+ * written inline. Nodes with a doc comment, such as classes, functions and interfaces, add it as a `@template` tag.
+ *
+ * @template TBuilder The type of the source builder the type parameter is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsGenericParameter
+ */
 export declare class TsGenericParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The description of the type parameter. It is not written inline. Enclosing nodes with a doc comment add it as a
+     * `@template` tag.
+     */
     description: BasicAppendValue<TBuilder> | null;
+    /**
+     * Whether the parameter is written with the `const` modifier, such as `const T`.
+     * @default false
+     */
     const: boolean;
+    /**
+     * The name of the type parameter, such as `T`.
+     */
     name: string;
+    /**
+     * The type that the parameter must extend, written as ` extends Type`, or `null` to omit it.
+     */
     constraint: TsType<TBuilder> | null;
+    /**
+     * The type used when no type argument is given, written as ` = Type`, or `null` to omit it.
+     */
     default: TsType<TBuilder> | null;
+    /**
+     * Initializes a new instance of the TsGenericParameter class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createGenericParameter: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsGenericParameter<TBuilder>;
+/**
+ * Factory for creating type parameter nodes. The `write` function writes the parameters in angle brackets, or nothing
+ * when there are none. More than two parameters are written one per line.
+ *
+ * @param name The name of the type parameter.
+ * @param options The settings of the type parameter. See `TsGenericParameter` for the available properties.
+ * @example
+ * ```ts
+ * tsGenericParameter('T', { constraint: 'number', default: '4711', const: true });
+ * // Emits:
+ * // const T extends number = 4711
+ * ```
+ */
 export declare const tsGenericParameter: typeof createGenericParameter & {
     write: typeof writeTsGenericParameters;
 };

package/dist/src/ast/nodes/generic-parameter.js

@@ -1,12 +1,43 @@
 import { TsNode } from '../node.js';
 import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters.js';
 import { writeTsNode } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a type parameter, such as `const T extends number = 4711`.
+ *
+ * Written in this order: the `const` modifier, the name, the constraint and the default type. The description is not
+ * written inline. Nodes with a doc comment, such as classes, functions and interfaces, add it as a `@template` tag.
+ *
+ * @template TBuilder The type of the source builder the type parameter is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsGenericParameter
+ */
 export class TsGenericParameter extends TsNode {
+    /**
+     * The description of the type parameter. It is not written inline. Enclosing nodes with a doc comment add it as a
+     * `@template` tag.
+     */
     description;
+    /**
+     * Whether the parameter is written with the `const` modifier, such as `const T`.
+     * @default false
+     */
     const;
+    /**
+     * The name of the type parameter, such as `T`.
+     */
     name;
+    /**
+     * The type that the parameter must extend, written as ` extends Type`, or `null` to omit it.
+     */
     constraint;
+    /**
+     * The type used when no type argument is given, written as ` = Type`, or `null` to omit it.
+     */
     default;
+    /**
+     * Initializes a new instance of the TsGenericParameter class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.description = options.description ?? null;
@@ -35,6 +66,19 @@ export class TsGenericParameter extends TsNode {
     }
 }
 const createGenericParameter = (name, options) => new TsGenericParameter({ ...options, name });
+/**
+ * Factory for creating type parameter nodes. The `write` function writes the parameters in angle brackets, or nothing
+ * when there are none. More than two parameters are written one per line.
+ *
+ * @param name The name of the type parameter.
+ * @param options The settings of the type parameter. See `TsGenericParameter` for the available properties.
+ * @example
+ * ```ts
+ * tsGenericParameter('T', { constraint: 'number', default: '4711', const: true });
+ * // Emits:
+ * // const T extends number = 4711
+ * ```
+ */
 export const tsGenericParameter = Object.assign(createGenericParameter, {
     write: writeTsGenericParameters,
 });

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

@@ -9,15 +9,56 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     valueType: TsType<TBuilder>;
     readonly?: Nullable<boolean>;
 }>;
+/**
+ * Represents an index signature, such as `readonly [key: string]: number;`.
+ *
+ * Written in this order: the `readonly` keyword when set, the key in square brackets as `name: keyType`, then
+ * `: valueType;`. The signature is followed by a line break. It is used as a member of an interface or a class.
+ *
+ * @template TBuilder The type of the source builder the index signature is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsIndexer
+ */
 export declare class TsIndexer<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the key parameter, written before the key type, such as `id` in `[id: string]`.
+     * @default 'key'
+     */
     keyName: string;
+    /**
+     * The type of the keys, written after the key name in square brackets, such as `string`.
+     */
     keyType: TsType<TBuilder>;
+    /**
+     * The type of the values, written after the closing bracket, such as `number` in `: number;`.
+     */
     valueType: TsType<TBuilder>;
+    /**
+     * Whether the signature is written with the `readonly` keyword in front of it.
+     * @default false
+     */
     readonly: boolean;
+    /**
+     * Initializes a new instance of the TsIndexer class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createIndexer: <TBuilder extends SourceBuilder>(keyType: Options<TBuilder>['keyType'], valueType: Options<TBuilder>['valueType'], options?: Prettify<Omit<Options<TBuilder>, 'keyType' | 'valueType'>>) => TsIndexer<TBuilder>;
+/**
+ * Factory for creating index signature nodes. The `write` function writes one or more index signatures to a builder.
+ *
+ * @param keyType The type of the keys.
+ * @param valueType The type of the values.
+ * @param options The settings of the index signature. See `TsIndexer` for the available properties.
+ * @example
+ * ```ts
+ * tsIndexer('string', 'number', { keyName: 'id', readonly: true });
+ * // Emits:
+ * // readonly [id: string]: number;
+ * ```
+ */
 export declare const tsIndexer: typeof createIndexer & {
     write: typeof writeTsNodes;
 };

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

@@ -1,10 +1,38 @@
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents an index signature, such as `readonly [key: string]: number;`.
+ *
+ * Written in this order: the `readonly` keyword when set, the key in square brackets as `name: keyType`, then
+ * `: valueType;`. The signature is followed by a line break. It is used as a member of an interface or a class.
+ *
+ * @template TBuilder The type of the source builder the index signature is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsIndexer
+ */
 export class TsIndexer extends TsNode {
+    /**
+     * The name of the key parameter, written before the key type, such as `id` in `[id: string]`.
+     * @default 'key'
+     */
     keyName;
+    /**
+     * The type of the keys, written after the key name in square brackets, such as `string`.
+     */
     keyType;
+    /**
+     * The type of the values, written after the closing bracket, such as `number` in `: number;`.
+     */
     valueType;
+    /**
+     * Whether the signature is written with the `readonly` keyword in front of it.
+     * @default false
+     */
     readonly;
+    /**
+     * Initializes a new instance of the TsIndexer class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.keyName = options.keyName ?? 'key';
@@ -26,6 +54,19 @@ export class TsIndexer extends TsNode {
     }
 }
 const createIndexer = (keyType, valueType, options) => new TsIndexer({ ...options, keyType, valueType });
+/**
+ * Factory for creating index signature nodes. The `write` function writes one or more index signatures to a builder.
+ *
+ * @param keyType The type of the keys.
+ * @param valueType The type of the values.
+ * @param options The settings of the index signature. See `TsIndexer` for the available properties.
+ * @example
+ * ```ts
+ * tsIndexer('string', 'number', { keyName: 'id', readonly: true });
+ * // Emits:
+ * // readonly [id: string]: number;
+ * ```
+ */
 export const tsIndexer = Object.assign(createIndexer, {
     write: writeTsNodes,
 });

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

@@ -19,18 +19,75 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     members?: Nullable<Nullable<Member<TBuilder>>[]>;
 }>;
 type Member<TBuilder extends SourceBuilder> = TsIndexer<TBuilder> | TsProperty<TBuilder> | TsMethod<TBuilder> | BasicAppendValue<TBuilder>;
+/**
+ * Represents an interface declaration.
+ *
+ * Written in this order: the doc comment, the decorators, the `export` keyword, the name, the generics, the `extends`
+ * list, then the members in braces, followed by a line break.
+ *
+ * @template TBuilder The type of the source builder the interface is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsInterface
+ */
 export declare class TsInterface<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The doc comment written above the interface, or `null` to omit it. Descriptions of generic parameters are merged
+     * into it as `@template` tags.
+     */
     doc: TsDoc<TBuilder> | null;
+    /**
+     * The decorators written above the interface, each on its own line.
+     */
     decorators: TsDecorator<TBuilder>[];
+    /**
+     * Whether the interface is written with the `export` keyword.
+     * @default false
+     */
     export: boolean;
+    /**
+     * The name of the interface, written after the `interface` 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> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The interfaces written after `extends` as a comma-separated list. The clause is omitted when empty.
+     */
     extends: (TsReference<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The members written in the body, in the given order. Properties and bodyless methods without a doc comment or
+     * decorators are written without blank lines, other members are set off by blank lines.
+     */
     members: Member<TBuilder>[];
+    /**
+     * Initializes a new instance of the TsInterface class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createInterface: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsInterface<TBuilder>;
+/**
+ * Factory for creating interface nodes. The `write` function writes one or more interfaces to a builder.
+ *
+ * @param name The name of the interface.
+ * @param options The settings of the interface. See `TsInterface` for the available properties.
+ * @example
+ * ```ts
+ * tsInterface('User', {
+ *   export: true,
+ *   extends: [tsReference('Entity')],
+ *   members: [tsProperty('name', { type: 'string' }), tsMethod('save')],
+ * });
+ * // Emits:
+ * // export interface User extends Entity {
+ * //   name: string;
+ * //   save();
+ * // }
+ * ```
+ */
 export declare const tsInterface: typeof createInterface & {
     write: typeof writeTsNodes;
 };

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

@@ -5,14 +5,52 @@ import { writeTsNodes } from '../utils/write-ts-nodes.js';
 import { tsDecorator } from './decorator.js';
 import { tsDoc } from './doc.js';
 import { tsGenericParameter } from './generic-parameter.js';
+/**
+ * Represents an interface declaration.
+ *
+ * Written in this order: the doc comment, the decorators, the `export` keyword, the name, the generics, the `extends`
+ * list, then the members in braces, followed by a line break.
+ *
+ * @template TBuilder The type of the source builder the interface is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsInterface
+ */
 export class TsInterface extends TsNode {
+    /**
+     * The doc comment written above the interface, or `null` to omit it. Descriptions of generic parameters are merged
+     * into it as `@template` tags.
+     */
     doc;
+    /**
+     * The decorators written above the interface, each on its own line.
+     */
     decorators;
+    /**
+     * Whether the interface is written with the `export` keyword.
+     * @default false
+     */
     export;
+    /**
+     * The name of the interface, written after the `interface` keyword.
+     */
     name;
+    /**
+     * The type parameters written in angle brackets after the name, such as `<T, U>`. Nothing is written when empty.
+     */
     generics;
+    /**
+     * The interfaces written after `extends` as a comma-separated list. The clause is omitted when empty.
+     */
     extends;
+    /**
+     * The members written in the body, in the given order. Properties and bodyless methods without a doc comment or
+     * decorators are written without blank lines, other members are set off by blank lines.
+     */
     members;
+    /**
+     * Initializes a new instance of the TsInterface class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.doc = options.doc ?? null;
@@ -57,6 +95,25 @@ export class TsInterface extends TsNode {
     }
 }
 const createInterface = (name, options) => new TsInterface({ ...options, name });
+/**
+ * Factory for creating interface nodes. The `write` function writes one or more interfaces to a builder.
+ *
+ * @param name The name of the interface.
+ * @param options The settings of the interface. See `TsInterface` for the available properties.
+ * @example
+ * ```ts
+ * tsInterface('User', {
+ *   export: true,
+ *   extends: [tsReference('Entity')],
+ *   members: [tsProperty('name', { type: 'string' }), tsMethod('save')],
+ * });
+ * // Emits:
+ * // export interface User extends Entity {
+ * //   name: string;
+ * //   save();
+ * // }
+ * ```
+ */
 export const tsInterface = Object.assign(createInterface, {
     write: writeTsNodes,
 });

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

@@ -6,12 +6,44 @@ type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     types: Nullable<TsType<TBuilder>>[];
 }>;
+/**
+ * Represents an intersection type, which combines several types with `&`, such as `(string) & (number)`.
+ *
+ * Each type is wrapped in parentheses. Nested intersection types are flattened into the same list. An intersection
+ * without types is written as `unknown`, and one with a single type is written as that type without parentheses.
+ * Intersections of more than three types are written with one type per line, and each line starts with `&`.
+ *
+ * @template TBuilder The type of the source builder the intersection type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsIntersectionType
+ */
 export declare class TsIntersectionType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The types that are combined, in the given order. Null entries are skipped. Nested intersection types are
+     * flattened into this list when the node is written, so they add no nested parentheses.
+     */
     types: TsType<TBuilder>[];
+    /**
+     * Initializes a new instance of the TsIntersectionType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createIntersectionType: <TBuilder extends SourceBuilder>(types: Options<TBuilder>['types'], options?: Prettify<Omit<Options<TBuilder>, 'types'>>) => TsIntersectionType<TBuilder>;
+/**
+ * Factory for creating intersection type nodes. The `write` function writes one or more intersection type nodes to a
+ * builder.
+ *
+ * @param types The types to combine. See `TsIntersectionType.types` for how they are written.
+ * @param options The settings of the intersection type. See `TsIntersectionType` for the available properties.
+ * @example
+ * ```ts
+ * tsIntersectionType(['string', 'number']);
+ * // Emits:
+ * // (string) & (number)
+ * ```
+ */
 export declare const tsIntersectionType: typeof createIntersectionType & {
     write: typeof writeTsNodes;
 };

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

@@ -1,8 +1,27 @@
 import { notNullish } from '@goast/core';
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents an intersection type, which combines several types with `&`, such as `(string) & (number)`.
+ *
+ * Each type is wrapped in parentheses. Nested intersection types are flattened into the same list. An intersection
+ * without types is written as `unknown`, and one with a single type is written as that type without parentheses.
+ * Intersections of more than three types are written with one type per line, and each line starts with `&`.
+ *
+ * @template TBuilder The type of the source builder the intersection type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsIntersectionType
+ */
 export class TsIntersectionType extends TsNode {
+    /**
+     * The types that are combined, in the given order. Null entries are skipped. Nested intersection types are
+     * flattened into this list when the node is written, so they add no nested parentheses.
+     */
     types;
+    /**
+     * Initializes a new instance of the TsIntersectionType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.types = options.types.filter(notNullish);
@@ -24,6 +43,19 @@ export class TsIntersectionType extends TsNode {
     }
 }
 const createIntersectionType = (types, options) => new TsIntersectionType({ ...options, types });
+/**
+ * Factory for creating intersection type nodes. The `write` function writes one or more intersection type nodes to a
+ * builder.
+ *
+ * @param types The types to combine. See `TsIntersectionType.types` for how they are written.
+ * @param options The settings of the intersection type. See `TsIntersectionType` for the available properties.
+ * @example
+ * ```ts
+ * tsIntersectionType(['string', 'number']);
+ * // Emits:
+ * // (string) & (number)
+ * ```
+ */
 export const tsIntersectionType = Object.assign(createIntersectionType, {
     write: writeTsNodes,
 });

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

@@ -7,13 +7,47 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     type: TsType<TBuilder>;
     index: TsType<TBuilder>;
 }>;
+/**
+ * Represents an indexed access type, which looks up the type of one member of another type, such as `(Foo)['bar']`.
+ *
+ * Both parts are wrapped in parentheses. The `type` is written first, followed by the `index` in square brackets. The
+ * injection points `beforeType` and `afterType` wrap the type, and `beforeIndex` and `afterIndex` wrap the index.
+ *
+ * @template TBuilder The type of the source builder the indexed access type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsLookupType
+ */
 export declare class TsLookupType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The type whose member is looked up. It is written in parentheses before the index, such as `(Foo)`.
+     */
     type: TsType<TBuilder>;
+    /**
+     * The index type or key that selects the member. It is written in square brackets after the type, such as `['bar']`.
+     * A plain string is written as it is, so the quotes of a string literal have to be part of the string.
+     */
     index: TsType<TBuilder>;
+    /**
+     * Initializes a new instance of the TsLookupType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createLookupType: <TBuilder extends SourceBuilder>(type: Options<TBuilder>['type'], index: Options<TBuilder>['index'], options?: Omit<Options<TBuilder>, 'type' | 'index'>) => TsLookupType<TBuilder>;
+/**
+ * Factory for creating indexed access type nodes. The `write` function writes one or more of them to a builder.
+ *
+ * @param type The type whose member is looked up. See `TsLookupType.type`.
+ * @param index The index type or key. See `TsLookupType.index`.
+ * @param options The settings of the indexed access type. See `TsLookupType` for the available properties.
+ * @example
+ * ```ts
+ * tsLookupType('Foo', "'bar'");
+ * // Emits:
+ * // (Foo)['bar']
+ * ```
+ */
 export declare const tsLookupType: typeof createLookupType & {
     write: typeof writeTsNodes;
 };

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

@@ -1,8 +1,29 @@
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents an indexed access type, which looks up the type of one member of another type, such as `(Foo)['bar']`.
+ *
+ * Both parts are wrapped in parentheses. The `type` is written first, followed by the `index` in square brackets. The
+ * injection points `beforeType` and `afterType` wrap the type, and `beforeIndex` and `afterIndex` wrap the index.
+ *
+ * @template TBuilder The type of the source builder the indexed access type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsLookupType
+ */
 export class TsLookupType extends TsNode {
+    /**
+     * The type whose member is looked up. It is written in parentheses before the index, such as `(Foo)`.
+     */
     type;
+    /**
+     * The index type or key that selects the member. It is written in square brackets after the type, such as `['bar']`.
+     * A plain string is written as it is, so the quotes of a string literal have to be part of the string.
+     */
     index;
+    /**
+     * Initializes a new instance of the TsLookupType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.type = options.type;
@@ -23,6 +44,19 @@ export class TsLookupType extends TsNode {
     }
 }
 const createLookupType = (type, index, options) => new TsLookupType({ ...options, type, index });
+/**
+ * Factory for creating indexed access type nodes. The `write` function writes one or more of them to a builder.
+ *
+ * @param type The type whose member is looked up. See `TsLookupType.type`.
+ * @param index The index type or key. See `TsLookupType.index`.
+ * @param options The settings of the indexed access type. See `TsLookupType` for the available properties.
+ * @example
+ * ```ts
+ * tsLookupType('Foo', "'bar'");
+ * // Emits:
+ * // (Foo)['bar']
+ * ```
+ */
 export const tsLookupType = Object.assign(createLookupType, {
     write: writeTsNodes,
 });