@goast/typescript 0.0.4 → 0.2.0

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsConstructor = exports.TsConstructor = void 0;
+const core_1 = require("@goast/core");
+const decorator_1 = require("./decorator");
+const doc_1 = require("./doc");
+const parameter_1 = require("./parameter");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsConstructor extends node_1.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(core_1.notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.parameters = (_e = (_d = options.parameters) === null || _d === void 0 ? void 0 : _d.filter(core_1.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 = doc_1.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);
+        decorator_1.tsDecorator.write(builder, this.decorators, { multiline: true });
+        builder.append(this.inject.afterDecorators);
+        builder.append('constructor');
+        builder.append(this.inject.beforeParams);
+        parameter_1.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();
+    }
+}
+exports.TsConstructor = TsConstructor;
+const createConstructor = (options) => new TsConstructor(options !== null && options !== void 0 ? options : {});
+exports.tsConstructor = Object.assign(createConstructor, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsDecorator = exports.TsDecorator = void 0;
+const core_1 = require("@goast/core");
+const argument_1 = require("./argument");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsDecorator extends node_1.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(core_1.notNullish)) !== null && _b !== void 0 ? _b : null;
+    }
+    onWrite(builder) {
+        builder.append('@');
+        builder.append(this.inject.beforeFunction);
+        (0, write_ts_nodes_1.writeTsNode)(builder, this.function);
+        builder.append(this.inject.afterFunction);
+        if (this.arguments) {
+            builder.append(this.inject.beforeArguments);
+            argument_1.tsArgument.write(builder, this.arguments);
+            builder.append(this.inject.afterArguments);
+        }
+    }
+}
+exports.TsDecorator = TsDecorator;
+const createDecorator = (fn, args, options) => new TsDecorator(Object.assign(Object.assign({}, options), { function: fn, arguments: args }));
+const writeDecorators = (builder, nodes, options) => {
+    const filteredNodes = (0, core_1.toArray)(nodes).filter(core_1.notNullish);
+    builder.forEach(filteredNodes, (b, d) => {
+        (0, write_ts_nodes_1.writeTsNode)(b, d);
+        b.append((options === null || options === void 0 ? void 0 : options.multiline) ? '\n' : ' ');
+    });
+};
+exports.tsDecorator = Object.assign(createDecorator, {
+    write: writeDecorators,
+});

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsDocTag = exports.TsDocTag = void 0;
+const core_1 = require("@goast/core");
+const file_builder_1 = require("../../file-builder");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsDocTag extends node_1.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) => (0, write_ts_nodes_1.writeTsNode)(b, this.type));
+        }
+        if (this.text) {
+            builder.append(' ', this.text);
+        }
+    }
+}
+exports.TsDocTag = TsDocTag;
+function createDocTag(tag, ...args) {
+    let opt = {};
+    if (args.length > 0) {
+        const lastArg = args[args.length - 1];
+        if (!(0, file_builder_1.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] && (0, file_builder_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(core_1.notNullish);
+    return new TsDocTag({
+        tag,
+        type: opt.type,
+        text: params.length > 0 ? (0, core_1.basicAppendValueGroup)(params, ' ') : null,
+        inject: opt.inject,
+    });
+}
+exports.tsDocTag = Object.assign(createDocTag, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsDoc = exports.TsDoc = void 0;
+const core_1 = require("@goast/core");
+const doc_tag_1 = require("./doc-tag");
+const generic_parameter_1 = require("./generic-parameter");
+const parameter_1 = require("./parameter");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsDoc extends node_1.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(core_1.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();
+                doc_tag_1.tsDocTag.write(b, this.tags, { separator: '\n' });
+            }
+        }), { multiline: true, indent: false })
+            .appendLine();
+    }
+}
+exports.TsDoc = TsDoc;
+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((0, core_1.getIsInstanceOf)((parameter_1.TsParameter))).filter((x) => !!x.description)) !== null && _b !== void 0 ? _b : [];
+    const genericsWithDesc = (_d = (_c = options.generics) === null || _c === void 0 ? void 0 : _c.filter((0, core_1.getIsInstanceOf)((generic_parameter_1.TsGenericParameter))).filter((x) => !!x.description)) !== null && _d !== void 0 ? _d : [];
+    if (paramsWithDesc.length === 0 && genericsWithDesc.length === 0) {
+        return baseDoc;
+    }
+    const doc = baseDoc ? (0, core_1.createOverwriteProxy)(baseDoc) : createDoc();
+    const paramTags = paramsWithDesc.map((p) => (0, doc_tag_1.tsDocTag)('param', p.name, p.description));
+    const genericTags = genericsWithDesc.map((p) => (0, doc_tag_1.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);
+}
+exports.tsDoc = Object.assign(createDoc, {
+    write: write_ts_nodes_1.writeTsNodes,
+    get: getDoc,
+    isEmpty: isDocEmpty,
+});

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsEnumValue = exports.TsEnumValue = void 0;
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsEnumValue extends node_1.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);
+            (0, write_ts_nodes_1.writeTsNode)(builder, this.value);
+            builder.append(this.inject.afterValue);
+        }
+    }
+}
+exports.TsEnumValue = TsEnumValue;
+const createEnumValue = (name, options) => new TsEnumValue(Object.assign(Object.assign({}, options), { name }));
+const writeEnumValues = (builder, nodes) => {
+    (0, write_ts_nodes_1.writeTsNodes)(builder, nodes, { separator: ',\n' });
+};
+exports.tsEnumValue = Object.assign(createEnumValue, {
+    write: writeEnumValues,
+});

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsEnum = exports.TsEnum = void 0;
+const core_1 = require("@goast/core");
+const enum_value_1 = require("./enum-value");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsEnum extends node_1.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(core_1.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);
+            enum_value_1.tsEnumValue.write(b, this.members);
+            b.append(this.inject.afterMembers);
+        }, { multiline: this.members.length > 0 });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+}
+exports.TsEnum = TsEnum;
+const createEnum = (name, options) => new TsEnum(Object.assign(Object.assign({}, options), { name }));
+exports.tsEnum = Object.assign(createEnum, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsExport = exports.createExport = exports.TsExport = void 0;
+const file_builder_1 = require("../../file-builder");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsExport extends node_1.TsNode {
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.filePath = options.filePath;
+    }
+    onWrite(builder) {
+        if (builder instanceof file_builder_1.TypeScriptFileBuilder) {
+            builder.addExport(this.name, this.filePath);
+        }
+        else {
+            builder.appendLine(`export { ${this.name} } from '${this.filePath}';`);
+        }
+    }
+}
+exports.TsExport = TsExport;
+const createExport = (name, filePath, options) => new TsExport(Object.assign(Object.assign({}, options), { name, filePath }));
+exports.createExport = createExport;
+exports.tsExport = Object.assign(exports.createExport, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsFunctionType = exports.TsFunctionType = void 0;
+const core_1 = require("@goast/core");
+const generic_parameter_1 = require("./generic-parameter");
+const parameter_1 = require("./parameter");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsFunctionType extends node_1.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(core_1.notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.parameters = (_d = (_c = options.parameters) === null || _c === void 0 ? void 0 : _c.filter(core_1.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);
+        generic_parameter_1.tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        builder.append(this.inject.beforeParams);
+        parameter_1.tsParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        builder.append(' => ');
+        builder.append(this.inject.beforeReturnType);
+        (0, write_ts_nodes_1.writeTsNode)(builder, (_a = this.returnType) !== null && _a !== void 0 ? _a : 'void');
+        builder.append(this.inject.afterReturnType);
+    }
+}
+exports.TsFunctionType = TsFunctionType;
+const createFunctionType = (options) => new TsFunctionType(options !== null && options !== void 0 ? options : {});
+exports.tsFunctionType = Object.assign(createFunctionType, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsFunction = exports.TsFunction = void 0;
+const core_1 = require("@goast/core");
+const decorator_1 = require("./decorator");
+const doc_1 = require("./doc");
+const generic_parameter_1 = require("./generic-parameter");
+const parameter_1 = require("./parameter");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsFunction extends node_1.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(core_1.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(core_1.notNullish)) !== null && _f !== void 0 ? _f : [];
+        this.parameters = (_h = (_g = options.parameters) === null || _g === void 0 ? void 0 : _g.filter(core_1.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);
+        doc_1.tsDoc.write(builder, doc_1.tsDoc.get(this.doc, { generics: this.generics }));
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeDecorators);
+        decorator_1.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);
+        generic_parameter_1.tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        builder.append(this.inject.beforeParams);
+        parameter_1.tsParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        if (this.returnType) {
+            builder.append(': ');
+            builder.append(this.inject.beforeReturnType);
+            (0, write_ts_nodes_1.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();
+    }
+}
+exports.TsFunction = TsFunction;
+const createFunction = (name, options) => new TsFunction(Object.assign(Object.assign({}, options), { name }));
+exports.tsFunction = Object.assign(createFunction, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsGenericParameter = exports.TsGenericParameter = void 0;
+const node_1 = require("../node");
+const write_ts_generic_parameters_1 = require("../utils/write-ts-generic-parameters");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsGenericParameter extends node_1.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);
+            (0, write_ts_nodes_1.writeTsNode)(builder, this.constraint);
+            builder.append(this.inject.afterConstraint);
+        }
+        if (this.default !== null) {
+            builder.append(' = ');
+            builder.append(this.inject.beforeDefault);
+            (0, write_ts_nodes_1.writeTsNode)(builder, this.default);
+            builder.append(this.inject.afterDefault);
+        }
+    }
+}
+exports.TsGenericParameter = TsGenericParameter;
+const createGenericParameter = (name, options) => new TsGenericParameter(Object.assign(Object.assign({}, options), { name }));
+exports.tsGenericParameter = Object.assign(createGenericParameter, {
+    write: write_ts_generic_parameters_1.writeTsGenericParameters,
+});

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsIndexer = exports.TsIndexer = void 0;
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsIndexer extends node_1.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, ': ');
+            (0, write_ts_nodes_1.writeTsNode)(b, this.keyType);
+        });
+        builder.append(': ');
+        (0, write_ts_nodes_1.writeTsNode)(builder, this.valueType);
+        builder.append(';');
+        builder.appendLine();
+    }
+}
+exports.TsIndexer = TsIndexer;
+const createIndexer = (keyType, valueType, options) => new TsIndexer(Object.assign(Object.assign({}, options), { keyType, valueType }));
+exports.tsIndexer = Object.assign(createIndexer, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsInterface = exports.TsInterface = void 0;
+const core_1 = require("@goast/core");
+const decorator_1 = require("./decorator");
+const doc_1 = require("./doc");
+const generic_parameter_1 = require("./generic-parameter");
+const node_1 = require("../node");
+const write_ts_members_1 = require("../utils/write-ts-members");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsInterface extends node_1.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(core_1.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(core_1.notNullish)) !== null && _f !== void 0 ? _f : [];
+        this.extends = (_h = (_g = options.extends) === null || _g === void 0 ? void 0 : _g.filter(core_1.notNullish)) !== null && _h !== void 0 ? _h : [];
+        this.members = (_k = (_j = options.members) === null || _j === void 0 ? void 0 : _j.filter(core_1.notNullish)) !== null && _k !== void 0 ? _k : [];
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        doc_1.tsDoc.write(builder, doc_1.tsDoc.get(this.doc, { generics: this.generics }));
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeDecorators);
+        decorator_1.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);
+        generic_parameter_1.tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        if (this.extends.length > 0) {
+            builder.append(' extends ');
+            builder.append(this.inject.beforeExtends);
+            (0, write_ts_nodes_1.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);
+            (0, write_ts_members_1.writeTsMembers)(b, this.members);
+            b.append(this.inject.afterMembers);
+        }, { multiline: this.members.length > 0 });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+}
+exports.TsInterface = TsInterface;
+const createInterface = (name, options) => new TsInterface(Object.assign(Object.assign({}, options), { name }));
+exports.tsInterface = Object.assign(createInterface, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsIntersectionType = exports.TsIntersectionType = void 0;
+const core_1 = require("@goast/core");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsIntersectionType extends node_1.TsNode {
+    constructor(options) {
+        super(options);
+        this.types = options.types.filter(core_1.notNullish);
+    }
+    onWrite(builder) {
+        const types = this.types.length === 0 ? ['unknown'] : resolveNestedIntersectionTypes(this);
+        if (types.length === 1) {
+            (0, write_ts_nodes_1.writeTsNode)(builder, types[0]);
+        }
+        else {
+            const multiline = types.length > 3;
+            if (multiline) {
+                builder.appendLine().append('& ');
+            }
+            builder.forEach(types, (b, t) => b.parenthesize('()', (b) => (0, write_ts_nodes_1.writeTsNode)(b, t)), {
+                separator: multiline ? '\n& ' : ' & ',
+            });
+        }
+    }
+}
+exports.TsIntersectionType = TsIntersectionType;
+const createIntersectionType = (types, options) => new TsIntersectionType(Object.assign(Object.assign({}, options), { types }));
+exports.tsIntersectionType = Object.assign(createIntersectionType, {
+    write: write_ts_nodes_1.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;
+}

package/cjs/lib/ast/nodes/lookup-type.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsLookupType = exports.TsLookupType = void 0;
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsLookupType extends node_1.TsNode {
+    constructor(options) {
+        super(options);
+        this.type = options.type;
+        this.index = options.index;
+    }
+    onWrite(builder) {
+        builder
+            .parenthesize('()', (b) => {
+            b.append(this.inject.beforeType);
+            (0, write_ts_nodes_1.writeTsNode)(b, this.type);
+            b.append(this.inject.afterType);
+        })
+            .parenthesize('[]', (b) => {
+            b.append(this.inject.beforeIndex);
+            (0, write_ts_nodes_1.writeTsNode)(b, this.index);
+            b.append(this.inject.afterIndex);
+        });
+    }
+}
+exports.TsLookupType = TsLookupType;
+const createLookupType = (type, index, options) => new TsLookupType(Object.assign(Object.assign({}, options), { type, index }));
+exports.tsLookupType = Object.assign(createLookupType, {
+    write: write_ts_nodes_1.writeTsNodes,
+});