@terra-graph/core 1.0.0-rc.4

package/dist/esm/Graph/Serialization/index.d.ts

@@ -0,0 +1 @@
+export * from './Registry.js';

package/dist/esm/Graph/Serialization/index.js

@@ -0,0 +1 @@
+export * from './Registry.js';

package/dist/esm/Graph/TgGraph.d.ts

@@ -0,0 +1,82 @@
+export type NodeId = string & {
+    readonly __brand: 'NodeId';
+};
+export type EdgeId = string & {
+    readonly __brand: 'EdgeId';
+};
+export declare const TG_ID_NAMESPACE = "tg";
+export declare const TG_SCHEMA_VERSION = "1.0.0";
+export type TgNodeKind = 'resource' | 'data' | 'local' | 'var' | 'output' | 'module' | 'provider' | 'root' | 'meta' | 'terraform';
+export type ParsedTgNodeId = {
+    namespace: string;
+    version: string;
+    kind: string;
+    address: string;
+};
+export type TgEdgeLegendAttribute = {
+    title: string;
+    colour: string;
+};
+export type TgEdgeRenderHints = {
+    resource: string;
+    name: string;
+};
+export declare const TgEdgeDirectionSemantics: {
+    readonly Invokes: "invokes";
+    readonly Accesses: "accesses";
+    readonly Publishes: "publishes";
+    readonly Triggers: "triggers";
+    readonly Routes: "routes";
+    readonly Authorizes: "authorizes";
+    readonly ObservedBy: "observedBy";
+};
+export type TgEdgeDirectionSemantic = (typeof TgEdgeDirectionSemantics)[keyof typeof TgEdgeDirectionSemantics];
+export declare const TG_EDGE_DIRECTION_SEMANTICS: readonly TgEdgeDirectionSemantic[];
+export declare const isTgEdgeDirectionSemantic: (value: unknown) => value is TgEdgeDirectionSemantic;
+export interface TgEdgeAttributes extends Record<string, unknown> {
+    directionSemantic?: TgEdgeDirectionSemantic;
+    legend?: TgEdgeLegendAttribute;
+    renderHints?: TgEdgeRenderHints;
+    adapter?: Record<string, Record<string, unknown>>;
+}
+export type TgEdge = {
+    id: EdgeId;
+    from: NodeId;
+    to: NodeId;
+    attributes?: TgEdgeAttributes;
+};
+export type TgNodeTerraform = {
+    kind?: TgNodeKind;
+    address?: string;
+    resource?: string;
+    name?: string;
+    moduleAddress?: string;
+    parentModuleName?: string;
+    parentModuleNodeId?: NodeId;
+};
+export type TgNodeLabelHints = {
+    end?: string;
+};
+export type TgNodeHints = {
+    label?: TgNodeLabelHints;
+};
+export type TgNodeAttributes = {
+    terraform?: TgNodeTerraform;
+    hints?: TgNodeHints;
+    adapter?: Record<string, Record<string, unknown>>;
+    [key: string]: unknown;
+};
+export type TgNode = {
+    id: NodeId;
+} & TgNodeAttributes;
+export type TgGraph = {
+    schemaVersion: string;
+    nodes: Record<string, TgNode>;
+    edges: TgEdge[];
+    description: Record<string, string>;
+};
+export declare const edgeIdFrom: (from: NodeId, to: NodeId, suffix?: string, version?: string) => EdgeId;
+export declare const tgNodeIdFrom: (kind: TgNodeKind, address: string, version?: string) => NodeId;
+export declare const parseTgNodeId: (value: NodeId | string) => ParsedTgNodeId | undefined;
+export declare const asNodeId: (value: string) => NodeId;
+export declare const asEdgeId: (value: string) => EdgeId;

package/dist/esm/Graph/TgGraph.js

