@goast/typescript 0.5.0 → 0.5.1-k6.1

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

@@ -1,38 +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 { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsIntersectionType } from './intersection-type.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-describe('tsIntersectionType', () => {
-    it('should write type "unknown" if no types are provided', () => {
-        builder.append(tsIntersectionType([]));
-        expect(builder.toString(false)).toBe('unknown');
-    });
-    it('should write the type if only one type is provided', () => {
-        builder.append(tsIntersectionType(['string']));
-        expect(builder.toString(false)).toBe('string');
-    });
-    it('should write the types', () => {
-        builder.append(tsIntersectionType(['string', 'number']));
-        expect(builder.toString(false)).toBe('(string) & (number)');
-    });
-    it('should write the types on separate lines if there are more than 3', () => {
-        builder.append(tsIntersectionType(['string', 'number', 'boolean', 'unknown']));
-        expect(builder.toString(false)).toBe(`${EOL}& (string)${EOL}& (number)${EOL}& (boolean)${EOL}& (unknown)`);
-    });
-    it('should collapse nested intersection types', () => {
-        builder.append(tsIntersectionType([tsIntersectionType(['string', 'number']), tsIntersectionType(['boolean', 'unknown'])]));
-        expect(builder.toString(false)).toBe(`${EOL}& (string)${EOL}& (number)${EOL}& (boolean)${EOL}& (unknown)`);
-    });
-    it('should render injections', () => {
-        builder.append(tsIntersectionType(['string', 'number'], {
-            inject: { before: '║b║', after: '║a║' },
-        }));
-        expect(builder.toString(false)).toBe('║b║(string) & (number)║a║');
-    });
-});

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

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

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

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

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

