@goast/typescript 0.4.3 → 0.5.0

package/esm/src/assets.js

@@ -1,5 +1,5 @@
 import { AssetManager } from '@goast/core';
-import { pathToFileURL } from 'node:url';
+import { pathToFileURL, URL } from 'node:url';
 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);

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

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

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

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

@@ -0,0 +1,34 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.13/mod.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsArgument } from './argument.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsArgument', () => {
+    it('should write the argument value', () => {
+        builder.append(tsArgument('42'));
+        expect(builder.toString(false)).toBe('42');
+    });
+    it('should write injections', () => {
+        builder.append(tsArgument('42', { inject: { before: '║b║', after: '║a║' } }));
+        expect(builder.toString(false)).toBe(`║b║42║a║`);
+    });
+    describe('write', () => {
+        it('should write parantheses even if there are no arguments', () => {
+            tsArgument.write(builder, []);
+            expect(builder.toString(false)).toBe('()');
+        });
+        it('should write the arguments', () => {
+            tsArgument.write(builder, ['42', 'true']);
+            expect(builder.toString(false)).toBe('(42, true)');
+        });
+        it('should write multiline if there are more than 2 arguments', () => {
+            tsArgument.write(builder, ['42', 'true', 'false']);
+            expect(builder.toString(false)).toBe(`(${EOL}  42,${EOL}  true,${EOL}  false${EOL})`);
+        });
+    });
+});

package/esm/src/ast/nodes/array-type.test.d.ts

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

package/esm/src/ast/nodes/array-type.test.d.ts.map

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

package/esm/src/ast/nodes/array-type.test.js

@@ -0,0 +1,26 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.13/mod.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsArrayType } from './array-type.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsArrayType', () => {
+    it('should write the type of the array', () => {
+        builder.append(tsArrayType('number'));
+        expect(builder.toString(false)).toBe('(number)[]');
+    });
+    it('should write the array as readonly', () => {
+        builder.append(tsArrayType('number', { readonly: true }));
+        expect(builder.toString(false)).toBe('readonly (number)[]');
+    });
+    it('should render injections', () => {
+        builder.append(tsArrayType('number', {
+            readonly: true,
+            inject: { before: '║b║', after: '║a║', beforeType: '║bt║', afterType: '║at║' },
+        }));
+        expect(builder.toString(false)).toBe(`║b║readonly ║bt║(number)║at║[]║a║`);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,62 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.13/mod.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsArrowFunction } from './arrow-function.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsArrowFunction', () => {
+    it('should write empty function', () => {
+        builder.append(tsArrowFunction());
+        expect(builder.toString(false)).toBe('() => {}');
+    });
+    it('should write the parameters', () => {
+        builder.append(tsArrowFunction({ parameters: ['x', 'y'] }));
+        expect(builder.toString(false)).toBe('(x, y) => {}');
+    });
+    it('should write the return type', () => {
+        builder.append(tsArrowFunction({ returnType: 'number' }));
+        expect(builder.toString(false)).toBe('(): number => {}');
+    });
+    it('should write the body', () => {
+        builder.append(tsArrowFunction({ body: 'return 42;' }));
+        expect(builder.toString(false)).toBe('() => {' + EOL + '  return 42;' + EOL + '}');
+    });
+    it('should write the generics if they exist', () => {
+        builder.append(tsArrowFunction({ generics: ['T', 'U'] }));
+        expect(builder.toString(false)).toBe('<T, U>() => {}');
+    });
+    it('should write all the parts of the arrow function', () => {
+        builder.append(tsArrowFunction({
+            generics: ['T', 'U'],
+            parameters: ['x', 'y'],
+            returnType: 'number',
+            body: 'return 42;',
+        }));
+        expect(builder.toString(false)).toBe('<T, U>(x, y): number => {' + EOL + '  return 42;' + EOL + '}');
+    });
+    it('should render injections', () => {
+        builder.append(tsArrowFunction({
+            generics: ['T', 'U'],
+            parameters: ['x', 'y'],
+            returnType: 'number',
+            body: 'return 42;',
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeGenerics: '║bg║',
+                afterGenerics: '║ag║',
+                beforeParams: '║bp║',
+                afterParams: '║ap║',
+                beforeReturnType: '║brt║',
+                afterReturnType: '║art║',
+                beforeBody: '║bb║',
+                afterBody: '║ab║',
+            },
+        }));
+        expect(builder.toString(false)).toBe('║b║║bg║<T, U>║ag║║bp║(x, y)║ap║: ║brt║number║art║ => ║bb║{' + EOL + '  return 42;' + EOL + '}║ab║║a║');
+    });
+});

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

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

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

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