@@ -0,0 +1,46 @@
+// this is DOT / graphviz specific?
+// export type TgGraphMeta = {
+//   directed: boolean;
+//   multigraph: boolean;
+//   compound: boolean;
+// };
+export const TG_ID_NAMESPACE = 'tg';
+export const TG_SCHEMA_VERSION = '1.0.0';
+export const TgEdgeDirectionSemantics = {
+    Invokes: 'invokes',
+    Accesses: 'accesses',
+    Publishes: 'publishes',
+    Triggers: 'triggers',
+    Routes: 'routes',
+    Authorizes: 'authorizes',
+    ObservedBy: 'observedBy',
+};
+export const TG_EDGE_DIRECTION_SEMANTICS = Object.freeze(Object.values(TgEdgeDirectionSemantics));
+export const isTgEdgeDirectionSemantic = (value) => {
+    return (typeof value === 'string' &&
+        TG_EDGE_DIRECTION_SEMANTICS.includes(value));
+};
+export const edgeIdFrom = (from, to, suffix, version = TG_SCHEMA_VERSION) => {
+    const base = `${TG_ID_NAMESPACE}:${version}:edge:${from}->${to}`;
+    return (suffix ? `${base}:${suffix}` : base);
+};
+export const tgNodeIdFrom = (kind, address, version = TG_SCHEMA_VERSION) => `${TG_ID_NAMESPACE}:${version}:${kind}:${address}`;
+export const parseTgNodeId = (value) => {
+    const nodeId = String(value);
+    const parts = nodeId.split(':');
+    if (parts.length < 4) {
+        return undefined;
+    }
+    const [namespace, version, kind, ...addressParts] = parts;
+    if (namespace !== TG_ID_NAMESPACE || addressParts.length === 0) {
+        return undefined;
+    }
+    return {
+        namespace,
+        version,
+        kind,
+        address: addressParts.join(':'),
+    };
+};
+export const asNodeId = (value) => value;
+export const asEdgeId = (value) => value;

package/dist/esm/Graph/TgGraph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/Graph/TgGraph.test.js

@@ -0,0 +1,59 @@
+import { TG_EDGE_DIRECTION_SEMANTICS, TG_SCHEMA_VERSION, asEdgeId, asNodeId, edgeIdFrom, isTgEdgeDirectionSemantic, parseTgNodeId, tgNodeIdFrom, } from './TgGraph.js';
+describe('TgGraph.edgeIdFrom', () => {
+    it('should create expected id without suffix', () => {
+        expect(edgeIdFrom(asNodeId('from'), asNodeId('to'))).toStrictEqual(`tg:${TG_SCHEMA_VERSION}:edge:from->to`);
+    });
+    it('should create expected id with suffix', () => {
+        expect(edgeIdFrom(asNodeId('from'), asNodeId('to'), 'suffix')).toStrictEqual(`tg:${TG_SCHEMA_VERSION}:edge:from->to:suffix`);
+    });
+});
+describe('TgGraph.tgNodeIdFrom', () => {
+    it('should create expected namespaced id', () => {
+        expect(tgNodeIdFrom('resource', 'aws_s3_bucket.example')).toStrictEqual(`tg:${TG_SCHEMA_VERSION}:resource:aws_s3_bucket.example`);
+    });
+});
+describe('TgGraph.parseTgNodeId', () => {
+    it('should parse namespaced ids', () => {
+        expect(parseTgNodeId(`tg:${TG_SCHEMA_VERSION}:resource:aws_s3_bucket.example`)).toStrictEqual({
+            namespace: 'tg',
+            version: TG_SCHEMA_VERSION,
+            kind: 'resource',
+            address: 'aws_s3_bucket.example',
+        });
+    });
+    it('should return undefined for invalid namespaces or missing addresses', () => {
+        expect(parseTgNodeId('not-tg:1.0.0:resource:one')).toBeUndefined();
+        expect(parseTgNodeId(`tg:${TG_SCHEMA_VERSION}:resource`)).toBeUndefined();
+    });
+});
+describe('TgGraph.asNodeId', () => {
+    it('should return the same string value, branded as a NodeId', () => {
+        const id = asNodeId('node-1');
+        expect(id).toBe('node-1');
+        const _assert = id;
+    });
+});
+describe('TgGraph.asEdgeId', () => {
+    it('should return the same string value, branded as an EdgeId', () => {
+        const id = asEdgeId('edge-1');
+        expect(id).toBe('edge-1');
+        const _assert = id;
+    });
+});
+describe('TgGraph.TgEdgeDirectionSemantic', () => {
+    it('should include expected direction semantic values', () => {
+        expect(TG_EDGE_DIRECTION_SEMANTICS).toStrictEqual([
+            'invokes',
+            'accesses',
+            'publishes',
+            'triggers',
+            'routes',
+            'authorizes',
+            'observedBy',
+        ]);
+    });
+    it('should validate direction semantic values', () => {
+        expect(isTgEdgeDirectionSemantic('invokes')).toBe(true);
+        expect(isTgEdgeDirectionSemantic('unknown')).toBe(false);
+    });
+});

