@likec4/language-server 1.18.0 → 1.19.1

package/dist/model/model-locator.js

@@ -0,0 +1,126 @@
+import { AstUtils, GrammarUtils } from "langium";
+import { isString } from "remeda";
+import { ast, isParsedLikeC4LangiumDocument } from "../ast.js";
+const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
+const { getDocument } = AstUtils;
+export class LikeC4ModelLocator {
+  constructor(services) {
+    this.services = services;
+    this.fqnIndex = services.likec4.FqnIndex;
+    this.deploymentsIndex = services.likec4.DeploymentsIndex;
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+  }
+  fqnIndex;
+  deploymentsIndex;
+  langiumDocuments;
+  documents() {
+    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument);
+  }
+  getParsedElement(astNodeOrFqn) {
+    if (isString(astNodeOrFqn)) {
+      const fqn2 = astNodeOrFqn;
+      const entry = this.fqnIndex.byFqn(astNodeOrFqn).head();
+      if (!entry) {
+        return null;
+      }
+      const doc2 = this.langiumDocuments.getDocument(entry.documentUri);
+      if (!doc2 || !isParsedLikeC4LangiumDocument(doc2)) {
+        return null;
+      }
+      return doc2.c4Elements.find((e) => e.id === fqn2) ?? null;
+    }
+    const fqn = this.fqnIndex.getFqn(astNodeOrFqn);
+    if (!fqn) return null;
+    const doc = getDocument(astNodeOrFqn);
+    if (!isParsedLikeC4LangiumDocument(doc)) {
+      return null;
+    }
+    return doc.c4Elements.find((e) => e.id === fqn) ?? null;
+  }
+  locateElement(fqn, _prop) {
+    const entry = this.fqnIndex.byFqn(fqn).head();
+    const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
+    if (!entry || !docsegment) {
+      return null;
+    }
+    return {
+      uri: entry.documentUri.toString(),
+      range: docsegment.range
+    };
+  }
+  locateDeploymentElement(fqn, _prop) {
+    const entry = this.deploymentsIndex.byFqn(fqn).head();
+    const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
+    if (!entry || !docsegment) {
+      return null;
+    }
+    return {
+      uri: entry.documentUri.toString(),
+      range: docsegment.range
+    };
+  }
+  locateRelation(relationId) {
+    for (const doc of this.documents()) {
+      const relation = doc.c4Relations.find((r) => r.id === relationId) ?? doc.c4DeploymentRelations.find((r) => r.id === relationId);
+      if (!relation) {
+        continue;
+      }
+      const node = this.services.workspace.AstNodeLocator.getAstNode(
+        doc.parseResult.value,
+        relation.astPath
+      );
+      if (!ast.isRelation(node) && !ast.isDeploymentRelation(node)) {
+        continue;
+      }
+      let targetNode = node.title ? findNodeForProperty(node.$cstNode, "title") : void 0;
+      targetNode ??= node.kind ? findNodeForProperty(node.$cstNode, "kind") : void 0;
+      targetNode ??= findNodeForProperty(node.$cstNode, "target");
+      targetNode ??= node.$cstNode;
+      if (!targetNode) {
+        continue;
+      }
+      return {
+        uri: doc.uri.toString(),
+        range: targetNode.range
+      };
+    }
+    return null;
+  }
+  locateViewAst(viewId) {
+    for (const doc of this.documents()) {
+      const view = doc.c4Views.find((r) => r.id === viewId);
+      if (!view) {
+        continue;
+      }
+      const viewAst = this.services.workspace.AstNodeLocator.getAstNode(
+        doc.parseResult.value,
+        view.astPath
+      );
+      if (ast.isLikeC4View(viewAst)) {
+        return {
+          doc,
+          view,
+          viewAst
+        };
+      }
+    }
+    return null;
+  }
+  locateView(viewId) {
+    const res = this.locateViewAst(viewId);
+    if (!res) {
+      return null;
+    }
+    const node = res.viewAst;
+    let targetNode = node.name ? findNodeForProperty(node.$cstNode, "name") : void 0;
+    targetNode ??= findNodeForKeyword(node.$cstNode, "view");
+    targetNode ??= node.$cstNode;
+    if (!targetNode) {
+      return null;
+    }
+    return {
+      uri: res.doc.uri.toString(),
+      range: targetNode.range
+    };
+  }
+}

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

