@likec4/language-server 0.6.2 → 0.6.3

package/contrib/likec4.monarch.ts

@@ -0,0 +1,31 @@
+// Monarch syntax highlighting for the likec4 language.
+export default {
+    keywords: [
+        'BottomTop','LeftRight','RightLeft','TopBottom','autoLayout','browser','color','cylinder','description','element','exclude','extend','include','it','model','muted','of','person','primary','queue','rectangle','secondary','shape','specification','storage','style','tag','technology','this','title','view','views'
+    ],
+    operators: [
+        '*','->','.*'
+    ],
+    symbols:  /\*|->|\.\*/,
+
+    tokenizer: {
+        initial: [
+            { 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: /"[^"]*"|'[^']*'/, action: {"token":"string"} },
+            { include: '@whitespace' },
+            { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },
+        ],
+        whitespace: [
+            { regex: /[^\S\r\n]/, action: {"token":"white"} },
+            { regex: /\/\*/, action: {"token":"comment","next":"@comment"} },
+            { regex: /\/\/[^\n\r]*/, action: {"token":"comment"} },
+        ],
+        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|autoLayout|browser|color|cylinder|description|element|exclude|extend|include|it|model|muted|of|person|primary|queue|rectangle|secondary|shape|specification|storage|style|tag|technology|this|title|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/ast.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="react" />
+import * as ast from './generated/ast';
+import type { LangiumDocument } from 'langium';
+import type { LikeC4Document } from './generated/ast';
+import type * as c4 from '@likec4/core/types';
+export { ast };
+export declare function c4hash({ c4Specification, c4Elements, c4Relations, c4Views }: LikeC4LangiumDocument): string;
+export interface ParsedAstSpecification {
+    kinds: Record<c4.ElementKind, {
+        shape: c4.ElementShape;
+        color: c4.ThemeColor;
+    }>;
+}
+export interface ParsedAstElement {
+    id: c4.Fqn;
+    astPath: string;
+    kind: c4.ElementKind;
+    title: string;
+    description?: string;
+    technology?: string;
+    tags?: c4.Tag[];
+    shape?: c4.ElementShape;
+    color?: c4.ThemeColor;
+}
+export interface ParsedAstRelation {
+    id: c4.RelationID;
+    astPath: string;
+    source: c4.Fqn;
+    target: c4.Fqn;
+    title: string;
+}
+export interface ParsedAstElementView {
+    id: c4.ViewID;
+    astPath: string;
+    viewOf?: c4.Fqn;
+    title?: string;
+    description?: 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): ast.Element;
+    readId(node: ast.Element): c4.Fqn | undefined;
+};
+export interface LikeC4LangiumDocument extends LangiumDocument<LikeC4Document> {
+    c4hash?: string;
+    c4Specification: ParsedAstSpecification;
+    c4Elements: ParsedAstElement[];
+    c4Relations: ParsedAstRelation[];
+    c4Views: ParsedAstElementView[];
+}
+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 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 resolveRelationPoints(node: ast.Relation): {
+    source: ast.Element;
+    target: ast.Element;
+};
+export declare function toElementStyle(props?: ast.AStyleProperty[]): {
+    color?: c4.ThemeColor;
+    shape?: c4.ElementShape;
+};
+export declare function toAutoLayout(direction: ast.ViewRuleLayoutDirection): c4.ViewRuleAutoLayout['autoLayout'];

package/dist/ast.js

@@ -0,0 +1,133 @@
+import * as ast from './generated/ast';
+import { DocumentState } from 'langium';
+import objectHash from 'object-hash';
+import { elementRef } from './elementRef';
+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) {
+        Object.assign(node, { [idattr]: id });
+        return node;
+    },
+    readId(node) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return node[idattr];
+    }
+};
+export const ElementOps = {
+    writeId(node, id) {
+        Object.assign(node, { [idattr]: id });
+        return node;
+    },
+    readId(node) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return node[idattr];
+    }
+};
+export function cleanParsedModel(doc) {
+    doc.c4Specification = {
+        kinds: {}
+    };
+    const elements = (doc.c4Elements = []);
+    const relations = (doc.c4Relations = []);
+    const views = (doc.c4Views = []);
+    return {
+        elements,
+        relations,
+        views,
+        specification: doc.c4Specification
+    };
+}
+export function isLikeC4LangiumDocument(doc) {
+    return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
+}
+export function isParsedLikeC4LangiumDocument(doc) {
+    return (isLikeC4LangiumDocument(doc) &&
+        ['c4Specification', 'c4Elements', 'c4Relations', 'c4Views'].every(key => key in doc));
+}
+export const isValidDocument = (doc) => {
+    if (!isLikeC4LangiumDocument(doc))
+        return false;
+    const { state, parseResult, diagnostics } = doc;
+    return (state === DocumentState.Validated &&
+        parseResult.lexerErrors.length === 0 &&
+        (!diagnostics || diagnostics.every(d => d.severity !== 1)));
+};
+export function* streamModel(doc) {
+    const elements = doc.parseResult.value.model?.elements ?? [];
+    const traverseStack = [...elements];
+    let el;
+    while ((el = traverseStack.shift())) {
+        if (ast.isExtendElement(el)) {
+            traverseStack.push(...el.body.elements);
+            continue;
+        }
+        if (ast.isElement(el) && el.body) {
+            traverseStack.push(...el.body.elements);
+        }
+        yield el;
+    }
+}
+export function resolveRelationPoints(node) {
+    const target = elementRef(node.target);
+    if (!target) {
+        throw new Error('Skip relation due to invalid reference to target');
+    }
+    if (ast.isRelationWithSource(node)) {
+        const source = elementRef(node.source);
+        if (!source) {
+            throw new Error('Skip relation due to invalid reference to source');
+        }
+        return {
+            source,
+            target
+        };
+    }
+    if (!ast.isElementBody(node.$container)) {
+        throw new Error('Skip relation due to invalid reference to source');
+    }
+    const source = node.$container.$container;
+    return {
+        source,
+        target
+    };
+}
+export function toElementStyle(props) {
+    const result = {};
+    const color = props?.find(ast.isColorProperty)?.value;
+    if (color) {
+        result.color = color;
+    }
+    const shape = props?.find(ast.isShapeProperty)?.value;
+    if (shape) {
+        result.shape = shape;
+    }
+    return result;
+}
+export function toAutoLayout(direction) {
+    switch (direction) {
+        case 'TopBottom': {
+            return 'TB';
+        }
+        case 'BottomTop': {
+            return 'BT';
+        }
+        case 'LeftRight': {
+            return 'LR';
+        }
+        case 'RightLeft': {
+            return 'RL';
+        }
+    }
+}

