@goast/kotlin 0.1.17 → 0.2.0

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

@@ -0,0 +1,83 @@
+import { spliceString } from '@goast/core';
+import { ktArgument } from './argument';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtString extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        super(options);
+        this.value = (_a = options === null || options === void 0 ? void 0 : options.value) !== null && _a !== void 0 ? _a : null;
+        this.template = (_b = options === null || options === void 0 ? void 0 : options.template) !== null && _b !== void 0 ? _b : false;
+        this.multiline = (_c = options === null || options === void 0 ? void 0 : options.multiline) !== null && _c !== void 0 ? _c : false;
+        this.trimMargin = (_d = options === null || options === void 0 ? void 0 : options.trimMargin) !== null && _d !== void 0 ? _d : true;
+        this.marginPrefix = (_e = options === null || options === void 0 ? void 0 : options.marginPrefix) !== null && _e !== void 0 ? _e : null;
+        this.autoAddMarginPrefix = (_f = options === null || options === void 0 ? void 0 : options.autoAddMarginPrefix) !== null && _f !== void 0 ? _f : true;
+    }
+    onWrite(builder) {
+        if (this.value === null) {
+            builder.append('null');
+            return;
+        }
+        let value = JSON.stringify(this.value).slice(1, -1);
+        if (this.multiline) {
+            value = value.replace(/\\n/g, '\n').replace(/\\r/g, '\r');
+        }
+        if (!this.template) {
+            value = value.replace(/\$/g, '\\$');
+        }
+        else {
+            const originalParts = this.findTemplateParts(this.value);
+            const escapedParts = this.findTemplateParts(value);
+            if (originalParts.length !== escapedParts.length) {
+                throw new Error('Template parts count mismatch');
+            }
+            for (let i = originalParts.length - 1; i >= 0; i--) {
+                const original = originalParts[i];
+                const escaped = escapedParts[i];
+                value = spliceString(value, escaped.index, escaped.value.length, original.value);
+            }
+        }
+        builder.append(this.multiline ? '"""' + (this.trimMargin ? '\n' : '') : '"');
+        if (this.multiline && this.trimMargin) {
+            builder.indent((b) => {
+                var _a;
+                if (this.autoAddMarginPrefix) {
+                    b.appendWithLinePrefix((_a = this.marginPrefix) !== null && _a !== void 0 ? _a : '|', value);
+                }
+                else {
+                    b.append(value);
+                }
+                b.append('\n""".trimMargin');
+                ktArgument.write(b, [this.marginPrefix ? new KtString({ value: this.marginPrefix }) : null]);
+            });
+        }
+        else {
+            builder.append(value, this.multiline ? '"""' : '"');
+        }
+    }
+    findTemplateParts(value) {
+        const parts = [];
+        let start = undefined;
+        let bracketCount = 0;
+        for (let i = 0; i < value.length; i++) {
+            if (value[i] === '$' && value[i + 1] === '{') {
+                start = i;
+            }
+            else if (value[i] === '{') {
+                bracketCount++;
+            }
+            else if (value[i] === '}') {
+                bracketCount--;
+                if (bracketCount === 0 && start !== undefined) {
+                    parts.push({ value: value.slice(start, i + 1), index: start });
+                    start = undefined;
+                }
+            }
+        }
+        return parts;
+    }
+}
+const createString = (value, options) => new KtString(Object.assign(Object.assign({}, options), { value }));
+export const ktString = Object.assign(createString, {
+    write: writeKtNodes,
+});

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

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

package/esm/lib/ast/references/index.js

@@ -0,0 +1,15 @@
+import * as jackson_1 from './jackson';
+export { jackson_1 as jackson };
+import * as jakarta_1 from './jakarta';
+export { jakarta_1 as jakarta };
+import * as java_1 from './java';
+export { java_1 as java };
+export * from './kotlin';
+import * as okhttp3_1 from './okhttp3';
+export { okhttp3_1 as okhttp3 };
+import * as reactor_1 from './reactor';
+export { reactor_1 as reactor };
+import * as spring_1 from './spring';
+export { spring_1 as spring };
+import * as swagger_1 from './swagger';
+export { swagger_1 as swagger };

