@goast/typescript 0.4.3 → 0.4.4

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

@@ -0,0 +1,38 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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

@@ -0,0 +1,148 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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

@@ -0,0 +1,30 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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

@@ -0,0 +1,30 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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

@@ -0,0 +1,71 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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

@@ -0,0 +1,102 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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

@@ -0,0 +1,89 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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

@@ -0,0 +1,31 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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

@@ -0,0 +1,28 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/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

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

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

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