@goast/kotlin 0.4.13 → 0.4.14-beta1

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

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

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

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

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

@@ -1,56 +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;
-    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/esm/src/ast/nodes/argument.test.d.ts

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

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

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

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

@@ -1,33 +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;
-    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/esm/src/ast/nodes/call.test.d.ts

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

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

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

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

@@ -1,35 +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;
-    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/esm/src/ast/nodes/class.test.d.ts

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

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

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

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

@@ -1,219 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-import { appendValueGroup } from '@goast/core';
-import { normalizeEOL } from '@goast/test-utils';
-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';
-import { ktClass } from './class.js';
-import { ktConstructor } from './constructor.js';
-import { ktDoc } from './doc.js';
-import { ktFunction } from './function.js';
-import { ktGenericParameter } from './generic-parameter.js';
-import { ktInitBlock } from './init-block.js';
-import { ktObject } from './object.js';
-import { ktParameter } from './parameter.js';
-import { ktProperty } from './property.js';
-describe('ktClass', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write class', () => {
-        builder.append(ktClass('Foo'));
-        expect(builder.toString(false)).toBe(`class Foo${EOL}`);
-    });
-    it('should write generics', () => {
-        builder.append(ktClass('Foo', { generics: [ktGenericParameter('T'), ktGenericParameter('U')] }));
-        expect(builder.toString(false)).toBe(`class Foo<T, U>${EOL}`);
-    });
-    it('should write primary constructor without body', () => {
-        builder.append(ktClass('Foo', { primaryConstructor: ktConstructor([ktParameter.class('x', 'Int')], null) }));
-        expect(builder.toString(false)).toBe(`class Foo(x: Int)${EOL}`);
-    });
-    it('should write primary constructor with body', () => {
-        builder.append(ktClass('Foo', { primaryConstructor: ktConstructor([ktParameter.class('x', 'Int')], 'println(x)') }));
-        expect(builder.toString(false)).toBe(`class Foo(x: Int) {${EOL}    init {${EOL}        println(x)${EOL}    }${EOL}}${EOL}`);
-    });
-    it('should write members', () => {
-        builder.append(ktClass('Foo', {
-            members: [
-                ktConstructor([ktParameter('x', 'Int')], 'println(x)'),
-                ktInitBlock('println("Hello")'),
-                ktProperty('y', { type: 'Int?' }),
-                ktProperty('z', { type: 'String?' }),
-                ktFunction('bar', { parameters: [ktParameter('x', 'Int')], body: 'println(x)' }),
-                ktClass('Bar'),
-                '// Comment 1',
-                appendValueGroup(['// Comment 2', '// Comment 3'], '\n'),
-            ],
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`class Foo {
-            constructor(x: Int) {
-                println(x)
-            }
-
-            init {
-                println("Hello")
-            }
-
-            val y: Int?
-            val z: String?
-
-            fun bar(x: Int) {
-                println(x)
-            }
-
-            class Bar
-
-            // Comment 1
-            // Comment 2
-            // Comment 3
-        }
-        `));
-    });
-    it('should write annotations', () => {
-        builder.append(ktClass('Foo', { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
-        expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}class Foo${EOL}`);
-    });
-    it('should write documentation', () => {
-        builder.append(ktClass('Foo', { doc: ktDoc('This is a class') }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * This is a class${EOL} */${EOL}class Foo${EOL}`);
-    });
-    it('should write primary constructor parameter description', () => {
-        builder.append(ktClass('Foo', {
-            primaryConstructor: ktConstructor([ktParameter.class('x', 'Int', { description: 'The number' })]),
-        }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * @param x The number${EOL} */${EOL}class Foo(x: Int)${EOL}`);
-    });
-    it('should write primary constructor parameter property description', () => {
-        builder.append(ktClass('Foo', {
-            primaryConstructor: ktConstructor([
-                ktParameter.class('x', 'Int', { property: 'readonly', propertyDescription: 'The number' }),
-            ]),
-        }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * @property x The number${EOL} */${EOL}class Foo(val x: Int)${EOL}`);
-    });
-    it('should ignore primary constructor parameter property description if property is not set', () => {
-        builder.append(ktClass('Foo', {
-            primaryConstructor: ktConstructor([ktParameter.class('x', 'Int', { propertyDescription: 'The number' })]),
-        }));
-        expect(builder.toString(false)).toBe(`class Foo(x: Int)${EOL}`);
-    });
-    it('should write generic parameter description', () => {
-        builder.append(ktClass('Foo', { generics: [ktGenericParameter('T', { description: 'The type' })] }));
-        expect(builder.toString(false)).toBe(`/**${EOL} * @param T The type${EOL} */${EOL}class Foo<T>${EOL}`);
-    });
-    it('should write modifiers', () => {
-        builder.append(ktClass('Foo', { accessModifier: 'private', open: true, abstract: true }));
-        expect(builder.toString(false)).toBe(`private open abstract class Foo${EOL}`);
-    });
-    it('should write class kind', () => {
-        builder.append(ktClass('Foo', { classKind: 'annotation' }));
-        expect(builder.toString(false)).toBe(`annotation class Foo${EOL}`);
-    });
-    it('should write base class', () => {
-        builder.append(ktClass('Foo', { extends: 'Bar' }));
-        expect(builder.toString(false)).toBe(`class Foo : Bar${EOL}`);
-    });
-    it('should write base class constructor arguments', () => {
-        builder.append(ktClass('Foo', {
-            extends: 'Bar',
-            primaryConstructor: ktConstructor([], null, { delegateTarget: 'super', delegateArguments: ['1337', '4711'] }),
-        }));
-        expect(builder.toString(false)).toBe(`class Foo : Bar(1337, 4711)${EOL}`);
-    });
-    it('should write implemented interfaces', () => {
-        builder.append(ktClass('Foo', { implements: ['Bar', 'Baz'] }));
-        expect(builder.toString(false)).toBe(`class Foo : Bar, Baz${EOL}`);
-    });
-    it('should write companion object', () => {
-        builder.append(ktClass('Foo', { companionObject: ktObject() }));
-        expect(builder.toString(false)).toBe(`class Foo {${EOL}    companion object {}${EOL}}${EOL}`);
-    });
-    it('should write all parts of the class', () => {
-        builder.append(ktClass('Foo', {
-            generics: [ktGenericParameter('T'), ktGenericParameter('U')],
-            primaryConstructor: ktConstructor([ktParameter.class('x', 'Int')], null, {
-                delegateTarget: 'super',
-                delegateArguments: ['x'],
-            }),
-            members: [ktProperty('y', { type: 'Int?' })],
-            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-            doc: ktDoc('This is a class'),
-            accessModifier: 'private',
-            open: true,
-            abstract: true,
-            classKind: 'annotation',
-            extends: 'Bar',
-            implements: ['Baz'],
-            companionObject: ktObject(),
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
-         * This is a class
-         */
-        @Inject
-        @Optional
-        private open abstract annotation class Foo<T, U>(x: Int) : Bar(x), Baz {
-            companion object {}
-
-            val y: Int?
-        }
-        `));
-    });
-    it('should render injections', () => {
-        builder.append(ktClass('Foo', {
-            generics: [ktGenericParameter('T'), ktGenericParameter('U')],
-            primaryConstructor: ktConstructor([ktParameter.class('x', 'Int')], null, {
-                delegateTarget: 'super',
-                delegateArguments: ['x'],
-            }),
-            members: [ktProperty('y', { type: 'Int?' })],
-            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-            doc: ktDoc('This is a class'),
-            accessModifier: 'private',
-            open: true,
-            abstract: true,
-            classKind: 'annotation',
-            extends: 'Bar',
-            implements: ['Baz'],
-            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║',
-                beforePrimaryConstructor: '║bpc║',
-                afterPrimaryConstructor: '║apc║',
-                beforeInheritList: '║bil║',
-                afterInheritList: '║ail║',
-                beforeBody: '║bb║',
-                afterBody: '║ab║',
-                beforeMembers: '║bmb║',
-                afterMembers: '║amb║',
-            },
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
-        /**
-         * This is a class
-         */
-        ║ad║║ba║@Inject
-        @Optional
-        ║aa║║bm║private open abstract annotation ║am║class ║bn║Foo║an║║bg║<T, U>║ag║║bpc║(x: Int)║apc║ : ║bil║Bar(x), Baz║ail║ ║bb║{
-            ║bmb║companion object {}
-
-            val y: Int?
-            ║amb║
-        }║ab║
-        ║a║`));
-    });
-});

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

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

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

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

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

@@ -1,139 +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 { normalizeEOL } from '@goast/test-utils';
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktAnnotation } from './annotation.js';
-import { ktConstructor } from './constructor.js';
-import { ktParameter } from './parameter.js';
-describe('ktConstructor', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write an empty constructor', () => {
-        builder.append(ktConstructor([], null));
-        expect(builder.toString(false)).toBe(`constructor() {}${EOL}`);
-    });
-    it('should write a constructor with parameters', () => {
-        builder.append(ktConstructor([ktParameter('x', 'Int')], null));
-        expect(builder.toString(false)).toBe(`constructor(x: Int) {}${EOL}`);
-    });
-    it('should write a constructor with a body', () => {
-        builder.append(ktConstructor([], 'println("Hello")'));
-        expect(builder.toString(false)).toBe(`constructor() {${EOL}    println("Hello")${EOL}}${EOL}`);
-    });
-    it('should write access modifiers if they exist', () => {
-        builder.append(ktConstructor([], null, { accessModifier: 'private' }));
-        expect(builder.toString(false)).toBe(`private constructor() {}${EOL}`);
-    });
-    it('should write all annotations', () => {
-        builder.append(ktConstructor([], null, { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
-        expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}constructor() {}${EOL}`);
-    });
-    it('should write delegation without arguments', () => {
-        builder.append(ktConstructor([], null, { delegateTarget: 'this' }));
-        expect(builder.toString(false)).toBe(`constructor() : this() {}${EOL}`);
-    });
-    it('should write delegation with arguments', () => {
-        builder.append(ktConstructor([], null, { delegateTarget: 'super', delegateArguments: ['42', 'true'] }));
-        expect(builder.toString(false)).toBe(`constructor() : super(42, true) {}${EOL}`);
-    });
-    it('should write all the parts of the constructor', () => {
-        builder.append(ktConstructor([ktParameter('x', 'Int')], 'println("Hello")', {
-            accessModifier: 'private',
-            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-            delegateTarget: 'this',
-            delegateArguments: ['42', 'true'],
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`@Inject
-        @Optional
-        private constructor(x: Int) : this(42, true) {
-            println("Hello")
-        }
-        `));
-    });
-    it('should render injections', () => {
-        builder.append(ktConstructor([ktParameter('x', 'Int')], 'println("Hello")', {
-            accessModifier: 'private',
-            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-            delegateTarget: 'this',
-            delegateArguments: ['42', 'true'],
-            inject: {
-                before: '║b║',
-                after: '║a║',
-                beforeAnnotations: '║ba║',
-                afterAnnotations: '║aa║',
-                beforeModifiers: '║bm║',
-                afterModifiers: '║am║',
-                beforeParams: '║bp║',
-                afterParams: '║ap║',
-                beforeDelegate: '║bd║',
-                afterDelegate: '║ad║',
-                beforeBody: '║bb║',
-                afterBody: '║ab║',
-            },
-        }));
-        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║ba║@Inject
-        @Optional
-        ║aa║║bm║private ║am║constructor║bp║(x: Int)║ap║ : ║bd║this(42, true)║ad║ ║bb║{
-            println("Hello")
-        }║ab║
-        ║a║`));
-    });
-});
-describe('ktPrimaryConstructor', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should not write anything if there are no parameters, accessModifier, or annotations', () => {
-        ktConstructor().writeAsPrimary(builder);
-        expect(builder.toString(false)).toBe('');
-    });
-    it('should not write body', () => {
-        ktConstructor([], 'println("Hello")').writeAsPrimary(builder);
-        expect(builder.toString(false)).toBe('');
-    });
-    it('should write accessModifier', () => {
-        ktConstructor([], null, { accessModifier: 'private' }).writeAsPrimary(builder);
-        expect(builder.toString(false)).toBe(' private constructor()');
-    });
-    it('should write annotations', () => {
-        ktConstructor([], null, { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }).writeAsPrimary(builder);
-        expect(builder.toString(false)).toBe(' @Inject @Optional constructor()');
-    });
-    it('should write parameters', () => {
-        ktConstructor([ktParameter('x', 'Int')], null).writeAsPrimary(builder);
-        expect(builder.toString(false)).toBe('(x: Int)');
-    });
-    it('should write all the parts of the primary constructor', () => {
-        ktConstructor([ktParameter('x', 'Int')], 'println("Hello")', {
-            accessModifier: 'private',
-            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-        }).writeAsPrimary(builder);
-        expect(builder.toString(false)).toBe(' @Inject @Optional private constructor(x: Int)');
-    });
-    it('should render injections', () => {
-        ktConstructor([ktParameter('x', 'Int')], 'println("Hello")', {
-            accessModifier: 'private',
-            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-            inject: {
-                before: '║b║',
-                after: '║a║',
-                beforeAnnotations: '║ba║',
-                afterAnnotations: '║aa║',
-                beforeModifiers: '║bm║',
-                afterModifiers: '║am║',
-                beforeParams: '║bp║',
-                afterParams: '║ap║',
-                beforeDelegate: '║bd║',
-                afterDelegate: '║ad║',
-                beforeBody: '║bb║',
-                afterBody: '║ab║',
-            },
-        }).writeAsPrimary(builder);
-        expect(builder.toString(false)).toBe('║b║ ║ba║@Inject @Optional ║aa║║bm║private ║am║constructor║bp║(x: Int)║ap║║a║');
-    });
-});

