@likec4/language-server 0.37.0 → 0.40.0

package/dist/Rpc.d.ts

@@ -0,0 +1,6 @@
+import type { LikeC4Services } from './module';
+export declare class Rpc {
+    private services;
+    constructor(services: LikeC4Services);
+    init(): void;
+}

package/dist/Rpc.js

@@ -0,0 +1,130 @@
+import { logError, logger } from "./logger.js";
+import pThrottle from "p-throttle";
+import { nonexhaustive } from "@likec4/core";
+import { URI } from "langium";
+import { isLikeC4LangiumDocument } from "./ast.js";
+import {
+  buildDocuments,
+  computeView,
+  fetchModel,
+  fetchRawModel,
+  locate,
+  onDidChangeModel,
+  rebuild
+} from "./protocol.js";
+export class Rpc {
+  constructor(services) {
+    this.services = services;
+  }
+  init() {
+    const { ModelBuilder: modelBuilder, ModelLocator: modelLocator } = this.services.likec4;
+    const connection = this.services.shared.lsp.Connection;
+    if (!connection) {
+      return;
+    }
+    logger.info(`[ServerRpc] init`);
+    const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
+    const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
+    const notifyClient = pThrottle({
+      limit: 4,
+      interval: 1e3
+    })(() => connection.sendNotification(onDidChangeModel, ""));
+    modelBuilder.onModelParsed(() => {
+      void notifyClient();
+    });
+    connection.onRequest(fetchModel, async (_cancelToken) => {
+      let model;
+      try {
+        model = modelBuilder.buildModel() ?? null;
+      } catch (e) {
+        model = null;
+        logError(e);
+      }
+      return Promise.resolve({ model });
+    });
+    connection.onRequest(fetchRawModel, async (_cancelToken) => {
+      let rawmodel;
+      try {
+        rawmodel = modelBuilder.buildRawModel() ?? null;
+      } catch (e) {
+        rawmodel = null;
+        logError(e);
+      }
+      return Promise.resolve({ rawmodel });
+    });
+    connection.onRequest(computeView, ({ viewId }) => {
+      return {
+        view: modelBuilder.computeView(viewId)
+      };
+    });
+    connection.onRequest(rebuild, async (cancelToken) => {
+      const changed = LangiumDocuments.all.map((d) => {
+        if (isLikeC4LangiumDocument(d)) {
+          delete d.c4Specification;
+          delete d.c4Elements;
+          delete d.c4Relations;
+          delete d.c4Views;
+          delete d.c4fqns;
+        }
+        return d.uri;
+      }).toArray();
+      logger.debug(`[ServerRpc] rebuild all documents: [
+        ${changed.map((d) => d.toString()).join("\n      ")}
+      ]`);
+      await DocumentBuilder.update(changed, [], cancelToken);
+      return {
+        docs: changed.map((d) => d.toString())
+      };
+    });
+    connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
+      if (docs.length === 0) {
+        logger.debug(`[ServerRpc] received empty request to rebuild`);
+        return;
+      }
+      logger.debug(
+        `[ServerRpc] received request to buildDocuments:
+${docs.map((d) => "   - " + d).join("\n")}`
+      );
+      const changed = [];
+      for (const d of docs) {
+        try {
+          const uri = URI.parse(d);
+          if (LangiumDocuments.hasDocument(uri)) {
+            changed.push(uri);
+          } else {
+            logger.warn(`[ServerRpc] LangiumDocuments does not have document: ${d}`);
+            LangiumDocuments.getOrCreateDocument(uri);
+          }
+        } catch (e) {
+          logError(e);
+        }
+      }
+      if (changed.length !== docs.length) {
+        const all = LangiumDocuments.all.map((d) => d.uri.toString()).toArray();
+        logger.warn(
+          `
+[ServerRpc] We have in LangiumDocuments: [
+  ${all.join("\n  ")}
+]
+We rebuild: [
+  ${changed.join("\n  ")}
+]
+  `.trim()
+        );
+      }
+      await DocumentBuilder.update(changed, [], cancelToken);
+    });
+    connection.onRequest(locate, (params) => {
+      if ("element" in params) {
+        return modelLocator.locateElement(params.element, params.property ?? "name");
+      }
+      if ("relation" in params) {
+        return modelLocator.locateRelation(params.relation);
+      }
+      if ("view" in params) {
+        return modelLocator.locateView(params.view);
+      }
+      nonexhaustive(params);
+    });
+  }
+}

