@goast/typescript 0.0.5 → 0.2.0

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

@@ -0,0 +1,66 @@
+import { notNullish } from '@goast/core';
+import { tsDecorator } from './decorator';
+import { tsDoc } from './doc';
+import { tsGenericParameter } from './generic-parameter';
+import { TsNode } from '../node';
+import { writeTsMembers } from '../utils/write-ts-members';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsClass extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.decorators = (_c = (_b = options.decorators) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.export = (_d = options.export) !== null && _d !== void 0 ? _d : false;
+        this.abstract = (_e = options.abstract) !== null && _e !== void 0 ? _e : false;
+        this.name = options.name;
+        this.generics = (_g = (_f = options.generics) === null || _f === void 0 ? void 0 : _f.filter(notNullish)) !== null && _g !== void 0 ? _g : [];
+        this.extends = (_h = options.extends) !== null && _h !== void 0 ? _h : null;
+        this.implements = (_k = (_j = options.implements) === null || _j === void 0 ? void 0 : _j.filter(notNullish)) !== null && _k !== void 0 ? _k : [];
+        this.members = (_m = (_l = options.members) === null || _l === void 0 ? void 0 : _l.filter(notNullish)) !== null && _m !== void 0 ? _m : [];
+    }
+    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 ');
+        if (this.abstract)
+            builder.append('abstract ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('class ');
+        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);
+        if (this.extends) {
+            builder.append(' extends ');
+            builder.append(this.inject.beforeExtends);
+            writeTsNode(builder, this.extends);
+            builder.append(this.inject.afterExtends);
+        }
+        if (this.implements.length > 0) {
+            builder.append(' implements ');
+            builder.append(this.inject.beforeImplements);
+            writeTsNodes(builder, this.implements, { separator: ', ' });
+            builder.append(this.inject.afterImplements);
+        }
+        builder.append(' ');
+        builder.append(this.inject.beforeBody);
+        builder.parenthesize('{}', (b) => {
+            b.append(this.inject.beforeMembers);
+            writeTsMembers(b, this.members);
+            b.append(this.inject.afterMembers);
+        }, { multiline: this.members.length > 0 });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+}
+const createClass = (name, options) => new TsClass(Object.assign(Object.assign({}, options), { name }));
+export const tsClass = Object.assign(createClass, {
+    write: writeTsNodes,
+});

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

@@ -0,0 +1,42 @@
+import { tsDecorator } from './decorator';
+import { TsParameter } from './parameter';
+import { writeTsNode } from '../utils/write-ts-nodes';
+import { writeTsParameters } from '../utils/write-ts-parameters';
+export class TsConstructorParameter extends TsParameter {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        this.accessModifier = (_a = options.accessModifier) !== null && _a !== void 0 ? _a : null;
+        this.readonly = (_b = options.readonly) !== null && _b !== void 0 ? _b : false;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDecorators);
+        tsDecorator.write(builder, this.decorators);
+        builder.append(this.inject.afterDecorators);
+        builder.append(this.inject.beforeModifiers);
+        if (this.accessModifier)
+            builder.append(this.accessModifier, ' ');
+        if (this.readonly)
+            builder.append('readonly ');
+        builder.append(this.inject.afterModifiers);
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.optional)
+            builder.append('?');
+        if (this.type) {
+            builder.append(': ');
+            builder.append(this.inject.beforeType);
+            writeTsNode(builder, this.type);
+            builder.append(this.inject.afterType);
+        }
+        if (this.default) {
+            builder.append(' = ');
+            builder.append(this.inject.beforeDefault);
+            writeTsNode(builder, this.default);
+            builder.append(this.inject.afterDefault);
+        }
+    }
+}
+const createConstructorParameter = (name, options) => new TsConstructorParameter(Object.assign(Object.assign({}, options), { name }));
+export const tsConstructorParameter = Object.assign(createConstructorParameter, {
+    write: writeTsParameters,
+});

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

