@likec4/language-server 0.37.1 → 0.41.0

package/contrib/likec4.monarch.ts

@@ -1,12 +1,12 @@
 // Monarch syntax highlighting for the likec4 language.
 export default {
     keywords: [
-        'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','browser','color','cylinder','description','element','exclude','extend','extends','gray','green','icon','include','indigo','it','kind','link','mobile','model','muted','of','person','primary','queue','rectangle','red','secondary','shape','sky','slate','specification','storage','style','tag','technology','this','title','view','views'
+        'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','browser','color','crow','cylinder','dashed','description','diamond','dotted','element','exclude','extend','extends','gray','green','head','icon','include','indigo','it','kind','line','link','mobile','model','muted','none','normal','odiamond','of','onormal','open','person','primary','queue','rectangle','red','relationship','secondary','shape','sky','slate','solid','specification','storage','style','tag','tail','technology','this','title','vee','view','views'
     ],
     operators: [
         '*','.*'
     ],
-    symbols: /\*|\.\*/,
+    symbols: /\*|-\[|\.\*|\]->/,
 
     tokenizer: {
         initial: [
@@ -27,17 +27,17 @@ export default {
             { regex: /:/, action: {"token":"Colon"} },
             { regex: /;/, action: {"token":"SemiColon"} },
             { regex: /,/, action: {"token":"Comma"} },
+            { regex: /"[^"]*"|'[^']*'/, action: {"token":"string"} },
             { regex: /((#)([^\W\d_])(((([^\W\d_])|([0-9]))|(_))|(-))*)/, action: {"token":"TagID"} },
             { regex: /((([^\W\d_])|(_))(((([^\W\d_])|([0-9]))|(_))|(-))*)/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"ID"} }} },
-            { regex: /"[^"]*"|'[^']*'/, action: {"token":"string"} },
             { include: '@whitespace' },
             { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },
         ],
         whitespace: [
-            { regex: /[^\S\r\n]/, action: {"token":"white"} },
-            { regex: /(([\t\r\n\v\f])|([^\S\r\n]))+/, action: {"token":"white"} },
             { regex: /\/\*/, action: {"token":"comment","next":"@comment"} },
             { regex: /\/\/[^\n\r]*/, action: {"token":"comment"} },
+            { regex: /(([\t\r\n\v\f])|([^\S\r\n]))+/, action: {"token":"white"} },
+            { regex: /[^\S\r\n]/, action: {"token":"white"} },
         ],
         comment: [
             { regex: /[^/\*]+/, action: {"token":"comment"} },

package/contrib/likec4.tmLanguage.json

@@ -12,7 +12,7 @@
     },
     {
       "name": "keyword.control.likec4",
-      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|browser|color|cylinder|description|element|exclude|extend|extends|gray|green|icon|include|indigo|it|kind|link|mobile|model|muted|of|person|primary|queue|rectangle|red|secondary|shape|sky|slate|specification|storage|style|tag|technology|this|title|view|views)\\b"
+      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|browser|color|crow|cylinder|dashed|description|diamond|dotted|element|exclude|extend|extends|gray|green|head|icon|include|indigo|it|kind|line|link|mobile|model|muted|none|normal|odiamond|of|onormal|open|person|primary|queue|rectangle|red|relationship|secondary|shape|sky|slate|solid|specification|storage|style|tag|tail|technology|this|title|vee|view|views)\\b"
     },
     {
       "name": "string.quoted.double.likec4",

package/dist/Rpc.d.ts

@@ -0,0 +1,7 @@
+import type { LikeC4Services } from './module';
+export declare class Rpc {
+    private services;
+    constructor(services: LikeC4Services);
+    init(): void;
+}
+//# sourceMappingURL=Rpc.d.ts.map

package/dist/Rpc.js

@@ -0,0 +1,130 @@
+import { logError, logger } from "./logger.js";
+import pThrottle from "p-throttle";
+import { nonexhaustive } from "@likec4/core";
+import { URI } from "langium";
+import { isLikeC4LangiumDocument } from "./ast.js";
+import {
+  buildDocuments,
+  computeView,
+  fetchModel,
+  fetchRawModel,
+  locate,
+  onDidChangeModel,
+  rebuild
+} from "./protocol.js";
+export class Rpc {
+  constructor(services) {
+    this.services = services;
+  }
+  init() {
+    const { ModelBuilder: modelBuilder, ModelLocator: modelLocator } = this.services.likec4;
+    const connection = this.services.shared.lsp.Connection;
+    if (!connection) {
+      return;
+    }
+    logger.info(`[ServerRpc] init`);
+    const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
+    const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
+    const notifyClient = pThrottle({
+      limit: 4,
+      interval: 1e3
+    })(() => connection.sendNotification(onDidChangeModel, ""));
+    modelBuilder.onModelParsed(() => {
+      void notifyClient();
+    });
+    connection.onRequest(fetchModel, async (_cancelToken) => {
+      let model;
+      try {
+        model = modelBuilder.buildModel() ?? null;
+      } catch (e) {
+        model = null;
+        logError(e);
+      }
+      return Promise.resolve({ model });
+    });
+    connection.onRequest(fetchRawModel, async (_cancelToken) => {
+      let rawmodel;
+      try {
+        rawmodel = modelBuilder.buildRawModel() ?? null;
+      } catch (e) {
+        rawmodel = null;
+        logError(e);
+      }
+      return Promise.resolve({ rawmodel });
+    });
+    connection.onRequest(computeView, ({ viewId }) => {
+      return {
+        view: modelBuilder.computeView(viewId)
+      };
+    });
+    connection.onRequest(rebuild, async (cancelToken) => {
+      const changed = LangiumDocuments.all.map((d) => {
+        if (isLikeC4LangiumDocument(d)) {
+          delete d.c4Specification;
+          delete d.c4Elements;
+          delete d.c4Relations;
+          delete d.c4Views;
+          delete d.c4fqns;
+        }
+        return d.uri;
+      }).toArray();
+      logger.debug(`[ServerRpc] rebuild all documents: [
+        ${changed.map((d) => d.toString()).join("\n      ")}
+      ]`);
+      await DocumentBuilder.update(changed, [], cancelToken);
+      return {
+        docs: changed.map((d) => d.toString())
+      };
+    });
+    connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
+      if (docs.length === 0) {
+        logger.debug(`[ServerRpc] received empty request to rebuild`);
+        return;
+      }
+      logger.debug(
+        `[ServerRpc] received request to buildDocuments:
+${docs.map((d) => "   - " + d).join("\n")}`
+      );
+      const changed = [];
+      for (const d of docs) {
+        try {
+          const uri = URI.parse(d);
+          if (LangiumDocuments.hasDocument(uri)) {
+            changed.push(uri);
+          } else {
+            logger.warn(`[ServerRpc] LangiumDocuments does not have document: ${d}`);
+            LangiumDocuments.getOrCreateDocument(uri);
+          }
+        } catch (e) {
+          logError(e);
+        }
+      }
+      if (changed.length !== docs.length) {
+        const all = LangiumDocuments.all.map((d) => d.uri.toString()).toArray();
+        logger.warn(
+          `
+[ServerRpc] We have in LangiumDocuments: [
+  ${all.join("\n  ")}
+]
+We rebuild: [
+  ${changed.join("\n  ")}
+]
+  `.trim()
+        );
+      }
+      await DocumentBuilder.update(changed, [], cancelToken);
+    });
+    connection.onRequest(locate, (params) => {
+      if ("element" in params) {
+        return modelLocator.locateElement(params.element, params.property ?? "name");
+      }
+      if ("relation" in params) {
+        return modelLocator.locateRelation(params.relation);
+      }
+      if ("view" in params) {
+        return modelLocator.locateView(params.view);
+      }
+      nonexhaustive(params);
+    });
+  }
+}

