@goast/typescript 0.8.0 → 0.9.0-beta.2

package/{esm → dist}/src/ast/nodes/decorator.js

@@ -3,23 +3,12 @@ import { TsNode } from '../node.js';
 import { writeTsNode } from '../utils/write-ts-nodes.js';
 import { tsArgument } from './argument.js';
 export class TsDecorator extends TsNode {
+    function;
+    arguments;
     constructor(options) {
-        var _a, _b;
         super(options);
-        Object.defineProperty(this, "function", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "arguments", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.function = options.function;
-        this.arguments = (_b = (_a = options.arguments) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : null;
+        this.arguments = options.arguments?.filter(notNullish) ?? null;
     }
     onWrite(builder) {
         builder.append('@');
@@ -38,7 +27,7 @@ const writeDecorators = (builder, nodes, options) => {
     const filteredNodes = toArray(nodes).filter(notNullish);
     builder.forEach(filteredNodes, (b, d) => {
         writeTsNode(b, d);
-        b.append((options === null || options === void 0 ? void 0 : options.multiline) ? '\n' : ' ');
+        b.append(options?.multiline ? '\n' : ' ');
     });
 };
 export const tsDecorator = Object.assign(createDecorator, {

package/{esm → dist}/src/ast/nodes/doc-tag.d.ts

@@ -1,7 +1,7 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type ParametersWithOverloads, type Prettify, type SourceBuilder, type StringSuggestions } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsType } from './types.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import type { TsType } from './types.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     tag: string;
@@ -71,4 +71,3 @@ export declare const tsDocTag: typeof createDocTag & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=doc-tag.d.ts.map

package/{esm → dist}/src/ast/nodes/doc-tag.js

@@ -3,30 +3,14 @@ import { isTypeScriptAppendValue } from '../../file-builder.js';
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
 export class TsDocTag extends TsNode {
+    tag;
+    type;
+    text;
     constructor(options) {
-        var _a, _b;
         super(options);
-        Object.defineProperty(this, "tag", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "text", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.tag = options.tag;
-        this.type = (_a = options.type) !== null && _a !== void 0 ? _a : null;
-        this.text = (_b = options.text) !== null && _b !== void 0 ? _b : null;
+        this.type = options.type ?? null;
+        this.text = options.text ?? null;
     }
     onWrite(builder) {
         builder.append('@', this.tag);
@@ -39,7 +23,6 @@ export class TsDocTag extends TsNode {
         }
     }
 }
-// deno-lint-ignore no-explicit-any
 function createDocTag(tag, ...args) {
     let opt = {};
     if (args.length > 0) {

package/{script → dist}/src/ast/nodes/doc.d.ts

@@ -1,9 +1,9 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import { type TsDocTag } from './doc-tag.js';
-import { TsGenericParameter } from './generic-parameter.js';
-import { TsParameter } from './parameter.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import { type TsDocTag } from './doc-tag.ts';
+import { TsGenericParameter } from './generic-parameter.ts';
+import { TsParameter } from './parameter.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     description?: Nullable<BasicAppendValue<TBuilder>>;
@@ -27,4 +27,3 @@ export declare const tsDoc: typeof createDoc & {
     isEmpty: typeof isDocEmpty;
 };
 export {};
-//# sourceMappingURL=doc.d.ts.map

package/{esm → dist}/src/ast/nodes/doc.js

@@ -5,23 +5,12 @@ import { tsDocTag } from './doc-tag.js';
 import { TsGenericParameter } from './generic-parameter.js';
 import { TsParameter } from './parameter.js';
 export class TsDoc extends TsNode {
+    description;
+    tags;
     constructor(options) {
-        var _a, _b, _c;
         super(options);
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "tags", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.description = (_a = options.description) !== null && _a !== void 0 ? _a : null;
-        this.tags = (_c = (_b = options.tags) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.description = options.description ?? null;
+        this.tags = options.tags?.filter(notNullish) ?? [];
     }
     onWrite(builder) {
         if (!this.description && this.tags.length === 0) {
@@ -41,11 +30,14 @@ export class TsDoc extends TsNode {
             .appendLine();
     }
 }
-const createDoc = (options) => new TsDoc(options !== null && options !== void 0 ? options : {});
+const createDoc = (options) => new TsDoc(options ?? {});
 function getDoc(baseDoc, options) {
-    var _a, _b, _c, _d;
-    const paramsWithDesc = (_b = (_a = options.parameters) === null || _a === void 0 ? void 0 : _a.filter(getIsInstanceOf((TsParameter))).filter((x) => !!x.description)) !== null && _b !== void 0 ? _b : [];
-    const genericsWithDesc = (_d = (_c = options.generics) === null || _c === void 0 ? void 0 : _c.filter(getIsInstanceOf((TsGenericParameter))).filter((x) => !!x.description)) !== null && _d !== void 0 ? _d : [];
+    const paramsWithDesc = options.parameters
+        ?.filter(getIsInstanceOf(TsParameter))
+        .filter((x) => !!x.description) ?? [];
+    const genericsWithDesc = options.generics
+        ?.filter(getIsInstanceOf(TsGenericParameter))
+        .filter((x) => !!x.description) ?? [];
     if (paramsWithDesc.length === 0 && genericsWithDesc.length === 0) {
         return baseDoc;
     }

package/{script → dist}/src/ast/nodes/enum-value.d.ts

@@ -1,7 +1,7 @@
 import type { AppendValue, AstNodeOptions, BasicAppendValue, Nullable, Prettify, SingleOrMultiple, SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import type { TsDoc } from './doc.js';
-import type { TsString } from './string.js';
+import { TsNode } from '../node.ts';
+import type { TsDoc } from './doc.ts';
+import type { TsString } from './string.ts';
 type Injects = 'doc' | 'name' | 'value';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     doc?: Nullable<TsDoc<TBuilder>>;
@@ -15,10 +15,9 @@ export declare class TsEnumValue<TBuilder extends SourceBuilder, TInjects extend
     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 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;
 export declare const tsEnumValue: typeof createEnumValue & {
     write: typeof writeEnumValues;
 };
 export {};
-//# sourceMappingURL=enum-value.d.ts.map

package/{esm → dist}/src/ast/nodes/enum-value.js

@@ -1,35 +1,18 @@
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
 export class TsEnumValue extends TsNode {
+    doc;
+    name;
+    value;
     constructor(options) {
-        var _a, _b;
         super(options);
-        Object.defineProperty(this, "doc", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.name = options.name;
-        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
-        this.value = (_b = options.value) !== null && _b !== void 0 ? _b : null;
+        this.doc = options.doc ?? null;
+        this.value = options.value ?? null;
     }
     onWrite(builder) {
-        var _a;
         builder.append(this.inject.beforeDoc);
-        (_a = this.doc) === null || _a === void 0 ? void 0 : _a.write(builder);
+        this.doc?.write(builder);
         builder.append(this.inject.afterDoc);
         builder.append(this.inject.beforeName, this.name, this.inject.afterName);
         if (this.value) {

package/{script → dist}/src/ast/nodes/enum.d.ts

@@ -1,8 +1,8 @@
 import { type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsDoc } from './doc.js';
-import { type TsEnumValue } from './enum-value.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import type { TsDoc } from './doc.ts';
+import { type TsEnumValue } from './enum-value.ts';
 type Injects = 'doc' | 'modifiers' | 'name' | 'body' | 'members';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     doc?: Nullable<TsDoc<TBuilder>>;
@@ -20,9 +20,8 @@ export declare class TsEnum<TBuilder extends SourceBuilder, TInjects extends str
     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>;
+declare const createEnum: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsEnum<TBuilder>;
 export declare const tsEnum: typeof createEnum & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=enum.d.ts.map

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

@@ -0,0 +1,45 @@
+import { notNullish } from '@goast/core';
+import { TsNode } from '../node.js';
+import { writeTsNodes } from '../utils/write-ts-nodes.js';
+import { tsEnumValue } from './enum-value.js';
+export class TsEnum extends TsNode {
+    doc;
+    export;
+    const;
+    name;
+    members;
+    constructor(options) {
+        super(options);
+        this.doc = options.doc ?? null;
+        this.export = options.export ?? false;
+        this.const = options.const ?? false;
+        this.name = options.name;
+        this.members = options.members?.filter(notNullish) ?? [];
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        this.doc?.write(builder);
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeModifiers);
+        if (this.export)
+            builder.append('export ');
+        if (this.const)
+            builder.append('const ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('enum ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        builder.append(' ');
+        builder.append(this.inject.beforeBody);
+        builder.parenthesize('{}', (b) => {
+            b.append(this.inject.beforeMembers);
+            tsEnumValue.write(b, this.members);
+            b.append(this.inject.afterMembers);
+        }, { multiline: this.members.length > 0 });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+}
+const createEnum = (name, options) => new TsEnum({ ...options, name });
+export const tsEnum = Object.assign(createEnum, {
+    write: writeTsNodes,
+});

package/{esm → dist}/src/ast/nodes/export.d.ts

@@ -1,7 +1,7 @@
 import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
-import type { TypeScriptExportType } from '../../common-results.js';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
+import type { TypeScriptExportType } from '../../common-results.ts';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     name: string;
@@ -15,9 +15,8 @@ export declare class TsExport<TBuilder extends SourceBuilder, TInjects extends s
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const createExport: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], filePath: Options<TBuilder>["filePath"], options?: Prettify<Omit<Options<TBuilder>, "name" | "filePath">>) => TsExport<TBuilder>;
+export declare const createExport: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], filePath: Options<TBuilder>['filePath'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'filePath'>>) => TsExport<TBuilder>;
 export declare const tsExport: typeof createExport & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=export.d.ts.map

package/{esm → dist}/src/ast/nodes/export.js

@@ -2,30 +2,14 @@ import { TypeScriptFileBuilder } from '../../file-builder.js';
 import { TsNode } from '../node.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
 export class TsExport extends TsNode {
+    name;
+    filePath;
+    kind;
     constructor(options) {
-        var _a;
         super(options);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "filePath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "kind", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.name = options.name;
         this.filePath = options.filePath;
-        this.kind = (_a = options.kind) !== null && _a !== void 0 ? _a : 'export';
+        this.kind = options.kind ?? 'export';
     }
     onWrite(builder) {
         if (builder instanceof TypeScriptFileBuilder) {

package/{script → dist}/src/ast/nodes/function-type.d.ts

@@ -1,9 +1,9 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import { type TsGenericParameter } from './generic-parameter.js';
-import { type TsParameter } from './parameter.js';
-import type { TsType } from './types.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import { type TsGenericParameter } from './generic-parameter.ts';
+import { type TsParameter } from './parameter.ts';
+import type { TsType } from './types.ts';
 type Injects = 'generics' | 'params' | 'returnType';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
@@ -22,4 +22,3 @@ export declare const tsFunctionType: typeof createFunctionType & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=function-type.d.ts.map

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

@@ -0,0 +1,32 @@
+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';
+import { tsParameter } from './parameter.js';
+export class TsFunctionType extends TsNode {
+    generics;
+    parameters;
+    returnType;
+    constructor(options) {
+        super(options);
+        this.generics = options.generics?.filter(notNullish) ?? [];
+        this.parameters = options.parameters?.filter(notNullish) ?? [];
+        this.returnType = options.returnType ?? null;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeGenerics);
+        tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        builder.append(this.inject.beforeParams);
+        tsParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        builder.append(' => ');
+        builder.append(this.inject.beforeReturnType);
+        writeTsNode(builder, this.returnType ?? 'void');
+        builder.append(this.inject.afterReturnType);
+    }
+}
+const createFunctionType = (options) => new TsFunctionType(options ?? {});
+export const tsFunctionType = Object.assign(createFunctionType, {
+    write: writeTsNodes,
+});

package/{esm → dist}/src/ast/nodes/function.d.ts

@@ -1,11 +1,11 @@
 import { type AppendValue, type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import { type TsDecorator } from './decorator.js';
-import { type TsDoc } from './doc.js';
-import { type TsGenericParameter } from './generic-parameter.js';
-import { type TsParameter } from './parameter.js';
-import type { TsType } from './types.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import { type TsDecorator } from './decorator.ts';
+import { type TsDoc } from './doc.ts';
+import { type TsGenericParameter } from './generic-parameter.ts';
+import { type TsParameter } from './parameter.ts';
+import type { TsType } from './types.ts';
 type Injects = 'doc' | 'decorators' | 'modifiers' | 'name' | 'generics' | 'params' | 'returnType' | 'body';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     doc?: Nullable<TsDoc<TBuilder>>;
@@ -29,9 +29,8 @@ export declare class TsFunction<TBuilder extends SourceBuilder, TInjects extends
     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>;
+declare const createFunction: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsFunction<TBuilder>;
 export declare const tsFunction: typeof createFunction & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=function.d.ts.map

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

@@ -0,0 +1,63 @@
+import { notNullish, } from '@goast/core';
+import { TsNode } from '../node.js';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+import { tsDecorator } from './decorator.js';
+import { tsDoc } from './doc.js';
+import { tsGenericParameter } from './generic-parameter.js';
+import { tsParameter } from './parameter.js';
+export class TsFunction extends TsNode {
+    doc;
+    decorators;
+    export;
+    name;
+    generics;
+    parameters;
+    returnType;
+    body;
+    constructor(options) {
+        super(options);
+        this.doc = options.doc ?? null;
+        this.decorators = options.decorators?.filter(notNullish) ?? [];
+        this.export = options.export ?? false;
+        this.name = options.name;
+        this.generics = options.generics?.filter(notNullish) ?? [];
+        this.parameters = options.parameters?.filter(notNullish) ?? [];
+        this.returnType = options.returnType ?? null;
+        this.body = options.body ?? null;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        tsDoc.write(builder, tsDoc.get(this.doc, { generics: this.generics }));
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeDecorators);
+        tsDecorator.write(builder, this.decorators, { multiline: true });
+        builder.append(this.inject.afterDecorators);
+        builder.append(this.inject.beforeModifiers);
+        if (this.export)
+            builder.append('export ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('function ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        builder.append(this.inject.beforeGenerics);
+        tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        builder.append(this.inject.beforeParams);
+        tsParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        if (this.returnType) {
+            builder.append(': ');
+            builder.append(this.inject.beforeReturnType);
+            writeTsNode(builder, this.returnType);
+            builder.append(this.inject.afterReturnType);
+        }
+        builder.append(' ');
+        builder.append(this.inject.beforeBody);
+        builder.parenthesize('{}', this.body, { multiline: !!this.body });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+}
+const createFunction = (name, options) => new TsFunction({ ...options, name });
+export const tsFunction = Object.assign(createFunction, {
+    write: writeTsNodes,
+});

package/{esm → dist}/src/ast/nodes/generic-parameter.d.ts

@@ -1,7 +1,7 @@
 import type { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters.js';
-import type { TsType } from './types.js';
+import { TsNode } from '../node.ts';
+import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters.ts';
+import type { TsType } from './types.ts';
 type Injects = 'modifiers' | 'name' | 'constraint' | 'default';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     description?: Nullable<BasicAppendValue<TBuilder>>;
@@ -19,9 +19,8 @@ export declare class TsGenericParameter<TBuilder extends SourceBuilder, TInjects
     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>;
+declare const createGenericParameter: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsGenericParameter<TBuilder>;
 export declare const tsGenericParameter: typeof createGenericParameter & {
     write: typeof writeTsGenericParameters;
 };
 export {};
-//# sourceMappingURL=generic-parameter.d.ts.map

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

@@ -0,0 +1,40 @@
+import { TsNode } from '../node.js';
+import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters.js';
+import { writeTsNode } from '../utils/write-ts-nodes.js';
+export class TsGenericParameter extends TsNode {
+    description;
+    const;
+    name;
+    constraint;
+    default;
+    constructor(options) {
+        super(options);
+        this.description = options.description ?? null;
+        this.const = options.const ?? false;
+        this.name = options.name;
+        this.constraint = options.constraint ?? null;
+        this.default = options.default ?? null;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeModifiers);
+        builder.appendIf(this.const, 'const ');
+        builder.append(this.inject.afterModifiers);
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.constraint !== null) {
+            builder.append(' extends ');
+            builder.append(this.inject.beforeConstraint);
+            writeTsNode(builder, this.constraint);
+            builder.append(this.inject.afterConstraint);
+        }
+        if (this.default !== null) {
+            builder.append(' = ');
+            builder.append(this.inject.beforeDefault);
+            writeTsNode(builder, this.default);
+            builder.append(this.inject.afterDefault);
+        }
+    }
+}
+const createGenericParameter = (name, options) => new TsGenericParameter({ ...options, name });
+export const tsGenericParameter = Object.assign(createGenericParameter, {
+    write: writeTsGenericParameters,
+});

package/{esm → dist}/src/ast/nodes/indexer.d.ts

@@ -1,7 +1,7 @@
 import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsType } from './types.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import type { TsType } from './types.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     keyName?: Nullable<string>;
@@ -17,9 +17,8 @@ export declare class TsIndexer<TBuilder extends SourceBuilder, TInjects extends
     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>;
+declare const createIndexer: <TBuilder extends SourceBuilder>(keyType: Options<TBuilder>['keyType'], valueType: Options<TBuilder>['valueType'], options?: Prettify<Omit<Options<TBuilder>, 'keyType' | 'valueType'>>) => TsIndexer<TBuilder>;
 export declare const tsIndexer: typeof createIndexer & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=indexer.d.ts.map

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

@@ -0,0 +1,31 @@
+import { TsNode } from '../node.js';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+export class TsIndexer extends TsNode {
+    keyName;
+    keyType;
+    valueType;
+    readonly;
+    constructor(options) {
+        super(options);
+        this.keyName = options.keyName ?? 'key';
+        this.keyType = options.keyType;
+        this.valueType = options.valueType;
+        this.readonly = options.readonly ?? false;
+    }
+    onWrite(builder) {
+        if (this.readonly)
+            builder.append('readonly ');
+        builder.parenthesize('[]', (b) => {
+            b.append(this.keyName, ': ');
+            writeTsNode(b, this.keyType);
+        });
+        builder.append(': ');
+        writeTsNode(builder, this.valueType);
+        builder.append(';');
+        builder.appendLine();
+    }
+}
+const createIndexer = (keyType, valueType, options) => new TsIndexer({ ...options, keyType, valueType });
+export const tsIndexer = Object.assign(createIndexer, {
+    write: writeTsNodes,
+});