@@ -0,0 +1,38 @@
+import { notNullish } from '@goast/core';
+import { tsDecorator } from './decorator';
+import { tsDoc } from './doc';
+import { tsParameter } from './parameter';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+export class TsConstructor extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.decorators = (_c = (_b = options.decorators) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.parameters = (_e = (_d = options.parameters) === null || _d === void 0 ? void 0 : _d.filter(notNullish)) !== null && _e !== void 0 ? _e : [];
+        this.body = (_f = options.body) !== null && _f !== void 0 ? _f : null;
+    }
+    onWrite(builder) {
+        var _a;
+        builder.append(this.inject.beforeDoc);
+        (_a = tsDoc.get(this.doc, { parameters: this.parameters })) === null || _a === void 0 ? void 0 : _a.write(builder);
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeDecorators);
+        tsDecorator.write(builder, this.decorators, { multiline: true });
+        builder.append(this.inject.afterDecorators);
+        builder.append('constructor');
+        builder.append(this.inject.beforeParams);
+        tsParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        builder.append(' ');
+        builder.append(this.inject.beforeBody);
+        builder.parenthesize('{}', this.body, { multiline: !!this.body });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+}
+const createConstructor = (options) => new TsConstructor(options !== null && options !== void 0 ? options : {});
+export const tsConstructor = Object.assign(createConstructor, {
+    write: writeTsNodes,
+});

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

@@ -0,0 +1,34 @@
+import { notNullish, toArray, } from '@goast/core';
+import { tsArgument } from './argument';
+import { TsNode } from '../node';
+import { writeTsNode } from '../utils/write-ts-nodes';
+export class TsDecorator extends TsNode {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        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;
+    }
+    onWrite(builder) {
+        builder.append('@');
+        builder.append(this.inject.beforeFunction);
+        writeTsNode(builder, this.function);
+        builder.append(this.inject.afterFunction);
+        if (this.arguments) {
+            builder.append(this.inject.beforeArguments);
+            tsArgument.write(builder, this.arguments);
+            builder.append(this.inject.afterArguments);
+        }
+    }
+}
+const createDecorator = (fn, args, options) => new TsDecorator(Object.assign(Object.assign({}, options), { function: fn, arguments: args }));
+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' : ' ');
+    });
+};
+export const tsDecorator = Object.assign(createDecorator, {
+    write: writeDecorators,
+});

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

@@ -0,0 +1,60 @@
+import { basicAppendValueGroup, notNullish, } from '@goast/core';
+import { isTypeScriptAppendValue } from '../../file-builder';
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsDocTag extends TsNode {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        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;
+    }
+    onWrite(builder) {
+        builder.append('@', this.tag);
+        if (this.type) {
+            builder.append(' ');
+            builder.parenthesize('{}', (b) => writeTsNode(b, this.type));
+        }
+        if (this.text) {
+            builder.append(' ', this.text);
+        }
+    }
+}
+function createDocTag(tag, ...args) {
+    let opt = {};
+    if (args.length > 0) {
+        const lastArg = args[args.length - 1];
+        if (!isTypeScriptAppendValue(lastArg) && !!lastArg) {
+            opt = args.pop();
+        }
+    }
+    let params = args;
+    if (tag === 'author' && params.length === 2) {
+        params[1] = `<${params[1]}>`;
+    }
+    if (tag === 'borrows') {
+        params.splice(1, 0, 'as');
+    }
+    if (tag === 'example') {
+        if (typeof params[0] === 'string') {
+            params[0] = `<caption>${params[0]}</caption>`;
+        }
+        if (params[1] && isTypeScriptAppendValue(params[1])) {
+            params.splice(1, 0, '\n');
+        }
+    }
+    if ((tag === 'event' || tag === 'fires') && typeof params[0] === 'string' && typeof params[1] === 'string') {
+        params.splice(0, 2, `${params[0]}#${params[1]}`);
+    }
+    params = [...params, opt.text].filter(notNullish);
+    return new TsDocTag({
+        tag,
+        type: opt.type,
+        text: params.length > 0 ? basicAppendValueGroup(params, ' ') : null,
+        inject: opt.inject,
+    });
+}
+export const tsDocTag = Object.assign(createDocTag, {
+    write: writeTsNodes,
+});

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

@@ -0,0 +1,53 @@
+import { createOverwriteProxy, getIsInstanceOf, notNullish, } from '@goast/core';
+import { tsDocTag } from './doc-tag';
+import { TsGenericParameter } from './generic-parameter';
+import { TsParameter } from './parameter';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+export class TsDoc extends TsNode {
+    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) => {
+            if (this.description) {
+                b.append(this.description);
+            }
+            if (this.tags.length > 0) {
+                b.ensurePreviousLineEmpty();
+                tsDocTag.write(b, this.tags, { separator: '\n' });
+            }
+        }), { multiline: true, indent: false })
+            .appendLine();
+    }
+}
+const createDoc = (options) => new TsDoc(options !== null && options !== void 0 ? 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 : [];
+    if (paramsWithDesc.length === 0 && genericsWithDesc.length === 0) {
+        return baseDoc;
+    }
+    const doc = baseDoc ? createOverwriteProxy(baseDoc) : createDoc();
+    const paramTags = paramsWithDesc.map((p) => tsDocTag('param', p.name, p.description));
+    const genericTags = genericsWithDesc.map((p) => tsDocTag('template', p.name, p.description));
+    doc.tags.splice(0, 0, ...genericTags, ...paramTags);
+    return doc;
+}
+function isDocEmpty(doc) {
+    return !doc || (!doc.description && doc.tags.length === 0);
+}
+export const tsDoc = Object.assign(createDoc, {
+    write: writeTsNodes,
+    get: getDoc,
+    isEmpty: isDocEmpty,
+});

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

