@goast/kotlin 0.4.7-beta2 → 0.4.8

package/src/mod.ts

@@ -0,0 +1,8 @@
+export * from './src/ast/index.js';
+export * from './src/common-results.js';
+export * from './src/config.js';
+export * from './src/file-builder.js';
+export * from './src/generators/index.js';
+export * from './src/import-collection.js';
+export * from './src/types.js';
+export * from './src/utils.js';

package/src/src/assets.ts

@@ -0,0 +1,9 @@
+import { AssetManager } from '@goast/core';
+import { pathToFileURL } from 'node:url';
+
+declare const __filename: string | undefined;
+const scriptUrl = typeof __filename === 'undefined' ? import.meta.url : pathToFileURL(__filename);
+
+const manager = new AssetManager(new URL('../assets/', scriptUrl));
+export const getAssetFileContent = manager.getAssetFileContent.bind(manager);
+export const copyAssetFile = manager.copyAssetFile.bind(manager);

package/src/src/ast/_index.ts

@@ -0,0 +1,66 @@
+export { type KtAccessModifier as AccessModifier } from './common.js';
+export { KtNode as Node } from './node.js';
+export {
+  KtAnnotation as Annotation,
+  ktAnnotation as annotation,
+  type KtAnnotationTarget as AnnotationTarget,
+} from './nodes/annotation.js';
+export { KtArgument as Argument, ktArgument as argument } from './nodes/argument.js';
+export { KtCall as Call, ktCall as call } from './nodes/call.js';
+export {
+  KtClass as Class,
+  ktClass as class,
+  type KtClassKind as ClassKind,
+  type KtClassMember as ClassMember,
+} from './nodes/class.js';
+export {
+  KtCollectionLiteral as CollectionLiteral,
+  ktCollectionLiteral as collectionLiteral,
+} from './nodes/collection-literal.js';
+export {
+  KtConstructor as Constructor,
+  ktConstructor as constructor,
+  type KtDelegateTarget as DelegateTarget,
+} from './nodes/constructor.js';
+export { KtDocTag as DocTag, ktDocTag as docTag } from './nodes/doc-tag.js';
+export { KtDoc as Doc, ktDoc as doc } from './nodes/doc.js';
+export {
+  KtEnumValue as EnumValue,
+  ktEnumValue as enumValue,
+  type KtEnumValueMember as EnumValueMember,
+} from './nodes/enum-value.js';
+export { KtEnum as Enum, ktEnum as enum, type KtEnumMember as EnumMember } from './nodes/enum.js';
+export { KtFunction as Function, ktFunction as function } from './nodes/function.js';
+export {
+  KtGenericParameter as GenericParameter,
+  ktGenericParameter as genericParameter,
+} from './nodes/generic-parameter.js';
+export { KtInitBlock as InitBlock, ktInitBlock as initBlock } from './nodes/init-block.js';
+export {
+  KtInterface as Interface,
+  ktInterface as interface,
+  type KtInterfaceMember as InterfaceMember,
+} from './nodes/interface.js';
+export { KtLambdaType as LambdaType, ktLambdaType as lambdaType } from './nodes/lambda-type.js';
+export { KtLambda as Lambda, ktLambda as lambda } from './nodes/lambda.js';
+export { KtObject as Object, ktObject as object, type KtObjectMember as ObjectMember } from './nodes/object.js';
+export { KtParameter as Parameter, ktParameter as parameter } from './nodes/parameter.js';
+export {
+  KtProperty as Property,
+  ktProperty as property,
+  KtPropertyAccessor as PropertyAccessor,
+  KtPropertyGetter as PropertyGetter,
+  KtPropertySetter as PropertySetter,
+} from './nodes/property.js';
+export {
+  type KtGenericReferenceFactory as GenericReferenceFactory,
+  KtReference as Reference,
+  ktReference as reference,
+  type KtReferenceFactory as ReferenceFactory,
+} from './nodes/reference.js';
+export { KtString as String, ktString as string } from './nodes/string.js';
+export { type KtType as Type, type KtValue as Value } from './nodes/types.js';
+export * as refs from './references/index.js';
+export { getKotlinBuilderOptions as getBuilderOptions } from './utils/get-kotlin-builder-options.js';
+export { toKtNode as toNode } from './utils/to-kt-node.js';
+export { writeKtNode as writeNode, writeKtNodes as writeNodes } from './utils/write-kt-node.js';

