@likec4/language-server 1.42.1 → 1.44.0

package/dist/validation/view-predicates/relation-expr.mjs

@@ -1,39 +0,0 @@
-import { FqnExpr, RelationExpr } from "@likec4/core";
-import { AstUtils } from "langium";
-import { ast } from "../../ast.mjs";
-import { tryOrLog } from "../_shared.mjs";
-export const checkRelationExpr = (services) => {
-  const ModelParser = services.likec4.ModelParser;
-  return tryOrLog((node, accept) => {
-    const predicate = AstUtils.getContainerOfType(node, ast.isDeploymentViewRulePredicate);
-    if (!predicate || predicate.isInclude !== true) {
-      return;
-    }
-    const doc = AstUtils.getDocument(node);
-    const parser = ModelParser.forDocument(doc);
-    let relationExpr = RelationExpr.unwrap(parser.parseRelationExpr(node));
-    const ModelRefOnlyExclude = "Model reference is allowed in exclude predicate only";
-    if (RelationExpr.isDirect(relationExpr)) {
-      if (FqnExpr.isModelRef(relationExpr.source) || FqnExpr.isModelRef(relationExpr.target)) {
-        accept("error", ModelRefOnlyExclude, {
-          node
-        });
-      }
-      return;
-    }
-    let expr;
-    if (RelationExpr.isIncoming(relationExpr)) {
-      expr = relationExpr.incoming;
-    } else if (RelationExpr.isOutgoing(relationExpr)) {
-      expr = relationExpr.outgoing;
-    } else {
-      expr = relationExpr.inout;
-    }
-    if (FqnExpr.isModelRef(expr)) {
-      accept("error", ModelRefOnlyExclude, {
-        node
-      });
-      return;
-    }
-  });
-};

package/dist/validation/view-predicates/relation-with.mjs

@@ -1,16 +0,0 @@
-import { getViewRulePredicateContainer } from "../../ast.mjs";
-import { tryOrLog } from "../_shared.mjs";
-export const checkRelationExprWith = (_services) => {
-  return tryOrLog((el, accept) => {
-    const container = getViewRulePredicateContainer(el);
-    if (!container || container.$type == "DynamicViewIncludePredicate") {
-      return;
-    }
-    if (!container.isInclude) {
-      accept("error", 'Invalid usage inside "exclude"', {
-        node: el
-      });
-      return;
-    }
-  });
-};

package/dist/validation/view.mjs

@@ -1,25 +0,0 @@
-import { ast } from "../ast.mjs";
-import { projectIdFrom } from "../utils/index.mjs";
-import { RESERVED_WORDS, tryOrLog } from "./_shared.mjs";
-export const viewChecks = (services) => {
-  const index = services.shared.workspace.IndexManager;
-  return tryOrLog((node, accept) => {
-    if (!node.name) {
-      return;
-    }
-    if (RESERVED_WORDS.includes(node.name)) {
-      accept("error", `Reserved word: ${node.name}`, {
-        node,
-        property: "name"
-      });
-    }
-    const projectId = projectIdFrom(node);
-    const anotherViews = index.projectElements(projectId, ast.LikeC4View).filter((n) => n.name === node.name).limit(2).count();
-    if (anotherViews > 1) {
-      accept("error", `Duplicate view '${node.name}'`, {
-        node,
-        property: "name"
-      });
-    }
-  });
-};

package/dist/view-utils/assignNavigateTo.mjs

@@ -1,25 +0,0 @@
-import { isElementView } from "@likec4/core";
-import { find, isNullish } from "remeda";
-export function assignNavigateTo(views) {
-  const allElementViews = /* @__PURE__ */ new Map();
-  for (const v of views) {
-    if (isElementView(v) && v.viewOf && isNullish(v.extends)) {
-      const viewsOf = allElementViews.get(v.viewOf) ?? [];
-      viewsOf.push(v.id);
-      allElementViews.set(v.viewOf, viewsOf);
-    }
-  }
-  for (const { id, nodes } of views) {
-    for (const node of nodes) {
-      const modelRef = node.modelRef;
-      if (node.navigateTo || !modelRef) {
-        continue;
-      }
-      const navigateTo = find(allElementViews.get(modelRef) ?? [], (v) => v !== id);
-      if (navigateTo) {
-        node.navigateTo = navigateTo;
-      }
-    }
-  }
-  return views;
-}