@@ -0,0 +1,31 @@
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsEnumValue extends TsNode {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        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;
+    }
+    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.beforeName, this.name, this.inject.afterName);
+        if (this.value) {
+            builder.append(' = ');
+            builder.append(this.inject.beforeValue);
+            writeTsNode(builder, this.value);
+            builder.append(this.inject.afterValue);
+        }
+    }
+}
+const createEnumValue = (name, options) => new TsEnumValue(Object.assign(Object.assign({}, options), { name }));
+const writeEnumValues = (builder, nodes) => {
+    writeTsNodes(builder, nodes, { separator: ',\n' });
+};
+export const tsEnumValue = Object.assign(createEnumValue, {
+    write: writeEnumValues,
+});

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

@@ -0,0 +1,42 @@
+import { notNullish } from '@goast/core';
+import { tsEnumValue } from './enum-value';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+export class TsEnum extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.export = (_b = options.export) !== null && _b !== void 0 ? _b : false;
+        this.const = (_c = options.const) !== null && _c !== void 0 ? _c : false;
+        this.name = options.name;
+        this.members = (_e = (_d = options.members) === null || _d === void 0 ? void 0 : _d.filter(notNullish)) !== null && _e !== void 0 ? _e : [];
+    }
+    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.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(Object.assign(Object.assign({}, options), { name }));
+export const tsEnum = Object.assign(createEnum, {
+    write: writeTsNodes,
+});

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

@@ -0,0 +1,22 @@
+import { TypeScriptFileBuilder } from '../../file-builder';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+export class TsExport extends TsNode {
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.filePath = options.filePath;
+    }
+    onWrite(builder) {
+        if (builder instanceof TypeScriptFileBuilder) {
+            builder.addExport(this.name, this.filePath);
+        }
+        else {
+            builder.appendLine(`export { ${this.name} } from '${this.filePath}';`);
+        }
+    }
+}
+export const createExport = (name, filePath, options) => new TsExport(Object.assign(Object.assign({}, options), { name, filePath }));
+export const tsExport = Object.assign(createExport, {
+    write: writeTsNodes,
+});

package/esm/lib/ast/nodes/function-type.js

@@ -0,0 +1,31 @@
+import { notNullish } from '@goast/core';
+import { tsGenericParameter } from './generic-parameter';
+import { tsParameter } from './parameter';
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsFunctionType extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
+        super(options);
+        this.generics = (_b = (_a = options.generics) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.parameters = (_d = (_c = options.parameters) === null || _c === void 0 ? void 0 : _c.filter(notNullish)) !== null && _d !== void 0 ? _d : [];
+        this.returnType = (_e = options.returnType) !== null && _e !== void 0 ? _e : null;
+    }
+    onWrite(builder) {
+        var _a;
+        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, (_a = this.returnType) !== null && _a !== void 0 ? _a : 'void');
+        builder.append(this.inject.afterReturnType);
+    }
+}
+const createFunctionType = (options) => new TsFunctionType(options !== null && options !== void 0 ? options : {});
+export const tsFunctionType = Object.assign(createFunctionType, {
+    write: writeTsNodes,
+});

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