package/dist/ast.d.ts

@@ -1,97 +0,0 @@
-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;
-    }>;
-}
-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;
-    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.Relation | ast.Element, 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?: "person" | "browser" | "mobile" | "cylinder" | "storage" | "queue";
-    color?: "amber" | "blue" | "gray" | "slate" | "green" | "indigo" | "muted" | "red" | "secondary" | "sky";
-    icon?: c4.IconUrl;
-};
-export declare function toAutoLayout(direction: ast.ViewRuleLayoutDirection): c4.ViewRuleAutoLayout['autoLayout'];
-//# sourceMappingURL=ast.d.ts.map

package/dist/ast.js

@@ -1,175 +1,159 @@
-import { DefaultElementShape, DefaultThemeColor, RelationRefError, nonexhaustive } from '@likec4/core';
-import { DocumentState } from 'langium';
-import { elementRef } from './elementRef';
-import * as ast from './generated/ast';
-import { LikeC4LanguageMetaData } from './generated/module';
+import { DefaultElementShape, DefaultThemeColor, RelationRefError, nonexhaustive } from "@likec4/core";
+import { DocumentState } from "langium";
+import { elementRef } from "./elementRef.js";
+import * as ast from "./generated/ast.js";
+import { LikeC4LanguageMetaData } from "./generated/module.js";
 export { ast };
