@likec4/language-server 1.23.1 → 1.24.1

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { LikeC4FileSystem } from './LikeC4FileSystem';
 import { type LikeC4Services, type LikeC4SharedServices } from './module';
 export { getLspConnectionSink, logger as lspLogger } from './logger';
 export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
+export { isLikeC4Builtin } from './likec4lib';
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module';
 export type { LikeC4Services, LikeC4SharedServices } from './module';
 export type { LikeC4Views } from './views';

package/dist/index.js

@@ -6,6 +6,7 @@ import { getTelemetrySink, logger } from "./logger.js";
 import { createCustomLanguageServices } from "./module.js";
 import { ConfigurableLayouter } from "./views/configurable-layouter.js";
 export { getLspConnectionSink, logger as lspLogger } from "./logger.js";
+export { isLikeC4Builtin } from "./likec4lib.js";
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from "./module.js";
 export { LikeC4FileSystem };
 export async function startLanguageServer() {

package/dist/likec4lib.d.ts

@@ -1,4 +1,6 @@
+import { type URI } from 'langium';
 import { LibIcons } from './generated-lib/icons';
 export declare const Scheme = "likec4builtin";
 export declare const Uri: "likec4builtin:///likec4/lib/icons.c4";
 export { LibIcons as Content };
+export declare function isLikeC4Builtin(uri: URI): boolean;

package/dist/likec4lib.js

@@ -2,3 +2,6 @@ import { LibIcons } from "./generated-lib/icons.js";
 export const Scheme = "likec4builtin";
 export const Uri = `${Scheme}:///likec4/lib/icons.c4`;
 export { LibIcons as Content };
+export function isLikeC4Builtin(uri) {
+  return uri.scheme === Scheme;
+}

package/dist/lsp/CodeLensProvider.js

@@ -1,19 +1,23 @@
-import { DocumentState } from "langium";
-import { isParsedLikeC4LangiumDocument, ViewOps } from "../ast.js";
+import { DocumentState, interruptAndCheck } from "langium";
+import { isLikeC4LangiumDocument, ViewOps } from "../ast.js";
 import { logger } from "../logger.js";
 export class LikeC4CodeLensProvider {
   constructor(services) {
     this.services = services;
   }
   async provideCodeLens(doc, _params, cancelToken) {
-    if (doc.state !== DocumentState.Validated) {
-      logger.debug(`Waiting for document ${doc.uri.path} to be validated`);
+    if (!isLikeC4LangiumDocument(doc)) {
+      return;
+    }
+    if (doc.state <= DocumentState.Linked) {
+      logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
       await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
       logger.debug(`Document ${doc.uri.path} is validated`);
     }
-    if (!isParsedLikeC4LangiumDocument(doc)) {
-      return;
+    if (cancelToken) {
+      await interruptAndCheck(cancelToken);
     }
+    this.services.likec4.ModelParser.parse(doc);
     const views = doc.parseResult.value.views.flatMap((v) => v.views);
     return views.flatMap((ast) => {
       const viewId = ViewOps.readId(ast);

package/dist/lsp/CompletionProvider.js

@@ -1,3 +1,4 @@
+import { ThemeColors } from "@likec4/core";
 import { AstUtils } from "langium";
 import {
   DefaultCompletionProvider
@@ -12,7 +13,8 @@ const STYLE_FIELDS = [
   "border",
   "opacity",
   "multiple",
-  "size"
+  "size",
+  "textSize"
 ].join(",");
 export class LikeC4CompletionProvider extends DefaultCompletionProvider {
   completionOptions = {
@@ -45,6 +47,22 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
         insertText: `${keyword.value} '\${0}'`
       });
     }
+    if (keyword.value === "color") {
+      return acceptor(context, {
+        label: keyword.value,
+        kind: CompletionItemKind.Property,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: `${keyword.value} \${1|${ThemeColors.join(",")}|}$0`
+      });
+    }
+    if (keyword.value === "opacity") {
+      return acceptor(context, {
+        label: keyword.value,
+        kind: CompletionItemKind.Property,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: `${keyword.value} \${0:100}%`
+      });
+    }
     if (["views", "specification", "model", "deployment", "with"].includes(keyword.value)) {
       return acceptor(context, {
         label: keyword.value,
@@ -123,7 +141,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
         detail: `Extend another view`,
         kind: CompletionItemKind.Class,
         insertTextFormat: InsertTextFormat.Snippet,
-        insertText: "extend ${1:element} {\n	$0\n}"
+        insertText: "extend $1 {\n	$0\n}"
       });
     }
     if (keyword.value === "autoLayout") {

package/dist/lsp/DocumentLinkProvider.d.ts

@@ -1,11 +1,11 @@
-import type { LangiumDocument, MaybePromise } from 'langium';
+import type { LangiumDocument } from 'langium';
 import type { DocumentLinkProvider } from 'langium/lsp';
-import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver';
+import type { CancellationToken, DocumentLink, DocumentLinkParams } from 'vscode-languageserver';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
     private services;
     constructor(services: LikeC4Services);
-    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
+    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams, cancelToken?: CancellationToken): Promise<DocumentLink[]>;
     resolveLink(doc: LangiumDocument, link: string): string;
     relativeLink(doc: LangiumDocument, link: string): string | null;
 }

package/dist/lsp/DocumentLinkProvider.js

@@ -1,20 +1,20 @@
 import { AstUtils, GrammarUtils } from "langium";
 import { hasLeadingSlash, hasProtocol, isRelative, withoutBase, withoutLeadingSlash } from "ufo";
-import { ast, isParsedLikeC4LangiumDocument } from "../ast.js";
+import { ast, isLikeC4LangiumDocument } from "../ast.js";
 import { logWarnError } from "../logger.js";
 export class LikeC4DocumentLinkProvider {
   constructor(services) {
     this.services = services;
   }
-  getDocumentLinks(doc, _params) {
-    if (!isParsedLikeC4LangiumDocument(doc)) {
+  async getDocumentLinks(doc, _params, cancelToken) {
+    if (!isLikeC4LangiumDocument(doc)) {
       return [];
     }
     return AstUtils.streamAllContents(doc.parseResult.value).filter(ast.isLinkProperty).map((n) => {
       try {
         const range = GrammarUtils.findNodeForProperty(n.$cstNode, "value")?.range;
-        const target = this.resolveLink(doc, n.value);
-        if (range && hasProtocol(target)) {
+        const target = range && this.resolveLink(doc, n.value);
+        if (target && hasProtocol(target)) {
           return {
             range,
             target

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -25,7 +25,7 @@ export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvi
     protected getTagSymbol(astTag: ast.SpecificationTag): DocumentSymbol | null;
     protected getLibIconSymbol(astTag: ast.LibIcon): DocumentSymbol | null;
     protected getViewSymbol(astView: ast.LikeC4View): DocumentSymbol[];
-    protected getDeploymentElementSymbol(el: ast.DeploymentElement | ast.DeploymentRelation): DocumentSymbol[];
+    protected getDeploymentElementSymbol(el: ast.DeploymentElement | ast.DeploymentRelation | ast.ExtendDeployment): DocumentSymbol[];
     protected getDeploymentNodeSymbol(astElement: ast.DeploymentNode): DocumentSymbol[];
     protected getDeployedInstanceSymbol(astElement: ast.DeployedInstance): DocumentSymbol[];
     protected symbolKind(node: AstNode): SymbolKind;

package/dist/lsp/DocumentSymbolProvider.js

@@ -4,7 +4,7 @@ import { filter, isEmpty, isTruthy, map, pipe } from "remeda";
 import { SymbolKind } from "vscode-languageserver-types";
 import { ast } from "../ast.js";
 import { logWarnError } from "../logger.js";
-import { getFqnElementRef } from "../utils/elementRef.js";
+import { readStrictFqn } from "../utils/elementRef.js";
 export class LikeC4DocumentSymbolProvider {
   constructor(services) {
     this.services = services;
@@ -137,7 +137,7 @@ export class LikeC4DocumentSymbolProvider {
     return [
       {
         kind: this.symbolKind(astElement),
-        name: getFqnElementRef(astElement.element),
+        name: readStrictFqn(astElement.element),
         range: cst.range,
         selectionRange: nameNode.range,
         children: body.elements.flatMap((e) => this.getElementsSymbol(e))
@@ -226,6 +226,9 @@ export class LikeC4DocumentSymbolProvider {
       if (ast.isDeployedInstance(el)) {
         return this.getDeployedInstanceSymbol(el);
       }
+      if (ast.isExtendDeployment(el)) {
+        return [];
+      }
     } catch (e) {
       logWarnError(e);
     }

package/dist/lsp/HoverProvider.js

@@ -1,6 +1,5 @@
 import { AstUtils } from "langium";
 import { AstNodeHoverProvider } from "langium/lsp";
-import stripIndent from "strip-indent";
 import { ast } from "../ast.js";
 export class LikeC4HoverProvider extends AstNodeHoverProvider {
   parser;
@@ -15,9 +14,7 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
       return {
         contents: {
           kind: "markdown",
-          value: stripIndent(`
-            tag: \`${node.name}\`
-          `)
+          value: "tag `" + node.name + "`"
         }
       };
     }
@@ -28,7 +25,7 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
       if (el.title !== node.name) {
         lines.push(`### ${el.title}`);
       }
-      lines.push("Deployment: `" + el.kind + "` ");
+      lines.push("deployment node `" + el.kind + "` ");
       return {
         contents: {
           kind: "markdown",
@@ -42,7 +39,7 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
       const el = this.locator.getParsedElement(instance.element);
       const lines = [instance.id + "  ", `instance of \`${instance.element}\``];
       if (el) {
-        lines.push(`### ${el.title}`, "Element: `" + el.kind + "` ");
+        lines.push(`### ${el.title}`, "element kind `" + el.kind + "` ");
       }
       return {
         contents: {
@@ -51,12 +48,28 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
         }
       };
     }
+    if (ast.isElementKind(node)) {
+      return {
+        contents: {
+          kind: "markdown",
+          value: "element kind `" + node.name + "`"
+        }
+      };
+    }
+    if (ast.isDeploymentNodeKind(node)) {
+      return {
+        contents: {
+          kind: "markdown",
+          value: "deployment node `" + node.name + "`"
+        }
+      };
+    }
     if (ast.isElement(node)) {
       const el = this.locator.getParsedElement(node);
       if (!el) {
         return;
       }
-      const lines = [el.id, `### ${el.title}`, "Element: `" + el.kind + "` "];
+      const lines = [el.id, `### ${el.title}`, "element kind `" + el.kind + "` "];
       return {
         contents: {
           kind: "markdown",

package/dist/lsp/SemanticTokenProvider.js

@@ -191,7 +191,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       });
       return "prune";
     }
-    if (ast.isFqnRef(node)) {
+    if (ast.isFqnRef(node) || ast.isStrictFqnRef(node)) {
       acceptor({
         node,
         property: "value",
@@ -334,6 +334,23 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       type: SemanticTokenTypes.keyword,
       modifier: []
     });
+    if (ast.isElement(node)) {
+      if (node.props.length > 0) {
+        acceptor({
+          node,
+          property: "props",
+          type: SemanticTokenTypes.string
+        });
+      }
+      return;
+    }
+    if (node.title) {
+      acceptor({
+        node,
+        property: "title",
+        type: SemanticTokenTypes.string
+      });
+    }
   }
   highlightView(node, acceptor) {
     if (node.name) {

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

@@ -0,0 +1,12 @@
+import type * as c4 from '@likec4/core';
+import type { ParsedAstExtend } from '../../ast';
+export declare class MergedExtends {
+    private mergedData;
+    merge(parsedExtends: ParsedAstExtend[]): void;
+    apply<E extends {
+        id: c4.Fqn;
+        tags?: c4.NonEmptyArray<c4.Tag> | null;
+        links?: c4.NonEmptyArray<c4.Link> | null;
+        metadata?: Record<string, string>;
+    }>(el: E): E;
+}

package/dist/model/builder/MergedExtends.js

@@ -0,0 +1,67 @@
+import {
+  hasAtLeast,
+  isEmpty,
+  unique
+} from "remeda";
+export class MergedExtends {
+  mergedData = /* @__PURE__ */ new Map();
+  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 = {
+          ...existing.metadata,
+          ...metadata
+        };
+      }
+      this.mergedData.set(id, existing);
+    }
+  }
+  apply(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 = {
+        ...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

@@ -0,0 +1,29 @@
+import type * as c4 from '@likec4/core';
+import type { 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: ParsedAstSpecification;
+    readonly globals: c4.ModelGlobals;
+    constructor(docs: ParsedLikeC4LangiumDocument[]);
+    /**
+     * Converts a parsed model into a C4 model element.
+     */
+    toModelElement: ({ tags, links, style: { color, shape, icon, opacity, border, size, multiple, padding, textSize, }, id, kind, title, description, technology, metadata, }: ParsedAstElement) => c4.Element | null;
+    /**
+     * Converts a parsed model into a C4 model relation.
+     */
+    toModelRelation: ({ astPath, source, target, kind, links, id, ...model }: ParsedAstRelation) => c4.ModelRelation | null;
+    /**
+     * Converts a parsed deployment model into a C4 deployment model
+     */
+    toDeploymentElement: (parsed: c4.DeploymentElement) => c4.DeploymentElement | null;
+    /**
+     * Converts a parsed deployment relation into a C4 deployment relation.
+     */
+    toDeploymentRelation: ({ astPath, source, target, kind, links, id, ...model }: ParsedAstDeploymentRelation) => c4.DeploymentRelation | null;
+}

package/dist/model/builder/MergedSpecification.js

@@ -0,0 +1,203 @@
+import {
+  DeploymentElement
+} from "@likec4/core";
+import {
+  isBoolean,
+  isEmpty,
+  isNonNullish,
+  isNumber
+} from "remeda";
+import { logger, logWarnError } from "../../logger.js";
+export class MergedSpecification {
+  specs = {
+    tags: /* @__PURE__ */ new Set(),
+    elements: {},
+    deployments: {},
+    relationships: {},
+    colors: {}
+  };
+  globals = {
+    predicates: {},
+    dynamicPredicates: {},
+    styles: {}
+  };
+  constructor(docs) {
+    for (const doc of docs) {
+      const {
+        c4Specification: spec,
+        c4Globals
+      } = doc;
+      spec.tags.forEach((t) => this.specs.tags.add(t));
+      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);
+    }
+  }
+  /**
+   * Converts a parsed model into a C4 model element.
+   */
+  toModelElement = ({
+    tags,
+    links,
+    style: {
+      color,
+      shape,
+      icon,
+      opacity,
+      border,
+      size,
+      multiple,
+      padding,
+      textSize
+    },
+    id,
+    kind,
+    title,
+    description,
+    technology,
+    metadata
+  }) => {
+    try {
+      const __kind = this.specs.elements[kind];
+      if (!__kind) {
+        logger.warn`No kind '${kind}' found for ${id}`;
+        return null;
+      }
+      color ??= __kind.style.color;
+      shape ??= __kind.style.shape;
+      icon ??= __kind.style.icon;
+      opacity ??= __kind.style.opacity;
+      border ??= __kind.style.border;
+      technology ??= __kind.technology;
+      multiple ??= __kind.style.multiple;
+      size ??= __kind.style.size;
+      padding ??= __kind.style.padding;
+      textSize ??= __kind.style.textSize;
+      return {
+        ...color && { color },
+        ...shape && { shape },
+        ...icon && { icon },
+        ...metadata && !isEmpty(metadata) && { metadata },
+        ...__kind.notation && { notation: __kind.notation },
+        style: {
+          ...border && { border },
+          ...size && { size },
+          ...padding && { padding },
+          ...textSize && { textSize },
+          ...isBoolean(multiple) && { multiple },
+          ...isNumber(opacity) && { opacity }
+        },
+        links: links ?? null,
+        tags: tags ?? null,
+        technology: technology ?? null,
+        description: description ?? null,
+        title,
+        kind,
+        id
+      };
+    } catch (e) {
+      logWarnError(e);
+    }
+    return null;
+  };
+  /**
+   * Converts a parsed model into a C4 model relation.
+   */
+  toModelRelation = ({
+    astPath,
+    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 (!DeploymentElement.isDeploymentNode(parsed)) {
+      return parsed;
+    }
+    try {
+      const __kind = this.specs.deployments[parsed.kind];
+      if (!__kind) {
+        logger.warn`No kind ${parsed.kind} found for ${parsed.id}`;
+        return null;
+      }
+      let {
+        technology = __kind.technology,
+        notation = __kind.notation,
+        style
+      } = parsed;
+      return {
+        ...parsed,
+        ...notation && { notation },
+        ...technology && { technology },
+        style: {
+          border: "dashed",
+          opacity: 10,
+          ...__kind.style,
+          ...style
+        }
+      };
+    } catch (e) {
+      logWarnError(e);
+    }
+    return null;
+  };
+  /**
+   * Converts a parsed deployment relation into a C4 deployment relation.
+   */
+  toDeploymentRelation = ({
+    astPath,
+    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

@@ -0,0 +1,3 @@
+import type * as c4 from '@likec4/core';
+import type { ParsedLikeC4LangiumDocument } from '../../ast';
+export declare function buildModel(docs: ParsedLikeC4LangiumDocument[]): c4.ParsedLikeC4Model;