@likec4/language-server 1.40.0 → 1.42.0

package/dist/model/parser/SpecificationParser.mjs

@@ -1,9 +1,12 @@
 import * as c4 from "@likec4/core";
+import { exact } from "@likec4/core";
 import { nonNullable } from "@likec4/core/utils";
+import { loggable } from "@likec4/log";
 import { filter, isNonNullish, isNullish, isTruthy, mapToObj, omitBy, pipe } from "remeda";
-import { ast, parseMarkdownAsString, toRelationshipStyleExcludeDefaults } from "../../ast.mjs";
-import { logger, logWarnError } from "../../logger.mjs";
+import { ast, parseMarkdownAsString, toRelationshipStyle } from "../../ast.mjs";
+import { serverLogger } from "../../logger.mjs";
 import { removeIndent } from "./Base.mjs";
+const logger = serverLogger.getChild("SpecificationParser");
 export function SpecificationParser(B) {
   return class SpecificationParser extends B {
     parseSpecification() {
@@ -20,14 +23,14 @@ export function SpecificationParser(B) {
         try {
           Object.assign(c4Specification.elements, this.parseElementSpecificationNode(elementSpec));
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       for (const deploymentNodeSpec of specifications.flatMap((s) => s.deploymentNodes.filter(isValid))) {
         try {
           Object.assign(c4Specification.deployments, this.parseElementSpecificationNode(deploymentNodeSpec));
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       const relations_specs = specifications.flatMap((s) => s.relationships.filter(this.isValid));
@@ -49,10 +52,10 @@ export function SpecificationParser(B) {
           );
           c4Specification.relationships[kindName] = {
             ...bodyProps,
-            ...toRelationshipStyleExcludeDefaults(props, this.isValid)
+            ...toRelationshipStyle(props.filter(ast.isRelationshipStyleProperty), this.isValid)
           };
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       const tags_specs = specifications.flatMap((s) => s.tags.filter(this.isValid));
@@ -68,7 +71,7 @@ export function SpecificationParser(B) {
             };
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       const colors_specs = specifications.flatMap((s) => s.colors.filter(isValid));
@@ -83,7 +86,7 @@ export function SpecificationParser(B) {
             color: nonNullable(this.parseColorLiteral(color), `Color "${colorName}" is not valid: ${color}`)
           };
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
     }
@@ -101,25 +104,16 @@ export function SpecificationParser(B) {
         filter((p) => this.isValid(p)),
         mapToObj((p) => [p.key, p.value])
       );
-      const { title, description, technology } = this.parseTitleDescriptionTechnology(
-        {
-          title: void 0,
-          description: void 0,
-          technology: void 0
-        },
-        bodyProps
-      );
+      const baseProps = this.parseBaseProps(bodyProps);
       const notation = removeIndent(parseMarkdownAsString(bodyProps.notation));
       return {
-        [kindName]: {
-          ...title && { title },
-          ...description && { description },
-          ...technology && { technology },
-          ...notation && { notation },
-          ...tags && { tags },
+        [kindName]: exact({
+          ...baseProps,
+          notation,
+          tags: tags ?? void 0,
           ...links && c4.isNonEmptyArray(links) && { links },
           style
-        }
+        })
       };
     }
   };

package/dist/model/parser/ValueConverter.mjs

@@ -3,7 +3,7 @@ export class LikeC4ValueConverter extends DefaultValueConverter {
   runConverter(rule, input, cstNode) {
     if (rule.name === "MarkdownString") {
       if (input.startsWith('"""') && input.endsWith('"""') || input.startsWith(`'''`) && input.endsWith(`'''`)) {
-        input = input.slice(3, -3);
+        input = input.slice(2, -2);
       }
       return ValueConverter.convertString(input);
     }

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

@@ -1,4 +1,5 @@
 import * as c4 from '@likec4/core';
+import type { Except, Writable } from 'type-fest';
 import { type ParsedAstDynamicView, type ParsedAstElementView, ast } from '../../ast';
 import type { WithDeploymentView } from './DeploymentViewParser';
 import type { WithPredicates } from './PredicatesParser';
@@ -18,8 +19,16 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: ViewRuleStyleOrGlobalRef[]): ParsedAstDynamicView;
         parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
-        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps;
-        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep;
+        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicStepsParallel;
+        /**
+         * @returns non-empty array in case of step chain A -> B -> C
+         */
+        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicStep | c4.DynamicStepsSeries;
+        recursiveParseDynamicStepChain(node: ast.DynamicStepChain, callstack?: Array<[source: c4.Fqn, target: c4.Fqn]>): c4.DynamicStep[];
+        parseDynamicStepSingle(node: ast.DynamicStepSingle): c4.DynamicStep;
+        parseAbstractDynamicStep(astnode: ast.AbstractDynamicStep): Writable<Except<c4.DynamicStep, "source", {
+            requireExactProps: true;
+        }>>;
         parsePredicate(astNode: ast.ExpressionV2): c4.ModelExpression;
         parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelFqnExpr.Any;
         parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelFqnExpr.OrWhere;
@@ -42,6 +51,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
         parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
         parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): Except<c4.RelationExpr.Custom["customRelation"], "expr">;
         parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
         parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
         parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
@@ -70,16 +80,19 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        parseBaseProps(props: {
             title?: ast.MarkdownOrString | undefined;
+            summary?: ast.MarkdownOrString | undefined;
             description?: ast.MarkdownOrString | undefined;
             technology?: ast.MarkdownOrString | undefined;
+        }, override?: {
+            title?: string | undefined;
+            summary?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
         }): {
             title?: string;
+            summary?: c4.MarkdownOrString;
             description?: c4.MarkdownOrString;
             technology?: string;
         };

package/dist/model/parser/ViewsParser.mjs

@@ -1,6 +1,7 @@
 import * as c4 from "@likec4/core";
 import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { filter, find, isArray, isDefined, isEmpty, isNonNullish, isTruthy, mapToObj, pipe } from "remeda";
+import { loggable } from "@likec4/log";
+import { filter, find, isDefined, isEmpty, isNonNullish, isNumber, isTruthy, last, mapToObj, pipe } from "remeda";
 import {
   ast,
   parseMarkdownAsString,
@@ -8,11 +9,12 @@ import {
   toColor,
   ViewOps
 } from "../../ast.mjs";
-import { logger, logWarnError } from "../../logger.mjs";
+import { logger as mainLogger } from "../../logger.mjs";
 import { stringHash } from "../../utils/index.mjs";
 import { elementRef } from "../../utils/elementRef.mjs";
 import { parseViewManualLayout } from "../../view-utils/manual-layout.mjs";
 import { removeIndent, toSingleLine } from "./Base.mjs";
+const logger = mainLogger.getChild("ViewsParser");
 export function ViewsParser(B) {
   return class ViewsParser extends B {
     parseViews() {
@@ -22,7 +24,7 @@ export function ViewsParser(B) {
           try {
             return isValid(s) ? this.parseViewRuleStyleOrGlobalRef(s) : [];
           } catch (e) {
-            logWarnError(e);
+            logger.warn(loggable(e));
             return [];
           }
         });
@@ -50,7 +52,7 @@ export function ViewsParser(B) {
               view2.title = folder + " / " + (view2.title || view2.id);
             }
           } catch (e) {
-            logWarnError(e);
+            logger.warn(loggable(e));
           }
         }
       }
@@ -77,8 +79,7 @@ export function ViewsParser(B) {
           viewOf ?? ""
         );
       }
-      const { title = null, description = null } = this.parseTitleDescriptionTechnology(
-        {},
+      const { title = null, description = null } = this.parseBaseProps(
         pipe(
           body.props,
           filter((p) => this.isValid(p)),
@@ -103,7 +104,7 @@ export function ViewsParser(B) {
             try {
               return this.isValid(n) ? this.parseElementViewRule(n) : [];
             } catch (e) {
-              logWarnError(e);
+              logger.warn(loggable(e));
               return [];
             }
           })
@@ -150,7 +151,7 @@ export function ViewsParser(B) {
             exprs.unshift(expr);
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
         if (!prev) {
           break;
@@ -190,7 +191,7 @@ export function ViewsParser(B) {
           }
           nonexhaustive(rule);
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       return {
@@ -229,8 +230,7 @@ export function ViewsParser(B) {
           astPath
         );
       }
-      const { title = null, description = null } = this.parseTitleDescriptionTechnology(
-        {},
+      const { title = null, description = null } = this.parseBaseProps(
         pipe(
           props,
           filter(ast.isViewStringProperty),
@@ -257,7 +257,7 @@ export function ViewsParser(B) {
             try {
               return isValid(n) ? this.parseDynamicViewRule(n) : [];
             } catch (e) {
-              logWarnError(e);
+              logger.warn(loggable(e));
               return [];
             }
           }, [])
@@ -272,7 +272,7 @@ export function ViewsParser(B) {
               }
             }
           } catch (e) {
-            logWarnError(e);
+            logger.warn(loggable(e));
           }
           return acc;
         }, []),
@@ -306,46 +306,113 @@ export function ViewsParser(B) {
             }
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
         iter = iter.prev;
       }
       return { include };
     }
     parseDynamicParallelSteps(node) {
+      const parallelId = pathInsideDynamicView(node);
+      const __parallel = node.steps.map((step) => this.parseDynamicStep(step));
+      invariant(isNonEmptyArray(__parallel), "Dynamic parallel steps must have at least one step");
       return {
-        __parallel: node.steps.map((step) => this.parseDynamicStep(step))
+        parallelId,
+        __parallel
       };
     }
+    /**
+     * @returns non-empty array in case of step chain A -> B -> C
+     */
     parseDynamicStep(node) {
+      if (ast.isDynamicStepSingle(node)) {
+        invariant(this.isValid(node));
+        return this.parseDynamicStepSingle(node);
+      }
+      const __series = this.recursiveParseDynamicStepChain(node);
+      invariant(isNonEmptyArray(__series), "Dynamic step chain must have at least one step");
+      return {
+        seriesId: pathInsideDynamicView(node),
+        __series
+      };
+    }
+    recursiveParseDynamicStepChain(node, callstack) {
+      if (ast.isDynamicStepSingle(node.source)) {
+        if (!this.isValid(node.source)) {
+          return [];
+        }
+        const previous2 = this.parseDynamicStepSingle(node.source);
+        if (previous2.isBackward) {
+          return [];
+        }
+        const thisStep2 = {
+          ...this.parseAbstractDynamicStep(node),
+          source: previous2.target
+        };
+        if (thisStep2.target === previous2.source) {
+          thisStep2.isBackward = true;
+        } else if (callstack) {
+          callstack.push([previous2.source, previous2.target]);
+          callstack.push([thisStep2.source, thisStep2.target]);
+        }
+        return [previous2, thisStep2];
+      }
+      callstack ??= [];
+      const allprevious = this.recursiveParseDynamicStepChain(node.source, callstack);
+      if (!isNonEmptyArray(allprevious) || !this.isValid(node)) {
+        return [];
+      }
+      const previous = last(allprevious);
+      const thisStep = {
+        ...this.parseAbstractDynamicStep(node),
+        source: previous.target
+      };
+      const index = callstack.findIndex(([source, target]) => source === thisStep.target && target === thisStep.source);
+      if (index !== -1) {
+        thisStep.isBackward = true;
+        callstack.splice(index, callstack.length - index);
+      } else {
+        callstack.push([thisStep.source, thisStep.target]);
+      }
+      return [...allprevious, thisStep];
+    }
+    parseDynamicStepSingle(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);
-      const title = removeIndent(node.title) ?? null;
-      let step = {
-        source,
-        target,
-        title
+      let baseStep = {
+        ...this.parseAbstractDynamicStep(node),
+        source: this.resolveFqn(sourceEl)
       };
       if (node.isBackward) {
-        step = {
-          source: target,
-          target: source,
-          title,
+        baseStep = {
+          ...baseStep,
+          source: baseStep.target,
+          target: baseStep.source,
           isBackward: true
         };
       }
-      if (!isArray(node.custom?.props)) {
-        return step;
+      return baseStep;
+    }
+    parseAbstractDynamicStep(astnode) {
+      const targetEl = elementRef(astnode.target);
+      if (!targetEl) {
+        throw new Error("Invalid reference to target");
+      }
+      const step = {
+        target: this.resolveFqn(targetEl),
+        astPath: pathInsideDynamicView(astnode)
+      };
+      const title = removeIndent(astnode.title);
+      if (title) {
+        step.title = title;
+      }
+      const kind = astnode.kind?.ref?.name ?? astnode.dotKind?.kind.ref?.name;
+      if (kind) {
+        step.kind = kind;
       }
-      for (const prop of node.custom.props) {
+      for (const prop of astnode.custom?.props ?? []) {
         try {
           switch (true) {
             case ast.isRelationNavigateToProperty(prop): {
@@ -358,7 +425,14 @@ export function ViewsParser(B) {
             case ast.isRelationStringProperty(prop):
             case ast.isNotationProperty(prop): {
               if (isDefined(prop.value)) {
-                step[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) ?? "";
+                if (prop.key === "description") {
+                  const value = removeIndent(prop.value);
+                  if (value) {
+                    step.description = value;
+                  }
+                } else {
+                  step[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) ?? "";
+                }
               }
               break;
             }
@@ -391,10 +465,26 @@ export function ViewsParser(B) {
               nonexhaustive(prop);
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       return step;
     }
   };
 }
+function pathInsideDynamicView(_node) {
+  let node = _node;
+  let path = [];
+  while (!ast.isDynamicViewBody(node)) {
+    if (isNumber(node.$containerIndex)) {
+      path.unshift(
+        `@${node.$containerIndex}`
+      );
+    }
+    path.unshift(
+      `/${node.$containerProperty ?? "__invalid__"}`
+    );
+    node = node.$container;
+  }
+  return path.join("");
+}

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

@@ -1,5 +1,5 @@
 import { Location, Range, TextEdit } from 'vscode-languageserver-types';
-import { type ParsedLikeC4LangiumDocument } from '../ast';
+import type { ParsedLikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
 import type { ChangeView } from '../protocol';
 export declare class LikeC4ModelChanges {

package/dist/module.mjs

@@ -1,3 +1,4 @@
+import { onNextTick } from "@likec4/core/utils";
 import { GraphvizWasmAdapter, QueueGraphvizLayoter } from "@likec4/layouts";
 import {
   DocumentState,
@@ -144,9 +145,9 @@ export function createLanguageServices(context, module, module2, module3) {
   shared.ServiceRegistry.register(likec4);
   registerValidationChecks(likec4);
   if (!context.connection) {
-    shared.workspace.ConfigurationProvider.initialized({});
+    void shared.workspace.ConfigurationProvider.initialized({});
   } else {
-    likec4.Rpc.init();
+    onNextTick(() => likec4.Rpc.init());
   }
   return { shared, likec4 };
 }

package/dist/protocol.d.ts

@@ -176,18 +176,42 @@ export declare namespace BuildDocuments {
  * If LSP has multiple projects, the projectId is required.
  */
 export declare namespace Locate {
-    type Params = {
+    type Params = 
+    /**
+     * Locate an element by its fqn
+     */
+    {
         element: Fqn;
         projectId?: string | undefined;
         property?: string;
-    } | {
+    }
+    /**
+     * Locate a relation by its id
+     */
+     | {
         projectId?: string | undefined;
         relation: RelationId;
-    } | {
+    }
+    /**
+     * Locate a deployment by its fqn
+     */
+     | {
         deployment: DeploymentFqn;
         projectId?: string | undefined;
         property?: string;
-    } | {
+    }
+    /**
+     * Locate a step in a dynamic view by its astPath
+     */
+     | {
+        view: ViewId;
+        astPath: string;
+        projectId?: string | undefined;
+    }
+    /**
+     * Locate a view by its id
+     */
+     | {
         view: ViewId;
         projectId?: string | undefined;
     };

package/dist/references/scope-computation.mjs

@@ -27,8 +27,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         views,
         globals,
         likec4lib,
-        deployments,
-        imports
+        deployments
       } = document.parseResult.value;
       this.exportLibrary(likec4lib, docExports, document);
       this.exportSpecification(specifications, docExports, document);
@@ -205,7 +204,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           let imported = imports;
           while (imported) {
             descendants.push(
-              this.descriptions.createDescription(imported, imported.imported.$refText, document)
+              this.descriptions.createDescription(imported, imported.imported.$refText)
             );
             imported = imported.prev;
           }

package/dist/references/scope-provider.d.ts

@@ -1,6 +1,6 @@
 import { type ProjectId } from '@likec4/core';
 import { type AstNodeDescription, type ReferenceInfo, type Scope, type Stream, DefaultScopeProvider } from 'langium';
-import { type AstNodeDescriptionWithFqn, ast } from '../ast';
+import { ast } from '../ast';
 import type { DeploymentsIndex, FqnIndex } from '../model';
 import type { LikeC4Services } from '../module';
 import type { IndexManager } from '../workspace';
@@ -10,7 +10,7 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     protected readonly indexManager: IndexManager;
     constructor(services: LikeC4Services);
     getScope(context: ReferenceInfo): Scope;
-    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<Stream<AstNodeDescriptionWithFqn>, void, any>;
+    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<Stream<import("../ast").AstNodeDescriptionWithFqn>, void, any>;
     protected genScopeExtendElement({ element }: ast.ExtendElement): Generator<AstNodeDescription>;
     protected genScopeElementView({ viewOf, extends: ext }: ast.ElementView): Generator<AstNodeDescription>;
     protected getScopeForStrictFqnRef(projectId: ProjectId, container: ast.StrictFqnRef, context: ReferenceInfo): any;

package/dist/references/scope-provider.mjs

@@ -2,12 +2,10 @@ import { nonexhaustive } from "@likec4/core";
 import {
   AstUtils,
   DefaultScopeProvider,
-  DONE_RESULT,
   EMPTY_SCOPE,
   EMPTY_STREAM,
   MapScope,
   stream,
-  StreamImpl,
   StreamScope
 } from "langium";
 import { ast, isFqnRefInsideGlobals, isFqnRefInsideModel } from "../ast.mjs";
@@ -81,6 +79,14 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
   *genScopeExtendElement({ element }) {
     if (element.el.$nodeDescription) {
       yield element.el.$nodeDescription;
+      yield {
+        ...element.el.$nodeDescription,
+        name: "this"
+      };
+      yield {
+        ...element.el.$nodeDescription,
+        name: "it"
+      };
     }
     yield* this.genUniqueDescedants(() => elementRef(element));
   }
@@ -231,16 +237,3 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     return this.getProjectScope(projectId, referenceType, context);
   }
 }
-function lazyStream(fn) {
-  return new StreamImpl(
-    () => {
-      return fn().iterator();
-    },
-    (iterator) => {
-      if (iterator) {
-        return iterator.next();
-      }
-      return DONE_RESULT;
-    }
-  );
-}

package/dist/test/testServices.d.ts

@@ -1,5 +1,6 @@
 import type { LikeC4ProjectJsonConfig } from '@likec4/config';
 import type { ComputedLikeC4ModelData } from '@likec4/core';
+import { type LangiumDocument } from 'langium';
 import type { LiteralUnion } from 'type-fest';
 import { URI } from 'vscode-uri';
 import type { LikeC4LangiumDocument } from '../ast';
@@ -9,6 +10,7 @@ export declare function createTestServices(options?: {
 }): {
     services: any;
     addDocument: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
+    removeDocument: (doc: LangiumDocument | URI) => Promise<void>;
     parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;