@goast/kotlin 0.4.6 → 0.4.7-beta2

package/esm/src/ast/nodes/enum-value.test.js

@@ -1,115 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/bdd.js';
-import { normalizeEOL } from '@goast/test-utils';
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktAnnotation } from './annotation.js';
-import { ktDoc } from './doc.js';
-import { ktEnumValue } from './enum-value.js';
-describe('ktEnumValue', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write enum value', () => {
-        builder.append(ktEnumValue('FOO'));
-        expect(builder.toString(false)).toBe('FOO');
-    });
-    it('should write enum value with arguments', () => {
-        builder.append(ktEnumValue('FOO', { arguments: ['x', 'y'] }));
-        expect(builder.toString(false)).toBe('FOO(x, y)');
-    });
-    it('should write enum value with documenation', () => {
-        builder.append(ktEnumValue('FOO', { doc: ktDoc('This is a foo') }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * This is a foo${EOL} */${EOL}FOO`);
-    });
-    it('should write enum value with annotations', () => {
-        builder.append(ktEnumValue('FOO', { annotations: [ktAnnotation('Deprecated')] }));
-        expect(builder.toString(false)).toBe(`@Deprecated${EOL}FOO`);
-    });
-    it('should write enum value with members', () => {
-        builder.append(ktEnumValue('FOO', {
-            members: ['// Comment 1', '// Comment 2'],
-        }));
-        expect(builder.toString(false)).toBe(`FOO {${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}`);
-    });
-    it('should write enum value with all options', () => {
-        builder.append(ktEnumValue('FOO', {
-            doc: ktDoc('This is a foo'),
-            annotations: [ktAnnotation('Deprecated')],
-            arguments: ['x', 'y'],
-            members: ['// Comment 1', '// Comment 2'],
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
-         * This is a foo
-         */
-        @Deprecated
-        FOO(x, y) {
-            // Comment 1
-            // Comment 2
-        }`));
-    });
-    it('should render injections', () => {
-        builder.append(ktEnumValue('FOO', {
-            doc: ktDoc('This is a foo'),
-            annotations: [ktAnnotation('Deprecated')],
-            arguments: ['x', 'y'],
-            members: ['// Comment 1', '// Comment 2'],
-            inject: {
-                before: '║b║',
-                after: '║a║',
-                beforeDoc: '║bd║',
-                afterDoc: '║ad║',
-                beforeAnnotations: '║ba║',
-                afterAnnotations: '║aa║',
-                beforeName: '║bn║',
-                afterName: '║an║',
-                beforeArguments: '║ba║',
-                afterArguments: '║aa║',
-                beforeBody: '║bb║',
-                afterBody: '║ab║',
-                beforeMembers: '║bm║',
-                afterMembers: '║am║',
-            },
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
-        /**
-         * This is a foo
-         */
-        ║ad║║ba║@Deprecated
-        ║aa║║bn║FOO║an║║ba║(x, y)║aa║ ║bb║{
-            ║bm║// Comment 1
-            // Comment 2
-            ║am║
-        }║ab║║a║`));
-    });
-});
-describe('writeKtEnumValues', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write enum values in single line', () => {
-        ktEnumValue.write(builder, [ktEnumValue('FOO'), ktEnumValue('BAR')]);
-        expect(builder.toString(false)).toBe('FOO, BAR');
-    });
-    it('should write enum values in multiline', () => {
-        ktEnumValue.write(builder, [
-            ktEnumValue('FOO'),
-            ktEnumValue('BAR'),
-            ktEnumValue('BAZ'),
-            ktEnumValue('QUX'),
-            ktEnumValue('QUUX'),
-        ]);
-        expect(builder.toString(false)).toBe(`FOO,${EOL}BAR,${EOL}BAZ,${EOL}QUX,${EOL}QUUX`);
-    });
-    it('should write enum values with space between', () => {
-        ktEnumValue.write(builder, [
-            ktEnumValue('FOO'),
-            ktEnumValue('BAR', { annotations: [ktAnnotation('Deprecated')] }),
-            ktEnumValue('BAZ'),
-        ]);
-        expect(builder.toString(false)).toBe(`FOO,${EOL}${EOL}@Deprecated${EOL}BAR,${EOL}${EOL}BAZ`);
-    });
-});

package/esm/src/ast/nodes/enum.test.d.ts

@@ -1,2 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-//# sourceMappingURL=enum.test.d.ts.map

package/esm/src/ast/nodes/enum.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"enum.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/enum.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/enum.test.js

@@ -1,129 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/bdd.js';
-import { normalizeEOL } from '@goast/test-utils';
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktAnnotation } from './annotation.js';
-import { ktConstructor } from './constructor.js';
-import { ktDoc } from './doc.js';
-import { ktEnumValue } from './enum-value.js';
-import { ktEnum } from './enum.js';
-import { ktObject } from './object.js';
-import { ktParameter } from './parameter.js';
-describe('ktEnum', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write enum', () => {
-        builder.append(ktEnum('Foo'));
-        expect(builder.toString(false)).toBe(`enum class Foo${EOL}`);
-    });
-    it('should write enum with values', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR'), ktEnumValue('BAZ')]));
-        expect(builder.toString(false)).toBe(`enum class Foo {${EOL}    BAR, BAZ${EOL}}${EOL}`);
-    });
-    it('should write documenation', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { doc: ktDoc('This is a foo') }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * This is a foo${EOL} */${EOL}enum class Foo {${EOL}    BAR${EOL}}${EOL}`);
-    });
-    it('should write annotations', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { annotations: [ktAnnotation('Deprecated')] }));
-        expect(builder.toString(false)).toBe(`@Deprecated${EOL}enum class Foo {${EOL}    BAR${EOL}}${EOL}`);
-    });
-    it('should write access modifiers', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { accessModifier: 'private' }));
-        expect(builder.toString(false)).toBe(`private enum class Foo {${EOL}    BAR${EOL}}${EOL}`);
-    });
-    it('should write primary constructor', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
-            primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
-        }));
-        expect(builder.toString(false)).toBe(`enum class Foo(x: Int, y: Int) {${EOL}    BAR(0, 1)${EOL}}${EOL}`);
-    });
-    it('should write members', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR'), ktEnumValue('BAZ')], { members: ['// Comment 1', '// Comment 2'] }));
-        expect(builder.toString(false)).toBe(`enum class Foo {${EOL}    BAR, BAZ;${EOL}${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}${EOL}`);
-    });
-    it('should write implemented interfaces', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { implements: ['Bar', 'Baz'] }));
-        expect(builder.toString(false)).toBe(`enum class Foo : Bar, Baz {${EOL}    BAR${EOL}}${EOL}`);
-    });
-    it('should write companion object', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { companionObject: ktObject() }));
-        expect(builder.toString(false)).toBe(`enum class Foo {${EOL}    BAR;${EOL}${EOL}    companion object {}${EOL}}${EOL}`);
-    });
-    it('should write all options', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
-            doc: ktDoc('This is a foo'),
-            annotations: [ktAnnotation('Deprecated')],
-            accessModifier: 'private',
-            primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
-            implements: ['Bar', 'Baz'],
-            members: ['// Comment 1', '// Comment 2'],
-            companionObject: ktObject(),
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
-         * This is a foo
-         */
-        @Deprecated
-        private enum class Foo(x: Int, y: Int) : Bar, Baz {
-            BAR(0, 1);
-
-            companion object {}
-
-            // Comment 1
-            // Comment 2
-        }
-        `));
-    });
-    it('should render injections', () => {
-        builder.append(ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
-            doc: ktDoc('This is a foo'),
-            annotations: [ktAnnotation('Deprecated')],
-            accessModifier: 'private',
-            primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
-            implements: ['Bar', 'Baz'],
-            members: ['// Comment 1', '// Comment 2'],
-            companionObject: ktObject(),
-            inject: {
-                before: '║b║',
-                after: '║a║',
-                beforeDoc: '║bd║',
-                afterDoc: '║ad║',
-                beforeAnnotations: '║ba║',
-                afterAnnotations: '║aa║',
-                beforeModifiers: '║bm║',
-                afterModifiers: '║am║',
-                beforeName: '║bn║',
-                afterName: '║an║',
-                beforePrimaryConstructor: '║bpc║',
-                afterPrimaryConstructor: '║apc║',
-                beforeImplements: '║bi║',
-                afterImplements: '║ai║',
-                beforeBody: '║bb║',
-                afterBody: '║ab║',
-                beforeValues: '║bv║',
-                afterValues: '║av║',
-                beforeMembers: '║bm║',
-                afterMembers: '║am║',
-            },
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
-        /**
-         * This is a foo
-         */
-        ║ad║║ba║@Deprecated
-        ║aa║║bm║private ║am║enum class ║bn║Foo║an║║bpc║(x: Int, y: Int)║apc║ : ║bi║Bar, Baz║ai║ ║bb║{
-            ║bv║BAR(0, 1);
-
-            ║av║║bm║companion object {}
-
-            // Comment 1
-            // Comment 2
-            ║am║
-        }║ab║
-        ║a║`));
-    });
-});

