@likec4/language-server 1.18.0 → 1.19.0

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 {};