package/esm/src/ast/nodes/doc-tag.test.d.ts

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

package/esm/src/ast/nodes/doc-tag.test.d.ts.map

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

package/esm/src/ast/nodes/doc-tag.test.js

@@ -1,67 +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 { ktDocTag } from './doc-tag.js';
-describe('ktDocTag', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should write custom tag', () => {
-        builder.append(ktDocTag('custom'));
-        expect(builder.toString(false)).toBe('@custom');
-    });
-    it('should write custom tag with description', () => {
-        builder.append(ktDocTag('custom', { description: 'description' }));
-        expect(builder.toString(false)).toBe('@custom description');
-    });
-    it('should write param tag', () => {
-        builder.append(ktDocTag('param', 'x', 'description'));
-        expect(builder.toString(false)).toBe('@param x description');
-    });
-    it('should write return tag', () => {
-        builder.append(ktDocTag('return', 'description'));
-        expect(builder.toString(false)).toBe('@return description');
-    });
-    it('should write constructor tag', () => {
-        builder.append(ktDocTag('constructor', 'description'));
-        expect(builder.toString(false)).toBe('@constructor description');
-    });
-    it('should write receiver tag', () => {
-        builder.append(ktDocTag('receiver', 'description'));
-        expect(builder.toString(false)).toBe('@receiver description');
-    });
-    it('should write property tag', () => {
-        builder.append(ktDocTag('property', 'name', 'description'));
-        expect(builder.toString(false)).toBe('@property name description');
-    });
-    it('should write throws tag', () => {
-        builder.append(ktDocTag('throws', 'exception', 'description'));
-        expect(builder.toString(false)).toBe('@throws exception description');
-    });
-    it('should write exception tag', () => {
-        builder.append(ktDocTag('exception', 'exception', 'description'));
-        expect(builder.toString(false)).toBe('@exception exception description');
-    });
-    it('should write see tag', () => {
-        builder.append(ktDocTag('see', 'reference'));
-        expect(builder.toString(false)).toBe('@see reference');
-    });
-    it('should write author tag', () => {
-        builder.append(ktDocTag('author', 'name'));
-        expect(builder.toString(false)).toBe('@author name');
-    });
-    it('should write since tag', () => {
-        builder.append(ktDocTag('since', 'version'));
-        expect(builder.toString(false)).toBe('@since version');
-    });
-    it('should write supress tag', () => {
-        builder.append(ktDocTag('suppress'));
-        expect(builder.toString(false)).toBe('@suppress');
-    });
-    it('should render injections', () => {
-        builder.append(ktDocTag('custom', { inject: { before: 'before', after: 'after' } }));
-        expect(builder.toString(false)).toBe('before@customafter');
-    });
-});

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

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

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

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

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