@@ -0,0 +1,150 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.13/mod.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { normalizeEOL } from '@goast/test-utils';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsClass } from './class.js';
+import { tsConstructor } from './constructor.js';
+import { tsDecorator } from './decorator.js';
+import { tsDoc } from './doc.js';
+import { tsGenericParameter } from './generic-parameter.js';
+import { tsMethod } from './method.js';
+import { tsProperty } from './property.js';
+import { tsReference } from './reference.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsClass', () => {
+    it('should write the name of the class', () => {
+        builder.append(tsClass('X'));
+        expect(builder.toString(false)).toBe('class X {}' + EOL);
+    });
+    it('should write documenation if it exists', () => {
+        builder.append(tsClass('X', { doc: tsDoc({ description: 'description' }) }));
+        expect(builder.toString(false)).toBe('/**' + EOL + ' * description' + EOL + ' */' + EOL + 'class X {}' + EOL);
+    });
+    it('should write decorators if they exist', () => {
+        builder.append(tsClass('X', { decorators: [tsDecorator('decorator')] }));
+        expect(builder.toString(false)).toBe('@decorator' + EOL + 'class X {}' + EOL);
+    });
+    it('should write the generics if they exist', () => {
+        builder.append(tsClass('X', { generics: ['T', 'U'] }));
+        expect(builder.toString(false)).toBe('class X<T, U> {}' + EOL);
+    });
+    it('should write the descriptions of the generics if they exist', () => {
+        builder.append(tsClass('X', {
+            generics: [tsGenericParameter('T', { description: 'description' }), 'U'],
+        }));
+        expect(builder.toString(false)).toBe('/**' + EOL + ' * @template T description' + EOL + ' */' + EOL + 'class X<T, U> {}' + EOL);
+    });
+    it('should write the extends if it exists', () => {
+        builder.append(tsClass('X', { extends: 'Y' }));
+        expect(builder.toString(false)).toBe('class X extends Y {}' + EOL);
+    });
+    it('should write the implements if it exists', () => {
+        builder.append(tsClass('X', { implements: ['Y', 'Z'] }));
+        expect(builder.toString(false)).toBe('class X implements Y, Z {}' + EOL);
+    });
+    it('should write the properties if they exist', () => {
+        builder.append(tsClass('X', { members: [tsProperty('x'), tsProperty('y')] }));
+        expect(builder.toString(false)).toBe('class X {' + EOL + '  x;' + EOL + '  y;' + EOL + '}' + EOL);
+    });
+    it('should write the methods if they exist', () => {
+        builder.append(tsClass('X', { members: [tsMethod('x'), tsMethod('y')] }));
+        expect(builder.toString(false)).toBe('class X {' + EOL + '  x();' + EOL + '  y();' + EOL + '}' + EOL);
+    });
+    it('should write the constructor if it exists', () => {
+        builder.append(tsClass('X', { members: [tsConstructor()] }));
+        expect(builder.toString(false)).toBe('class X {' + EOL + '  constructor() {}' + EOL + '}' + EOL);
+    });
+    it('should write export keyword if configured', () => {
+        builder.append(tsClass('X', { export: true }));
+        expect(builder.toString(false)).toBe('export class X {}' + EOL);
+    });
+    it('should write the abstract keyword if configured', () => {
+        builder.append(tsClass('X', { abstract: true }));
+        expect(builder.toString(false)).toBe('abstract class X {}' + EOL);
+    });
+    it('should write all the parts of the class', () => {
+        builder.append(tsClass('X', {
+            doc: tsDoc({ description: 'description' }),
+            decorators: [tsDecorator('decorator')],
+            generics: [tsGenericParameter('T', { description: 'description for T' }), tsGenericParameter('U')],
+            extends: tsReference('Y'),
+            implements: [tsReference('Z')],
+            members: [tsProperty('x'), tsProperty('y'), tsConstructor(), tsMethod('x'), tsMethod('y')],
+            export: true,
+            abstract: true,
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
+         * description
+         *
+         * @template T description for T
+         */
+        @decorator
+        export abstract class X<T, U> extends Y implements Z {
+          x;
+          y;
+
+          constructor() {}
+
+          x();
+          y();
+        }
+        `.trimStart()));
+    });
+    it('should render injections', () => {
+        builder.append(tsClass('X', {
+            doc: tsDoc({ description: 'description' }),
+            decorators: [tsDecorator('decorator')],
+            generics: [tsGenericParameter('T', { description: 'description for T' }), tsGenericParameter('U')],
+            extends: tsReference('Y'),
+            implements: [tsReference('Z')],
+            members: [tsProperty('x'), tsProperty('y'), tsConstructor(), tsMethod('x'), tsMethod('y')],
+            export: true,
+            abstract: true,
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeDoc: '║bd║',
+                afterDoc: '║ad║',
+                beforeDecorators: '║bds║',
+                afterDecorators: '║ads║',
+                beforeModifiers: '║bm║',
+                afterModifiers: '║am║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforeGenerics: '║bg║',
+                afterGenerics: '║ag║',
+                beforeExtends: '║be║',
+                afterExtends: '║ae║',
+                beforeImplements: '║bi║',
+                afterImplements: '║ai║',
+                beforeBody: '║bb║',
+                afterBody: '║ab║',
+                beforeMembers: '║bmb║',
+                afterMembers: '║amb║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
+        /**
+         * description
+         *
+         * @template T description for T
+         */
+        ║ad║║bds║@decorator
+        ║ads║║bm║export abstract ║am║class ║bn║X║an║║bg║<T, U>║ag║ extends ║be║Y║ae║ implements ║bi║Z║ai║ ║bb║{
+          ║bmb║x;
+          y;
+
+          constructor() {}
+
+          x();
+          y();
+          ║amb║
+        }║ab║
+        ║a║`.trimStart()));
+    });
+});

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

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

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

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

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

