@goast/kotlin 0.4.16 → 0.4.17-beta1

package/src/src/ast/nodes/reference.ts

@@ -1,178 +0,0 @@
-import {
-  type AstNodeOptions,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-  type TupleWithCount,
-} from '@goast/core';
-
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { KtNode } from '../node.js';
-import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
-import { ktGenericParameter } from './generic-parameter.js';
-import type { KtType } from './types.js';
-
-import type { KtCall } from './call.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    name: string;
-    packageName?: Nullable<string>;
-    generics?: Nullable<Nullable<KtType<TBuilder>>[]>;
-    nullable?: Nullable<boolean>;
-    classReference?: Nullable<boolean>;
-    subReference?: Nullable<KtReference<TBuilder> | KtCall<TBuilder>>;
-  }
->;
-
-type _AddImportHandler<T> = {
-  // deno-lint-ignore no-explicit-any
-  builderClass: abstract new (...args: any) => T;
-  // deno-lint-ignore no-explicit-any
-  handler: (builder: T, reference: KtReference<any>) => void;
-};
-
-export class KtReference<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  // deno-lint-ignore no-explicit-any
-  private static readonly addImportHandlers: _AddImportHandler<any>[] = [
-    {
-      builderClass: KotlinFileBuilder,
-      handler: (builder, reference) => builder.addImport(reference.name, reference.packageName),
-    },
-  ];
-
-  public name: string;
-  public packageName: string | null;
-  public generics: KtType<TBuilder>[];
-  public nullable: boolean;
-  public classReference: boolean;
-  public subReference: KtReference<TBuilder> | KtCall<TBuilder> | null;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.packageName = options.packageName ?? null;
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.nullable = options.nullable ?? false;
-    this.classReference = options.classReference ?? false;
-    this.subReference = options.subReference ?? null;
-  }
-
-  public addImport(builder: TBuilder): void {
-    if (this.packageName) {
-      const handler = KtReference.addImportHandlers.find((h) => builder instanceof h.builderClass);
-      if (handler) {
-        handler.handler(builder, this);
-      }
-    }
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.name);
-    ktGenericParameter.write(builder, this.generics);
-    if (this.classReference) {
-      builder.append('::class');
-    } else if (this.subReference) {
-      builder.append('::');
-      writeKtNode(builder, this.subReference);
-    } else if (this.nullable) {
-      builder.append('?');
-    }
-
-    this.addImport(builder);
-  }
-
-  public static registerAddImportHandler<TBuilder extends SourceBuilder>(
-    builderClass: _AddImportHandler<TBuilder>['builderClass'],
-    handler: _AddImportHandler<TBuilder>['handler'],
-  ): void {
-    KtReference.addImportHandlers.push({ builderClass, handler });
-  }
-}
-
-const createReference = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  packageName?: Options<TBuilder>['packageName'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>,
-): KtReference<TBuilder> => new KtReference<TBuilder>({ ...options, name, packageName });
-
-export type KtReferenceFactory =
-  & (<TBuilder extends SourceBuilder>(
-    options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>,
-  ) => KtReference<TBuilder>)
-  & {
-    refName: string;
-    packageName: Nullable<string>;
-    matches: (value: unknown) => value is KtReference<never>;
-  };
-
-export type KtGenericReferenceFactory<TGenericCount extends number | number[]> =
-  & (<TBuilder extends SourceBuilder>(
-    generics: TupleWithCount<KtType<TBuilder>, TGenericCount>,
-    options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName' | 'generics'>>,
-  ) => KtReference<TBuilder>)
-  & {
-    refName: string;
-    packageName: Nullable<string>;
-    infer: <TBuilder extends SourceBuilder>(
-      options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName' | 'generics'>>,
-    ) => KtReference<TBuilder>;
-    matches: (value: unknown) => value is KtReference<never>;
-  };
-
-const createFactory = (name: string, packageName?: Nullable<string>): KtReferenceFactory => {
-  return Object.assign(
-    <TBuilder extends SourceBuilder>(options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>) =>
-      createReference<TBuilder>(name, packageName, options),
-    {
-      refName: name,
-      packageName,
-      matches: (value: unknown): value is KtReference<never> =>
-        value instanceof KtReference && value.name === name && value.packageName === (packageName ?? null),
-    },
-  );
-};
-
-const createGenericFactory = <TGenericCount extends number | number[]>(
-  name: string,
-  packageName?: Nullable<string>,
-): KtGenericReferenceFactory<TGenericCount> => {
-  return Object.assign(
-    <TBuilder extends SourceBuilder>(
-      generics: TupleWithCount<KtType<TBuilder>, TGenericCount>,
-      options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName' | 'generics'>>,
-    ) => createReference<TBuilder>(name, packageName, { ...options, generics }),
-    {
-      refName: name,
-      packageName,
-      infer: <TBuilder extends SourceBuilder>(
-        options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName' | 'generics'>>,
-      ) => createReference<TBuilder>(name, packageName, options),
-      matches: (value: unknown): value is KtReference<never> =>
-        value instanceof KtReference && value.name === name && value.packageName === (packageName ?? null),
-    },
-  );
-};
-
-const importRefs = <TBuilder extends SourceBuilder>(builder: TBuilder, references: KtReference<TBuilder>[]): void => {
-  references.forEach((ref) => ref.addImport(builder));
-};
-
-export const ktReference: typeof createReference & {
-  factory: typeof createFactory;
-  genericFactory: typeof createGenericFactory;
-  write: typeof writeKtNodes;
-  import: typeof importRefs;
-} = Object.assign(createReference, {
-  factory: createFactory,
-  genericFactory: createGenericFactory,
-  write: writeKtNodes,
-  import: importRefs,
-});

