yarramate 0.1.0

package/dist/adapters/likec4-cli.js

@@ -0,0 +1,662 @@
+#!/usr/bin/env node
+import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash, randomUUID } from 'node:crypto';
+import Ajv2020Module from 'ajv/dist/2020.js';
+import { parseDocument } from 'yaml';
+import { isMainModule, resolveCliWorkspaceSources, } from '../cli-support.js';
+import { locateSourcePath } from '../source-document.js';
+import { prepareLikeC4Export, } from './likec4-prepare.js';
+import { exportLikeC4Project, loadLikeC4ProjectDefinition, } from './likec4-project.js';
+import generatedProjectSchema from '../../schema/yarramate-likec4-generated-project.schema.json' with {
+    type: 'json'
+};
+import generatedProjectV2Schema from '../../schema/yarramate-likec4-generated-project-v2.schema.json' with {
+    type: 'json'
+};
+const Ajv2020 = Ajv2020Module.default;
+const validateGeneratedProjectMarker = new Ajv2020({
+    allErrors: true,
+}).compile(generatedProjectSchema);
+const validateGeneratedProjectV2Marker = new Ajv2020({
+    allErrors: true,
+}).compile(generatedProjectV2Schema);
+const generatedFileNames = [
+    'likec4.config.json',
+    'model.likec4',
+    'specification.likec4',
+];
+const sha256 = (value) => createHash('sha256').update(value).digest('hex');
+const stageFile = (destination, value) => {
+    const staged = `${destination}.yarramate-${randomUUID()}.tmp`;
+    const descriptor = openSync(staged, 'wx', 0o666);
+    let written = false;
+    try {
+        writeFileSync(descriptor, value);
+        written = true;
+    }
+    finally {
+        closeSync(descriptor);
+        if (!written && existsSync(staged))
+            unlinkSync(staged);
+    }
+    return {
+        publish: () => renameSync(staged, destination),
+        cleanup: () => {
+            if (existsSync(staged))
+                unlinkSync(staged);
+        },
+    };
+};
+const publishFiles = (files) => {
+    const stagedFiles = [];
+    try {
+        for (const file of files) {
+            stagedFiles.push(stageFile(file.destination, file.value));
+        }
+    }
+    catch (error) {
+        for (const staged of stagedFiles)
+            staged.cleanup();
+        throw error;
+    }
+    try {
+        for (const staged of stagedFiles)
+            staged.publish();
+    }
+    finally {
+        for (const staged of stagedFiles)
+            staged.cleanup();
+    }
+};
+const usage = 'Usage:\n' +
+    '  yarramate-likec4 check <projection.yaml> <mapping.yaml> [--json] [--kinds <kind-mapping.yaml>] [--compare <from-state> <to-state>] <workspace-or-source...>\n' +
+    '  yarramate-likec4 check <likec4-project.yaml> [--json] <workspace-or-source...>\n' +
+    '  yarramate-likec4 export <projection.yaml> <mapping.yaml> [--kinds <kind-mapping.yaml>] [--compare <from-state> <to-state>] <workspace-or-source...>\n' +
+    '  yarramate-likec4 export-project <projection.yaml> <mapping.yaml> <output-dir> [--kinds <kind-mapping.yaml>] [--compare <from-state> <to-state>] <workspace-or-source...>\n' +
+    '  yarramate-likec4 export-project <likec4-project.yaml> <output-dir> <workspace-or-source...>\n';
+const diagnosticJson = (diagnostics) => `${JSON.stringify({
+    format: 'yarramate/likec4-diagnostic-result/v1',
+    diagnostics,
+}, null, 2)}\n`;
+const checkJson = (ok, diagnostics) => `${JSON.stringify({
+    format: 'yarramate/likec4-check-result/v1',
+    ok,
+    diagnostics,
+}, null, 2)}\n`;
+const sameJson = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const publishGeneratedProject = (cwd, outputDirectory, input) => {
+    const projectPath = resolve(cwd, outputDirectory);
+    const markerPath = resolve(projectPath, 'yarramate.generated.json');
+    const updating = existsSync(projectPath);
+    if (updating) {
+        const projectStat = lstatSync(projectPath);
+        if (projectStat.isSymbolicLink() || !projectStat.isDirectory()) {
+            return {
+                exitCode: 2,
+                stdout: '',
+                stderr: `Output directory already exists: ${projectPath}\n`,
+            };
+        }
+        const unsafeFile = [
+            markerPath,
+            ...generatedFileNames.map((file) => resolve(projectPath, file)),
+        ].find((path) => {
+            if (!existsSync(path))
+                return false;
+            const stat = lstatSync(path);
+            return stat.isSymbolicLink() || !stat.isFile();
+        });
+        if (unsafeFile !== undefined) {
+            return {
+                exitCode: 2,
+                stdout: '',
+                stderr: `Generated project contains an unsafe file: ${unsafeFile}\n`,
+            };
+        }
+        let marker;
+        try {
+            marker = JSON.parse(readFileSync(markerPath, 'utf8'));
+        }
+        catch {
+            marker = undefined;
+        }
+        if (!input.validateMarker(marker) ||
+            typeof marker !== 'object' ||
+            marker === null ||
+            Object.entries(input.ownership).some(([key, value]) => !sameJson(marker[key], value))) {
+            return {
+                exitCode: 2,
+                stdout: '',
+                stderr: `Output directory already exists: ${projectPath}\n`,
+            };
+        }
+        if ('digests' in marker && marker.digests !== undefined) {
+            const digests = marker.digests;
+            const changedFile = generatedFileNames.find((file) => {
+                const path = resolve(projectPath, file);
+                return (!existsSync(path) ||
+                    sha256(readFileSync(path)) !== digests[file]);
+            });
+            if (changedFile !== undefined) {
+                return {
+                    exitCode: 2,
+                    stdout: '',
+                    stderr: `Generated project file has changed: ${resolve(projectPath, changedFile)}\n`,
+                };
+            }
+        }
+    }
+    else {
+        mkdirSync(projectPath, { recursive: true });
+    }
+    const specificationSource = readFileSync(fileURLToPath(new URL('../../.yarramate/integrations/likec4/prototype/specification.likec4', import.meta.url)));
+    const configSource = `${JSON.stringify({
+        $schema: 'https://likec4.dev/schemas/config.json',
+        name: input.projectName,
+        title: input.title,
+    }, null, 2)}\n`;
+    const markerSource = `${JSON.stringify({
+        ...input.ownership,
+        files: [
+            'likec4.config.json',
+            'model.likec4',
+            'specification.likec4',
+        ],
+        digests: {
+            'likec4.config.json': sha256(configSource),
+            'model.likec4': sha256(input.modelSource),
+            'specification.likec4': sha256(specificationSource),
+        },
+    }, null, 2)}\n`;
+    publishFiles([
+        {
+            destination: resolve(projectPath, 'likec4.config.json'),
+            value: configSource,
+        },
+        {
+            destination: resolve(projectPath, 'model.likec4'),
+            value: input.modelSource,
+        },
+        {
+            destination: resolve(projectPath, 'specification.likec4'),
+            value: specificationSource,
+        },
+        { destination: markerPath, value: markerSource },
+    ]);
+    return {
+        exitCode: 0,
+        stdout: updating
+            ? `Updated LikeC4 project at ${projectPath}\n`
+            : `Wrote LikeC4 project to ${projectPath}\n`,
+        stderr: '',
+    };
+};
+export function runLikeC4Cli(args, cwd = process.cwd()) {
+    const [command, projectionPath, mappingPath, ...options] = args;
+    let projectDefinitionMode = false;
+    if ((command === 'check' || command === 'export-project') &&
+        projectionPath !== undefined) {
+        try {
+            projectDefinitionMode =
+                parseDocument(readFileSync(resolve(cwd, projectionPath), 'utf8')).get('format') === 'yarramate/likec4-project/v1';
+        }
+        catch {
+            projectDefinitionMode = false;
+        }
+    }
+    const outputDirectory = command === 'export-project'
+        ? projectDefinitionMode
+            ? mappingPath
+            : options[0]
+        : undefined;
+    const sourceOptions = projectDefinitionMode && command === 'check'
+        ? [mappingPath, ...options].filter((value) => value !== undefined)
+        : command === 'export-project'
+            ? projectDefinitionMode
+                ? options
+                : options.slice(1)
+            : options;
+    const json = command === 'check' && sourceOptions.includes('--json');
+    let invalidOptions = false;
+    let kindMappingPath;
+    let comparison;
+    const sourcePaths = [];
+    for (let index = 0; index < sourceOptions.length; index += 1) {
+        const option = sourceOptions[index];
+        if (option === '--json') {
+            if (command !== 'check')
+                invalidOptions = true;
+            continue;
+        }
+        if (option === '--kinds') {
+            const value = sourceOptions[index + 1];
+            if (value === undefined ||
+                value.startsWith('-') ||
+                kindMappingPath !== undefined) {
+                invalidOptions = true;
+            }
+            else {
+                kindMappingPath = value;
+                index += 1;
+            }
+            continue;
+        }
+        if (option === '--compare') {
+            const from = sourceOptions[index + 1];
+            const to = sourceOptions[index + 2];
+            if (from === undefined ||
+                to === undefined ||
+                from.startsWith('-') ||
+                to.startsWith('-') ||
+                comparison !== undefined) {
+                invalidOptions = true;
+            }
+            else {
+                comparison = { from, to };
+                index += 2;
+            }
+            continue;
+        }
+        if (option.startsWith('-'))
+            invalidOptions = true;
+        else
+            sourcePaths.push(option);
+    }
+    if ((command !== 'check' &&
+        command !== 'export' &&
+        command !== 'export-project') ||
+        projectionPath === undefined ||
+        (!projectDefinitionMode && mappingPath === undefined) ||
+        (projectDefinitionMode &&
+            command === 'export-project' &&
+            mappingPath === undefined) ||
+        (command === 'export-project' && outputDirectory === undefined) ||
+        (projectDefinitionMode &&
+            (kindMappingPath !== undefined || comparison !== undefined)) ||
+        invalidOptions ||
+        sourcePaths.length === 0 ||
+        sourcePaths.some((argument) => argument.startsWith('-'))) {
+        return { exitCode: 2, stdout: '', stderr: usage };
+    }
+    const diagnosticOutput = (diagnostics) => (json ? checkJson(false, diagnostics) : diagnosticJson(diagnostics));
+    try {
+        const resolved = resolveCliWorkspaceSources(sourcePaths, cwd);
+        if (!resolved.ok) {
+            return {
+                exitCode: 1,
+                stdout: diagnosticOutput(resolved.diagnostics),
+                stderr: '',
+            };
+        }
+        const sources = resolved.paths.map((path) => ({
+            path,
+            source: readFileSync(resolve(cwd, path), 'utf8'),
+        }));
+        if (projectDefinitionMode) {
+            const projectSource = {
+                path: projectionPath,
+                source: readFileSync(resolve(cwd, projectionPath), 'utf8'),
+            };
+            const loadedProject = loadLikeC4ProjectDefinition(projectSource);
+            if (!loadedProject.ok) {
+                return {
+                    exitCode: 1,
+                    stdout: diagnosticOutput(loadedProject.diagnostics),
+                    stderr: '',
+                };
+            }
+            const preparedViews = loadedProject.document.value.views.map((view) => ({
+                view,
+                prepared: prepareLikeC4Export({
+                    sources,
+                    projection: {
+                        path: view.projection,
+                        source: readFileSync(resolve(cwd, view.projection), 'utf8'),
+                    },
+                    subjectMapping: {
+                        path: loadedProject.document.value.mapping,
+                        source: readFileSync(resolve(cwd, loadedProject.document.value.mapping), 'utf8'),
+                    },
+                    ...(loadedProject.document.value.kindMapping === undefined
+                        ? {}
+                        : {
+                            kindMapping: {
+                                path: loadedProject.document.value.kindMapping,
+                                source: readFileSync(resolve(cwd, loadedProject.document.value.kindMapping), 'utf8'),
+                            },
+                        }),
+                    ...(view.compare === undefined
+                        ? {}
+                        : { comparison: view.compare }),
+                    vocabulary: 'bundled',
+                }),
+            }));
+            const failed = preparedViews.find(({ prepared }) => !prepared.ok);
+            if (failed !== undefined && !failed.prepared.ok) {
+                return {
+                    exitCode: 1,
+                    stdout: diagnosticOutput(failed.prepared.diagnostics),
+                    stderr: '',
+                };
+            }
+            const successfulViews = preparedViews.flatMap(({ view, prepared }) => prepared.ok
+                ? [
+                    {
+                        ...(view.id === undefined ? {} : { id: view.id }),
+                        prepared,
+                        ...(view.compare === undefined
+                            ? {}
+                            : { comparison: view.compare }),
+                        ...(view.dynamic === undefined
+                            ? {}
+                            : { dynamic: view.dynamic }),
+                        ...(view.deployment === undefined
+                            ? {}
+                            : { deployment: view.deployment }),
+                    },
+                ]
+                : []);
+            const renderedViewIds = new Set();
+            const deploymentIdentities = new Set();
+            for (const [index, view] of successfulViews.entries()) {
+                const deployment = view.deployment;
+                if (deployment !== undefined) {
+                    const nodeIds = new Set();
+                    for (const [nodeIndex, node] of deployment.nodes.entries()) {
+                        const problem = nodeIds.has(node.id)
+                            ? `Deployment node "${node.id}" is duplicated`
+                            : deploymentIdentities.has(node.id)
+                                ? `Deployment identity "${node.id}" is duplicated`
+                                : node.parent === node.id
+                                    ? `Deployment node "${node.id}" cannot parent itself`
+                                    : undefined;
+                        if (problem !== undefined) {
+                            const field = nodeIds.has(node.id) || deploymentIdentities.has(node.id)
+                                ? 'id'
+                                : 'parent';
+                            const pointer = `/views/${index}/deployment/nodes/${nodeIndex}/${field}`;
+                            const location = locateSourcePath(projectSource.path, loadedProject.document.yaml, loadedProject.document.lineCounter, ['views', index, 'deployment', 'nodes', nodeIndex, field], pointer);
+                            return {
+                                exitCode: 1,
+                                stdout: diagnosticOutput([{
+                                        severity: 'error',
+                                        code: 'YMLC109',
+                                        message: problem,
+                                        ...location,
+                                    }]),
+                                stderr: '',
+                            };
+                        }
+                        nodeIds.add(node.id);
+                        deploymentIdentities.add(node.id);
+                    }
+                    for (const [nodeIndex, node] of deployment.nodes.entries()) {
+                        if (node.parent !== undefined &&
+                            !nodeIds.has(node.parent)) {
+                            const pointer = `/views/${index}/deployment/nodes/${nodeIndex}/parent`;
+                            const location = locateSourcePath(projectSource.path, loadedProject.document.yaml, loadedProject.document.lineCounter, [
+                                'views',
+                                index,
+                                'deployment',
+                                'nodes',
+                                nodeIndex,
+                                'parent',
+                            ], pointer);
+                            return {
+                                exitCode: 1,
+                                stdout: diagnosticOutput([{
+                                        severity: 'error',
+                                        code: 'YMLC109',
+                                        message: `Deployment parent "${node.parent}" does not exist`,
+                                        ...location,
+                                    }]),
+                                stderr: '',
+                            };
+                        }
+                        const nodeById = new Map(deployment.nodes.map((candidate) => [
+                            candidate.id,
+                            candidate,
+                        ]));
+                        const ancestors = new Set([node.id]);
+                        let parent = node.parent;
+                        while (parent !== undefined) {
+                            if (ancestors.has(parent)) {
+                                const pointer = `/views/${index}/deployment/nodes/${nodeIndex}/parent`;
+                                const location = locateSourcePath(projectSource.path, loadedProject.document.yaml, loadedProject.document.lineCounter, [
+                                    'views',
+                                    index,
+                                    'deployment',
+                                    'nodes',
+                                    nodeIndex,
+                                    'parent',
+                                ], pointer);
+                                return {
+                                    exitCode: 1,
+                                    stdout: diagnosticOutput([{
+                                            severity: 'error',
+                                            code: 'YMLC109',
+                                            message: `Deployment node "${node.id}" participates in a parent cycle`,
+                                            ...location,
+                                        }]),
+                                    stderr: '',
+                                };
+                            }
+                            ancestors.add(parent);
+                            parent = nodeById.get(parent)?.parent;
+                        }
+                    }
+                    const instanceIds = new Set();
+                    for (const [instanceIndex, instance] of (deployment.instances).entries()) {
+                        const projected = view.prepared.projection.subjects.find(({ id }) => id === instance.subject);
+                        const problem = instanceIds.has(instance.id)
+                            ? `Deployment instance "${instance.id}" is duplicated`
+                            : deploymentIdentities.has(instance.id)
+                                ? `Deployment identity "${instance.id}" is duplicated`
+                                : !nodeIds.has(instance.node)
+                                    ? `Deployment instance node "${instance.node}" does not exist`
+                                    : projected?.type !== 'concept'
+                                        ? `Deployment instance subject "${instance.subject}" is not selected as a concept by its projection`
+                                        : undefined;
+                        if (problem !== undefined) {
+                            const field = instanceIds.has(instance.id) ||
+                                deploymentIdentities.has(instance.id)
+                                ? 'id'
+                                : !nodeIds.has(instance.node)
+                                    ? 'node'
+                                    : 'subject';
+                            const pointer = `/views/${index}/deployment/instances/${instanceIndex}/${field}`;
+                            const location = locateSourcePath(projectSource.path, loadedProject.document.yaml, loadedProject.document.lineCounter, [
+                                'views',
+                                index,
+                                'deployment',
+                                'instances',
+                                instanceIndex,
+                                field,
+                            ], pointer);
+                            return {
+                                exitCode: 1,
+                                stdout: diagnosticOutput([{
+                                        severity: 'error',
+                                        code: 'YMLC109',
+                                        message: problem,
+                                        ...location,
+                                    }]),
+                                stderr: '',
+                            };
+                        }
+                        instanceIds.add(instance.id);
+                        deploymentIdentities.add(instance.id);
+                    }
+                }
+                for (const [stepIndex, step] of (view.dynamic?.steps ?? []).entries()) {
+                    const projected = view.prepared.projection.subjects.find(({ id }) => id === step.relationship);
+                    if (projected?.type !== 'relationship') {
+                        const pointer = `/views/${index}/dynamic/steps/${stepIndex}/relationship`;
+                        const location = locateSourcePath(projectSource.path, loadedProject.document.yaml, loadedProject.document.lineCounter, [
+                            'views',
+                            index,
+                            'dynamic',
+                            'steps',
+                            stepIndex,
+                            'relationship',
+                        ], pointer);
+                        return {
+                            exitCode: 1,
+                            stdout: diagnosticOutput([
+                                {
+                                    severity: 'error',
+                                    code: 'YMLC108',
+                                    message: `Dynamic step relationship "${step.relationship}" is not selected as a relationship by its projection`,
+                                    ...location,
+                                },
+                            ]),
+                            stderr: '',
+                        };
+                    }
+                }
+                const renderedId = view.id ?? view.prepared.projection.projection.split('@')[0];
+                if (renderedViewIds.has(renderedId)) {
+                    const field = view.id === undefined ? 'projection' : 'id';
+                    const pointer = `/views/${index}/${field}`;
+                    const location = locateSourcePath(projectSource.path, loadedProject.document.yaml, loadedProject.document.lineCounter, ['views', index, field], pointer);
+                    return {
+                        exitCode: 1,
+                        stdout: diagnosticOutput([
+                            {
+                                severity: 'error',
+                                code: 'YMLC107',
+                                message: `LikeC4 view identity "${renderedId}" is duplicated`,
+                                ...location,
+                            },
+                        ]),
+                        stderr: '',
+                    };
+                }
+                renderedViewIds.add(renderedId);
+            }
+            const exported = exportLikeC4Project(loadedProject.document.value, successfulViews);
+            if (!exported.ok) {
+                return {
+                    exitCode: 1,
+                    stdout: diagnosticOutput(exported.diagnostics),
+                    stderr: '',
+                };
+            }
+            if (command === 'check') {
+                const identity = `${loadedProject.document.value.id}@${loadedProject.document.value.version}`;
+                return {
+                    exitCode: 0,
+                    stdout: json
+                        ? checkJson(true, [])
+                        : `Checked LikeC4 project ${identity}: no errors\n`,
+                    stderr: '',
+                };
+            }
+            const first = successfulViews[0];
+            const mappingIdentity = `${first.prepared.subjectMapping.id}@${first.prepared.subjectMapping.version}`;
+            const kindMappingIdentity = first.prepared.kindMapping === undefined
+                ? undefined
+                : `${first.prepared.kindMapping.id}@${first.prepared.kindMapping.version}`;
+            const projectIdentity = `${loadedProject.document.value.id}@${loadedProject.document.value.version}`;
+            return publishGeneratedProject(cwd, outputDirectory, {
+                projectName: `yarramate-${projectIdentity}`.replaceAll(/[^A-Za-z0-9_-]/g, '-'),
+                title: loadedProject.document.value.title,
+                modelSource: exported.source,
+                ownership: {
+                    format: 'yarramate/likec4-generated-project/v2',
+                    project: projectIdentity,
+                    mapping: mappingIdentity,
+                    ...(kindMappingIdentity === undefined
+                        ? {}
+                        : { kindMapping: kindMappingIdentity }),
+                    views: successfulViews.map(({ id, prepared, comparison }) => ({
+                        ...(id === undefined ? {} : { id }),
+                        projection: prepared.projection.projection,
+                        ...(comparison === undefined
+                            ? {}
+                            : { comparison }),
+                    })),
+                },
+                validateMarker: (value) => validateGeneratedProjectV2Marker(value),
+            });
+        }
+        const prepared = prepareLikeC4Export({
+            sources,
+            projection: {
+                path: projectionPath,
+                source: readFileSync(resolve(cwd, projectionPath), 'utf8'),
+            },
+            subjectMapping: {
+                path: mappingPath,
+                source: readFileSync(resolve(cwd, mappingPath), 'utf8'),
+            },
+            ...(kindMappingPath === undefined
+                ? {}
+                : {
+                    kindMapping: {
+                        path: kindMappingPath,
+                        source: readFileSync(resolve(cwd, kindMappingPath), 'utf8'),
+                    },
+                }),
+            ...(comparison === undefined ? {} : { comparison }),
+            vocabulary: command === 'export' ? 'consumer' : 'bundled',
+        });
+        if (!prepared.ok) {
+            return {
+                exitCode: 1,
+                stdout: diagnosticOutput(prepared.diagnostics),
+                stderr: '',
+            };
+        }
+        if (command === 'check') {
+            return {
+                exitCode: 0,
+                stdout: json
+                    ? checkJson(true, [])
+                    : `Checked LikeC4 export ${prepared.projection.projection}: no errors\n`,
+                stderr: '',
+            };
+        }
+        if (command === 'export') {
+            return { exitCode: 0, stdout: prepared.source, stderr: '' };
+        }
+        const projectionIdentity = prepared.projection.projection;
+        const mappingIdentity = `${prepared.subjectMapping.id}@${prepared.subjectMapping.version}`;
+        const kindMappingIdentity = prepared.kindMapping === undefined
+            ? undefined
+            : `${prepared.kindMapping.id}@${prepared.kindMapping.version}`;
+        const comparisonIdentity = comparison;
+        return publishGeneratedProject(cwd, outputDirectory, {
+            projectName: ['yarramate', projectionIdentity]
+                .join('-')
+                .replaceAll(/[^A-Za-z0-9_-]/g, '-'),
+            title: prepared.projection.presentation?.title ??
+                projectionIdentity.slice(0, projectionIdentity.lastIndexOf('@')),
+            modelSource: prepared.source,
+            ownership: {
+                format: 'yarramate/likec4-generated-project/v1',
+                projection: projectionIdentity,
+                mapping: mappingIdentity,
+                ...(kindMappingIdentity === undefined
+                    ? {}
+                    : { kindMapping: kindMappingIdentity }),
+                ...(comparisonIdentity === undefined
+                    ? {}
+                    : { comparison: comparisonIdentity }),
+            },
+            validateMarker: (value) => validateGeneratedProjectMarker(value),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { exitCode: 2, stdout: '', stderr: `${message}\n` };
+    }
+}
+if (isMainModule(import.meta.url, process.argv[1])) {
+    const result = runLikeC4Cli(process.argv.slice(2));
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    process.exitCode = result.exitCode;
+}

package/dist/adapters/likec4-export.d.ts

@@ -0,0 +1,25 @@
+import { type AdapterMapping } from '../adapter-mapping.js';
+import type { StateComparison } from '../architecture-state.js';
+import type { ProjectionResult } from '../projection.js';
+import type { LikeC4KindMapping } from './likec4-kind-mapping.js';
+export interface LikeC4ExportDiagnostic {
+    readonly severity: 'error';
+    readonly code: 'YMLC101' | 'YMLC102' | 'YMLC103' | 'YMLC104' | 'YMLC105' | 'YMLC106' | 'YMLC107' | 'YMLC108' | 'YMLC109';
+    readonly message: string;
+    readonly subject?: string;
+    readonly path: string;
+    readonly pointer: string;
+    readonly line: number;
+    readonly column: number;
+}
+export type LikeC4ExportResult = {
+    readonly ok: true;
+    readonly source: string;
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly LikeC4ExportDiagnostic[];
+};
+export interface LikeC4ExportOptions {
+    readonly comparison?: StateComparison;
+}
+export declare function exportLikeC4(projection: ProjectionResult, mapping: AdapterMapping, kindMapping?: LikeC4KindMapping, options?: LikeC4ExportOptions): LikeC4ExportResult;