package/dist/view-utils/index.mjs

@@ -1 +0,0 @@
-export * from "./assignNavigateTo.mjs";

package/dist/view-utils/manual-layout.mjs

@@ -1,99 +0,0 @@
-import { isAutoLayoutDirection } from "@likec4/core";
-import { decode, encode } from "@msgpack/msgpack";
-import { fromBase64, toBase64 } from "@smithy/util-base64";
-import { AstUtils, CstUtils } from "langium";
-import { mapValues } from "remeda";
-import { logger, logWarnError } from "../logger.mjs";
-const { getDocument } = AstUtils;
-function pack({
-  nodes,
-  edges,
-  ...rest
-}) {
-  return {
-    ...rest,
-    nodes: mapValues(nodes, ({ x, y, width, height, isCompound, ...n }) => ({
-      ...n,
-      b: [x, y, width, height],
-      c: isCompound
-    })),
-    edges: mapValues(edges, ({ points, controlPoints, labelBBox, dotpos, ...e }) => ({
-      ...!!controlPoints && { cp: controlPoints },
-      ...!!labelBBox && { l: labelBBox },
-      ...!!dotpos && { dp: dotpos },
-      ...e,
-      p: points
-    }))
-  };
-}
-function unpack({
-  nodes,
-  edges,
-  autoLayout,
-  ...rest
-}) {
-  return {
-    ...rest,
-    /// Try to parse the old format for backward compatibility
-    autoLayout: isAutoLayoutDirection(autoLayout) ? { direction: autoLayout } : autoLayout,
-    nodes: mapValues(nodes, ({ b, c, ...n }) => ({
-      x: b[0],
-      y: b[1],
-      width: b[2],
-      height: b[3],
-      isCompound: c,
-      ...n
-    })),
-    edges: mapValues(edges, ({ p, cp, l, dp, ...e }) => ({
-      ...!!cp && { controlPoints: cp },
-      ...!!l && { labelBBox: l },
-      ...!!dp && { dotpos: dp },
-      ...e,
-      points: p
-    }))
-  };
-}
-const MAX_LINE_LENGTH = 500;
-export function serializeToComment(layout) {
-  const bytes = encode(pack(layout));
-  const base64 = toBase64(bytes);
-  const lines = [];
-  let offset = 0;
-  while (offset < base64.length) {
-    lines.push(" * " + base64.slice(offset, Math.min(offset + MAX_LINE_LENGTH, base64.length)));
-    offset += MAX_LINE_LENGTH;
-  }
-  lines.unshift(
-    "/**",
-    " * @likec4-generated(v1)"
-  );
-  lines.push(" */");
-  return lines.join("\n");
-}
-export function hasManualLayout(comment) {
-  return comment.includes("@likec4-generated");
-}
-export function deserializeFromComment(comment) {
-  if (!hasManualLayout(comment)) {
-    throw new Error(`Not a likec4-generated comment: ${comment}`);
-  }
-  const b64 = comment.trim().split("\n").filter((l) => !l.includes("**") && !l.includes("@likec4-") && !l.includes("*/")).map((l) => l.replaceAll("*", "").trim()).join("");
-  const decodedb64 = fromBase64(b64);
-  return unpack(decode(decodedb64));
-}
-export function parseViewManualLayout(node) {
-  const commentNode = CstUtils.findCommentNode(node.$cstNode, ["BLOCK_COMMENT"]);
-  if (!commentNode || !hasManualLayout(commentNode.text)) {
-    return void 0;
-  }
-  try {
-    return deserializeFromComment(commentNode.text);
-  } catch (e) {
-    const doc = getDocument(node);
-    logWarnError(e);
-    logger.warn(
-      `Ignoring manual layout of "${node.name ?? "unnamed"}" at ${doc.uri.fsPath}:${1 + (commentNode.range.start.line || 0)}`
-    );
-    return void 0;
-  }
-}