@@ -0,0 +1,99 @@
+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 { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsConstructorParameter } from './constructor-parameter.js';
+import { tsDecorator } from './decorator.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsConstructorParameter', () => {
+    it('should write the name of the parameter', () => {
+        builder.append(tsConstructorParameter('x'));
+        expect(builder.toString(false)).toBe('x');
+    });
+    it('should write decorators if they exist', () => {
+        builder.append(tsConstructorParameter('x', { decorators: [tsDecorator('decorator')] }));
+        expect(builder.toString(false)).toBe('@decorator x');
+    });
+    it('should write the type if it exists', () => {
+        builder.append(tsConstructorParameter('x', { type: 'number' }));
+        expect(builder.toString(false)).toBe('x: number');
+    });
+    it('should write the default if it exists', () => {
+        builder.append(tsConstructorParameter('x', { default: '42' }));
+        expect(builder.toString(false)).toBe('x = 42');
+    });
+    it('should write the accessibility if it exists', () => {
+        builder.append(tsConstructorParameter('x', { accessModifier: 'public' }));
+        expect(builder.toString(false)).toBe('public x');
+    });
+    it('should write the readonly keyword if the parameter is readonly', () => {
+        builder.append(tsConstructorParameter('x', { readonly: true }));
+        expect(builder.toString(false)).toBe('readonly x');
+    });
+    it('should write the optional symbol if the parameter is optional', () => {
+        builder.append(tsConstructorParameter('x', { optional: true }));
+        expect(builder.toString(false)).toBe('x?');
+    });
+    it('should write all the parts of the parameter', () => {
+        builder.append(tsConstructorParameter('x', {
+            decorators: [tsDecorator('decorator')],
+            type: 'number',
+            default: 42,
+            accessModifier: 'public',
+            readonly: true,
+            optional: true,
+        }));
+        expect(builder.toString(false)).toBe('@decorator public readonly x?: number = 42');
+    });
+    it('should render injections', () => {
+        builder.append(tsConstructorParameter('x', {
+            decorators: [tsDecorator('decorator')],
+            type: 'number',
+            default: 42,
+            accessModifier: 'public',
+            readonly: true,
+            optional: true,
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeDecorators: '║bd║',
+                afterDecorators: '║ad║',
+                beforeModifiers: '║bm║',
+                afterModifiers: '║am║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforeType: '║bt║',
+                afterType: '║at║',
+                beforeDefault: '║bdf║',
+                afterDefault: '║adf║',
+            },
+        }));
+        expect(builder.toString(false)).toBe('║b║║bd║@decorator ║ad║║bm║public readonly ║am║║bn║x║an║?: ║bt║number║at║ = ║bdf║42║adf║║a║');
+    });
+    describe('write', () => {
+        it('should write parenthesis if the node is empty', () => {
+            tsConstructorParameter.write(builder, []);
+            expect(builder.toString(false)).toBe('()');
+        });
+        it('should write a single parameter', () => {
+            tsConstructorParameter.write(builder, [tsConstructorParameter('x')]);
+            expect(builder.toString(false)).toBe('(x)');
+        });
+        it('should write all the parameters', () => {
+            tsConstructorParameter.write(builder, [tsConstructorParameter('x'), tsConstructorParameter('y')]);
+            expect(builder.toString(false)).toBe('(x, y)');
+        });
+        it('should write multiline if more than 2 parameters', () => {
+            tsConstructorParameter.write(builder, [
+                tsConstructorParameter('x'),
+                tsConstructorParameter('y'),
+                tsConstructorParameter('z'),
+            ]);
+            expect(builder.toString(false)).toBe(`(${EOL}  x,${EOL}  y,${EOL}  z${EOL})`);
+        });
+    });
+});

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

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

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

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