@@ -1,148 +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, 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 { tsDecorator } from './decorator.js';
-import { tsDoc } from './doc.js';
-import { tsGenericParameter } from './generic-parameter.js';
-import { tsMethod } from './method.js';
-import { tsParameter } from './parameter.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-it('should write the name of the method', () => {
-    builder.append(tsMethod('x'));
-    expect(builder.toString(false)).toBe('x();' + EOL);
-});
-it('should write the generics if they exist', () => {
-    builder.append(tsMethod('x', { generics: [tsGenericParameter('T'), tsGenericParameter('U')] }));
-    expect(builder.toString(false)).toBe('x<T, U>();' + EOL);
-});
-it('should write the parameters if they exist', () => {
-    builder.append(tsMethod('x', { parameters: [tsParameter('y'), tsParameter('z')] }));
-    expect(builder.toString(false)).toBe('x(y, z);' + EOL);
-});
-it('should write the return type if it exists', () => {
-    builder.append(tsMethod('x', { returnType: 'number' }));
-    expect(builder.toString(false)).toBe('x(): number;' + EOL);
-});
-it('should write the body if it exists', () => {
-    builder.append(tsMethod('x', { body: 'return 42;' }));
-    expect(builder.toString(false)).toBe(`x() {${EOL}  return 42;${EOL}}${EOL}`);
-});
-it('should write the accessibility if it exists', () => {
-    builder.append(tsMethod('x', { accessModifier: 'public' }));
-    expect(builder.toString(false)).toBe('public x();' + EOL);
-});
-it('should write the static keyword if the method is static', () => {
-    builder.append(tsMethod('x', { static: true }));
-    expect(builder.toString(false)).toBe('static x();' + EOL);
-});
-it('should write the abstract keyword if the method is abstract', () => {
-    builder.append(tsMethod('x', { abstract: true }));
-    expect(builder.toString(false)).toBe('abstract x();' + EOL);
-});
-it('should write the override keyword if the method is override', () => {
-    builder.append(tsMethod('x', { override: true }));
-    expect(builder.toString(false)).toBe('override x();' + EOL);
-});
-it('should write the optional symbol if the method is optional', () => {
-    builder.append(tsMethod('x', { optional: true }));
-    expect(builder.toString(false)).toBe('x?();' + EOL);
-});
-it('should write documenation if it exists', () => {
-    builder.append(tsMethod('x', { doc: tsDoc({ description: 'description' }) }));
-    expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}x();${EOL}`);
-});
-it('should write parameter documentation if it exists', () => {
-    builder.append(tsMethod('x', {
-        parameters: [tsParameter('y', { description: 'description' })],
-    }));
-    expect(builder.toString(false)).toBe(`/**${EOL} * @param y description${EOL} */${EOL}x(y);${EOL}`);
-});
-it('should write generic parameter documentation if it exists', () => {
-    builder.append(tsMethod('x', {
-        generics: [tsGenericParameter('T', { description: 'description' })],
-    }));
-    expect(builder.toString(false)).toBe(`/**${EOL} * @template T description${EOL} */${EOL}x<T>();${EOL}`);
-});
-it('should write decorators if they exist', () => {
-    builder.append(tsMethod('x', { decorators: [tsDecorator('decorator')] }));
-    expect(builder.toString(false)).toBe(`@decorator${EOL}x();${EOL}`);
-});
-it('should write all the parts of the method', () => {
-    builder.append(tsMethod('x', {
-        doc: tsDoc({ description: 'description' }),
-        decorators: [tsDecorator('decorator')],
-        generics: [tsGenericParameter('T'), tsGenericParameter('U', { description: 'description for U' })],
-        parameters: [tsParameter('y'), tsParameter('z', { description: 'description for z' })],
-        returnType: 'number',
-        body: 'return 42;',
-        accessModifier: 'public',
-        static: true,
-        abstract: true,
-        override: true,
-        optional: true,
-    }));
-    expect(builder.toString(false)).toBe(normalizeEOL(6)(`/**
-       * description
-       *
-       * @template U description for U
-       * @param z description for z
-       */
-      @decorator
-      public static abstract override x?<T, U>(y, z): number {
-        return 42;
-      }
-      `));
-});
-it('should render injections', () => {
-    builder.append(tsMethod('x', {
-        doc: tsDoc({ description: 'description' }),
-        decorators: [tsDecorator('decorator')],
-        generics: [tsGenericParameter('T'), tsGenericParameter('U', { description: 'description for U' })],
-        parameters: [tsParameter('y'), tsParameter('z', { description: 'description for z' })],
-        returnType: 'number',
-        body: 'return 42;',
-        accessModifier: 'public',
-        static: true,
-        abstract: true,
-        override: true,
-        optional: 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(6)(`║b║║bd║
-      /**
-       * description
-       *
-       * @template U description for U
-       * @param z description for z
-       */
-      ║ad║║bds║@decorator
-      ║ads║║bm║public static abstract override ║am║║bn║x║an║?║bg║<T, U>║ag║║bp║(y, z)║ap║: ║brt║number║art║ ║bb║{
-        return 42;
-      }║ab║
-      ║a║`));
-});

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

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

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

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

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

@@ -1,30 +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, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsMethod } from './method.js';
-import { tsObjectType } from './object-type.js';
-import { tsProperty } from './property.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-it('should write the properties if they exist', () => {
-    builder.append(tsObjectType({ members: [tsProperty('x'), tsProperty('y')] }));
-    expect(builder.toString(false)).toBe('{' + EOL + '  x;' + EOL + '  y;' + EOL + '}');
-});
-it('should write the methods if they exist', () => {
-    builder.append(tsObjectType({ members: [tsMethod('x'), tsMethod('y')] }));
-    expect(builder.toString(false)).toBe('{' + EOL + '  x();' + EOL + '  y();' + EOL + '}');
-});
-it('should write all the parts of the object type', () => {
-    builder.append(tsObjectType({
-        members: [tsProperty('x'), tsProperty('y'), tsMethod('x'), tsMethod('y')],
-    }));
-    expect(builder.toString(false)).toBe('{' + EOL + '  x;' + EOL + '  y;' + EOL + '  x();' + EOL + '  y();' + EOL + '}');
-});
-it('should render injections', () => {
-    builder.append(tsObjectType({ inject: { before: ['before'], after: ['after'] } }));
-    expect(builder.toString(false)).toBe(`before{}after`);
-});

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

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

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

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

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

@@ -1,30 +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, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsMethod } from './method.js';
-import { tsObject } from './object.js';
-import { tsProperty } from './property.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-it('should write the properties if they exist', () => {
-    builder.append(tsObject({ members: [tsProperty('x'), tsProperty('y')] }));
-    expect(builder.toString(false)).toBe('{' + EOL + '  x,' + EOL + '  y,' + EOL + '}');
-});
-it('should write the methods if they exist', () => {
-    builder.append(tsObject({ members: [tsMethod('x'), tsMethod('y')] }));
-    expect(builder.toString(false)).toBe('{' + EOL + '  x(),' + EOL + '  y(),' + EOL + '}');
-});
-it('should write all the parts of the object', () => {
-    builder.append(tsObject({
-        members: [tsProperty('x'), tsProperty('y'), tsMethod('x'), tsMethod('y')],
-    }));
-    expect(builder.toString(false)).toBe('{' + EOL + '  x,' + EOL + '  y,' + EOL + '  x(),' + EOL + '  y(),' + EOL + '}');
-});
-it('should render injections', () => {
-    builder.append(tsObject({ inject: { before: ['before'], after: ['after'] } }));
-    expect(builder.toString(false)).toBe(`before{}after`);
-});

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

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

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

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

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

@@ -1,71 +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 { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsDecorator } from './decorator.js';
-import { tsParameter } from './parameter.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-describe('single', () => {
-    it('should write the name of the parameter', () => {
-        builder.append(tsParameter('x'));
-        expect(builder.toString(false)).toBe('x');
-    });
-    it('should write the type if it exists', () => {
-        builder.append(tsParameter('x', { type: 'number' }));
-        expect(builder.toString(false)).toBe('x: number');
-    });
-    it('should write the default if it exists', () => {
-        builder.append(tsParameter('x', { default: '42' }));
-        expect(builder.toString(false)).toBe('x = 42');
-    });
-    it('should write the optional symbol if the parameter is optional', () => {
-        builder.append(tsParameter('x', { optional: true }));
-        expect(builder.toString(false)).toBe('x?');
-    });
-    it('should write decorators', () => {
-        builder.append(tsParameter('x', { decorators: [tsDecorator('decorator')] }));
-        expect(builder.toString(false)).toBe('@decorator x');
-    });
-    it('should write all the parts of the parameter', () => {
-        builder.append(tsParameter('x', { decorators: [tsDecorator('decorator')], type: 'number', default: '42', optional: true }));
-        expect(builder.toString(false)).toBe('@decorator x?: number = 42');
-    });
-    it('should render injections', () => {
-        builder.append(tsParameter('x', {
-            decorators: [tsDecorator('decorator')],
-            type: 'number',
-            default: '42',
-            optional: true,
-            inject: {
-                before: '║b║',
-                after: '║a║',
-                beforeDecorators: '║bd║',
-                afterDecorators: '║ad║',
-                beforeName: '║bn║',
-                afterName: '║an║',
-                beforeType: '║bt║',
-                afterType: '║at║',
-                beforeDefault: '║bdf║',
-                afterDefault: '║adf║',
-            },
-        }));
-        expect(builder.toString(false)).toBe('║b║║bd║@decorator ║ad║║bn║x║an║?: ║bt║number║at║ = ║bdf║42║adf║║a║');
-    });
-});
-describe('multiple', () => {
-    it('should write parenthesis if the node is empty', () => {
-        tsParameter.write(builder, []);
-        expect(builder.toString(false)).toBe('()');
-    });
-    it('should write a single parameter', () => {
-        tsParameter.write(builder, [tsParameter('x')]);
-        expect(builder.toString(false)).toBe('(x)');
-    });
-    it('should write all the parameters', () => {
-        tsParameter.write(builder, [tsParameter('x'), tsParameter('y')]);
-        expect(builder.toString(false)).toBe('(x, y)');
-    });
-});

package/esm/src/ast/nodes/property-accessor.test.d.ts

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

package/esm/src/ast/nodes/property-accessor.test.d.ts.map

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

package/esm/src/ast/nodes/property-accessor.test.js

@@ -1,102 +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 { TypeScriptFileBuilder } from '../../file-builder.js';
-import { createPropertyGetter, createPropertySetter } from './property-accessor.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-describe('TsPropertySetter', () => {
-    it('should write the name of the method', () => {
-        builder.append(createPropertySetter({ propertyName: 'x' }));
-        expect(builder.toString(false)).toBe('set x(value);' + EOL);
-    });
-    it('should write the type if it exists', () => {
-        builder.append(createPropertySetter({ propertyName: 'x', type: 'number' }));
-        expect(builder.toString(false)).toBe('set x(value: number);' + EOL);
-    });
-    it('should write the body if it exists', () => {
-        builder.append(createPropertySetter({ propertyName: 'x', body: 'this.x = value;' }));
-        expect(builder.toString(false)).toBe(`set x(value) {${EOL}  this.x = value;${EOL}}${EOL}`);
-    });
-    it('should write the accessibility if it exists', () => {
-        builder.append(createPropertySetter({ propertyName: 'x', accessModifier: 'public' }));
-        expect(builder.toString(false)).toBe('public set x(value);' + EOL);
-    });
-    it('should write the static keyword if the method is static', () => {
-        builder.append(createPropertySetter({ propertyName: 'x', static: true }));
-        expect(builder.toString(false)).toBe('static set x(value);' + EOL);
-    });
-    it('should write the abstract keyword if the method is abstract', () => {
-        builder.append(createPropertySetter({ propertyName: 'x', abstract: true }));
-        expect(builder.toString(false)).toBe('abstract set x(value);' + EOL);
-    });
-    it('should write the override keyword if the method is override', () => {
-        builder.append(createPropertySetter({ propertyName: 'x', override: true }));
-        expect(builder.toString(false)).toBe('override set x(value);' + EOL);
-    });
-    it('should write all the parts of the method', () => {
-        builder.append(createPropertySetter({
-            propertyName: 'x',
-            type: 'number',
-            body: 'this.x = value;',
-            accessModifier: 'public',
-            static: true,
-            abstract: true,
-            override: true,
-        }));
-        expect(builder.toString(false)).toBe(`public static abstract override set x(value: number) {${EOL}  this.x = value;${EOL}}${EOL}`);
-    });
-    it('should render injections', () => {
-        builder.append(createPropertySetter({ propertyName: 'x', inject: { before: ['before'], after: ['after'] } }));
-        expect(builder.toString(false)).toBe(`beforeset x(value);${EOL}after`);
-    });
-});
-describe('TsPropertyGetter', () => {
-    it('should write the name of the method', () => {
-        builder.append(createPropertyGetter({ propertyName: 'x' }));
-        expect(builder.toString(false)).toBe('get x();' + EOL);
-    });
-    it('should write the type if it exists', () => {
-        builder.append(createPropertyGetter({ propertyName: 'x', type: 'number' }));
-        expect(builder.toString(false)).toBe('get x(): number;' + EOL);
-    });
-    it('should write the body if it exists', () => {
-        builder.append(createPropertyGetter({ propertyName: 'x', body: 'return this.x;' }));
-        expect(builder.toString(false)).toBe(`get x() {${EOL}  return this.x;${EOL}}${EOL}`);
-    });
-    it('should write the accessibility if it exists', () => {
-        builder.append(createPropertyGetter({ propertyName: 'x', accessModifier: 'public' }));
-        expect(builder.toString(false)).toBe('public get x();' + EOL);
-    });
-    it('should write the static keyword if the method is static', () => {
-        builder.append(createPropertyGetter({ propertyName: 'x', static: true }));
-        expect(builder.toString(false)).toBe('static get x();' + EOL);
-    });
-    it('should write the abstract keyword if the method is abstract', () => {
-        builder.append(createPropertyGetter({ propertyName: 'x', abstract: true }));
-        expect(builder.toString(false)).toBe('abstract get x();' + EOL);
-    });
-    it('should write the override keyword if the method is override', () => {
-        builder.append(createPropertyGetter({ propertyName: 'x', override: true }));
-        expect(builder.toString(false)).toBe('override get x();' + EOL);
-    });
-    it('should write all the parts of the method', () => {
-        builder.append(createPropertyGetter({
-            propertyName: 'x',
-            type: 'number',
-            body: 'return this.x;',
-            accessModifier: 'public',
-            static: true,
-            abstract: true,
-            override: true,
-        }));
-        expect(builder.toString(false)).toBe(`public static abstract override get x(): number {${EOL}  return this.x;${EOL}}${EOL}`);
-    });
-    it('should render injections', () => {
-        builder.append(createPropertyGetter({ propertyName: 'x', inject: { before: ['before'], after: ['after'] } }));
-        expect(builder.toString(false)).toBe(`beforeget x();${EOL}after`);
-    });
-});

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

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

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

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

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

@@ -1,89 +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 { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsProperty } from './property.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-describe('tsProperty', () => {
-    it('should write the name of the property', () => {
-        builder.append(tsProperty('x'));
-        expect(builder.toString(false)).toBe('x;' + EOL);
-    });
-    it('should put name in quotes if needed', () => {
-        builder.append(tsProperty('x y'));
-        expect(builder.toString(false)).toBe("'x y';" + EOL);
-    });
-    it('should write the type if it exists', () => {
-        builder.append(tsProperty('x', { type: 'number' }));
-        expect(builder.toString(false)).toBe('x: number;' + EOL);
-    });
-    it('should write the value if it exists', () => {
-        builder.append(tsProperty('x', { value: '42' }));
-        expect(builder.toString(false)).toBe('x = 42;' + EOL);
-    });
-    it('should write the readonly keyword if the property is readonly', () => {
-        builder.append(tsProperty('x', { readonly: true }));
-        expect(builder.toString(false)).toBe('readonly x;' + EOL);
-    });
-    it('should write the accessibility if it exists', () => {
-        builder.append(tsProperty('x', { accessModifier: 'public' }));
-        expect(builder.toString(false)).toBe('public x;' + EOL);
-    });
-    it('should write the static keyword if the property is static', () => {
-        builder.append(tsProperty('x', { static: true }));
-        expect(builder.toString(false)).toBe('static x;' + EOL);
-    });
-    it('should write the abstract keyword if the property is abstract', () => {
-        builder.append(tsProperty('x', { abstract: true }));
-        expect(builder.toString(false)).toBe('abstract x;' + EOL);
-    });
-    it('should write the override keyword if the property is override', () => {
-        builder.append(tsProperty('x', { override: true }));
-        expect(builder.toString(false)).toBe('override x;' + EOL);
-    });
-    it('should write the optional symbol if the property is optional', () => {
-        builder.append(tsProperty('x', { optional: true }));
-        expect(builder.toString(false)).toBe('x?;' + EOL);
-    });
-    it('should write all the parts of the property', () => {
-        builder.append(tsProperty('x', {
-            type: 'number',
-            value: 42,
-            readonly: true,
-            accessModifier: 'public',
-            static: true,
-            abstract: true,
-            override: true,
-            optional: true,
-        }));
-        expect(builder.toString(false)).toBe('public static abstract override readonly x?: number = 42;' + EOL);
-    });
-    it('should write getter and setter', () => {
-        builder.append(tsProperty('x', { get: tsProperty.getter(), set: tsProperty.setter() }));
-        expect(builder.toString(false)).toBe('get x();' + EOL + 'set x(value);' + EOL);
-    });
-    it('should write getter only', () => {
-        builder.append(tsProperty('x', { get: tsProperty.getter() }));
-        expect(builder.toString(false)).toBe('get x();' + EOL);
-    });
-    it('should write setter only', () => {
-        builder.append(tsProperty('x', { set: tsProperty.setter() }));
-        expect(builder.toString(false)).toBe('set x(value);' + EOL);
-    });
-    it('should render injections', () => {
-        builder.append(tsProperty('x', { inject: { before: ['before'], after: ['after'] } }));
-        expect(builder.toString(false)).toBe(`beforex;${EOL}after`);
-    });
-    it('should render injections with getter and setter', () => {
-        builder.append(tsProperty('x', {
-            get: tsProperty.getter(),
-            set: tsProperty.setter(),
-            inject: { before: ['before'], after: ['after'] },
-        }));
-        expect(builder.toString(false)).toBe(`beforeget x();${EOL}set x(value);${EOL}after`);
-    });
-});

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

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

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

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

package/esm/src/ast/nodes/reference.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.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 { tsReference } from './reference.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-describe('tsReference', () => {
-    it('should write the name of the reference', () => {
-        builder.append(tsReference('X'));
-        expect(builder.toString(false)).toBe('X');
-    });
-    it('should write the generics if they exist', () => {
-        builder.append(tsReference('X', null, { generics: ['T', 'U'] }));
-        expect(builder.toString(false)).toBe('X<T, U>');
-    });
-    it('should add the import if module name of file path is provided', () => {
-        builder.append(tsReference('X', 'module'));
-        expect(builder.imports.imports).toEqual([
-            { kind: 'module', modulePath: 'module', name: 'X', type: 'import' },
-        ]);
-        expect(builder.toString(false)).toBe(`import { X } from 'module';${EOL}X`);
-    });
-    it('should write the injections', () => {
-        builder.append(tsReference('X', null, { generics: ['T', 'U'], inject: { before: '║b║', after: '║a║' } }));
-        expect(builder.toString(false)).toBe('║b║X<T, U>║a║');
-    });
-});

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

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

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

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

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

@@ -1,28 +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 { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsString } from './string.js';
-let builder;
-beforeEach(() => {
-    builder = new TypeScriptFileBuilder();
-});
-describe('tsString', () => {
-    it('should write the string', () => {
-        builder.append(tsString('X'));
-        expect(builder.toString(false)).toBe(`'X'`);
-    });
-    it('should use double quotes if configured', () => {
-        builder.options.useSingleQuotes = false;
-        builder.append(tsString('X'));
-        expect(builder.toString(false)).toBe(`"X"`);
-    });
-    it('should write the string as template string if configured', () => {
-        builder.append(tsString('X', { template: true }));
-        expect(builder.toString(false)).toBe('`X`');
-    });
-    it('should write the injections', () => {
-        builder.append(tsString('X', { inject: { before: '║b║', after: '║a║' } }));
-        expect(builder.toString(false)).toBe(`║b║'X'║a║`);
-    });
-});

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

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

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

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