package/dist/views/configurable-layouter.mjs

@@ -1,51 +0,0 @@
-import { GraphvizWasmAdapter, QueueGraphvizLayoter } from "@likec4/layouts";
-import { GraphvizBinaryAdapter } from "@likec4/layouts/graphviz/binary";
-import { isEmpty } from "remeda";
-import which from "which";
-import { logger } from "../logger.mjs";
-function graphvizBinPath() {
-  try {
-    return which.sync("dot");
-  } catch (error) {
-    logger.error("Error checking for native Graphviz:", { error });
-    return null;
-  }
-}
-export const ConfigurableLayouter = {
-  likec4: {
-    Layouter(services) {
-      logger.debug("Creating ConfigurableLayouter");
-      const layouter = new QueueGraphvizLayoter();
-      services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
-        logger.debug("Configuration update: {update}", { update });
-        if (update.section !== services.LanguageMetaData.languageId) {
-          logger.debug(`Ignoring configuration update as it is not for ${services.LanguageMetaData.languageId}`);
-          return;
-        }
-        try {
-          const { mode, path } = update.configuration.graphviz ?? {
-            mode: "wasm",
-            path: ""
-          };
-          if (mode !== "wasm") {
-            let binaryPath = isEmpty(path) ? graphvizBinPath() : path;
-            if (!isEmpty(binaryPath)) {
-              layouter.changePort(new GraphvizBinaryAdapter(binaryPath));
-              logger.info`use graphviz binary: ${binaryPath}`;
-              return;
-            }
-            logger.warn(`No Graphviz binaries found on PATH, use graphviz wasm`);
-            services.shared.lsp.Connection?.window.showWarningMessage(
-              "No Graphviz binaries found on PATH, set path to binaries in settings."
-            );
-          }
-          layouter.changePort(new GraphvizWasmAdapter());
-          logger.info("use graphviz wasm");
-        } catch (error) {
-          logger.error("Failed to update configuration", { error });
-        }
-      });
-      return layouter;
-    }
-  }
-};

package/dist/views/index.mjs

@@ -1 +0,0 @@
-export { DefaultLikeC4Views } from "./likec4-views.mjs";

package/dist/views/likec4-views.mjs