@@ -0,0 +1,102 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.13/mod.js';
+import { beforeEach, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { normalizeEOL } from '@goast/test-utils';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsConstructorParameter } from './constructor-parameter.js';
+import { tsConstructor } from './constructor.js';
+import { tsDecorator } from './decorator.js';
+import { tsDocTag } from './doc-tag.js';
+import { tsDoc } from './doc.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+it('should write empty constructor', () => {
+    builder.append(tsConstructor());
+    expect(builder.toString(false)).toBe(`constructor() {}${EOL}`);
+});
+it('should write documentation if it exists', () => {
+    builder.append(tsConstructor({ doc: tsDoc({ description: 'description' }) }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}constructor() {}${EOL}`);
+});
+it('should write decorators if they exist', () => {
+    builder.append(tsConstructor({ decorators: [tsDecorator('decorator')] }));
+    expect(builder.toString(false)).toBe(`@decorator${EOL}constructor() {}${EOL}`);
+});
+it('should write the parameters', () => {
+    builder.append(tsConstructor({
+        parameters: ['x', 'y'],
+    }));
+    expect(builder.toString(false)).toBe(`constructor(x, y) {}${EOL}`);
+});
+it('should write the description of the parameters when no documentation is provided', () => {
+    builder.append(tsConstructor({
+        parameters: [tsConstructorParameter('x', { description: 'description' }), 'y'],
+    }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * @param x description${EOL} */${EOL}constructor(x, y) {}${EOL}`);
+});
+it('should write the body', () => {
+    builder.append(tsConstructor({ body: 'this.x = x;' }));
+    expect(builder.toString(false)).toBe(`constructor() {${EOL}  this.x = x;${EOL}}${EOL}`);
+});
+it('should write the description of the parameter when documentation is provided', () => {
+    builder.append(tsConstructor({
+        doc: tsDoc({
+            description: 'description',
+            tags: [tsDocTag('param', 'y', 'y-description'), tsDocTag('returns', 'r-description')],
+        }),
+        decorators: [tsDecorator('decorator')],
+        parameters: [tsConstructorParameter('x', { description: 'x-description' }), 'y'],
+        body: 'this.x = x;',
+    }));
+    expect(builder.toString(false)).toBe(normalizeEOL(6)(`/**
+       * description
+       *
+       * @param x x-description
+       * @param y y-description
+       * @returns r-description
+       */
+      @decorator
+      constructor(x, y) {
+        this.x = x;
+      }
+      `));
+});
+it('should render injections', () => {
+    builder.append(tsConstructor({
+        doc: tsDoc({
+            description: 'description',
+            tags: [tsDocTag('param', 'y', 'y-description'), tsDocTag('returns', 'r-description')],
+        }),
+        decorators: [tsDecorator('decorator')],
+        parameters: [tsConstructorParameter('x', { description: 'x-description' }), 'y'],
+        body: 'this.x = x;',
+        inject: {
+            before: '║b║',
+            after: '║a║',
+            beforeParams: '║bp║',
+            afterParams: '║ap║',
+            beforeDoc: '║bd║',
+            afterDoc: '║ad║',
+            beforeDecorators: '║bds║',
+            afterDecorators: '║ads║',
+            beforeBody: '║bb║',
+            afterBody: '║ab║',
+        },
+    }));
+    expect(builder.toString(false)).toBe(normalizeEOL(6)(`║b║║bd║
+      /**
+       * description
+       *
+       * @param x x-description
+       * @param y y-description
+       * @returns r-description
+       */
+      ║ad║║bds║@decorator
+      ║ads║constructor║bp║(x, y)║ap║ ║bb║{
+        this.x = x;
+      }║ab║
+      ║a║`));
+});

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

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

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

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

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

