@likec4/language-server 0.40.0 → 0.42.0

package/contrib/likec4.monarch.ts

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

package/contrib/likec4.tmLanguage.json

@@ -0,0 +1,73 @@
+{
+  "name": "likec4",
+  "scopeName": "source.likec4",
+  "fileTypes": [
+    ".c4",
+    ".likec4",
+    ".like-c4"
+  ],
+  "patterns": [
+    {
+      "include": "#comments"
+    },
+    {
+      "name": "keyword.control.likec4",
+      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|browser|color|crow|cylinder|dashed|description|diamond|dotted|element|exclude|extend|extends|gray|green|head|icon|include|indigo|it|kind|line|link|mobile|model|muted|none|normal|odiamond|of|onormal|open|person|primary|queue|rectangle|red|relationship|secondary|shape|sky|slate|solid|specification|storage|style|tag|tail|technology|this|title|vee|view|views)\\b"
+    },
+    {
+      "name": "string.quoted.double.likec4",
+      "begin": "\"",
+      "end": "\"",
+      "patterns": [
+        {
+          "include": "#string-character-escape"
+        }
+      ]
+    },
+    {
+      "name": "string.quoted.single.likec4",
+      "begin": "'",
+      "end": "'",
+      "patterns": [
+        {
+          "include": "#string-character-escape"
+        }
+      ]
+    }
+  ],
+  "repository": {
+    "comments": {
+      "patterns": [
+        {
+          "name": "comment.block.likec4",
+          "begin": "/\\*",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.comment.likec4"
+            }
+          },
+          "end": "\\*/",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.comment.likec4"
+            }
+          }
+        },
+        {
+          "begin": "//",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.whitespace.comment.leading.likec4"
+            }
+          },
+          "end": "(?=$)",
+          "name": "comment.line.likec4"
+        }
+      ]
+    },
+    "string-character-escape": {
+      "name": "constant.character.escape.likec4",
+      "match": "\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\\{[0-9A-Fa-f]+\\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)"
+    }
+  }
+}

package/dist/Rpc.d.ts

@@ -4,3 +4,4 @@ export declare class Rpc {
     constructor(services: LikeC4Services);
     init(): void;
 }
+//# sourceMappingURL=Rpc.d.ts.map

package/dist/ast.d.ts

