@likec4/language-server 1.2.0 → 1.2.2

package/dist/model/model-builder.js

@@ -1,365 +0,0 @@
-import {
-  compareByFqnHierarchically,
-  isElementView,
-  isStrictElementView,
-  parentFqn
-} from "@likec4/core";
-import { computeDynamicView, computeView, LikeC4ModelGraph } from "@likec4/graph";
-import { deepEqual as eq } from "fast-equals";
-import { DocumentState, interruptAndCheck } from "langium";
-import {
-  filter,
-  find,
-  flatMap,
-  forEach,
-  isNullish,
-  isTruthy,
-  map,
-  mapToObj,
-  pipe,
-  prop,
-  reduce,
-  sort,
-  values
-} from "remeda";
-import { Disposable } from "vscode-languageserver";
-import { isParsedLikeC4LangiumDocument } from "../ast.js";
-import { logError, logger, logWarnError } from "../logger.js";
-import { printDocs } from "../utils/printDocs.js";
-import { assignNavigateTo, resolveRelativePaths, resolveRulesExtendedViews } from "../view-utils/index.js";
-function buildModel(services, docs) {
-  const c4Specification = {
-    kinds: {},
-    relationships: {}
-  };
-  forEach(map(docs, prop("c4Specification")), (spec) => {
-    Object.assign(c4Specification.kinds, spec.kinds);
-    Object.assign(c4Specification.relationships, spec.relationships);
-  });
-  const resolveLinks = (doc, links) => {
-    return links.map((l) => services.lsp.DocumentLinkProvider.resolveLink(doc, l));
-  };
-  const toModelElement = (doc) => {
-    return ({
-      tags,
-      links,
-      style: {
-        color,
-        shape,
-        icon,
-        opacity,
-        border
-      },
-      id,
-      kind,
-      title,
-      description,
-      technology
-    }) => {
-      try {
-        const __kind = c4Specification.kinds[kind];
-        if (!__kind) {
-          logger.warn(`No kind '${kind}' found for ${id}`);
-          return null;
-        }
-        color ??= __kind.color;
-        shape ??= __kind.shape;
-        icon ??= __kind.icon;
-        opacity ??= __kind.opacity;
-        border ??= __kind.border;
-        return {
-          ...color && { color },
-          ...shape && { shape },
-          ...icon && { icon },
-          style: {
-            ...border && { border },
-            ...opacity && { opacity }
-          },
-          links: links ? resolveLinks(doc, links) : null,
-          tags: tags ?? null,
-          technology: technology ?? null,
-          description: description ?? null,
-          title,
-          kind,
-          id
-        };
-      } catch (e) {
-        logWarnError(e);
-      }
-      return null;
-    };
-  };
-  const elements = pipe(
-    docs,
-    flatMap((d) => d.c4Elements.map(toModelElement(d))),
-    filter(isTruthy),
-    sort(compareByFqnHierarchically),
-    reduce(
-      (acc, el) => {
-        const parent = parentFqn(el.id);
-        if (parent && isNullish(acc[parent])) {
-          logWarnError(`No parent found for ${el.id}`);
-          return acc;
-        }
-        if (el.id in acc) {
-          logWarnError(`Duplicate element id: ${el.id}`);
-          return acc;
-        }
-        acc[el.id] = el;
-        return acc;
-      },
-      {}
-    )
-  );
-  const toModelRelation = (doc) => {
-    return ({
-      astPath,
-      source,
-      target,
-      kind,
-      links,
-      id,
-      ...model
-    }) => {
-      if (isNullish(elements[source]) || isNullish(elements[target])) {
-        return null;
-      }
-      if (!!kind && kind in c4Specification.relationships) {
-        return {
-          ...links && { links: resolveLinks(doc, links) },
-          ...c4Specification.relationships[kind],
-          ...model,
-          source,
-          target,
-          kind,
-          id
-        };
-      }
-      return {
-        ...links && { links: resolveLinks(doc, links) },
-        ...model,
-        source,
-        target,
-        id
-      };
-    };
-  };
-  const relations = pipe(
-    flatMap(docs, (d) => map(d.c4Relations, toModelRelation(d))),
-    filter(isTruthy),
-    mapToObj((r) => [r.id, r])
-  );
-  const toC4View = (doc) => {
-    const docUri = doc.uri.toString();
-    return (parsedAstView) => {
-      let {
-        id,
-        title,
-        description,
-        tags,
-        links,
-        // ignore this property
-        astPath: _ignore,
-        // model should include discriminant __
-        ...model
-      } = parsedAstView;
-      if (parsedAstView.__ === "element" && isNullish(title) && "viewOf" in parsedAstView) {
-        title ??= elements[parsedAstView.viewOf]?.title ?? null;
-      }
-      if (isNullish(title) && id === "index") {
-        title = "Landscape view";
-      }
-      return {
-        id,
-        title,
-        description,
-        tags,
-        links: links ? resolveLinks(doc, links) : null,
-        docUri,
-        ...model
-      };
-    };
-  };
-  const views = pipe(
-    docs,
-    flatMap((d) => map(d.c4Views, toC4View(d))),
-    resolveRelativePaths,
-    mapToObj((v) => [v.id, v]),
-    resolveRulesExtendedViews
-  );
-  if (!("index" in views)) {
-    views["index"] = {
-      __: "element",
-      id: "index",
-      title: "Landscape",
-      description: null,
-      tags: null,
-      links: null,
-      rules: [
-        {
-          include: [
-            {
-              wildcard: true
-            }
-          ]
-        }
-      ]
-    };
-  }
-  return {
-    elements,
-    relations,
-    views
-  };
-}
-const RAW_MODEL_CACHE = "LikeC4RawModel";
-const MODEL_CACHE = "LikeC4Model";
-export class LikeC4ModelBuilder {
-  constructor(services) {
-    this.services = services;
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-    const parser = services.likec4.ModelParser;
-    services.shared.workspace.DocumentBuilder.onUpdate((changed, deleted) => {
-      if (deleted.length > 0) {
-        this.notifyListeners(deleted);
-      }
-    });
-    services.shared.workspace.DocumentBuilder.onBuildPhase(
-      DocumentState.Validated,
-      async (docs, _cancelToken) => {
-        let parsed = [];
-        logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)
-${printDocs(docs)}`);
-        for (const doc of parser.parse(docs)) {
-          parsed.push(doc.uri);
-        }
-        if (parsed.length > 0) {
-          this.notifyListeners(parsed);
-        }
-        return await Promise.resolve();
-      }
-    );
-    logger.debug(`[ModelBuilder] Created`);
-  }
-  langiumDocuments;
-  listeners = [];
-  async buildModel(cancelToken) {
-    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
-      if (cancelToken) {
-        await interruptAndCheck(cancelToken);
-      }
-      const cache = this.services.WorkspaceCache;
-      return cache.get(RAW_MODEL_CACHE, () => {
-        const docs = this.documents();
-        if (docs.length === 0) {
-          logger.debug("[ModelBuilder] No documents to build model from");
-          return null;
-        }
-        logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:
-${printDocs(docs)}`);
-        return buildModel(this.services, docs);
-      });
-    });
-  }
-  previousViews = {};
-  async buildComputedModel(cancelToken) {
-    const model = await this.buildModel(cancelToken);
-    if (!model) {
-      return null;
-    }
-    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
-      if (cancelToken) {
-        await interruptAndCheck(cancelToken);
-      }
-      const cache = this.services.WorkspaceCache;
-      const viewsCache = this.services.WorkspaceCache;
-      return cache.get(MODEL_CACHE, () => {
-        const index = new LikeC4ModelGraph(model);
-        const allViews = [];
-        for (const view of values(model.views)) {
-          const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index);
-          if (!result.isSuccess) {
-            logWarnError(result.error);
-            continue;
-          }
-          allViews.push(result.view);
-        }
-        assignNavigateTo(allViews);
-        const views = mapToObj(allViews, (v) => {
-          const previous = this.previousViews[v.id];
-          const view = previous && eq(v, previous) ? previous : v;
-          viewsCache.set(computedViewKey(v.id), view);
-          return [v.id, view];
-        });
-        this.previousViews = { ...views };
-        return {
-          elements: model.elements,
-          relations: model.relations,
-          views
-        };
-      });
-    });
-  }
-  async computeView(viewId, cancelToken) {
-    const model = await this.buildModel(cancelToken);
-    const view = model?.views[viewId];
-    if (!view) {
-      logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
-      return null;
-    }
-    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
-      if (cancelToken) {
-        await interruptAndCheck(cancelToken);
-      }
-      const cache = this.services.WorkspaceCache;
-      return cache.get(computedViewKey(viewId), () => {
-        const index = new LikeC4ModelGraph(model);
-        const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index);
-        if (!result.isSuccess) {
-          logError(result.error);
-          return null;
-        }
-        const allElementViews = values(model.views).filter(
-          (v) => isStrictElementView(v) && v.id !== viewId
-        );
-        let computedView = result.view;
-        computedView.nodes.forEach((node) => {
-          if (!node.navigateTo) {
-            const navigateTo = find(allElementViews, (v) => v.viewOf === node.id);
-            if (navigateTo) {
-              node.navigateTo = navigateTo.id;
-            }
-          }
-        });
-        const previous = this.previousViews[viewId];
-        computedView = previous && eq(computedView, previous) ? previous : computedView;
-        this.previousViews[viewId] = computedView;
-        return computedView;
-      });
-    });
-  }
-  onModelParsed(callback) {
-    this.listeners.push(callback);
-    return Disposable.create(() => {
-      const index = this.listeners.indexOf(callback);
-      if (index >= 0) {
-        this.listeners.splice(index, 1);
-      }
-    });
-  }
-  documents() {
-    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument).toArray();
-  }
-  notifyListeners(docs) {
-    for (const listener of this.listeners) {
-      try {
-        listener(docs);
-      } catch (e) {
-        logError(e);
-      }
-    }
-  }
-}
-function computedViewKey(viewId) {
-  return `computed-view-${viewId}`;
-}

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

