@goast/kotlin 0.4.10 → 0.4.12-beta1

package/src/mod.ts

@@ -1,8 +0,0 @@
-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

@@ -1,9 +0,0 @@
-import { AssetManager } from '@goast/core';
-import { pathToFileURL, URL } 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

@@ -1,66 +0,0 @@
-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

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

package/src/src/ast/index.ts

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

package/src/src/ast/node.ts

@@ -1,10 +0,0 @@
-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

@@ -1,69 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.13/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/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

@@ -1,79 +0,0 @@
-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

@@ -1,41 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.13/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/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

@@ -1,62 +0,0 @@
-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

@@ -1,44 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.13/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/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

@@ -1,66 +0,0 @@
-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,
-});