@likec4/language-server 1.43.0 → 1.45.0

package/dist/Rpc.mjs

@@ -1,296 +0,0 @@
-import { filter, flatMap, funnel, indexBy, keys, map, mapValues, pipe, sort } from "remeda";
-import { logger as rootLogger } from "./logger.mjs";
-import { serializableLikeC4ProjectConfig } from "@likec4/config";
-import {
-  invariant,
-  nonexhaustive
-} from "@likec4/core";
-import { LikeC4Model } from "@likec4/core/model";
-import { Disposable, interruptAndCheck, URI, UriUtils } from "langium";
-import { DiagnosticSeverity } from "vscode-languageserver-protocol";
-import {
-  BuildDocuments,
-  ChangeView,
-  ComputeView,
-  DidChangeModelNotification,
-  DidRequestOpenViewNotification,
-  FetchComputedModel,
-  FetchLayoutedModel,
-  FetchProjects,
-  FetchTelemetryMetrics,
-  FetchViewsFromAllProjects,
-  GetDocumentTags,
-  LayoutView,
-  Locate,
-  RegisterProject,
-  ReloadProjects,
-  ValidateLayout
-} from "./protocol.mjs";
-import { ADisposable } from "./utils/index.mjs";
-const logger = rootLogger.getChild("rpc");
-export class Rpc extends ADisposable {
-  constructor(services) {
-    super();
-    this.services = services;
-  }
-  init() {
-    const connection = this.services.shared.lsp.Connection;
-    if (!connection) {
-      logger.info(`[ServerRpc] no connection, not initializing`);
-      return;
-    }
-    logger.info(`[ServerRpc] init`);
-    const likec4Services = this.services.likec4;
-    const projects = this.services.shared.workspace.ProjectsManager;
-    const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
-    const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
-    const notifyModelParsed = funnel(
-      () => {
-        logger.debug`sendNotification ${"onDidChangeModel"}`;
-        connection.sendNotification(DidChangeModelNotification.type, "").catch((error) => {
-          logger.warn(`[ServerRpc] error sending onDidChangeModel:`, { error });
-          return;
-        });
-      },
-      {
-        triggerAt: "end",
-        minQuietPeriodMs: 150,
-        maxBurstDurationMs: 500,
-        minGapMs: 300
-      }
-    );
-    let isFirstBuild = true;
-    this.onDispose(
-      likec4Services.ModelBuilder.onModelParsed(() => notifyModelParsed.call()),
-      connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
-        logger.debug`received request ${"fetchComputedModel"} for project ${projectId}`;
-        if (cleanCaches) {
-          const docs = projectId ? LangiumDocuments.projectDocuments(projectId) : LangiumDocuments.allExcludingBuiltin;
-          const uris = docs.toArray().map((d) => d.uri);
-          await DocumentBuilder.update(uris, [], cancelToken);
-        }
-        const likec4model = await likec4Services.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
-        if (likec4model !== LikeC4Model.EMPTY) {
-          return { model: likec4model.$model };
-        }
-        return { model: null };
-      }),
-      connection.onRequest(ComputeView.req, async ({ viewId, projectId }, cancelToken) => {
-        const view = await likec4Services.ModelBuilder.computeView(viewId, projectId, cancelToken);
-        return { view };
-      }),
-      connection.onRequest(FetchLayoutedModel.req, async ({ projectId }, cancelToken) => {
-        const model = await likec4Services.ModelBuilder.parseModel(projectId, cancelToken);
-        if (model === null) {
-          return { model: null };
-        }
-        const diagrams = await likec4Services.Views.diagrams(projectId, cancelToken);
-        return {
-          model: {
-            ...model.$data,
-            _stage: "layouted",
-            views: indexBy(diagrams, (d) => d.id)
-          }
-        };
-      }),
-      connection.onRequest(LayoutView.req, async ({ viewId, projectId }, cancelToken) => {
-        logger.debug`received request ${"layoutView"} of ${viewId} from project ${projectId}`;
-        const result = await likec4Services.Views.layoutView(viewId, projectId, cancelToken);
-        return { result };
-      }),
-      connection.onRequest(ValidateLayout.Req, async ({ projectId }, cancelToken) => {
-        const layouts = await likec4Services.Views.layoutAllViews(projectId, cancelToken);
-        const result = reportLayoutDrift(layouts.map((l) => l.diagram));
-        return { result };
-      }),
-      connection.onRequest(FetchProjects.req, async (_cancelToken) => {
-        logger.debug`received request ${"FetchProjects"}`;
-        const docsByProject = LangiumDocuments.groupedByProject();
-        return {
-          projects: mapValues(docsByProject, (docs, projectId) => {
-            const {
-              folderUri,
-              config
-            } = projects.getProject(projectId);
-            return {
-              folder: folderUri.toString(),
-              config: serializableLikeC4ProjectConfig(config),
-              docs: map(docs, (d) => d.uri.toString())
-            };
-          })
-        };
-      }),
-      connection.onRequest(ReloadProjects.req, async () => {
-        logger.debug`received request ${"ReloadProjects"}`;
-        await projects.reloadProjects();
-        return;
-      }),
-      connection.onRequest(RegisterProject.req, async (params) => {
-        logger.debug`received request ${"RegisterProject"}`;
-        const project = await projects.registerProject(params);
-        return { id: project.id };
-      }),
-      connection.onRequest(FetchViewsFromAllProjects.req, async (cancelToken) => {
-        logger.debug`received request ${"FetchViewsFromAllProjects"}`;
-        const promises = projects.all.map(async (projectId) => {
-          const computedViews = await likec4Services.Views.computedViews(projectId, cancelToken);
-          return pipe(
-            computedViews,
-            map((v) => ({
-              id: v.id,
-              title: v.title ?? v.id,
-              projectId
-            })),
-            sort((a, b) => {
-              if (a.id === "index") {
-                return -1;
-              }
-              if (b.id === "index") {
-                return 1;
-              }
-              return a.title.localeCompare(b.title);
-            })
-          );
-        });
-        const results = await Promise.allSettled(promises);
-        await interruptAndCheck(cancelToken);
-        return {
-          views: pipe(
-            results,
-            filter((r) => r.status === "fulfilled"),
-            flatMap((r) => r.value)
-          )
-        };
-      }),
-      connection.onRequest(BuildDocuments.Req, async ({ docs }, cancelToken) => {
-        const changed = docs.map((d) => URI.parse(d));
-        const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));
-        const deleted = LangiumDocuments.allExcludingBuiltin.toArray().filter((d) => notChanged(d.uri)).map((d) => d.uri);
-        logger.debug(
-          `[ServerRpc] received request to build:
-  changed (total ${changed.length}):${docs.map((d) => "\n    - " + d).join("")}
-  deleted (total ${deleted.length}):${deleted.map((d) => "\n    - " + d.toString()).join("\n")}`
-        );
-        if (!isFirstBuild && changed.length + deleted.length > 0) {
-          await Promise.allSettled(
-            [...changed, ...deleted].map(async (d) => {
-              const uri = d.toString();
-              logger.debug(`clear diagnostics for ${uri}`);
-              try {
-                await connection.sendDiagnostics({
-                  uri,
-                  diagnostics: []
-                });
-              } catch (e) {
-                logger.warn(`error clearing diagnostics for ${uri}: ${e}`);
-              }
-            })
-          );
-        }
-        isFirstBuild = false;
-        await interruptAndCheck(cancelToken);
-        await DocumentBuilder.update(changed, deleted, cancelToken);
-      }),
-      connection.onRequest(Locate.Req, (params) => {
-        switch (true) {
-          case "element" in params:
-            return likec4Services.ModelLocator.locateElement(params.element, params.projectId);
-          case "relation" in params:
-            return likec4Services.ModelLocator.locateRelation(params.relation, params.projectId);
-          case "astPath" in params:
-            return likec4Services.ModelLocator.locateDynamicViewStep({
-              view: params.view,
-              astPath: params.astPath,
-              projectId: params.projectId
-            });
-          case "view" in params:
-            return likec4Services.ModelLocator.locateView(params.view, params.projectId);
-          case "deployment" in params:
-            return likec4Services.ModelLocator.locateDeploymentElement(params.deployment, params.projectId);
-          default:
-            nonexhaustive(params);
-        }
-      }),
-      connection.onRequest(ChangeView.Req, async (request, _cancelToken) => {
-        logger.debug`received request ${"changeView"} of ${request.viewId} from project ${request.projectId}`;
-        return await likec4Services.ModelChanges.applyChange(request);
-      }),
-      connection.onRequest(FetchTelemetryMetrics.req, async (cancelToken) => {
-        const projectsIds = [...projects.all];
-        const promises = projectsIds.map(async (projectId) => {
-          const model = await likec4Services.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
-          if (model === LikeC4Model.EMPTY) {
-            return Promise.reject(new Error(`Model is empty`));
-          }
-          return {
-            elementKinds: keys(model.specification.elements).length,
-            deploymentKinds: keys(model.specification.deployments).length,
-            relationshipKinds: keys(model.specification.relationships).length,
-            tags: keys(model.specification.tags).length,
-            customColors: keys(model.specification.customColors ?? {}).length,
-            elements: keys(model.$data.elements).length,
-            deploymentNodes: [...model.deployment.nodes()].length,
-            relationships: keys(model.$data.relations).length,
-            views: keys(model.$data.views).length,
-            projects: 1
-          };
-        });
-        const results = await Promise.allSettled(promises);
-        await interruptAndCheck(cancelToken);
-        const values = results.filter((r) => r.status === "fulfilled").map((r) => r.value);
-        const metrics = values.length > 0 ? values.reduce((acc, r) => ({
-          elementKinds: acc.elementKinds + r.elementKinds,
-          deploymentKinds: acc.deploymentKinds + r.deploymentKinds,
-          relationshipKinds: acc.relationshipKinds + r.relationshipKinds,
-          tags: acc.tags + r.tags,
-          customColors: acc.customColors + r.customColors,
-          elements: acc.elements + r.elements,
-          deploymentNodes: acc.deploymentNodes + r.deploymentNodes,
-          relationships: acc.relationships + r.relationships,
-          views: acc.views + r.views,
-          projects: acc.projects + 1
-        })) : null;
-        return {
-          metrics
-        };
-      }),
-      connection.onRequest(GetDocumentTags.req, async ({ documentUri }, cancelToken) => {
-        const tags = await likec4Services.ModelLocator.locateDocumentTags(URI.parse(documentUri), cancelToken);
-        return {
-          tags
-        };
-      }),
-      Disposable.create(() => {
-        notifyModelParsed.cancel();
-      })
-    );
-    function reportLayoutDrift(diagrams) {
-      return pipe(
-        diagrams,
-        filter((d) => !!d.hasLayoutDrift),
-        map((d) => {
-          const loc = likec4Services.ModelLocator.locateView(d.id);
-          invariant(loc, `View ${d.id} not found`);
-          return {
-            uri: loc.uri,
-            viewId: d.id,
-            severity: DiagnosticSeverity.Warning,
-            message: `Layout drift detected for view '${d.id}'`,
-            range: loc.range
-          };
-        })
-      );
-    }
-  }
-  async openView(params) {
-    const lspConnection = this.services.shared.lsp.Connection;
-    if (!lspConnection) {
-      logger.warn("No LSP connection");
-      return;
-    }
-    await lspConnection.sendNotification(
-      DidRequestOpenViewNotification.type,
-      params
-    );
-  }
-}