@@ -0,0 +1,117 @@
+/// <reference types="react" />
+import { type c4 } from '@likec4/core';
+import type { LangiumDocument, MultiMap } from 'langium';
+import type { LikeC4Document } from './generated/ast';
+import * as ast from './generated/ast';
+export { ast };
+declare module './generated/ast' {
+    interface Element {
+        fqn?: c4.Fqn;
+    }
+}
+export interface ParsedAstSpecification {
+    kinds: Record<c4.ElementKind, {
+        shape?: c4.ElementShape;
+        color?: c4.ThemeColor;
+        icon?: c4.IconUrl;
+    }>;
+    relationships: Record<c4.RelationshipKind, {
+        color?: c4.ThemeColor;
+        line?: c4.RelationshipLineType;
+        head?: c4.RelationshipArrowType;
+        tail?: c4.RelationshipArrowType;
+    }>;
+}
+export interface ParsedAstElement {
+    id: c4.Fqn;
+    astPath: string;
+    kind: c4.ElementKind;
+    title: string;
+    description?: string;
+    technology?: string;
+    icon?: c4.IconUrl;
+    tags?: c4.NonEmptyArray<c4.Tag>;
+    links?: c4.NonEmptyArray<string>;
+    shape?: c4.ElementShape;
+    color?: c4.ThemeColor;
+}
+export interface ParsedAstRelation {
+    id: c4.RelationID;
+    astPath: string;
+    source: c4.Fqn;
+    target: c4.Fqn;
+    kind?: c4.RelationshipKind;
+    title: string;
+}
+export interface ParsedAstElementView {
+    id: c4.ViewID;
+    viewOf?: c4.Fqn;
+    extends?: c4.ViewID;
+    astPath: string;
+    title?: string;
+    description?: string;
+    tags?: c4.NonEmptyArray<c4.Tag>;
+    links?: c4.NonEmptyArray<string>;
+    rules: c4.ViewRule[];
+}
+export declare const ElementViewOps: {
+    writeId(node: ast.ElementView, id: c4.ViewID): ast.ElementView;
+    readId(node: ast.ElementView): c4.ViewID | undefined;
+};
+export declare const ElementOps: {
+    writeId(node: ast.Element, id: c4.Fqn | null): ast.Element;
+    readId(node: ast.Element): c4.Fqn | undefined;
+};
+export interface DocFqnIndexEntry {
+    name: string;
+    el: WeakRef<ast.Element>;
+    path: string;
+}
+export interface LikeC4DocumentProps {
+    c4Specification?: ParsedAstSpecification;
+    c4Elements?: ParsedAstElement[];
+    c4Relations?: ParsedAstRelation[];
+    c4Views?: ParsedAstElementView[];
+    c4fqns?: MultiMap<c4.Fqn, DocFqnIndexEntry>;
+}
+export interface LikeC4LangiumDocument extends LangiumDocument<LikeC4Document>, LikeC4DocumentProps {
+}
+export type ParsedLikeC4LangiumDocument = Omit<LikeC4LangiumDocument, keyof LikeC4DocumentProps> & Required<LikeC4DocumentProps>;
+export declare function cleanParsedModel(doc: LikeC4LangiumDocument): {
+    elements: ParsedAstElement[];
+    relations: ParsedAstRelation[];
+    views: ParsedAstElementView[];
+    specification: ParsedAstSpecification;
+};
+export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
+export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;
+export declare const isValidLikeC4LangiumDocument: (doc: LangiumDocument) => doc is ParsedLikeC4LangiumDocument;
+export declare function streamModel(doc: LikeC4LangiumDocument): Generator<ast.Element | ast.Relation, void, unknown>;
+export declare function resolveRelationPoints(node: ast.Relation): {
+    source: ast.Element;
+    target: ast.Element;
+};
+export declare function toElementStyle(props?: ast.StyleProperties['props']): {
+    color?: c4.ThemeColor;
+    shape?: c4.ElementShape;
+    icon?: c4.IconUrl;
+};
+export declare function toElementStyleExcludeDefaults(props?: ast.StyleProperties['props']): {
+    shape?: "browser" | "cylinder" | "mobile" | "person" | "queue" | "storage";
+    color?: "amber" | "blue" | "gray" | "green" | "indigo" | "muted" | "red" | "secondary" | "sky" | "slate";
+    icon?: c4.IconUrl;
+};
+export declare function toRelationshipStyle(props?: ast.SpecificationRelationshipKind['props']): {
+    color?: c4.ThemeColor;
+    line?: c4.RelationshipLineType;
+    head?: c4.RelationshipArrowType;
+    tail?: c4.RelationshipArrowType;
+};
+export declare function toRelationshipStyleExcludeDefaults(props?: ast.SpecificationRelationshipKind['props']): {
+    tail?: "crow" | "diamond" | "none" | "odiamond" | "onormal" | "open" | "vee";
+    head?: "crow" | "diamond" | "none" | "odiamond" | "onormal" | "open" | "vee";
+    line?: "dotted" | "solid";
+    color?: "amber" | "blue" | "green" | "indigo" | "muted" | "primary" | "red" | "secondary" | "sky" | "slate";
+};
+export declare function toAutoLayout(direction: ast.ViewRuleLayoutDirection): c4.ViewRuleAutoLayout['autoLayout'];
+//# sourceMappingURL=ast.d.ts.map

package/dist/ast.js

@@ -1,4 +1,4 @@
-import { DefaultElementShape, DefaultThemeColor, RelationRefError, nonexhaustive } from "@likec4/core";
+import { DefaultElementShape, DefaultThemeColor, RelationRefError, nonexhaustive, DefaultLineStyle, DefaultArrowType, DefaultRelationshipColor } from "@likec4/core";
 import { DocumentState } from "langium";
 import { elementRef } from "./elementRef.js";
 import * as ast from "./generated/ast.js";