package/dist/ast.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { type c4 } from '@likec4/core';
 import type { LangiumDocument, MultiMap } from 'langium';
 import type { LikeC4Document } from './generated/ast';
@@ -14,6 +15,12 @@ export interface ParsedAstSpecification {
         color?: c4.ThemeColor;
         icon?: c4.IconUrl;
     }>;
+    relationships: Record<c4.RelationshipKind, {
+        color?: c4.ThemeColor;
+        line?: c4.RelationshipLineType;
+        head?: c4.RelationshipArrowType;
+        tail?: c4.RelationshipArrowType;
+    }>;
 }
 export interface ParsedAstElement {
     id: c4.Fqn;
@@ -33,6 +40,7 @@ export interface ParsedAstRelation {
     astPath: string;
     source: c4.Fqn;
     target: c4.Fqn;
+    kind?: c4.RelationshipKind;
     title: string;
 }
 export interface ParsedAstElementView {
@@ -93,5 +101,17 @@ export declare function toElementStyleExcludeDefaults(props?: ast.StylePropertie
     color?: "amber" | "blue" | "gray" | "slate" | "green" | "indigo" | "muted" | "red" | "secondary" | "sky";
     icon?: c4.IconUrl;
 };
+export declare function toRelationshipStyle(props?: ast.SpecificationRelationshipKind['props']): {
+    color?: c4.ThemeColor;
+    line?: c4.RelationshipLineType;
+    head?: c4.RelationshipArrowType;
+    tail?: c4.RelationshipArrowType;
+};
+export declare function toRelationshipStyleExcludeDefaults(props?: ast.SpecificationRelationshipKind['props']): {
+    tail?: "none" | "onormal" | "diamond" | "odiamond" | "crow" | "open" | "vee";
+    head?: "none" | "onormal" | "diamond" | "odiamond" | "crow" | "open" | "vee";
+    line?: "solid" | "dotted";
+    color?: "amber" | "blue" | "slate" | "green" | "indigo" | "muted" | "primary" | "red" | "secondary" | "sky";
+};
 export declare function toAutoLayout(direction: ast.ViewRuleLayoutDirection): c4.ViewRuleAutoLayout['autoLayout'];
 //# sourceMappingURL=ast.d.ts.map

package/dist/ast.js

@@ -1,175 +1,203 @@
-import { DefaultElementShape, DefaultThemeColor, RelationRefError, nonexhaustive } from '@likec4/core';
-import { DocumentState } from 'langium';
-import { elementRef } from './elementRef';
-import * as ast from './generated/ast';
-import { LikeC4LanguageMetaData } from './generated/module';
+import { DefaultElementShape, DefaultThemeColor, RelationRefError, nonexhaustive, DefaultLineStyle, DefaultArrowType, DefaultRelationshipColor } from "@likec4/core";
+import { DocumentState } from "langium";
+import { elementRef } from "./elementRef.js";
+import * as ast from "./generated/ast.js";
+import { LikeC4LanguageMetaData } from "./generated/module.js";
 export { ast };
-const idattr = Symbol.for('idattr');
+const idattr = Symbol.for("idattr");
 export const ElementViewOps = {
-    writeId(node, id) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-extra-semi
-        ;
-        node[idattr] = id;
-        return node;
-    },
-    readId(node) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return node[idattr];
-    }
+  writeId(node, id) {
+    ;
+    node[idattr] = id;
+    return node;
+  },
+  readId(node) {
+    return node[idattr];
+  }
 };
 export const ElementOps = {
-    writeId(node, id) {
-        if (id === null) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-dynamic-delete
-            delete node[idattr];
-            delete node.fqn;
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-extra-semi
-            ;
-            node[idattr] = id;
-            node.fqn = id;
-        }
-        return node;
-    },
-    readId(node) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return node[idattr];
+  writeId(node, id) {
+    if (id === null) {
+      delete node[idattr];
+      delete node.fqn;
+    } else {
+      ;
+      node[idattr] = id;
+      node.fqn = id;
     }
+    return node;
+  },
+  readId(node) {
+    return node[idattr];
+  }
 };
 export function cleanParsedModel(doc) {
-    const specification = (doc.c4Specification = {
-        kinds: {}
-    });
-    const elements = (doc.c4Elements = []);
-    const relations = (doc.c4Relations = []);
-    const views = (doc.c4Views = []);
-    return {
-        elements,
-        relations,
-        views,
-        specification
-    };
+  const specification = doc.c4Specification = {
+    kinds: {},
+    relationships: {}
+  };
+  const elements = doc.c4Elements = [];
+  const relations = doc.c4Relations = [];
+  const views = doc.c4Views = [];
+  return {
+    elements,
+    relations,
+    views,
+    specification
+  };
 }
 export function isLikeC4LangiumDocument(doc) {
-    return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
+  return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
 }
 export function isParsedLikeC4LangiumDocument(doc) {
-    return (isLikeC4LangiumDocument(doc) &&
-        doc.state >= DocumentState.Validated &&
-        !!doc.c4Specification &&
-        !!doc.c4Elements &&
-        !!doc.c4Relations &&
-        !!doc.c4Views &&
-        !!doc.c4fqns);
+  return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.Validated && !!doc.c4Specification && !!doc.c4Elements && !!doc.c4Relations && !!doc.c4Views && !!doc.c4fqns;
 }
 export const isValidLikeC4LangiumDocument = (doc) => {
-    if (!isParsedLikeC4LangiumDocument(doc))
-        return false;
-    const { state, parseResult, diagnostics } = doc;
-    return (state === DocumentState.Validated &&
-        parseResult.lexerErrors.length === 0 &&
-        (!diagnostics || diagnostics.every(d => d.severity !== 1)));
+  if (!isParsedLikeC4LangiumDocument(doc))
+    return false;
+  const { state, parseResult, diagnostics } = doc;
+  return state === DocumentState.Validated && parseResult.lexerErrors.length === 0 && (!diagnostics || diagnostics.every((d) => d.severity !== 1));
 };
 export function* streamModel(doc) {
-    const elements = doc.parseResult.value.model?.elements ?? [];
-    const traverseStack = [...elements];
-    const relations = [];
-    let el;
-    while ((el = traverseStack.shift())) {
-        if (ast.isRelation(el)) {
-            relations.push(el);
-            continue;
-        }
-        if (ast.isExtendElement(el)) {
-            if (el.body && el.body.elements.length > 0) {
-                traverseStack.push(...el.body.elements);
-            }
-            continue;
-        }
-        if (el.body && el.body.elements.length > 0) {
-            for (const nested of el.body.elements) {
-                if (ast.isRelation(nested)) {
-                    relations.push(nested);
-                }
-                else {
-                    traverseStack.push(nested);
-                }
-            }
-        }
-        yield el;
+  const elements = doc.parseResult.value.model?.elements ?? [];
+  const traverseStack = [...elements];
+  const relations = [];
+  let el;
+  while (el = traverseStack.shift()) {
+    if (ast.isRelation(el)) {
+      relations.push(el);
+      continue;
     }
-    for (const relation of relations) {
-        yield relation;
+    if (ast.isExtendElement(el)) {
+      if (el.body && el.body.elements.length > 0) {
+        traverseStack.push(...el.body.elements);
+      }
+      continue;
     }
-}
-export function resolveRelationPoints(node) {
-    const target = elementRef(node.target);
-    if (!target) {
-        throw new RelationRefError('Invalid reference to target');
-    }
-    if ('source' in node) {
-        const source = elementRef(node.source);
-        if (!source) {
-            throw new RelationRefError('Invalid reference to source');
+    if (el.body && el.body.elements.length > 0) {
+      for (const nested of el.body.elements) {
+        if (ast.isRelation(nested)) {
+          relations.push(nested);
+        } else {
+          traverseStack.push(nested);
         }
-        return {
-            source,
-            target
-        };
+      }
     }
-    if (!ast.isElementBody(node.$container)) {
-        throw new RelationRefError('Invalid relation parent, expected Element');
+    yield el;
+  }
+  for (const relation of relations) {
+    yield relation;
+  }
+}
+export function resolveRelationPoints(node) {
+  const target = elementRef(node.target);
+  if (!target) {
+    throw new RelationRefError("Invalid reference to target");
+  }
+  if ("source" in node) {
+    const source = elementRef(node.source);
+    if (!source) {
+      throw new RelationRefError("Invalid reference to source");
     }
     return {
-        source: node.$container.$container,
-        target
+      source,
+      target
     };
+  }
+  if (!ast.isElementBody(node.$container)) {
+    throw new RelationRefError("Invalid relation parent, expected Element");
+  }
+  return {
+    source: node.$container.$container,
+    target
+  };
 }
 export function toElementStyle(props) {
-    const result = {};
-    if (!props || props.length === 0) {
-        return result;
+  const result = {};
+  if (!props || props.length === 0) {
+    return result;
+  }
+  for (const prop of props) {
+    if (ast.isColorProperty(prop)) {
+      result.color = prop.value;
+      continue;
     }
-    for (const prop of props) {
-        if (ast.isColorProperty(prop)) {
-            result.color = prop.value;
-            continue;
-        }
-        if (ast.isShapeProperty(prop)) {
-            result.shape = prop.value;
-            continue;
-        }
-        if (ast.isIconProperty(prop)) {
-            result.icon = prop.value;
-            continue;
-        }
-        nonexhaustive(prop);
+    if (ast.isShapeProperty(prop)) {
+      result.shape = prop.value;
+      continue;
     }
-    return result;
+    if (ast.isIconProperty(prop)) {
+      result.icon = prop.value;
+      continue;
+    }
+    nonexhaustive(prop);
+  }
+  return result;
 }
 export function toElementStyleExcludeDefaults(props) {
-    const { color, shape, ...rest } = toElementStyle(props);
-    return {
-        ...rest,
-        ...(color && color !== DefaultThemeColor ? { color } : {}),
-        ...(shape && shape !== DefaultElementShape ? { shape } : {})
-    };
+  const { color, shape, ...rest } = toElementStyle(props);
+  return {
+    ...rest,
+    ...color && color !== DefaultThemeColor ? { color } : {},
+    ...shape && shape !== DefaultElementShape ? { shape } : {}
+  };
 }
-export function toAutoLayout(direction) {
-    switch (direction) {
-        case 'TopBottom': {
-            return 'TB';
-        }
-        case 'BottomTop': {
-            return 'BT';
+export function toRelationshipStyle(props) {
+  const result = {};
+  if (!props || props.length === 0) {
+    return result;
+  }
+  for (const prop of props) {
+    if (ast.isColorProperty(prop)) {
+      result.color = prop.value;
+      continue;
+    }
+    if (ast.isLineProperty(prop)) {
+      result.line = prop.value;
+      continue;
+    }
+    if (ast.isArrowProperty(prop)) {
+      switch (prop.key) {
+        case "head": {
+          result.head = prop.value;
+          break;
         }
-        case 'LeftRight': {
-            return 'LR';
+        case "tail": {
+          result.tail = prop.value;
+          break;
         }
-        case 'RightLeft': {
-            return 'RL';
+        default: {
+          nonexhaustive(prop);
         }
+      }
+      continue;
+    }
+    nonexhaustive(prop);
+  }
+  return result;
+}
+export function toRelationshipStyleExcludeDefaults(props) {
+  const { color, line, head, tail } = toRelationshipStyle(props);
+  return {
+    ...color && color !== DefaultRelationshipColor ? { color } : {},
+    ...line && line !== DefaultLineStyle ? { line } : {},
+    ...head && head !== DefaultArrowType ? { head } : {},
+    ...tail && tail !== DefaultArrowType ? { tail } : {}
+  };
+}
+export function toAutoLayout(direction) {
+  switch (direction) {
+    case "TopBottom": {
+      return "TB";
+    }
+    case "BottomTop": {
+      return "BT";
+    }
+    case "LeftRight": {
+      return "LR";
+    }
+    case "RightLeft": {
+      return "RL";
     }
+  }
 }
-//# sourceMappingURL=ast.js.map

package/dist/elementRef.js

@@ -1,52 +1,39 @@
-import { invariant, nonexhaustive } from '@likec4/core';
-import { ast } from './ast';
+import { invariant, nonexhaustive } from "@likec4/core";
+import { ast } from "./ast.js";
 export function isElementRefHead(node) {
-    if (ast.isElementRef(node)) {
-        return !ast.isElementRef(node.$container);
-    }
-    if (ast.isStrictElementRef(node)) {
-        return !ast.isStrictElementRef(node.$container);
-    }
-    nonexhaustive(node);
+  if (ast.isElementRef(node)) {
+    return !ast.isElementRef(node.$container);
+  }
+  if (ast.isStrictElementRef(node)) {
+    return !ast.isStrictElementRef(node.$container);
+  }
+  nonexhaustive(node);
 }
-/**
- * Returns referenced AST Element
- *
- */
 export function elementRef(node) {
-    invariant(isElementRefHead(node), 'Expected head ElementRef');
-    while (node.next) {
-        node = node.next;
-    }
-    return node.el.ref;
+  invariant(isElementRefHead(node), "Expected head ElementRef");
+  while (node.next) {
+    node = node.next;
+  }
+  return node.el.ref;
 }
-/**
- * Returns FQN of strictElementRef
- * a.b.c.d - for c node returns a.b
- */
 export function fqnElementRef(node) {
-    invariant(isElementRefHead(node), 'Expected head StrictElementRef');
-    const name = [node.el.$refText];
-    let child = node.next;
-    while (child) {
-        name.push(child.el.$refText);
-        child = child.next;
-    }
-    return name.join('.');
+  invariant(isElementRefHead(node), "Expected head StrictElementRef");
+  const name = [node.el.$refText];
+  let child = node.next;
+  while (child) {
+    name.push(child.el.$refText);
+    child = child.next;
+  }
+  return name.join(".");
 }
-/**
- * Returns parent FQN
- * a.b.c.d - for c node returns a.b
- */
 export function parentFqnElementRef(node) {
-    invariant(!isElementRefHead(node), 'Expected next StrictElementRef');
-    const path = [];
-    let parent = node.$container;
-    while (ast.isStrictElementRef(parent)) {
-        path.unshift(parent.el.$refText);
-        parent = parent.$container;
-    }
-    invariant(path.length > 0, 'Expected non-empty parent path');
-    return path.join('.');
+  invariant(!isElementRefHead(node), "Expected next StrictElementRef");
+  const path = [];
+  let parent = node.$container;
+  while (ast.isStrictElementRef(parent)) {
+    path.unshift(parent.el.$refText);
+    parent = parent.$container;
+  }
+  invariant(path.length > 0, "Expected non-empty parent path");
+  return path.join(".");
 }
-//# sourceMappingURL=elementRef.js.map