package/dist/builtin.d.ts

@@ -0,0 +1,4 @@
+export declare const specification: {
+    uri: string;
+    document: string;
+};

package/dist/builtin.js

@@ -0,0 +1,8 @@
+export const specification = {
+    uri: 'builtin:///specification.likec4',
+    document: `
+specification {
+  element element
+}
+`.trimStart()
+};

package/dist/elementRef.d.ts

@@ -0,0 +1,6 @@
+import type * as c4 from '@likec4/core/types';
+import { ast } from './ast';
+export declare function isElementRefHead(node: ast.ElementRef | ast.StrictElementRef): boolean;
+export declare function elementRef(node: ast.ElementRef): ast.Element | undefined;
+export declare function strictElementRefFqn(node: ast.StrictElementRef): c4.Fqn;
+export declare function parentStrictElementRef(node: ast.StrictElementRef): c4.Fqn;

package/dist/elementRef.js

@@ -0,0 +1,39 @@
+import { ast } from './ast';
+import invariant from 'tiny-invariant';
+import { failExpectedNever } from './utils';
+export function isElementRefHead(node) {
+    if (ast.isElementRef(node)) {
+        return !ast.isElementRef(node.$container);
+    }
+    if (ast.isStrictElementRef(node)) {
+        return !ast.isStrictElementRef(node.$container);
+    }
+    failExpectedNever(node);
+}
+export function elementRef(node) {
+    invariant(isElementRefHead(node), 'Expected head ElementRef');
+    while (node.next) {
+        node = node.next;
+    }
+    return node.el.ref;
+}
+export function strictElementRefFqn(node) {
+    invariant(isElementRefHead(node), 'Expected head StrictElementRef');
+    const name = [node.el.$refText];
+    let child = node.next;
+    while (child) {
+        name.push(child.el.$refText);
+        child = child.next;
+    }
+    return name.join('.');
+}
+export function parentStrictElementRef(node) {
+    invariant(!isElementRefHead(node), 'Expected next StrictElementRef');
+    const path = [];
+    let parent = node.$container;
+    while (ast.isStrictElementRef(parent)) {
+        path.unshift(parent.el.$refText);
+        parent = parent.$container;
+    }
+    return path.join('.');
+}