@@ -0,0 +1,47 @@
+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 { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsDecorator } from './decorator.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('single', () => {
+    it('should write a static decorator', () => {
+        builder.append(tsDecorator('decorator'));
+        expect(builder.toString(false)).toBe(`@decorator`);
+    });
+    it('should write a decorator without arguments', () => {
+        builder.append(tsDecorator('decorator', []));
+        expect(builder.toString(false)).toBe(`@decorator()`);
+    });
+    it('should write a decorator with arguments', () => {
+        builder.append(tsDecorator('decorator', ['arg1', 'arg2']));
+        expect(builder.toString(false)).toBe(`@decorator(arg1, arg2)`);
+    });
+    it('should render injections', () => {
+        builder.append(tsDecorator('decorator', ['arg1', 'arg2'], {
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeFunction: '║bf║',
+                afterFunction: '║af║',
+                beforeArguments: '║ba║',
+                afterArguments: '║aa║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(`║b║@║bf║decorator║af║║ba║(arg1, arg2)║aa║║a║`);
+    });
+});
+describe('multiple', () => {
+    it('should write decorators across multiple lines', () => {
+        tsDecorator.write(builder, [tsDecorator('decorator1'), tsDecorator('decorator2')], { multiline: true });
+        expect(builder.toString(false)).toBe(`@decorator1${EOL}@decorator2${EOL}`);
+    });
+    it('should write decorators on the same line', () => {
+        tsDecorator.write(builder, [tsDecorator('decorator1'), tsDecorator('decorator2')], { multiline: false });
+        expect(builder.toString(false)).toBe(`@decorator1 @decorator2 `);
+    });
+});

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

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

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

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

@@ -0,0 +1,30 @@
+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, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsDocTag } from './doc-tag.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+it('should write a custom tag', () => {
+    builder
+        .appendLine(tsDocTag('custom'))
+        .appendLine(tsDocTag('custom', { type: 'number' }))
+        .appendLine(tsDocTag('custom', { text: 'description' }))
+        .append(tsDocTag('custom', { type: 'number', text: 'description' }));
+    expect(builder.toString(false)).toBe(`@custom${EOL}@custom {number}${EOL}@custom description${EOL}@custom {number} description`);
+});
+it('should render injections', () => {
+    builder.append(tsDocTag('custom', { inject: { before: ['before'], after: ['after'] } }));
+    expect(builder.toString(false)).toBe(`before@customafter`);
+});
+it('should write author tag', () => {
+    builder.appendLine(tsDocTag('author', 'John Doe')).append(tsDocTag('author', 'John Doe', 'john.doe@gmail.com'));
+    expect(builder.toString(false)).toBe(`@author John Doe${EOL}@author John Doe <john.doe@gmail.com>`);
+});
+it('should write access tag', () => {
+    builder.append(tsDocTag('access', 'public'));
+    expect(builder.toString(false)).toBe('@access public');
+});

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

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

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

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