package/dist/esm/Graph/index.d.ts

@@ -0,0 +1,15 @@
+export * from './Adapter.js';
+export * from './Importer.js';
+export * from './Renderer.js';
+export * from './TgGraph.js';
+export * from './RuleError.js';
+export * from './GraphResolver.js';
+export * from './GraphPlugin.js';
+export * from './Profile.js';
+export * from './ProfileRegistry.js';
+export * from './Adapters/index.js';
+export * from './Importers/index.js';
+export * from './Operations/index.js';
+export * from './Renderers/index.js';
+export * from './Rules/index.js';
+export * from './Serialization/index.js';

package/dist/esm/Graph/index.js

@@ -0,0 +1,15 @@
+export * from './Adapter.js';
+export * from './Importer.js';
+export * from './Renderer.js';
+export * from './TgGraph.js';
+export * from './RuleError.js';
+export * from './GraphResolver.js';
+export * from './GraphPlugin.js';
+export * from './Profile.js';
+export * from './ProfileRegistry.js';
+export * from './Adapters/index.js';
+export * from './Importers/index.js';
+export * from './Operations/index.js';
+export * from './Renderers/index.js';
+export * from './Rules/index.js';
+export * from './Serialization/index.js';

package/dist/esm/Output/ArtifactTransformer/DotCliArtifactTransformer.d.ts

@@ -0,0 +1,25 @@
+import { RenderArtifact } from '../../Graph/Renderer.js';
+import { ArtifactTransformInput, ArtifactTransformer } from '../ArtifactTransformer.js';
+export type DotCliRunProcessInput = {
+    executable: string;
+    args: string[];
+    stdin: string;
+};
+export type DotCliRunProcess = (input: DotCliRunProcessInput) => Promise<Uint8Array>;
+export type DotCliArtifactTransformerOptions = {
+    format: string;
+    executable?: string;
+    dotArgs?: string[];
+    runProcess?: DotCliRunProcess;
+};
+export declare class DotCliArtifactTransformer implements ArtifactTransformer {
+    private readonly options;
+    private readonly executable;
+    private readonly runProcess;
+    constructor(options: DotCliArtifactTransformerOptions);
+    transform(input: ArtifactTransformInput): Promise<RenderArtifact>;
+    private isDotArtifact;
+    private toUtf8;
+    private static resolveMediaType;
+    private readonly defaultRunProcess;
+}

package/dist/esm/Output/ArtifactTransformer/DotCliArtifactTransformer.js