@@ -0,0 +1,56 @@
+import { notNullish } from '@goast/core';
+import { tsDecorator } from './decorator';
+import { tsDoc } from './doc';
+import { tsGenericParameter } from './generic-parameter';
+import { tsParameter } from './parameter';
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsFunction extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.decorators = (_c = (_b = options.decorators) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.export = (_d = options.export) !== null && _d !== void 0 ? _d : false;
+        this.name = options.name;
+        this.generics = (_f = (_e = options.generics) === null || _e === void 0 ? void 0 : _e.filter(notNullish)) !== null && _f !== void 0 ? _f : [];
+        this.parameters = (_h = (_g = options.parameters) === null || _g === void 0 ? void 0 : _g.filter(notNullish)) !== null && _h !== void 0 ? _h : [];
+        this.returnType = (_j = options.returnType) !== null && _j !== void 0 ? _j : null;
+        this.body = (_k = options.body) !== null && _k !== void 0 ? _k : 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(Object.assign(Object.assign({}, options), { name }));
+export const tsFunction = Object.assign(createFunction, {
+    write: writeTsNodes,
+});

package/esm/lib/ast/nodes/generic-parameter.js

@@ -0,0 +1,36 @@
+import { TsNode } from '../node';
+import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters';
+import { writeTsNode } from '../utils/write-ts-nodes';
+export class TsGenericParameter extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        super(options);
+        this.description = (_a = options.description) !== null && _a !== void 0 ? _a : null;
+        this.const = (_b = options.const) !== null && _b !== void 0 ? _b : false;
+        this.name = options.name;
+        this.constraint = (_c = options.constraint) !== null && _c !== void 0 ? _c : null;
+        this.default = (_d = options.default) !== null && _d !== void 0 ? _d : 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(Object.assign(Object.assign({}, options), { name }));
+export const tsGenericParameter = Object.assign(createGenericParameter, {
+    write: writeTsGenericParameters,
+});

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

@@ -0,0 +1,28 @@
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsIndexer extends TsNode {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        this.keyName = (_a = options.keyName) !== null && _a !== void 0 ? _a : 'key';
+        this.keyType = options.keyType;
+        this.valueType = options.valueType;
+        this.readonly = (_b = options.readonly) !== null && _b !== void 0 ? _b : 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(Object.assign(Object.assign({}, options), { keyType, valueType }));
+export const tsIndexer = Object.assign(createIndexer, {
+    write: writeTsNodes,
+});

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

@@ -0,0 +1,56 @@
+import { notNullish } from '@goast/core';
+import { tsDecorator } from './decorator';
+import { tsDoc } from './doc';
+import { tsGenericParameter } from './generic-parameter';
+import { TsNode } from '../node';
+import { writeTsMembers } from '../utils/write-ts-members';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+export class TsInterface extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.decorators = (_c = (_b = options.decorators) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.export = (_d = options.export) !== null && _d !== void 0 ? _d : false;
+        this.name = options.name;
+        this.generics = (_f = (_e = options.generics) === null || _e === void 0 ? void 0 : _e.filter(notNullish)) !== null && _f !== void 0 ? _f : [];
+        this.extends = (_h = (_g = options.extends) === null || _g === void 0 ? void 0 : _g.filter(notNullish)) !== 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 : [];
+    }
+    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('interface ');
+        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);
+        if (this.extends.length > 0) {
+            builder.append(' extends ');
+            builder.append(this.inject.beforeExtends);
+            writeTsNodes(builder, this.extends, { separator: ', ' });
+            builder.append(this.inject.afterExtends);
+        }
+        builder.append(' ');
+        builder.append(this.inject.beforeBody);
+        builder.parenthesize('{}', (b) => {
+            b.append(this.inject.beforeMembers);
+            writeTsMembers(b, this.members);
+            b.append(this.inject.afterMembers);
+        }, { multiline: this.members.length > 0 });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+}
+const createInterface = (name, options) => new TsInterface(Object.assign(Object.assign({}, options), { name }));
+export const tsInterface = Object.assign(createInterface, {
+    write: writeTsNodes,
+});

package/esm/lib/ast/nodes/intersection-type.js

@@ -0,0 +1,40 @@
+import { notNullish } from '@goast/core';
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsIntersectionType extends TsNode {
+    constructor(options) {
+        super(options);
+        this.types = options.types.filter(notNullish);
+    }
+    onWrite(builder) {
+        const types = this.types.length === 0 ? ['unknown'] : resolveNestedIntersectionTypes(this);
+        if (types.length === 1) {
+            writeTsNode(builder, types[0]);
+        }
+        else {
+            const multiline = types.length > 3;
+            if (multiline) {
+                builder.appendLine().append('& ');
+            }
+            builder.forEach(types, (b, t) => b.parenthesize('()', (b) => writeTsNode(b, t)), {
+                separator: multiline ? '\n& ' : ' & ',
+            });
+        }
+    }
+}
+const createIntersectionType = (types, options) => new TsIntersectionType(Object.assign(Object.assign({}, options), { types }));
+export const tsIntersectionType = Object.assign(createIntersectionType, {
+    write: writeTsNodes,
+});
+function resolveNestedIntersectionTypes(node) {
+    const types = [];
+    for (const type of node.types) {
+        if (type instanceof TsIntersectionType) {
+            types.push(...resolveNestedIntersectionTypes(type));
+        }
+        else {
+            types.push(type);
+        }
+    }
+    return types;
+}