package/dist/ast.mjs

@@ -1,221 +0,0 @@
-import { nonexhaustive } from "@likec4/core/utils";
-import { AstUtils, DocumentState } from "langium";
-import { clamp, isNullish, isTruthy } from "remeda";
-import * as ast from "./generated/ast.mjs";
-import { LikeC4LanguageMetaData } from "./generated/module.mjs";
-export { ast };
-const idattr = Symbol.for("idattr");
-export const ViewOps = {
-  writeId(node, id) {
-    node[idattr] = id;
-    return node;
-  },
-  readId(node) {
-    return node[idattr];
-  }
-};
-export const ElementOps = {
-  writeId(node, id) {
-    if (isNullish(id)) {
-      node[idattr] = void 0;
-    } else {
-      node[idattr] = id;
-    }
-    return node;
-  },
-  readId(node) {
-    return node[idattr];
-  }
-};
-export function isLikeC4LangiumDocument(doc) {
-  return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
-}
-export function isParsedLikeC4LangiumDocument(doc) {
-  return isLikeC4LangiumDocument(doc) && doc.state == DocumentState.Validated && !!doc.c4Specification && !!doc.c4Elements && !!doc.c4ExtendElements && !!doc.c4ExtendDeployments && !!doc.c4Relations && !!doc.c4Views && !!doc.c4Deployments && !!doc.c4DeploymentRelations && !!doc.c4Imports;
-}
-export function parseMarkdownAsString(node) {
-  return node?.markdown || node?.text;
-}
-export function parseAstPercent(value) {
-  const opacity = parseFloat(value);
-  return isNaN(opacity) ? 100 : clamp(opacity, { min: 0, max: 100 });
-}
-export function parseAstOpacityProperty({ value }) {
-  return parseAstPercent(value);
-}
-export function parseAstSizeValue({ value }) {
-  switch (value) {
-    case "xs":
-    case "sm":
-    case "md":
-    case "lg":
-    case "xl":
-      return value;
-    case "xsmall":
-      return "xs";
-    case "small":
-      return "sm";
-    case "medium":
-      return "md";
-    case "large":
-      return "lg";
-    case "xlarge":
-      return "xl";
-    default:
-      nonexhaustive(value);
-  }
-}
-export function toRelationshipStyle(props, isValid) {
-  const result = {};
-  if (!props || props.length === 0) {
-    return result;
-  }
-  for (const prop of props) {
-    if (!isValid(prop)) {
-      continue;
-    }
-    switch (true) {
-      case ast.isColorProperty(prop): {
-        const color = toColor(prop);
-        if (isTruthy(color)) {
-          result.color = color;
-        }
-        break;
-      }
-      case ast.isLineProperty(prop): {
-        result.line = prop.value;
-        break;
-      }
-      case ast.isArrowProperty(prop): {
-        switch (prop.key) {
-          case "head": {
-            result.head = prop.value;
-            break;
-          }
-          case "tail": {
-            result.tail = prop.value;
-            break;
-          }
-          default: {
-            nonexhaustive(prop);
-          }
-        }
-        break;
-      }
-      default: {
-        nonexhaustive(prop);
-      }
-    }
-  }
-  return result;
-}
-export function toColor(astNode) {
-  return astNode?.themeColor ?? astNode?.customColor?.$refText;
-}
-export function toAutoLayout(rule) {
-  const rankSep = rule.rankSep;
-  const nodeSep = rule.nodeSep;
-  let direction;
-  switch (rule.direction) {
-    case "TopBottom": {
-      direction = "TB";
-      break;
-    }
-    case "BottomTop": {
-      direction = "BT";
-      break;
-    }
-    case "LeftRight": {
-      direction = "LR";
-      break;
-    }
-    case "RightLeft": {
-      direction = "RL";
-      break;
-    }
-    default:
-      nonexhaustive(rule.direction);
-  }
-  return {
-    direction,
-    ...nodeSep && { nodeSep },
-    ...rankSep && { rankSep }
-  };
-}
-export function toAstViewLayoutDirection(c4) {
-  switch (c4) {
-    case "TB": {
-      return "TopBottom";
-    }
-    case "BT": {
-      return "BottomTop";
-    }
-    case "LR": {
-      return "LeftRight";
-    }
-    case "RL": {
-      return "RightLeft";
-    }
-    default:
-      nonexhaustive(c4);
-  }
-}
-export function getViewRulePredicateContainer(el) {
-  return AstUtils.getContainerOfType(
-    el,
-    (n) => {
-      return ast.isViewRulePredicate(n) || ast.isDeploymentViewRulePredicate(n) || ast.isDynamicViewIncludePredicate(n);
-    }
-  );
-}
-const _isModel = (astNode) => {
-  return ast.isModel(astNode) || ast.isElementBody(astNode) || ast.isExtendElementBody(astNode) || ast.isElementViewBody(astNode) || ast.isDynamicViewBody(astNode) || ast.isElementRef(astNode);
-};
-const _isDeployment = (astNode) => {
-  return ast.isModelDeployments(astNode) || ast.isDeploymentViewBody(astNode) || ast.isDeploymentNodeBody(astNode) || ast.isExtendDeploymentBody(astNode) || ast.isDeployedInstanceBody(astNode);
-};
-export function isFqnRefInsideGlobals(astNode) {
-  while (true) {
-    if (_isDeployment(astNode) || _isModel(astNode)) {
-      return false;
-    }
-    if (ast.isGlobals(astNode) || ast.isModelViews(astNode)) {
-      return true;
-    }
-    if (astNode.$container) {
-      astNode = astNode.$container;
-    } else {
-      return false;
-    }
-  }
-}
-export function isFqnRefInsideModel(astNode) {
-  while (true) {
-    if (_isDeployment(astNode)) {
-      return false;
-    }
-    if (_isModel(astNode)) {
-      return true;
-    }
-    if (astNode.$container) {
-      astNode = astNode.$container;
-    } else {
-      return false;
-    }
-  }
-}
-export function isFqnRefInsideDeployment(astNode) {
-  while (true) {
-    if (_isModel(astNode)) {
-      return false;
-    }
-    if (_isDeployment(astNode)) {
-      return true;
-    }
-    if (astNode.$container) {
-      astNode = astNode.$container;
-    } else {
-      return false;
-    }
-  }
-}