package/esm/lib/ast/references/jackson.js

@@ -0,0 +1,9 @@
+import { ktReference } from '../nodes/reference';
+// com.fasterxml.jackson.annotation
+export const jsonTypeInfo = ktReference.factory('JsonTypeInfo', 'com.fasterxml.jackson.annotation');
+export const jsonSubTypes = ktReference.factory('JsonSubTypes', 'com.fasterxml.jackson.annotation');
+export const jsonProperty = ktReference.factory('JsonProperty', 'com.fasterxml.jackson.annotation');
+export const jsonInclude = ktReference.factory('JsonInclude', 'com.fasterxml.jackson.annotation');
+export const jsonIgnore = ktReference.factory('JsonIgnore', 'com.fasterxml.jackson.annotation');
+export const jsonAnySetter = ktReference.factory('JsonAnySetter', 'com.fasterxml.jackson.annotation');
+export const jsonAnyGetter = ktReference.factory('JsonAnyGetter', 'com.fasterxml.jackson.annotation');

package/esm/lib/ast/references/jakarta.js

@@ -0,0 +1,7 @@
+import { ktReference } from '../nodes/reference';
+// jakarta.annotation
+export const generated = ktReference.factory('Generated', 'jakarta.annotation');
+// jakarta.validation
+export const valid = ktReference.factory('Valid', 'jakarta.validation');
+// jakarta.validation.constraints
+export const pattern = ktReference.factory('Pattern', 'jakarta.validation.constraints');

package/esm/lib/ast/references/java.js

@@ -0,0 +1,11 @@
+import { ktReference } from '../nodes/reference';
+// java.lang
+export const system = ktReference.factory('System', 'java.lang');
+export const illegalStateException = ktReference.factory('IllegalStateException', 'java.lang');
+export const unsupportedOperationException = ktReference.factory('UnsupportedOperationException', 'java.lang');
+// java.io
+export const ioException = ktReference.factory('IOException', 'java.io');
+// java.time
+export const offsetDateTime = ktReference.factory('OffsetDateTime', 'java.time');
+// java.util
+export const optional = ktReference.genericFactory('Optional', 'java.util');

package/esm/lib/ast/references/kotlin.js

@@ -0,0 +1,24 @@
+import { ktReference } from '../nodes/reference';
+// kotlin
+export const any = ktReference.factory('Any', 'kotlin');
+export const nothing = ktReference.factory('Nothing', 'kotlin');
+export const unit = ktReference.factory('Unit', 'kotlin');
+export const string = ktReference.factory('String', 'kotlin');
+export const int = ktReference.factory('Int', 'kotlin');
+export const long = ktReference.factory('Long', 'kotlin');
+export const float = ktReference.factory('Float', 'kotlin');
+export const double = ktReference.factory('Double', 'kotlin');
+export const boolean = ktReference.factory('Boolean', 'kotlin');
+export const lazyFun = ktReference.genericFactory('lazy', 'kotlin');
+export const throws = ktReference.factory('Throws', 'kotlin');
+// kotlin.collections
+export const list = ktReference.genericFactory('List', 'kotlin.collections');
+export const mutableList = ktReference.genericFactory('MutableList', 'kotlin.collections');
+export const map = ktReference.genericFactory('Map', 'kotlin.collections');
+export const mutableMap = ktReference.genericFactory('MutableMap', 'kotlin.collections');
+export const listOf = ktReference.genericFactory('listOf', 'kotlin.collections');
+export const mutableListOf = ktReference.genericFactory('mutableListOf', 'kotlin.collections');
+export const mapOf = ktReference.genericFactory('mapOf', 'kotlin.collections');
+export const mutableMapOf = ktReference.genericFactory('mutableMapOf', 'kotlin.collections');
+// kotlin.jvm
+export const jvmStatic = ktReference.factory('JvmStatic', 'kotlin.jvm');

package/esm/lib/ast/references/okhttp3.js

@@ -0,0 +1,4 @@
+import { ktReference } from '../nodes/reference';
+// okhttp3
+export const okHttpClient = ktReference.factory('OkHttpClient', 'okhttp3');
+export const httpUrl = ktReference.factory('HttpUrl', 'okhttp3');

