@likec4/language-server 1.1.0 → 1.2.0

package/dist/model/model-builder.js

@@ -1,9 +1,10 @@
 import {
   compareByFqnHierarchically,
+  isElementView,
   isStrictElementView,
   parentFqn
 } from "@likec4/core";
-import { computeView, LikeC4ModelGraph } from "@likec4/graph";
+import { computeDynamicView, computeView, LikeC4ModelGraph } from "@likec4/graph";
 import { deepEqual as eq } from "fast-equals";
 import { DocumentState, interruptAndCheck } from "langium";
 import {
@@ -32,14 +33,14 @@ function buildModel(services, docs) {
     relationships: {}
   };
   forEach(map(docs, prop("c4Specification")), (spec) => {
-    Object.assign(c4Specification.kinds, spec.kinds), Object.assign(c4Specification.relationships, spec.relationships);
+    Object.assign(c4Specification.kinds, spec.kinds);
+    Object.assign(c4Specification.relationships, spec.relationships);
   });
   const resolveLinks = (doc, links) => {
     return links.map((l) => services.lsp.DocumentLinkProvider.resolveLink(doc, l));
   };
   const toModelElement = (doc) => {
     return ({
-      astPath,
       tags,
       links,
       style: {
@@ -49,19 +50,23 @@ function buildModel(services, docs) {
         opacity,
         border
       },
-      ...parsed
+      id,
+      kind,
+      title,
+      description,
+      technology
     }) => {
       try {
-        const kind = c4Specification.kinds[parsed.kind];
-        if (!kind) {
-          logger.warn(`No kind '${parsed.kind}' found for ${parsed.id}`);
+        const __kind = c4Specification.kinds[kind];
+        if (!__kind) {
+          logger.warn(`No kind '${kind}' found for ${id}`);
           return null;
         }
-        color ??= kind.color;
-        shape ??= kind.shape;
-        icon ??= kind.icon;
-        opacity ??= kind.opacity;
-        border ??= kind.border;
+        color ??= __kind.color;
+        shape ??= __kind.shape;
+        icon ??= __kind.icon;
+        opacity ??= __kind.opacity;
+        border ??= __kind.border;
         return {
           ...color && { color },
           ...shape && { shape },
@@ -70,11 +75,13 @@ function buildModel(services, docs) {
             ...border && { border },
             ...opacity && { opacity }
           },
-          description: null,
-          technology: null,
-          tags: tags ?? null,
           links: links ? resolveLinks(doc, links) : null,
-          ...parsed
+          tags: tags ?? null,
+          technology: technology ?? null,
+          description: description ?? null,
+          title,
+          kind,
+          id
         };
       } catch (e) {
         logWarnError(e);
@@ -83,7 +90,8 @@ function buildModel(services, docs) {
     };
   };
   const elements = pipe(
-    flatMap(docs, (d) => d.c4Elements.map(toModelElement(d))),
+    docs,
+    flatMap((d) => d.c4Elements.map(toModelElement(d))),
     filter(isTruthy),
     sort(compareByFqnHierarchically),
     reduce(
@@ -110,27 +118,30 @@ function buildModel(services, docs) {
       target,
       kind,
       links,
+      id,
       ...model
     }) => {
-      if (source in elements && target in elements) {
-        if (!!kind && kind in c4Specification.relationships) {
-          return {
-            source,
-            target,
-            kind,
-            ...links && { links: resolveLinks(doc, links) },
-            ...c4Specification.relationships[kind],
-            ...model
-          };
-        }
+      if (isNullish(elements[source]) || isNullish(elements[target])) {
+        return null;
+      }
+      if (!!kind && kind in c4Specification.relationships) {
         return {
+          ...links && { links: resolveLinks(doc, links) },
+          ...c4Specification.relationships[kind],
+          ...model,
           source,
           target,
-          ...links && { links: resolveLinks(doc, links) },
-          ...model
+          kind,
+          id
         };
       }
-      return null;
+      return {
+        ...links && { links: resolveLinks(doc, links) },
+        ...model,
+        source,
+        target,
+        id
+      };
     };
   };
   const relations = pipe(
@@ -138,35 +149,47 @@ function buildModel(services, docs) {
     filter(isTruthy),
     mapToObj((r) => [r.id, r])
   );
-  const toElementView = (doc) => {
+  const toC4View = (doc) => {
     const docUri = doc.uri.toString();
-    return (view) => {
-      let { astPath, rules, title, description, tags, links, ...model } = view;
-      if (!title && "viewOf" in view) {
-        title = elements[view.viewOf]?.title;
+    return (parsedAstView) => {
+      let {
+        id,
+        title,
+        description,
+        tags,
+        links,
+        // ignore this property
+        astPath: _ignore,
+        // model should include discriminant __
+        ...model
+      } = parsedAstView;
+      if (parsedAstView.__ === "element" && isNullish(title) && "viewOf" in parsedAstView) {
+        title ??= elements[parsedAstView.viewOf]?.title ?? null;
       }
-      if (!title && view.id === "index") {
+      if (isNullish(title) && id === "index") {
         title = "Landscape view";
       }
       return {
-        ...model,
-        title: title ?? null,
-        description: description ?? null,
-        tags: tags ?? null,
+        id,
+        title,
+        description,
+        tags,
         links: links ? resolveLinks(doc, links) : null,
         docUri,
-        rules
+        ...model
       };
     };
   };
   const views = pipe(
-    flatMap(docs, (d) => map(d.c4Views, toElementView(d))),
+    docs,
+    flatMap((d) => map(d.c4Views, toC4View(d))),
     resolveRelativePaths,
     mapToObj((v) => [v.id, v]),
     resolveRulesExtendedViews
   );
   if (!("index" in views)) {
     views["index"] = {
+      __: "element",
       id: "index",
       title: "Landscape",
       description: null,
@@ -254,7 +277,7 @@ ${printDocs(docs)}`);
         const index = new LikeC4ModelGraph(model);
         const allViews = [];
         for (const view of values(model.views)) {
-          const result = computeView(view, index);
+          const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index);
           if (!result.isSuccess) {
             logWarnError(result.error);
             continue;
@@ -291,7 +314,7 @@ ${printDocs(docs)}`);
       const cache = this.services.WorkspaceCache;
       return cache.get(computedViewKey(viewId), () => {
         const index = new LikeC4ModelGraph(model);
-        const result = computeView(view, index);
+        const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index);
         if (!result.isSuccess) {
           logError(result.error);
           return null;

package/dist/model/model-locator.d.ts

@@ -14,8 +14,8 @@ export declare class LikeC4ModelLocator {
     locateRelation(relationId: c4.RelationID): Location | null;
     locateViewAst(viewId: c4.ViewID): {
         doc: import("../ast").ParsedLikeC4LangiumDocument;
-        view: import("../ast").ParsedAstElementView;
-        viewAst: ast.ElementView;
+        view: import("../ast").ParsedAstView;
+        viewAst: ast.LikeC4View;
     } | null;
     locateView(viewId: c4.ViewID): Location | null;
 }

package/dist/model/model-locator.js

@@ -55,21 +55,19 @@ export class LikeC4ModelLocator {
         if (targetNode2) {
           return {
             uri: doc.uri.toString(),
-            range: {
-              start: targetNode2.range.start,
-              end: targetNode2.range.end
-            }
+            range: targetNode2.range
           };
         }
       }
-      const targetNode = (node.kind ? findNodeForProperty(node.$cstNode, "kind") : findNodeForKeyword(node.$cstNode, "->")) ?? findNodeForProperty(node.$cstNode, "target");
-      return targetNode ? {
+      let targetNode = node.kind ? findNodeForProperty(node.$cstNode, "kind") : findNodeForKeyword(node.$cstNode, "->");
+      targetNode ??= findNodeForProperty(node.$cstNode, "target");
+      if (!targetNode) {
+        return null;
+      }
+      return {
         uri: doc.uri.toString(),
-        range: {
-          start: targetNode.range.start,
-          end: targetNode.range.end
-        }
-      } : null;
+        range: targetNode.range
+      };
     }
     return null;
   }
@@ -83,7 +81,7 @@ export class LikeC4ModelLocator {
         doc.parseResult.value,
         view.astPath
       );
-      if (ast.isElementView(viewAst)) {
+      if (ast.isLikeC4View(viewAst)) {
         return {
           doc,
           view,
@@ -105,15 +103,13 @@ export class LikeC4ModelLocator {
     } else if ("viewOf" in node) {
       targetNode = findNodeForProperty(node.$cstNode, "viewOf") ?? targetNode;
     }
+    targetNode ??= findNodeForKeyword(node.$cstNode, "view");
     if (!targetNode) {
       return null;
     }
     return {
       uri: res.doc.uri.toString(),
-      range: {
-        start: targetNode.range.start,
-        end: targetNode.range.start
-      }
+      range: targetNode.range
     };
   }
 }

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

@@ -19,7 +19,9 @@ export declare class LikeC4ModelParser {
     private parseCustomElementExpr;
     private parsePredicateExpr;
     private parseViewRule;
+    private parseDynamicStep;
     private parseElementView;
+    private parseDynamicElementView;
     protected resolveFqn(node: ast.Element | ast.ExtendElement): c4.Fqn;
     private getAstNodePath;
     private convertTags;

package/dist/model/model-parser.js

@@ -6,14 +6,14 @@ import {
   ast,
   checksFromDiagnostics,
   cleanParsedModel,
-  ElementViewOps,
   isFqnIndexedDocument,
   parseAstOpacityProperty,
   resolveRelationPoints,
   streamModel,
   toAutoLayout,
   toElementStyle,
-  toRelationshipStyleExcludeDefaults
+  toRelationshipStyleExcludeDefaults,
+  ViewOps
 } from "../ast.js";
 import { elementRef, getFqnElementRef } from "../elementRef.js";
 import { logError, logger, logWarnError } from "../logger.js";
@@ -50,13 +50,13 @@ export class LikeC4ModelParser {
   }
   parseLikeC4Document(_doc) {
     const doc = cleanParsedModel(_doc);
-    this.parseSpecification(doc);
-    this.parseModel(doc);
-    this.parseViews(doc);
+    const { isValid } = checksFromDiagnostics(doc);
+    this.parseSpecification(doc, isValid);
+    this.parseModel(doc, isValid);
+    this.parseViews(doc, isValid);
     return doc;
   }
-  parseSpecification(doc) {
-    const { isValid } = checksFromDiagnostics(doc);
+  parseSpecification(doc, isValid) {
     const { parseResult, c4Specification } = doc;
     const specifications = parseResult.value.specifications.filter(isValid);
     const element_specs = specifications.flatMap((s) => s.elements.filter(isValid));
@@ -84,8 +84,8 @@ export class LikeC4ModelParser {
       }
     }
   }
-  parseModel(doc) {
-    for (const el of streamModel(doc)) {
+  parseModel(doc, isValid) {
+    for (const el of streamModel(doc, isValid)) {
       if (ast.isElement(el)) {
         try {
           doc.c4Elements.push(this.parseElement(el));
@@ -159,13 +159,16 @@ export class LikeC4ModelParser {
       ...toRelationshipStyleExcludeDefaults(styleProp?.props)
     };
   }
-  parseViews(doc) {
-    const { isValid } = checksFromDiagnostics(doc);
-    const views = doc.parseResult.value.views.flatMap((v) => isValid(v) ? v.views.filter(isValid) : []);
+  parseViews(doc, isValid) {
+    const views = doc.parseResult.value.views.flatMap((v) => isValid(v) ? v.views : []);
     for (const view of views) {
       try {
-        const v = this.parseElementView(view);
-        doc.c4Views.push(v);
+        if (!isValid(view)) {
+          continue;
+        }
+        doc.c4Views.push(
+          ast.isElementView(view) ? this.parseElementView(view, isValid) : this.parseDynamicElementView(view, isValid)
+        );
       } catch (e) {
         logWarnError(e);
       }
@@ -307,11 +310,11 @@ export class LikeC4ModelParser {
     }
     nonexhaustive(astNode);
   }
-  parseViewRule(astRule) {
+  parseViewRule(astRule, isValid) {
     if (ast.isIncludePredicate(astRule) || ast.isExcludePredicate(astRule)) {
       const exprs = astRule.expressions.flatMap((n) => {
         try {
-          return this.parsePredicateExpr(n);
+          return isValid(n) ? this.parsePredicateExpr(n) : [];
         } catch (e) {
           logWarnError(e);
           return [];
@@ -335,7 +338,30 @@ export class LikeC4ModelParser {
     }
     nonexhaustive(astRule);
   }
-  parseElementView(astNode) {
+  parseDynamicStep(node) {
+    const sourceEl = elementRef(node.source);
+    if (!sourceEl) {
+      throw new Error("Invalid reference to source");
+    }
+    const targetEl = elementRef(node.target);
+    if (!targetEl) {
+      throw new Error("Invalid reference to target");
+    }
+    let source = this.resolveFqn(sourceEl);
+    let target = this.resolveFqn(targetEl);
+    if (node.isBackward) {
+      ;
+      [source, target] = [target, source];
+    }
+    const title = toSingleLine(node.title) ?? null;
+    return {
+      source,
+      target,
+      title,
+      isBackward: node.isBackward
+    };
+  }
+  parseElementView(astNode, isValid) {
     const body = astNode.body;
     invariant(body, "ElementView body is not defined");
     const astPath = this.getAstNodePath(astNode);
@@ -357,37 +383,121 @@ export class LikeC4ModelParser {
         viewOf ?? ""
       );
     }
-    const title = body.props.find((p) => p.key === "title")?.value;
-    const description = body.props.find((p) => p.key === "description")?.value;
+    const title = toSingleLine(body.props.find((p) => p.key === "title")?.value) ?? null;
+    const description = removeIndent(body.props.find((p) => p.key === "description")?.value) ?? null;
     const tags = this.convertTags(body);
     const links = body.props.filter(ast.isLinkProperty).map((p) => p.value);
-    const basic = {
+    const view = {
+      __: "element",
       id,
       astPath,
       ...viewOf && { viewOf },
-      ...title && { title },
-      ...description && { description },
-      ...tags && { tags },
-      ...isNonEmptyArray(links) && { links },
+      title,
+      description,
+      tags,
+      links: isNonEmptyArray(links) ? links : null,
       rules: body.rules.flatMap((n) => {
         try {
-          return this.parseViewRule(n);
+          return isValid(n) ? this.parseViewRule(n, isValid) : [];
         } catch (e) {
           logWarnError(e);
           return [];
         }
       })
     };
-    ElementViewOps.writeId(astNode, basic.id);
+    ViewOps.writeId(astNode, view.id);
     if ("extends" in astNode) {
       const extendsView = astNode.extends.view.ref;
       invariant(extendsView?.name, "view extends is not resolved: " + astNode.$cstNode?.text);
-      return {
-        ...basic,
+      return Object.assign(view, {
         extends: extendsView.name
-      };
+      });
     }
-    return basic;
+    return view;
+  }
+  parseDynamicElementView(astNode, isValid) {
+    const body = astNode.body;
+    invariant(body, "ElementView body is not defined");
+    const props = body.props.filter(isValid);
+    const astPath = this.getAstNodePath(astNode);
+    let id = astNode.name;
+    if (!id) {
+      id = "dynamic_" + stringHash(
+        getDocument(astNode).uri.toString(),
+        astPath
+      );
+    }
+    const title = toSingleLine(props.find((p) => p.key === "title")?.value) ?? null;
+    const description = removeIndent(props.find((p) => p.key === "description")?.value) ?? null;
+    const tags = this.convertTags(body);
+    const links = props.filter(ast.isLinkProperty).map((p) => p.value);
+    ViewOps.writeId(astNode, id);
+    return {
+      __: "dynamic",
+      id,
+      astPath,
+      title,
+      description,
+      tags,
+      links: isNonEmptyArray(links) ? links : null,
+      rules: body.rules.reduce((acc, n) => {
+        if (!isValid(n)) {
+          return acc;
+        }
+        try {
+          if (ast.isDynamicViewRulePredicate(n)) {
+            const include = [];
+            for (const expr of n.expressions) {
+              if (ast.isElementExpr(expr)) {
+                include.push(this.parseElementExpr(expr));
+                continue;
+              }
+              if (ast.isCustomElementExpr(expr)) {
+                include.push(this.parseCustomElementExpr(expr));
+                continue;
+              }
+            }
+            if (include.length > 0) {
+              acc.push({ include });
+            }
+            return acc;
+          }
+          if (ast.isViewRuleStyle(n)) {
+            const styleProps = toElementStyle(n.styleprops);
+            const targets = n.targets.map((n2) => this.parseElementExpr(n2));
+            if (targets.length > 0) {
+              acc.push({
+                targets,
+                style: {
+                  ...styleProps
+                }
+              });
+            }
+            return acc;
+          }
+          if (ast.isViewRuleAutoLayout(n)) {
+            acc.push({
+              autoLayout: toAutoLayout(n.direction)
+            });
+            return acc;
+          }
+          nonexhaustive(n);
+        } catch (e) {
+          logWarnError(e);
+          return acc;
+        }
+      }, []),
+      steps: body.steps.reduce((acc, n) => {
+        try {
+          if (isValid(n)) {
+            acc.push(this.parseDynamicStep(n));
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+        return acc;
+      }, [])
+    };
   }
   resolveFqn(node) {
     if (ast.isExtendElement(node)) {

package/dist/model-change/ModelChanges.d.ts

@@ -1,4 +1,4 @@
-import { Location, TextEdit } from 'vscode-languageserver-protocol';
+import { Location, Range, TextEdit } from 'vscode-languageserver-protocol';
 import { type ParsedLikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
 import type { ChangeViewRequestParams } from '../protocol';
@@ -9,6 +9,7 @@ export declare class LikeC4ModelChanges {
     applyChange(changeView: ChangeViewRequestParams): Promise<Location | null>;
     protected convertToTextEdit({ viewId, changes }: ChangeViewRequestParams): {
         doc: ParsedLikeC4LangiumDocument;
+        ranges: Range[];
         edits: TextEdit[];
     };
 }

package/dist/model-change/ModelChanges.js

@@ -1,23 +1,31 @@
 import { invariant, nonexhaustive } from "@likec4/core";
-import { Range, TextDocumentEdit } from "vscode-languageserver-protocol";
+import { Range } from "vscode-languageserver-protocol";
+import { changeElementStyle } from "./changeElementStyle.js";
 import { changeViewLayout } from "./changeViewLayout.js";
-import { changeViewStyle } from "./changeViewStyle.js";
-function unionRangeOfAllEdits(edits) {
-  let start = Number.MAX_SAFE_INTEGER;
-  let end = Number.MIN_SAFE_INTEGER;
-  let startCharacter = 0;
-  let endCharacter = 0;
-  for (const { range } of edits) {
-    start = Math.min(start, range.start.line);
-    if (start === range.start.line) {
-      startCharacter = range.start.character;
+function unionRangeOfAllEdits(ranges) {
+  let startLine = Number.MAX_SAFE_INTEGER;
+  let endLine = Number.MIN_SAFE_INTEGER;
+  let startCharacter = Number.MAX_SAFE_INTEGER;
+  let endCharacter = Number.MIN_SAFE_INTEGER;
+  for (const { start, end } of ranges) {
+    if (start.line <= startLine) {
+      if (startLine == start.line) {
+        startCharacter = Math.min(start.character, startCharacter);
+      } else {
+        startLine = start.line;
+        startCharacter = start.character;
+      }
     }
-    end = Math.max(end, range.end.line);
-    if (end === range.end.line) {
-      endCharacter = range.end.character;
+    if (endLine <= end.line) {
+      if (endLine == end.line) {
+        endCharacter = Math.max(end.character, endCharacter);
+      } else {
+        endLine = end.line;
+        endCharacter = end.character;
+      }
     }
   }
-  return Range.create(start, startCharacter, end, endCharacter);
+  return Range.create(startLine, startCharacter, endLine, endCharacter);
 }
 export class LikeC4ModelChanges {
   constructor(services) {
@@ -41,9 +49,9 @@ export class LikeC4ModelChanges {
       const applyResult = await lspConnection.workspace.applyEdit({
         label: `LikeC4 - change view ${changeView.viewId}`,
         edit: {
-          documentChanges: [
-            TextDocumentEdit.create(textDocument, edits)
-          ]
+          changes: {
+            [textDocument.uri]: edits
+          }
         }
       });
       if (!applyResult.applied) {
@@ -52,7 +60,7 @@ export class LikeC4ModelChanges {
       }
       result = {
         uri: textDocument.uri,
-        range: unionRangeOfAllEdits(edits)
+        range: unionRangeOfAllEdits(edits.map((edit) => edit.range))
       };
     });
     return result;
@@ -62,32 +70,27 @@ export class LikeC4ModelChanges {
     if (!lookup) {
       throw new Error(`View not found: ${viewId}`);
     }
+    const ranges = [];
     const edits = [];
     for (const change of changes) {
       switch (change.op) {
-        case "change-color": {
-          edits.push(...changeViewStyle(this.services, {
-            ...lookup,
-            targets: change.targets,
-            key: "color",
-            value: change.color
-          }));
-          break;
-        }
-        case "change-shape": {
-          edits.push(...changeViewStyle(this.services, {
+        case "change-element-style": {
+          const { edits: elementEdits, modifiedRange } = changeElementStyle(this.services, {
             ...lookup,
             targets: change.targets,
-            key: "shape",
-            value: change.shape
-          }));
+            style: change.style
+          });
+          ranges.push(modifiedRange);
+          edits.push(...elementEdits);
           break;
         }
         case "change-autolayout": {
-          edits.push(...changeViewLayout(this.services, {
+          const edit = changeViewLayout(this.services, {
             ...lookup,
             layout: change.layout
-          }));
+          });
+          edits.push(edit);
+          ranges.push(edit.range);
           break;
         }
         default:
@@ -96,6 +99,7 @@ export class LikeC4ModelChanges {
     }
     return {
       doc: lookup.doc,
+      ranges,
       edits
     };
   }