@likec4/language-server 1.1.1 → 1.2.0

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,16 +50,16 @@ 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: isValid2 } = checksFromDiagnostics(doc);
+  parseSpecification(doc, isValid) {
     const { parseResult, c4Specification } = doc;
-    const specifications = parseResult.value.specifications.filter(isValid2);
-    const element_specs = specifications.flatMap((s) => s.elements.filter(isValid2));
+    const specifications = parseResult.value.specifications.filter(isValid);
+    const element_specs = specifications.flatMap((s) => s.elements.filter(isValid));
     for (const { kind, style } of element_specs) {
       try {
         const kindName = kind.name;
@@ -71,7 +71,7 @@ export class LikeC4ModelParser {
         logWarnError(e);
       }
     }
-    const relations_specs = specifications.flatMap((s) => s.relationships.filter(isValid2));
+    const relations_specs = specifications.flatMap((s) => s.relationships.filter(isValid));
     for (const { kind, props } of relations_specs) {
       try {
         const kindName = kind.name;
@@ -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: isValid2 } = checksFromDiagnostics(doc);
-    const views = doc.parseResult.value.views.flatMap((v) => isValid2(v) ? v.views.filter(isValid2) : []);
+  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, isValid2);
-        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, isValid2) {
+  parseViewRule(astRule, isValid) {
     if (ast.isIncludePredicate(astRule) || ast.isExcludePredicate(astRule)) {
       const exprs = astRule.expressions.flatMap((n) => {
         try {
-          return isValid2(n) ? 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, isValid2) {
+  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 = toSingleLine(body.props.find((p) => p.key === "title")?.value);
-    const description = removeIndent(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 isValid2(n) ? this.parseViewRule(n, isValid2) : [];
+          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 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
+      );
     }
-    return basic;
+    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

@@ -2,30 +2,30 @@ import { invariant, nonexhaustive } from "@likec4/core";
 import { Range } from "vscode-languageserver-protocol";
 import { changeElementStyle } from "./changeElementStyle.js";
 import { changeViewLayout } from "./changeViewLayout.js";
-function unionRangeOfAllEdits(edits) {
-  let start = Number.MAX_SAFE_INTEGER;
-  let end = Number.MIN_SAFE_INTEGER;
+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 { range } of edits) {
-    if (range.start.line <= start) {
-      if (start == range.start.line) {
-        startCharacter = Math.min(range.start.character, startCharacter);
+  for (const { start, end } of ranges) {
+    if (start.line <= startLine) {
+      if (startLine == start.line) {
+        startCharacter = Math.min(start.character, startCharacter);
       } else {
-        start = range.start.line;
-        startCharacter = range.start.character;
+        startLine = start.line;
+        startCharacter = start.character;
       }
     }
-    if (end <= range.end.line) {
-      if (end == range.end.line) {
-        endCharacter = Math.max(range.end.character, endCharacter);
+    if (endLine <= end.line) {
+      if (endLine == end.line) {
+        endCharacter = Math.max(end.character, endCharacter);
       } else {
-        end = range.end.line;
-        endCharacter = range.end.character;
+        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) {
@@ -60,7 +60,7 @@ export class LikeC4ModelChanges {
       }
       result = {
         uri: textDocument.uri,
-        range: unionRangeOfAllEdits(edits)
+        range: unionRangeOfAllEdits(edits.map((edit) => edit.range))
       };
     });
     return result;
@@ -70,22 +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-element-style": {
-          edits.push(...changeElementStyle(this.services, {
+          const { edits: elementEdits, modifiedRange } = changeElementStyle(this.services, {
             ...lookup,
             targets: change.targets,
             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:
@@ -94,6 +99,7 @@ export class LikeC4ModelChanges {
     }
     return {
       doc: lookup.doc,
+      ranges,
       edits
     };
   }

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

@@ -1,15 +1,18 @@
 import { type Fqn, type NonEmptyArray } from '@likec4/core';
-import { TextEdit } from 'vscode-languageserver-protocol';
-import { ast, type ParsedAstElementView, type ParsedLikeC4LangiumDocument } from '../ast';
+import { type Range, TextEdit } from 'vscode-languageserver-protocol';
+import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
 import type { ChangeView } from '../protocol';
 type ChangeElementStyleArg = {
-    view: ParsedAstElementView;
+    view: ParsedAstView;
     doc: ParsedLikeC4LangiumDocument;
-    viewAst: ast.ElementView;
+    viewAst: ast.LikeC4View;
     targets: NonEmptyArray<Fqn>;
     style: ChangeView.ChangeElementStyle['style'];
 };
-export declare function changeElementStyle(services: LikeC4Services, { view, viewAst, targets, style }: ChangeElementStyleArg): TextEdit[];
+export declare function changeElementStyle(services: LikeC4Services, { view, viewAst, targets, style }: ChangeElementStyleArg): {
+    modifiedRange: Range;
+    edits: TextEdit[];
+};
 export {};
 //# sourceMappingURL=changeElementStyle.d.ts.map

package/dist/model-change/changeElementStyle.js

@@ -1,6 +1,6 @@
 import { invariant, isAncestor, nonNullable } from "@likec4/core";
 import { GrammarUtils } from "langium";
-import { entries, findLast, isNumber, last } from "remeda";
+import { entries, filter, findLast, last } from "remeda";
 import { TextEdit } from "vscode-languageserver-protocol";
 import { ast } from "../ast.js";
 const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
@@ -8,9 +8,11 @@ const asViewStyleRule = (target, style, indent = 0) => {
   const indentStr = indent > 0 ? " ".repeat(indent) : "";
   return [
     indentStr + `style ${target} {`,
-    ...entries(style).map(([key, value]) => indentStr + `  ${key} ${value}`),
+    ...entries.strict(style).map(
+      ([key, value]) => indentStr + `  ${key} ${key === "opacity" ? value.toString() + "%" : value}`
+    ),
     indentStr + `}`
-  ].join("\n");
+  ];
 };
 const isMatchingViewRule = (fqn, index) => (rule) => {
   if (!ast.isViewRuleStyle(rule)) {
@@ -32,12 +34,12 @@ export function changeElementStyle(services, {
 }) {
   const viewCstNode = viewAst.$cstNode;
   invariant(viewCstNode, "viewCstNode");
-  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? last(viewAst.body.props)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.start;
+  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.end;
   invariant(insertPos, "insertPos is not defined");
   const indent = viewCstNode.range.start.character + 2;
   const fqnIndex = services.likec4.FqnIndex;
-  const styleRules = viewAst.body.rules.filter(ast.isViewRuleStyle);
-  const viewOf = view.viewOf;
+  const styleRules = filter(viewAst.body.rules, ast.isViewRuleStyle);
+  const viewOf = view.__ === "element" ? view.viewOf : null;
   const existing = [];
   const insert = [];
   targets.forEach((target) => {
@@ -58,38 +60,33 @@ export function changeElementStyle(services, {
       if (range.start.line == modifiedRange.start.line) {
         modifiedRange.start.character = Math.min(range.start.character, modifiedRange.start.character);
       } else {
-        modifiedRange.start.line = range.start.line;
-        modifiedRange.start.character = range.start.character;
+        modifiedRange.start = range.start;
       }
     }
     if (range.end.line >= modifiedRange.end.line) {
       if (range.end.line == modifiedRange.end.line) {
         modifiedRange.end.character = Math.max(range.end.character, modifiedRange.end.character);
       } else {
-        modifiedRange.end.line = range.end.line;
-        modifiedRange.end.character = range.end.character;
+        modifiedRange.end = range.end;
       }
     }
   };
   const edits = [];
   if (insert.length > 0) {
-    const linesToInsert = [
-      "",
-      ...insert.map(({ fqn }) => asViewStyleRule(fqn, style, indent))
-    ];
+    const linesToInsert = insert.flatMap(({ fqn }) => asViewStyleRule(fqn, style, indent));
     edits.push(
       TextEdit.insert(
         insertPos,
-        linesToInsert.join("\n")
+        "\n" + linesToInsert.join("\n")
       )
     );
     modifiedRange.start = {
       line: insertPos.line + 1,
-      character: indent
+      character: indent + 1
     };
     modifiedRange.end = {
       line: insertPos.line + linesToInsert.length,
-      character: indent + (last(linesToInsert)?.length ?? 0) + 1
+      character: last(linesToInsert)?.length ?? 0
     };
   }
   if (existing.length > 0) {
@@ -97,7 +94,7 @@ export function changeElementStyle(services, {
       const ruleCstNode = rule.$cstNode;
       invariant(ruleCstNode, "RuleCstNode not found");
       for (const [key, _value] of entries.strict(style)) {
-        const value = isNumber(_value) ? _value.toString() + "%" : _value;
+        const value = key === "opacity" ? _value.toString() + "%" : _value;
         const ruleProp = rule.styleprops.find((p) => p.key === key);
         if (ruleProp && ruleProp.$cstNode) {
           const { range: { start, end } } = nonNullable(
@@ -107,8 +104,8 @@ export function changeElementStyle(services, {
           includeRange({
             start,
             end: {
-              line: end.line,
-              character: start.character + value.length + 1
+              line: start.line,
+              character: start.character + value.length
             }
           });
           edits.push(TextEdit.replace({ start, end }, value));
@@ -127,15 +124,18 @@ export function changeElementStyle(services, {
         includeRange({
           start: {
             line: insertPos2.line + 1,
-            character: indentStr.length + 1
+            character: indentStr.length
           },
           end: {
             line: insertPos2.line + 1,
-            character: insertKeyValue.length + 1
+            character: insertKeyValue.length
           }
         });
       }
     }
   }
-  return edits;
+  return {
+    modifiedRange,
+    edits
+  };
 }

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

@@ -1,13 +1,13 @@
 import { type AutoLayoutDirection } from '@likec4/core';
 import { TextEdit } from 'vscode-languageserver-protocol';
-import { ast, type ParsedAstElementView, type ParsedLikeC4LangiumDocument } from '../ast';
+import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
 type ChangeViewLayoutArg = {
-    view: ParsedAstElementView;
+    view: ParsedAstView;
     doc: ParsedLikeC4LangiumDocument;
-    viewAst: ast.ElementView;
+    viewAst: ast.LikeC4View;
     layout: AutoLayoutDirection;
 };
-export declare function changeViewLayout(services: LikeC4Services, { view, viewAst, layout }: ChangeViewLayoutArg): TextEdit[];
+export declare function changeViewLayout(services: LikeC4Services, { viewAst, layout }: ChangeViewLayoutArg): TextEdit;
 export {};
 //# sourceMappingURL=changeViewLayout.d.ts.map

package/dist/model-change/changeViewLayout.js

@@ -5,7 +5,6 @@ import { TextEdit } from "vscode-languageserver-protocol";
 import { ast, toAstViewLayoutDirection } from "../ast.js";
 const { findNodeForProperty } = GrammarUtils;
 export function changeViewLayout(services, {
-  view,
   viewAst,
   layout
 }) {
@@ -16,15 +15,15 @@ export function changeViewLayout(services, {
   if (existingRule && existingRule.$cstNode) {
     const directionCstNode = findNodeForProperty(existingRule.$cstNode, "direction");
     if (directionCstNode) {
-      return [TextEdit.replace(directionCstNode.range, newlayout)];
+      return TextEdit.replace(directionCstNode.range, newlayout);
     }
-    return [TextEdit.replace(existingRule.$cstNode.range, `autoLayout ${newlayout}`)];
+    return TextEdit.replace(existingRule.$cstNode.range, `autoLayout ${newlayout}`);
   }
-  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? last(viewAst.body.props)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.start;
+  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.end;
   invariant(insertPos, "insertPos is not defined");
   const indent = " ".repeat(2 + viewCstNode.range.start.character);
   const insert = `
 
 ${indent}autoLayout ${newlayout}`;
-  return [TextEdit.insert(insertPos, insert)];
+  return TextEdit.insert(insertPos, insert);
 }