@@ -0,0 +1,82 @@
+import { spawn } from 'node:child_process';
+const dotMediaTypeByFormat = {
+    dot: 'text/vnd.graphviz',
+    json: 'application/json',
+    pdf: 'application/pdf',
+    png: 'image/png',
+    svg: 'image/svg+xml',
+};
+export class DotCliArtifactTransformer {
+    options;
+    executable;
+    runProcess;
+    constructor(options) {
+        this.options = options;
+        this.executable = options.executable ?? 'dot';
+        this.runProcess = options.runProcess ?? this.defaultRunProcess;
+    }
+    async transform(input) {
+        if (!this.isDotArtifact(input.artifact)) {
+            throw new Error("DotCliArtifactTransformer can only transform DOT artifacts ('text/vnd.graphviz' or extension 'dot')");
+        }
+        const args = [`-T${this.options.format}`, ...(this.options.dotArgs ?? [])];
+        const stdin = this.toUtf8(input.artifact.content);
+        let content;
+        try {
+            content = await this.runProcess({
+                executable: this.executable,
+                args,
+                stdin,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`DotCliArtifactTransformer failed for format '${this.options.format}': ${message}`);
+        }
+        return {
+            content,
+            mediaType: DotCliArtifactTransformer.resolveMediaType(this.options.format),
+            extension: this.options.format,
+        };
+    }
+    isDotArtifact(artifact) {
+        return (artifact.mediaType === 'text/vnd.graphviz' || artifact.extension === 'dot');
+    }
+    toUtf8(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return Buffer.from(content).toString('utf8');
+    }
+    static resolveMediaType(format) {
+        return dotMediaTypeByFormat[format] ?? 'application/octet-stream';
+    }
+    defaultRunProcess = async (input) => {
+        return await new Promise((resolve, reject) => {
+            const child = spawn(input.executable, input.args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            child.stdout.on('data', (chunk) => {
+                stdoutChunks.push(chunk);
+            });
+            child.stderr.on('data', (chunk) => {
+                stderrChunks.push(chunk);
+            });
+            child.on('error', (error) => {
+                reject(error);
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(Buffer.concat(stdoutChunks));
+                    return;
+                }
+                const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+                const output = stderr ? `: ${stderr}` : '';
+                reject(new Error(`dot exited with code ${String(code)}${output}`));
+            });
+            child.stdin.end(input.stdin);
+        });
+    };
+}

package/dist/esm/Output/ArtifactTransformer/DotCliArtifactTransformer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/Output/ArtifactTransformer/DotCliArtifactTransformer.test.js

@@ -0,0 +1,198 @@
+import { EventEmitter } from 'node:events';
+import { DotCliArtifactTransformer, } from './DotCliArtifactTransformer.js';
+const spawnMock = jest.fn();
+jest.mock('node:child_process', () => ({
+    spawn: (...args) => spawnMock(...args),
+}));
+const buildChild = () => {
+    const child = new EventEmitter();
+    child.stdout = new EventEmitter();
+    child.stderr = new EventEmitter();
+    child.stdin = { end: jest.fn() };
+    return child;
+};
+describe('DotCliArtifactTransformer.transform', () => {
+    beforeEach(() => {
+        spawnMock.mockReset();
+    });
+    it('shoud transform dot text to the requested format', async () => {
+        const calls = [];
+        const transformer = new DotCliArtifactTransformer({
+            format: 'png',
+            dotArgs: ['-Gdpi=200'],
+            runProcess: async (input) => {
+                calls.push(input);
+                return Buffer.from([1, 2, 3]);
+            },
+        });
+        const artifact = await transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        });
+        expect(calls).toHaveLength(1);
+        expect(calls[0]).toEqual({
+            executable: 'dot',
+            args: ['-Tpng', '-Gdpi=200'],
+            stdin: 'digraph G {}',
+        });
+        expect(artifact.mediaType).toBe('image/png');
+        expect(artifact.extension).toBe('png');
+        expect(Buffer.from(artifact.content)).toEqual(Buffer.from([1, 2, 3]));
+    });
+    it('shoud reject artifacts that are not dot', async () => {
+        const transformer = new DotCliArtifactTransformer({
+            format: 'svg',
+            runProcess: async () => Buffer.from([]),
+        });
+        const input = {
+            content: '{"ok":true}',
+            mediaType: 'application/json',
+            extension: 'json',
+        };
+        await expect(transformer.transform({
+            artifact: input,
+        })).rejects.toThrow("DotCliArtifactTransformer can only transform DOT artifacts ('text/vnd.graphviz' or extension 'dot')");
+    });
+    it('shoud add context when dot process execution fails', async () => {
+        const transformer = new DotCliArtifactTransformer({
+            format: 'svg',
+            runProcess: async () => {
+                throw new Error('boom');
+            },
+        });
+        await expect(transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        })).rejects.toThrow("DotCliArtifactTransformer failed for format 'svg': boom");
+    });
+    it('shoud accept dot artifacts by extension and decode binary content', async () => {
+        const calls = [];
+        const transformer = new DotCliArtifactTransformer({
+            format: 'svg',
+            runProcess: async (input) => {
+                calls.push(input);
+                return Buffer.from([9, 8, 7]);
+            },
+        });
+        const artifact = await transformer.transform({
+            artifact: {
+                content: Buffer.from('digraph G {}'),
+                mediaType: 'text/plain',
+                extension: 'dot',
+            },
+        });
+        expect(calls[0]).toEqual({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        });
+        expect(artifact.mediaType).toBe('image/svg+xml');
+    });
+    it('shoud add context when dot process throws a non-error value', async () => {
+        const transformer = new DotCliArtifactTransformer({
+            format: 'svg',
+            runProcess: async () => {
+                throw 'boom';
+            },
+        });
+        await expect(transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        })).rejects.toThrow("DotCliArtifactTransformer failed for format 'svg': boom");
+    });
+    it('shoud fall back to octet-stream when format is unknown', async () => {
+        const transformer = new DotCliArtifactTransformer({
+            format: 'eps',
+            runProcess: async () => Buffer.from([1, 2]),
+        });
+        const artifact = await transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        });
+        expect(artifact.mediaType).toBe('application/octet-stream');
+    });
+});
+describe('DotCliArtifactTransformer.defaultRunProcess', () => {
+    beforeEach(() => {
+        spawnMock.mockReset();
+    });
+    it('shoud resolve stdout when the process succeeds', async () => {
+        const transformer = new DotCliArtifactTransformer({ format: 'svg' });
+        const runProcess = transformer.defaultRunProcess;
+        spawnMock.mockImplementation(() => {
+            const child = buildChild();
+            process.nextTick(() => {
+                child.stdout.emit('data', Buffer.from('ok'));
+                child.emit('close', 0);
+            });
+            return child;
+        });
+        const output = await runProcess({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        });
+        expect(Buffer.from(output).toString('utf8')).toBe('ok');
+    });
+    it('shoud reject with stderr when the process exits non-zero', async () => {
+        const transformer = new DotCliArtifactTransformer({ format: 'svg' });
+        const runProcess = transformer.defaultRunProcess;
+        spawnMock.mockImplementation(() => {
+            const child = buildChild();
+            process.nextTick(() => {
+                child.stderr.emit('data', Buffer.from('failure'));
+                child.emit('close', 2);
+            });
+            return child;
+        });
+        await expect(runProcess({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        })).rejects.toThrow('dot exited with code 2: failure');
+    });
+    it('shoud include no stderr output when the process exits non-zero', async () => {
+        const transformer = new DotCliArtifactTransformer({ format: 'svg' });
+        const runProcess = transformer.defaultRunProcess;
+        spawnMock.mockImplementation(() => {
+            const child = buildChild();
+            process.nextTick(() => {
+                child.emit('close', 3);
+            });
+            return child;
+        });
+        await expect(runProcess({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        })).rejects.toThrow('dot exited with code 3');
+    });
+    it('shoud reject when the process emits an error', async () => {
+        const transformer = new DotCliArtifactTransformer({ format: 'svg' });
+        const runProcess = transformer.defaultRunProcess;
+        spawnMock.mockImplementation(() => {
+            const child = buildChild();
+            process.nextTick(() => {
+                child.emit('error', new Error('spawn failed'));
+            });
+            return child;
+        });
+        await expect(runProcess({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        })).rejects.toThrow('spawn failed');
+    });
+});