@@ -1,166 +0,0 @@
-import { loggable } from "@likec4/log";
-import { values } from "remeda";
-import { logger as rootLogger, logWarnError } from "../logger.mjs";
-import { performanceMark } from "../utils/index.mjs";
-const viewsLogger = rootLogger.getChild("views");
-export class DefaultLikeC4Views {
-  constructor(services) {
-    this.services = services;
-    this.ModelBuilder = services.likec4.ModelBuilder;
-  }
-  cache = /* @__PURE__ */ new WeakMap();
-  /**
-   * Set of viewIds with reported errors
-   * value is `${projectId}-${viewId}`
-   */
-  viewsWithReportedErrors = /* @__PURE__ */ new Set();
-  ModelBuilder;
-  get layouter() {
-    return this.services.likec4.Layouter;
-  }
-  async computedViews(projectId, cancelToken) {
-    const likeC4Model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
-    return values(likeC4Model.$data.views);
-  }
-  async layoutAllViews(projectId, cancelToken) {
-    const likeC4Model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
-    const views = values(likeC4Model.$data.views);
-    if (views.length === 0) {
-      return [];
-    }
-    const m0 = performanceMark();
-    projectId ??= likeC4Model.project.id;
-    const logger = viewsLogger.getChild(projectId);
-    logger.debug`layoutAll: ${views.length} views`;
-    const tasks = [];
-    const styles = likeC4Model.$styles;
-    const results = [];
-    for (const view of views) {
-      let cached = this.cache.get(view);
-      if (cached) {
-        logger.debug`layout ${view.id} from cache`;
-        results.push(cached);
-        continue;
-      }
-      tasks.push({
-        view,
-        styles
-      });
-    }
-    if (tasks.length > 0) {
-      await this.layouter.batchLayout({
-        batch: tasks,
-        onSuccess: (task, result) => {
-          this.viewSucceed(task.view, projectId, result);
-          results.push(result);
-        },
-        onError: (task, error) => {
-          logger.warn(`Fail layout view ${task.view.id}`, { error });
-        }
-      });
-    }
-    if (results.length !== views.length) {
-      logger.warn`layouted ${results.length} of ${views.length} views in ${m0.pretty}`;
-    } else if (results.length > 0) {
-      logger.debug`layouted all ${results.length} views in ${m0.pretty}`;
-    }
-    return results;
-  }
-  async layoutView(viewId, projectId, cancelToken) {
-    const model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
-    const view = model.findView(viewId)?.$view;
-    projectId ??= model.project.id;
-    const logger = viewsLogger.getChild(projectId);
-    if (!view) {
-      logger.warn`layoutView ${viewId} not found`;
-      return null;
-    }
-    let cached = this.cache.get(view);
-    if (cached) {
-      logger.debug`layout ${viewId} from cache`;
-      return await Promise.resolve().then(() => cached);
-    }
-    try {
-      const m0 = performanceMark();
-      const result = await this.layouter.layout({
-        view,
-        styles: model.$styles
-      });
-      this.viewSucceed(view, projectId, result);
-      logger.debug(`layout {viewId} ready in ${m0.pretty}`, { viewId });
-      return result;
-    } catch (e) {
-      const errMessage = loggable(e);
-      logger.warn(errMessage);
-      this.reportViewError(view, projectId, errMessage);
-      return Promise.reject(e);
-    }
-  }
-  async diagrams(projectId, cancelToken) {
-    const layouted = await this.layoutAllViews(projectId, cancelToken);
-    return layouted.map((l) => l.diagram);
-  }
-  async viewsAsGraphvizOut(projectId, cancelToken) {
-    const KEY = "All-LayoutedViews-DotWithSvg";
-    const cache = this.services.ValidatedWorkspaceCache;
-    if (cache.has(KEY)) {
-      return await Promise.resolve(cache.get(KEY));
-    }
-    const likeC4Model = await this.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
-    const views = values(likeC4Model.$data.views);
-    if (views.length === 0) {
-      return [];
-    }
-    const tasks = views.map(async (view) => {
-      const { dot, svg } = await this.layouter.svg({
-        view,
-        styles: likeC4Model.$styles
-      });
-      return {
-        id: view.id,
-        dot,
-        svg
-      };
-    });
-    const succeed = [];
-    const settledResult = await Promise.allSettled(tasks);
-    for (const result of settledResult) {
-      if (result.status === "fulfilled") {
-        succeed.push(result.value);
-      } else {
-        logWarnError(result.reason);
-      }
-    }
-    cache.set(KEY, succeed);
-    return succeed;
-  }
-  /**
-   * Open a view in the preview panel.
-   */
-  async openView(viewId, projectId) {
-    await this.services.Rpc.openView({ viewId, projectId });
-  }
-  reportViewError(view, projectId, error) {
-    const key = `${projectId}-${view.id}`;
-    if (!this.viewsWithReportedErrors.has(key)) {
-      this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${error}`);
-      this.viewsWithReportedErrors.add(key);
-    }
-  }
-  viewSucceed(view, projectId, result) {
-    const key = `${projectId}-${view.id}`;
-    this.viewsWithReportedErrors.delete(key);
-    this.cache.set(view, result);
-  }
-  // async overviewGraph(): Promise<OverviewGraph> {
-  //   const KEY = 'OverviewGraph'
-  //   const cache = this.services.ValidatedWorkspaceCache as WorkspaceCache<string, OverviewGraph>
-  //   if (cache.has(KEY)) {
-  //     return await Promise.resolve(cache.get(KEY)!)
-  //   }
-  //   const views = await this.computedViews()
-  //   const overviewGraph = await this.layouter.layoutOverviewGraph(views)
-  //   cache.set(KEY, overviewGraph)
-  //   return overviewGraph
-  // }
-}

package/dist/workspace/AstNodeDescriptionProvider.mjs

@@ -1,17 +0,0 @@
-import {
-  AstUtils,
-  DefaultAstNodeDescriptionProvider
-} from "langium";
-export class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
-  constructor(services) {
-    super(services);
-    this.services = services;
-  }
-  createDescription(node, name, document) {
-    const doc = document ?? AstUtils.getDocument(node);
-    const description = super.createDescription(node, name, document);
-    doc.likec4ProjectId ??= this.services.shared.workspace.ProjectsManager.belongsTo(doc.uri);
-    description.likec4ProjectId = doc.likec4ProjectId;
-    return description;
-  }
-}

package/dist/workspace/IndexManager.mjs

@@ -1,17 +0,0 @@
-import { DefaultIndexManager, stream } from "langium";
-export class IndexManager extends DefaultIndexManager {
-  constructor(services) {
-    super(services);
-    this.services = services;
-  }
-  async updateContent(document, cancelToken) {
-    const projects = this.services.workspace.ProjectsManager;
-    document.likec4ProjectId = projects.belongsTo(document.uri);
-    await super.updateContent(document, cancelToken);
-  }
-  projectElements(projectId, nodeType, uris) {
-    const projects = this.services.workspace.ProjectsManager;
-    let documentUris = stream(this.symbolIndex.keys());
-    return documentUris.filter((uri) => projects.belongsTo(uri) === projectId && (!uris || uris.has(uri))).flatMap((uri) => this.getFileDescriptions(uri, nodeType));
-  }
-}

package/dist/workspace/LangiumDocuments.mjs

@@ -1,53 +0,0 @@
-import { compareNaturalHierarchically } from "@likec4/core/utils";
-import { DefaultLangiumDocuments } from "langium";
-import { groupBy, prop } from "remeda";
-import { isLikeC4LangiumDocument } from "../ast.mjs";
-import { isLikeC4Builtin } from "../likec4lib.mjs";
-const compare = compareNaturalHierarchically("/", true);
-const ensureOrder = (a, b) => compare(a.uri.path, b.uri.path);
-export class LangiumDocuments extends DefaultLangiumDocuments {
-  constructor(services) {
-    super(services);
-    this.services = services;
-  }
-  compare = compareNaturalHierarchically("/", true);
-  addDocument(document) {
-    const uriString = document.uri.toString();
-    if (this.documentMap.has(uriString)) {
-      throw new Error(`A document with the URI '${uriString}' is already present.`);
-    }
-    const docs = [...this.documentMap.values(), document].sort(ensureOrder);
-    this.documentMap.clear();
-    for (const doc of docs) {
-      this.documentMap.set(doc.uri.toString(), doc);
-    }
-  }
-  /**
-   * Returns all user documents, excluding built-in documents.
-   */
-  get allExcludingBuiltin() {
-    const projects = this.services.workspace.ProjectsManager;
-    return super.all.filter((doc) => {
-      if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri) || projects.checkIfExcluded(doc)) {
-        return false;
-      }
-      doc.likec4ProjectId = projects.belongsTo(doc.uri);
-      return true;
-    });
-  }
-  projectDocuments(projectId) {
-    return this.allExcludingBuiltin.filter((doc) => doc.likec4ProjectId === projectId);
-  }
-  groupedByProject() {
-    return groupBy(this.allExcludingBuiltin.toArray(), prop("likec4ProjectId"));
-  }
-  resetProjectIds() {
-    const projects = this.services.workspace.ProjectsManager;
-    this.all.forEach((doc) => {
-      if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
-        return;
-      }
-      doc.likec4ProjectId = projects.belongsTo(doc);
-    });
-  }
-}