package/src/src/ast/nodes/string.test.ts

@@ -1,61 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.15/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.11/bdd.js';
-
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktString } from './string.js';
-
-describe('ktString', () => {
-  let builder: KotlinFileBuilder;
-
-  beforeEach(() => {
-    builder = new KotlinFileBuilder();
-  });
-
-  it('should handle null', () => {
-    builder.append(ktString(null));
-    expect(builder.toString(false)).toBe('null');
-  });
-
-  it('should surround string with double quotes', () => {
-    builder.append(ktString('test'));
-    expect(builder.toString(false)).toBe('"test"');
-  });
-
-  it('should escape certain characters', () => {
-    builder.append(ktString('\r\n\t${\n"abc"\n}\u0014'));
-    expect(builder.toString(false)).toBe('"\\r\\n\\t\\${\\n\\"abc\\"\\n}\\u0014"');
-  });
-
-  it('should not escape $ character in template string', () => {
-    builder.append(ktString('\r\n\t${\n"abc"\n}\u0014', { template: true }));
-    expect(builder.toString(false)).toBe(`"\\r\\n\\t\${${EOL}"abc"${EOL}}\\u0014"`);
-  });
-
-  it('should handle multiline strings', () => {
-    builder.append(ktString('test\r\ntest', { multiline: true }));
-    expect(builder.toString(false)).toBe(`"""${EOL}    |test${EOL}    |test${EOL}    """.trimMargin()`);
-  });
-
-  it('should handle multiline strings with custom margin prefix', () => {
-    builder.append(ktString('test\r\ntest', { multiline: true, marginPrefix: '!' }));
-    expect(builder.toString(false)).toBe(`"""${EOL}    !test${EOL}    !test${EOL}    """.trimMargin("!")`);
-  });
-
-  it('should handle multiline strings without auto prefix', () => {
-    builder.append(ktString('test\r\ntest', { multiline: true, autoAddMarginPrefix: false }));
-    expect(builder.toString(false)).toBe(`"""${EOL}    test${EOL}    test${EOL}    """.trimMargin()`);
-  });
-
-  it('should handle multiline strings without trimMargin', () => {
-    builder.append(ktString('test\r\ntest', { multiline: true, trimMargin: false }));
-    expect(builder.toString(false)).toBe(`"""test${EOL}test"""`);
-  });
-
-  it('should render injections', () => {
-    builder.append(ktString('test', { inject: { before: 'before', after: 'after' } }));
-    expect(builder.toString(false)).toBe('before"test"after');
-  });
-});

