@likec4/language-server 0.18.1 → 0.20.0

package/contrib/likec4.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the likec4 language.
 export default {
     keywords: [
-        'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','browser','color','cylinder','description','element','exclude','extend','gray','green','include','indigo','it','mobile','model','muted','of','person','primary','queue','rectangle','red','secondary','shape','sky','slate','specification','storage','style','tag','technology','this','title','view','views'
+        'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','browser','color','cylinder','description','element','exclude','extend','gray','green','include','indigo','it','kind','mobile','model','muted','of','person','primary','queue','rectangle','red','secondary','shape','sky','slate','specification','storage','style','tag','technology','this','title','view','views'
     ],
     operators: [
         '*','->','.*'

package/contrib/likec4.tmLanguage.json

@@ -12,7 +12,7 @@
     },
     {
       "name": "keyword.control.likec4",
-      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|browser|color|cylinder|description|element|exclude|extend|gray|green|include|indigo|it|mobile|model|muted|of|person|primary|queue|rectangle|red|secondary|shape|sky|slate|specification|storage|style|tag|technology|this|title|view|views)\\b"
+      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|browser|color|cylinder|description|element|exclude|extend|gray|green|include|indigo|it|kind|mobile|model|muted|of|person|primary|queue|rectangle|red|secondary|shape|sky|slate|specification|storage|style|tag|technology|this|title|view|views)\\b"
     },
     {
       "name": "string.quoted.double.likec4",

package/dist/ast.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="react" />
-import * as ast from './generated/ast';
+import type * as c4 from '@likec4/core/types';
 import type { LangiumDocument, MultiMap } from 'langium';
 import type { LikeC4Document } from './generated/ast';
-import type * as c4 from '@likec4/core/types';
+import * as ast from './generated/ast';
 export { ast };
 export declare function c4hash({ c4Specification, c4Elements, c4Relations, c4Views }: LikeC4LangiumDocument): string;
 export interface ParsedAstSpecification {
@@ -62,7 +62,7 @@ export declare function cleanParsedModel(doc: LikeC4LangiumDocument): {
 export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
 export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
 export declare const isValidDocument: (doc: LangiumDocument) => doc is LikeC4LangiumDocument;
-export declare function streamModel(doc: LikeC4LangiumDocument): Generator<ast.Element | ast.Relation, void, unknown>;
+export declare function streamModel(doc: LikeC4LangiumDocument): Generator<ast.Relation | ast.Element, void, unknown>;
 export declare function resolveRelationPoints(node: ast.Relation): {
     source: ast.Element;
     target: ast.Element;

package/dist/ast.js

@@ -1,7 +1,7 @@
-import * as ast from './generated/ast';
-import { DocumentState } from 'langium';
+import { DocumentState } from 'langium/lib/workspace';
 import objectHash from 'object-hash';
 import { elementRef } from './elementRef';
+import * as ast from './generated/ast';
 import { LikeC4LanguageMetaData } from './generated/module';
 export { ast };
 export function c4hash({ c4Specification, c4Elements, c4Relations, c4Views }) {
@@ -74,19 +74,34 @@ export const isValidDocument = (doc) => {
 export function* streamModel(doc) {
     const elements = doc.parseResult.value.model?.elements ?? [];
     const traverseStack = [...elements];
+    const relations = [];
     let el;
     while ((el = traverseStack.shift())) {
+        if (ast.isRelationWithSource(el)) {
+            relations.push(el);
+            continue;
+        }
         if (ast.isExtendElement(el)) {
-            if (!!el.body) {
+            if (el.body && el.body.elements.length > 0) {
                 traverseStack.push(...el.body.elements);
             }
             continue;
         }
-        if (ast.isElement(el) && el.body) {
-            traverseStack.push(...el.body.elements);
+        if (ast.isElement(el) && el.body && el.body.elements.length > 0) {
+            for (const nested of el.body.elements) {
+                if (ast.isRelation(nested)) {
+                    relations.push(nested);
+                }
+                else {
+                    traverseStack.push(nested);
+                }
+            }
         }
         yield el;
     }
+    for (const relation of relations) {
+        yield relation;
+    }
 }
 export function resolveRelationPoints(node) {
     const target = elementRef(node.target);

package/dist/generated/ast.d.ts

@@ -10,7 +10,7 @@ export declare function isAnyStringProperty(item: unknown): item is AnyStringPro
 export type AStyleProperty = ColorProperty | ShapeProperty;
 export declare const AStyleProperty = "AStyleProperty";
 export declare function isAStyleProperty(item: unknown): item is AStyleProperty;
-export type ElementExpression = ElementRefExpression | WildcardExpression;
+export type ElementExpression = ElementKindExpression | ElementRefExpression | ElementTagExpression | WildcardExpression;
 export declare const ElementExpression = "ElementExpression";
 export declare function isElementExpression(item: unknown): item is ElementExpression;
 export type ElementProperty = ElementStringProperty | ElementStyleProperty;
@@ -34,7 +34,7 @@ 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 ColorProperty extends AstNode {
-    readonly $container: ElementStyleProperty | SpecificationElementKindStyle | ViewRuleStyle;
+    readonly $container: ElementStyleProperty | SpecificationElementKindStyle | SpecificationTagStyle | ViewRuleStyle;
     readonly $type: 'ColorProperty';
     key: 'color';
     value: ThemeColor;
@@ -67,6 +67,14 @@ export interface ElementKind extends AstNode {
 }
 export declare const ElementKind = "ElementKind";
 export declare function isElementKind(item: unknown): item is ElementKind;
+export interface ElementKindExpression extends AstNode {
+    readonly $container: InOutExpression | IncomingExpression | OutgoingExpression | RelationExpression | ViewRuleExpression | ViewRuleStyle;
+    readonly $type: 'ElementKindExpression';
+    isEqual: boolean;
+    kind: Reference<ElementKind>;
+}
+export declare const ElementKindExpression = "ElementKindExpression";
+export declare function isElementKindExpression(item: unknown): item is ElementKindExpression;
 export interface ElementRef extends AstNode {
     readonly $container: ElementRef | ElementRefExpression | ElementView | Relation | RelationWithSource;
     readonly $type: 'ElementRef';
@@ -99,6 +107,14 @@ export interface ElementStyleProperty extends AstNode {
 }
 export declare const ElementStyleProperty = "ElementStyleProperty";
 export declare function isElementStyleProperty(item: unknown): item is ElementStyleProperty;
+export interface ElementTagExpression extends AstNode {
+    readonly $container: InOutExpression | IncomingExpression | OutgoingExpression | RelationExpression | ViewRuleExpression | ViewRuleStyle;
+    readonly $type: 'ElementTagExpression';
+    isEqual: boolean;
+    tag: Reference<Tag>;
+}
+export declare const ElementTagExpression = "ElementTagExpression";
+export declare function isElementTagExpression(item: unknown): item is ElementTagExpression;
 export interface ElementView extends AstNode {
     readonly $container: ModelViews;
     readonly $type: 'ElementView';
@@ -203,7 +219,7 @@ export interface RelationStringProperty extends AstNode {
 export declare const RelationStringProperty = "RelationStringProperty";
 export declare function isRelationStringProperty(item: unknown): item is RelationStringProperty;
 export interface ShapeProperty extends AstNode {
-    readonly $container: ElementStyleProperty | SpecificationElementKindStyle | ViewRuleStyle;
+    readonly $container: ElementStyleProperty | SpecificationElementKindStyle | SpecificationTagStyle | ViewRuleStyle;
     readonly $type: 'ShapeProperty';
     key: 'shape';
     value: ElementShape;
@@ -237,10 +253,18 @@ export declare function isSpecificationRule(item: unknown): item is Specificatio
 export interface SpecificationTag extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationTag';
+    style?: SpecificationTagStyle;
     tag: Tag;
 }
 export declare const SpecificationTag = "SpecificationTag";
 export declare function isSpecificationTag(item: unknown): item is SpecificationTag;
+export interface SpecificationTagStyle extends AstNode {
+    readonly $container: SpecificationTag;
+    readonly $type: 'SpecificationTagStyle';
+    props: Array<ColorProperty | ShapeProperty>;
+}
+export declare const SpecificationTagStyle = "SpecificationTagStyle";
+export declare function isSpecificationTagStyle(item: unknown): item is SpecificationTagStyle;
 export interface StrictElementRef extends AstNode {
     readonly $container: ExtendElement | StrictElementRef;
     readonly $type: 'StrictElementRef';
@@ -319,11 +343,13 @@ export type LikeC4AstType = {
     ElementBody: ElementBody;
     ElementExpression: ElementExpression;
     ElementKind: ElementKind;
+    ElementKindExpression: ElementKindExpression;
     ElementProperty: ElementProperty;
     ElementRef: ElementRef;
     ElementRefExpression: ElementRefExpression;
     ElementStringProperty: ElementStringProperty;
     ElementStyleProperty: ElementStyleProperty;
+    ElementTagExpression: ElementTagExpression;
     ElementView: ElementView;
     Expression: Expression;
     ExtendElement: ExtendElement;
@@ -344,6 +370,7 @@ export type LikeC4AstType = {
     SpecificationElementKindStyle: SpecificationElementKindStyle;
     SpecificationRule: SpecificationRule;
     SpecificationTag: SpecificationTag;
+    SpecificationTagStyle: SpecificationTagStyle;
     StrictElementRef: StrictElementRef;
     Tag: Tag;
     Tags: Tags;

package/dist/generated/ast.js

@@ -59,6 +59,10 @@ export const ElementKind = 'ElementKind';
 export function isElementKind(item) {
     return reflection.isInstance(item, ElementKind);
 }
+export const ElementKindExpression = 'ElementKindExpression';
+export function isElementKindExpression(item) {
+    return reflection.isInstance(item, ElementKindExpression);
+}
 export const ElementRef = 'ElementRef';
 export function isElementRef(item) {
     return reflection.isInstance(item, ElementRef);
@@ -75,6 +79,10 @@ export const ElementStyleProperty = 'ElementStyleProperty';
 export function isElementStyleProperty(item) {
     return reflection.isInstance(item, ElementStyleProperty);
 }
+export const ElementTagExpression = 'ElementTagExpression';
+export function isElementTagExpression(item) {
+    return reflection.isInstance(item, ElementTagExpression);
+}
 export const ElementView = 'ElementView';
 export function isElementView(item) {
     return reflection.isInstance(item, ElementView);
@@ -147,6 +155,10 @@ export const SpecificationTag = 'SpecificationTag';
 export function isSpecificationTag(item) {
     return reflection.isInstance(item, SpecificationTag);
 }
+export const SpecificationTagStyle = 'SpecificationTagStyle';
+export function isSpecificationTagStyle(item) {
+    return reflection.isInstance(item, SpecificationTagStyle);
+}
 export const StrictElementRef = 'StrictElementRef';
 export function isStrictElementRef(item) {
     return reflection.isInstance(item, StrictElementRef);
@@ -185,7 +197,7 @@ export function isRelationWithSource(item) {
 }
 export class LikeC4AstReflection extends AbstractAstReflection {
     getAllTypes() {
-        return ['AStyleProperty', 'AnyStringProperty', 'ColorProperty', 'Element', 'ElementBody', 'ElementExpression', 'ElementKind', 'ElementProperty', 'ElementRef', 'ElementRefExpression', 'ElementStringProperty', 'ElementStyleProperty', 'ElementView', 'Expression', 'ExtendElement', 'ExtendElementBody', 'InOutExpression', 'IncomingExpression', 'LikeC4Document', 'Model', 'ModelViews', 'OutgoingExpression', 'Relation', 'RelationBody', 'RelationExpression', 'RelationStringProperty', 'RelationWithSource', 'ShapeProperty', 'SpecificationElementKind', 'SpecificationElementKindStyle', 'SpecificationRule', 'SpecificationTag', 'StrictElementRef', 'Tag', 'Tags', 'View', 'ViewProperty', 'ViewRule', 'ViewRuleAutoLayout', 'ViewRuleExpression', 'ViewRuleStyle', 'WildcardExpression'];
+        return ['AStyleProperty', 'AnyStringProperty', 'ColorProperty', 'Element', 'ElementBody', 'ElementExpression', 'ElementKind', 'ElementKindExpression', 'ElementProperty', 'ElementRef', 'ElementRefExpression', 'ElementStringProperty', 'ElementStyleProperty', 'ElementTagExpression', 'ElementView', 'Expression', 'ExtendElement', 'ExtendElementBody', 'InOutExpression', 'IncomingExpression', 'LikeC4Document', 'Model', 'ModelViews', 'OutgoingExpression', 'Relation', 'RelationBody', 'RelationExpression', 'RelationStringProperty', 'RelationWithSource', 'ShapeProperty', 'SpecificationElementKind', 'SpecificationElementKindStyle', 'SpecificationRule', 'SpecificationTag', 'SpecificationTagStyle', 'StrictElementRef', 'Tag', 'Tags', 'View', 'ViewProperty', 'ViewRule', 'ViewRuleAutoLayout', 'ViewRuleExpression', 'ViewRuleStyle', 'WildcardExpression'];
     }
     computeIsSubtype(subtype, supertype) {
         switch (subtype) {
@@ -200,7 +212,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case RelationExpression: {
                 return this.isSubtype(Expression, supertype);
             }
+            case ElementKindExpression:
             case ElementRefExpression:
+            case ElementTagExpression:
             case WildcardExpression: {
                 return this.isSubtype(ElementExpression, supertype);
             }
@@ -233,13 +247,15 @@ export class LikeC4AstReflection extends AbstractAstReflection {
     getReferenceType(refInfo) {
         const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
         switch (referenceId) {
-            case 'Element:kind': {
+            case 'Element:kind':
+            case 'ElementKindExpression:kind': {
                 return ElementKind;
             }
             case 'ElementRef:el':
             case 'StrictElementRef:el': {
                 return Element;
             }
+            case 'ElementTagExpression:tag':
             case 'Tags:value': {
                 return Tag;
             }
@@ -267,6 +283,14 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case 'ElementKindExpression': {
+                return {
+                    name: 'ElementKindExpression',
+                    mandatory: [
+                        { name: 'isEqual', type: 'boolean' }
+                    ]
+                };
+            }
             case 'ElementRefExpression': {
                 return {
                     name: 'ElementRefExpression',
@@ -283,6 +307,14 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case 'ElementTagExpression': {
+                return {
+                    name: 'ElementTagExpression',
+                    mandatory: [
+                        { name: 'isEqual', type: 'boolean' }
+                    ]
+                };
+            }
             case 'ElementView': {
                 return {
                     name: 'ElementView',
@@ -341,6 +373,14 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case 'SpecificationTagStyle': {
+                return {
+                    name: 'SpecificationTagStyle',
+                    mandatory: [
+                        { name: 'props', type: 'array' }
+                    ]
+                };
+            }
             case 'Tags': {
                 return {
                     name: 'Tags',