package/src/src/ast/common.ts

@@ -0,0 +1 @@
+export type KtAccessModifier = 'public' | 'protected' | 'internal' | 'private';

package/src/src/ast/index.ts

@@ -0,0 +1 @@
+export * as kt from './_index.js';

package/src/src/ast/node.ts

@@ -0,0 +1,10 @@
+import { AstNode, type AstNodeOptions, type SourceBuilder } from '@goast/core';
+
+export abstract class KtNode<TBuilder extends SourceBuilder, TInjects extends string = never> extends AstNode<
+  TBuilder,
+  TInjects
+> {
+  constructor(options: AstNodeOptions<typeof AstNode<TBuilder, TInjects>>) {
+    super(options);
+  }
+}

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

@@ -0,0 +1,69 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.9/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.6/bdd.js';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktAnnotation } from './annotation.js';
+
+describe('ktAnnotation', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  describe('single', () => {
+    it('should write an annotation without parameters', () => {
+      builder.append(ktAnnotation('Test'));
+      expect(builder.toString(false)).toBe('@Test');
+    });
+
+    it('should write an annotation with parameters', () => {
+      builder.append(ktAnnotation('Test', ['Param']));
+      expect(builder.toString(false)).toBe('@Test(Param)');
+    });
+
+    it('should write an annotation with target', () => {
+      builder.append(ktAnnotation('Test', [], { target: 'property' }));
+      expect(builder.toString(false)).toBe('@property:Test');
+    });
+
+    it('should write an annotation with all options', () => {
+      builder.append(ktAnnotation('Test', ['Param'], { target: 'property' }));
+      expect(builder.toString(false)).toBe('@property:Test(Param)');
+    });
+
+    it('should render injections', () => {
+      builder.append(
+        ktAnnotation('Test', ['Param'], {
+          target: 'property',
+          inject: {
+            before: '║b║',
+            after: '║a║',
+            beforeTarget: '║bt║',
+            afterTarget: '║at║',
+            beforeClass: '║bc║',
+            afterClass: '║ac║',
+            beforeArguments: '║ba║',
+            afterArguments: '║aa║',
+          },
+        }),
+      );
+      expect(builder.toString(false)).toBe('║b║@║bt║property║at║:║bc║Test║ac║║ba║(Param)║aa║║a║');
+    });
+  });
+
+  describe('multiple', () => {
+    it('should write annotations across multiple lines', () => {
+      ktAnnotation.write(builder, [ktAnnotation('Test'), ktAnnotation('Test')], { multiline: true });
+      expect(builder.toString(false)).toBe(`@Test${EOL}@Test${EOL}`);
+    });
+
+    it('should write annotations on the same line', () => {
+      ktAnnotation.write(builder, [ktAnnotation('Test'), ktAnnotation('Test')], { multiline: false });
+      expect(builder.toString(false)).toBe('@Test @Test ');
+    });
+  });
+});

package/src/src/ast/nodes/annotation.ts

