@goast/typescript 0.4.1-beta1 → 0.4.1

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

@@ -0,0 +1,31 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsDocTag } from './doc-tag.js';
+import { tsDoc } from './doc.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+it('should not write anything if the node is empty', () => {
+    builder.append(tsDoc());
+    expect(builder.toString(false)).toBe('');
+});
+it('should write description', () => {
+    builder.append(tsDoc({ description: 'description' }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}`);
+});
+it('should write tags', () => {
+    builder.append(tsDoc({ tags: [tsDocTag('tag1'), tsDocTag('tag2')] }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * @tag1${EOL} * @tag2${EOL} */${EOL}`);
+});
+it('should write all the parts of the node', () => {
+    builder.append(tsDoc({ description: 'description', tags: [tsDocTag('tag1'), tsDocTag('tag2')] }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} *${EOL} * @tag1${EOL} * @tag2${EOL} */${EOL}`);
+});
+it('should render injections', () => {
+    builder.append(tsDoc({ description: '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

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

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

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

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

@@ -0,0 +1,52 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsDoc } from './doc.js';
+import { tsEnumValue } from './enum-value.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsEnumValue', () => {
+    it('should write the name of the enum value', () => {
+        builder.append(tsEnumValue('x'));
+        expect(builder.toString(false)).toBe('x');
+    });
+    it('should write the value if it exists', () => {
+        builder.append(tsEnumValue('x', { value: '42' }));
+        expect(builder.toString(false)).toBe('x = 42');
+    });
+    it('should write documentation if it exists', () => {
+        builder.append(tsEnumValue('x', { doc: tsDoc({ description: 'description' }) }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}x`);
+    });
+    it('should write all the parts of the enum value', () => {
+        builder.append(tsEnumValue('x', { value: '42', doc: tsDoc({ description: 'description' }) }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}x = 42`);
+    });
+    it('should write injections', () => {
+        builder.append(tsEnumValue('x', {
+            value: '42',
+            doc: tsDoc({ description: 'description' }),
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeDoc: '║bd║',
+                afterDoc: '║ad║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforeValue: '║bv║',
+                afterValue: '║av║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(`║b║║bd║${EOL}/**${EOL} * description${EOL} */${EOL}║ad║║bn║x║an║ = ║bv║42║av║║a║`);
+    });
+    describe('write', () => {
+        it('should write multiple enum values', () => {
+            tsEnumValue.write(builder, [tsEnumValue('x', { value: '42' }), tsEnumValue('y', { value: '43' })]);
+            expect(builder.toString(false)).toBe(`x = 42,${EOL}y = 43`);
+        });
+    });
+});

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

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

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

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

@@ -0,0 +1,66 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsDoc } from './doc.js';
+import { tsEnumValue } from './enum-value.js';
+import { tsEnum } from './enum.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsEnum', () => {
+    it('should write the name of the enum', () => {
+        builder.append(tsEnum('X'));
+        expect(builder.toString(false)).toBe(`enum X {}${EOL}`);
+    });
+    it('should write the members if they exist', () => {
+        builder.append(tsEnum('X', { members: [tsEnumValue('A'), tsEnumValue('B')] }));
+        expect(builder.toString(false)).toBe(`enum X {${EOL}  A,${EOL}  B${EOL}}${EOL}`);
+    });
+    it('should write export keyword if configured', () => {
+        builder.append(tsEnum('X', { export: true }));
+        expect(builder.toString(false)).toBe(`export enum X {}${EOL}`);
+    });
+    it('should write const keyword if configured', () => {
+        builder.append(tsEnum('X', { const: true }));
+        expect(builder.toString(false)).toBe(`const enum X {}${EOL}`);
+    });
+    it('should write documenation if it exists', () => {
+        builder.append(tsEnum('X', { doc: tsDoc({ description: 'description' }) }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}enum X {}${EOL}`);
+    });
+    it('should write all the parts of the enum', () => {
+        builder.append(tsEnum('X', {
+            doc: tsDoc({ description: 'description' }),
+            members: [tsEnumValue('A'), tsEnumValue('B')],
+            export: true,
+            const: true,
+        }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}export const enum X {${EOL}  A,${EOL}  B${EOL}}${EOL}`);
+    });
+    it('should render injections', () => {
+        builder.append(tsEnum('X', {
+            doc: tsDoc({ description: 'description' }),
+            members: [tsEnumValue('A'), tsEnumValue('B')],
+            export: true,
+            const: true,
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeDoc: '║bd║',
+                afterDoc: '║ad║',
+                beforeModifiers: '║bm║',
+                afterModifiers: '║am║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforeBody: '║bb║',
+                afterBody: '║ab║',
+                beforeMembers: '║bm║',
+                afterMembers: '║am║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(`║b║║bd║${EOL}/**${EOL} * description${EOL} */${EOL}║ad║║bm║export const ║am║enum ║bn║X║an║ ║bb║{${EOL}  ║bm║A,${EOL}  B║am║${EOL}}║ab║${EOL}║a║`);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,22 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { SourceBuilder } from '@goast/core';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsExport } from './export.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsExport', () => {
+    it('should add the export to the builder', () => {
+        builder.append(tsExport('myFunction', './my-function'));
+        expect(builder.imports['_exports']).toEqual(new Map([['./my-function', new Set(['myFunction'])]]));
+    });
+    it('should write export if not TypeScriptFileBuilder', () => {
+        const builder = new SourceBuilder();
+        tsExport('myFunction', './my-function').write(builder);
+        expect(builder.toString()).toBe(`export { myFunction } from './my-function';${EOL}`);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,48 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsFunctionType } from './function-type.js';
+import { tsGenericParameter } from './generic-parameter.js';
+import { tsParameter } from './parameter.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+it('should write the parameters and the return type', () => {
+    builder.append(tsFunctionType({ parameters: [tsParameter('x'), tsParameter('y')], returnType: 'number' }));
+    expect(builder.toString(false)).toBe('(x, y) => number');
+});
+it('should write the generics if they exist', () => {
+    builder.append(tsFunctionType({
+        generics: [tsGenericParameter('T'), tsGenericParameter('U')],
+        returnType: 'number',
+    }));
+    expect(builder.toString(false)).toBe('<T, U>() => number');
+});
+it('should write all the parts of the function type', () => {
+    builder.append(tsFunctionType({
+        generics: [tsGenericParameter('T'), tsGenericParameter('U')],
+        parameters: [tsParameter('x'), tsParameter('y')],
+        returnType: 'number',
+    }));
+    expect(builder.toString(false)).toBe('<T, U>(x, y) => number');
+});
+it('should render injections', () => {
+    builder.append(tsFunctionType({
+        generics: [tsGenericParameter('T'), tsGenericParameter('U')],
+        parameters: [tsParameter('x'), tsParameter('y')],
+        returnType: 'number',
+        inject: {
+            before: '║b║',
+            after: '║a║',
+            beforeGenerics: '║bg║',
+            afterGenerics: '║ag║',
+            beforeParams: '║bp║',
+            afterParams: '║ap║',
+            beforeReturnType: '║brt║',
+            afterReturnType: '║art║',
+        },
+    }));
+    expect(builder.toString(false)).toBe('║b║║bg║<T, U>║ag║║bp║(x, y)║ap║ => ║brt║number║art║║a║');
+});

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

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

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

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

@@ -0,0 +1,108 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { normalizeEOL } from '@goast/test-utils';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsDecorator } from './decorator.js';
+import { tsDoc } from './doc.js';
+import { tsFunction } from './function.js';
+import { tsGenericParameter } from './generic-parameter.js';
+import { tsParameter } from './parameter.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsFunction', () => {
+    it('should write the name of the function', () => {
+        builder.append(tsFunction('X'));
+        expect(builder.toString(false)).toBe('function X() {}' + EOL);
+    });
+    it('should write the generics if they exist', () => {
+        builder.append(tsFunction('X', { generics: [tsGenericParameter('T'), tsGenericParameter('U')] }));
+        expect(builder.toString(false)).toBe('function X<T, U>() {}' + EOL);
+    });
+    it('should write the parameters if they exist', () => {
+        builder.append(tsFunction('X', { parameters: [tsParameter('y'), tsParameter('z')] }));
+        expect(builder.toString(false)).toBe('function X(y, z) {}' + EOL);
+    });
+    it('should write the return type if it exists', () => {
+        builder.append(tsFunction('X', { returnType: 'number' }));
+        expect(builder.toString(false)).toBe('function X(): number {}' + EOL);
+    });
+    it('should write the body if it exists', () => {
+        builder.append(tsFunction('X', { body: 'return 42;' }));
+        expect(builder.toString(false)).toBe(`function X() {${EOL}  return 42;${EOL}}${EOL}`);
+    });
+    it('should write export keyword if configured', () => {
+        builder.append(tsFunction('X', { export: true }));
+        expect(builder.toString(false)).toBe('export function X() {}' + EOL);
+    });
+    it('should write documenation if it exists', () => {
+        builder.append(tsFunction('X', { doc: tsDoc({ description: 'description' }) }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}function X() {}${EOL}`);
+    });
+    it('should write decorators if they exist', () => {
+        builder.append(tsFunction('X', { decorators: [tsDecorator('decorator')] }));
+        expect(builder.toString(false)).toBe(`@decorator${EOL}function X() {}${EOL}`);
+    });
+    it('should write all the parts of the function', () => {
+        builder.append(tsFunction('X', {
+            doc: tsDoc({ description: 'description' }),
+            decorators: [tsDecorator('decorator')],
+            generics: [tsGenericParameter('T'), tsGenericParameter('U')],
+            parameters: [tsParameter('y'), tsParameter('z')],
+            returnType: 'number',
+            body: 'return 42;',
+            export: true,
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
+         * description
+         */
+        @decorator
+        export function X<T, U>(y, z): number {
+          return 42;
+        }
+        `));
+    });
+    it('should render injections', () => {
+        builder.append(tsFunction('X', {
+            doc: tsDoc({ description: 'description' }),
+            decorators: [tsDecorator('decorator')],
+            generics: [tsGenericParameter('T'), tsGenericParameter('U')],
+            parameters: [tsParameter('y'), tsParameter('z')],
+            returnType: 'number',
+            body: 'return 42;',
+            export: 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║',
+                beforeParams: '║bp║',
+                afterParams: '║ap║',
+                beforeReturnType: '║brt║',
+                afterReturnType: '║art║',
+                beforeBody: '║bb║',
+                afterBody: '║ab║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
+        /**
+         * description
+         */
+        ║ad║║bds║@decorator
+        ║ads║║bm║export ║am║function ║bn║X║an║║bg║<T, U>║ag║║bp║(y, z)║ap║: ║brt║number║art║ ║bb║{
+          return 42;
+        }║ab║
+        ║a║`));
+    });
+});

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

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

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

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

