@goast/kotlin 0.4.15 → 0.4.16-beta2

package/src/src/ast/utils/write-kt-arguments.ts

@@ -1,45 +0,0 @@
-import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
-
-import { KtLambda } from '../nodes/lambda.js';
-import { type KtAppendValue, writeKtNode, writeKtNodes } from './write-kt-node.js';
-
-export function writeKtArguments<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
-) {
-  const filteredNodes = toArray(nodes).filter(notNullish);
-
-  if (filteredNodes.length === 0) {
-    builder.append('()');
-    return;
-  }
-
-  const lastNode = filteredNodes[filteredNodes.length - 1];
-  let lambda: KtAppendValue<TBuilder> | null = 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/src/src/ast/utils/write-kt-enum-values.ts

@@ -1,27 +0,0 @@
-import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
-
-import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
-
-export function writeKtEnumValues<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
-) {
-  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/src/src/ast/utils/write-kt-generic-parameters.ts

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

package/src/src/ast/utils/write-kt-members.ts

@@ -1,25 +0,0 @@
-import { isAppendValue, isAppendValueGroup, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
-
-import { KtProperty } from '../nodes/property.js';
-import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
-
-export function writeKtMembers<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  members: Nullable<KtAppendValue<TBuilder>>[],
-  options?: { alreadyHasMembers?: boolean },
-): void {
-  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?.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/src/src/ast/utils/write-kt-node.ts

@@ -1,37 +0,0 @@
-import {
-  type AppendValue,
-  notNullish,
-  type Nullable,
-  type Separator,
-  type SingleOrMultiple,
-  type SourceBuilder,
-  toArray,
-} from '@goast/core';
-
-import { KtNode } from '../node.js';
-
-export type KtAppendValue<TBuilder extends SourceBuilder> = AppendValue<TBuilder> | KtNode<TBuilder>;
-
-export function writeKtNode<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  node: Nullable<KtAppendValue<TBuilder>>,
-): void {
-  if (node instanceof KtNode) {
-    node.write(builder);
-  } else {
-    builder.append(node);
-  }
-}
-
-export function writeKtNodes<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
-  options?: { separator?: Separator<TBuilder, KtAppendValue<TBuilder>> },
-): void {
-  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?.separator });
-  }
-}

package/src/src/ast/utils/write-kt-parameters.ts

