@goast/kotlin 0.1.18 → 0.2.1

package/cjs/lib/import-collection.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportCollection = void 0;
+exports.ImportCollection = exports.defaultImportCollectionOptions = void 0;
 const core_1 = require("@goast/core");
+const config_1 = require("./config");
+exports.defaultImportCollectionOptions = {
+    globalImports: config_1.defaultKotlinGeneratorConfig.globalImports,
+};
 class ImportCollection {
-    constructor() {
+    constructor(options = {}) {
         this._imports = new Map();
+        this._options = Object.assign(Object.assign({}, exports.defaultImportCollectionOptions), options);
     }
     get hasImports() {
         return this._imports.size > 0;
@@ -46,25 +51,29 @@ class ImportCollection {
     }
     writeTo(builder) {
         if (this._imports.size > 0) {
-            const sortedImports = Array.from(this._imports.entries()).sort(([fromModuleA], [fromModuleB]) => {
-                if (isCoreImport(fromModuleA) && !isCoreImport(fromModuleB)) {
+            const globalPackages = this._options.globalImports
+                .filter((g) => g.endsWith('.*'))
+                .map((g) => g.substring(0, g.length - 2));
+            const globalImports = this._options.globalImports.filter((g) => !g.endsWith('.*'));
+            Array.from(this._imports.entries())
+                .filter(([packageName]) => !globalPackages.includes(packageName))
+                .flatMap(([packageName, importNames]) => Array.from(importNames).map((importName) => [packageName, importName]))
+                .map(([packageName, importName]) => `${packageName}.${importName}`)
+                .filter((importPath) => !globalImports.includes(importPath))
+                .sort((a, b) => {
+                if (isCoreImport(a) && !isCoreImport(b)) {
                     return 1;
                 }
-                else if (!isCoreImport(fromModuleA) && isCoreImport(fromModuleB)) {
+                else if (!isCoreImport(a) && isCoreImport(b)) {
                     return -1;
                 }
-                return fromModuleA.localeCompare(fromModuleB);
-            });
-            for (const [fromPackage, importNames] of sortedImports) {
-                const sortedImportNames = Array.from(importNames).sort();
-                for (const importName of sortedImportNames) {
-                    builder.appendLine(`import ${fromPackage}.${importName}`);
-                }
-            }
+                return a.localeCompare(b);
+            })
+                .forEach((importPath) => builder.appendLine(`import ${importPath}`));
         }
     }
 }
 exports.ImportCollection = ImportCollection;
-function isCoreImport(packageName) {
-    return packageName.startsWith('kotlin.') || packageName.startsWith('java.') || packageName.startsWith('javax.');
+function isCoreImport(importPath) {
+    return importPath.startsWith('kotlin.') || importPath.startsWith('java.') || importPath.startsWith('javax.');
 }

package/esm/index.js

@@ -4,3 +4,6 @@ export * from './lib/generators';
 export * from './lib/file-builder';
 export * from './lib/import-collection';
 export * from './lib/utils';
+export * from './lib/ast';
+import * as kt_1 from './lib/ast/references';
+export { kt_1 as kt };

package/esm/lib/ast/_index.js

@@ -0,0 +1,27 @@
+export { KtNode as Node } from './node';
+export { KtAnnotation as Annotation, ktAnnotation as annotation, } from './nodes/annotation';
+export { KtArgument as Argument, ktArgument as argument } from './nodes/argument';
+export { KtCall as Call, ktCall as call } from './nodes/call';
+export { KtClass as Class, ktClass as class, } from './nodes/class';
+export { KtCollectionLiteral as CollectionLiteral, ktCollectionLiteral as collectionLiteral, } from './nodes/collection-literal';
+export { KtConstructor as Constructor, ktConstructor as constructor, } from './nodes/constructor';
+export { KtDoc as Doc, ktDoc as doc } from './nodes/doc';
+export { KtDocTag as DocTag, ktDocTag as docTag } from './nodes/doc-tag';
+export { KtEnum as Enum, ktEnum as enum } from './nodes/enum';
+export { KtEnumValue as EnumValue, ktEnumValue as enumValue, } from './nodes/enum-value';
+export { KtFunction as Function, ktFunction as function } from './nodes/function';
+export { KtGenericParameter as GenericParameter, ktGenericParameter as genericParameter, } from './nodes/generic-parameter';
+export { KtInitBlock as InitBlock, ktInitBlock as initBlock } from './nodes/init-block';
+export { KtInterface as Interface, ktInterface as interface, } from './nodes/interface';
+export { KtLambda as Lambda, ktLambda as lambda } from './nodes/lambda';
+export { KtLambdaType as LambdaType, ktLambdaType as lambdaType } from './nodes/lambda-type';
+export { KtObject as Object, ktObject as object } from './nodes/object';
+export { KtParameter as Parameter, ktParameter as parameter } from './nodes/parameter';
+export { KtProperty as Property, KtPropertyAccessor as PropertyAccessor, KtPropertyGetter as PropertyGetter, KtPropertySetter as PropertySetter, ktProperty as property, } from './nodes/property';
+export { KtReference as Reference, ktReference as reference } from './nodes/reference';
+export { KtString as String, ktString as string } from './nodes/string';
+import * as refs_1 from './references';
+export { refs_1 as refs };
+export { getKotlinBuilderOptions as getBuilderOptions } from './utils/get-kotlin-builder-options';
+export { toKtNode as toNode } from './utils/to-kt-node';
+export { writeKtNode as writeNode, writeKtNodes as writeNodes } from './utils/write-kt-node';

package/esm/lib/ast/common.js

@@ -0,0 +1 @@
+export {};

package/esm/lib/ast/index.js

@@ -0,0 +1,2 @@
+import * as kt_1 from './_index';
+export { kt_1 as kt };

package/esm/lib/ast/node.js

@@ -0,0 +1,6 @@
+import { AstNode } from '@goast/core';
+export class KtNode extends AstNode {
+    constructor(options) {
+        super(options);
+    }
+}

package/esm/lib/ast/nodes/annotation.js

@@ -0,0 +1,35 @@
+import { notNullish } from '@goast/core';
+import { ktArgument } from './argument';
+import { KtNode } from '../node';
+import { writeKtAnnotations } from '../utils/write-kt-annotations';
+import { writeKtNode } from '../utils/write-kt-node';
+export class KtAnnotation extends KtNode {
+    constructor(options) {
+        var _a, _b, _c;
+        super(options);
+        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;
+    }
+    onWrite(builder) {
+        builder.append('@');
+        if (this.target) {
+            builder.append(this.inject.beforeTarget);
+            builder.append(this.target);
+            builder.append(this.inject.afterTarget);
+            builder.append(':');
+        }
+        builder.append(this.inject.beforeClass);
+        writeKtNode(builder, this.class);
+        builder.append(this.inject.afterClass);
+        if (this.arguments.length > 0) {
+            builder.append(this.inject.beforeArguments);
+            ktArgument.write(builder, this.arguments);
+            builder.append(this.inject.afterArguments);
+        }
+    }
+}
+const createAnnotation = ($class, $arguments, options) => new KtAnnotation(Object.assign(Object.assign({}, options), { class: $class, arguments: $arguments }));
+export const ktAnnotation = Object.assign(createAnnotation, {
+    write: writeKtAnnotations,
+});

package/esm/lib/ast/nodes/argument.js

@@ -0,0 +1,28 @@
+import { KtNode } from '../node';
+import { writeKtArguments } from '../utils/write-kt-arguments';
+import { writeKtNode } from '../utils/write-kt-node';
+export class KtArgument extends KtNode {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.name = (_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : null;
+        this.value = options.value;
+    }
+    onWrite(builder) {
+        if (this.name) {
+            builder.append(this.inject.beforeName);
+            builder.append(this.name);
+            builder.append(this.inject.afterName);
+            builder.append(' = ');
+        }
+        builder.append(this.inject.beforeValue);
+        writeKtNode(builder, this.value);
+        builder.append(this.inject.afterValue);
+    }
+}
+const createArgument = (value, options) => new KtArgument(Object.assign(Object.assign({}, options), { value }));
+const createNamedArgument = (name, value, options) => new KtArgument(Object.assign(Object.assign({}, options), { value, name }));
+export const ktArgument = Object.assign(createArgument, {
+    named: createNamedArgument,
+    write: writeKtArguments,
+});

package/esm/lib/ast/nodes/call.js

@@ -0,0 +1,33 @@
+import { notNullish } from '@goast/core';
+import { ktArgument } from './argument';
+import { KtNode } from '../node';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node';
+export class KtCall extends KtNode {
+    constructor(options) {
+        var _a, _b, _c;
+        super(options);
+        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;
+    }
+    onWrite(builder) {
+        var _a;
+        if (this.infix && ((_a = this.arguments) === null || _a === void 0 ? void 0 : _a.length) === 1 && this.path.length > 1) {
+            writeKtNodes(builder, this.path.slice(0, 1), { separator: '.' });
+            builder.append(' ');
+            writeKtNode(builder, this.path.at(-1));
+            builder.append(' ');
+            writeKtNode(builder, this.arguments[0]);
+        }
+        else {
+            writeKtNodes(builder, this.path, { separator: '.' });
+            if (this.arguments) {
+                ktArgument.write(builder, this.arguments);
+            }
+        }
+    }
+}
+const createCall = (path, args, options) => new KtCall(Object.assign(Object.assign({}, options), { path: Array.isArray(path) ? path : [path], arguments: args }));
+export const ktCall = Object.assign(createCall, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/class.js

@@ -0,0 +1,90 @@
+import { createOverwriteProxy, notNullish, } from '@goast/core';
+import { ktAnnotation } from './annotation';
+import { ktArgument } from './argument';
+import { ktDoc } from './doc';
+import { ktGenericParameter } from './generic-parameter';
+import { ktInitBlock } from './init-block';
+import { KtNode } from '../node';
+import { writeKtMembers } from '../utils/write-kt-members';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node';
+export class KtClass extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.annotations = (_c = (_b = options.annotations) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.accessModifier = (_d = options.accessModifier) !== null && _d !== void 0 ? _d : null;
+        this.open = (_e = options.open) !== null && _e !== void 0 ? _e : false;
+        this.abstract = (_f = options.abstract) !== null && _f !== void 0 ? _f : false;
+        this.classKind = (_g = options.classKind) !== null && _g !== void 0 ? _g : null;
+        this.name = options.name;
+        this.generics = (_j = (_h = options.generics) === null || _h === void 0 ? void 0 : _h.filter(notNullish)) !== null && _j !== void 0 ? _j : [];
+        this.primaryConstructor = (_k = options.primaryConstructor) !== null && _k !== void 0 ? _k : null;
+        this.extends = (_l = options.extends) !== null && _l !== void 0 ? _l : null;
+        this.implements = (_o = (_m = options.implements) === null || _m === void 0 ? void 0 : _m.filter(notNullish)) !== null && _o !== void 0 ? _o : [];
+        this.members = (_q = (_p = options.members) === null || _p === void 0 ? void 0 : _p.filter(notNullish)) !== null && _q !== void 0 ? _q : [];
+        this.companionObject = options.companionObject;
+    }
+    onWrite(builder) {
+        var _a, _b, _c, _d;
+        builder.append(this.inject.beforeDoc);
+        (_b = ktDoc.get(this.doc, { generics: this.generics, parameters: (_a = this.primaryConstructor) === null || _a === void 0 ? void 0 : _a.parameters })) === null || _b === void 0 ? void 0 : _b.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 && ((_c = this.primaryConstructor) === null || _c === void 0 ? void 0 : _c.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 || ((_d = this.primaryConstructor) === null || _d === void 0 ? void 0 : _d.body) || this.companionObject) {
+            builder.append(' ');
+            builder.append(this.inject.beforeBody);
+            builder.parenthesize('{}', (b) => {
+                var _a, _b;
+                b.append(this.inject.beforeMembers);
+                writeKtMembers(b, [
+                    this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
+                    ((_a = this.primaryConstructor) === null || _a === void 0 ? void 0 : _a.body) ? ktInitBlock((_b = this.primaryConstructor) === null || _b === void 0 ? void 0 : _b.body) : null,
+                    ...this.members,
+                ]);
+                b.append(this.inject.afterMembers);
+            }, { multiline: true });
+            builder.append(this.inject.afterBody);
+        }
+        builder.appendLine();
+    }
+}
+const createClass = (name, options) => new KtClass(Object.assign(Object.assign({}, options), { name }));
+export const ktClass = Object.assign(createClass, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/collection-literal.js

@@ -0,0 +1,20 @@
+import { notNullish } from '@goast/core';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtCollectionLiteral extends KtNode {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        this.elements = (_b = (_a = options.elements) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+    }
+    onWrite(builder) {
+        const multiline = this.elements.length > 2;
+        builder.parenthesize('[]', (b) => {
+            writeKtNodes(b, this.elements, { separator: multiline ? ',\n' : ', ' });
+        }, { multiline });
+    }
+}
+const createCollectionLiteral = (elements, options) => new KtCollectionLiteral(Object.assign(Object.assign({}, options), { elements }));
+export const ktCollectionLiteral = Object.assign(createCollectionLiteral, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/constructor.js

@@ -0,0 +1,71 @@
+import { notNullish, } from '@goast/core';
+import { ktAnnotation } from './annotation';
+import { ktArgument } from './argument';
+import { ktParameter } from './parameter';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtConstructor extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        super(options);
+        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 : [];
+    }
+    onWrite(builder) {
+        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, ' ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('constructor');
+        builder.append(this.inject.beforeParams);
+        ktParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        if (this.delegateTarget) {
+            builder.append(' : ');
+            builder.append(this.inject.beforeDelegate);
+            builder.append(this.delegateTarget);
+            ktArgument.write(builder, this.delegateArguments);
+            builder.append(this.inject.afterDelegate);
+        }
+        builder.append(' ');
+        builder.append(this.inject.beforeBody);
+        builder.parenthesize('{}', this.body, { multiline: !!this.body });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+    writeAsPrimary(builder) {
+        builder.append(this.inject.before);
+        this.onWriteAsPrimary(builder);
+        builder.append(this.inject.after);
+    }
+    onWriteAsPrimary(builder) {
+        const needsCtorKeyword = this.annotations.length > 0 || !!this.accessModifier;
+        if (needsCtorKeyword)
+            builder.append(' ');
+        builder.append(this.inject.beforeAnnotations);
+        ktAnnotation.write(builder, this.annotations);
+        builder.append(this.inject.afterAnnotations);
+        builder.append(this.inject.beforeModifiers);
+        if (this.accessModifier)
+            builder.append(this.accessModifier, ' ');
+        builder.append(this.inject.afterModifiers);
+        if (needsCtorKeyword)
+            builder.append('constructor');
+        if (needsCtorKeyword || this.parameters.length > 0) {
+            builder.append(this.inject.beforeParams);
+            ktParameter.write(builder, this.parameters);
+            builder.append(this.inject.afterParams);
+        }
+    }
+}
+const createConstructor = (parameters, body, options) => new KtConstructor(Object.assign(Object.assign({}, options), { parameters: parameters !== null && parameters !== void 0 ? parameters : undefined, body }));
+export const ktConstructor = Object.assign(createConstructor, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/doc-tag.js

@@ -0,0 +1,56 @@
+import { notNullish, basicAppendValueGroup, } from '@goast/core';
+import { isKotlinAppendValue } from '../../file-builder';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtDocTag extends KtNode {
+    constructor(options) {
+        var _a, _b, _c;
+        super(options);
+        this.tag = options.tag;
+        this.args = (_b = (_a = options.args) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.description = (_c = options.description) !== null && _c !== void 0 ? _c : null;
+    }
+    onWrite(builder) {
+        builder.append('@', this.tag);
+        this.args.forEach((a) => builder.append(' ', a));
+        if (this.description)
+            builder.append(' ', this.description);
+    }
+}
+const tagsWithDescription = [
+    'return',
+    'constructor',
+    'receiver',
+    'author',
+    'since',
+    'param',
+    'property',
+    'throws',
+    'exception',
+];
+function createDocTag(tag, ...args) {
+    let opt = {};
+    if (args.length > 0) {
+        const lastArg = args[args.length - 1];
+        if (!isKotlinAppendValue(lastArg) && !!lastArg) {
+            opt = args.pop();
+        }
+    }
+    const params = args;
+    if (tagsWithDescription.includes(tag)) {
+        const description = params.pop();
+        if (opt.description && description) {
+            opt.description = basicAppendValueGroup([description, opt.description], '\n');
+        }
+        else if (description) {
+            opt.description = description;
+        }
+    }
+    return new KtDocTag(Object.assign(Object.assign({}, opt), { tag, args: params }));
+}
+const writeDocTags = (builder, nodes) => {
+    writeKtNodes(builder, nodes, { separator: '\n' });
+};
+export const ktDocTag = Object.assign(createDocTag, {
+    write: writeDocTags,
+});

package/esm/lib/ast/nodes/doc.js

@@ -0,0 +1,51 @@
+import { createOverwriteProxy, notNullish, getIsInstanceOf, } from '@goast/core';
+import { ktDocTag } from './doc-tag';
+import { KtGenericParameter } from './generic-parameter';
+import { KtParameter } from './parameter';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtDoc extends KtNode {
+    constructor(options) {
+        var _a, _b, _c;
+        super(options);
+        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 : [];
+    }
+    onWrite(builder) {
+        if (!this.description && this.tags.length === 0)
+            return;
+        builder
+            .ensureCurrentLineEmpty()
+            .parenthesize(['/**', ' */'], (b) => b.appendWithLinePrefix(' * ', (b) => {
+            builder.append(this.description);
+            if (this.tags.length > 0) {
+                b.ensurePreviousLineEmpty();
+                ktDocTag.write(b, this.tags);
+            }
+        }), { multiline: true, indent: false })
+            .appendLine();
+    }
+}
+const createDoc = (description, tags, options) => new KtDoc(Object.assign(Object.assign({}, options), { description, tags: tags !== null && tags !== void 0 ? tags : undefined }));
+function getDoc(baseDoc, options) {
+    var _a, _b, _c, _d, _e, _f;
+    const paramsWithDesc = (_b = (_a = options.parameters) === null || _a === void 0 ? void 0 : _a.filter(getIsInstanceOf((KtParameter))).filter((x) => !!x.description)) !== null && _b !== void 0 ? _b : [];
+    const classParamsWithPropertyDesc = (_d = (_c = options.parameters) === null || _c === void 0 ? void 0 : _c.filter(getIsInstanceOf((KtParameter))).filter((x) => !!x.property && !!x.propertyDescription)) !== null && _d !== void 0 ? _d : [];
+    const genericsWithDesc = (_f = (_e = options.generics) === null || _e === void 0 ? void 0 : _e.filter(getIsInstanceOf((KtGenericParameter))).filter((x) => !!x.description)) !== null && _f !== void 0 ? _f : [];
+    if (baseDoc === null &&
+        paramsWithDesc.length === 0 &&
+        genericsWithDesc.length === 0 &&
+        classParamsWithPropertyDesc.length === 0) {
+        return null;
+    }
+    const doc = baseDoc ? createOverwriteProxy(baseDoc) : ktDoc();
+    const paramTags = paramsWithDesc.map((p) => ktDocTag('param', p.name, p.description));
+    const propertyTags = classParamsWithPropertyDesc.map((p) => ktDocTag('property', p.name, p.propertyDescription));
+    const genericTags = genericsWithDesc.map((p) => ktDocTag('param', p.name, p.description));
+    doc.tags.splice(0, 0, ...genericTags, ...paramTags, ...propertyTags);
+    return doc;
+}
+export const ktDoc = Object.assign(createDoc, {
+    write: writeKtNodes,
+    get: getDoc,
+});

package/esm/lib/ast/nodes/enum-value.js

@@ -0,0 +1,46 @@
+import { notNullish } from '@goast/core';
+import { ktAnnotation } from './annotation';
+import { ktArgument } from './argument';
+import { KtNode } from '../node';
+import { writeKtEnumValues } from '../utils/write-kt-enum-values';
+import { writeKtMembers } from '../utils/write-kt-members';
+export class KtEnumValue extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        super(options);
+        this.name = options.name;
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.annotations = (_c = (_b = options.annotations) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.arguments = (_e = (_d = options.arguments) === null || _d === void 0 ? void 0 : _d.filter(notNullish)) !== null && _e !== void 0 ? _e : [];
+        this.members = (_g = (_f = options.members) === null || _f === void 0 ? void 0 : _f.filter(notNullish)) !== null && _g !== void 0 ? _g : [];
+    }
+    onWrite(builder) {
+        var _a;
+        builder.append(this.inject.beforeDoc);
+        (_a = this.doc) === null || _a === void 0 ? void 0 : _a.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.beforeName, this.name, this.inject.afterName);
+        if (this.arguments.length > 0) {
+            builder.append(this.inject.beforeArguments);
+            ktArgument.write(builder, this.arguments);
+            builder.append(this.inject.afterArguments);
+        }
+        if (this.members.length > 0) {
+            builder.append(' ');
+            builder.append(this.inject.beforeBody);
+            builder.parenthesize('{}', (b) => {
+                builder.append(this.inject.beforeMembers);
+                writeKtMembers(b, this.members);
+                builder.append(this.inject.afterMembers);
+            }, { multiline: true });
+            builder.append(this.inject.afterBody);
+        }
+    }
+}
+const createEnumValue = (name, options) => new KtEnumValue(Object.assign(Object.assign({}, options), { name }));
+export const ktEnumValue = Object.assign(createEnumValue, {
+    write: writeKtEnumValues,
+});

package/esm/lib/ast/nodes/enum.js

@@ -0,0 +1,79 @@
+import { createOverwriteProxy, notNullish, } from '@goast/core';
+import { ktAnnotation } from './annotation';
+import { ktDoc } from './doc';
+import { ktEnumValue } from './enum-value';
+import { ktInitBlock } from './init-block';
+import { KtNode } from '../node';
+import { writeKtMembers } from '../utils/write-kt-members';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtEnum extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        super(options);
+        this.name = options.name;
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.annotations = (_c = (_b = options.annotations) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.accessModifier = (_d = options.accessModifier) !== null && _d !== void 0 ? _d : null;
+        this.primaryConstructor = (_e = options.primaryConstructor) !== null && _e !== void 0 ? _e : null;
+        this.implements = (_g = (_f = options.implements) === null || _f === void 0 ? void 0 : _f.filter(notNullish)) !== null && _g !== void 0 ? _g : [];
+        this.values = (_h = options.values) !== null && _h !== void 0 ? _h : [];
+        this.members = (_k = (_j = options.members) === null || _j === void 0 ? void 0 : _j.filter(notNullish)) !== null && _k !== void 0 ? _k : [];
+        this.companionObject = (_l = options.companionObject) !== null && _l !== void 0 ? _l : null;
+    }
+    onWrite(builder) {
+        var _a, _b, _c, _d;
+        builder.append(this.inject.beforeDoc);
+        (_b = ktDoc.get(this.doc, { parameters: (_a = this.primaryConstructor) === null || _a === void 0 ? void 0 : _a.parameters })) === null || _b === void 0 ? void 0 : _b.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, ' ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('enum class ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.primaryConstructor) {
+            builder.append(this.inject.beforePrimaryConstructor);
+            this.primaryConstructor.writeAsPrimary(builder);
+            builder.append(this.inject.afterPrimaryConstructor);
+        }
+        if (this.implements.length > 0) {
+            builder.append(' : ');
+            builder.append(this.inject.beforeImplements);
+            writeKtNodes(builder, this.implements, { separator: ', ' });
+            builder.append(this.inject.afterImplements);
+        }
+        const allMembers = [
+            this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
+            ((_c = this.primaryConstructor) === null || _c === void 0 ? void 0 : _c.body) ? ktInitBlock((_d = this.primaryConstructor) === null || _d === void 0 ? void 0 : _d.body) : null,
+            ...this.members,
+        ].filter(notNullish);
+        if (this.values.length > 0 || allMembers.length > 0) {
+            builder.append(' ');
+            builder.append(this.inject.beforeBody);
+            builder.parenthesize('{}', (b) => {
+                if (this.values.length > 0) {
+                    b.append(this.inject.beforeValues);
+                    ktEnumValue.write(b, this.values);
+                    if (allMembers.length > 0) {
+                        b.append(';\n\n');
+                    }
+                    b.append(this.inject.afterValues);
+                }
+                if (allMembers.length > 0) {
+                    b.append(this.inject.beforeMembers);
+                    writeKtMembers(b, allMembers);
+                    b.append(this.inject.afterMembers);
+                }
+            }, { multiline: true });
+            builder.append(this.inject.afterBody);
+        }
+        builder.appendLine();
+    }
+}
+const createEnum = (name, values, options) => new KtEnum(Object.assign(Object.assign({}, options), { name, values: values !== null && values !== void 0 ? values : undefined }));
+export const ktEnum = Object.assign(createEnum, {
+    write: writeKtNodes,
+});