@goast/kotlin 0.6.0 → 0.7.0-beta.1

package/src/src/ast/nodes/parameter.ts

@@ -1,118 +0,0 @@
-import {
-  type AstNodeOptions,
-  type BasicAppendValue,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtNode } from '../utils/write-kt-node.js';
-import { writeKtParameters } from '../utils/write-kt-parameters.js';
-import { type KtAnnotation, ktAnnotation } from './annotation.js';
-import type { KtType, KtValue } from './types.js';
-
-type Injects = 'modifiers' | 'annotations' | 'name' | 'type' | 'default';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    name: string;
-    type: KtType<TBuilder>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    default?: Nullable<KtValue<TBuilder>>;
-    vararg?: Nullable<boolean>;
-    description?: Nullable<BasicAppendValue<TBuilder>>;
-
-    // class parameter options
-    accessModifier?: Nullable<KtAccessModifier>;
-    property?: Nullable<'readonly' | 'mutable'>;
-    propertyDescription?: Nullable<BasicAppendValue<TBuilder>>;
-    override?: Nullable<boolean>;
-  }
->;
-
-export class KtParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public name: string;
-  public type: KtType<TBuilder>;
-  public annotations: KtAnnotation<TBuilder>[];
-  public default: KtValue<TBuilder> | null;
-  public vararg: boolean;
-  public description: BasicAppendValue<TBuilder> | null;
-
-  // class parameter options
-  public accessModifier: KtAccessModifier | null;
-  public property: 'readonly' | 'mutable' | null;
-  public propertyDescription: BasicAppendValue<TBuilder> | null;
-  public override: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.type = options.type;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.default = options.default ?? null;
-    this.vararg = options.vararg ?? false;
-    this.description = options.description ?? null;
-
-    this.accessModifier = options.accessModifier ?? null;
-    this.property = options.property ?? null;
-    this.propertyDescription = options.propertyDescription ?? null;
-    this.override = options.override ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeAnnotations);
-    ktAnnotation.write(builder, this.annotations, { multiline: true });
-    builder.append(this.inject.afterAnnotations);
-
-    builder.append(this.inject.beforeModifiers);
-    if (this.accessModifier && this.property) builder.append(this.accessModifier, ' ');
-    if (this.override && this.property) builder.append('override ');
-    if (this.vararg) builder.append('vararg ');
-    builder.append(this.inject.afterModifiers);
-
-    if (this.property) builder.append(this.property === 'mutable' ? 'var' : 'val', ' ');
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-
-    builder.append(': ');
-
-    builder.append(this.inject.beforeType);
-    writeKtNode(builder, this.type);
-    builder.append(this.inject.afterType);
-
-    if (this.default) {
-      builder.append(' = ');
-      builder.append(this.inject.beforeDefault);
-      writeKtNode(builder, this.default);
-      builder.append(this.inject.afterDefault);
-    }
-  }
-}
-
-const createParameter = <TBuilder extends SourceBuilder>(
-  name: KtParameter<TBuilder>['name'],
-  type: KtParameter<TBuilder>['type'],
-  options?: Prettify<
-    Omit<Options<TBuilder>, 'name' | 'type' | 'accessModifier' | 'property' | 'propertyDescription' | 'override'>
-  >,
-): KtParameter<TBuilder> => new KtParameter<TBuilder>({ ...options, name, type });
-
-const createClassParameter = <TBuilder extends SourceBuilder>(
-  name: KtParameter<TBuilder>['name'],
-  type: KtParameter<TBuilder>['type'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type'>>,
-): KtParameter<TBuilder> => new KtParameter<TBuilder>({ ...options, name, type });
-
-export const ktParameter: typeof createParameter & {
-  class: typeof createClassParameter;
-  write: typeof writeKtParameters;
-} = Object.assign(createParameter, {
-  class: createClassParameter,
-  write: writeKtParameters,
-});

package/src/src/ast/nodes/property.ts

@@ -1,225 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation, ktAnnotation } from './annotation.js';
-import { type KtArgument, ktArgument } from './argument.js';
-import type { KtDoc } from './doc.js';
-import type { KtType, KtValue } from './types.js';
-
-type AccessorInjects = 'annotations' | 'modifiers' | 'params' | 'body';
-
-type AccessorOptions<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | AccessorInjects>,
-  {
-    accessModifier?: Nullable<KtAccessModifier>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    body?: Nullable<AppendValue<TBuilder>>;
-    singleExpression?: Nullable<boolean>;
-  }
->;
-
-export abstract class KtPropertyAccessor<
-  TBuilder extends SourceBuilder,
-  TInjects extends string = never,
-> extends KtNode<TBuilder, TInjects | AccessorInjects> {
-  public abstract get kind(): 'get' | 'set';
-  public accessModifier: KtAccessModifier | null;
-  public annotations: KtAnnotation<TBuilder>[];
-  public body: AppendValue<TBuilder> | null;
-  public singleExpression: boolean;
-
-  constructor(options: AccessorOptions<TBuilder, TInjects>) {
-    super(options);
-    this.accessModifier = options.accessModifier ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.body = options.body ?? null;
-    this.singleExpression = options.singleExpression ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeAnnotations);
-    ktAnnotation.write(builder, this.annotations, { multiline: true });
-    builder.append(this.inject.afterAnnotations);
-
-    builder.append(this.inject.beforeModifiers);
-    if (this.accessModifier) builder.append(this.accessModifier, ' ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append(this.kind);
-
-    if (this.body) {
-      builder.append(this.inject.beforeParams);
-      builder.append(this.kind === 'set' ? '(value)' : '()');
-      builder.append(this.inject.afterParams);
-
-      if (this.singleExpression) {
-        builder.append(' = ', this.inject.beforeBody);
-        builder.indent(this.body);
-      } else {
-        builder.append(' ', this.inject.beforeBody);
-        builder.parenthesize('{}', this.body, { multiline: true });
-      }
-      builder.append(this.inject.afterBody);
-    }
-
-    builder.appendLine();
-  }
-}
-export class KtPropertyGetter<TBuilder extends SourceBuilder> extends KtPropertyAccessor<TBuilder> {
-  public override readonly kind = 'get' as const;
-}
-export class KtPropertySetter<TBuilder extends SourceBuilder> extends KtPropertyAccessor<TBuilder> {
-  public override readonly kind = 'set' as const;
-}
-
-type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'type' | 'default' | 'delegate';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    doc?: Nullable<KtDoc<TBuilder>>;
-    name: string;
-    type?: KtType<TBuilder>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    accessModifier?: Nullable<KtAccessModifier>;
-    getter?: Nullable<KtPropertyGetter<TBuilder>>;
-    setter?: Nullable<KtPropertySetter<TBuilder>>;
-    default?: Nullable<KtValue<TBuilder>>;
-    delegate?: Nullable<KtType<TBuilder>>;
-    delegateArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
-    mutable?: Nullable<boolean>;
-    const?: Nullable<boolean>;
-    lateinit?: Nullable<boolean>;
-    open?: Nullable<boolean>;
-    override?: Nullable<boolean>;
-    abstract?: Nullable<boolean>;
-  }
->;
-
-export class KtProperty<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public doc: KtDoc<TBuilder> | null;
-  public name: string;
-  public type: KtType<TBuilder> | null;
-  public annotations: KtAnnotation<TBuilder>[];
-  public accessModifier: KtAccessModifier | null;
-  public getter: KtPropertyGetter<TBuilder> | null;
-  public setter: KtPropertySetter<TBuilder> | null;
-  public default: KtValue<TBuilder> | null;
-  public delegate: KtType<TBuilder> | null;
-  public delegateArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[] | null;
-  public mutable: boolean;
-  public const: boolean;
-  public lateinit: boolean;
-  public open: boolean;
-  public override: boolean;
-  public abstract: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.doc = options.doc ?? null;
-    this.name = options.name;
-    this.type = options.type ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.accessModifier = options.accessModifier ?? null;
-    this.getter = options.getter ?? null;
-    this.setter = options.setter ?? null;
-    this.default = options.default ?? null;
-    this.delegate = options.delegate ?? null;
-    this.delegateArguments = options.delegateArguments?.filter(notNullish) ?? null;
-    this.mutable = options.mutable ?? false;
-    this.const = options.const ?? false;
-    this.lateinit = options.lateinit ?? false;
-    this.open = options.open ?? false;
-    this.override = options.override ?? false;
-    this.abstract = options.abstract ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeDoc);
-    this.doc?.write(builder);
-    builder.append(this.inject.afterDoc);
-
-    builder.append(this.inject.beforeAnnotations);
-    ktAnnotation.write(builder, this.annotations, { multiline: true });
-    builder.append(this.inject.afterAnnotations);
-
-    builder.append(this.inject.beforeModifiers);
-    if (this.accessModifier) builder.append(this.accessModifier, ' ');
-    if (this.const) builder.append('const ');
-    if (this.lateinit) builder.append('lateinit ');
-    if (this.abstract) builder.append('abstract ');
-    if (this.override) builder.append('override ');
-    if (this.open) builder.append('open ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append(this.mutable || !!this.setter ? 'var ' : 'val ');
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-
-    if (this.type || (!this.default && !this.getter?.body)) {
-      builder.append(': ', this.inject.beforeType);
-      writeKtNode(builder, this.type ?? 'Any?');
-      builder.append(this.inject.afterType);
-    }
-
-    if (this.default) {
-      builder.append(' = ', this.inject.beforeDefault);
-      writeKtNode(builder, this.default);
-      builder.append(this.inject.afterDefault);
-    }
-
-    if (this.delegate) {
-      builder.append(' by ', this.inject.beforeDelegate);
-      writeKtNode(builder, this.delegate);
-      if (this.delegateArguments) {
-        ktArgument.write(builder, this.delegateArguments);
-      }
-      builder.append(this.inject.afterDelegate);
-    }
-
-    builder.appendLine();
-
-    if (this.getter || this.setter) {
-      builder.indent((b) => {
-        this.getter?.write(b);
-        this.setter?.write(b);
-      });
-    }
-
-    builder.ensureCurrentLineEmpty();
-  }
-}
-
-const createPropertyGetter = <TBuilder extends SourceBuilder>(
-  options?: AccessorOptions<TBuilder>,
-): KtPropertyGetter<TBuilder> => new KtPropertyGetter<TBuilder>(options ?? {});
-
-const createPropertySetter = <TBuilder extends SourceBuilder>(
-  options?: AccessorOptions<TBuilder>,
-): KtPropertySetter<TBuilder> => new KtPropertySetter<TBuilder>(options ?? {});
-
-const createProperty = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): KtProperty<TBuilder> => new KtProperty<TBuilder>({ ...options, name });
-
-export const ktProperty: typeof createProperty & {
-  getter: typeof createPropertyGetter;
-  setter: typeof createPropertySetter;
-  write: typeof writeKtNodes;
-} = Object.assign(createProperty, {
-  getter: createPropertyGetter,
-  setter: createPropertySetter,
-  write: writeKtNodes,
-});

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.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,10 +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 kotlinx from './kotlinx.js';
-export * as okhttp3 from './okhttp3.js';
-export * as reactor from './reactor.js';
-export * as springReactive from './spring-reactive.js';
-export * as spring from './spring.js';
-export * as swagger from './swagger.js';