@@ -1,25 +0,0 @@
-import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
-
-import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
-
-export function writeKtParameters<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
-) {
-  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/src/src/common-results.ts

@@ -1,4 +0,0 @@
-export type KotlinImport = {
-  packageName?: string;
-  typeName: string;
-};

package/src/src/config.ts

@@ -1,41 +0,0 @@
-import type {
-  DefaultGenerationProviderConfig,
-  OpenApiGeneratorConfig,
-  StringCasing,
-  StringCasingWithOptions,
-} from '@goast/core';
-
-export type KotlinGeneratorConfig = OpenApiGeneratorConfig & {
-  typeNameCasing: StringCasing | StringCasingWithOptions;
-  parameterNameCasing: StringCasing | StringCasingWithOptions;
-  functionNameCasing: StringCasing | StringCasingWithOptions;
-  propertyNameCasing: StringCasing | StringCasingWithOptions;
-  enumValueNameCasing: StringCasing | StringCasingWithOptions;
-  constantNameCasing: StringCasing | StringCasingWithOptions;
-
-  globalImports: string[];
-};
-
-export const defaultKotlinGeneratorConfig: DefaultGenerationProviderConfig<KotlinGeneratorConfig> = {
-  indent: { type: 'spaces', count: 4 },
-
-  typeNameCasing: 'pascal',
-  parameterNameCasing: 'camel',
-  functionNameCasing: 'camel',
-  propertyNameCasing: 'camel',
-  enumValueNameCasing: 'snake',
-  constantNameCasing: 'snake',
-
-  globalImports: [
-    'kotlin.*',
-    'kotlin.annotation.*',
-    'kotlin.collections.*',
-    'kotlin.comparisons.*',
-    'kotlin.io.*',
-    'kotlin.ranges.*',
-    'kotlin.sequences.*',
-    'kotlin.text.*',
-    'java.lang.*',
-    'kotlin.jvm.*',
-  ],
-};

package/src/src/file-builder.ts

@@ -1,108 +0,0 @@
-import { type AppendParam, type AppendValue, isAppendValue, SourceBuilder } from '@goast/core';
-
-import { KtNode } from './ast/node.js';
-import { defaultKotlinGeneratorConfig, type KotlinGeneratorConfig } from './config.js';
-import { ImportCollection } from './import-collection.js';
-
-type AnnotationArgumentValue<T extends SourceBuilder> = string | ((builder: T) => void);
-type AnnotationArgument<T extends SourceBuilder> =
-  | AnnotationArgumentValue<T>
-  | [key: string, value: AnnotationArgumentValue<T>]
-  | [value: AnnotationArgumentValue<T>, condition: boolean]
-  | [key: string, value: AnnotationArgumentValue<T>, condition: boolean];
-
-export type KotlinAppends<TAdditionalAppends> = KtNode<KotlinFileBuilder> | TAdditionalAppends;
-export type KotlinAppendParam<TBuilder extends KotlinFileBuilder, TAdditionalAppends> = AppendParam<
-  TBuilder,
-  KotlinAppends<TAdditionalAppends>
->;
-
-export function isKotlinAppendValue<TBuilder extends KotlinFileBuilder>(
-  value: unknown,
-): value is AppendValue<TBuilder> {
-  return isAppendValue(value) || value instanceof KtNode;
-}
-
-export class KotlinFileBuilder<TAdditionalAppends = never> extends SourceBuilder<KotlinAppends<TAdditionalAppends>> {
-  public readonly packageName: string | undefined;
-  public readonly imports: ImportCollection = new ImportCollection();
-
-  public override get options(): KotlinGeneratorConfig {
-    return super.options as KotlinGeneratorConfig;
-  }
-
-  constructor(packageName?: string, options?: KotlinGeneratorConfig) {
-    super(options ?? defaultKotlinGeneratorConfig);
-    this.packageName = packageName;
-  }
-
-  public addImport(name: string, packageName?: string): this {
-    if (packageName !== undefined && packageName !== this.packageName) {
-      this.imports.addImport(name, packageName);
-    }
-    return this;
-  }
-
-  public appendAnnotation(name: string, packageName?: string, args?: AnnotationArgument<this>[]): this {
-    const allArgs: [key: string | undefined, value: AnnotationArgumentValue<this>][] = [];
-    if (args) {
-      for (const a of args) {
-        if (!Array.isArray(a)) {
-          allArgs.push([undefined, a]);
-        } else if (a.length === 2 && a[1] === true) {
-          allArgs.push([undefined, a[0]]);
-        }
-      }
-      for (const a of args) {
-        if (Array.isArray(a) && typeof a[1] !== 'boolean' && a[2] !== false) {
-          allArgs.push(a.length === 2 ? a : [a[0], a[1]]);
-        }
-      }
-    }
-
-    this.append(`@${name}`).addImport(name, packageName);
-
-    if (allArgs.length > 0) {
-      const multiline = allArgs.some((x) => typeof x[1] !== 'string') ||
-        allArgs.reduce((c, [key, value]) => c + (key ? key.length + 3 : 0) + (value?.length ?? 0), 0) > 80;
-      this.parenthesize('()', (builder) =>
-        builder
-          .appendLineIf(multiline)
-          .forEach(
-            allArgs,
-            (builder, [name, value]) =>
-              builder
-                .append(name ? `${name} = ` : '')
-                .append((builder) => (typeof value === 'string' ? builder.append(value) : value(builder))),
-            { separator: multiline ? ',\n' : ', ' },
-          )
-          .appendLineIf(multiline));
-    }
-
-    this.appendLine();
-
-    return this;
-  }
-
-  public override clear(): void {
-    super.clear();
-    this.imports.clear();
-  }
-
-  public override toString(addPadding: boolean = true): string {
-    return new SourceBuilder(this.options)
-      .if(this.packageName !== undefined, (builder) => builder.appendLine(`package ${this.packageName}`).appendLine())
-      .append((builder) => this.imports.writeTo(builder))
-      .if(addPadding, (builder) => builder.ensurePreviousLineEmpty())
-      .append(super.toString())
-      .if(addPadding, (builder) => builder.ensureCurrentLineEmpty())
-      .toString();
-  }
-
-  protected override appendSingle(value: KotlinAppendParam<this, TAdditionalAppends>): void {
-    super.appendSingle(value);
-    if (value instanceof KtNode) {
-      value.write(this);
-    }
-  }
-}

package/src/src/generators/file-generator.ts

@@ -1,29 +0,0 @@
-import {
-  type MaybePromise,
-  type Nullable,
-  type OpenApiGenerationProviderContext,
-  type OpenApiGeneratorInput,
-  toCasing,
-} from '@goast/core';
-
-import type { KotlinGeneratorConfig } from '../config.js';
-import { toKotlinPropertyName, toKotlinStringLiteral } from '../utils.js';
-
-export abstract class KotlinFileGenerator<
-  TContext extends OpenApiGenerationProviderContext<OpenApiGeneratorInput, KotlinGeneratorConfig>,
-  TOutput,
-> {
-  public abstract generate(context: TContext): MaybePromise<TOutput>;
-
-  protected toPropertyName(context: TContext, name: string): string {
-    return toKotlinPropertyName(toCasing(name, context.config.propertyNameCasing));
-  }
-
-  protected toEnumValueName(context: TContext, name: string): string {
-    return toKotlinPropertyName(toCasing(name, context.config.enumValueNameCasing));
-  }
-
-  protected toStringLiteral(_context: TContext, text: Nullable<string>): string {
-    return toKotlinStringLiteral(text);
-  }
-}

package/src/src/generators/index.ts

@@ -1,4 +0,0 @@
-export * from './file-generator.js';
-export * from './models/index.js';
-export * from './services/okhttp3-clients/index.js';
-export * from './services/spring-controllers/index.js';

package/src/src/generators/models/args.ts

@@ -1,123 +0,0 @@
-import type { ApiSchema, ApiSchemaProperty } from '@goast/core';
-
-export type GetFileContent = object;
-
-export type GetSchemaDeclaration = {
-  schema: ApiSchema;
-};
-
-export type GetClass = {
-  schema: ApiSchema<'object'>;
-};
-
-export type GetInterface = {
-  schema: ApiSchema<'object'>;
-};
-
-export type GetEnum = {
-  schema: ApiSchema;
-};
-
-export type GetType = {
-  schema: ApiSchema;
-  nullable?: boolean;
-};
-
-export type GetGeneratedType = {
-  schema: ApiSchema;
-  nullable?: boolean;
-};
-
-export type GetAdditionalPropertiesType = {
-  schema: ApiSchema<'object'>;
-};
-
-export type GetDefaultValue = {
-  schema: ApiSchema;
-};
-
-export type GetClassParameter = {
-  schema: ApiSchema<'object'>;
-  inheritedSchemas: ApiSchema[];
-  parameters: ApiSchemaProperty[];
-  property: ApiSchemaProperty;
-};
-
-export type GetInterfaceProperty = {
-  schema: ApiSchema<'object'>;
-  property: ApiSchemaProperty;
-};
-
-export type GetAdditionalPropertiesProperty = {
-  schema: ApiSchema<'object'>;
-};
-
-export type GetAdditionalPropertiesSetter = {
-  schema: ApiSchema<'object'>;
-};
-
-export type GetAdditionalPropertiesGetter = {
-  schema: ApiSchema<'object'>;
-};
-
-export type GetJacksonJsonTypeInfoAnnotation = {
-  schema: ApiSchema;
-};
-
-export type GetJacksonJsonSubTypesAnnotation = {
-  schema: ApiSchema;
-};
-
-export type GetJacksonJsonPropertyAnnotation = {
-  schema: ApiSchema;
-  property: ApiSchemaProperty;
-};
-
-export type GetJacksonJsonIncludeAnnotation = {
-  schema: ApiSchema;
-  property: ApiSchemaProperty;
-};
-
-export type GetJakartaValidationAnnotations = {
-  schema: ApiSchema;
-  property: ApiSchemaProperty;
-};
-
-export type GetSwaggerSchemaAnnotation = {
-  schema: ApiSchema;
-  property: ApiSchemaProperty;
-};
-
-export type GetPackageName = {
-  schema: ApiSchema;
-};
-
-export type ShouldGenerateTypeDeclaration = {
-  schema: ApiSchema;
-};
-
-export type GetDeclarationTypeName = {
-  schema: ApiSchema;
-};
-
-export type GetInheritedSchemas = {
-  schema: ApiSchema;
-};
-
-export type GetClassProperties = {
-  schema: ApiSchema<'object'>;
-};
-
-export type SortProperties = {
-  schema: ApiSchema;
-  properties: Iterable<ApiSchemaProperty>;
-};
-
-export type NormalizeSchema = {
-  schema: ApiSchema;
-};
-
-export type HasProperty = {
-  schema: ApiSchema;
-  propertyName: string;
-};

package/src/src/generators/models/index.ts

@@ -1,4 +0,0 @@
-export * as DefaultKotlinModelGeneratorArgs from './args.js';
-export * from './model-generator.js';
-export * from './models-generator.js';
-export * from './models.js';