@@ -0,0 +1,70 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsGenericParameter } from './generic-parameter.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsGenericParameter', () => {
+    it('should write the name of the parameter', () => {
+        builder.append(tsGenericParameter('T'));
+        expect(builder.toString(false)).toBe('T');
+    });
+    it('should write the constraint if it exists', () => {
+        builder.append(tsGenericParameter('T', { constraint: 'number' }));
+        expect(builder.toString(false)).toBe('T extends number');
+    });
+    it('should write the default if it exists', () => {
+        builder.append(tsGenericParameter('T', { default: 'string' }));
+        expect(builder.toString(false)).toBe('T = string');
+    });
+    it('should write the const keyword if the parameter is const', () => {
+        builder.append(tsGenericParameter('T', { const: true }));
+        expect(builder.toString(false)).toBe('const T');
+    });
+    it('should write all the parts of the parameter', () => {
+        builder.append(tsGenericParameter('T', { constraint: 'number', default: '4711', const: true }));
+        expect(builder.toString(false)).toBe('const T extends number = 4711');
+    });
+    it('should render injections', () => {
+        builder.append(tsGenericParameter('T', {
+            constraint: 'number',
+            default: '4711',
+            const: true,
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeModifiers: '║bm║',
+                afterModifiers: '║am║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforeConstraint: '║bc║',
+                afterConstraint: '║ac║',
+                beforeDefault: '║bd║',
+                afterDefault: '║ad║',
+            },
+        }));
+        expect(builder.toString(false)).toBe('║b║║bm║const ║am║║bn║T║an║ extends ║bc║number║ac║ = ║bd║4711║ad║║a║');
+    });
+    describe('write', () => {
+        it('should not write anything if the node is empty', () => {
+            tsGenericParameter.write(builder, []);
+            expect(builder.toString(false)).toBe('');
+        });
+        it('should write a single parameter', () => {
+            tsGenericParameter.write(builder, [tsGenericParameter('T')]);
+            expect(builder.toString(false)).toBe('<T>');
+        });
+        it('should write all the parameters', () => {
+            tsGenericParameter.write(builder, [tsGenericParameter('T'), tsGenericParameter('U')]);
+            expect(builder.toString(false)).toBe('<T, U>');
+        });
+        it('should write multiline if more than 2 parameters', () => {
+            tsGenericParameter.write(builder, [tsGenericParameter('T'), tsGenericParameter('U'), tsGenericParameter('V')]);
+            expect(builder.toString(false)).toBe(`<${EOL}  T,${EOL}  U,${EOL}  V${EOL}>`);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,32 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsIndexer } from './indexer.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsIndexer', () => {
+    it('should write the key and value types', () => {
+        builder.append(tsIndexer('string', 'number'));
+        expect(builder.toString(false)).toBe(`[key: string]: number;${EOL}`);
+    });
+    it('should write the readonly keyword if the indexer is readonly', () => {
+        builder.append(tsIndexer('string', 'number', { readonly: true }));
+        expect(builder.toString(false)).toBe(`readonly [key: string]: number;${EOL}`);
+    });
+    it('should write the key name if it exists', () => {
+        builder.append(tsIndexer('string', 'number', { keyName: 'id' }));
+        expect(builder.toString(false)).toBe(`[id: string]: number;${EOL}`);
+    });
+    it('should render injections', () => {
+        builder.append(tsIndexer('string', 'number', {
+            keyName: 'id',
+            readonly: true,
+            inject: { before: '║b║', after: '║a║' },
+        }));
+        expect(builder.toString(false)).toBe(`║b║readonly [id: string]: number;${EOL}║a║`);
+    });
+});

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

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

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

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

@@ -0,0 +1,115 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { normalizeEOL } from '@goast/test-utils';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsDecorator } from './decorator.js';
+import { tsDoc } from './doc.js';
+import { tsGenericParameter } from './generic-parameter.js';
+import { tsInterface } from './interface.js';
+import { tsMethod } from './method.js';
+import { tsProperty } from './property.js';
+import { tsReference } from './reference.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsInterface', () => {
+    it('should write the name of the interface', () => {
+        builder.append(tsInterface('X'));
+        expect(builder.toString(false)).toBe(`interface X {}${EOL}`);
+    });
+    it('should write the generics if they exist', () => {
+        builder.append(tsInterface('X', { generics: [tsGenericParameter('T'), tsGenericParameter('U')] }));
+        expect(builder.toString(false)).toBe(`interface X<T, U> {}${EOL}`);
+    });
+    it('should write the extends if it exists', () => {
+        builder.append(tsInterface('X', { extends: [tsReference('Y'), tsReference('Z')] }));
+        expect(builder.toString(false)).toBe(`interface X extends Y, Z {}${EOL}`);
+    });
+    it('should write the properties if they exist', () => {
+        builder.append(tsInterface('X', { members: [tsProperty('x'), tsProperty('y')] }));
+        expect(builder.toString(false)).toBe(`interface X {${EOL}  x;${EOL}  y;${EOL}}${EOL}`);
+    });
+    it('should write the methods if they exist', () => {
+        builder.append(tsInterface('X', { members: [tsMethod('x'), tsMethod('y')] }));
+        expect(builder.toString(false)).toBe(`interface X {${EOL}  x();${EOL}  y();${EOL}}${EOL}`);
+    });
+    it('should write export keyword if configured', () => {
+        builder.append(tsInterface('X', { export: true }));
+        expect(builder.toString(false)).toBe(`export interface X {}${EOL}`);
+    });
+    it('should write the doc if it exists', () => {
+        builder.append(tsInterface('X', { doc: tsDoc({ description: 'description' }) }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}interface X {}${EOL}`);
+    });
+    it('should write the decorators if they exist', () => {
+        builder.append(tsInterface('X', { decorators: [tsDecorator('decorator')] }));
+        expect(builder.toString(false)).toBe(`@decorator${EOL}interface X {}${EOL}`);
+    });
+    it('should write all the parts of the interface', () => {
+        builder.append(tsInterface('X', {
+            doc: tsDoc({ description: 'description' }),
+            decorators: [tsDecorator('decorator')],
+            generics: [tsGenericParameter('T'), tsGenericParameter('U')],
+            extends: [tsReference('Y'), tsReference('Z')],
+            members: [tsProperty('x'), tsProperty('y'), tsMethod('x'), tsMethod('y')],
+            export: true,
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
+         * description
+         */
+        @decorator
+        export interface X<T, U> extends Y, Z {
+          x;
+          y;
+          x();
+          y();
+        }
+        `));
+    });
+    it('should render injections', () => {
+        builder.append(tsInterface('X', {
+            doc: tsDoc({ description: 'description' }),
+            decorators: [tsDecorator('decorator')],
+            generics: [tsGenericParameter('T'), tsGenericParameter('U')],
+            extends: [tsReference('Y'), tsReference('Z')],
+            members: [tsProperty('x'), tsProperty('y'), tsMethod('x'), tsMethod('y')],
+            export: 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║',
+                beforeBody: '║bb║',
+                afterBody: '║ab║',
+                beforeMembers: '║bm║',
+                afterMembers: '║am║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
+        /**
+         * description
+         */
+        ║ad║║bds║@decorator
+        ║ads║║bm║export ║am║interface ║bn║X║an║║bg║<T, U>║ag║ extends ║be║Y, Z║ae║ ║bb║{
+          ║bm║x;
+          y;
+          x();
+          y();
+          ║am║
+        }║ab║
+        ║a║`));
+    });
+});

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

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

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

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