@likec4/language-server 1.47.0 → 1.48.0

package/dist/model/builder/MergedExtends.js

@@ -1,74 +0,0 @@
-import { hasAtLeast, isEmpty, unique, } from 'remeda';
-export class MergedExtends {
-    mergedData = new Map();
-    mergeMetadata(existing, incoming) {
-        const result = { ...existing };
-        for (const [key, incomingValue] of Object.entries(incoming)) {
-            const existingValue = result[key];
-            if (existingValue === undefined) {
-                result[key] = incomingValue;
-                continue;
-            }
-            // Convert both values to arrays to make merging easier.
-            const existingArray = Array.isArray(existingValue) ? existingValue : [existingValue];
-            const incomingArray = Array.isArray(incomingValue) ? incomingValue : [incomingValue];
-            // Merge and deduplicate based on value.
-            const merged = unique([...existingArray, ...incomingArray]);
-            result[key] = merged.length === 1 ? merged[0] : merged;
-        }
-        return result;
-    }
-    merge(parsedExtends) {
-        for (const parsedExtend of parsedExtends) {
-            const { id, links, tags, metadata } = parsedExtend;
-            const existing = this.mergedData.get(id) ?? {
-                links: [],
-                tags: [],
-                metadata: {},
-            };
-            if (links) {
-                existing.links.push(...links);
-            }
-            if (tags) {
-                existing.tags = unique([
-                    ...existing.tags,
-                    ...tags,
-                ]);
-            }
-            if (metadata) {
-                existing.metadata = this.mergeMetadata(existing.metadata, metadata);
-            }
-            this.mergedData.set(id, existing);
-        }
-    }
-    applyExtended(el) {
-        const extendData = this.mergedData.get(el.id);
-        if (!extendData) {
-            return el;
-        }
-        let links = extendData.links;
-        if (el.links && el.links.length > 0) {
-            links = [
-                ...el.links,
-                ...links,
-            ];
-        }
-        let tags = extendData.tags;
-        if (el.tags && el.tags.length > 0) {
-            tags = unique([
-                ...el.tags,
-                ...tags,
-            ]);
-        }
-        let metadata = extendData.metadata;
-        if (el.metadata) {
-            metadata = this.mergeMetadata(el.metadata, extendData.metadata);
-        }
-        return {
-            ...el,
-            tags: hasAtLeast(tags, 1) ? tags : null,
-            links: hasAtLeast(links, 1) ? links : null,
-            ...(!isEmpty(metadata) && { metadata }),
-        };
-    }
-}

package/dist/model/builder/MergedSpecification.d.ts

@@ -1,32 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { MultiMap } from '@likec4/core/utils';
-import type { ParsedAstDeployment, ParsedAstDeploymentRelation, ParsedAstElement, ParsedAstRelation, ParsedAstSpecification, ParsedLikeC4LangiumDocument } from '../../ast';
-/**
- * The `MergedSpecification` class is responsible for merging multiple parsed
- * LikeC4Langium documents into a single specification. It consolidates tags,
- * elements, deployments, relationships, and colors from the provided documents
- * and provides methods to convert parsed models into C4 model elements and relations.
- */
-export declare class MergedSpecification {
-    readonly specs: Omit<ParsedAstSpecification, 'tags'>;
-    readonly tags: Readonly<Record<c4.Tag, c4.TagSpecification>>;
-    readonly globals: c4.ModelGlobals;
-    readonly imports: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
-    constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>);
-    /**
-     * Converts a parsed model into a C4 model element.
-     */
-    toModelElement: ({ tags, links, style, id, kind, title, description, technology, summary, metadata, }: ParsedAstElement) => c4.Element | null;
-    /**
-     * Converts a parsed model into a C4 model relation.
-     */
-    toModelRelation: ({ astPath: _astPath, source, target, kind, links, id, ...model }: ParsedAstRelation) => c4.Relationship | null;
-    /**
-     * Converts a parsed deployment model into a C4 deployment model
-     */
-    toDeploymentElement: (parsed: ParsedAstDeployment) => c4.DeploymentElement | null;
-    /**
-     * Converts a parsed deployment relation into a C4 deployment relation.
-     */
-    toDeploymentRelation: ({ astPath: _astPath, source, target, kind, links, id, ...model }: ParsedAstDeploymentRelation) => c4.DeploymentRelationship | null;
-}