package/dist/esm/Output/ArtifactTransformer/index.d.ts

@@ -0,0 +1 @@
+export * from './DotCliArtifactTransformer.js';

package/dist/esm/Output/ArtifactTransformer/index.js

@@ -0,0 +1 @@
+export * from './DotCliArtifactTransformer.js';

package/dist/esm/Output/ArtifactTransformer.d.ts

@@ -0,0 +1,7 @@
+import { RenderArtifact } from '../Graph/Renderer.js';
+export type ArtifactTransformInput = {
+    artifact: RenderArtifact;
+};
+export interface ArtifactTransformer {
+    transform(input: ArtifactTransformInput): Promise<RenderArtifact>;
+}

package/dist/esm/Output/ArtifactTransformer.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/Output/ArtifactTransformerFactory/DefaultArtifactTransformerFactory.d.ts

@@ -0,0 +1,17 @@
+import { ArtifactTransformer } from '../ArtifactTransformer.js';
+import { DotCliRunProcess } from '../ArtifactTransformer/DotCliArtifactTransformer.js';
+import { ArtifactTransformerFactory, ArtifactTransformerFactoryInput } from '../ArtifactTransformerFactory.js';
+export type DefaultArtifactTransformerFactoryOptions = {
+    dotCliRunProcess?: DotCliRunProcess;
+};
+export declare class DefaultArtifactTransformerFactory implements ArtifactTransformerFactory {
+    private readonly options;
+    constructor(options?: DefaultArtifactTransformerFactoryOptions);
+    create(input: ArtifactTransformerFactoryInput): ArtifactTransformer;
+    private createDotCliTransformer;
+    private resolveDotArgs;
+    private readRequiredStringOption;
+    private readOptionalStringOption;
+    private readStringListOption;
+    private toStringList;
+}

