@goast/kotlin 0.6.0 → 0.7.0-beta.1

package/README.md

@@ -1,7 +1,6 @@
 # gOAst (@goast/kotlin)
 
 [![@goast/kotlin NPM Version](https://img.shields.io/npm/v/%40goast%2Fkotlin?logo=npm&label=%40goast%2Fkotlin)](https://www.npmjs.com/package/@goast/kotlin)
-[![@goast/kotlin JSR Version](https://img.shields.io/jsr/v/%40goast%2Fkotlin?logo=jsr&label=%40goast%2Fkotlin)](https://jsr.io/@goast/kotlin)
 
 **gOAst** stands for **g**enerative **O**pen **A**PI **s**pecification **t**ransformer, a tool designed to transform
 OpenAPI specifications into various forms with flexibility and extensibility at its core.

package/dist/mod.d.ts

@@ -0,0 +1,8 @@
+export * from './src/ast/index.ts';
+export * from './src/common-results.ts';
+export * from './src/config.ts';
+export * from './src/file-builder.ts';
+export * from './src/generators/index.ts';
+export * from './src/import-collection.ts';
+export * from './src/types.ts';
+export * from './src/utils.ts';

package/{esm → dist}/src/assets.d.ts

@@ -1,3 +1,2 @@
 export declare const getAssetFileContent: (relativePath: string) => Promise<string>;
 export declare const copyAssetFile: (relativePath: string, destDir: string, logName?: string) => Promise<void>;
-//# sourceMappingURL=assets.d.ts.map

package/dist/src/assets.js

@@ -0,0 +1,5 @@
+import { AssetManager } from '@goast/core';
+import { URL } from 'node:url';
+const manager = new AssetManager(new URL('../assets/', import.meta.url));
+export const getAssetFileContent = manager.getAssetFileContent.bind(manager);
+export const copyAssetFile = manager.copyAssetFile.bind(manager);

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

@@ -1,29 +1,28 @@
-export { type KtAccessModifier as AccessModifier } from './common.js';
-export { KtNode as Node } from './node.js';
-export { KtAnnotation as Annotation, ktAnnotation as annotation, type KtAnnotationTarget as AnnotationTarget, } from './nodes/annotation.js';
-export { KtArgument as Argument, ktArgument as argument } from './nodes/argument.js';
-export { KtCall as Call, ktCall as call } from './nodes/call.js';
-export { KtClass as Class, ktClass as class, type KtClassKind as ClassKind, type KtClassMember as ClassMember, } from './nodes/class.js';
-export { KtCollectionLiteral as CollectionLiteral, ktCollectionLiteral as collectionLiteral, } from './nodes/collection-literal.js';
-export { KtConstructor as Constructor, ktConstructor as constructor, type KtDelegateTarget as DelegateTarget, } from './nodes/constructor.js';
-export { KtDocTag as DocTag, ktDocTag as docTag } from './nodes/doc-tag.js';
-export { KtDoc as Doc, ktDoc as doc } from './nodes/doc.js';
-export { KtEnumValue as EnumValue, ktEnumValue as enumValue, type KtEnumValueMember as EnumValueMember, } from './nodes/enum-value.js';
-export { KtEnum as Enum, ktEnum as enum, type KtEnumMember as EnumMember } from './nodes/enum.js';
-export { KtFunction as Function, ktFunction as function } from './nodes/function.js';
-export { KtGenericParameter as GenericParameter, ktGenericParameter as genericParameter, } from './nodes/generic-parameter.js';
-export { KtInitBlock as InitBlock, ktInitBlock as initBlock } from './nodes/init-block.js';
-export { KtInterface as Interface, ktInterface as interface, type KtInterfaceMember as InterfaceMember, } from './nodes/interface.js';
-export { KtLambdaType as LambdaType, ktLambdaType as lambdaType } from './nodes/lambda-type.js';
-export { KtLambda as Lambda, ktLambda as lambda } from './nodes/lambda.js';
-export { KtObject as Object, ktObject as object, type KtObjectMember as ObjectMember } from './nodes/object.js';
-export { KtParameter as Parameter, ktParameter as parameter } from './nodes/parameter.js';
-export { KtProperty as Property, ktProperty as property, KtPropertyAccessor as PropertyAccessor, KtPropertyGetter as PropertyGetter, KtPropertySetter as PropertySetter, } from './nodes/property.js';
-export { type KtGenericReferenceFactory as GenericReferenceFactory, KtReference as Reference, ktReference as reference, type KtReferenceFactory as ReferenceFactory, } from './nodes/reference.js';
-export { KtString as String, ktString as string } from './nodes/string.js';
-export { type KtType as Type, type KtValue as Value } from './nodes/types.js';
-export * as refs from './references/index.js';
-export { getKotlinBuilderOptions as getBuilderOptions } from './utils/get-kotlin-builder-options.js';
-export { toKtNode as toNode } from './utils/to-kt-node.js';
-export { writeKtNode as writeNode, writeKtNodes as writeNodes } from './utils/write-kt-node.js';
-//# sourceMappingURL=_index.d.ts.map
+export { type KtAccessModifier as AccessModifier } from './common.ts';
+export { KtNode as Node } from './node.ts';
+export { KtAnnotation as Annotation, ktAnnotation as annotation, type KtAnnotationTarget as AnnotationTarget, } from './nodes/annotation.ts';
+export { KtArgument as Argument, ktArgument as argument } from './nodes/argument.ts';
+export { KtCall as Call, ktCall as call } from './nodes/call.ts';
+export { KtClass as Class, ktClass as class, type KtClassKind as ClassKind, type KtClassMember as ClassMember, } from './nodes/class.ts';
+export { KtCollectionLiteral as CollectionLiteral, ktCollectionLiteral as collectionLiteral, } from './nodes/collection-literal.ts';
+export { KtConstructor as Constructor, ktConstructor as constructor, type KtDelegateTarget as DelegateTarget, } from './nodes/constructor.ts';
+export { KtDocTag as DocTag, ktDocTag as docTag } from './nodes/doc-tag.ts';
+export { KtDoc as Doc, ktDoc as doc } from './nodes/doc.ts';
+export { KtEnumValue as EnumValue, ktEnumValue as enumValue, type KtEnumValueMember as EnumValueMember, } from './nodes/enum-value.ts';
+export { KtEnum as Enum, ktEnum as enum, type KtEnumMember as EnumMember } from './nodes/enum.ts';
+export { KtFunction as Function, ktFunction as function } from './nodes/function.ts';
+export { KtGenericParameter as GenericParameter, ktGenericParameter as genericParameter, } from './nodes/generic-parameter.ts';
+export { KtInitBlock as InitBlock, ktInitBlock as initBlock } from './nodes/init-block.ts';
+export { KtInterface as Interface, ktInterface as interface, type KtInterfaceMember as InterfaceMember, } from './nodes/interface.ts';
+export { KtLambdaType as LambdaType, ktLambdaType as lambdaType } from './nodes/lambda-type.ts';
+export { KtLambda as Lambda, ktLambda as lambda } from './nodes/lambda.ts';
+export { KtObject as Object, ktObject as object, type KtObjectMember as ObjectMember } from './nodes/object.ts';
+export { KtParameter as Parameter, ktParameter as parameter } from './nodes/parameter.ts';
+export { KtProperty as Property, ktProperty as property, KtPropertyAccessor as PropertyAccessor, KtPropertyGetter as PropertyGetter, KtPropertySetter as PropertySetter, } from './nodes/property.ts';
+export { type KtGenericReferenceFactory as GenericReferenceFactory, KtReference as Reference, ktReference as reference, type KtReferenceFactory as ReferenceFactory, } from './nodes/reference.ts';
+export { KtString as String, ktString as string } from './nodes/string.ts';
+export { type KtType as Type, type KtValue as Value } from './nodes/types.ts';
+export * as refs from './references/index.ts';
+export { getKotlinBuilderOptions as getBuilderOptions } from './utils/get-kotlin-builder-options.ts';
+export { toKtNode as toNode } from './utils/to-kt-node.ts';
+export { writeKtNode as writeNode, writeKtNodes as writeNodes } from './utils/write-kt-node.ts';

package/{esm → dist}/src/ast/_index.js

@@ -1,3 +1,4 @@
+export {} from './common.js';
 export { KtNode as Node } from './node.js';
 export { KtAnnotation as Annotation, ktAnnotation as annotation, } from './nodes/annotation.js';
 export { KtArgument as Argument, ktArgument as argument } from './nodes/argument.js';
@@ -20,6 +21,7 @@ export { KtParameter as Parameter, ktParameter as parameter } from './nodes/para
 export { KtProperty as Property, ktProperty as property, KtPropertyAccessor as PropertyAccessor, KtPropertyGetter as PropertyGetter, KtPropertySetter as PropertySetter, } from './nodes/property.js';
 export { KtReference as Reference, ktReference as reference, } from './nodes/reference.js';
 export { KtString as String, ktString as string } from './nodes/string.js';
+export {} from './nodes/types.js';
 export * as refs from './references/index.js';
 export { getKotlinBuilderOptions as getBuilderOptions } from './utils/get-kotlin-builder-options.js';
 export { toKtNode as toNode } from './utils/to-kt-node.js';

package/dist/src/ast/index.d.ts

@@ -0,0 +1 @@
+export * as kt from './_index.ts';

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

@@ -2,4 +2,3 @@ import { AstNode, type AstNodeOptions, type SourceBuilder } from '@goast/core';
 export declare abstract class KtNode<TBuilder extends SourceBuilder, TInjects extends string = never> extends AstNode<TBuilder, TInjects> {
     constructor(options: AstNodeOptions<typeof AstNode<TBuilder, TInjects>>);
 }
-//# sourceMappingURL=node.d.ts.map

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

@@ -1,8 +1,8 @@
 import { type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtAnnotations } from '../utils/write-kt-annotations.js';
-import { type KtArgument } from './argument.js';
-import type { KtType, KtValue } from './types.js';
+import { KtNode } from '../node.ts';
+import { writeKtAnnotations } from '../utils/write-kt-annotations.ts';
+import { type KtArgument } from './argument.ts';
+import type { KtType, KtValue } from './types.ts';
 type Injects = 'class' | 'target' | 'arguments';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     class: KtType<TBuilder>;
@@ -17,9 +17,8 @@ export declare class KtAnnotation<TBuilder extends SourceBuilder, TInjects exten
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createAnnotation: <TBuilder extends SourceBuilder>($class: Options<TBuilder>["class"], $arguments?: Options<TBuilder>["arguments"], options?: Prettify<Omit<Options<TBuilder>, "class" | "arguments">>) => KtAnnotation<TBuilder>;
+declare const createAnnotation: <TBuilder extends SourceBuilder>($class: Options<TBuilder>['class'], $arguments?: Options<TBuilder>['arguments'], options?: Prettify<Omit<Options<TBuilder>, 'class' | 'arguments'>>) => KtAnnotation<TBuilder>;
 export declare const ktAnnotation: typeof createAnnotation & {
     write: typeof writeKtAnnotations;
 };
 export {};
-//# sourceMappingURL=annotation.d.ts.map

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

@@ -4,30 +4,14 @@ import { writeKtAnnotations } from '../utils/write-kt-annotations.js';
 import { writeKtNode } from '../utils/write-kt-node.js';
 import { ktArgument } from './argument.js';
 export class KtAnnotation extends KtNode {
+    class;
+    arguments;
+    target;
     constructor(options) {
-        var _a, _b, _c;
         super(options);
-        Object.defineProperty(this, "class", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "arguments", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "target", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.class = options.class;
-        this.arguments = (_b = (_a = options.arguments) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
-        this.target = (_c = options.target) !== null && _c !== void 0 ? _c : null;
+        this.arguments = options.arguments?.filter(notNullish) ?? [];
+        this.target = options.target ?? null;
     }
     onWrite(builder) {
         builder.append('@');

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

@@ -1,7 +1,7 @@
 import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtArguments } from '../utils/write-kt-arguments.js';
-import type { KtValue } from './types.js';
+import { KtNode } from '../node.ts';
+import { writeKtArguments } from '../utils/write-kt-arguments.ts';
+import type { KtValue } from './types.ts';
 type Injects = 'name' | 'value';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     name?: Nullable<string>;
@@ -13,11 +13,10 @@ export declare class KtArgument<TBuilder extends SourceBuilder, TInjects extends
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createArgument: <TBuilder extends SourceBuilder>(value: Options<TBuilder>["value"], options?: Prettify<Omit<Options<TBuilder>, "value">>) => KtArgument<TBuilder>;
-declare const createNamedArgument: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], value: Options<TBuilder>["value"], options?: Prettify<Omit<Options<TBuilder>, "value" | "name">>) => KtArgument<TBuilder>;
+declare const createArgument: <TBuilder extends SourceBuilder>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => KtArgument<TBuilder>;
+declare const createNamedArgument: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value' | 'name'>>) => KtArgument<TBuilder>;
 export declare const ktArgument: typeof createArgument & {
     named: typeof createNamedArgument;
     write: typeof writeKtArguments;
 };
 export {};
-//# sourceMappingURL=argument.d.ts.map

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

@@ -2,22 +2,11 @@ import { KtNode } from '../node.js';
 import { writeKtArguments } from '../utils/write-kt-arguments.js';
 import { writeKtNode } from '../utils/write-kt-node.js';
 export class KtArgument extends KtNode {
+    name;
+    value;
     constructor(options) {
-        var _a;
         super(options);
-        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 = (_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : null;
+        this.name = options?.name ?? null;
         this.value = options.value;
     }
     onWrite(builder) {

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

@@ -1,8 +1,8 @@
 import { type ArrayItem, type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtArgument } from './argument.js';
-import type { KtType, KtValue } from './types.js';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import { type KtArgument } from './argument.ts';
+import type { KtType, KtValue } from './types.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     path: Nullable<KtType<TBuilder> | KtValue<TBuilder>>[];
@@ -16,9 +16,8 @@ export declare class KtCall<TBuilder extends SourceBuilder, TInjects extends str
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createCall: <TBuilder extends SourceBuilder>(path: Options<TBuilder>["path"] | ArrayItem<Options<TBuilder>["path"]>, args?: Options<TBuilder>["arguments"], options?: Prettify<Omit<Options<TBuilder>, "path" | "arguments">>) => KtCall<TBuilder>;
+declare const createCall: <TBuilder extends SourceBuilder>(path: Options<TBuilder>['path'] | ArrayItem<Options<TBuilder>['path']>, args?: Options<TBuilder>['arguments'], options?: Prettify<Omit<Options<TBuilder>, 'path' | 'arguments'>>) => KtCall<TBuilder>;
 export declare const ktCall: typeof createCall & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=call.d.ts.map

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

@@ -3,34 +3,17 @@ import { KtNode } from '../node.js';
 import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
 import { ktArgument } from './argument.js';
 export class KtCall extends KtNode {
+    path;
+    arguments;
+    infix;
     constructor(options) {
-        var _a, _b, _c;
         super(options);
-        Object.defineProperty(this, "path", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "arguments", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "infix", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.path = options.path.filter(notNullish);
-        this.arguments = (_b = (_a = options.arguments) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : null;
-        this.infix = (_c = options.infix) !== null && _c !== void 0 ? _c : false;
+        this.arguments = options.arguments?.filter(notNullish) ?? null;
+        this.infix = options.infix ?? false;
     }
     onWrite(builder) {
-        var _a;
-        if (this.infix && ((_a = this.arguments) === null || _a === void 0 ? void 0 : _a.length) === 1 && this.path.length > 1) {
+        if (this.infix && this.arguments?.length === 1 && this.path.length > 1) {
             writeKtNodes(builder, this.path.slice(0, 1), { separator: '.' });
             builder.append(' ');
             writeKtNode(builder, this.path.at(-1));

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

@@ -1,18 +1,18 @@
 import { type AppendValue, type AstNodeOptions, type BasicAppendValue, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation } from './annotation.js';
-import type { KtConstructor } from './constructor.js';
-import { type KtDoc } from './doc.js';
-import type { KtEnum } from './enum.js';
-import type { KtFunction } from './function.js';
-import { type KtGenericParameter } from './generic-parameter.js';
-import { type KtInitBlock } from './init-block.js';
-import type { KtInterface } from './interface.js';
-import type { KtObject } from './object.js';
-import type { KtProperty } from './property.js';
-import type { KtType } from './types.js';
+import type { KtAccessModifier } from '../common.ts';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import { type KtAnnotation } from './annotation.ts';
+import type { KtConstructor } from './constructor.ts';
+import { type KtDoc } from './doc.ts';
+import type { KtEnum } from './enum.ts';
+import type { KtFunction } from './function.ts';
+import { type KtGenericParameter } from './generic-parameter.ts';
+import { type KtInitBlock } from './init-block.ts';
+import type { KtInterface } from './interface.ts';
+import type { KtObject } from './object.ts';
+import type { KtProperty } from './property.ts';
+import type { KtType } from './types.ts';
 type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'generics' | 'primaryConstructor' | 'inheritList' | 'body' | 'members';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     doc?: Nullable<KtDoc<TBuilder>>;
@@ -48,9 +48,8 @@ export declare class KtClass<TBuilder extends SourceBuilder, TInjects extends st
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createClass: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => KtClass<TBuilder>;
+declare const createClass: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtClass<TBuilder>;
 export declare const ktClass: typeof createClass & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=class.d.ts.map

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

@@ -0,0 +1,100 @@
+import { createOverwriteProxy, notNullish, } from '@goast/core';
+import { KtNode } from '../node.js';
+import { writeKtMembers } from '../utils/write-kt-members.js';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
+import { ktAnnotation } from './annotation.js';
+import { ktArgument } from './argument.js';
+import { ktDoc } from './doc.js';
+import { ktGenericParameter } from './generic-parameter.js';
+import { ktInitBlock } from './init-block.js';
+export class KtClass extends KtNode {
+    doc;
+    annotations;
+    accessModifier;
+    open;
+    abstract;
+    classKind;
+    name;
+    generics;
+    primaryConstructor;
+    extends;
+    implements;
+    members;
+    companionObject;
+    constructor(options) {
+        super(options);
+        this.doc = options.doc ?? null;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.accessModifier = options.accessModifier ?? null;
+        this.open = options.open ?? false;
+        this.abstract = options.abstract ?? false;
+        this.classKind = options.classKind ?? null;
+        this.name = options.name;
+        this.generics = options.generics?.filter(notNullish) ?? [];
+        this.primaryConstructor = options.primaryConstructor ?? null;
+        this.extends = options.extends ?? null;
+        this.implements = options.implements?.filter(notNullish) ?? [];
+        this.members = options.members?.filter(notNullish) ?? [];
+        this.companionObject = options.companionObject;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        ktDoc.get(this.doc, { generics: this.generics, parameters: this.primaryConstructor?.parameters })?.write(builder);
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeAnnotations);
+        ktAnnotation.write(builder, this.annotations, { multiline: true });
+        builder.append(this.inject.afterAnnotations);
+        builder.append(this.inject.beforeModifiers);
+        if (this.accessModifier)
+            builder.append(this.accessModifier, ' ');
+        if (this.open)
+            builder.append('open ');
+        if (this.abstract)
+            builder.append('abstract ');
+        if (this.classKind)
+            builder.append(this.classKind, ' ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('class ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        builder.append(this.inject.beforeGenerics);
+        ktGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        if (this.primaryConstructor) {
+            builder.append(this.inject.beforePrimaryConstructor);
+            this.primaryConstructor.writeAsPrimary(builder);
+            builder.append(this.inject.afterPrimaryConstructor);
+        }
+        if (this.extends || this.implements.length > 0) {
+            builder.append(' : ');
+            builder.append(this.inject.beforeInheritList);
+            writeKtNode(builder, this.extends);
+            if (this.extends && this.primaryConstructor?.delegateTarget === 'super') {
+                ktArgument.write(builder, this.primaryConstructor.delegateArguments);
+            }
+            if (this.extends && this.implements.length > 0) {
+                builder.append(', ');
+            }
+            writeKtNodes(builder, this.implements, { separator: ', ' });
+            builder.append(this.inject.afterInheritList);
+        }
+        if (this.members.length > 0 || this.primaryConstructor?.body || this.companionObject) {
+            builder.append(' ');
+            builder.append(this.inject.beforeBody);
+            builder.parenthesize('{}', (b) => {
+                b.append(this.inject.beforeMembers);
+                writeKtMembers(b, [
+                    this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
+                    this.primaryConstructor?.body ? ktInitBlock(this.primaryConstructor?.body) : null,
+                    ...this.members,
+                ]);
+                b.append(this.inject.afterMembers);
+            }, { multiline: true });
+            builder.append(this.inject.afterBody);
+        }
+        builder.appendLine();
+    }
+}
+const createClass = (name, options) => new KtClass({ ...options, name });
+export const ktClass = Object.assign(createClass, {
+    write: writeKtNodes,
+});

package/{esm → dist}/src/ast/nodes/collection-literal.d.ts

@@ -1,7 +1,7 @@
 import { type AstNodeOptions, type Nullable, type SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import type { KtValue } from './types.js';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import type { KtValue } from './types.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     elements: Nullable<Nullable<KtValue<TBuilder>>[]>;
@@ -11,9 +11,8 @@ export declare class KtCollectionLiteral<TBuilder extends SourceBuilder, TInject
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createCollectionLiteral: <TBuilder extends SourceBuilder>(elements: Options<TBuilder>["elements"], options?: Omit<Options<TBuilder>, "elements">) => KtCollectionLiteral<TBuilder>;
+declare const createCollectionLiteral: <TBuilder extends SourceBuilder>(elements: Options<TBuilder>['elements'], options?: Omit<Options<TBuilder>, 'elements'>) => KtCollectionLiteral<TBuilder>;
 export declare const ktCollectionLiteral: typeof createCollectionLiteral & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=collection-literal.d.ts.map

package/{esm → dist}/src/ast/nodes/collection-literal.js

@@ -2,16 +2,10 @@ import { notNullish } from '@goast/core';
 import { KtNode } from '../node.js';
 import { writeKtNodes } from '../utils/write-kt-node.js';
 export class KtCollectionLiteral extends KtNode {
+    elements;
     constructor(options) {
-        var _a, _b;
         super(options);
-        Object.defineProperty(this, "elements", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.elements = (_b = (_a = options.elements) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.elements = options.elements?.filter(notNullish) ?? [];
     }
     onWrite(builder) {
         const multiline = this.elements.length > 2;

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

@@ -1,11 +1,11 @@
 import { type AppendValue, type AstNodeOptions, type BasicAppendValue, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation } from './annotation.js';
-import { type KtArgument } from './argument.js';
-import { type KtParameter } from './parameter.js';
-import type { KtValue } from './types.js';
+import type { KtAccessModifier } from '../common.ts';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import { type KtAnnotation } from './annotation.ts';
+import { type KtArgument } from './argument.ts';
+import { type KtParameter } from './parameter.ts';
+import type { KtValue } from './types.ts';
 type Injects = 'annotations' | 'modifiers' | 'params' | 'body' | 'delegate';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     accessModifier?: Nullable<KtAccessModifier>;
@@ -28,9 +28,8 @@ export declare class KtConstructor<TBuilder extends SourceBuilder, TInjects exte
     writeAsPrimary(builder: TBuilder): void;
     protected onWriteAsPrimary(builder: TBuilder): void;
 }
-declare const createConstructor: <TBuilder extends SourceBuilder>(parameters?: Options<TBuilder>["parameters"], body?: Options<TBuilder>["body"], options?: Prettify<Omit<Options<TBuilder>, "parameters" | "body">>) => KtConstructor<TBuilder>;
+declare const createConstructor: <TBuilder extends SourceBuilder>(parameters?: Options<TBuilder>['parameters'], body?: Options<TBuilder>['body'], options?: Prettify<Omit<Options<TBuilder>, 'parameters' | 'body'>>) => KtConstructor<TBuilder>;
 export declare const ktConstructor: typeof createConstructor & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=constructor.d.ts.map

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

@@ -5,51 +5,20 @@ import { ktAnnotation } from './annotation.js';
 import { ktArgument } from './argument.js';
 import { ktParameter } from './parameter.js';
 export class KtConstructor extends KtNode {
+    accessModifier;
+    annotations;
+    parameters;
+    body;
+    delegateTarget;
+    delegateArguments;
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         super(options);
-        Object.defineProperty(this, "accessModifier", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "annotations", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "parameters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "body", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "delegateTarget", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "delegateArguments", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.parameters = (_b = (_a = options.parameters) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
-        this.body = (_c = options.body) !== null && _c !== void 0 ? _c : null;
-        this.accessModifier = (_d = options.accessModifier) !== null && _d !== void 0 ? _d : null;
-        this.annotations = (_f = (_e = options.annotations) === null || _e === void 0 ? void 0 : _e.filter(notNullish)) !== null && _f !== void 0 ? _f : [];
-        this.delegateTarget = (_g = options.delegateTarget) !== null && _g !== void 0 ? _g : null;
-        this.delegateArguments = (_j = (_h = options.delegateArguments) === null || _h === void 0 ? void 0 : _h.filter(notNullish)) !== null && _j !== void 0 ? _j : [];
+        this.parameters = options.parameters?.filter(notNullish) ?? [];
+        this.body = options.body ?? null;
+        this.accessModifier = options.accessModifier ?? null;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.delegateTarget = options.delegateTarget ?? null;
+        this.delegateArguments = options.delegateArguments?.filter(notNullish) ?? [];
     }
     onWrite(builder) {
         builder.append(this.inject.beforeAnnotations);
@@ -101,7 +70,7 @@ export class KtConstructor extends KtNode {
         }
     }
 }
-const createConstructor = (parameters, body, options) => new KtConstructor({ ...options, parameters: parameters !== null && parameters !== void 0 ? parameters : undefined, body });
+const createConstructor = (parameters, body, options) => new KtConstructor({ ...options, parameters: parameters ?? undefined, body });
 export const ktConstructor = Object.assign(createConstructor, {
     write: writeKtNodes,
 });

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

@@ -1,6 +1,6 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type ParametersWithOverloads, type Prettify, type SingleOrMultiple, type SourceBuilder, type StringSuggestions } from '@goast/core';
-import { KtNode } from '../node.js';
-import { type KtAppendValue } from '../utils/write-kt-node.js';
+import { KtNode } from '../node.ts';
+import { type KtAppendValue } from '../utils/write-kt-node.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     tag: string;
@@ -33,4 +33,3 @@ export declare const ktDocTag: typeof createDocTag & {
     write: typeof writeDocTags;
 };
 export {};
-//# sourceMappingURL=doc-tag.d.ts.map