package/dist/browser-worker.mjs

@@ -1,2 +0,0 @@
-import { startLanguageServer } from "./browser.mjs";
-startLanguageServer(self);

package/dist/browser.mjs

@@ -1,32 +0,0 @@
-import { configureLogger, getAnsiColorFormatter, getConsoleSink } from "@likec4/log";
-import { startLanguageServer as startLanguim } from "langium/lsp";
-import { BrowserMessageReader, BrowserMessageWriter, createConnection } from "vscode-languageserver/browser";
-import { createLanguageServices } from "./module.mjs";
-export { logger as lspLogger } from "./logger.mjs";
-export { createLanguageServices } from "./module.mjs";
-export function startLanguageServer(port) {
-  const messageReader = new BrowserMessageReader(port);
-  const messageWriter = new BrowserMessageWriter(port);
-  const connection = createConnection(messageReader, messageWriter);
-  configureLogger({
-    sinks: {
-      console: getConsoleSink({
-        formatter: getAnsiColorFormatter({
-          format: ({ level, category, message }) => {
-            return `${level} ${category} ${message}`;
-          }
-        })
-      })
-    },
-    loggers: [
-      {
-        category: "likec4",
-        sinks: ["console"],
-        lowestLevel: "debug"
-      }
-    ]
-  });
-  const services = createLanguageServices({ connection });
-  startLanguim(services.shared);
-  return services;
-}