@@ -0,0 +1,79 @@
+import { type AstNodeOptions, notNullish, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
+
+import { KtNode } from '../node.js';
+import { writeKtAnnotations } from '../utils/write-kt-annotations.js';
+import { writeKtNode } from '../utils/write-kt-node.js';
+import { type KtArgument, ktArgument } from './argument.js';
+import type { KtType, KtValue } from './types.js';
+
+type Injects = 'class' | 'target' | 'arguments';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    class: KtType<TBuilder>;
+    arguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+    target?: Nullable<KtAnnotationTarget>;
+  }
+>;
+
+export type KtAnnotationTarget =
+  | 'file'
+  | 'property'
+  | 'field'
+  | 'get'
+  | 'set'
+  | 'receiver'
+  | 'param'
+  | 'setparam'
+  | 'delegate';
+
+export class KtAnnotation<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public class: KtType<TBuilder>;
+  public arguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
+  public target: KtAnnotationTarget | null;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.class = options.class;
+    this.arguments = options.arguments?.filter(notNullish) ?? [];
+    this.target = options.target ?? null;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    builder.append('@');
+
+    if (this.target) {
+      builder.append(this.inject.beforeTarget);
+      builder.append(this.target);
+      builder.append(this.inject.afterTarget);
+      builder.append(':');
+    }
+
+    builder.append(this.inject.beforeClass);
+    writeKtNode(builder, this.class);
+    builder.append(this.inject.afterClass);
+
+    if (this.arguments.length > 0) {
+      builder.append(this.inject.beforeArguments);
+      ktArgument.write(builder, this.arguments);
+      builder.append(this.inject.afterArguments);
+    }
+  }
+}
+
+const createAnnotation = <TBuilder extends SourceBuilder>(
+  $class: Options<TBuilder>['class'],
+  $arguments?: Options<TBuilder>['arguments'],
+  options?: Prettify<Omit<Options<TBuilder>, 'class' | 'arguments'>>,
+): KtAnnotation<TBuilder> => new KtAnnotation<TBuilder>({ ...options, class: $class, arguments: $arguments });
+
+export const ktAnnotation: typeof createAnnotation & { write: typeof writeKtAnnotations } = Object.assign(
+  createAnnotation,
+  {
+    write: writeKtAnnotations,
+  },
+);

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

@@ -0,0 +1,41 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.9/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.6/bdd.js';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktArgument } from './argument.js';
+
+describe('ktArgument', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write argument', () => {
+    builder.append(ktArgument('123'));
+    expect(builder.toString(false)).toBe('123');
+  });
+
+  it('should write argument with name', () => {
+    builder.append(ktArgument('123', { name: 'y' }));
+    expect(builder.toString(false)).toBe('y = 123');
+  });
+
+  it('should render injections', () => {
+    builder.append(
+      ktArgument('123', {
+        name: 'y',
+        inject: {
+          before: '║b║',
+          after: '║a║',
+          beforeName: '║bn║',
+          afterName: '║an║',
+          beforeValue: '║bv║',
+          afterValue: '║av║',
+        },
+      }),
+    );
+    expect(builder.toString(false)).toBe('║b║║bn║y║an║ = ║bv║123║av║║a║');
+  });
+});

package/src/src/ast/nodes/argument.ts

@@ -0,0 +1,62 @@
+import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+
+import { KtNode } from '../node.js';
+import { writeKtArguments } from '../utils/write-kt-arguments.js';
+import { writeKtNode } from '../utils/write-kt-node.js';
+import type { KtValue } from './types.js';
+
+type Injects = 'name' | 'value';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    name?: Nullable<string>;
+    value: KtValue<TBuilder>;
+  }
+>;
+
+export class KtArgument<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public name: string | null;
+  public value: KtValue<TBuilder>;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.name = options?.name ?? null;
+    this.value = options.value;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    if (this.name) {
+      builder.append(this.inject.beforeName);
+      builder.append(this.name);
+      builder.append(this.inject.afterName);
+      builder.append(' = ');
+    }
+
+    builder.append(this.inject.beforeValue);
+    writeKtNode(builder, this.value);
+    builder.append(this.inject.afterValue);
+  }
+}
+
+const createArgument = <TBuilder extends SourceBuilder>(
+  value: Options<TBuilder>['value'],
+  options?: Prettify<Omit<Options<TBuilder>, 'value'>>,
+): KtArgument<TBuilder> => new KtArgument<TBuilder>({ ...options, value });
+
+const createNamedArgument = <TBuilder extends SourceBuilder>(
+  name: Options<TBuilder>['name'],
+  value: Options<TBuilder>['value'],
+  options?: Prettify<Omit<Options<TBuilder>, 'value' | 'name'>>,
+): KtArgument<TBuilder> => new KtArgument<TBuilder>({ ...options, value, name });
+
+export const ktArgument: typeof createArgument & {
+  named: typeof createNamedArgument;
+  write: typeof writeKtArguments;
+} = Object.assign(createArgument, {
+  named: createNamedArgument,
+  write: writeKtArguments,
+});

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

