@likec4/language-server 0.28.2 → 0.29.0

package/contrib/likec4.monarch.ts

@@ -10,12 +10,13 @@ export default {
 
     tokenizer: {
         initial: [
-            { regex: /(\w+:\/\/)[^\s]+/, action: {"token":"URI_WITH_SCHEMA"} },
-            { regex: /\/[^\s\/][^\s]*/, action: {"token":"URI_RELATIVE"} },
-            { regex: /"[^"]*"|'[^']*'/, action: {"token":"string"} },
             { 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: /\b\.\b/, action: {"token":"Dot"} },
+            { regex: /"[^"]*"|'[^']*'/, action: {"token":"string"} },
             { include: '@whitespace' },
             { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },
         ],

package/dist/ast.d.ts

@@ -1,10 +1,8 @@
-/// <reference types="react" />
 import type * as c4 from '@likec4/core/types';
 import type { LangiumDocument, MultiMap } from 'langium';
 import type { LikeC4Document } from './generated/ast';
 import * as ast from './generated/ast';
 export { ast };
-export declare function c4hash({ c4Specification, c4Elements, c4Relations, c4Views }: LikeC4LangiumDocument): string;
 export interface ParsedAstSpecification {
     kinds: Record<c4.ElementKind, {
         shape: c4.ElementShape;

package/dist/ast.js

@@ -1,23 +1,15 @@
+import { RelationRefError } from '@likec4/core';
 import { DocumentState } from 'langium/lib/workspace';
-import objectHash from 'object-hash';
+// 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 }) {
-    return objectHash({
-        c4Specification,
-        c4Elements,
-        c4Relations,
-        c4Views
-    }, {
-        respectType: false
-    });
-}
 const idattr = Symbol.for('idattr');
 export const ElementViewOps = {
     writeId(node, id) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ;
         node[idattr] = id;
         return node;
     },
@@ -34,6 +26,7 @@ export const ElementOps = {
         }
         else {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ;
             node[idattr] = id;
         }
         return node;
@@ -78,7 +71,7 @@ export function* streamModel(doc) {
     const relations = [];
     let el;
     while ((el = traverseStack.shift())) {
-        if (ast.isRelationWithSource(el)) {
+        if (ast.isRelation(el)) {
             relations.push(el);
             continue;
         }
@@ -107,12 +100,12 @@ export function* streamModel(doc) {
 export function resolveRelationPoints(node) {
     const target = elementRef(node.target);
     if (!target) {
-        throw new Error('Skip relation due to invalid reference to target');
+        throw new RelationRefError('Invalid reference to target');
     }
-    if (ast.isRelationWithSource(node)) {
+    if ('source' in node) {
         const source = elementRef(node.source);
         if (!source) {
-            throw new Error('Skip relation due to invalid reference to source');
+            throw new RelationRefError('Invalid reference to source');
         }
         return {
             source,
@@ -120,7 +113,7 @@ export function resolveRelationPoints(node) {
         };
     }
     if (!ast.isElementBody(node.$container)) {
-        throw new Error('Skip relation due to invalid reference to source');
+        throw new RelationRefError('Invalid relation parent');
     }
     return {
         source: node.$container.$container,

package/dist/elementRef.js

@@ -1,5 +1,5 @@
 import { ast } from './ast';
-import invariant from 'tiny-invariant';
+import { invariant } from '@likec4/core';
 import { failExpectedNever } from './utils';
 export function isElementRefHead(node) {
     if (ast.isElementRef(node)) {

package/dist/generated/ast.d.ts

@@ -4,16 +4,13 @@
  ******************************************************************************/
 import type { AstNode, Reference, ReferenceInfo, TypeMetaData } from 'langium';
 import { AbstractAstReflection } from 'langium';
-export type AnyStringProperty = ElementStringProperty | LinkProperty | RelationStringProperty | ViewProperty;
-export declare const AnyStringProperty = "AnyStringProperty";
-export declare function isAnyStringProperty(item: unknown): item is AnyStringProperty;
 export type AStyleProperty = ColorProperty | ShapeProperty;
 export declare const AStyleProperty = "AStyleProperty";
 export declare function isAStyleProperty(item: unknown): item is AStyleProperty;
 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;
+export type ElementProperty = ElementStringProperty | ElementStyleProperties;
 export declare const ElementProperty = "ElementProperty";
 export declare function isElementProperty(item: unknown): item is ElementProperty;
 export type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
@@ -38,7 +35,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 | SpecificationTagStyle | ViewRuleStyle;
+    readonly $container: ElementStyleProperties | SpecificationStyleProperties | ViewRuleStyle;
     readonly $type: 'ColorProperty';
     key: 'color';
     value: ThemeColor;
@@ -80,7 +77,7 @@ export interface ElementKindExpression extends AstNode {
 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 $container: ElementRef | ElementRefExpression | ElementView | Relation;
     readonly $type: 'ElementRef';
     el: Reference<Element>;
     next?: ElementRef;
@@ -96,21 +93,21 @@ export interface ElementRefExpression extends AstNode {
 export declare const ElementRefExpression = "ElementRefExpression";
 export declare function isElementRefExpression(item: unknown): item is ElementRefExpression;
 export interface ElementStringProperty extends AstNode {
-    readonly $container: ElementBody | ElementView | RelationBody;
+    readonly $container: ElementBody;
     readonly $type: 'ElementStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
 }
 export declare const ElementStringProperty = "ElementStringProperty";
 export declare function isElementStringProperty(item: unknown): item is ElementStringProperty;
-export interface ElementStyleProperty extends AstNode {
-    readonly $container: ElementBody | ElementView | RelationBody;
-    readonly $type: 'ElementStyleProperty';
+export interface ElementStyleProperties extends AstNode {
+    readonly $container: ElementBody;
+    readonly $type: 'ElementStyleProperties';
     key: 'style';
     props: Array<ColorProperty | ShapeProperty>;
 }
-export declare const ElementStyleProperty = "ElementStyleProperty";
-export declare function isElementStyleProperty(item: unknown): item is ElementStyleProperty;
+export declare const ElementStyleProperties = "ElementStyleProperties";
+export declare function isElementStyleProperties(item: unknown): item is ElementStyleProperties;
 export interface ElementTagExpression extends AstNode {
     readonly $container: InOutExpression | IncomingExpression | OutgoingExpression | RelationExpression | ViewRuleExpression | ViewRuleStyle;
     readonly $type: 'ElementTagExpression';
@@ -140,7 +137,7 @@ export declare function isExtendElement(item: unknown): item is ExtendElement;
 export interface ExtendElementBody extends AstNode {
     readonly $container: ExtendElement;
     readonly $type: 'ExtendElementBody';
-    elements: Array<Element | RelationWithSource>;
+    elements: Array<Element | Relation>;
 }
 export declare const ExtendElementBody = "ExtendElementBody";
 export declare function isExtendElementBody(item: unknown): item is ExtendElementBody;
@@ -169,7 +166,7 @@ export interface LikeC4Document extends AstNode {
 export declare const LikeC4Document = "LikeC4Document";
 export declare function isLikeC4Document(item: unknown): item is LikeC4Document;
 export interface LinkProperty extends AstNode {
-    readonly $container: ElementBody | ElementView | RelationBody;
+    readonly $container: ElementBody;
     readonly $type: 'LinkProperty';
     key: 'link';
     value: Uri;
@@ -179,7 +176,7 @@ export declare function isLinkProperty(item: unknown): item is LinkProperty;
 export interface Model extends AstNode {
     readonly $container: LikeC4Document;
     readonly $type: 'Model';
-    elements: Array<Element | ExtendElement | RelationWithSource>;
+    elements: Array<Element | ExtendElement | Relation>;
     name: 'model';
 }
 export declare const Model = "Model";
@@ -202,16 +199,17 @@ export declare const OutgoingExpression = "OutgoingExpression";
 export declare function isOutgoingExpression(item: unknown): item is OutgoingExpression;
 export interface Relation extends AstNode {
     readonly $container: ElementBody | ExtendElementBody | Model;
-    readonly $type: 'Relation' | 'RelationWithSource';
+    readonly $type: 'Relation';
     arr: RArrow;
-    definition?: RelationBody;
+    body?: RelationBody;
+    source?: ElementRef;
     target: ElementRef;
     title?: string;
 }
 export declare const Relation = "Relation";
 export declare function isRelation(item: unknown): item is Relation;
 export interface RelationBody extends AstNode {
-    readonly $container: Relation | RelationWithSource;
+    readonly $container: Relation;
     readonly $type: 'RelationBody';
     props: Array<RelationStringProperty>;
     tags?: Tags;
@@ -228,7 +226,7 @@ export interface RelationExpression extends AstNode {
 export declare const RelationExpression = "RelationExpression";
 export declare function isRelationExpression(item: unknown): item is RelationExpression;
 export interface RelationStringProperty extends AstNode {
-    readonly $container: ElementBody | ElementView | RelationBody;
+    readonly $container: RelationBody;
     readonly $type: 'RelationStringProperty';
     key: 'title';
     value: string;
@@ -236,7 +234,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 | SpecificationTagStyle | ViewRuleStyle;
+    readonly $container: ElementStyleProperties | SpecificationStyleProperties | ViewRuleStyle;
     readonly $type: 'ShapeProperty';
     key: 'shape';
     value: ElementShape;
@@ -247,17 +245,10 @@ export interface SpecificationElementKind extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationElementKind';
     kind: ElementKind;
-    style?: SpecificationElementKindStyle;
+    style?: SpecificationStyleProperties;
 }
 export declare const SpecificationElementKind = "SpecificationElementKind";
 export declare function isSpecificationElementKind(item: unknown): item is SpecificationElementKind;
-export interface SpecificationElementKindStyle extends AstNode {
-    readonly $container: SpecificationElementKind;
-    readonly $type: 'SpecificationElementKindStyle';
-    props: Array<ColorProperty | ShapeProperty>;
-}
-export declare const SpecificationElementKindStyle = "SpecificationElementKindStyle";
-export declare function isSpecificationElementKindStyle(item: unknown): item is SpecificationElementKindStyle;
 export interface SpecificationRule extends AstNode {
     readonly $container: LikeC4Document;
     readonly $type: 'SpecificationRule';
@@ -266,21 +257,21 @@ export interface SpecificationRule extends AstNode {
 }
 export declare const SpecificationRule = "SpecificationRule";
 export declare function isSpecificationRule(item: unknown): item is SpecificationRule;
+export interface SpecificationStyleProperties extends AstNode {
+    readonly $container: SpecificationElementKind | SpecificationTag;
+    readonly $type: 'SpecificationStyleProperties';
+    props: Array<ColorProperty | ShapeProperty>;
+}
+export declare const SpecificationStyleProperties = "SpecificationStyleProperties";
+export declare function isSpecificationStyleProperties(item: unknown): item is SpecificationStyleProperties;
 export interface SpecificationTag extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationTag';
-    style?: SpecificationTagStyle;
+    style?: SpecificationStyleProperties;
     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';
@@ -304,7 +295,7 @@ export interface Tags extends AstNode {
 export declare const Tags = "Tags";
 export declare function isTags(item: unknown): item is Tags;
 export interface ViewProperty extends AstNode {
-    readonly $container: ElementBody | ElementView | RelationBody;
+    readonly $container: ElementView;
     readonly $type: 'ViewProperty';
     key: 'description' | 'title';
     value: string;
@@ -341,20 +332,8 @@ export interface WildcardExpression extends AstNode {
 }
 export declare const WildcardExpression = "WildcardExpression";
 export declare function isWildcardExpression(item: unknown): item is WildcardExpression;
-export interface RelationWithSource extends Relation {
-    readonly $container: ElementBody | ExtendElementBody | Model;
-    readonly $type: 'RelationWithSource';
-    arr: RArrow;
-    definition?: RelationBody;
-    source: ElementRef;
-    target: ElementRef;
-    title?: string;
-}
-export declare const RelationWithSource = "RelationWithSource";
-export declare function isRelationWithSource(item: unknown): item is RelationWithSource;
 export type LikeC4AstType = {
     AStyleProperty: AStyleProperty;
-    AnyStringProperty: AnyStringProperty;
     ColorProperty: ColorProperty;
     Element: Element;
     ElementBody: ElementBody;
@@ -365,7 +344,7 @@ export type LikeC4AstType = {
     ElementRef: ElementRef;
     ElementRefExpression: ElementRefExpression;
     ElementStringProperty: ElementStringProperty;
-    ElementStyleProperty: ElementStyleProperty;
+    ElementStyleProperties: ElementStyleProperties;
     ElementTagExpression: ElementTagExpression;
     ElementView: ElementView;
     Expression: Expression;
@@ -382,13 +361,11 @@ export type LikeC4AstType = {
     RelationBody: RelationBody;
     RelationExpression: RelationExpression;
     RelationStringProperty: RelationStringProperty;
-    RelationWithSource: RelationWithSource;
     ShapeProperty: ShapeProperty;
     SpecificationElementKind: SpecificationElementKind;
-    SpecificationElementKindStyle: SpecificationElementKindStyle;
     SpecificationRule: SpecificationRule;
+    SpecificationStyleProperties: SpecificationStyleProperties;
     SpecificationTag: SpecificationTag;
-    SpecificationTagStyle: SpecificationTagStyle;
     StrictElementRef: StrictElementRef;
     Tag: Tag;
     Tags: Tags;

package/dist/generated/ast.js

@@ -3,10 +3,6 @@
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 import { AbstractAstReflection } from 'langium';
-export const AnyStringProperty = 'AnyStringProperty';
-export function isAnyStringProperty(item) {
-    return reflection.isInstance(item, AnyStringProperty);
-}
 export const AStyleProperty = 'AStyleProperty';
 export function isAStyleProperty(item) {
     return reflection.isInstance(item, AStyleProperty);
@@ -36,7 +32,7 @@ export function isThemeColor(item) {
     return item === 'primary' || item === 'secondary' || item === 'muted' || item === 'slate' || item === 'blue' || item === 'indigo' || item === 'sky' || item === 'red' || item === 'gray' || item === 'green' || item === 'amber';
 }
 export function isUri(item) {
-    return typeof item === 'string';
+    return (typeof item === 'string' && (/\w+:\/\/\S+/.test(item) || /\.{0,2}\/[^\/]\S+/.test(item)));
 }
 export const View = 'View';
 export function isView(item) {
@@ -81,9 +77,9 @@ export const ElementStringProperty = 'ElementStringProperty';
 export function isElementStringProperty(item) {
     return reflection.isInstance(item, ElementStringProperty);
 }
-export const ElementStyleProperty = 'ElementStyleProperty';
-export function isElementStyleProperty(item) {
-    return reflection.isInstance(item, ElementStyleProperty);
+export const ElementStyleProperties = 'ElementStyleProperties';
+export function isElementStyleProperties(item) {
+    return reflection.isInstance(item, ElementStyleProperties);
 }
 export const ElementTagExpression = 'ElementTagExpression';
 export function isElementTagExpression(item) {
@@ -153,22 +149,18 @@ export const SpecificationElementKind = 'SpecificationElementKind';
 export function isSpecificationElementKind(item) {
     return reflection.isInstance(item, SpecificationElementKind);
 }
-export const SpecificationElementKindStyle = 'SpecificationElementKindStyle';
-export function isSpecificationElementKindStyle(item) {
-    return reflection.isInstance(item, SpecificationElementKindStyle);
-}
 export const SpecificationRule = 'SpecificationRule';
 export function isSpecificationRule(item) {
     return reflection.isInstance(item, SpecificationRule);
 }
+export const SpecificationStyleProperties = 'SpecificationStyleProperties';
+export function isSpecificationStyleProperties(item) {
+    return reflection.isInstance(item, SpecificationStyleProperties);
+}
 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);
@@ -201,13 +193,9 @@ export const WildcardExpression = 'WildcardExpression';
 export function isWildcardExpression(item) {
     return reflection.isInstance(item, WildcardExpression);
 }
-export const RelationWithSource = 'RelationWithSource';
-export function isRelationWithSource(item) {
-    return reflection.isInstance(item, RelationWithSource);
-}
 export class LikeC4AstReflection extends AbstractAstReflection {
     getAllTypes() {
-        return ['AStyleProperty', 'AnyStringProperty', 'ColorProperty', 'Element', 'ElementBody', 'ElementExpression', 'ElementKind', 'ElementKindExpression', 'ElementProperty', 'ElementRef', 'ElementRefExpression', 'ElementStringProperty', 'ElementStyleProperty', 'ElementTagExpression', 'ElementView', 'Expression', 'ExtendElement', 'ExtendElementBody', 'InOutExpression', 'IncomingExpression', 'LikeC4Document', 'LinkProperty', 'Model', 'ModelViews', 'OutgoingExpression', 'Relation', 'RelationBody', 'RelationExpression', 'RelationStringProperty', 'RelationWithSource', 'ShapeProperty', 'SpecificationElementKind', 'SpecificationElementKindStyle', 'SpecificationRule', 'SpecificationTag', 'SpecificationTagStyle', 'StrictElementRef', 'Tag', 'Tags', 'View', 'ViewProperty', 'ViewRule', 'ViewRuleAutoLayout', 'ViewRuleExpression', 'ViewRuleStyle', 'WildcardExpression'];
+        return ['AStyleProperty', 'ColorProperty', 'Element', 'ElementBody', 'ElementExpression', 'ElementKind', 'ElementKindExpression', 'ElementProperty', 'ElementRef', 'ElementRefExpression', 'ElementStringProperty', 'ElementStyleProperties', 'ElementTagExpression', 'ElementView', 'Expression', 'ExtendElement', 'ExtendElementBody', 'InOutExpression', 'IncomingExpression', 'LikeC4Document', 'LinkProperty', 'Model', 'ModelViews', 'OutgoingExpression', 'Relation', 'RelationBody', 'RelationExpression', 'RelationStringProperty', 'ShapeProperty', 'SpecificationElementKind', 'SpecificationRule', 'SpecificationStyleProperties', 'SpecificationTag', 'StrictElementRef', 'Tag', 'Tags', 'View', 'ViewProperty', 'ViewRule', 'ViewRuleAutoLayout', 'ViewRuleExpression', 'ViewRuleStyle', 'WildcardExpression'];
     }
     computeIsSubtype(subtype, supertype) {
         switch (subtype) {
@@ -228,23 +216,13 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case WildcardExpression: {
                 return this.isSubtype(ElementExpression, supertype);
             }
-            case ElementStringProperty: {
-                return this.isSubtype(AnyStringProperty, supertype) || this.isSubtype(ElementProperty, supertype);
-            }
-            case ElementStyleProperty: {
+            case ElementStringProperty:
+            case ElementStyleProperties: {
                 return this.isSubtype(ElementProperty, supertype);
             }
             case ElementView: {
                 return this.isSubtype(View, supertype);
             }
-            case LinkProperty:
-            case RelationStringProperty:
-            case ViewProperty: {
-                return this.isSubtype(AnyStringProperty, supertype);
-            }
-            case RelationWithSource: {
-                return this.isSubtype(Relation, supertype);
-            }
             case ViewRuleAutoLayout:
             case ViewRuleExpression:
             case ViewRuleStyle: {
@@ -310,9 +288,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case 'ElementStyleProperty': {
+            case 'ElementStyleProperties': {
                 return {
-                    name: 'ElementStyleProperty',
+                    name: 'ElementStyleProperties',
                     mandatory: [
                         { name: 'props', type: 'array' }
                     ]
@@ -367,14 +345,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case 'SpecificationElementKindStyle': {
-                return {
-                    name: 'SpecificationElementKindStyle',
-                    mandatory: [
-                        { name: 'props', type: 'array' }
-                    ]
-                };
-            }
             case 'SpecificationRule': {
                 return {
                     name: 'SpecificationRule',
@@ -383,9 +353,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case 'SpecificationTagStyle': {
+            case 'SpecificationStyleProperties': {
                 return {
-                    name: 'SpecificationTagStyle',
+                    name: 'SpecificationStyleProperties',
                     mandatory: [
                         { name: 'props', type: 'array' }
                     ]