@likec4/language-server 1.18.0 → 1.19.1

package/dist/model/fqn-computation.js

@@ -0,0 +1,72 @@
+import { AsFqn, LinkedList, nonexhaustive } from "@likec4/core";
+import { AstUtils, CstUtils, GrammarUtils, MultiMap } from "langium";
+import { isDefined, isEmpty } from "remeda";
+import { ast, ElementOps } from "../ast.js";
+import { logError } from "../logger.js";
+import { getFqnElementRef } from "../utils/elementRef.js";
+const { findNodeForProperty } = GrammarUtils;
+const { toDocumentSegment } = CstUtils;
+const { getDocument } = AstUtils;
+function toAstNodeDescription(locator, entry, doc) {
+  const $cstNode = findNodeForProperty(entry.$cstNode, "name");
+  return {
+    documentUri: doc.uri,
+    name: entry.name,
+    ...entry.$cstNode && {
+      selectionSegment: toDocumentSegment(entry.$cstNode)
+    },
+    ...$cstNode && {
+      nameSegment: toDocumentSegment($cstNode)
+    },
+    path: locator.getAstNodePath(entry),
+    type: ast.Element
+  };
+}
+export function computeDocumentFqn(document, services) {
+  const c4fqnIndex = document.c4fqnIndex = new MultiMap();
+  const elements = document.parseResult.value.models.flatMap((m) => m.elements);
+  if (elements.length === 0) {
+    return;
+  }
+  const locator = services.workspace.AstNodeLocator;
+  const traverseStack = LinkedList.from(elements.map((el) => [el, null]));
+  let pair;
+  while (pair = traverseStack.shift()) {
+    try {
+      const [el, parent] = pair;
+      if (ast.isRelation(el)) {
+        continue;
+      }
+      if (ast.isExtendElement(el)) {
+        if (isDefined(el.body) && !isEmpty(el.body.elements)) {
+          const fqn = getFqnElementRef(el.element);
+          for (const child of el.body.elements) {
+            if (!ast.isRelation(child)) {
+              traverseStack.push([child, fqn]);
+            }
+          }
+        }
+        continue;
+      }
+      if (ast.isElement(el)) {
+        const fqn = AsFqn(el.name, parent);
+        c4fqnIndex.add(fqn, {
+          ...toAstNodeDescription(locator, el, document),
+          fqn
+        });
+        ElementOps.writeId(el, fqn);
+        if (isDefined(el.body) && !isEmpty(el.body.elements)) {
+          for (const child of el.body.elements) {
+            if (!ast.isRelation(child)) {
+              traverseStack.push([child, fqn]);
+            }
+          }
+        }
+        continue;
+      }
+      nonexhaustive(el);
+    } catch (e) {
+      logError(e);
+    }
+  }
+}

package/dist/model/fqn-index.d.ts