@@ -33,7 +33,8 @@ export const ElementOps = {
 };
 export function cleanParsedModel(doc) {
   const specification = doc.c4Specification = {
-    kinds: {}
+    kinds: {},
+    relationships: {}
   };
   const elements = doc.c4Elements = [];
   const relations = doc.c4Relations = [];
@@ -141,6 +142,49 @@ export function toElementStyleExcludeDefaults(props) {
     ...shape && shape !== DefaultElementShape ? { shape } : {}
   };
 }
+export function toRelationshipStyle(props) {
+  const result = {};
+  if (!props || props.length === 0) {
+    return result;
+  }
+  for (const prop of props) {
+    if (ast.isColorProperty(prop)) {
+      result.color = prop.value;
+      continue;
+    }
+    if (ast.isLineProperty(prop)) {
+      result.line = prop.value;
+      continue;
+    }
+    if (ast.isArrowProperty(prop)) {
+      switch (prop.key) {
+        case "head": {
+          result.head = prop.value;
+          break;
+        }
+        case "tail": {
+          result.tail = prop.value;
+          break;
+        }
+        default: {
+          nonexhaustive(prop);
+        }
+      }
+      continue;
+    }
+    nonexhaustive(prop);
+  }
+  return result;
+}
+export function toRelationshipStyleExcludeDefaults(props) {
+  const { color, line, head, tail } = toRelationshipStyle(props);
+  return {
+    ...color && color !== DefaultRelationshipColor ? { color } : {},
+    ...line && line !== DefaultLineStyle ? { line } : {},
+    ...head && head !== DefaultArrowType ? { head } : {},
+    ...tail && tail !== DefaultArrowType ? { tail } : {}
+  };
+}
 export function toAutoLayout(direction) {
   switch (direction) {
     case "TopBottom": {

package/dist/elementRef.d.ts

@@ -5,7 +5,7 @@ export declare function isElementRefHead(node: ast.ElementRef | ast.StrictElemen
  * Returns referenced AST Element
  *
  */
-export declare function elementRef(node: ast.ElementRef | ast.StrictElementRef): any;
+export declare function elementRef(node: ast.ElementRef | ast.StrictElementRef): ast.Element | undefined;
 /**
  * Returns FQN of strictElementRef
  * a.b.c.d - for c node returns a.b
@@ -16,3 +16,4 @@ export declare function fqnElementRef(node: ast.StrictElementRef): c4.Fqn;
  * a.b.c.d - for c node returns a.b
  */
 export declare function parentFqnElementRef(node: ast.StrictElementRef): c4.Fqn;
+//# sourceMappingURL=elementRef.d.ts.map

package/dist/generated/ast.d.ts

@@ -23,6 +23,8 @@ export declare const LikeC4Terminals: {
     TagID: RegExp;
     ID: RegExp;
 };
+export type ArrowType = 'crow' | 'diamond' | 'none' | 'normal' | 'odiamond' | 'onormal' | 'open' | 'vee';
+export declare function isArrowType(item: unknown): item is ArrowType;
 export type ElementExpression = ElementKindExpression | ElementRefExpression | ElementTagExpression | WildcardExpression;
 export declare const ElementExpression = "ElementExpression";
 export declare function isElementExpression(item: unknown): item is ElementExpression;
@@ -34,7 +36,9 @@ export declare function isElementShape(item: unknown): item is ElementShape;
 export type Expression = ElementExpression | InOutExpression | IncomingExpression | OutgoingExpression | RelationExpression;
 export declare const Expression = "Expression";
 export declare function isExpression(item: unknown): item is Expression;
-export type Name = 'element' | 'model' | ElementShape | ThemeColor | string;
+export type LineOptions = 'dashed' | 'dotted' | 'solid';
+export declare function isLineOptions(item: unknown): item is LineOptions;
+export type Name = 'element' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
 export declare function isName(item: unknown): item is Name;
 export type RArrow = string;
 export declare function isRArrow(item: unknown): item is RArrow;
@@ -50,8 +54,16 @@ export declare const ViewRule = "ViewRule";
 export declare function isViewRule(item: unknown): item is ViewRule;
 export type ViewRuleLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
 export declare function isViewRuleLayoutDirection(item: unknown): item is ViewRuleLayoutDirection;
+export interface ArrowProperty extends AstNode {
+    readonly $container: SpecificationRelationshipKind;
+    readonly $type: 'ArrowProperty';
+    key: 'head' | 'tail';
+    value: ArrowType;
+}
+export declare const ArrowProperty = "ArrowProperty";
+export declare function isArrowProperty(item: unknown): item is ArrowProperty;
 export interface ColorProperty extends AstNode {
-    readonly $container: StyleProperties | ViewRuleStyle;
+    readonly $container: SpecificationRelationshipKind | StyleProperties | ViewRuleStyle;
     readonly $type: 'ColorProperty';
     key: 'color';
     value: ThemeColor;
@@ -197,6 +209,14 @@ export interface LikeC4Document extends AstNode {
 }
 export declare const LikeC4Document = "LikeC4Document";
 export declare function isLikeC4Document(item: unknown): item is LikeC4Document;
+export interface LineProperty extends AstNode {
+    readonly $container: SpecificationRelationshipKind;
+    readonly $type: 'LineProperty';
+    key: 'line';
+    value: LineOptions;
+}
+export declare const LineProperty = "LineProperty";
+export declare function isLineProperty(item: unknown): item is LineProperty;
 export interface LinkProperty extends AstNode {
     readonly $container: ElementBody | ElementViewBody;
     readonly $type: 'LinkProperty';
@@ -232,8 +252,9 @@ export declare function isOutgoingExpression(item: unknown): item is OutgoingExp
 export interface Relation extends AstNode {
     readonly $container: ElementBody | ExtendElementBody | Model;
     readonly $type: 'Relation';
-    arr: RArrow;
+    arr?: RArrow;
     body?: RelationBody;
+    kind?: Reference<RelationshipKind>;
     source?: ElementRef;
     target: ElementRef;
     title?: string;
@@ -257,6 +278,13 @@ export interface RelationExpression extends AstNode {
 }
 export declare const RelationExpression = "RelationExpression";
 export declare function isRelationExpression(item: unknown): item is RelationExpression;
+export interface RelationshipKind extends AstNode {
+    readonly $container: SpecificationRelationshipKind;
+    readonly $type: 'RelationshipKind';
+    name: Name;
+}
+export declare const RelationshipKind = "RelationshipKind";
+export declare function isRelationshipKind(item: unknown): item is RelationshipKind;
 export interface RelationStringProperty extends AstNode {
     readonly $container: RelationBody;
     readonly $type: 'RelationStringProperty';
@@ -281,11 +309,20 @@ export interface SpecificationElementKind extends AstNode {
 }
 export declare const SpecificationElementKind = "SpecificationElementKind";
 export declare function isSpecificationElementKind(item: unknown): item is SpecificationElementKind;
+export interface SpecificationRelationshipKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationRelationshipKind';
+    kind: RelationshipKind;
+    props: Array<ArrowProperty | ColorProperty | LineProperty>;
+}
+export declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
+export declare function isSpecificationRelationshipKind(item: unknown): item is SpecificationRelationshipKind;
 export interface SpecificationRule extends AstNode {
     readonly $container: LikeC4Document;
     readonly $type: 'SpecificationRule';
     elements: Array<SpecificationElementKind>;
     name: 'specification';
+    relationships: Array<SpecificationRelationshipKind>;
     tags: Array<SpecificationTag>;
 }
 export declare const SpecificationRule = "SpecificationRule";
@@ -367,6 +404,7 @@ export interface WildcardExpression extends AstNode {
 export declare const WildcardExpression = "WildcardExpression";
 export declare function isWildcardExpression(item: unknown): item is WildcardExpression;
 export type LikeC4AstType = {
+    ArrowProperty: ArrowProperty;
     ColorProperty: ColorProperty;
     Element: Element;
     ElementBody: ElementBody;
@@ -388,6 +426,7 @@ export type LikeC4AstType = {
     InOutExpression: InOutExpression;
     IncomingExpression: IncomingExpression;
     LikeC4Document: LikeC4Document;
+    LineProperty: LineProperty;
     LinkProperty: LinkProperty;
     Model: Model;
     ModelViews: ModelViews;
@@ -396,8 +435,10 @@ export type LikeC4AstType = {
     RelationBody: RelationBody;
     RelationExpression: RelationExpression;
     RelationStringProperty: RelationStringProperty;
+    RelationshipKind: RelationshipKind;
     ShapeProperty: ShapeProperty;
     SpecificationElementKind: SpecificationElementKind;
+    SpecificationRelationshipKind: SpecificationRelationshipKind;
     SpecificationRule: SpecificationRule;
     SpecificationTag: SpecificationTag;
     StrictElementRef: StrictElementRef;
@@ -419,3 +460,4 @@ export declare class LikeC4AstReflection extends AbstractAstReflection {
     getTypeMetaData(type: string): TypeMetaData;
 }
 export declare const reflection: LikeC4AstReflection;
+//# sourceMappingURL=ast.d.ts.map

package/dist/generated/ast.js

@@ -18,6 +18,9 @@ export const LikeC4Terminals = {
   TagID: /((#)([^\W\d_])(((([^\W\d_])|([0-9]))|(_))|(-))*)/,
   ID: /((([^\W\d_])|(_))(((([^\W\d_])|([0-9]))|(_))|(-))*)/
 };
+export function isArrowType(item) {
+  return item === "none" || item === "normal" || item === "onormal" || item === "diamond" || item === "odiamond" || item === "crow" || item === "open" || item === "vee";
+}
 export const ElementExpression = "ElementExpression";
 export function isElementExpression(item) {
   return reflection.isInstance(item, ElementExpression);
@@ -33,8 +36,11 @@ export const Expression = "Expression";
 export function isExpression(item) {
   return reflection.isInstance(item, Expression);
 }
+export function isLineOptions(item) {
+  return item === "solid" || item === "dashed" || item === "dotted";
+}
 export function isName(item) {
-  return isElementShape(item) || isThemeColor(item) || item === "element" || item === "model" || typeof item === "string" && /((([^\W\d_])|(_))(((([^\W\d_])|([0-9]))|(_))|(-))*)/.test(item);
+  return isElementShape(item) || isThemeColor(item) || isLineOptions(item) || isArrowType(item) || item === "element" || item === "model" || typeof item === "string" && /((([^\W\d_])|(_))(((([^\W\d_])|([0-9]))|(_))|(-))*)/.test(item);
 }
 export function isRArrow(item) {
   return typeof item === "string" && /->/.test(item);
@@ -56,6 +62,10 @@ export function isViewRule(item) {
 export function isViewRuleLayoutDirection(item) {
   return item === "TopBottom" || item === "LeftRight" || item === "BottomTop" || item === "RightLeft";
 }
+export const ArrowProperty = "ArrowProperty";
+export function isArrowProperty(item) {
+  return reflection.isInstance(item, ArrowProperty);
+}
 export const ColorProperty = "ColorProperty";
 export function isColorProperty(item) {
   return reflection.isInstance(item, ColorProperty);
@@ -128,6 +138,10 @@ export const LikeC4Document = "LikeC4Document";
 export function isLikeC4Document(item) {
   return reflection.isInstance(item, LikeC4Document);
 }
+export const LineProperty = "LineProperty";
+export function isLineProperty(item) {
+  return reflection.isInstance(item, LineProperty);
+}
 export const LinkProperty = "LinkProperty";
 export function isLinkProperty(item) {
   return reflection.isInstance(item, LinkProperty);
@@ -156,6 +170,10 @@ export const RelationExpression = "RelationExpression";
 export function isRelationExpression(item) {
   return reflection.isInstance(item, RelationExpression);
 }
+export const RelationshipKind = "RelationshipKind";
+export function isRelationshipKind(item) {
+  return reflection.isInstance(item, RelationshipKind);
+}
 export const RelationStringProperty = "RelationStringProperty";
 export function isRelationStringProperty(item) {
   return reflection.isInstance(item, RelationStringProperty);
@@ -168,6 +186,10 @@ export const SpecificationElementKind = "SpecificationElementKind";
 export function isSpecificationElementKind(item) {
   return reflection.isInstance(item, SpecificationElementKind);
 }
+export const SpecificationRelationshipKind = "SpecificationRelationshipKind";
+export function isSpecificationRelationshipKind(item) {
+  return reflection.isInstance(item, SpecificationRelationshipKind);
+}
 export const SpecificationRule = "SpecificationRule";
 export function isSpecificationRule(item) {
   return reflection.isInstance(item, SpecificationRule);
@@ -214,7 +236,7 @@ export function isWildcardExpression(item) {
 }
 export class LikeC4AstReflection extends AbstractAstReflection {
   getAllTypes() {
-    return ["ColorProperty", "Element", "ElementBody", "ElementExpression", "ElementKind", "ElementKindExpression", "ElementProperty", "ElementRef", "ElementRefExpression", "ElementStringProperty", "ElementTagExpression", "ElementView", "ElementViewBody", "ElementViewRef", "Expression", "ExtendElement", "ExtendElementBody", "IconProperty", "InOutExpression", "IncomingExpression", "LikeC4Document", "LinkProperty", "Model", "ModelViews", "OutgoingExpression", "Relation", "RelationBody", "RelationExpression", "RelationStringProperty", "ShapeProperty", "SpecificationElementKind", "SpecificationRule", "SpecificationTag", "StrictElementRef", "StyleProperties", "Tag", "Tags", "View", "ViewProperty", "ViewRule", "ViewRuleAutoLayout", "ViewRuleExpression", "ViewRuleStyle", "WildcardExpression"];
+    return ["ArrowProperty", "ColorProperty", "Element", "ElementBody", "ElementExpression", "ElementKind", "ElementKindExpression", "ElementProperty", "ElementRef", "ElementRefExpression", "ElementStringProperty", "ElementTagExpression", "ElementView", "ElementViewBody", "ElementViewRef", "Expression", "ExtendElement", "ExtendElementBody", "IconProperty", "InOutExpression", "IncomingExpression", "LikeC4Document", "LineProperty", "LinkProperty", "Model", "ModelViews", "OutgoingExpression", "Relation", "RelationBody", "RelationExpression", "RelationStringProperty", "RelationshipKind", "ShapeProperty", "SpecificationElementKind", "SpecificationRelationshipKind", "SpecificationRule", "SpecificationTag", "StrictElementRef", "StyleProperties", "Tag", "Tags", "View", "ViewProperty", "ViewRule", "ViewRuleAutoLayout", "ViewRuleExpression", "ViewRuleStyle", "WildcardExpression"];
   }
   computeIsSubtype(subtype, supertype) {
     switch (subtype) {
@@ -266,6 +288,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
       case "ElementViewRef:view": {
         return ElementView;
       }
+      case "Relation:kind": {
+        return RelationshipKind;
+      }
       default: {
         throw new Error(`${referenceId} is not a valid reference id.`);
       }
@@ -355,11 +380,20 @@ export class LikeC4AstReflection extends AbstractAstReflection {
           ]
         };
       }
+      case "SpecificationRelationshipKind": {
+        return {
+          name: "SpecificationRelationshipKind",
+          mandatory: [
+            { name: "props", type: "array" }
+          ]
+        };
+      }
       case "SpecificationRule": {
         return {
           name: "SpecificationRule",
           mandatory: [
             { name: "elements", type: "array" },
+            { name: "relationships", type: "array" },
             { name: "tags", type: "array" }
           ]
         };

package/dist/generated/grammar.d.ts

@@ -2,4 +2,6 @@
  * This file was generated by langium-cli 2.0.1.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
+import type { Grammar } from 'langium';
 export declare const LikeC4Grammar: () => Grammar;
+//# sourceMappingURL=grammar.d.ts.map