@likec4/language-server 0.37.1 → 0.40.0

package/dist/model/model-parser.d.ts

@@ -1,6 +1,5 @@
 import { type c4 } from '@likec4/core';
 import type { LangiumDocument } from 'langium';
-import { Disposable, type CancellationToken } from 'vscode-languageserver-protocol';
 import type { LikeC4LangiumDocument } from '../ast';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
@@ -8,11 +7,9 @@ export type ModelParsedListener = () => void;
 export declare class LikeC4ModelParser {
     private services;
     private fqnIndex;
-    protected readonly listeners: ModelParsedListener[];
     constructor(services: LikeC4Services);
-    onParsed(callback: ModelParsedListener): Disposable;
-    protected onValidated(docs: LangiumDocument[], cancelToken: CancellationToken): Promise<void>;
-    protected parseDocument(doc: LikeC4LangiumDocument, cancelToken: CancellationToken): Promise<void>;
+    parse(doc: LangiumDocument | LangiumDocument[]): void;
+    protected parseLikeC4Document(doc: LikeC4LangiumDocument): void;
     private parseElement;
     private parseRelation;
     private parseElementExpression;
@@ -22,6 +19,4 @@ export declare class LikeC4ModelParser {
     protected resolveFqn(node: ast.Element | ast.ExtendElement): c4.Fqn;
     private getAstNodePath;
     private convertTags;
-    private notifyListeners;
 }
-//# sourceMappingURL=model-parser.d.ts.map

package/dist/model/model-parser.js

@@ -1,309 +1,318 @@
-import { InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core';
-import { DocumentState, getDocument, interruptAndCheck } from 'langium';
-import objectHash from 'object-hash';
-import stripIndent from 'strip-indent';
-import { Disposable } from 'vscode-languageserver-protocol';
-import { ElementViewOps, ast, cleanParsedModel, isLikeC4LangiumDocument, resolveRelationPoints, streamModel, toAutoLayout, toElementStyle, toElementStyleExcludeDefaults } from '../ast';
-import { elementRef, fqnElementRef } from '../elementRef';
-import { logError, logWarnError, logger } from '../logger';
-import { printDocs } from '../utils';
+import { InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
+import { getDocument } from "langium";
+import objectHash from "object-hash";
+import stripIndent from "strip-indent";
+import {
+  ElementViewOps,
+  ast,
+  cleanParsedModel,
+  isLikeC4LangiumDocument,
+  resolveRelationPoints,
+  streamModel,
+  toAutoLayout,
+  toElementStyle,
+  toElementStyleExcludeDefaults
+} from "../ast.js";
+import { elementRef, fqnElementRef } from "../elementRef.js";
+import { logError, logWarnError, logger } from "../logger.js";
+import { printDocs } from "../utils.js";
 export class LikeC4ModelParser {
-    services;
-    fqnIndex;
-    listeners = [];
-    constructor(services) {
-        this.services = services;
-        this.fqnIndex = services.likec4.FqnIndex;
-        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Validated, async (docs, cancelToken) => await this.onValidated(docs, cancelToken));
+  constructor(services) {
+    this.services = services;
+    this.fqnIndex = services.likec4.FqnIndex;
+  }
+  fqnIndex;
+  // public onParsed(callback: ModelParsedListener): Disposable {
+  //   this.listeners.push(callback)
+  //   return Disposable.create(() => {
+  //     const index = this.listeners.indexOf(callback)
+  //     if (index >= 0) {
+  //       this.listeners.splice(index, 1)
+  //     }
+  //   })
+  // }
+  // protected async onValidated(docs: LangiumDocument[], cancelToken: CancellationToken): Promise<void> {
+  //   let countOfChangedDocs = 0
+  //   logger.debug(`[ModelParser] onValidated (${docs.length} docs)\n${printDocs(docs)}`)
+  //   for (const doc of docs) {
+  //     if (!isLikeC4LangiumDocument(doc)) {
+  //       continue
+  //     }
+  //     countOfChangedDocs++
+  //     try {
+  //       await this.parseDocument(doc, cancelToken)
+  //     } catch (cause) {
+  //       logError(new InvalidModelError(`Error parsing document ${doc.uri.toString()}`, { cause }))
+  //     }
+  //   }
+  //   if (countOfChangedDocs > 0) {
+  //     this.notifyListeners()
+  //   }
+  // }
+  parse(doc) {
+    const docs = Array.isArray(doc) ? doc : [doc];
+    logger.debug(`[ModelParser] onValidated (${docs.length} docs)
+${printDocs(docs)}`);
+    for (const doc2 of docs) {
+      if (!isLikeC4LangiumDocument(doc2)) {
+        continue;
+      }
+      try {
+        this.parseLikeC4Document(doc2);
+      } catch (cause) {
+        logError(new InvalidModelError(`Error parsing document ${doc2.uri.toString()}`, { cause }));
+      }
     }
-    onParsed(callback) {
-        this.listeners.push(callback);
-        return Disposable.create(() => {
-            const index = this.listeners.indexOf(callback);
-            if (index >= 0) {
-                this.listeners.splice(index, 1);
-            }
-        });
-    }
-    async onValidated(docs, cancelToken) {
-        let countOfChangedDocs = 0;
-        logger.debug(`[ModelParser] onValidated (${docs.length} docs)\n${printDocs(docs)}`);
-        for (const doc of docs) {
-            if (!isLikeC4LangiumDocument(doc)) {
-                continue;
-            }
-            countOfChangedDocs++;
-            try {
-                await this.parseDocument(doc, cancelToken);
-            }
-            catch (cause) {
-                logError(new InvalidModelError(`Error parsing document ${doc.uri.toString()}`, { cause }));
-            }
+  }
+  parseLikeC4Document(doc) {
+    const { elements, relations, views, specification } = cleanParsedModel(doc);
+    const specs = doc.parseResult.value.specification?.elements;
+    if (specs) {
+      for (const { kind, style } of specs) {
+        if (kind.name in specification.kinds) {
+          logger.warn(`Duplicate specification for kind ${kind.name}`);
+          continue;
         }
-        if (countOfChangedDocs > 0) {
-            this.notifyListeners();
+        try {
+          specification.kinds[kind.name] = toElementStyleExcludeDefaults(
+            style?.props
+          );
+        } catch (e) {
+          logWarnError(e);
         }
+      }
     }
-    async parseDocument(doc, cancelToken) {
-        const { elements, relations, views, specification } = cleanParsedModel(doc);
-        const specs = doc.parseResult.value.specification?.elements;
-        if (specs) {
-            for (const { kind, style } of specs) {
-                if (kind.name in specification.kinds) {
-                    logger.warn(`Duplicate specification for kind ${kind.name}`);
-                    continue;
-                }
-                try {
-                    specification.kinds[kind.name] = toElementStyleExcludeDefaults(style?.props);
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-            }
+    for (const el of streamModel(doc)) {
+      if (ast.isElement(el)) {
+        try {
+          elements.push(this.parseElement(el));
+        } catch (e) {
+          logWarnError(e);
         }
-        await interruptAndCheck(cancelToken);
-        for (const el of streamModel(doc)) {
-            if (ast.isElement(el)) {
-                try {
-                    elements.push(this.parseElement(el));
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-                continue;
-            }
-            if (ast.isRelation(el)) {
-                try {
-                    relations.push(this.parseRelation(el));
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-                continue;
-            }
-            nonexhaustive(el);
+        continue;
+      }
+      if (ast.isRelation(el)) {
+        try {
+          relations.push(this.parseRelation(el));
+        } catch (e) {
+          logWarnError(e);
         }
-        await interruptAndCheck(cancelToken);
-        const docviews = doc.parseResult.value.views?.views;
-        if (docviews) {
-            for (const view of docviews) {
-                try {
-                    const v = this.parseElementView(view);
-                    ElementViewOps.writeId(view, v.id);
-                    views.push(v);
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-            }
+        continue;
+      }
+      nonexhaustive(el);
+    }
+    const docviews = doc.parseResult.value.views?.views;
+    if (docviews) {
+      for (const view of docviews) {
+        try {
+          const v = this.parseElementView(view);
+          ElementViewOps.writeId(view, v.id);
+          views.push(v);
+        } catch (e) {
+          logWarnError(e);
         }
-        // const prevHash = doc.c4hash ?? ''
-        // doc.c4hash = c4hash(doc)
-        // return prevHash !== doc.c4hash
+      }
     }
-    parseElement(astNode) {
-        const id = this.resolveFqn(astNode);
-        invariant(astNode.kind.ref, 'Element kind is not resolved: ' + astNode.name);
-        const kind = astNode.kind.ref.name;
-        const tags = this.convertTags(astNode.body);
-        const stylePropsAst = astNode.body?.props.find(ast.isStyleProperties)?.props;
-        const styleProps = toElementStyleExcludeDefaults(stylePropsAst);
-        const astPath = this.getAstNodePath(astNode);
-        let [title, description, technology] = astNode.props;
-        const bodyProps = astNode.body?.props.filter((p) => ast.isElementStringProperty(p)) ?? [];
-        title = title ?? bodyProps.find(p => p.key === 'title')?.value;
-        description = description ?? bodyProps.find(p => p.key === 'description')?.value;
-        technology = technology ?? bodyProps.find(p => p.key === 'technology')?.value;
-        const links = astNode.body?.props.filter(ast.isLinkProperty).map(p => p.value);
-        return {
-            id,
-            kind,
-            astPath,
-            title: title ? stripIndent(title).trim() : astNode.name,
-            ...(tags && { tags }),
-            ...(links && isNonEmptyArray(links) && { links }),
-            ...(technology && { technology }),
-            ...(description && { description: stripIndent(description).trim() }),
-            ...styleProps
-        };
+  }
+  parseElement(astNode) {
+    const id = this.resolveFqn(astNode);
+    invariant(astNode.kind.ref, "Element kind is not resolved: " + astNode.name);
+    const kind = astNode.kind.ref.name;
+    const tags = this.convertTags(astNode.body);
+    const stylePropsAst = astNode.body?.props.find(ast.isStyleProperties)?.props;
+    const styleProps = toElementStyleExcludeDefaults(stylePropsAst);
+    const astPath = this.getAstNodePath(astNode);
+    let [title, description, technology] = astNode.props;
+    const bodyProps = astNode.body?.props.filter(
+      (p) => ast.isElementStringProperty(p)
+    ) ?? [];
+    title = title ?? bodyProps.find((p) => p.key === "title")?.value;
+    description = description ?? bodyProps.find((p) => p.key === "description")?.value;
+    technology = technology ?? bodyProps.find((p) => p.key === "technology")?.value;
+    const links = astNode.body?.props.filter(ast.isLinkProperty).map((p) => p.value);
+    return {
+      id,
+      kind,
+      astPath,
+      title: title ? stripIndent(title).trim() : astNode.name,
+      ...tags && { tags },
+      ...links && isNonEmptyArray(links) && { links },
+      ...technology && { technology },
+      ...description && { description: stripIndent(description).trim() },
+      ...styleProps
+    };
+  }
+  parseRelation(astNode) {
+    const coupling = resolveRelationPoints(astNode);
+    const target = this.resolveFqn(coupling.target);
+    const source = this.resolveFqn(coupling.source);
+    const hashdata = {
+      astPath: this.getAstNodePath(astNode),
+      source,
+      target
+    };
+    const id = objectHash(hashdata);
+    const title = astNode.title ?? astNode.body?.props.find((p) => p.key === "title")?.value ?? "";
+    return {
+      id,
+      ...hashdata,
+      title
+    };
+  }
+  parseElementExpression(astNode) {
+    if (ast.isWildcardExpression(astNode)) {
+      return {
+        wildcard: true
+      };
     }
-    parseRelation(astNode) {
-        const coupling = resolveRelationPoints(astNode);
-        const target = this.resolveFqn(coupling.target);
-        const source = this.resolveFqn(coupling.source);
-        const hashdata = {
-            astPath: this.getAstNodePath(astNode),
-            source,
-            target
-        };
-        const id = objectHash(hashdata);
-        const title = astNode.title ?? astNode.body?.props.find(p => p.key === 'title')?.value ?? '';
-        return {
-            id,
-            ...hashdata,
-            title
-        };
+    if (ast.isElementKindExpression(astNode)) {
+      invariant(
+        astNode.kind.ref,
+        "ElementKindExpression kind is not resolved: " + astNode.$cstNode?.text
+      );
+      return {
+        elementKind: astNode.kind.ref.name,
+        isEqual: astNode.isEqual
+      };
     }
-    parseElementExpression(astNode) {
-        if (ast.isWildcardExpression(astNode)) {
-            return {
-                wildcard: true
-            };
-        }
-        if (ast.isElementKindExpression(astNode)) {
-            invariant(astNode.kind.ref, 'ElementKindExpression kind is not resolved: ' + astNode.$cstNode?.text);
-            return {
-                elementKind: astNode.kind.ref.name,
-                isEqual: astNode.isEqual
-            };
-        }
-        if (ast.isElementTagExpression(astNode)) {
-            invariant(astNode.tag.ref, 'ElementTagExpression tag is not resolved: ' + astNode.$cstNode?.text);
-            return {
-                elementTag: astNode.tag.ref.name,
-                isEqual: astNode.isEqual
-            };
-        }
-        if (ast.isElementRefExpression(astNode)) {
-            const element = elementRef(astNode.id);
-            invariant(element, 'Element not found ' + astNode.id.$cstNode?.text);
-            return {
-                element: this.resolveFqn(element),
-                isDescedants: astNode.isDescedants
-            };
-        }
-        nonexhaustive(astNode);
+    if (ast.isElementTagExpression(astNode)) {
+      invariant(
+        astNode.tag.ref,
+        "ElementTagExpression tag is not resolved: " + astNode.$cstNode?.text
+      );
+      return {
+        elementTag: astNode.tag.ref.name,
+        isEqual: astNode.isEqual
+      };
     }
-    parseExpression(astNode) {
-        if (ast.isElementExpression(astNode)) {
-            return this.parseElementExpression(astNode);
-        }
-        if (ast.isIncomingExpression(astNode)) {
-            return {
-                incoming: this.parseElementExpression(astNode.target)
-            };
-        }
-        if (ast.isOutgoingExpression(astNode)) {
-            return {
-                outgoing: this.parseElementExpression(astNode.source)
-            };
-        }
-        if (ast.isInOutExpression(astNode)) {
-            return {
-                inout: this.parseElementExpression(astNode.inout.target)
-            };
-        }
-        if (ast.isRelationExpression(astNode)) {
-            return {
-                source: this.parseElementExpression(astNode.source),
-                target: this.parseElementExpression(astNode.target)
-            };
-        }
-        nonexhaustive(astNode);
+    if (ast.isElementRefExpression(astNode)) {
+      const element = elementRef(astNode.id);
+      invariant(element, "Element not found " + astNode.id.$cstNode?.text);
+      return {
+        element: this.resolveFqn(element),
+        isDescedants: astNode.isDescedants
+      };
     }
-    parseViewRule(astRule) {
-        if (ast.isViewRuleExpression(astRule)) {
-            const exprs = astRule.expressions.map(n => this.parseExpression(n));
-            return {
-                isInclude: astRule.isInclude,
-                exprs
-            };
-        }
-        if (ast.isViewRuleStyle(astRule)) {
-            const styleProps = toElementStyle(astRule.props);
-            return {
-                targets: astRule.targets.map(n => this.parseElementExpression(n)),
-                style: {
-                    ...styleProps
-                }
-            };
-        }
-        if (ast.isViewRuleAutoLayout(astRule)) {
-            return {
-                autoLayout: toAutoLayout(astRule.direction)
-            };
-        }
-        nonexhaustive(astRule);
+    nonexhaustive(astNode);
+  }
+  parseExpression(astNode) {
+    if (ast.isElementExpression(astNode)) {
+      return this.parseElementExpression(astNode);
     }
-    parseElementView(astNode) {
-        const body = astNode.body;
-        invariant(body, 'ElementView body is not defined');
-        const astPath = this.getAstNodePath(astNode);
-        let id = astNode.name;
-        if (!id) {
-            const doc = getDocument(astNode).uri.toString();
-            id = objectHash({
-                doc,
-                astPath
-            });
-        }
-        const title = body.props.find(p => p.key === 'title')?.value;
-        const description = body.props.find(p => p.key === 'description')?.value;
-        const tags = this.convertTags(body);
-        const links = body.props.filter(ast.isLinkProperty).map(p => p.value);
-        const basic = {
-            id: id,
-            astPath,
-            ...(title && { title }),
-            ...(description && { description }),
-            ...(tags && { tags }),
-            ...(isNonEmptyArray(links) && { links }),
-            rules: body.rules.flatMap(n => {
-                try {
-                    return this.parseViewRule(n);
-                }
-                catch (e) {
-                    logWarnError(e);
-                    return [];
-                }
-            })
-        };
-        if ('viewOf' in astNode) {
-            const viewOfEl = elementRef(astNode.viewOf);
-            const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
-            invariant(viewOf, ' viewOf is not resolved: ' + astNode.$cstNode?.text);
-            return {
-                ...basic,
-                viewOf
-            };
-        }
-        if ('extends' in astNode) {
-            const extendsView = astNode.extends.view.ref;
-            invariant(extendsView?.name, 'view extends is not resolved: ' + astNode.$cstNode?.text);
-            return {
-                ...basic,
-                extends: extendsView.name
-            };
-        }
-        return basic;
+    if (ast.isIncomingExpression(astNode)) {
+      return {
+        incoming: this.parseElementExpression(astNode.target)
+      };
     }
-    resolveFqn(node) {
-        if (ast.isExtendElement(node)) {
-            return fqnElementRef(node.element);
-        }
-        const fqn = this.fqnIndex.getFqn(node);
-        invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
-        return fqn;
+    if (ast.isOutgoingExpression(astNode)) {
+      return {
+        outgoing: this.parseElementExpression(astNode.source)
+      };
+    }
+    if (ast.isInOutExpression(astNode)) {
+      return {
+        inout: this.parseElementExpression(astNode.inout.target)
+      };
     }
-    getAstNodePath(node) {
-        return this.services.workspace.AstNodeLocator.getAstNodePath(node);
+    if (ast.isRelationExpression(astNode)) {
+      return {
+        source: this.parseElementExpression(astNode.source),
+        target: this.parseElementExpression(astNode.target)
+      };
     }
-    convertTags(withTags) {
-        if (!withTags) {
-            return null;
+    nonexhaustive(astNode);
+  }
+  parseViewRule(astRule) {
+    if (ast.isViewRuleExpression(astRule)) {
+      const exprs = astRule.expressions.map((n) => this.parseExpression(n));
+      return {
+        isInclude: astRule.isInclude,
+        exprs
+      };
+    }
+    if (ast.isViewRuleStyle(astRule)) {
+      const styleProps = toElementStyle(astRule.props);
+      return {
+        targets: astRule.targets.map((n) => this.parseElementExpression(n)),
+        style: {
+          ...styleProps
         }
-        const tags = withTags.tags?.value.flatMap(({ ref }) => (ref ? ref.name : []));
-        return tags && isNonEmptyArray(tags) ? tags : null;
+      };
+    }
+    if (ast.isViewRuleAutoLayout(astRule)) {
+      return {
+        autoLayout: toAutoLayout(astRule.direction)
+      };
+    }
+    nonexhaustive(astRule);
+  }
+  parseElementView(astNode) {
+    const body = astNode.body;
+    invariant(body, "ElementView body is not defined");
+    const astPath = this.getAstNodePath(astNode);
+    let id = astNode.name;
+    if (!id) {
+      const doc = getDocument(astNode).uri.toString();
+      id = objectHash({
+        doc,
+        astPath
+      });
     }
-    notifyListeners() {
-        for (const listener of this.listeners) {
-            try {
-                listener();
-            }
-            catch (e) {
-                logError(e);
-            }
+    const title = body.props.find((p) => p.key === "title")?.value;
+    const description = body.props.find((p) => p.key === "description")?.value;
+    const tags = this.convertTags(body);
+    const links = body.props.filter(ast.isLinkProperty).map((p) => p.value);
+    const basic = {
+      id,
+      astPath,
+      ...title && { title },
+      ...description && { description },
+      ...tags && { tags },
+      ...isNonEmptyArray(links) && { links },
+      rules: body.rules.flatMap((n) => {
+        try {
+          return this.parseViewRule(n);
+        } catch (e) {
+          logWarnError(e);
+          return [];
         }
+      })
+    };
+    if ("viewOf" in astNode) {
+      const viewOfEl = elementRef(astNode.viewOf);
+      const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
+      invariant(viewOf, " viewOf is not resolved: " + astNode.$cstNode?.text);
+      return {
+        ...basic,
+        viewOf
+      };
+    }
+    if ("extends" in astNode) {
+      const extendsView = astNode.extends.view.ref;
+      invariant(extendsView?.name, "view extends is not resolved: " + astNode.$cstNode?.text);
+      return {
+        ...basic,
+        extends: extendsView.name
+      };
+    }
+    return basic;
+  }
+  resolveFqn(node) {
+    if (ast.isExtendElement(node)) {
+      return fqnElementRef(node.element);
+    }
+    const fqn = this.fqnIndex.getFqn(node);
+    invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
+    return fqn;
+  }
+  getAstNodePath(node) {
+    return this.services.workspace.AstNodeLocator.getAstNodePath(node);
+  }
+  convertTags(withTags) {
+    if (!withTags) {
+      return null;
     }
+    const tags = withTags.tags?.value.flatMap(({ ref }) => ref ? ref.name : []);
+    return tags && isNonEmptyArray(tags) ? tags : null;
+  }
 }
-//# sourceMappingURL=model-parser.js.map

package/dist/module.d.ts

@@ -1,10 +1,13 @@
-import type { DefaultSharedModuleContext, LangiumServices, LangiumSharedServices, Module, PartialLangiumServices } from 'langium';
+import { WorkspaceCache, type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type Module, type PartialLangiumServices } from 'langium';
 import { LikeC4DocumentSymbolProvider } from './lsp';
 import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
+import { Rpc } from './Rpc';
 /**
  * Declaration of custom services - add your own service classes here.
  */
 export interface LikeC4AddedServices {
+    WorkspaceCache: WorkspaceCache<string, any>;
+    Rpc: Rpc;
     likec4: {
         FqnIndex: FqnIndex;
         ModelParser: LikeC4ModelParser;
@@ -23,4 +26,3 @@ export declare function createLanguageServices(context?: LanguageServicesContext
     likec4: LikeC4Services;
 };
 export {};
-//# sourceMappingURL=module.d.ts.map