@@ -1,33 +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 { ktDocTag } from './doc-tag.js';
-import { ktDoc } from './doc.js';
-describe('ktDoc', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new KotlinFileBuilder();
-    });
-    it('should not write anything if the node is empty', () => {
-        builder.append(ktDoc(null));
-        expect(builder.toString(false)).toBe('');
-    });
-    it('should write description', () => {
-        builder.append(ktDoc('description'));
-        expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}`);
-    });
-    it('should write tags', () => {
-        builder.append(ktDoc(null, [ktDocTag('tag1'), ktDocTag('tag2')]));
-        expect(builder.toString(false)).toBe(`/**${EOL} * @tag1${EOL} * @tag2${EOL} */${EOL}`);
-    });
-    it('should write all the parts of the node', () => {
-        builder.append(ktDoc('description', [ktDocTag('tag1'), ktDocTag('tag2')]));
-        expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} *${EOL} * @tag1${EOL} * @tag2${EOL} */${EOL}`);
-    });
-    it('should render injections', () => {
-        builder.append(ktDoc('hello', [], { inject: { before: ['before'], after: ['after'] } }));
-        expect(builder.toString(false)).toBe(`before${EOL}/**${EOL} * hello${EOL} */${EOL}after`);
-    });
-});

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

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

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

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