package/esm/lib/ast/references/reactor.js

@@ -0,0 +1,3 @@
+import { ktReference } from '../nodes/reference';
+// reactor.core.publisher
+export const flux = ktReference.genericFactory('Flux', 'reactor.core.publisher');

package/esm/lib/ast/references/spring.js

@@ -0,0 +1,18 @@
+import { ktReference } from '../nodes/reference';
+// org.springframework.web.bind.annotation
+export const requestMapping = ktReference.factory('RequestMapping', 'org.springframework.web.bind.annotation');
+export const requestBody = ktReference.factory('RequestBody', 'org.springframework.web.bind.annotation');
+export const requestParam = ktReference.factory('RequestParam', 'org.springframework.web.bind.annotation');
+export const requestMethod = ktReference.factory('RequestMethod', 'org.springframework.web.bind.annotation');
+export const pathVariable = ktReference.factory('PathVariable', 'org.springframework.web.bind.annotation');
+// org.springframework.web.context.request
+export const nativeWebRequest = ktReference.factory('NativeWebRequest', 'org.springframework.web.context.request');
+// org.springframework.beans.factory.annotation
+export const autowired = ktReference.factory('Autowired', 'org.springframework.beans.factory.annotation');
+// org.springframework.validation.annotation
+export const validated = ktReference.factory('Validated', 'org.springframework.validation.annotation');
+// org.springframework.http
+export const responseEntity = ktReference.genericFactory('ResponseEntity', 'org.springframework.http');
+export const httpStatus = ktReference.factory('HttpStatus', 'org.springframework.http');
+// org.springframework.stereotype
+export const controller = ktReference.factory('Controller', 'org.springframework.stereotype');

package/esm/lib/ast/references/swagger.js

@@ -0,0 +1,8 @@
+import { ktReference } from '../nodes/reference';
+// io.swagger.v3.oas.annotations
+export const parameter = ktReference.factory('Parameter', 'io.swagger.v3.oas.annotations');
+export const operation = ktReference.factory('Operation', 'io.swagger.v3.oas.annotations');
+// io.swagger.v3.oas.annotations.media
+export const schema = ktReference.factory('Schema', 'io.swagger.v3.oas.annotations.media');
+// io.swagger.v3.oas.annotations.responses
+export const apiResponse = ktReference.factory('ApiResponse', 'io.swagger.v3.oas.annotations.responses');

package/esm/lib/ast/utils/get-kotlin-builder-options.js

@@ -0,0 +1,15 @@
+import { defaultOpenApiGeneratorConfig } from '@goast/core';
+import { defaultKotlinGeneratorConfig } from '../../config';
+import { KotlinFileBuilder } from '../../file-builder';
+const ktConfigSymbol = Symbol();
+export function getKotlinBuilderOptions(builder) {
+    if (builder instanceof KotlinFileBuilder) {
+        return builder.options;
+    }
+    if (ktConfigSymbol in builder.options) {
+        return builder.options[ktConfigSymbol];
+    }
+    const options = Object.assign(Object.assign(Object.assign({}, defaultOpenApiGeneratorConfig), defaultKotlinGeneratorConfig), builder.options);
+    builder[ktConfigSymbol] = options;
+    return options;
+}

package/esm/lib/ast/utils/to-kt-node.js

@@ -0,0 +1,18 @@
+import { ktCall } from '../nodes/call';
+import { ktString } from '../nodes/string';
+import { listOf, mapOf } from '../references';
+export function toKtNode(value) {
+    if (Array.isArray(value)) {
+        return ktCall([listOf.infer()], value.map((x) => toKtNode(x)));
+    }
+    if (typeof value === 'object' && value !== null) {
+        return ktCall([mapOf.infer()], Object.entries(value).map(([k, v]) => ktCall([toKtNode(k), 'to'], [toKtNode(v)])));
+    }
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return String(value);
+    }
+    return ktString(String(value));
+}

package/esm/lib/ast/utils/write-kt-annotations.js