@@ -0,0 +1,3 @@
+import type * as c4 from '@likec4/core';
+import { ast } from '../ast';
+export declare function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator<string, string>;

package/dist/model/model-parser-where.js

@@ -0,0 +1,70 @@
+import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
+import { isAndOperator, isOrOperator } from "@likec4/core";
+import { ast } from "../ast.js";
+const parseEquals = ({ operator, not }, value) => {
+  if (operator.startsWith("!=")) {
+    return {
+      neq: value
+    };
+  }
+  if (operator.startsWith("=")) {
+    return {
+      eq: value
+    };
+  }
+  return not ? { neq: value } : { eq: value };
+};
+export function parseWhereClause(astNode) {
+  switch (true) {
+    case ast.isWhereTagEqual(astNode): {
+      const tag = astNode.value?.ref?.name;
+      invariant(tag, "Expected tag name");
+      return {
+        tag: parseEquals(astNode, tag)
+      };
+    }
+    case ast.isWhereKindEqual(astNode): {
+      const kind = astNode.value?.ref?.name;
+      invariant(kind, "Expected kind name");
+      return {
+        kind: parseEquals(astNode, kind)
+      };
+    }
+    case (ast.isWhereElementNegation(astNode) || ast.isWhereRelationNegation(astNode)): {
+      return {
+        not: parseWhereClause(astNode.value)
+      };
+    }
+    case ast.isWhereBinaryExpression(astNode): {
+      const left = parseWhereClause(astNode.left);
+      const right = parseWhereClause(astNode.right);
+      const operator = astNode.operator.toLowerCase();
+      switch (operator) {
+        case "and": {
+          const operands = [
+            isAndOperator(left) ? left.and : left,
+            isAndOperator(right) ? right.and : right
+          ].flat();
+          invariant(isNonEmptyArray(operands), "Expected non-empty array");
+          return {
+            and: operands
+          };
+        }
+        case "or": {
+          const operands = [
+            isOrOperator(left) ? left.or : left,
+            isOrOperator(right) ? right.or : right
+          ].flat();
+          invariant(isNonEmptyArray(operands), "Expected non-empty array");
+          return {
+            or: operands
+          };
+        }
+        default:
+          nonexhaustive(operator);
+      }
+    }
+    default:
+      nonexhaustive(astNode);
+  }
+}

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