@@ -0,0 +1,25 @@
+import type { Fqn } from '@likec4/core';
+import type { AstNodeDescription, LangiumDocuments, Stream } from 'langium';
+import type { ast, FqnIndexedDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export interface FqnIndexEntry {
+    fqn: Fqn;
+    name: string;
+    el: ast.Element;
+    doc: FqnIndexedDocument;
+    path: string;
+}
+export declare class FqnIndex {
+    private services;
+    protected langiumDocuments: LangiumDocuments;
+    constructor(services: LikeC4Services);
+    get documents(): any;
+    private entries;
+    getFqn(el: ast.Element): Fqn | null;
+    byFqn(fqn: Fqn): Stream<AstNodeDescription>;
+    directChildrenOf(parent: Fqn): Stream<AstNodeDescription>;
+    /**
+     * Returns descedant elements with unique names in the scope
+     */
+    uniqueDescedants(parent: Fqn): Stream<AstNodeDescription>;
+}

package/dist/model/fqn-index.js

@@ -0,0 +1,96 @@
+import { nameFromFqn, parentFqn } from "@likec4/core";
+import { DocumentState, DONE_RESULT, MultiMap, stream, StreamImpl } from "langium";
+import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from "../ast.js";
+import { logger, logWarnError } from "../logger.js";
+import { computeDocumentFqn } from "./fqn-computation.js";
+export class FqnIndex {
+  constructor(services) {
+    this.services = services;
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    services.shared.workspace.DocumentBuilder.onBuildPhase(
+      DocumentState.IndexedContent,
+      async (docs, _cancelToken) => {
+        for (const doc of docs) {
+          if (isLikeC4LangiumDocument(doc)) {
+            delete doc.c4fqnIndex;
+            delete doc.c4Elements;
+            delete doc.c4Specification;
+            delete doc.c4Relations;
+            delete doc.c4Views;
+            try {
+              computeDocumentFqn(doc, services);
+            } catch (e) {
+              logWarnError(e);
+            }
+          }
+        }
+        return await Promise.resolve();
+      }
+    );
+    logger.debug(`[FqnIndex] Created`);
+  }
+  langiumDocuments;
+  get documents() {
+    return this.langiumDocuments.all.filter(isFqnIndexedDocument);
+  }
+  entries(filterByFqn) {
+    return this.documents.flatMap((doc) => {
+      return doc.c4fqnIndex.keys().filter(filterByFqn).flatMap((fqn) => doc.c4fqnIndex.get(fqn));
+    });
+  }
+  getFqn(el) {
+    return ElementOps.readId(el) ?? null;
+  }
+  byFqn(fqn) {
+    return this.documents.flatMap((doc) => {
+      return doc.c4fqnIndex.get(fqn);
+    });
+  }
+  directChildrenOf(parent) {
+    return stream([parent]).flatMap((_parent) => {
+      const children = this.entries((fqn) => parentFqn(fqn) === _parent).map((entry) => [entry.name, entry]).toArray();
+      if (children.length === 0) {
+        return [];
+      }
+      return new MultiMap(children).entriesGroupedByKey().flatMap(([_name, descrs]) => descrs.length === 1 ? descrs : []).iterator();
+    });
+  }
+  /**
+   * Returns descedant elements with unique names in the scope
+   */
+  uniqueDescedants(parent) {
+    return new StreamImpl(
+      () => {
+        const prefix = `${parent}.`;
+        const childrenNames = /* @__PURE__ */ new Set();
+        const descedants = [];
+        const nested = new MultiMap();
+        this.entries((f) => f.startsWith(prefix)).forEach((e) => {
+          const name = nameFromFqn(e.fqn);
+          const entry = { ...e, name };
+          if (parentFqn(e.fqn) === parent) {
+            childrenNames.add(name);
+            nested.add(name, entry);
+          } else {
+            descedants.push(entry);
+          }
+        });
+        if (nested.size + descedants.length === 0) {
+          return null;
+        }
+        for (const descedant of descedants) {
+          if (!childrenNames.has(descedant.name)) {
+            nested.add(descedant.name, descedant);
+          }
+        }
+        return nested.entriesGroupedByKey().flatMap(([_name, descrs]) => descrs.length === 1 ? descrs : []).iterator();
+      },
+      (iterator) => {
+        if (iterator) {
+          return iterator.next();
+        }
+        return DONE_RESULT;
+      }
+    );
+  }
+}

package/dist/model/index.d.ts

@@ -0,0 +1,6 @@
+export * from './deployments-index';
+export * from './fqn-computation';
+export * from './fqn-index';
+export * from './model-builder';
+export * from './model-locator';
+export * from './model-parser';

package/dist/model/index.js

@@ -0,0 +1,6 @@
+export * from "./deployments-index.js";
+export * from "./fqn-computation.js";
+export * from "./fqn-index.js";
+export * from "./model-builder.js";
+export * from "./model-locator.js";
+export * from "./model-parser.js";

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

@@ -0,0 +1,32 @@
+import type * as c4 from '@likec4/core';
+import { type ViewId } from '@likec4/core';
+import type { Cancellation, URI } from 'langium';
+import { Disposable } from 'langium';
+import type { LikeC4Services } from '../module';
+type ModelParsedListener = (docs: URI[]) => void;
+export declare class LikeC4ModelBuilder {
+    private services;
+    private langiumDocuments;
+    private listeners;
+    constructor(services: LikeC4Services);
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncBuildModel(): c4.ParsedLikeC4Model | null;
+    buildModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ParsedLikeC4Model | null>;
+    private previousViews;
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncBuildComputedModel(model: c4.ParsedLikeC4Model): c4.ComputedLikeC4Model;
+    buildComputedModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedLikeC4Model | null>;
+    computeView(viewId: ViewId, cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedView | null>;
+    onModelParsed(callback: ModelParsedListener): Disposable;
+    private documents;
+    private notifyListeners;
+}
+export {};