-const idattr = Symbol.for('idattr');
+const idattr = Symbol.for("idattr");
 export const ElementViewOps = {
-    writeId(node, id) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-extra-semi
-        ;
-        node[idattr] = id;
-        return node;
-    },
-    readId(node) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return node[idattr];
-    }
+  writeId(node, id) {
+    ;
+    node[idattr] = id;
+    return node;
+  },
+  readId(node) {
+    return node[idattr];
+  }
 };
 export const ElementOps = {
-    writeId(node, id) {
-        if (id === null) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-dynamic-delete
-            delete node[idattr];
-            delete node.fqn;
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-extra-semi
-            ;
-            node[idattr] = id;
-            node.fqn = id;
-        }
-        return node;
-    },
-    readId(node) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return node[idattr];
+  writeId(node, id) {
+    if (id === null) {
+      delete node[idattr];
+      delete node.fqn;
+    } else {
+      ;
+      node[idattr] = id;
+      node.fqn = id;
     }
+    return node;
+  },
+  readId(node) {
+    return node[idattr];
+  }
 };
 export function cleanParsedModel(doc) {
-    const specification = (doc.c4Specification = {
-        kinds: {}
-    });
-    const elements = (doc.c4Elements = []);
-    const relations = (doc.c4Relations = []);
-    const views = (doc.c4Views = []);
-    return {
-        elements,
-        relations,
-        views,
-        specification
-    };
+  const specification = doc.c4Specification = {
+    kinds: {}
+  };
+  const elements = doc.c4Elements = [];
+  const relations = doc.c4Relations = [];
+  const views = doc.c4Views = [];
+  return {
+    elements,
+    relations,
+    views,
+    specification
+  };
 }
 export function isLikeC4LangiumDocument(doc) {
-    return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
+  return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
 }
 export function isParsedLikeC4LangiumDocument(doc) {
-    return (isLikeC4LangiumDocument(doc) &&
-        doc.state >= DocumentState.Validated &&
-        !!doc.c4Specification &&
-        !!doc.c4Elements &&
-        !!doc.c4Relations &&
-        !!doc.c4Views &&
-        !!doc.c4fqns);
+  return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.Validated && !!doc.c4Specification && !!doc.c4Elements && !!doc.c4Relations && !!doc.c4Views && !!doc.c4fqns;
 }
 export const isValidLikeC4LangiumDocument = (doc) => {
-    if (!isParsedLikeC4LangiumDocument(doc))
-        return false;
-    const { state, parseResult, diagnostics } = doc;
-    return (state === DocumentState.Validated &&
-        parseResult.lexerErrors.length === 0 &&
-        (!diagnostics || diagnostics.every(d => d.severity !== 1)));
+  if (!isParsedLikeC4LangiumDocument(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];
-    const relations = [];
-    let el;
-    while ((el = traverseStack.shift())) {
-        if (ast.isRelation(el)) {
-            relations.push(el);
-            continue;
-        }
-        if (ast.isExtendElement(el)) {
-            if (el.body && el.body.elements.length > 0) {
-                traverseStack.push(...el.body.elements);
-            }
-            continue;
-        }
-        if (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;
+  const elements = doc.parseResult.value.model?.elements ?? [];
+  const traverseStack = [...elements];
+  const relations = [];
+  let el;
+  while (el = traverseStack.shift()) {
+    if (ast.isRelation(el)) {
+      relations.push(el);
+      continue;
     }
-}
-export function resolveRelationPoints(node) {
-    const target = elementRef(node.target);
-    if (!target) {
-        throw new RelationRefError('Invalid reference to target');
+    if (ast.isExtendElement(el)) {
+      if (el.body && el.body.elements.length > 0) {
+        traverseStack.push(...el.body.elements);
+      }
+      continue;
     }
-    if ('source' in node) {
-        const source = elementRef(node.source);
-        if (!source) {
-            throw new RelationRefError('Invalid reference to source');
+    if (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);
         }
-        return {
-            source,
-            target
-        };
+      }
     }
-    if (!ast.isElementBody(node.$container)) {
-        throw new RelationRefError('Invalid relation parent, expected Element');
+    yield el;
+  }
+  for (const relation of relations) {
+    yield relation;
+  }
+}
+export function resolveRelationPoints(node) {
+  const target = elementRef(node.target);
+  if (!target) {
+    throw new RelationRefError("Invalid reference to target");
+  }
+  if ("source" in node) {
+    const source = elementRef(node.source);
+    if (!source) {
+      throw new RelationRefError("Invalid reference to source");
     }
     return {
-        source: node.$container.$container,
-        target
+      source,
+      target
     };
+  }
+  if (!ast.isElementBody(node.$container)) {
+    throw new RelationRefError("Invalid relation parent, expected Element");
+  }
+  return {
+    source: node.$container.$container,
+    target
+  };
 }
 export function toElementStyle(props) {
-    const result = {};
-    if (!props || props.length === 0) {
-        return result;
+  const result = {};
+  if (!props || props.length === 0) {
+    return result;
+  }
+  for (const prop of props) {
+    if (ast.isColorProperty(prop)) {
+      result.color = prop.value;
+      continue;
     }
-    for (const prop of props) {
-        if (ast.isColorProperty(prop)) {
-            result.color = prop.value;
-            continue;
-        }
-        if (ast.isShapeProperty(prop)) {
-            result.shape = prop.value;
-            continue;
-        }
-        if (ast.isIconProperty(prop)) {
-            result.icon = prop.value;
-            continue;
-        }
-        nonexhaustive(prop);
+    if (ast.isShapeProperty(prop)) {
+      result.shape = prop.value;
+      continue;
     }
-    return result;
+    if (ast.isIconProperty(prop)) {
+      result.icon = prop.value;
+      continue;
+    }
+    nonexhaustive(prop);
+  }
+  return result;
 }
 export function toElementStyleExcludeDefaults(props) {
-    const { color, shape, ...rest } = toElementStyle(props);
-    return {
-        ...rest,
-        ...(color && color !== DefaultThemeColor ? { color } : {}),
-        ...(shape && shape !== DefaultElementShape ? { shape } : {})
-    };
+  const { color, shape, ...rest } = toElementStyle(props);
+  return {
+    ...rest,
+    ...color && color !== DefaultThemeColor ? { color } : {},
+    ...shape && shape !== DefaultElementShape ? { shape } : {}
+  };
 }
 export function toAutoLayout(direction) {
-    switch (direction) {
-        case 'TopBottom': {
-            return 'TB';
-        }
-        case 'BottomTop': {
-            return 'BT';
-        }
-        case 'LeftRight': {
-            return 'LR';
-        }
-        case 'RightLeft': {
-            return 'RL';
-        }
+  switch (direction) {
+    case "TopBottom": {
+      return "TB";
+    }
+    case "BottomTop": {
+      return "BT";
+    }
+    case "LeftRight": {
+      return "LR";
+    }
+    case "RightLeft": {
+      return "RL";
     }
+  }
 }
-//# sourceMappingURL=ast.js.map

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): ast.Element | undefined;
+export declare function elementRef(node: ast.ElementRef | ast.StrictElementRef): any;
 /**
  * Returns FQN of strictElementRef
  * a.b.c.d - for c node returns a.b
@@ -16,4 +16,3 @@ 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/elementRef.js

@@ -1,52 +1,39 @@
-import { invariant, nonexhaustive } from '@likec4/core';
-import { ast } from './ast';
+import { invariant, nonexhaustive } from "@likec4/core";
+import { ast } from "./ast.js";
 export function isElementRefHead(node) {
-    if (ast.isElementRef(node)) {
-        return !ast.isElementRef(node.$container);
-    }
-    if (ast.isStrictElementRef(node)) {
-        return !ast.isStrictElementRef(node.$container);
-    }
-    nonexhaustive(node);
+  if (ast.isElementRef(node)) {
+    return !ast.isElementRef(node.$container);
+  }
+  if (ast.isStrictElementRef(node)) {
+    return !ast.isStrictElementRef(node.$container);
+  }
+  nonexhaustive(node);
 }
-/**
- * Returns referenced AST Element
- *
- */
 export function elementRef(node) {
-    invariant(isElementRefHead(node), 'Expected head ElementRef');
-    while (node.next) {
-        node = node.next;
-    }
-    return node.el.ref;
+  invariant(isElementRefHead(node), "Expected head ElementRef");
+  while (node.next) {
+    node = node.next;
+  }
+  return node.el.ref;
 }
-/**
- * Returns FQN of strictElementRef
- * a.b.c.d - for c node returns a.b
- */
 export function fqnElementRef(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('.');
+  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(".");
 }
-/**
- * Returns parent FQN
- * a.b.c.d - for c node returns a.b
- */
 export function parentFqnElementRef(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;
-    }
-    invariant(path.length > 0, 'Expected non-empty parent path');
-    return path.join('.');
+  invariant(!isElementRefHead(node), "Expected next StrictElementRef");
+  const path = [];
+  let parent = node.$container;
+  while (ast.isStrictElementRef(parent)) {
+    path.unshift(parent.el.$refText);
+    parent = parent.$container;
+  }
+  invariant(path.length > 0, "Expected non-empty parent path");
+  return path.join(".");
 }
-//# sourceMappingURL=elementRef.js.map

package/dist/generated/ast.d.ts

@@ -5,6 +5,9 @@
 import type { AstNode, Reference, ReferenceInfo, TypeMetaData } from 'langium';
 import { AbstractAstReflection } from 'langium';
 export declare const LikeC4Terminals: {
+    BLOCK_COMMENT: RegExp;
+    LINE_COMMENT: RegExp;
+    WS: RegExp;
     URI_WITH_SCHEMA: RegExp;
     URI_RELATIVE: RegExp;
     RARROW: RegExp;
@@ -16,12 +19,9 @@ export declare const LikeC4Terminals: {
     Colon: RegExp;
     SemiColon: RegExp;
     Comma: RegExp;
+    STRING: RegExp;
     TagID: RegExp;
     ID: RegExp;
-    STRING: RegExp;
-    WS: RegExp;
-    BLOCK_COMMENT: RegExp;
-    LINE_COMMENT: RegExp;
 };
 export type ElementExpression = ElementKindExpression | ElementRefExpression | ElementTagExpression | WildcardExpression;
 export declare const ElementExpression = "ElementExpression";
@@ -419,4 +419,3 @@ export declare class LikeC4AstReflection extends AbstractAstReflection {
     getTypeMetaData(type: string): TypeMetaData;
 }
 export declare const reflection: LikeC4AstReflection;
-//# sourceMappingURL=ast.d.ts.map