@@ -0,0 +1,9 @@
+import { toArray, notNullish } from '@goast/core';
+import { writeKtNode } from './write-kt-node';
+export function writeKtAnnotations(builder, nodes, options) {
+    const filteredNodes = toArray(nodes).filter(notNullish);
+    builder.forEach(filteredNodes, (b, a) => {
+        writeKtNode(b, a);
+        b.append((options === null || options === void 0 ? void 0 : options.multiline) ? '\n' : ' ');
+    });
+}

package/esm/lib/ast/utils/write-kt-arguments.js

@@ -0,0 +1,29 @@
+import { notNullish, toArray } from '@goast/core';
+import { writeKtNode, writeKtNodes } from './write-kt-node';
+import { KtLambda } from '../nodes/lambda';
+export function writeKtArguments(builder, nodes) {
+    const filteredNodes = toArray(nodes).filter(notNullish);
+    if (filteredNodes.length === 0) {
+        builder.append('()');
+        return;
+    }
+    const lastNode = filteredNodes[filteredNodes.length - 1];
+    let lambda = null;
+    if (lastNode instanceof KtLambda) {
+        lambda = lastNode;
+        filteredNodes.pop();
+    }
+    else if (typeof lastNode === 'object' &&
+        (!('name' in lastNode) || !lastNode.name) &&
+        'value' in lastNode &&
+        lastNode.value instanceof KtLambda) {
+        lambda = lastNode.value;
+        filteredNodes.pop();
+    }
+    const multiline = filteredNodes.length > 3;
+    builder.parenthesizeIf(filteredNodes.length > 0, '()', (b) => writeKtNodes(b, filteredNodes, { separator: multiline ? ',\n' : ', ' }), { multiline });
+    if (lambda) {
+        builder.append(' ');
+        writeKtNode(builder, lambda);
+    }
+}

package/esm/lib/ast/utils/write-kt-enum-values.js

@@ -0,0 +1,13 @@
+import { toArray, notNullish } from '@goast/core';
+import { writeKtNode } from './write-kt-node';
+export function writeKtEnumValues(builder, nodes) {
+    const filteredNodes = toArray(nodes).filter(notNullish);
+    const spacing = filteredNodes.some((v) => typeof v === 'object' &&
+        (('annotations' in v && Array.isArray(v.annotations) && v.annotations.length > 0) ||
+            ('doc' in v && v.doc) ||
+            ('members' in v && Array.isArray(v.members) && v.members.some(notNullish))));
+    const multiline = spacing ||
+        filteredNodes.length > 4 ||
+        filteredNodes.some((v) => typeof v === 'object' && 'arguments' in v && Array.isArray(v.arguments) && v.arguments.length > 0);
+    builder.forEach(filteredNodes, (b, v, i) => b.if(spacing && i > 0, (b) => b.ensurePreviousLineEmpty()).append((b) => writeKtNode(b, v)), { separator: multiline ? ',\n' : ', ' });
+}

package/esm/lib/ast/utils/write-kt-generic-parameters.js

@@ -0,0 +1,8 @@
+import { toArray, notNullish } from '@goast/core';
+import { writeKtNode } from './write-kt-node';
+export function writeKtGenericParameters(builder, nodes) {
+    const filteredNodes = toArray(nodes).filter(notNullish);
+    if (filteredNodes.length === 0)
+        return;
+    builder.parenthesize('<>', (b) => b.forEach(filteredNodes, writeKtNode, { separator: ', ' }));
+}

package/esm/lib/ast/utils/write-kt-members.js

@@ -0,0 +1,12 @@
+import { notNullish, isAppendValue, isAppendValueGroup } from '@goast/core';
+import { writeKtNode } from './write-kt-node';
+import { KtProperty } from '../nodes/property';
+export function writeKtMembers(builder, members, options) {
+    const filteredMembers = members.filter(notNullish);
+    builder.forEach(filteredMembers, (b, m, i) => b.if(() => !(m instanceof KtProperty && !m.doc && m.annotations.length === 0) &&
+        !isAppendValue(m) &&
+        !isAppendValueGroup(m), (b) => b
+        .if(i > 0 || !!(options === null || options === void 0 ? void 0 : options.alreadyHasMembers), (b) => b.ensurePreviousLineEmpty())
+        .append((b) => writeKtNode(b, m))
+        .if(i < filteredMembers.length - 1, (b) => b.ensurePreviousLineEmpty()), (b) => b.append((b) => writeKtNode(b, m)).ensureCurrentLineEmpty()));
+}