@@ -0,0 +1,292 @@
+import { invariant } from '@likec4/core';
+import type { LangiumDocument } from 'langium';
+import type { ParsedLikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+import { BaseParser } from './parser/Base';
+export type ModelParsedListener = () => void;
+declare const DocumentParserFromMixins: {
+    new (...args: any[]): {
+        parseGlobals(): void;
+        parseAndStoreGlobalPredicateGroupOrDynamic(astRule: import("../generated/ast").GlobalPredicateGroup | import("../generated/ast").GlobalDynamicPredicateGroup, id: invariant, c4Globals: import("../ast").ParsedAstGlobals): void;
+        parseGlobalPredicateGroup(astRule: import("../generated/ast").GlobalPredicateGroup): invariant[];
+        parseGlobalDynamicPredicateGroup(astRule: import("../generated/ast").GlobalDynamicPredicateGroup): invariant[];
+        parseGlobalStyleOrGroup(astRule: import("../generated/ast").GlobalStyle | import("../generated/ast").GlobalStyleGroup): invariant[];
+        parseViews(): void;
+        parseElementView(astNode: import("../generated/ast").ElementView, additionalStyles: invariant[]): import("../ast").ParsedAstElementView;
+        parseViewRule(astRule: import("../generated/ast").ViewRule): invariant;
+        parseViewRulePredicate(astNode: import("../generated/ast").ViewRulePredicate): invariant;
+        parseViewRuleGlobalPredicateRef(astRule: import("../generated/ast").ViewRuleGlobalPredicateRef | import("../generated/ast").DynamicViewGlobalPredicateRef): invariant;
+        parseViewRuleStyleOrGlobalRef(astRule: import("../generated/ast").ViewRuleStyleOrGlobalRef): invariant;
+        parseViewRuleGroup(astNode: import("../generated/ast").ViewRuleGroup): invariant;
+        parseViewRuleStyle(astRule: import("../generated/ast").ViewRuleStyle | import("../generated/ast").GlobalStyle): invariant;
+        parseRuleStyle(styleProperties: import("../generated/ast").StyleProperty[], elementExpressionsIterator: import("../generated/ast").ElementExpressionsIterator, notationProperty?: import("../generated/ast").NotationProperty): invariant;
+        parseViewRuleGlobalStyle(astRule: import("../generated/ast").ViewRuleGlobalStyle): invariant;
+        parseDynamicElementView(astNode: import("../generated/ast").DynamicView, additionalStyles: invariant[]): import("../ast").ParsedAstDynamicView;
+        parseDynamicViewRule(astRule: import("../generated/ast").DynamicViewRule): invariant;
+        parseDynamicViewIncludePredicate(astRule: import("../generated/ast").DynamicViewIncludePredicate): invariant;
+        parseDynamicParallelSteps(node: import("../generated/ast").DynamicViewParallelSteps): invariant;
+        parseDynamicStep(node: import("../generated/ast").DynamicViewStep): invariant;
+        parsePredicate(astNode: import("../generated/ast").Predicate): invariant;
+        parseElementPredicate(astNode: import("../generated/ast").ElementPredicate): invariant;
+        parseElementExpressionsIterator(astNode: import("../generated/ast").ElementExpressionsIterator): invariant[];
+        parseElementExpression(astNode: import("../generated/ast").ElementExpression): invariant;
+        parseElementPredicateWhere(astNode: import("../generated/ast").ElementPredicateWhere): invariant;
+        parseElementPredicateWith(astNode: import("../generated/ast").ElementPredicateWith): invariant;
+        parseRelationPredicate(astNode: import("../generated/ast").RelationPredicate): invariant;
+        parseRelationPredicateWhere(astNode: import("../generated/ast").RelationPredicateWhere): invariant;
+        parseRelationPredicateWith(astNode: import("../generated/ast").RelationPredicateWith, relation: invariant | invariant): invariant;
+        parseRelationExpression(astNode: import("../generated/ast").RelationExpression): invariant;
+        isValid: import("../validation").IsValidFn;
+        readonly services: LikeC4Services;
+        readonly doc: ParsedLikeC4LangiumDocument;
+        resolveFqn(node: import("../generated/ast").FqnReferenceable): invariant;
+        getAstNodePath(node: invariant): any;
+        getMetadata(metadataAstNode: import("../generated/ast").MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E): invariant<invariant> | null;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseDeploymentView(astNode: import("../generated/ast").DeploymentView): import("../ast").ParsedAstDeploymentView;
+        parseDeploymentViewRule(astRule: import("../generated/ast").DeploymentViewRule): invariant;
+        parseDeploymentViewRulePredicate(astRule: import("../generated/ast").DeploymentViewRulePredicate): invariant;
+        parseDeploymentViewRuleStyle(astRule: import("../generated/ast").DeploymentViewRuleStyle): invariant;
+        parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
+        parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
+        parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
+        parseDeployment(): void;
+        parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
+        parseDeployedInstance(astNode: import("../generated/ast").DeployedInstance): import("../ast").ParsedAstDeployment.Instance;
+        parseDeploymentRelation(astNode: import("../generated/ast").DeploymentRelation): import("../ast").ParsedAstDeploymentRelation;
+    };
+} & {
+    new (...args: any[]): {
+        parseViews(): void;
+        parseElementView(astNode: import("../generated/ast").ElementView, additionalStyles: invariant[]): import("../ast").ParsedAstElementView;
+        parseViewRule(astRule: import("../generated/ast").ViewRule): invariant;
+        parseViewRulePredicate(astNode: import("../generated/ast").ViewRulePredicate): invariant;
+        parseViewRuleGlobalPredicateRef(astRule: import("../generated/ast").ViewRuleGlobalPredicateRef | import("../generated/ast").DynamicViewGlobalPredicateRef): invariant;
+        parseViewRuleStyleOrGlobalRef(astRule: import("../generated/ast").ViewRuleStyleOrGlobalRef): invariant;
+        parseViewRuleGroup(astNode: import("../generated/ast").ViewRuleGroup): invariant;
+        parseViewRuleStyle(astRule: import("../generated/ast").ViewRuleStyle | import("../generated/ast").GlobalStyle): invariant;
+        parseRuleStyle(styleProperties: import("../generated/ast").StyleProperty[], elementExpressionsIterator: import("../generated/ast").ElementExpressionsIterator, notationProperty?: import("../generated/ast").NotationProperty): invariant;
+        parseViewRuleGlobalStyle(astRule: import("../generated/ast").ViewRuleGlobalStyle): invariant;
+        parseDynamicElementView(astNode: import("../generated/ast").DynamicView, additionalStyles: invariant[]): import("../ast").ParsedAstDynamicView;
+        parseDynamicViewRule(astRule: import("../generated/ast").DynamicViewRule): invariant;
+        parseDynamicViewIncludePredicate(astRule: import("../generated/ast").DynamicViewIncludePredicate): invariant;
+        parseDynamicParallelSteps(node: import("../generated/ast").DynamicViewParallelSteps): invariant;
+        parseDynamicStep(node: import("../generated/ast").DynamicViewStep): invariant;
+        parsePredicate(astNode: import("../generated/ast").Predicate): invariant;
+        parseElementPredicate(astNode: import("../generated/ast").ElementPredicate): invariant;
+        parseElementExpressionsIterator(astNode: import("../generated/ast").ElementExpressionsIterator): invariant[];
+        parseElementExpression(astNode: import("../generated/ast").ElementExpression): invariant;
+        parseElementPredicateWhere(astNode: import("../generated/ast").ElementPredicateWhere): invariant;
+        parseElementPredicateWith(astNode: import("../generated/ast").ElementPredicateWith): invariant;
+        parseRelationPredicate(astNode: import("../generated/ast").RelationPredicate): invariant;
+        parseRelationPredicateWhere(astNode: import("../generated/ast").RelationPredicateWhere): invariant;
+        parseRelationPredicateWith(astNode: import("../generated/ast").RelationPredicateWith, relation: invariant | invariant): invariant;
+        parseRelationExpression(astNode: import("../generated/ast").RelationExpression): invariant;
+        isValid: import("../validation").IsValidFn;
+        readonly services: LikeC4Services;
+        readonly doc: ParsedLikeC4LangiumDocument;
+        resolveFqn(node: import("../generated/ast").FqnReferenceable): invariant;
+        getAstNodePath(node: invariant): any;
+        getMetadata(metadataAstNode: import("../generated/ast").MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E): invariant<invariant> | null;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseDeploymentView(astNode: import("../generated/ast").DeploymentView): import("../ast").ParsedAstDeploymentView;
+        parseDeploymentViewRule(astRule: import("../generated/ast").DeploymentViewRule): invariant;
+        parseDeploymentViewRulePredicate(astRule: import("../generated/ast").DeploymentViewRulePredicate): invariant;
+        parseDeploymentViewRuleStyle(astRule: import("../generated/ast").DeploymentViewRuleStyle): invariant;
+        parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
+        parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
+        parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
+        parseDeployment(): void;
+        parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
+        parseDeployedInstance(astNode: import("../generated/ast").DeployedInstance): import("../ast").ParsedAstDeployment.Instance;
+        parseDeploymentRelation(astNode: import("../generated/ast").DeploymentRelation): import("../ast").ParsedAstDeploymentRelation;
+    };
+} & {
+    new (...args: any[]): {
+        parseSpecification(): void;
+        parseSpecificationDeploymentNodeKind({ kind, props }: import("../generated/ast").SpecificationDeploymentNodeKind): {};
+        isValid: import("../validation").IsValidFn;
+        readonly services: LikeC4Services;
+        readonly doc: ParsedLikeC4LangiumDocument;
+        resolveFqn(node: import("../generated/ast").FqnReferenceable): invariant;
+        getAstNodePath(node: invariant): any;
+        getMetadata(metadataAstNode: import("../generated/ast").MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E): invariant<invariant> | null;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        parsePredicate(astNode: import("../generated/ast").Predicate): invariant;
+        parseElementPredicate(astNode: import("../generated/ast").ElementPredicate): invariant;
+        parseElementExpressionsIterator(astNode: import("../generated/ast").ElementExpressionsIterator): invariant[];
+        parseElementExpression(astNode: import("../generated/ast").ElementExpression): invariant;
+        parseElementPredicateWhere(astNode: import("../generated/ast").ElementPredicateWhere): invariant;
+        parseElementPredicateWith(astNode: import("../generated/ast").ElementPredicateWith): invariant;
+        parseRelationPredicate(astNode: import("../generated/ast").RelationPredicate): invariant;
+        parseRelationPredicateWhere(astNode: import("../generated/ast").RelationPredicateWhere): invariant;
+        parseRelationPredicateWith(astNode: import("../generated/ast").RelationPredicateWith, relation: invariant | invariant): invariant;
+        parseRelationExpression(astNode: import("../generated/ast").RelationExpression): invariant;
+        isValid: import("../validation").IsValidFn;
+        readonly services: LikeC4Services;
+        readonly doc: ParsedLikeC4LangiumDocument;
+        resolveFqn(node: import("../generated/ast").FqnReferenceable): invariant;
+        getAstNodePath(node: invariant): any;
+        getMetadata(metadataAstNode: import("../generated/ast").MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E): invariant<invariant> | null;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        parseDeploymentView(astNode: import("../generated/ast").DeploymentView): import("../ast").ParsedAstDeploymentView;
+        parseDeploymentViewRule(astRule: import("../generated/ast").DeploymentViewRule): invariant;
+        parseDeploymentViewRulePredicate(astRule: import("../generated/ast").DeploymentViewRulePredicate): invariant;
+        parseDeploymentViewRuleStyle(astRule: import("../generated/ast").DeploymentViewRuleStyle): invariant;
+        parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
+        parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
+        parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
+        isValid: import("../validation").IsValidFn;
+        readonly services: LikeC4Services;
+        readonly doc: ParsedLikeC4LangiumDocument;
+        resolveFqn(node: import("../generated/ast").FqnReferenceable): invariant;
+        getAstNodePath(node: invariant): any;
+        getMetadata(metadataAstNode: import("../generated/ast").MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E): invariant<invariant> | null;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseDeployment(): void;
+        parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
+        parseDeployedInstance(astNode: import("../generated/ast").DeployedInstance): import("../ast").ParsedAstDeployment.Instance;
+        parseDeploymentRelation(astNode: import("../generated/ast").DeploymentRelation): import("../ast").ParsedAstDeploymentRelation;
+    };
+} & {
+    new (...args: any[]): {
+        parseDeployment(): void;
+        parseDeploymentNode(astNode: import("../generated/ast").DeploymentNode): import("../ast").ParsedAstDeployment.Node;
+        parseDeployedInstance(astNode: import("../generated/ast").DeployedInstance): import("../ast").ParsedAstDeployment.Instance;
+        parseDeploymentRelation(astNode: import("../generated/ast").DeploymentRelation): import("../ast").ParsedAstDeploymentRelation;
+        parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
+        parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
+        parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
+        isValid: import("../validation").IsValidFn;
+        readonly services: LikeC4Services;
+        readonly doc: ParsedLikeC4LangiumDocument;
+        resolveFqn(node: import("../generated/ast").FqnReferenceable): invariant;
+        getAstNodePath(node: invariant): any;
+        getMetadata(metadataAstNode: import("../generated/ast").MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E): invariant<invariant> | null;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        parseModel(): void;
+        parseElement(astNode: import("../generated/ast").Element): import("../ast").ParsedAstElement;
+        parseRelation(astNode: import("../generated/ast").Relation): import("../ast").ParsedAstRelation;
+        isValid: import("../validation").IsValidFn;
+        readonly services: LikeC4Services;
+        readonly doc: ParsedLikeC4LangiumDocument;
+        resolveFqn(node: import("../generated/ast").FqnReferenceable): invariant;
+        getAstNodePath(node: invariant): any;
+        getMetadata(metadataAstNode: import("../generated/ast").MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E): invariant<invariant> | null;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        parseFqnRef(astNode: import("../generated/ast").FqnRef): invariant;
+        parseFqnExpr(astNode: import("../generated/ast").FqnExpr): invariant;
+        parseFqnRefExpr(astNode: import("../generated/ast").FqnRefExpr): invariant;
+        parseFqnExpressions(astNode: import("../generated/ast").FqnExpressions): invariant[];
+        parseRelationExpr(astNode: import("../generated/ast").RelationExpr): invariant;
+        isValid: import("../validation").IsValidFn;
+        readonly services: LikeC4Services;
+        readonly doc: ParsedLikeC4LangiumDocument;
+        resolveFqn(node: import("../generated/ast").FqnReferenceable): invariant;
+        getAstNodePath(node: invariant): any;
+        getMetadata(metadataAstNode: import("../generated/ast").MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: import("../generated/ast").Tags;
+        }>(withTags?: E): invariant<invariant> | null;
+        convertLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+        parseLinks(source?: import("../generated/ast").LinkProperty["$container"]): import("../ast").ParsedLink[] | undefined;
+    };
+} & typeof BaseParser;
+export declare class DocumentParser extends DocumentParserFromMixins {
+}
+export declare class LikeC4ModelParser {
+    private services;
+    private cachedParsers;
+    constructor(services: LikeC4Services);
+    parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
+    forDocument(doc: LangiumDocument): DocumentParser;
+}
+export {};

package/dist/model/model-parser.js

@@ -0,0 +1,72 @@
+import { invariant } from "@likec4/core";
+import DefaultWeakMap from "mnemonist/default-weak-map";
+import { pipe } from "remeda";
+import { isFqnIndexedDocument } from "../ast.js";
+import { BaseParser } from "./parser/Base.js";
+import { DeploymentModelParser } from "./parser/DeploymentModelParser.js";
+import { DeploymentViewParser } from "./parser/DeploymentViewParser.js";
+import { ExpressionV2Parser } from "./parser/FqnRefParser.js";
+import { GlobalsParser } from "./parser/GlobalsParser.js";
+import { ModelParser } from "./parser/ModelParser.js";
+import { PredicatesParser } from "./parser/PredicatesParser.js";
+import { SpecificationParser } from "./parser/SpecificationParser.js";
+import { ViewsParser } from "./parser/ViewsParser.js";
+const DocumentParserFromMixins = pipe(
+  BaseParser,
+  ExpressionV2Parser,
+  ModelParser,
+  DeploymentModelParser,
+  DeploymentViewParser,
+  PredicatesParser,
+  SpecificationParser,
+  ViewsParser,
+  GlobalsParser
+);
+export class DocumentParser extends DocumentParserFromMixins {
+}
+export class LikeC4ModelParser {
+  constructor(services) {
+    this.services = services;
+  }
+  cachedParsers = new DefaultWeakMap(
+    (doc) => new DocumentParser(this.services, doc)
+  );
+  parse(doc) {
+    invariant(isFqnIndexedDocument(doc), `Not a FqnIndexedDocument: ${doc.uri.toString(true)}`);
+    try {
+      const props = {
+        c4Specification: {
+          tags: /* @__PURE__ */ new Set(),
+          elements: {},
+          relationships: {},
+          colors: {},
+          deployments: {}
+        },
+        c4Elements: [],
+        c4Relations: [],
+        c4Deployments: [],
+        c4DeploymentRelations: [],
+        c4Globals: {
+          predicates: {},
+          dynamicPredicates: {},
+          styles: {}
+        },
+        c4Views: []
+      };
+      doc = Object.assign(doc, props);
+      const parser = this.cachedParsers.get(doc);
+      parser.parseSpecification();
+      parser.parseModel();
+      parser.parseGlobals();
+      parser.parseDeployment();
+      parser.parseViews();
+      return parser.doc;
+    } catch (cause) {
+      throw new Error(`Error parsing document ${doc.uri.toString()}`, { cause });
+    }
+  }
+  forDocument(doc) {
+    invariant(isFqnIndexedDocument(doc), `Not a FqnIndexedDocument: ${doc.uri.toString(true)}`);
+    return this.cachedParsers.get(doc);
+  }
+}

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

@@ -0,0 +1,28 @@
+import type * as c4 from '@likec4/core';
+import type { AstNode } from 'langium';
+import { type ParsedLikeC4LangiumDocument, type ParsedLink, ast } from '../../ast';
+import type { LikeC4Services } from '../../module';
+import { type IsValidFn } from '../../validation';
+export type GConstructor<T = {}> = new (...args: any[]) => T;
+export declare function toSingleLine<T extends string | undefined | null>(str: T): T;
+export declare function removeIndent<T extends string | undefined | null>(str: T): T;
+export type Base = GConstructor<BaseParser>;
+export declare class BaseParser {
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    isValid: IsValidFn;
+    constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument);
+    resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+    getAstNodePath(node: AstNode): any;
+    getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+        [key: string]: string;
+    } | undefined;
+    convertTags<E extends {
+        tags?: ast.Tags;
+    }>(withTags?: E): any;
+    parseTags<E extends {
+        tags?: ast.Tags;
+    }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+    convertLinks(source?: ast.LinkProperty['$container']): ParsedLink[] | undefined;
+    parseLinks(source?: ast.LinkProperty['$container']): ParsedLink[] | undefined;
+}