package/dist/documentation/documentation-provider.mjs

@@ -1,48 +0,0 @@
-import { FqnRef } from "@likec4/core";
-import { AstUtils } from "langium";
-import { ast } from "../ast.mjs";
-import { logWarnError } from "../logger.mjs";
-export class LikeC4DocumentationProvider {
-  parser;
-  locator;
-  constructor(services) {
-    this.parser = services.likec4.ModelParser;
-    this.locator = services.likec4.ModelLocator;
-  }
-  getDocumentation(node) {
-    try {
-      if (ast.isDeploymentNode(node)) {
-        const doc = AstUtils.getDocument(node);
-        const el = this.parser.forDocument(doc).parseDeploymentNode(node);
-        const lines = [el.id];
-        if (el.title !== node.name) {
-          lines.push(" ", `**${el.title}**`);
-        }
-        return lines.join("  \n");
-      }
-      if (ast.isDeployedInstance(node)) {
-        const doc = AstUtils.getDocument(node);
-        const instance = this.parser.forDocument(doc).parseDeployedInstance(node);
-        const [projectId, fqn] = FqnRef.isImportRef(instance.element) ? [instance.element.project, instance.element.model] : [doc.likec4ProjectId, instance.element.model];
-        const el = projectId ? this.locator.getParsedElement(fqn, projectId) : this.locator.getParsedElement(fqn);
-        const lines = [instance.id, `_instance of_ ${fqn}`];
-        if (el) {
-          lines.push(" ", `**${el.title}**`);
-        }
-        return lines.join("  \n");
-      }
-      if (ast.isElement(node)) {
-        const doc = AstUtils.getDocument(node);
-        const el = this.parser.forDocument(doc).parseElement(node);
-        if (!el) {
-          return;
-        }
-        const lines = [el.id, " ", `**${el.title}**`];
-        return lines.join("  \n");
-      }
-    } catch (e) {
-      logWarnError(e);
-    }
-    return;
-  }
-}