package/esm/lib/ast/utils/write-kt-node.js

@@ -0,0 +1,19 @@
+import { toArray, notNullish } from '@goast/core';
+import { KtNode } from '../node';
+export function writeKtNode(builder, node) {
+    if (node instanceof KtNode) {
+        node.write(builder);
+    }
+    else {
+        builder.append(node);
+    }
+}
+export function writeKtNodes(builder, nodes, options) {
+    const filteredNodes = toArray(nodes).filter(notNullish);
+    if (filteredNodes.length === 1) {
+        writeKtNode(builder, filteredNodes[0]);
+    }
+    else if (filteredNodes.length > 1) {
+        builder.forEach(filteredNodes, writeKtNode, { separator: options === null || options === void 0 ? void 0 : options.separator });
+    }
+}

package/esm/lib/ast/utils/write-kt-parameters.js

@@ -0,0 +1,9 @@
+import { toArray, notNullish } from '@goast/core';
+import { writeKtNode } from './write-kt-node';
+export function writeKtParameters(builder, nodes) {
+    const filteredNodes = toArray(nodes).filter(notNullish);
+    const hasAnnotations = filteredNodes.some((p) => typeof p === 'object' && 'annotations' in p && Array.isArray(p.annotations) && p.annotations.length > 0);
+    const multiline = filteredNodes.length > 2 || hasAnnotations;
+    const spacing = multiline && hasAnnotations;
+    builder.parenthesize('()', (b) => b.forEach(filteredNodes, (b, p, i) => b.if(i > 0 && spacing, (b) => b.ensurePreviousLineEmpty()).append((b) => writeKtNode(b, p)), { separator: multiline ? ',\n' : ', ' }), { multiline });
+}

package/esm/lib/config.js

@@ -1,6 +1,20 @@
 export const defaultKotlinGeneratorConfig = {
-    charsTreatedAsEmptyLine: ['{'],
     indent: { type: 'spaces', count: 4 },
+    typeNameCasing: 'pascal',
+    parameterNameCasing: 'camel',
+    functionNameCasing: 'camel',
     propertyNameCasing: 'camel',
     enumValueNameCasing: 'snake',
+    globalImports: [
+        'kotlin.*',
+        'kotlin.annotation.*',
+        'kotlin.collections.*',
+        'kotlin.comparisons.*',
+        'kotlin.io.*',
+        'kotlin.ranges.*',
+        'kotlin.sequences.*',
+        'kotlin.text.*',
+        'java.lang.*',
+        'kotlin.jvm.*',
+    ],
 };

package/esm/lib/file-builder.js

@@ -1,8 +1,16 @@
-import { SourceBuilder } from '@goast/core';
+import { SourceBuilder, isAppendValue } from '@goast/core';
+import { KtNode } from './ast/node';
+import { defaultKotlinGeneratorConfig } from './config';
 import { ImportCollection } from './import-collection';
+export function isKotlinAppendValue(value) {
+    return isAppendValue(value) || value instanceof KtNode;
+}
 export class KotlinFileBuilder extends SourceBuilder {
+    get options() {
+        return super.options;
+    }
     constructor(packageName, options) {
-        super(options);
+        super(options !== null && options !== void 0 ? options : defaultKotlinGeneratorConfig);
         this.imports = new ImportCollection();
         this.packageName = packageName;
     }
@@ -56,4 +64,10 @@ export class KotlinFileBuilder extends SourceBuilder {
             .if(addPadding, (builder) => builder.ensureCurrentLineEmpty())
             .toString();
     }
+    appendSingle(value) {
+        super.appendSingle(value);
+        if (value instanceof KtNode) {
+            value.write(this);
+        }
+    }
 }

package/esm/lib/generators/models/args.js

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

package/esm/lib/generators/models/index.js

@@ -1,3 +1,5 @@
 export * from './model-generator';
 export * from './models';
 export * from './models-generator';
+import * as DefaultKotlinModelGeneratorArgs_1 from './args';
+export { DefaultKotlinModelGeneratorArgs_1 as DefaultKotlinModelGeneratorArgs };