package/dist/model/builder/MergedSpecification.js

@@ -1,175 +0,0 @@
-import { assignTagColors } from '@likec4/core/styles';
-import { exact, FqnRef } from '@likec4/core/types';
-import { isNonEmptyArray, MultiMap, nameFromFqn } from '@likec4/core/utils';
-import { isEmpty, isNonNullish, unique, } from 'remeda';
-import { logger, logWarnError } from '../../logger';
-/**
- * The `MergedSpecification` class is responsible for merging multiple parsed
- * LikeC4Langium documents into a single specification. It consolidates tags,
- * elements, deployments, relationships, and colors from the provided documents
- * and provides methods to convert parsed models into C4 model elements and relations.
- */
-export class MergedSpecification {
-    specs = {
-        elements: {},
-        deployments: {},
-        relationships: {},
-        colors: {},
-    };
-    tags;
-    globals = {
-        predicates: {},
-        dynamicPredicates: {},
-        styles: {},
-    };
-    imports = new MultiMap(Set);
-    constructor(docs) {
-        const tags = {};
-        for (const doc of docs) {
-            const { c4Specification: spec, c4Globals, c4Imports, } = doc;
-            Object.assign(tags, spec.tags);
-            Object.assign(this.specs.elements, spec.elements);
-            Object.assign(this.specs.relationships, spec.relationships);
-            Object.assign(this.specs.colors, spec.colors);
-            Object.assign(this.specs.deployments, spec.deployments);
-            Object.assign(this.globals.predicates, c4Globals.predicates);
-            Object.assign(this.globals.dynamicPredicates, c4Globals.dynamicPredicates);
-            Object.assign(this.globals.styles, c4Globals.styles);
-            for (const [projectId, fqn] of c4Imports) {
-                this.imports.set(projectId, fqn);
-            }
-        }
-        this.tags = assignTagColors(tags);
-    }
-    /**
-     * Converts a parsed model into a C4 model element.
-     */
-    toModelElement = ({ tags, links, style, id, kind, title, description, technology, summary, metadata, }) => {
-        try {
-            const __kind = this.specs.elements[kind];
-            if (!__kind) {
-                logger.warn `No kind '${kind}' found for ${id}`;
-                return null;
-            }
-            technology ??= __kind.technology;
-            description ??= __kind.description;
-            summary ??= __kind.summary;
-            links ??= __kind.links;
-            title = title === nameFromFqn(id) && __kind.title ? __kind.title : title;
-            if (__kind.tags && isNonEmptyArray(__kind.tags)) {
-                tags = tags
-                    ? unique([
-                        ...__kind.tags,
-                        ...tags,
-                    ])
-                    : __kind.tags;
-            }
-            return exact({
-                metadata: metadata && !isEmpty(metadata) ? metadata : undefined,
-                notation: __kind.notation,
-                style: exact({
-                    ...__kind.style,
-                    ...style,
-                }),
-                links,
-                tags,
-                summary,
-                technology,
-                description,
-                title,
-                kind,
-                id,
-            });
-        }
-        catch (e) {
-            logWarnError(e);
-        }
-        return null;
-    };
-    /**
-     * Converts a parsed model into a C4 model relation.
-     */
-    toModelRelation = ({ astPath: _astPath, // omit
-    source, target, kind, links, id, ...model }) => {
-        if (isNonNullish(kind) && this.specs.relationships[kind]) {
-            return {
-                ...this.specs.relationships[kind],
-                ...model,
-                ...(links && { links }),
-                source,
-                target,
-                kind,
-                id,
-            };
-        }
-        return {
-            ...(links && { links }),
-            ...model,
-            source,
-            target,
-            id,
-        };
-    };
-    /**
-     * Converts a parsed deployment model into a C4 deployment model
-     */
-    toDeploymentElement = (parsed) => {
-        if ('element' in parsed && !('kind' in parsed)) {
-            return {
-                ...parsed,
-                element: FqnRef.flatten(parsed.element),
-            };
-        }
-        if ('element' in parsed) {
-            logger.warn `Invalid ParsedAstDeployment ${parsed.id}, has both element and kind properties`;
-            return null;
-        }
-        try {
-            const __kind = this.specs.deployments[parsed.kind];
-            if (!__kind) {
-                logger.warn `No kind ${parsed.kind} found for ${parsed.id}`;
-                return null;
-            }
-            let { id, style, title, ...rest } = parsed;
-            title = title === nameFromFqn(parsed.id) && __kind.title ? __kind.title : title;
-            return exact({
-                ...__kind,
-                ...rest,
-                title,
-                style: exact({
-                    ...__kind.style,
-                    ...style,
-                }),
-                id,
-            });
-        }
-        catch (e) {
-            logWarnError(e);
-        }
-        return null;
-    };
-    /**
-     * Converts a parsed deployment relation into a C4 deployment relation.
-     */
-    toDeploymentRelation = ({ astPath: _astPath, // omit
-    source, target, kind, links, id, ...model }) => {
-        if (isNonNullish(kind) && this.specs.relationships[kind]) {
-            return {
-                ...this.specs.relationships[kind],
-                ...model,
-                ...(links && { links }),
-                source,
-                target,
-                kind,
-                id,
-            };
-        }
-        return {
-            ...(links && { links }),
-            ...model,
-            source,
-            target,
-            id,
-        };
-    };
-}

