@likec4/language-server 1.40.0 → 1.42.0

package/browser/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/browser.d.ts",
+  "module": "../dist/browser.mjs"
+}

package/browser-worker/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/browser-worker.d.ts",
+  "module": "../dist/browser-worker.mjs"
+}

package/dist/LikeC4LanguageServices.d.ts

@@ -70,10 +70,10 @@ export interface LikeC4LanguageServices {
  */
 export declare class DefaultLikeC4LanguageServices implements LikeC4LanguageServices {
     private services;
-    readonly views: LikeC4Views;
     readonly builder: LikeC4ModelBuilder;
     readonly projectsManager: ProjectsManager;
     constructor(services: LikeC4Services);
+    get views(): LikeC4Views;
     get workspaceUri(): URI;
     projects(): NonEmptyArray<{
         id: ProjectId;

package/dist/LikeC4LanguageServices.mjs

@@ -13,13 +13,14 @@ const logger = mainLogger.getChild("LanguageServices");
 export class DefaultLikeC4LanguageServices {
   constructor(services) {
     this.services = services;
-    this.views = services.likec4.Views;
     this.builder = services.likec4.ModelBuilder;
     this.projectsManager = services.shared.workspace.ProjectsManager;
   }
-  views;
   builder;
   projectsManager;
+  get views() {
+    return this.services.likec4.Views;
+  }
   get workspaceUri() {
     return this.services.shared.workspace.WorkspaceManager.workspaceUri;
   }

package/dist/Rpc.mjs

@@ -2,6 +2,7 @@ import { filter, flatMap, funnel, indexBy, keys, map, mapValues, pipe, sort } fr
 import { logger as rootLogger } from "./logger.mjs";
 import { serializableLikeC4ProjectConfig } from "@likec4/config";
 import {
+  invariant,
   nonexhaustive
 } from "@likec4/core";
 import { LikeC4Model } from "@likec4/core/model";
@@ -33,17 +34,14 @@ export class Rpc extends ADisposable {
     this.services = services;
   }
   init() {
-    const modelBuilder = this.services.likec4.ModelBuilder;
-    const modelLocator = this.services.likec4.ModelLocator;
-    const modelEditor = this.services.likec4.ModelChanges;
-    const views = this.services.likec4.Views;
     const connection = this.services.shared.lsp.Connection;
-    const projects = this.services.shared.workspace.ProjectsManager;
     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(
@@ -63,7 +61,7 @@ export class Rpc extends ADisposable {
     );
     let isFirstBuild = true;
     this.onDispose(
-      modelBuilder.onModelParsed(() => notifyModelParsed.call()),
+      likec4Services.ModelBuilder.onModelParsed(() => notifyModelParsed.call()),
       connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
         logger.debug`received request ${"fetchComputedModel"} for project ${projectId}`;
         if (cleanCaches) {
@@ -71,22 +69,22 @@ export class Rpc extends ADisposable {
           const uris = docs.toArray().map((d) => d.uri);
           await DocumentBuilder.update(uris, [], cancelToken);
         }
-        const likec4model = await modelBuilder.buildLikeC4Model(projectId, 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 modelBuilder.computeView(viewId, projectId, cancelToken);
+        const view = await likec4Services.ModelBuilder.computeView(viewId, projectId, cancelToken);
         return { view };
       }),
       connection.onRequest(FetchLayoutedModel.req, async ({ projectId }, cancelToken) => {
-        const model = await modelBuilder.parseModel(projectId, cancelToken);
+        const model = await likec4Services.ModelBuilder.parseModel(projectId, cancelToken);
         if (model === null) {
           return { model: null };
         }
-        const diagrams = await views.diagrams(projectId, cancelToken);
+        const diagrams = await likec4Services.Views.diagrams(projectId, cancelToken);
         return {
           model: {
             ...model.$data,
@@ -97,11 +95,11 @@ export class Rpc extends ADisposable {
       }),
       connection.onRequest(LayoutView.req, async ({ viewId, projectId }, cancelToken) => {
         logger.debug`received request ${"layoutView"} of ${viewId} from project ${projectId}`;
-        const result = await views.layoutView(viewId, projectId, cancelToken);
+        const result = await likec4Services.Views.layoutView(viewId, projectId, cancelToken);
         return { result };
       }),
       connection.onRequest(ValidateLayout.Req, async ({ projectId }, cancelToken) => {
-        const layouts = await views.layoutAllViews(projectId, cancelToken);
+        const layouts = await likec4Services.Views.layoutAllViews(projectId, cancelToken);
         const result = reportLayoutDrift(layouts.map((l) => l.diagram));
         return { result };
       }),
@@ -122,9 +120,9 @@ export class Rpc extends ADisposable {
           })
         };
       }),
-      connection.onRequest(ReloadProjects.req, async (cancelToken) => {
+      connection.onRequest(ReloadProjects.req, async () => {
         logger.debug`received request ${"ReloadProjects"}`;
-        await projects.reloadProjects(cancelToken);
+        await projects.reloadProjects();
         return;
       }),
       connection.onRequest(RegisterProject.req, async (params) => {
@@ -135,7 +133,7 @@ export class Rpc extends ADisposable {
       connection.onRequest(FetchViewsFromAllProjects.req, async (cancelToken) => {
         logger.debug`received request ${"FetchViewsFromAllProjects"}`;
         const promises = projects.all.map(async (projectId) => {
-          const computedViews = await views.computedViews(projectId, cancelToken);
+          const computedViews = await likec4Services.Views.computedViews(projectId, cancelToken);
           return pipe(
             computedViews,
             map((v) => ({
@@ -196,25 +194,31 @@ export class Rpc extends ADisposable {
       connection.onRequest(Locate.Req, (params) => {
         switch (true) {
           case "element" in params:
-            return modelLocator.locateElement(params.element, params.projectId);
+            return likec4Services.ModelLocator.locateElement(params.element, params.projectId);
           case "relation" in params:
-            return modelLocator.locateRelation(params.relation, params.projectId);
+            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 modelLocator.locateView(params.view, params.projectId);
+            return likec4Services.ModelLocator.locateView(params.view, params.projectId);
           case "deployment" in params:
-            return modelLocator.locateDeploymentElement(params.deployment, params.projectId);
+            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 modelEditor.applyChange(request);
+        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 modelBuilder.buildLikeC4Model(projectId, cancelToken);
+          const model = await likec4Services.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
           if (model === LikeC4Model.EMPTY) {
             return Promise.reject(new Error(`Model is empty`));
           }
@@ -251,7 +255,7 @@ export class Rpc extends ADisposable {
         };
       }),
       connection.onRequest(GetDocumentTags.req, async ({ documentUri }, cancelToken) => {
-        const tags = await modelLocator.locateDocumentTags(URI.parse(documentUri), cancelToken);
+        const tags = await likec4Services.ModelLocator.locateDocumentTags(URI.parse(documentUri), cancelToken);
         return {
           tags
         };
@@ -265,12 +269,14 @@ export class Rpc extends ADisposable {
         diagrams,
         filter((d) => !!d.hasLayoutDrift),
         map((d) => {
+          const loc = likec4Services.ModelLocator.locateView(d.id);
+          invariant(loc, `View ${d.id} not found`);
           return {
-            uri: modelLocator.locateView(d.id).uri,
+            uri: loc.uri,
             viewId: d.id,
             severity: DiagnosticSeverity.Warning,
             message: `Layout drift detected for view '${d.id}'`,
-            range: modelLocator.locateView(d.id).range
+            range: loc.range
           };
         })
       );

package/dist/ast.d.ts

@@ -71,6 +71,7 @@ export interface ParsedAstElement {
     astPath: string;
     kind: c4.ElementKind;
     title: string;
+    summary?: c4.MarkdownOrString;
     description?: c4.MarkdownOrString;
     technology?: string;
     tags?: c4.NonEmptyArray<c4.Tag>;
@@ -83,8 +84,8 @@ export interface ParsedAstElement {
 export interface ParsedAstExtend {
     id: c4.Fqn;
     astPath: string;
-    tags?: c4.NonEmptyArray<c4.Tag>;
-    links?: c4.NonEmptyArray<c4.Link>;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<c4.Link> | null;
     metadata?: {
         [key: string]: string;
     };
@@ -139,7 +140,7 @@ export interface ParsedAstDynamicView {
     description: c4.MarkdownOrString | null;
     tags: c4.NonEmptyArray<c4.Tag> | null;
     links: c4.NonEmptyArray<c4.Link> | null;
-    steps: c4.DynamicViewStepOrParallel[];
+    steps: c4.DynamicViewStep[];
     rules: Array<c4.DynamicViewRule>;
     variant: c4.DynamicViewDisplayVariant | undefined;
     manualLayout?: c4.ViewManualLayout;
@@ -202,12 +203,6 @@ export declare function toRelationshipStyle(props: ast.RelationshipStyleProperty
     head?: c4.RelationshipArrowType;
     tail?: c4.RelationshipArrowType;
 };
-export declare function toRelationshipStyleExcludeDefaults(props: ast.SpecificationRelationshipKind['props'] | undefined, isValid: IsValidFn): {
-    tail?: any;
-    head?: any;
-    line?: any;
-    color?: any;
-};
 export declare function toColor(astNode: ast.ColorProperty): c4.Color | undefined;
 export declare function toAutoLayout(rule: ast.ViewRuleAutoLayout): c4.ViewRuleAutoLayout;
 export declare function toAstViewLayoutDirection(c4: c4.ViewRuleAutoLayout['direction']): ast.ViewLayoutDirection;

package/dist/ast.mjs

@@ -1,4 +1,3 @@
-import { DefaultArrowType, DefaultLineStyle, DefaultRelationshipColor } from "@likec4/core";
 import { nonexhaustive } from "@likec4/core/utils";
 import { AstUtils, DocumentState } from "langium";
 import { clamp, isNullish, isTruthy } from "remeda";
@@ -110,15 +109,6 @@ export function toRelationshipStyle(props, isValid) {
   }
   return result;
 }
-export function toRelationshipStyleExcludeDefaults(props, isValid) {
-  const { color, line, head, tail } = toRelationshipStyle(props?.filter(ast.isRelationshipStyleProperty), isValid);
-  return {
-    ...color && color !== DefaultRelationshipColor ? { color } : {},
-    ...line && line !== DefaultLineStyle ? { line } : {},
-    ...head && head !== DefaultArrowType ? { head } : {},
-    ...tail ? { tail } : {}
-  };
-}
 export function toColor(astNode) {
   return astNode?.themeColor ?? astNode?.customColor?.$refText;
 }