package/dist/esm/Output/ArtifactTransformerFactory/DefaultArtifactTransformerFactory.js

@@ -0,0 +1,74 @@
+import { DotCliArtifactTransformer, } from '../ArtifactTransformer/DotCliArtifactTransformer.js';
+export class DefaultArtifactTransformerFactory {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    create(input) {
+        const transformerName = input.name.trim().toLowerCase();
+        if (transformerName === 'dotcli') {
+            return this.createDotCliTransformer(input.options);
+        }
+        throw new Error(`Unsupported transformer '${input.name}'`);
+    }
+    createDotCliTransformer(options) {
+        const format = this.readRequiredStringOption('dotcli', 'format', options);
+        const executable = this.readOptionalStringOption('executable', options);
+        const dotArgs = this.resolveDotArgs(options);
+        return new DotCliArtifactTransformer({
+            format,
+            executable,
+            dotArgs: dotArgs.length > 0 ? dotArgs : undefined,
+            runProcess: this.options.dotCliRunProcess,
+        });
+    }
+    resolveDotArgs(options) {
+        if (!options) {
+            return [];
+        }
+        const dotArgs = [
+            ...this.readStringListOption('dotArg', options),
+            ...this.readStringListOption('dotArgs', options),
+            ...this.readStringListOption('arg', options),
+            ...this.readStringListOption('args', options),
+        ];
+        for (const [key, value] of Object.entries(options)) {
+            if (key === 'format' ||
+                key === 'executable' ||
+                key === 'dotArg' ||
+                key === 'dotArgs' ||
+                key === 'arg' ||
+                key === 'args') {
+                continue;
+            }
+            for (const item of this.toStringList(value)) {
+                dotArgs.push(`-${key}=${item}`);
+            }
+        }
+        return dotArgs;
+    }
+    readRequiredStringOption(transformerName, optionName, options) {
+        const value = this.readOptionalStringOption(optionName, options);
+        if (!value) {
+            throw new Error(`Transformer '${transformerName}' requires option '${optionName}'`);
+        }
+        return value;
+    }
+    readOptionalStringOption(optionName, options) {
+        const value = options?.[optionName];
+        if (value === undefined) {
+            return undefined;
+        }
+        return this.toStringList(value)[0];
+    }
+    readStringListOption(optionName, options) {
+        const value = options?.[optionName];
+        if (value === undefined) {
+            return [];
+        }
+        return this.toStringList(value);
+    }
+    toStringList(value) {
+        return Array.isArray(value) ? [...value] : [value];
+    }
+}

package/dist/esm/Output/ArtifactTransformerFactory/DefaultArtifactTransformerFactory.test.d.ts

@@ -0,0 +1 @@
+export {};