@@ -0,0 +1,44 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.9/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.6/bdd.js';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktCall } from './call.js';
+
+describe('ktCall', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write call with single path', () => {
+    builder.append(ktCall(['foo']));
+    expect(builder.toString(false)).toBe('foo');
+  });
+
+  it('should write call with multiple path', () => {
+    builder.append(ktCall(['foo', 'bar']));
+    expect(builder.toString(false)).toBe('foo.bar');
+  });
+
+  it('should write call with no arguments', () => {
+    builder.append(ktCall(['foo'], []));
+    expect(builder.toString(false)).toBe('foo()');
+  });
+
+  it('should write call with single argument', () => {
+    builder.append(ktCall(['foo'], ['bar']));
+    expect(builder.toString(false)).toBe('foo(bar)');
+  });
+
+  it('should write call with multiple arguments', () => {
+    builder.append(ktCall(['foo'], ['bar', 'baz']));
+    expect(builder.toString(false)).toBe('foo(bar, baz)');
+  });
+
+  it('should render injections', () => {
+    builder.append(ktCall(['foo'], null, { inject: { before: '║b║', after: '║a║' } }));
+    expect(builder.toString(false)).toBe('║b║foo║a║');
+  });
+});

package/src/src/ast/nodes/call.ts

@@ -0,0 +1,66 @@
+import {
+  type ArrayItem,
+  type AstNodeOptions,
+  notNullish,
+  type Nullable,
+  type Prettify,
+  type SourceBuilder,
+} from '@goast/core';
+
+import { KtNode } from '../node.js';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
+import { type KtArgument, ktArgument } from './argument.js';
+import type { KtType, KtValue } from './types.js';
+
+type Injects = never;
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    path: Nullable<KtType<TBuilder> | KtValue<TBuilder>>[];
+    arguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+    infix?: boolean;
+  }
+>;
+
+export class KtCall<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public path: (KtType<TBuilder> | KtValue<TBuilder>)[];
+  public arguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[] | null;
+  public infix: boolean;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.path = options.path.filter(notNullish);
+    this.arguments = options.arguments?.filter(notNullish) ?? null;
+    this.infix = options.infix ?? false;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    if (this.infix && this.arguments?.length === 1 && this.path.length > 1) {
+      writeKtNodes(builder, this.path.slice(0, 1), { separator: '.' });
+      builder.append(' ');
+      writeKtNode(builder, this.path.at(-1));
+      builder.append(' ');
+      writeKtNode(builder, this.arguments[0]);
+    } else {
+      writeKtNodes(builder, this.path, { separator: '.' });
+
+      if (this.arguments) {
+        ktArgument.write(builder, this.arguments);
+      }
+    }
+  }
+}
+
+const createCall = <TBuilder extends SourceBuilder>(
+  path: Options<TBuilder>['path'] | ArrayItem<Options<TBuilder>['path']>,
+  args?: Options<TBuilder>['arguments'],
+  options?: Prettify<Omit<Options<TBuilder>, 'path' | 'arguments'>>,
+): KtCall<TBuilder> => new KtCall<TBuilder>({ ...options, path: Array.isArray(path) ? path : [path], arguments: args });
+
+export const ktCall: typeof createCall & { write: typeof writeKtNodes } = Object.assign(createCall, {
+  write: writeKtNodes,
+});