@likec4/language-server 1.47.0 → 1.48.0

package/dist/_chunks/protocol.d.mts

@@ -0,0 +1,311 @@
+import { DiagnosticSeverity, DocumentUri, Location, Position, Range, URI } from "vscode-languageserver-types";
+import { LikeC4ProjectJsonConfig } from "@likec4/config";
+import { ComputedLikeC4ModelData, DeploymentFqn, DiagramView, Fqn, LayoutedLikeC4ModelData, LayoutedProjectsView, NonEmptyArray, ProjectId, RelationId, ViewChange, ViewId } from "@likec4/core";
+import { NotificationType, NotificationType0, RequestType, RequestType0 } from "vscode-jsonrpc";
+
+//#region src/protocol.d.ts
+declare namespace DidChangeModelNotification {
+  const type: NotificationType<string>;
+  type Type = typeof type;
+}
+/**
+ * Triggered by the language server when projects changed
+ * (number of projects changed, names changed, etc)
+ */
+declare namespace DidChangeProjectsNotification {
+  const type: NotificationType0;
+  type Type = typeof type;
+}
+/**
+ * When the snapshot of a manual layout changes
+ * Send by the editor to the language server
+ */
+declare namespace DidChangeSnapshotNotification {
+  type Params = {
+    snapshotUri: DocumentUri;
+  };
+  const Method: "likec4/onDidChangeSnapshot";
+  const type: NotificationType<Params>;
+  type Type = typeof type;
+}
+/**
+ * When server requests to open a likec4 preview panel
+ * (available only in the editor).
+ * (not the best place, but seems to be working)
+ */
+declare namespace DidRequestOpenViewNotification {
+  type Params = {
+    viewId: ViewId;
+    projectId: ProjectId;
+  };
+  const type: NotificationType<Params>;
+  type Type = typeof type;
+}
+/**
+ * Request to fetch the computed model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
+declare namespace FetchComputedModel {
+  type Params = {
+    projectId?: string | undefined;
+    cleanCaches?: boolean | undefined;
+  };
+  type Res = {
+    model: ComputedLikeC4ModelData | null;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch all views of all projects
+ */
+declare namespace FetchViewsFromAllProjects {
+  type Res = {
+    views: Array<{
+      id: ViewId;
+      title: string;
+      projectId: ProjectId;
+    }>;
+  };
+  const req: RequestType0<Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch the layouted model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
+declare namespace FetchLayoutedModel {
+  type Params = {
+    projectId?: string | undefined;
+  };
+  type Res = {
+    model: LayoutedLikeC4ModelData | null;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to layout a view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace LayoutView {
+  type Params = {
+    viewId: ViewId;
+    projectId?: string | undefined;
+    layoutType?: 'auto' | 'manual' | undefined;
+  };
+  type Res = {
+    result: {
+      dot: string;
+      diagram: DiagramView;
+    } | null;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to validate all views
+ * If projects ID is provided, it will validate only the views of that project.
+ */
+declare namespace ValidateLayout {
+  type Params = {
+    projectId?: string;
+  };
+  type Res = {
+    result: {
+      uri: string;
+      viewId: ViewId;
+      message: string;
+      severity: DiagnosticSeverity;
+      range: {
+        start: Position;
+        end: Position;
+      };
+    }[] | null;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to reload projects.
+ */
+declare namespace ReloadProjects {
+  type Params = never;
+  type Res = void;
+  const req: RequestType0<void, void>;
+  type Req = typeof req;
+}
+/**
+ * Fetch all non-empty projects.
+ */
+declare namespace FetchProjects {
+  type Params = never;
+  type Res = {
+    projects: {
+      [projectId: ProjectId]: {
+        folder: URI;
+        config: {
+          name: string;
+          title?: string | undefined;
+        };
+        docs: NonEmptyArray<DocumentUri>;
+      };
+    };
+  };
+  const req: RequestType0<Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request from the client to register a project.
+ */
+declare namespace RegisterProject {
+  type Params = {
+    folderUri: URI;
+    config: LikeC4ProjectJsonConfig;
+    configUri?: never;
+  } | {
+    configUri: URI;
+    folderUri?: never;
+    config?: never;
+  };
+  type Res = {
+    id: ProjectId;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to build documents.
+ */
+declare namespace BuildDocuments {
+  type Params = {
+    docs: DocumentUri[];
+  };
+  const req: RequestType<Params, void, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to locate an element, relation, deployment or view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace Locate {
+  type Params =
+  /**
+   * Locate an element by its fqn
+   */
+  {
+    element: Fqn;
+    projectId?: string | undefined;
+    property?: string;
+  }
+  /**
+   * Locate a relation by its id
+   */
+  | {
+    projectId?: string | undefined;
+    relation: RelationId;
+  }
+  /**
+   * Locate a deployment by its fqn
+   */
+  | {
+    deployment: DeploymentFqn;
+    projectId?: string | undefined;
+    property?: string;
+  }
+  /**
+   * Locate a step in a dynamic view by its astPath
+   */
+  | {
+    view: ViewId;
+    astPath: string;
+    projectId?: string | undefined;
+  }
+  /**
+   * Locate a view by its id
+   */
+  | {
+    view: ViewId;
+    projectId?: string | undefined;
+  };
+  type Res = Location | null;
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to change the view
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace ChangeView {
+  type Params = {
+    viewId: ViewId;
+    change: ViewChange;
+    projectId?: string | undefined;
+  };
+  type Res = {
+    success: true;
+    location: Location | null;
+  } | {
+    success: false;
+    location?: Location | null;
+    error: string;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch telemetry metrics
+ */
+declare namespace FetchTelemetryMetrics {
+  type Res = {
+    metrics: null | {
+      elementKinds: number;
+      deploymentKinds: number;
+      relationshipKinds: number;
+      tags: number;
+      customColors: number;
+      elements: number;
+      deploymentNodes: number;
+      relationships: number;
+      views: number;
+      projects: number;
+    };
+  };
+  const req: RequestType0<Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch all tags of a document
+ */
+declare namespace GetDocumentTags {
+  type Params = {
+    documentUri: DocumentUri;
+  };
+  type Res = {
+    /**
+     * Used tags in the document
+     */
+    tags: Array<{
+      name: string;
+      range: Range;
+      color: string;
+      isSpecification?: boolean;
+    }>;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch projects overview diagram
+ */
+declare namespace FetchProjectsOverview {
+  type Res = {
+    projectsView: LayoutedProjectsView | null;
+  };
+  const req: RequestType0<Res, void>;
+  type Req = typeof req;
+}
+//#endregion
+export { ReloadProjects as _, DidChangeSnapshotNotification as a, FetchLayoutedModel as c, FetchTelemetryMetrics as d, FetchViewsFromAllProjects as f, RegisterProject as g, Locate as h, DidChangeProjectsNotification as i, FetchProjects as l, LayoutView as m, ChangeView as n, DidRequestOpenViewNotification as o, GetDocumentTags as p, DidChangeModelNotification as r, FetchComputedModel as s, BuildDocuments as t, FetchProjectsOverview as u, ValidateLayout as v };

package/dist/_chunks/protocol.mjs

@@ -0,0 +1,78 @@
+import { NotificationType, NotificationType0, RequestType, RequestType0 } from "vscode-jsonrpc";
+
+//#region src/protocol.ts
+let DidChangeModelNotification;
+(function(_DidChangeModelNotification) {
+	_DidChangeModelNotification.type = new NotificationType("likec4/onDidChangeModel");
+})(DidChangeModelNotification || (DidChangeModelNotification = {}));
+let DidChangeProjectsNotification;
+(function(_DidChangeProjectsNotification) {
+	_DidChangeProjectsNotification.type = new NotificationType0("likec4/onDidChangeProjects");
+})(DidChangeProjectsNotification || (DidChangeProjectsNotification = {}));
+let DidChangeSnapshotNotification;
+(function(_DidChangeSnapshotNotification) {
+	_DidChangeSnapshotNotification.type = new NotificationType(_DidChangeSnapshotNotification.Method = "likec4/onDidChangeSnapshot");
+})(DidChangeSnapshotNotification || (DidChangeSnapshotNotification = {}));
+let DidRequestOpenViewNotification;
+(function(_DidRequestOpenViewNotification) {
+	_DidRequestOpenViewNotification.type = new NotificationType("likec4/onRequestOpenView");
+})(DidRequestOpenViewNotification || (DidRequestOpenViewNotification = {}));
+let FetchComputedModel;
+(function(_FetchComputedModel) {
+	_FetchComputedModel.req = new RequestType("likec4/fetchComputedModel");
+})(FetchComputedModel || (FetchComputedModel = {}));
+let FetchViewsFromAllProjects;
+(function(_FetchViewsFromAllProjects) {
+	_FetchViewsFromAllProjects.req = new RequestType0("likec4/fetchViewsFromAllProjects");
+})(FetchViewsFromAllProjects || (FetchViewsFromAllProjects = {}));
+let FetchLayoutedModel;
+(function(_FetchLayoutedModel) {
+	_FetchLayoutedModel.req = new RequestType("likec4/fetchLayoutedModel");
+})(FetchLayoutedModel || (FetchLayoutedModel = {}));
+let LayoutView;
+(function(_LayoutView) {
+	_LayoutView.req = new RequestType("likec4/layout-view");
+})(LayoutView || (LayoutView = {}));
+let ValidateLayout;
+(function(_ValidateLayout) {
+	_ValidateLayout.req = new RequestType("likec4/validate-layout");
+})(ValidateLayout || (ValidateLayout = {}));
+let ReloadProjects;
+(function(_ReloadProjects) {
+	_ReloadProjects.req = new RequestType0("likec4/reload-projects");
+})(ReloadProjects || (ReloadProjects = {}));
+let FetchProjects;
+(function(_FetchProjects) {
+	_FetchProjects.req = new RequestType0("likec4/fetch-projects");
+})(FetchProjects || (FetchProjects = {}));
+let RegisterProject;
+(function(_RegisterProject) {
+	_RegisterProject.req = new RequestType("likec4/register-project");
+})(RegisterProject || (RegisterProject = {}));
+let BuildDocuments;
+(function(_BuildDocuments) {
+	_BuildDocuments.req = new RequestType("likec4/build");
+})(BuildDocuments || (BuildDocuments = {}));
+let Locate;
+(function(_Locate) {
+	_Locate.req = new RequestType("likec4/locate");
+})(Locate || (Locate = {}));
+let ChangeView;
+(function(_ChangeView) {
+	_ChangeView.req = new RequestType("likec4/change-view");
+})(ChangeView || (ChangeView = {}));
+let FetchTelemetryMetrics;
+(function(_FetchTelemetryMetrics) {
+	_FetchTelemetryMetrics.req = new RequestType0("likec4/metrics");
+})(FetchTelemetryMetrics || (FetchTelemetryMetrics = {}));
+let GetDocumentTags;
+(function(_GetDocumentTags) {
+	_GetDocumentTags.req = new RequestType("likec4/document-tags");
+})(GetDocumentTags || (GetDocumentTags = {}));
+let FetchProjectsOverview;
+(function(_FetchProjectsOverview) {
+	_FetchProjectsOverview.req = new RequestType0("likec4/fetch-projects-overview");
+})(FetchProjectsOverview || (FetchProjectsOverview = {}));
+
+//#endregion
+export { ReloadProjects as _, DidChangeSnapshotNotification as a, FetchLayoutedModel as c, FetchTelemetryMetrics as d, FetchViewsFromAllProjects as f, RegisterProject as g, Locate as h, DidChangeProjectsNotification as i, FetchProjects as l, LayoutView as m, ChangeView as n, DidRequestOpenViewNotification as o, GetDocumentTags as p, DidChangeModelNotification as r, FetchComputedModel as s, BuildDocuments as t, FetchProjectsOverview as u, ValidateLayout as v };

package/dist/_chunks/rolldown-runtime.mjs

@@ -0,0 +1,42 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+export { __exportAll as n, __toESM as r, __commonJSMin as t };

package/dist/ast.d.mts

@@ -0,0 +1,4 @@
+import { kr as ast_d_exports } from "./_chunks/ast.mjs";
+import { A as ParsedElementStyle, B as parseAstOpacityProperty, C as ParsedAstElementView, D as ParsedAstRelation, E as ParsedAstGlobals, F as isFqnRefInsideGlobals, G as toAutoLayout, H as parseAstSizeValue, I as isFqnRefInsideModel, K as toColor, L as isLikeC4LangiumDocument, M as ViewOps, N as getViewRulePredicateContainer, O as ParsedAstSpecification, P as isFqnRefInsideDeployment, R as isParsedLikeC4LangiumDocument, S as ParsedAstElement, T as ParsedAstExtendRelation, U as parseMarkdownAsString, V as parseAstPercent, W as toAstViewLayoutDirection, _ as LikeC4LangiumDocument, b as ParsedAstDeploymentView, g as LikeC4DocumentProps, h as LikeC4AstNode, j as ParsedLikeC4LangiumDocument, k as ParsedAstView, m as ElementOps, p as AstNodeDescriptionWithFqn, q as toRelationshipStyle, v as ParsedAstDeployment, w as ParsedAstExtend, x as ParsedAstDynamicView, y as ParsedAstDeploymentRelation, z as parseAstIconPositionValue } from "./_chunks/LikeC4LanguageServices.mjs";
+import "./_chunks/protocol.mjs";
+export { AstNodeDescriptionWithFqn, ElementOps, LikeC4AstNode, LikeC4DocumentProps, LikeC4LangiumDocument, ParsedAstDeployment, ParsedAstDeploymentRelation, ParsedAstDeploymentView, ParsedAstDynamicView, ParsedAstElement, ParsedAstElementView, ParsedAstExtend, ParsedAstExtendRelation, ParsedAstGlobals, ParsedAstRelation, ParsedAstSpecification, ParsedAstView, ParsedElementStyle, ParsedLikeC4LangiumDocument, ViewOps, ast_d_exports as ast, getViewRulePredicateContainer, isFqnRefInsideDeployment, isFqnRefInsideGlobals, isFqnRefInsideModel, isLikeC4LangiumDocument, isParsedLikeC4LangiumDocument, parseAstIconPositionValue, parseAstOpacityProperty, parseAstPercent, parseAstSizeValue, parseMarkdownAsString, toAstViewLayoutDirection, toAutoLayout, toColor, toRelationshipStyle };

package/dist/ast.mjs

@@ -0,0 +1,4 @@
+import { ur as ast_exports } from "./_chunks/ast.mjs";
+import { _ as toRelationshipStyle, a as isFqnRefInsideGlobals, c as isParsedLikeC4LangiumDocument, d as parseAstPercent, f as parseAstSizeValue, g as toColor, h as toAutoLayout, i as isFqnRefInsideDeployment, l as parseAstIconPositionValue, m as toAstViewLayoutDirection, n as ViewOps, o as isFqnRefInsideModel, p as parseMarkdownAsString, r as getViewRulePredicateContainer, s as isLikeC4LangiumDocument, t as ElementOps, u as parseAstOpacityProperty } from "./_chunks/ast2.mjs";
+
+export { ElementOps, ViewOps, ast_exports as ast, getViewRulePredicateContainer, isFqnRefInsideDeployment, isFqnRefInsideGlobals, isFqnRefInsideModel, isLikeC4LangiumDocument, isParsedLikeC4LangiumDocument, parseAstIconPositionValue, parseAstOpacityProperty, parseAstPercent, parseAstSizeValue, parseMarkdownAsString, toAstViewLayoutDirection, toAutoLayout, toColor, toRelationshipStyle };

package/dist/browser-worker.d.mts

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

package/dist/browser-worker.mjs

@@ -0,0 +1,6 @@
+import { startLanguageServer } from "./browser.mjs";
+
+//#region src/browser-worker.ts
+startLanguageServer(self);
+
+//#endregion

package/dist/browser.d.mts

@@ -0,0 +1,11 @@
+import "./_chunks/ast.mjs";
+import { J as LanguageServicesContext, Q as createLanguageServices, X as LikeC4Services, Y as LikeC4AddedServices, Z as LikeC4SharedServices, _t as LikeC4ManualLayoutsModuleContext, bt as ProjectsManager, ct as NoFileSystem, d as LikeC4ModelBuilder, f as FqnIndex, ft as FileSystemModuleContext, gt as LikeC4ManualLayouts, ht as FileSystemWatcherModuleContext, i as LikeC4ModelParser, l as LikeC4ModelLocator, lt as NoFileSystemWatcher, mt as FileSystemWatcher, n as LikeC4LanguageServices, nt as NoMCPServer, ot as LikeC4WorkspaceManager, pt as FileSystemProvider, r as DocumentParser, st as LangiumDocuments, tt as LikeC4Views, u as ViewLocateResult, ut as NoLikeC4ManualLayouts, vt as Project, yt as ProjectData } from "./_chunks/LikeC4LanguageServices.mjs";
+import "./_chunks/protocol.mjs";
+
+//#region src/browser.d.ts
+declare function startLanguageServer(port: MessagePort | DedicatedWorkerGlobalScope): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+//#endregion
+export { DocumentParser, FileSystemModuleContext, FileSystemProvider, FileSystemWatcher, FileSystemWatcherModuleContext, FqnIndex, LangiumDocuments, LanguageServicesContext, LikeC4AddedServices, LikeC4LanguageServices, LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser, LikeC4Services, LikeC4SharedServices, LikeC4Views, LikeC4WorkspaceManager, NoFileSystem, NoFileSystemWatcher, NoLikeC4ManualLayouts, NoMCPServer, Project, ProjectData, ProjectsManager, ViewLocateResult, createLanguageServices, startLanguageServer };

package/dist/browser.mjs

@@ -0,0 +1,27 @@
+import { n as NoFileSystemWatcher, r as NoLikeC4ManualLayouts, t as NoFileSystem } from "./_chunks/filesystem.mjs";
+import { t as createLanguageServices } from "./_chunks/module2.mjs";
+import { t as NoMCPServer } from "./_chunks/mcp.mjs";
+import { configureLogger, getConsoleSink, getTextFormatter } from "@likec4/log";
+import { startLanguageServer as startLanguageServer$1 } from "langium/lsp";
+import { BrowserMessageReader, BrowserMessageWriter, createConnection } from "vscode-languageserver/browser";
+
+//#region src/browser.ts
+function startLanguageServer(port) {
+	const connection = createConnection(new BrowserMessageReader(port), new BrowserMessageWriter(port));
+	configureLogger({
+		sinks: { console: getConsoleSink({ formatter: getTextFormatter({ format: ({ level, category, message }) => {
+			return `${level} ${category} ${message}`;
+		} }) }) },
+		loggers: [{
+			category: "likec4",
+			sinks: ["console"],
+			lowestLevel: "debug"
+		}]
+	});
+	const services = createLanguageServices({ connection });
+	startLanguageServer$1(services.shared);
+	return services;
+}
+
+//#endregion
+export { NoFileSystem, NoFileSystemWatcher, NoLikeC4ManualLayouts, NoMCPServer, createLanguageServices, startLanguageServer };

package/dist/bundled.d.mts

@@ -0,0 +1,28 @@
+import "./_chunks/ast.mjs";
+import { X as LikeC4Services, Z as LikeC4SharedServices } from "./_chunks/LikeC4LanguageServices.mjs";
+import "./_chunks/protocol.mjs";
+
+//#region src/bundled.d.ts
+type StartBundledLanguageServerOptions = {
+  /**
+   * Whether to enable the MCP server.
+   * @default true
+   */
+  enableMCP?: boolean | {
+    port: number;
+  };
+  /**
+   * Whether to enable manual layouts, stored in json5 files.
+   * @default true
+   */
+  enableManualLayouts?: boolean;
+};
+/**
+ * This is used as `bin` entry point to start the language server.
+ */
+declare function startLanguageServer(options?: StartBundledLanguageServerOptions): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+//#endregion
+export { startLanguageServer };