package/src/src/ast/nodes/string.ts

@@ -1,114 +0,0 @@
-import { type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder, spliceString } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { ktArgument } from './argument.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    value?: Nullable<string>;
-    template?: Nullable<boolean>;
-    multiline?: Nullable<boolean>;
-    trimMargin?: Nullable<boolean>;
-    marginPrefix?: Nullable<string>;
-    autoAddMarginPrefix?: Nullable<boolean>;
-  }
->;
-
-export class KtString<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public value: string | null;
-  public template: boolean;
-  public multiline: boolean;
-  public trimMargin: boolean;
-  public marginPrefix: string | null;
-  public autoAddMarginPrefix: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.value = options?.value ?? null;
-    this.template = options?.template ?? false;
-    this.multiline = options?.multiline ?? false;
-    this.trimMargin = options?.trimMargin ?? true;
-    this.marginPrefix = options?.marginPrefix ?? null;
-    this.autoAddMarginPrefix = options?.autoAddMarginPrefix ?? true;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    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) => {
-        if (this.autoAddMarginPrefix) {
-          b.appendWithLinePrefix(this.marginPrefix ?? '|', value);
-        } else {
-          b.append(value);
-        }
-
-        b.append('\n""".trimMargin');
-        ktArgument.write(b, [this.marginPrefix ? new KtString<TBuilder>({ value: this.marginPrefix }) : null]);
-      });
-    } else {
-      builder.append(value, this.multiline ? '"""' : '"');
-    }
-  }
-
-  protected findTemplateParts(value: string): { value: string; index: number }[] {
-    const parts: { value: string; index: number }[] = [];
-    let start: number | undefined = 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 = <TBuilder extends SourceBuilder>(
-  value: Options<TBuilder>['value'],
-  options?: Prettify<Omit<Options<TBuilder>, 'value'>>,
-): KtString<TBuilder> => new KtString<TBuilder>({ ...options, value });
-
-export const ktString: typeof createString & { write: typeof writeKtNodes } = Object.assign(createString, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/types.ts

@@ -1,23 +0,0 @@
-import type { BasicAppendValue, SourceBuilder } from '@goast/core';
-
-import type { KtCall } from './call.js';
-import type { KtCollectionLiteral } from './collection-literal.js';
-import type { KtLambdaType } from './lambda-type.js';
-import type { KtLambda } from './lambda.js';
-import type { KtObject } from './object.js';
-import type { KtReference } from './reference.js';
-import type { KtString } from './string.js';
-
-export type KtType<TBuilder extends SourceBuilder> =
-  | KtReference<TBuilder>
-  | KtLambdaType<TBuilder>
-  | BasicAppendValue<TBuilder>;
-
-export type KtValue<TBuilder extends SourceBuilder> =
-  | KtReference<TBuilder>
-  | KtString<TBuilder>
-  | KtCall<TBuilder>
-  | KtObject<TBuilder>
-  | KtLambda<TBuilder>
-  | KtCollectionLiteral<TBuilder>
-  | BasicAppendValue<TBuilder>;

package/src/src/ast/references/index.ts

@@ -1,8 +0,0 @@
-export * as jackson from './jackson.js';
-export * as jakarta from './jakarta.js';
-export * as java from './java.js';
-export * from './kotlin.js';
-export * as okhttp3 from './okhttp3.js';
-export * as reactor from './reactor.js';
-export * as spring from './spring.js';
-export * as swagger from './swagger.js';

package/src/src/ast/references/jackson.ts

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

package/src/src/ast/references/jakarta.ts

@@ -1,14 +0,0 @@
-import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
-
-// jakarta.annotation
-export const generated: KtReferenceFactory = ktReference.factory('Generated', 'jakarta.annotation');
-
-// jakarta.validation
-export const valid: KtReferenceFactory = ktReference.factory('Valid', 'jakarta.validation');
-
-// jakarta.validation.constraints
-export const pattern: KtReferenceFactory = ktReference.factory('Pattern', 'jakarta.validation.constraints');
-export const min: KtReferenceFactory = ktReference.factory('Min', 'jakarta.validation.constraints');
-export const max: KtReferenceFactory = ktReference.factory('Max', 'jakarta.validation.constraints');
-export const notEmpty: KtReferenceFactory = ktReference.factory('NotEmpty', 'jakarta.validation.constraints');
-export const size: KtReferenceFactory = ktReference.factory('Size', 'jakarta.validation.constraints');

package/src/src/ast/references/java.ts

@@ -1,19 +0,0 @@
-import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
-
-// java.io
-export const file: KtReferenceFactory = ktReference.factory('File', 'java.io');
-export const ioException: KtReferenceFactory = ktReference.factory('IOException', 'java.io');
-
-// java.lang
-export const illegalStateException: KtReferenceFactory = ktReference.factory('IllegalStateException', 'java.lang');
-export const system: KtReferenceFactory = ktReference.factory('System', 'java.lang');
-export const unsupportedOperationException: KtReferenceFactory = ktReference.factory(
-  'UnsupportedOperationException',
-  'java.lang',
-);
-
-// java.time
-export const offsetDateTime: KtReferenceFactory = ktReference.factory('OffsetDateTime', 'java.time');
-
-// java.util
-export const optional: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('Optional', 'java.util');

package/src/src/ast/references/kotlin.ts

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

package/src/src/ast/references/okhttp3.ts

@@ -1,5 +0,0 @@
-import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
-
-// okhttp3
-export const okHttpClient: KtReferenceFactory = ktReference.factory('Factory', 'okhttp3.Call');
-export const httpUrl: KtReferenceFactory = ktReference.factory('HttpUrl', 'okhttp3');

package/src/src/ast/references/reactor.ts

@@ -1,5 +0,0 @@
-import { type KtGenericReferenceFactory, ktReference } from '../nodes/reference.js';
-
-// reactor.core.publisher
-export const flux: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('Flux', 'reactor.core.publisher');
-export const mono: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('Mono', 'reactor.core.publisher');

package/src/src/ast/references/spring.ts

@@ -1,72 +0,0 @@
-import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
-
-// org.springframework.beans.factory.annotation
-export const autowired: KtReferenceFactory = ktReference.factory(
-  'Autowired',
-  'org.springframework.beans.factory.annotation',
-);
-
-// org.springframework.http
-export const httpStatus: KtReferenceFactory = ktReference.factory('HttpStatus', 'org.springframework.http');
-export const responseEntity: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>(
-  'ResponseEntity',
-  'org.springframework.http',
-);
-
-// org.springframework.http.codec.multipart
-export const filePart: KtReferenceFactory = ktReference.factory('FilePart', 'org.springframework.http.codec.multipart');
-
-// org.springframework.stereotype
-export const controller: KtReferenceFactory = ktReference.factory('Controller', 'org.springframework.stereotype');
-
-// org.springframework.util
-export const multiValueMap: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>(
-  'MultiValueMap',
-  'org.springframework.util',
-);
-export const linkedMultiValueMap: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>(
-  'LinkedMultiValueMap',
-  'org.springframework.util',
-);
-
-// org.springframework.validation.annotation
-export const validated: KtReferenceFactory = ktReference.factory(
-  'Validated',
-  'org.springframework.validation.annotation',
-);
-
-// org.springframework.web.bind.annotation
-export const pathVariable: KtReferenceFactory = ktReference.factory(
-  'PathVariable',
-  'org.springframework.web.bind.annotation',
-);
-export const requestBody: KtReferenceFactory = ktReference.factory(
-  'RequestBody',
-  'org.springframework.web.bind.annotation',
-);
-export const requestMapping: KtReferenceFactory = ktReference.factory(
-  'RequestMapping',
-  'org.springframework.web.bind.annotation',
-);
-export const requestMethod: KtReferenceFactory = ktReference.factory(
-  'RequestMethod',
-  'org.springframework.web.bind.annotation',
-);
-export const requestParam: KtReferenceFactory = ktReference.factory(
-  'RequestParam',
-  'org.springframework.web.bind.annotation',
-);
-export const requestPart: KtReferenceFactory = ktReference.factory(
-  'RequestPart',
-  'org.springframework.web.bind.annotation',
-);
-export const requestHeader: KtReferenceFactory = ktReference.factory(
-  'RequestHeader',
-  'org.springframework.web.bind.annotation',
-);
-
-// org.springframework.web.context.request
-export const nativeWebRequest: KtReferenceFactory = ktReference.factory(
-  'NativeWebRequest',
-  'org.springframework.web.context.request',
-);

package/src/src/ast/references/swagger.ts

@@ -1,23 +0,0 @@
-import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
-
-// io.swagger.v3.oas.annotations
-export const parameter: KtReferenceFactory = ktReference.factory('Parameter', 'io.swagger.v3.oas.annotations');
-export const operation: KtReferenceFactory = ktReference.factory('Operation', 'io.swagger.v3.oas.annotations');
-
-// io.swagger.v3.oas.annotations.media
-export const schema: KtReferenceFactory = ktReference.factory('Schema', 'io.swagger.v3.oas.annotations.media');
-export const arraySchema: KtReferenceFactory = ktReference.factory(
-  'ArraySchema',
-  'io.swagger.v3.oas.annotations.media',
-);
-export const content: KtReferenceFactory = ktReference.factory('Content', 'io.swagger.v3.oas.annotations.media');
-
-// io.swagger.v3.oas.annotations.responses
-export const apiResponse: KtReferenceFactory = ktReference.factory(
-  'ApiResponse',
-  'io.swagger.v3.oas.annotations.responses',
-);
-export const apiResponses: KtReferenceFactory = ktReference.factory(
-  'ApiResponses',
-  'io.swagger.v3.oas.annotations.responses',
-);

package/src/src/ast/utils/get-kotlin-builder-options.ts

@@ -1,19 +0,0 @@
-import { defaultOpenApiGeneratorConfig, type SourceBuilder } from '@goast/core';
-
-import { defaultKotlinGeneratorConfig, type KotlinGeneratorConfig } from '../../config.js';
-import { KotlinFileBuilder } from '../../file-builder.js';
-
-const ktConfigSymbol = Symbol();
-type _BuilderWithConfig = SourceBuilder & { [ktConfigSymbol]?: KotlinGeneratorConfig };
-
-export function getKotlinBuilderOptions(builder: SourceBuilder): KotlinGeneratorConfig {
-  if (builder instanceof KotlinFileBuilder) {
-    return builder.options;
-  }
-  if (ktConfigSymbol in builder.options) {
-    return builder.options[ktConfigSymbol] as KotlinGeneratorConfig;
-  }
-  const options = { ...defaultOpenApiGeneratorConfig, ...defaultKotlinGeneratorConfig, ...builder.options };
-  (builder as _BuilderWithConfig)[ktConfigSymbol] = options;
-  return options;
-}

package/src/src/ast/utils/to-kt-node.ts

@@ -1,31 +0,0 @@
-import type { BasicAppendValue, SourceBuilder } from '@goast/core';
-
-import { type KtCall, ktCall } from '../nodes/call.js';
-import { type KtString, ktString } from '../nodes/string.js';
-import { listOf, mapOf } from '../references/index.js';
-
-export function toKtNode<TBuilder extends SourceBuilder>(object: Record<string | number, unknown>): KtCall<TBuilder>;
-export function toKtNode<TBuilder extends SourceBuilder>(list: unknown[]): KtCall<TBuilder>;
-export function toKtNode<TBuilder extends SourceBuilder>(string: string): KtString<TBuilder>;
-export function toKtNode<TBuilder extends SourceBuilder>(value: unknown): BasicAppendValue<TBuilder>;
-export function toKtNode<TBuilder extends SourceBuilder>(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return ktCall(
-      [listOf.infer()],
-      value.map((x) => toKtNode<TBuilder>(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/src/src/ast/utils/write-kt-annotations.ts

@@ -1,15 +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 writeKtAnnotations<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
-  options?: { multiline: boolean },
-) {
-  const filteredNodes = toArray(nodes).filter(notNullish);
-  builder.forEach(filteredNodes, (b, a) => {
-    writeKtNode(b, a);
-    b.append(options?.multiline ? '\n' : ' ');
-  });
-}