package/dist/model/builder/buildModel.d.ts

@@ -1,16 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { type MultiMap } from '@likec4/core';
-import type { ParsedLikeC4LangiumDocument } from '../../ast';
-import type { Project } from '../../workspace/ProjectsManager';
-export type BuildModelData = {
-    data: c4.ParsedLikeC4ModelData;
-    imports: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
-};
-/**
- * Each document was parsed into a ParsedLikeC4LangiumDocument, where elements
- * do not inherit styles from specification.
- *
- * This function builds a model from all documents, merging the specifications
- * and globals, and applying the extends to the elements.
- */
-export declare function buildModelData(project: Project, docs: ReadonlyArray<ParsedLikeC4LangiumDocument>): BuildModelData;

package/dist/model/builder/buildModel.js

@@ -1,245 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Copyright (c) 2023-2025 Denis Davydkov
-// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-//
-// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
-import { isDeploymentNode, isGlobalFqn, } from '@likec4/core';
-import { resolveRulesExtendedViews } from '@likec4/core/compute-view';
-import { computeColorValues } from '@likec4/core/styles';
-import { _stage, _type, exact, FqnRef, isExtendsElementView } from '@likec4/core/types';
-import { compareNatural, parentFqn, sortByFqnHierarchically, } from '@likec4/core/utils';
-import { UriUtils } from 'langium';
-import { filter, flatMap, forEach, hasAtLeast, indexBy, isDefined, isEmpty, isNullish, isTruthy, keys, map, mapValues, omitBy, pipe, prop, reduce, unique, } from 'remeda';
-import { logger } from '../../logger';
-import { stringHash } from '../../utils/stringHash';
-import { MergedExtends } from './MergedExtends';
-import { MergedSpecification } from './MergedSpecification';
-/**
- * Each document was parsed into a ParsedLikeC4LangiumDocument, where elements
- * do not inherit styles from specification.
- *
- * This function builds a model from all documents, merging the specifications
- * and globals, and applying the extends to the elements.
- */
-export function buildModelData(project, docs) {
-    const c4Specification = new MergedSpecification(docs);
-    const customColors = mapValues(c4Specification.specs.colors, c => computeColorValues(c.color));
-    const metadataKeys = new Set();
-    const elementExtends = new MergedExtends();
-    const deploymentExtends = new MergedExtends();
-    // Collect all relation extends - we'll match them by comparing source/target/kind/title
-    const relationExtends = docs.flatMap(doc => doc.c4ExtendRelations);
-    const matchedExtendIds = new Set();
-    const scanMetadataKeys = (obj) => {
-        if (obj?.metadata) {
-            keys(obj.metadata).forEach(key => metadataKeys.add(key));
-        }
-    };
-    const elements = pipe(docs, flatMap(d => {
-        elementExtends.merge(d.c4ExtendElements);
-        return map(d.c4Elements, c4Specification.toModelElement);
-    }), filter(isTruthy), 
-    // sort from root elements to nested, so that parent is always present
-    // Import to preserve the order from the source
-    sortByFqnHierarchically, reduce((acc, el) => {
-        const parent = parentFqn(el.id);
-        if (parent && isNullish(acc[parent])) {
-            logger.debug `No parent found for ${el.id}`;
-            return acc;
-        }
-        acc[el.id] = elementExtends.applyExtended(el);
-        scanMetadataKeys(acc[el.id]);
-        return acc;
-    }, {}));
-    const relations = pipe(docs, flatMap(d => map(d.c4Relations, c4Specification.toModelRelation)), filter((rel) => {
-        if (!rel)
-            return false;
-        const source = FqnRef.flatten(rel.source), target = FqnRef.flatten(rel.target);
-        if ((isNullish(elements[source]) && !isGlobalFqn(source)) ||
-            (isNullish(elements[target]) && !isGlobalFqn(target))) {
-            logger.debug `Invalid relation ${rel.id}
-  source: ${source} resolved: ${!!elements[source]}
-  target: ${target} resolved: ${!!elements[target]}\n`;
-            return false;
-        }
-        return true;
-    }), map(rel => {
-        // Apply relation extends by matching source, target, kind, and title
-        // Generate a stable match key for this relation
-        const matchKey = stringHash('extend-relation', FqnRef.flatten(rel.source), FqnRef.flatten(rel.target), rel.kind ?? 'default', rel.title ?? '');
-        // Find all extends that match this relation
-        const relExtends = relationExtends.filter(ext => ext.id === matchKey);
-        if (relExtends.length === 0) {
-            return rel;
-        }
-        // Mark these extends as matched
-        relExtends.forEach(ext => matchedExtendIds.add(ext.astPath));
-        // Merge all extends for this relation
-        const tags = rel.tags ? [...rel.tags] : [];
-        const links = rel.links ? [...rel.links] : [];
-        let metadata = rel.metadata ? { ...rel.metadata } : {};
-        for (const ext of relExtends) {
-            if (ext.tags) {
-                tags.push(...ext.tags);
-            }
-            if (ext.links) {
-                // Ensure links are unique based on both URL and title
-                for (const incomingLink of ext.links) {
-                    const isDuplicate = links.some(existingLink => existingLink.url === incomingLink.url && (existingLink.title || '') === (incomingLink.title || ''));
-                    if (!isDuplicate) {
-                        links.push(incomingLink);
-                    }
-                }
-            }
-            if (ext.metadata) {
-                for (const [key, value] of Object.entries(ext.metadata)) {
-                    const existingValue = metadata[key];
-                    if (existingValue === undefined) {
-                        metadata[key] = value;
-                    }
-                    else {
-                        const existingArray = Array.isArray(existingValue) ? existingValue : [existingValue];
-                        const incomingArray = Array.isArray(value) ? value : [value];
-                        const merged = unique([...existingArray, ...incomingArray]);
-                        metadata[key] = merged.length === 1 ? merged[0] : merged;
-                    }
-                }
-            }
-        }
-        // Apply unique after accumulating all values
-        const uniqueTags = unique(tags);
-        // Links are already de-duplicated by URL and title in the loop above
-        const uniqueLinks = links;
-        return {
-            ...rel,
-            ...(hasAtLeast(uniqueTags, 1) && { tags: uniqueTags }),
-            ...(hasAtLeast(uniqueLinks, 1) && { links: uniqueLinks }),
-            ...(!isEmpty(metadata) && { metadata }),
-        };
-    }), forEach(scanMetadataKeys), indexBy(prop('id')));
-    const deploymentElements = pipe(docs, flatMap(d => {
-        deploymentExtends.merge(d.c4ExtendDeployments);
-        return map(d.c4Deployments, c4Specification.toDeploymentElement);
-    }), filter(isTruthy), 
-    // sort from root elements to nested, so that parent is always present
-    // Import to preserve the order from the source
-    sortByFqnHierarchically, reduce((acc, el) => {
-        const parent = parentFqn(el.id);
-        if (parent && isNullish(acc[parent])) {
-            logger.debug `No parent found for deployment element ${el.id}`;
-            return acc;
-        }
-        acc[el.id] = isDeploymentNode(el) ? deploymentExtends.applyExtended(el) : el;
-        scanMetadataKeys(acc[el.id]);
-        return acc;
-    }, {}));
-    const deploymentRelations = pipe(docs, flatMap(d => map(d.c4DeploymentRelations, c4Specification.toDeploymentRelation)), filter((rel) => {
-        if (!rel)
-            return false;
-        if (isNullish(deploymentElements[rel.source.deployment]) || isNullish(deploymentElements[rel.target.deployment])) {
-            logger.debug `Invalid deployment relation ${rel.id}
-  source: ${rel.source.deployment} resolved: ${!!deploymentElements[rel.source.deployment]}
-  target: ${rel.target.deployment} resolved: ${!!deploymentElements[rel.target.deployment]}\n`;
-            return false;
-        }
-        return true;
-    }), reduce((acc, el) => {
-        if (isDefined(acc[el.id])) {
-            logger.debug `Duplicate deployment relation ${el.id}`;
-            return acc;
-        }
-        scanMetadataKeys(el);
-        acc[el.id] = el;
-        return acc;
-    }, {}));
-    function toC4View(doc) {
-        const docUri = doc.uri.toString();
-        return (parsedAstView) => {
-            let { id, title, description, 
-            // ignore this property
-            astPath: _ignore, 
-            // model should include discriminant __
-            ...model } = parsedAstView;
-            if (parsedAstView[_type] === 'element' && isNullish(title) && 'viewOf' in parsedAstView) {
-                title = elements[parsedAstView.viewOf]?.title ?? null;
-            }
-            if (isNullish(title) && id === 'index') {
-                title = 'Landscape view';
-            }
-            return {
-                ...omitBy(model, v => v === undefined),
-                [_stage]: 'parsed',
-                sourcePath: UriUtils.relative(project.folderUri, docUri),
-                docUri,
-                description,
-                title,
-                id,
-            };
-        };
-    }
-    const parsedViews = docs.flatMap(d => map(d.c4Views, toC4View(d)));
-    // Add index view if not present
-    if (!parsedViews.some(v => v.id === 'index')) {
-        parsedViews.unshift({
-            [_stage]: 'parsed',
-            [_type]: 'element',
-            id: 'index',
-            title: 'Landscape view',
-            description: null,
-            rules: [
-                {
-                    include: [
-                        {
-                            wildcard: true,
-                        },
-                    ],
-                },
-            ],
-        });
-    }
-    let views = pipe(parsedViews, indexBy(prop('id')));
-    if (parsedViews.some(isExtendsElementView)) {
-        views = resolveRulesExtendedViews(views);
-    }
-    // Warn about unmatched relation extends
-    for (const ext of relationExtends) {
-        if (!matchedExtendIds.has(ext.astPath)) {
-            logger.warn(`Relation extend at ${ext.astPath} does not match any relation in the model`);
-        }
-    }
-    return {
-        data: {
-            [_stage]: 'parsed',
-            projectId: project.id,
-            project: exact({
-                id: project.id,
-                title: project.config.title ?? project.config.name,
-                styles: project.config.styles,
-                manualLayouts: project.config.manualLayouts,
-            }),
-            specification: {
-                tags: c4Specification.tags,
-                elements: c4Specification.specs.elements,
-                relationships: mapValues(c4Specification.specs.relationships, ({ notation, technology, ...style }) => ({
-                    ...(notation && { notation }),
-                    ...(technology && { technology }),
-                    style,
-                })),
-                deployments: c4Specification.specs.deployments,
-                ...(metadataKeys.size > 0 && { metadataKeys: [...metadataKeys].sort(compareNatural) }),
-                customColors,
-            },
-            elements,
-            relations,
-            globals: c4Specification.globals,
-            views,
-            deployments: {
-                elements: deploymentElements,
-                relations: deploymentRelations,
-            },
-            imports: {},
-        },
-        imports: c4Specification.imports,
-    };
-}

