@goast/typescript 0.4.1 → 0.4.2

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

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

@@ -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"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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