@likec4/language-server 1.43.0 → 1.45.0

package/dist/model/model-parser.js

@@ -0,0 +1,126 @@
+import { DefaultWeakMap, invariant, MultiMap } from '@likec4/core/utils';
+import { DocumentState, UriUtils } from 'langium';
+import { pipe } from 'remeda';
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import { isLikeC4LangiumDocument } from '../ast';
+import { logger as rootLogger, logWarnError } from '../logger';
+import { BaseParser } from './parser/Base';
+import { DeploymentModelParser } from './parser/DeploymentModelParser';
+import { DeploymentViewParser } from './parser/DeploymentViewParser';
+import { ExpressionV2Parser } from './parser/FqnRefParser';
+import { GlobalsParser } from './parser/GlobalsParser';
+import { ImportsParser } from './parser/ImportsParser';
+import { ModelParser } from './parser/ModelParser';
+import { PredicatesParser } from './parser/PredicatesParser';
+import { SpecificationParser } from './parser/SpecificationParser';
+import { ViewsParser } from './parser/ViewsParser';
+const DocumentParserFromMixins = pipe(BaseParser, ExpressionV2Parser, ImportsParser, ModelParser, DeploymentModelParser, DeploymentViewParser, PredicatesParser, SpecificationParser, ViewsParser, GlobalsParser);
+export class DocumentParser extends DocumentParserFromMixins {
+}
+const logger = rootLogger.getChild('ModelParser');
+export class LikeC4ModelParser {
+    services;
+    cachedParsers = new DefaultWeakMap((doc) => this.createParser(doc));
+    constructor(services) {
+        this.services = services;
+        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Linked, async (doc) => {
+            if (this.cachedParsers.has(doc)) {
+                logger.trace('Linked: clear cached parser {projectId} document {doc}', {
+                    projectId: doc.likec4ProjectId,
+                    doc: UriUtils.basename(doc.uri),
+                });
+                this.cachedParsers.delete(doc);
+            }
+        });
+        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Linked, async (docs) => {
+            for (const doc of docs) {
+                if (services.shared.workspace.ProjectsManager.isExcluded(doc)) {
+                    continue;
+                }
+                try {
+                    // Force create parser for linked document (if not yet created)
+                    this.parse(doc);
+                }
+                catch (error) {
+                    logWarnError(error);
+                }
+            }
+        });
+        // We need to clean up cached parser when document is validated and has errors
+        // Because after that parser takes into account validation results
+        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Validated, async (doc) => {
+            if (doc.diagnostics?.some(d => d.severity === DiagnosticSeverity.Error) && this.cachedParsers.has(doc)) {
+                logger.trace('Validated: clear cached parser {projectId} document {doc} because of errors', {
+                    projectId: doc.likec4ProjectId,
+                    doc: UriUtils.basename(doc.uri),
+                });
+                this.cachedParsers.delete(doc);
+            }
+        });
+    }
+    documents(projectId) {
+        return this.services.shared.workspace.LangiumDocuments.projectDocuments(projectId).map(d => this.parse(d));
+    }
+    parse(doc) {
+        const parser = this.forDocument(doc);
+        return parser.doc;
+    }
+    forDocument(doc) {
+        return this.cachedParsers.get(doc);
+    }
+    createParser(doc) {
+        invariant(isLikeC4LangiumDocument(doc), `Document ${doc.uri.toString()} is not a LikeC4 document`);
+        const docbasename = UriUtils.basename(doc.uri);
+        if (doc.likec4ProjectId) {
+            logger.trace(`create parser {projectId} document {doc}`, {
+                projectId: doc.likec4ProjectId,
+                doc: docbasename,
+            });
+        }
+        else {
+            logger.warn(`create parser for document without project {doc}`, { doc: doc.uri.fsPath });
+        }
+        if (doc.state < DocumentState.Linked) {
+            logger.warn(`Document {doc} is not linked, state is {state}`, {
+                doc: docbasename,
+                state: doc.state,
+            });
+        }
+        const props = {
+            c4Specification: {
+                tags: {},
+                elements: {},
+                relationships: {},
+                colors: {},
+                deployments: {},
+            },
+            c4Elements: [],
+            c4ExtendElements: [],
+            c4ExtendDeployments: [],
+            c4Relations: [],
+            c4Deployments: [],
+            c4DeploymentRelations: [],
+            c4Globals: {
+                predicates: {},
+                dynamicPredicates: {},
+                styles: {},
+            },
+            c4Views: [],
+            c4Imports: new MultiMap(Set),
+        };
+        doc = Object.assign(doc, props);
+        const parser = new DocumentParser(this.services, doc);
+        try {
+            parser.parseSpecification();
+            parser.parseImports();
+            parser.parseModel();
+            parser.parseGlobals();
+            parser.parseDeployment();
+            parser.parseViews();
+        }
+        catch (error) {
+            throw new Error(`Error parsing document ${doc.uri.fsPath}`, { cause: error });
+        }
+        return parser;
+    }
+}