package/dist/documentation/index.mjs

@@ -1 +0,0 @@
-export { LikeC4DocumentationProvider } from "./documentation-provider.mjs";

package/dist/empty.mjs

@@ -1 +0,0 @@
-export default {};

package/dist/filesystem/ChokidarWatcher.mjs

@@ -1,68 +0,0 @@
-import { isLikeC4Config } from "@likec4/config/node";
-import { loggable } from "@likec4/log";
-import chokidar from "chokidar";
-import { URI } from "langium";
-import { logger as mainLogger } from "../logger.mjs";
-import { isAnyLikeC4File, isLikeC4File } from "./LikeC4FileSystem.mjs";
-const logger = mainLogger.getChild("chokidar");
-export const chokidarFileSystemWatcher = {
-  fileSystemWatcher: (services) => new ChokidarFileSystemWatcher(services)
-};
-export class ChokidarFileSystemWatcher {
-  constructor(services) {
-    this.services = services;
-  }
-  watcher;
-  watch(folder) {
-    if (this.watcher) {
-      this.watcher.add(folder);
-    } else {
-      this.watcher = this.createWatcher(folder);
-    }
-    logger.debug`watching folder: ${folder}`;
-  }
-  async dispose() {
-    if (this.watcher) {
-      await this.watcher.close();
-      this.watcher = void 0;
-    }
-    return;
-  }
-  createWatcher(folder) {
-    let watcher = chokidar.watch(folder, {
-      ignored: [
-        (path) => path.includes("node_modules") || path.includes(".git"),
-        (path, stats) => !!stats && stats.isFile() && !isAnyLikeC4File(path)
-      ],
-      ignoreInitial: true
-    });
-    const onAddOrChange = async (path) => {
-      try {
-        if (isLikeC4Config(path)) {
-          logger.debug`project file changed: ${path}`;
-          await this.services.workspace.ProjectsManager.reloadProjects();
-        } else if (isLikeC4File(path)) {
-          logger.debug`file changed: ${path}`;
-          await this.services.workspace.DocumentBuilder.update([URI.file(path)], []);
-        }
-      } catch (error) {
-        logger.error(loggable(error));
-      }
-    };
-    const onRemove = async (path) => {
-      try {
-        if (isLikeC4Config(path)) {
-          logger.debug`project file removed: ${path}`;
-          await this.services.workspace.ProjectsManager.reloadProjects();
-        } else if (isLikeC4File(path)) {
-          logger.debug`file removed: ${path}`;
-          await this.services.workspace.DocumentBuilder.update([], [URI.file(path)]);
-        }
-      } catch (error) {
-        logger.error(loggable(error));
-      }
-    };
-    watcher.on("add", onAddOrChange).on("change", onAddOrChange).on("unlink", onRemove);
-    return watcher;
-  }
-}

package/dist/filesystem/FileSystemWatcher.mjs

@@ -1,11 +0,0 @@
-export const noopFileSystemWatcher = {
-  fileSystemWatcher: () => new NoopFileSystemWatcher()
-};
-export class NoopFileSystemWatcher {
-  watch() {
-    return;
-  }
-  dispose() {
-    return Promise.resolve();
-  }
-}