@@ -1,22 +0,0 @@
-import type { likec4 as c4 } from '@likec4/core';
-import type { Location } from 'vscode-languageserver-protocol';
-import type { ParsedAstElement } from '../ast';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4ModelLocator {
-    private services;
-    private fqnIndex;
-    private langiumDocuments;
-    constructor(services: LikeC4Services);
-    private documents;
-    getParsedElement(astNode: ast.Element): ParsedAstElement | null;
-    locateElement(fqn: c4.Fqn, property?: string): Location | null;
-    locateRelation(relationId: c4.RelationID): Location | null;
-    locateViewAst(viewId: c4.ViewID): {
-        doc: import("../ast").ParsedLikeC4LangiumDocument;
-        view: import("../ast").ParsedAstView;
-        viewAst: ast.LikeC4View;
-    } | null;
-    locateView(viewId: c4.ViewID): Location | null;
-}
-//# sourceMappingURL=model-locator.d.ts.map

package/dist/model/model-locator.js

@@ -1,115 +0,0 @@
-import { AstUtils, GrammarUtils } from "langium";
-import { ast, isParsedLikeC4LangiumDocument } from "../ast.js";
-const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
-const { getDocument } = AstUtils;
-export class LikeC4ModelLocator {
-  constructor(services) {
-    this.services = services;
-    this.fqnIndex = services.likec4.FqnIndex;
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-  }
-  fqnIndex;
-  langiumDocuments;
-  documents() {
-    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument);
-  }
-  getParsedElement(astNode) {
-    const fqn = this.fqnIndex.getFqn(astNode);
-    if (!fqn)
-      return null;
-    const doc = getDocument(astNode);
-    if (!isParsedLikeC4LangiumDocument(doc)) {
-      return null;
-    }
-    return doc.c4Elements.find((e) => e.id === fqn) ?? null;
-  }
-  locateElement(fqn, property = "name") {
-    const entry = this.fqnIndex.byFqn(fqn).head();
-    if (!entry) {
-      return null;
-    }
-    const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode;
-    if (!propertyNode) {
-      return null;
-    }
-    return {
-      uri: entry.doc.uri.toString(),
-      range: propertyNode.range
-    };
-  }
-  locateRelation(relationId) {
-    for (const doc of this.documents()) {
-      const relation = doc.c4Relations.find((r) => r.id === relationId);
-      if (!relation) {
-        continue;
-      }
-      const node = this.services.workspace.AstNodeLocator.getAstNode(
-        doc.parseResult.value,
-        relation.astPath
-      );
-      if (!ast.isRelation(node)) {
-        continue;
-      }
-      if (node.title) {
-        const targetNode2 = findNodeForProperty(node.$cstNode, "title");
-        if (targetNode2) {
-          return {
-            uri: doc.uri.toString(),
-            range: targetNode2.range
-          };
-        }
-      }
-      let targetNode = node.kind ? findNodeForProperty(node.$cstNode, "kind") : findNodeForKeyword(node.$cstNode, "->");
-      targetNode ??= findNodeForProperty(node.$cstNode, "target");
-      if (!targetNode) {
-        return null;
-      }
-      return {
-        uri: doc.uri.toString(),
-        range: targetNode.range
-      };
-    }
-    return null;
-  }
-  locateViewAst(viewId) {
-    for (const doc of this.documents()) {
-      const view = doc.c4Views.find((r) => r.id === viewId);
-      if (!view) {
-        continue;
-      }
-      const viewAst = this.services.workspace.AstNodeLocator.getAstNode(
-        doc.parseResult.value,
-        view.astPath
-      );
-      if (ast.isLikeC4View(viewAst)) {
-        return {
-          doc,
-          view,
-          viewAst
-        };
-      }
-    }
-    return null;
-  }
-  locateView(viewId) {
-    const res = this.locateViewAst(viewId);
-    if (!res) {
-      return null;
-    }
-    const node = res.viewAst;
-    let targetNode = node.$cstNode;
-    if (node.name) {
-      targetNode = findNodeForProperty(node.$cstNode, "name") ?? targetNode;
-    } else if ("viewOf" in node) {
-      targetNode = findNodeForProperty(node.$cstNode, "viewOf") ?? targetNode;
-    }
-    targetNode ??= findNodeForKeyword(node.$cstNode, "view");
-    if (!targetNode) {
-      return null;
-    }
-    return {
-      uri: res.doc.uri.toString(),
-      range: targetNode.range
-    };
-  }
-}

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

@@ -1,29 +0,0 @@
-import { type c4 } from '@likec4/core';
-import type { LangiumDocument } from 'langium';
-import type { FqnIndexedDocument, ParsedLikeC4LangiumDocument } from '../ast';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export type ModelParsedListener = () => void;
-export declare class LikeC4ModelParser {
-    private services;
-    private fqnIndex;
-    constructor(services: LikeC4Services);
-    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
-    protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
-    private parseSpecification;
-    private parseModel;
-    private parseElement;
-    private parseRelation;
-    private parseViews;
-    private parseElementExpr;
-    private parseCustomElementExpr;
-    private parsePredicateExpr;
-    private parseViewRule;
-    private parseDynamicStep;
-    private parseElementView;
-    private parseDynamicElementView;
-    protected resolveFqn(node: ast.Element | ast.ExtendElement): c4.Fqn;
-    private getAstNodePath;
-    private convertTags;
-}
-//# sourceMappingURL=model-parser.d.ts.map