package/dist/model/parser/Base.d.ts

@@ -25,14 +25,14 @@ export declare class BaseParser {
     constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument);
     get project(): Project;
     resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-    getAstNodePath(node: AstNode): any;
+    getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
         [key: string]: string | string[];
     } | undefined;
     parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
     convertTags<E extends {
         tags?: ast.Tags;
-    }>(withTags?: E): any;
+    }>(withTags?: E): c4.NonEmptyArray<c4.Tag<string>> | null;
     parseTags<E extends {
         tags?: ast.Tags;
     }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;

package/dist/model/parser/Base.js

@@ -0,0 +1,367 @@
+import { exact, GlobalFqn, isNonEmptyArray, memoizeProp, nonexhaustive, nonNullable, } from '@likec4/core';
+import { filter, flatMap, groupBy, isArray, isBoolean, isEmpty, isNumber, isString, isTruthy, mapValues, pipe, unique, } from 'remeda';
+import { dedent } from 'strip-indent';
+import { hasLeadingSlash, hasProtocol, isRelative, joinRelativeURL, joinURL } from 'ufo';
+import { ast, parseAstOpacityProperty, parseAstPercent, parseAstSizeValue, parseMarkdownAsString, toColor, } from '../../ast';
+import { serverLogger } from '../../logger';
+import { projectIdFrom } from '../../utils';
+import { readStrictFqn } from '../../utils/elementRef';
+import { checksFromDiagnostics } from '../../validation';
+const logger = serverLogger.getChild('BaseParser');
+export function toSingleLine(str) {
+    if (str === null || str === undefined) {
+        return undefined;
+    }
+    const without = removeIndent(str);
+    if (isString(without)) {
+        return without.split('\n').join(' ');
+    }
+    if ('md' in without) {
+        return {
+            md: without.md.split('\n').join('  '),
+        };
+    }
+    return {
+        txt: without.txt.split('\n').join(' '),
+    };
+}
+// export function removeIndent(str: ast.MarkdownOrString | string): MarkdownOrString | string
+export function removeIndent(str) {
+    if (str === null || str === undefined) {
+        return undefined;
+    }
+    switch (true) {
+        case isString(str):
+            return dedent(str).trim();
+        case ast.isMarkdownOrString(str) && isTruthy(str.markdown):
+            return {
+                md: dedent(str.markdown).trim(),
+            };
+        case ast.isMarkdownOrString(str) && isTruthy(str.text):
+            return {
+                txt: dedent(str.text).trim(),
+            };
+        default:
+            return undefined;
+    }
+}
+export class BaseParser {
+    services;
+    doc;
+    isValid;
+    constructor(services, doc) {
+        this.services = services;
+        this.doc = doc;
+        // do nothing
+        this.isValid = checksFromDiagnostics(doc).isValid;
+    }
+    get project() {
+        return memoizeProp(this, 'project', () => this.services.shared.workspace.ProjectsManager.getProject(this.doc));
+    }
+    resolveFqn(node) {
+        if (ast.isImported(node)) {
+            const project = projectIdFrom(node);
+            const fqn = this.resolveFqn(nonNullable(node.imported.ref, `FqnRef is empty of imported: ${node.$cstNode?.text}`));
+            this.doc.c4Imports.set(project, fqn);
+            return GlobalFqn(project, fqn);
+        }
+        if (ast.isExtendElement(node)) {
+            return readStrictFqn(node.element);
+        }
+        if (ast.isExtendDeployment(node)) {
+            return readStrictFqn(node.deploymentNode);
+        }
+        if (ast.isDeploymentElement(node)) {
+            return this.services.likec4.DeploymentsIndex.getFqn(node);
+        }
+        return this.services.likec4.FqnIndex.getFqn(node);
+    }
+    getAstNodePath(node) {
+        return this.services.workspace.AstNodeLocator.getAstNodePath(node);
+    }
+    getMetadata(metadataAstNode) {
+        if (!metadataAstNode || !this.isValid(metadataAstNode) || isEmpty(metadataAstNode.props)) {
+            return undefined;
+        }
+        // Helper function to extract string values from MetadataValue
+        const extractValues = (value) => {
+            if (ast.isMarkdownOrString(value)) {
+                const mdOrStr = removeIndent(value);
+                if (!mdOrStr)
+                    return [];
+                // Handle both string and MarkdownOrString types
+                if (typeof mdOrStr === 'string') {
+                    return isTruthy(mdOrStr) ? [mdOrStr] : [];
+                }
+                else {
+                    // MarkdownOrString object with txt or md property
+                    const strValue = mdOrStr.md || mdOrStr.txt;
+                    return isTruthy(strValue) ? [strValue] : [];
+                }
+            }
+            else if (ast.isMetadataArray(value)) {
+                return value.values
+                    .map(v => removeIndent(v))
+                    .map(v => {
+                    if (typeof v === 'string') {
+                        return v;
+                    }
+                    else {
+                        // MarkdownOrString object
+                        return v.md || v.txt;
+                    }
+                })
+                    .filter(isTruthy);
+            }
+            return [];
+        };
+        // Transform metadata attributes into key-value pairs
+        const keyValuePairs = pipe(metadataAstNode.props, flatMap(p => extractValues(p.value).map(v => [p.key, v])), filter(([_, value]) => isTruthy(value)));
+        if (isEmpty(keyValuePairs)) {
+            return undefined;
+        }
+        // Group by key to handle duplicate keys
+        const groupedData = pipe(keyValuePairs, groupBy(([key]) => key), mapValues(pairs => pairs.map(([_, value]) => value)));
+        // Convert to final format: single values as string, multiple values as string[]
+        const data = {};
+        for (const [key, values] of Object.entries(groupedData)) {
+            if (values && values.length > 0) {
+                data[key] = values.length === 1 ? values[0] : values;
+            }
+        }
+        return isEmpty(data) ? undefined : data;
+    }
+    parseMarkdownOrString(markdownOrString) {
+        if (ast.isMarkdownOrString(markdownOrString)) {
+            return removeIndent(markdownOrString);
+        }
+        return undefined;
+    }
+    convertTags(withTags) {
+        return this.parseTags(withTags);
+    }
+    parseTags(withTags) {
+        let iter = withTags?.tags;
+        if (!iter) {
+            return null;
+        }
+        let tags = [];
+        while (iter) {
+            try {
+                if (this.isValid(iter)) {
+                    const values = iter.values.map(t => t.tag.ref?.name).filter(isTruthy);
+                    if (values.length > 0) {
+                        tags.push(...values);
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+            iter = iter.prev;
+        }
+        return isNonEmptyArray(tags) ? unique(tags) : null;
+    }
+    convertLinks(source) {
+        return this.parseLinks(source);
+    }
+    parseLinks(source) {
+        if (!source?.props || source.props.length === 0) {
+            return undefined;
+        }
+        return pipe(source.props, filter(ast.isLinkProperty), flatMap(p => {
+            if (!this.isValid(p)) {
+                return [];
+            }
+            const url = p.value;
+            if (isTruthy(url)) {
+                const title = isTruthy(p.title) ? toSingleLine(p.title) : undefined;
+                const relative = this.services.lsp.DocumentLinkProvider.relativeLink(this.doc, url);
+                return {
+                    url,
+                    ...(title && { title }),
+                    ...(relative && relative !== url && { relative }),
+                };
+            }
+            return [];
+        }));
+    }
+    parseIconProperty(prop) {
+        if (!prop || !this.isValid(prop)) {
+            return undefined;
+        }
+        const { libicon, value } = prop;
+        switch (true) {
+            case !!libicon: {
+                return nonNullable(libicon.ref, `Library icon ${libicon.$refText} has empty ref`).name;
+            }
+            case value && value === 'none': {
+                return value;
+            }
+            case value && hasProtocol(value): {
+                if (value.startsWith('file:')) {
+                    logger.warn(`Icon property '${value}' used the 'file' protocol which is not supported`);
+                    return undefined;
+                }
+                return value;
+            }
+            case value && value.startsWith('@'): {
+                return this.parseImageAlias(value);
+            }
+            case value && isRelative(value): {
+                return joinRelativeURL(this.doc.uri.toString(), '../', value);
+            }
+            case value && hasLeadingSlash(value): {
+                return joinURL(this.project.folderUri.toString(), value);
+            }
+            default: {
+                logger.warn(`Icon property '${value}' is not a valid URL, library icon, image alias or 'none'`);
+                return undefined;
+            }
+        }
+    }
+    parseImageAlias(value) {
+        // Extract the alias name (e.g., '@infra' from '@infra/backend.svg')
+        const slashIndex = value.indexOf('/');
+        const aliasName = slashIndex > 0 ? value.substring(0, slashIndex) : value;
+        const remainingPath = slashIndex > 0 ? value.substring(slashIndex + 1) : '';
+        // Get imageAliases from project config, or use default '@' -> './images' mapping
+        const imageAliases = { '@': './images', ...this.project.config.imageAliases };
+        // Look up the alias path
+        const aliasPath = imageAliases[aliasName];
+        if (!aliasPath) {
+            logger.warn(`Image alias "${aliasName}" not found in project configuration`);
+            return undefined;
+        }
+        // Combine the alias path with the remaining path
+        const fullPath = remainingPath ? joinURL(aliasPath, remainingPath) : aliasPath;
+        // Make it relative to the **project root**, not the current document.
+        return joinURL(this.project.folderUri.toString(), fullPath);
+    }
+    parseColorLiteral(astNode) {
+        if (!this.isValid(astNode)) {
+            return undefined;
+        }
+        if (ast.isHexColor(astNode)) {
+            return `#${astNode.hex}`;
+        }
+        if (ast.isRGBAColor(astNode)) {
+            let alpha = isNumber(astNode.alpha) ? astNode.alpha : undefined;
+            if (isString(astNode.alpha)) {
+                alpha = parseAstPercent(astNode.alpha) / 100;
+            }
+            if (alpha !== undefined) {
+                return `rgba(${astNode.red},${astNode.green},${astNode.blue},${alpha})`;
+            }
+            return `rgb(${astNode.red},${astNode.green},${astNode.blue})`;
+        }
+        nonexhaustive(astNode);
+    }
+    parseElementStyle(elementProps) {
+        if (!elementProps) {
+            return {};
+        }
+        if (isArray(elementProps)) {
+            const style = this.parseStyleProps(elementProps.find(ast.isElementStyleProperty)?.props);
+            // Property on element has higher priority than from style
+            const iconProp = this.parseIconProperty(elementProps.find(ast.isIconProperty));
+            if (iconProp) {
+                style.icon = iconProp;
+            }
+            return style;
+        }
+        return this.parseStyleProps(elementProps.props);
+    }
+    parseStyleProps(styleProps) {
+        const result = {};
+        if (!styleProps || styleProps.length === 0) {
+            return result;
+        }
+        for (const prop of styleProps) {
+            if (!this.isValid(prop)) {
+                continue;
+            }
+            switch (true) {
+                case ast.isBorderProperty(prop): {
+                    if (isTruthy(prop.value)) {
+                        result.border = prop.value;
+                    }
+                    break;
+                }
+                case ast.isColorProperty(prop): {
+                    const color = toColor(prop);
+                    if (isTruthy(color)) {
+                        result.color = color;
+                    }
+                    break;
+                }
+                case ast.isShapeProperty(prop): {
+                    if (isTruthy(prop.value)) {
+                        result.shape = prop.value;
+                    }
+                    break;
+                }
+                case ast.isIconProperty(prop): {
+                    const icon = this.parseIconProperty(prop);
+                    if (isTruthy(icon)) {
+                        result.icon = icon;
+                    }
+                    break;
+                }
+                case ast.isOpacityProperty(prop): {
+                    result.opacity = parseAstOpacityProperty(prop);
+                    break;
+                }
+                case ast.isMultipleProperty(prop): {
+                    result.multiple = isBoolean(prop.value) ? prop.value : false;
+                    break;
+                }
+                case ast.isShapeSizeProperty(prop): {
+                    if (isTruthy(prop.value)) {
+                        result.size = parseAstSizeValue(prop);
+                    }
+                    break;
+                }
+                case ast.isPaddingSizeProperty(prop): {
+                    if (isTruthy(prop.value)) {
+                        result.padding = parseAstSizeValue(prop);
+                    }
+                    break;
+                }
+                case ast.isTextSizeProperty(prop): {
+                    if (isTruthy(prop.value)) {
+                        result.textSize = parseAstSizeValue(prop);
+                    }
+                    break;
+                }
+                default:
+                    nonexhaustive(prop);
+            }
+        }
+        return exact(result);
+    }
+    /**
+     * Parse base properties: title, description and technology
+     *
+     * @param props - body properties (inside '{...}')
+     * @param override - optional, inline properties (right on the node)
+     *                   have higher priority and override body properties
+     */
+    parseBaseProps(props, override) {
+        const title = removeIndent(override?.title ?? parseMarkdownAsString(props.title));
+        const description = override?.description
+            ? { txt: removeIndent(override.description) }
+            : this.parseMarkdownOrString(props.description);
+        const summary = override?.summary
+            ? { txt: removeIndent(override.summary) }
+            : this.parseMarkdownOrString(props.summary);
+        const technology = toSingleLine(override?.technology) ??
+            removeIndent(parseMarkdownAsString(props.technology));
+        return exact({
+            title,
+            summary,
+            description,
+            technology,
+        });
+    }
+}

package/dist/model/parser/DeploymentModelParser.d.ts

@@ -33,14 +33,14 @@ export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B:
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: import("langium").AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
         parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;