package/dist/model/deployments-index.d.ts

@@ -1,10 +0,0 @@
-import { type LikeC4LangiumDocument, ast } from '../ast';
-import type { LikeC4Services } from '../module';
-import type { LikeC4NameProvider } from '../references';
-import { DocumentFqnIndex, FqnIndex } from './fqn-index';
-export declare class DeploymentsIndex extends FqnIndex<ast.DeploymentElement> {
-    protected services: LikeC4Services;
-    protected Names: LikeC4NameProvider;
-    constructor(services: LikeC4Services);
-    protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
-}

package/dist/model/deployments-index.js

@@ -1,102 +0,0 @@
-import { ancestorsFqn, Fqn } from '@likec4/core';
-import { MultiMap } from '@likec4/core/utils';
-import { isDefined, isTruthy } from 'remeda';
-import { ast, ElementOps, } from '../ast';
-import { logWarnError } from '../logger';
-import { readStrictFqn } from '../utils/elementRef';
-import { DocumentFqnIndex, FqnIndex } from './fqn-index';
-export class DeploymentsIndex extends FqnIndex {
-    services;
-    Names;
-    constructor(services) {
-        super(services);
-        this.services = services;
-        this.Names = services.references.NameProvider;
-    }
-    createDocumentIndex(document) {
-        const rootNodes = document.parseResult.value.deployments.flatMap(m => m.elements);
-        if (rootNodes.length === 0) {
-            return DocumentFqnIndex.EMPTY;
-        }
-        const projectId = this.projects.belongsTo(document);
-        const root = new Array();
-        const children = new MultiMap();
-        const descendants = new MultiMap();
-        const byfqn = new MultiMap();
-        const Names = this.Names;
-        const Descriptions = this.services.workspace.AstNodeDescriptionProvider;
-        const createAndSaveDescription = (node, name, fqn) => {
-            const desc = {
-                ...Descriptions.createDescription(node, name, document),
-                id: fqn,
-                likec4ProjectId: projectId,
-            };
-            ElementOps.writeId(node, fqn);
-            byfqn.set(fqn, desc);
-            return desc;
-        };
-        const traverseNode = (node, parentFqn) => {
-            let thisFqn;
-            if (ast.isExtendDeployment(node)) {
-                thisFqn = readStrictFqn(node.deploymentNode);
-            }
-            else {
-                const name = Names.getName(node);
-                if (!isTruthy(name)) {
-                    return [];
-                }
-                thisFqn = Fqn(name, parentFqn);
-                const desc = createAndSaveDescription(node, name, thisFqn);
-                if (!parentFqn) {
-                    root.push(desc);
-                }
-                else {
-                    children.set(parentFqn, desc);
-                }
-                if (ast.isDeployedInstance(node)) {
-                    return [];
-                }
-            }
-            let _nested = [];
-            if (isDefined(node.body)) {
-                for (const child of node.body.elements) {
-                    if (!ast.isDeploymentRelation(child)) {
-                        try {
-                            _nested.push(...traverseNode(child, thisFqn));
-                        }
-                        catch (e) {
-                            logWarnError(e);
-                        }
-                    }
-                }
-            }
-            _nested = [
-                ...children.get(thisFqn) ?? [],
-                ..._nested,
-            ];
-            for (const child of _nested) {
-                descendants.set(thisFqn, child);
-            }
-            if (ast.isExtendDeployment(node)) {
-                for (const ancestor of ancestorsFqn(thisFqn)) {
-                    for (const child of _nested) {
-                        descendants.set(ancestor, child);
-                    }
-                }
-            }
-            return descendants.get(thisFqn) ?? [];
-        };
-        for (const node of rootNodes) {
-            try {
-                if (ast.isDeploymentRelation(node)) {
-                    continue;
-                }
-                traverseNode(node, null);
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-        return new DocumentFqnIndex(root, children, descendants, byfqn, projectId);
-    }
-}