package/esm/src/ast/nodes/function.test.d.ts

@@ -1,2 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-//# sourceMappingURL=function.test.d.ts.map

package/esm/src/ast/nodes/function.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/function.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/function.test.js

@@ -1,160 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/bdd.js';
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktAnnotation } from './annotation.js';
-import { ktDoc } from './doc.js';
-import { ktFunction } from './function.js';
-import { ktGenericParameter } from './generic-parameter.js';
-import { ktParameter } from './parameter.js';
-describe('ktFunction', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write an empty function', () => {
-        builder.append(ktFunction('foo'));
-        expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
-    });
-    it('should write a function with generics', () => {
-        builder.append(ktFunction('foo', { generics: [ktGenericParameter('T')] }));
-        expect(builder.toString(false)).toBe(`fun <T> foo() {}${EOL}`);
-    });
-    it('should write a function with a single parameter', () => {
-        builder.append(ktFunction('foo', { parameters: [ktParameter('x', 'Int')] }));
-        expect(builder.toString(false)).toBe(`fun foo(x: Int) {}${EOL}`);
-    });
-    it('should write a function with a return type', () => {
-        builder.append(ktFunction('foo', { returnType: 'Int' }));
-        expect(builder.toString(false)).toBe(`fun foo(): Int {}${EOL}`);
-    });
-    it('should write a function with a body', () => {
-        builder.append(ktFunction('foo', { body: 'println("Hello")' }));
-        expect(builder.toString(false)).toBe(`fun foo() {${EOL}    println("Hello")${EOL}}${EOL}`);
-    });
-    it('should write access modifiers if they exist', () => {
-        builder.append(ktFunction('foo', { accessModifier: 'private' }));
-        expect(builder.toString(false)).toBe(`private fun foo() {}${EOL}`);
-    });
-    it('should write all annotations', () => {
-        builder.append(ktFunction('foo', { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
-        expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}fun foo() {}${EOL}`);
-    });
-    it('should write receiver type if it exists', () => {
-        builder.append(ktFunction('foo', { receiverType: 'String' }));
-        expect(builder.toString(false)).toBe(`fun String.foo() {}${EOL}`);
-    });
-    it('should write receiver annotations if they exist and a receiver type exists', () => {
-        builder.append(ktFunction('foo', { receiverType: 'String', receiverAnnotations: [ktAnnotation('Fancy')] }));
-        expect(builder.toString(false)).toBe(`fun @Fancy String.foo() {}${EOL}`);
-    });
-    it('shoudl not write receiver annotations if they exist and a receiver type does not exist', () => {
-        builder.append(ktFunction('foo', { receiverAnnotations: [ktAnnotation('Fancy')] }));
-        expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
-    });
-    it('should write single expression if configured and body exists', () => {
-        builder.append(ktFunction('foo', { body: '42', singleExpression: true }));
-        expect(builder.toString(false)).toBe(`fun foo() = 42${EOL}`);
-    });
-    it('should not write single expression if configured and body does not exist', () => {
-        builder.append(ktFunction('foo', { singleExpression: true }));
-        expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
-    });
-    it('should write open keyword if configured', () => {
-        builder.append(ktFunction('foo', { open: true }));
-        expect(builder.toString(false)).toBe(`open fun foo() {}${EOL}`);
-    });
-    it('should write inline keyword if configured', () => {
-        builder.append(ktFunction('foo', { inline: true }));
-        expect(builder.toString(false)).toBe(`inline fun foo() {}${EOL}`);
-    });
-    it('should write infix keyword if configured', () => {
-        builder.append(ktFunction('foo', { infix: true }));
-        expect(builder.toString(false)).toBe(`infix fun foo() {}${EOL}`);
-    });
-    it('should write tailrec keyword if configured', () => {
-        builder.append(ktFunction('foo', { tailrec: true }));
-        expect(builder.toString(false)).toBe(`tailrec fun foo() {}${EOL}`);
-    });
-    it('should write operator keyword if configured', () => {
-        builder.append(ktFunction('foo', { operator: true }));
-        expect(builder.toString(false)).toBe(`operator fun foo() {}${EOL}`);
-    });
-    it('should write override keyword if configured', () => {
-        builder.append(ktFunction('foo', { override: true }));
-        expect(builder.toString(false)).toBe(`override fun foo() {}${EOL}`);
-    });
-    it('should write abstract keyword if configured', () => {
-        builder.append(ktFunction('foo', { abstract: true }));
-        expect(builder.toString(false)).toBe(`abstract fun foo()${EOL}`);
-    });
-    it('should write documenation if it exists', () => {
-        builder.append(ktFunction('foo', { doc: ktDoc('This is a function') }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * This is a function${EOL} */${EOL}fun foo() {}${EOL}`);
-    });
-    it('should write all the parts of the function', () => {
-        builder.append(ktFunction('foo', {
-            generics: [ktGenericParameter('T')],
-            parameters: [ktParameter('x', 'Int')],
-            returnType: 'Int',
-            doc: ktDoc('This is a function'),
-            body: 'println("Hello")',
-            accessModifier: 'private',
-            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-            receiverType: 'String',
-            receiverAnnotations: [ktAnnotation('Fancy')],
-            singleExpression: true,
-            open: true,
-            inline: true,
-            infix: true,
-            tailrec: true,
-            operator: true,
-            override: true,
-        }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * This is a function${EOL} */${EOL}@Inject${EOL}@Optional${EOL}private inline infix tailrec open override operator fun <T> @Fancy String.foo(x: Int): Int = println("Hello")${EOL}`);
-    });
-    it('should render injections', () => {
-        builder.append(ktFunction('foo', {
-            generics: [ktGenericParameter('T')],
-            parameters: [ktParameter('x', 'Int')],
-            doc: ktDoc('This is a function'),
-            returnType: 'Int',
-            body: 'println("Hello")',
-            accessModifier: 'private',
-            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-            receiverType: 'String',
-            receiverAnnotations: [ktAnnotation('Fancy')],
-            singleExpression: true,
-            open: true,
-            inline: true,
-            infix: true,
-            tailrec: true,
-            operator: true,
-            override: true,
-            inject: {
-                before: '║bg║',
-                after: '║ag║',
-                beforeGenerics: '║bgg║',
-                afterGenerics: '║agg║',
-                beforeModifiers: '║bm║',
-                afterModifiers: '║am║',
-                beforeName: '║bn║',
-                afterName: '║an║',
-                beforeParameters: '║bp║',
-                afterParameters: '║ap║',
-                beforeReturnType: '║br║',
-                afterReturnType: '║ar║',
-                beforeReceiverType: '║brt║',
-                afterReceiverType: '║art║',
-                beforeReceiverAnnotations: '║bra║',
-                afterReceiverAnnotations: '║ara║',
-                beforeAnnotations: '║ba║',
-                afterAnnotations: '║aa║',
-                beforeDoc: '║bd║',
-                afterDoc: '║ad║',
-            },
-        }));
-        expect(builder.toString(false)).toBe(`║bg║║bd║${EOL}/**${EOL} * This is a function${EOL} */${EOL}║ad║║ba║@Inject${EOL}@Optional${EOL}║aa║║bm║private inline infix tailrec open override operator ║am║fun ║bgg║<T>║agg║ ║bra║@Fancy ║ara║║brt║String║art║.║bn║foo║an║║bp║(x: Int)║ap║: ║br║Int║ar║ = println("Hello")${EOL}║ag║`);
-    });
-});

package/esm/src/ast/nodes/generic-parameter.test.d.ts

@@ -1,2 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-//# sourceMappingURL=generic-parameter.test.d.ts.map

package/esm/src/ast/nodes/generic-parameter.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generic-parameter.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/generic-parameter.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/generic-parameter.test.js

@@ -1,49 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/bdd.js';
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktGenericParameter } from './generic-parameter.js';
-describe('ktGenericParameter', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    describe('single', () => {
-        it('should write the name of the parameter', () => {
-            builder.append(ktGenericParameter('T'));
-            expect(builder.toString(false)).toBe('T');
-        });
-        it('should write the constraint if it exists', () => {
-            builder.append(ktGenericParameter('T', { constraint: 'number' }));
-            expect(builder.toString(false)).toBe('T : number');
-        });
-        it('should render injections', () => {
-            builder.append(ktGenericParameter('T', {
-                constraint: 'number',
-                inject: {
-                    before: '║b║',
-                    after: '║a║',
-                    beforeName: '║bn║',
-                    afterName: '║an║',
-                    beforeConstraint: '║bc║',
-                    afterConstraint: '║ac║',
-                },
-            }));
-            expect(builder.toString(false)).toBe('║b║║bn║T║an║ : ║bc║number║ac║║a║');
-        });
-    });
-    describe('multiple', () => {
-        it('should not write anything if the node is empty', () => {
-            ktGenericParameter.write(builder, []);
-            expect(builder.toString(false)).toBe('');
-        });
-        it('should write a single parameter', () => {
-            ktGenericParameter.write(builder, [ktGenericParameter('T')]);
-            expect(builder.toString(false)).toBe('<T>');
-        });
-        it('should write all the parameters', () => {
-            ktGenericParameter.write(builder, [ktGenericParameter('T'), ktGenericParameter('U')]);
-            expect(builder.toString(false)).toBe('<T, U>');
-        });
-    });
-});

package/esm/src/ast/nodes/init-block.test.d.ts

@@ -1,2 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-//# sourceMappingURL=init-block.test.d.ts.map

package/esm/src/ast/nodes/init-block.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init-block.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/init-block.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/init-block.test.js

@@ -1,28 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/bdd.js';
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktInitBlock } from './init-block.js';
-describe('ktInitBlock', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write an empty init block', () => {
-        builder.append(ktInitBlock(''));
-        expect(builder.toString(false)).toBe(`init {}${EOL}`);
-    });
-    it('should write an init block with a single statement', () => {
-        builder.append(ktInitBlock('println("Hello")'));
-        expect(builder.toString(false)).toBe(`init {${EOL}    println("Hello")${EOL}}${EOL}`);
-    });
-    it('should write an init block with multiple statements', () => {
-        builder.append(ktInitBlock((b) => b.appendLine('println("Hello")').appendLine('println("World")')));
-        expect(builder.toString(false)).toBe(`init {${EOL}    println("Hello")${EOL}    println("World")${EOL}}${EOL}`);
-    });
-    it('should render injections', () => {
-        builder.append(ktInitBlock('println("Hello")', { inject: { before: ['before'], after: ['after'] } }));
-        expect(builder.toString(false)).toBe(`beforeinit {${EOL}    println("Hello")${EOL}}${EOL}after`);
-    });
-});

package/esm/src/ast/nodes/interface.test.d.ts

@@ -1,2 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-//# sourceMappingURL=interface.test.d.ts.map

package/esm/src/ast/nodes/interface.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"interface.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/interface.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/interface.test.js

@@ -1,121 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/bdd.js';
-import { normalizeEOL } from '@goast/test-utils';
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktAnnotation } from './annotation.js';
-import { ktDoc } from './doc.js';
-import { ktGenericParameter } from './generic-parameter.js';
-import { ktInterface } from './interface.js';
-import { ktObject } from './object.js';
-describe('ktInterface', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write interface', () => {
-        builder.append(ktInterface('Foo'));
-        expect(builder.toString(false)).toBe(`interface Foo${EOL}`);
-    });
-    it('should write generics', () => {
-        builder.append(ktInterface('Foo', { generics: [ktGenericParameter('T'), ktGenericParameter('U')] }));
-        expect(builder.toString(false)).toBe(`interface Foo<T, U>${EOL}`);
-    });
-    it('should write members', () => {
-        builder.append(ktInterface('Foo', {
-            members: ['// Comment 1', '// Comment 2'],
-        }));
-        expect(builder.toString(false)).toBe(`interface Foo {${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}${EOL}`);
-    });
-    it('should write extended interfaces', () => {
-        builder.append(ktInterface('Foo', { extends: ['Bar', 'Baz'] }));
-        expect(builder.toString(false)).toBe(`interface Foo : Bar, Baz${EOL}`);
-    });
-    it('should write annotations', () => {
-        builder.append(ktInterface('Foo', { annotations: [ktAnnotation('Deprecated')] }));
-        expect(builder.toString(false)).toBe(`@Deprecated${EOL}interface Foo${EOL}`);
-    });
-    it('should write access modifiers', () => {
-        builder.append(ktInterface('Foo', { accessModifier: 'private' }));
-        expect(builder.toString(false)).toBe(`private interface Foo${EOL}`);
-    });
-    it('should write documenation', () => {
-        builder.append(ktInterface('Foo', { doc: ktDoc('This is a foo') }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * This is a foo${EOL} */${EOL}interface Foo${EOL}`);
-    });
-    it('should write generic parameter description', () => {
-        builder.append(ktInterface('Foo', { generics: [ktGenericParameter('T', { description: 'The type' })] }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * @param T The type${EOL} */${EOL}interface Foo<T>${EOL}`);
-    });
-    it('should write companion object', () => {
-        builder.append(ktInterface('Foo', { companionObject: ktObject() }));
-        expect(builder.toString(false)).toBe(`interface Foo {${EOL}    companion object {}${EOL}}${EOL}`);
-    });
-    it('should write all options', () => {
-        builder.append(ktInterface('Foo', {
-            doc: ktDoc('This is a foo'),
-            annotations: [ktAnnotation('Deprecated')],
-            accessModifier: 'private',
-            extends: ['Bar', 'Baz'],
-            generics: [ktGenericParameter('T')],
-            members: ['// Comment 1', '// Comment 2'],
-            companionObject: ktObject(),
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
-         * This is a foo
-         */
-        @Deprecated
-        private interface Foo<T> : Bar, Baz {
-            companion object {}
-
-            // Comment 1
-            // Comment 2
-        }
-        `));
-    });
-    it('should render injections', () => {
-        builder.append(ktInterface('Foo', {
-            doc: ktDoc('This is a foo'),
-            annotations: [ktAnnotation('Deprecated')],
-            accessModifier: 'private',
-            extends: ['Bar', 'Baz'],
-            generics: [ktGenericParameter('T')],
-            members: ['// Comment 1', '// Comment 2'],
-            companionObject: ktObject(),
-            inject: {
-                before: '║b║',
-                after: '║a║',
-                beforeDoc: '║bd║',
-                afterDoc: '║ad║',
-                beforeAnnotations: '║ba║',
-                afterAnnotations: '║aa║',
-                beforeModifiers: '║bm║',
-                afterModifiers: '║am║',
-                beforeName: '║bn║',
-                afterName: '║an║',
-                beforeGenerics: '║bg║',
-                afterGenerics: '║ag║',
-                beforeExtends: '║be║',
-                afterExtends: '║ae║',
-                beforeBody: '║bb║',
-                afterBody: '║ab║',
-                beforeMembers: '║bm║',
-                afterMembers: '║am║',
-            },
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
-        /**
-         * This is a foo
-         */
-        ║ad║║ba║@Deprecated
-        ║aa║║bm║private ║am║interface ║bn║Foo║an║║bg║<T>║ag║ : ║be║Bar, Baz║ae║ ║bb║{
-            ║bm║companion object {}
-
-            // Comment 1
-            // Comment 2
-            ║am║
-        }║ab║
-        ║a║`));
-    });
-});

package/esm/src/ast/nodes/object.test.d.ts

@@ -1,2 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-//# sourceMappingURL=object.test.d.ts.map

package/esm/src/ast/nodes/object.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/object.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}