@likec4/language-server 0.60.2 → 1.0.0-next.0

package/dist/Rpc.d.ts

@@ -1,7 +1,10 @@
 import type { LikeC4Services } from './module';
-export declare class Rpc {
+import { Disposable } from 'langium';
+export declare class Rpc implements Disposable {
     private services;
+    private disposables;
     constructor(services: LikeC4Services);
     init(): void;
+    dispose(): void;
 }
 //# sourceMappingURL=Rpc.d.ts.map

package/dist/Rpc.js

@@ -3,14 +3,24 @@ import { logError, logger } from "./logger.js";
 import { nonexhaustive } from "@likec4/core";
 import { URI, UriUtils } from "langium";
 import { isLikeC4LangiumDocument } from "./ast.js";
-import { buildDocuments, computeView, fetchModel, fetchRawModel, locate, onDidChangeModel } from "./protocol.js";
+import {
+  buildDocuments,
+  changeView,
+  computeView,
+  fetchComputedModel,
+  fetchModel,
+  locate,
+  onDidChangeModel
+} from "./protocol.js";
 export class Rpc {
   constructor(services) {
     this.services = services;
   }
+  disposables = [];
   init() {
     const modelBuilder = this.services.likec4.ModelBuilder;
     const modelLocator = this.services.likec4.ModelLocator;
+    const modelEditor = this.services.likec4.ModelChanges;
     const connection = this.services.shared.lsp.Connection;
     if (!connection) {
       logger.info(`[ServerRpc] no connection, not initializing`);
@@ -19,51 +29,66 @@ export class Rpc {
     logger.info(`[ServerRpc] init`);
     const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
     const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
-    modelBuilder.onModelParsed(
-      debounceFunction(
-        () => void connection.sendNotification(onDidChangeModel, "").catch(logError),
-        {
-          before: true,
-          after: true,
-          wait: 250,
-          maxWait: 1e3
-        }
-      )
-    );
-    connection.onRequest(fetchModel, async (cancelToken) => {
-      const model = await modelBuilder.buildModel(cancelToken);
-      return { model };
-    });
-    connection.onRequest(fetchRawModel, async (cancelToken) => {
-      const rawmodel = await modelBuilder.buildRawModel(cancelToken);
-      return { rawmodel };
-    });
-    connection.onRequest(computeView, async ({ viewId }, cancelToken) => {
-      const view = await modelBuilder.computeView(viewId, cancelToken);
-      return { view };
-    });
-    connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
-      const changed = docs.map((d) => URI.parse(d));
-      const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));
-      const deleted = LangiumDocuments.all.filter((d) => isLikeC4LangiumDocument(d) && notChanged(d.uri)).map((d) => d.uri).toArray();
-      logger.debug(
-        `[ServerRpc] received request to build:
+    this.disposables.push(
+      modelBuilder.onModelParsed(
+        debounceFunction(
+          () => void connection.sendNotification(onDidChangeModel, "").catch(logError),
+          {
+            before: true,
+            after: true,
+            wait: 250,
+            maxWait: 1e3
+          }
+        )
+      ),
+      connection.onRequest(fetchComputedModel, async (cancelToken) => {
+        const model = await modelBuilder.buildComputedModel(cancelToken);
+        return { model };
+      }),
+      connection.onRequest(fetchModel, async (cancelToken) => {
+        const model = await modelBuilder.buildModel(cancelToken);
+        return { model };
+      }),
+      connection.onRequest(computeView, async ({ viewId }, cancelToken) => {
+        const view = await modelBuilder.computeView(viewId, cancelToken);
+        return { view };
+      }),
+      connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
+        const changed = docs.map((d) => URI.parse(d));
+        const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));
+        const deleted = LangiumDocuments.all.filter((d) => isLikeC4LangiumDocument(d) && notChanged(d.uri)).map((d) => d.uri).toArray();
+        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")}`
-      );
-      await DocumentBuilder.update(changed, deleted, cancelToken);
-    });
-    connection.onRequest(locate, (params) => {
-      if ("element" in params) {
-        return modelLocator.locateElement(params.element, params.property ?? "name");
-      }
-      if ("relation" in params) {
-        return modelLocator.locateRelation(params.relation);
-      }
-      if ("view" in params) {
-        return modelLocator.locateView(params.view);
+        );
+        await DocumentBuilder.update(changed, deleted, cancelToken);
+      }),
+      connection.onRequest(locate, (params) => {
+        if ("element" in params) {
+          return modelLocator.locateElement(params.element, params.property ?? "name");
+        }
+        if ("relation" in params) {
+          return modelLocator.locateRelation(params.relation);
+        }
+        if ("view" in params) {
+          return modelLocator.locateView(params.view);
+        }
+        nonexhaustive(params);
+      }),
+      connection.onRequest(changeView, async (request, _cancelToken) => {
+        return await modelEditor.applyChange(request);
+      })
+    );
+  }
+  dispose() {
+    let item;
+    while (item = this.disposables.pop()) {
+      try {
+        item.dispose();
+      } catch (e) {
+        logError(e);
       }
-      nonexhaustive(params);
-    });
+    }
   }
 }

package/dist/ast.d.ts

@@ -136,4 +136,5 @@ export declare function toRelationshipStyleExcludeDefaults(props?: ast.Specifica
     color?: "amber" | "blue" | "green" | "indigo" | "muted" | "primary" | "red" | "secondary" | "sky" | "slate";
 };
 export declare function toAutoLayout(direction: ast.ViewLayoutDirection): c4.ViewRuleAutoLayout['autoLayout'];
+export declare function toAstViewLayoutDirection(c4: c4.ViewRuleAutoLayout['autoLayout']): ast.ViewLayoutDirection;
 //# sourceMappingURL=ast.d.ts.map

package/dist/ast.js

@@ -236,5 +236,25 @@ export function toAutoLayout(direction) {
     case "RightLeft": {
       return "RL";
     }
+    default:
+      nonexhaustive(direction);
+  }
+}
+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);
   }
 }

package/dist/elementRef.d.ts

@@ -2,7 +2,6 @@ import { type c4 } from '@likec4/core';
 import type { ast } from './ast';
 /**
  * Returns referenced AST Element
- *
  */
 export declare function elementRef(node: ast.ElementRef | ast.FqnElementRef): ast.Element | undefined;
 /**

package/dist/lsp/index.d.ts

@@ -1,7 +1,7 @@
 export * from './CodeLensProvider';
+export * from './DocumentHighlightProvider';
 export * from './DocumentLinkProvider';
 export * from './DocumentSymbolProvider';
 export * from './HoverProvider';
 export * from './SemanticTokenProvider';
-export * from './DocumentHighlightProvider';
 //# sourceMappingURL=index.d.ts.map

package/dist/lsp/index.js

@@ -1,6 +1,6 @@
 export * from "./CodeLensProvider.js";
+export * from "./DocumentHighlightProvider.js";
 export * from "./DocumentLinkProvider.js";
 export * from "./DocumentSymbolProvider.js";
 export * from "./HoverProvider.js";
 export * from "./SemanticTokenProvider.js";
-export * from "./DocumentHighlightProvider.js";

package/dist/model/fqn-computation.js

@@ -1,7 +1,7 @@
 import { AsFqn, nonexhaustive } from "@likec4/core";
 import { MultiMap } from "langium";
-import { isEmpty, isNil } from "remeda";
-import { ElementOps, ast } from "../ast.js";
+import { isEmpty, isNullish as isNil } from "remeda";
+import { ast, ElementOps } from "../ast.js";
 import { getFqnElementRef } from "../elementRef.js";
 export function computeDocumentFqn(document, services) {
   const c4fqns = document.c4fqns = new MultiMap();

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

@@ -8,9 +8,9 @@ export declare class LikeC4ModelBuilder {
     private langiumDocuments;
     private listeners;
     constructor(services: LikeC4Services);
-    buildRawModel(cancelToken?: CancellationToken): Promise<c4.LikeC4RawModel | null>;
-    private previousViews;
     buildModel(cancelToken?: CancellationToken): Promise<c4.LikeC4Model | null>;
+    private previousViews;
+    buildComputedModel(cancelToken?: CancellationToken): Promise<c4.LikeC4ComputedModel | null>;
     computeView(viewId: ViewID, cancelToken?: CancellationToken): Promise<c4.ComputedView | null>;
     onModelParsed(callback: ModelParsedListener): Disposable;
     private documents;

package/dist/model/model-builder.js

@@ -4,6 +4,7 @@ import {
   parentFqn
 } from "@likec4/core";
 import { computeView, LikeC4ModelGraph } from "@likec4/graph";
+import { deepEqual as eq } from "fast-equals";
 import { DocumentState, interruptAndCheck } from "langium";
 import * as R from "remeda";
 import { Disposable } from "vscode-languageserver";
@@ -183,7 +184,8 @@ ${printDocs(docs)}`);
   }
   langiumDocuments;
   listeners = [];
-  async buildRawModel(cancelToken) {
+  async buildModel(cancelToken) {
+    await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, cancelToken);
     return await this.services.shared.workspace.WorkspaceLock.read(async () => {
       if (cancelToken) {
         await interruptAndCheck(cancelToken);
@@ -202,11 +204,14 @@ ${printDocs(docs)}`);
     });
   }
   previousViews = {};
-  async buildModel(cancelToken) {
-    const model = await this.buildRawModel(cancelToken);
+  async buildComputedModel(cancelToken) {
+    const model = await this.buildModel(cancelToken);
     if (!model) {
       return null;
     }
+    if (cancelToken) {
+      await interruptAndCheck(cancelToken);
+    }
     const cache = this.services.WorkspaceCache;
     const viewsCache = this.services.WorkspaceCache;
     return cache.get(MODEL_CACHE, () => {
@@ -223,7 +228,7 @@ ${printDocs(docs)}`);
       assignNavigateTo(allViews);
       const views = R.mapToObj(allViews, (v) => {
         const previous = this.previousViews[v.id];
-        const view = previous && R.equals(v, previous) ? previous : v;
+        const view = previous && eq(v, previous) ? previous : v;
         viewsCache.set(computedViewKey(v.id), view);
         return [v.id, view];
       });
@@ -236,12 +241,15 @@ ${printDocs(docs)}`);
     });
   }
   async computeView(viewId, cancelToken) {
-    const model = await this.buildRawModel(cancelToken);
+    const model = await this.buildModel(cancelToken);
     const view = model?.views[viewId];
     if (!view) {
       logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
       return null;
     }
+    if (cancelToken) {
+      await interruptAndCheck(cancelToken);
+    }
     const cache = this.services.WorkspaceCache;
     return cache.get(computedViewKey(viewId), () => {
       const index = new LikeC4ModelGraph(model);
@@ -263,9 +271,7 @@ ${printDocs(docs)}`);
         }
       });
       const previous = this.previousViews[viewId];
-      if (previous) {
-        computedView = R.equals(computedView, previous) ? previous : computedView;
-      }
+      computedView = previous && eq(computedView, previous) ? previous : computedView;
       this.previousViews[viewId] = computedView;
       return computedView;
     });

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

@@ -1,6 +1,6 @@
 import type { likec4 as c4 } from '@likec4/core';
 import type { Location } from 'vscode-languageserver-protocol';
-import type { ParsedAstElement } from '../ast';
+import type { ParsedAstElement, ParsedLikeC4LangiumDocument } from '../ast';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4ModelLocator {
@@ -12,6 +12,11 @@ export declare class LikeC4ModelLocator {
     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: ParsedLikeC4LangiumDocument;
+        view: import("../ast").ParsedAstElementView;
+        viewAst: ast.ElementView;
+    } | null;
     locateView(viewId: c4.ViewID): Location | null;
 }
 //# sourceMappingURL=model-locator.d.ts.map

package/dist/model/model-locator.js

@@ -73,36 +73,47 @@ export class LikeC4ModelLocator {
     }
     return null;
   }
-  locateView(viewId) {
+  locateViewAst(viewId) {
     for (const doc of this.documents()) {
       const view = doc.c4Views.find((r) => r.id === viewId);
       if (!view) {
         continue;
       }
-      const node = this.services.workspace.AstNodeLocator.getAstNode(
+      const viewAst = this.services.workspace.AstNodeLocator.getAstNode(
         doc.parseResult.value,
         view.astPath
       );
-      if (!ast.isElementView(node)) {
-        continue;
-      }
-      let targetNode = node.$cstNode;
-      if (node.name) {
-        targetNode = findNodeForProperty(node.$cstNode, "name") ?? targetNode;
-      } else if ("viewOf" in node) {
-        targetNode = findNodeForProperty(node.$cstNode, "viewOf") ?? targetNode;
-      }
-      if (!targetNode) {
-        return null;
+      if (ast.isElementView(viewAst)) {
+        return {
+          doc,
+          view,
+          viewAst
+        };
       }
-      return {
-        uri: doc.uri.toString(),
-        range: {
-          start: targetNode.range.start,
-          end: targetNode.range.start
-        }
-      };
     }
     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;
+    }
+    if (!targetNode) {
+      return null;
+    }
+    return {
+      uri: res.doc.uri.toString(),
+      range: {
+        start: targetNode.range.start,
+        end: targetNode.range.start
+      }
+    };
+  }
 }

package/dist/model/model-parser.js

@@ -1,6 +1,5 @@
 import { InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
 import { AstUtils } from "langium";
-import objectHash from "object-hash";
 import { isTruthy } from "remeda";
 import stripIndent from "strip-indent";
 import {
@@ -18,6 +17,7 @@ import {
 } from "../ast.js";
 import { elementRef, getFqnElementRef } from "../elementRef.js";
 import { logError, logger, logWarnError } from "../logger.js";
+import { stringHash } from "../utils/index.js";
 const { getDocument } = AstUtils;
 function toSingleLine(str) {
   return str ? removeIndent(str).split("\n").join(" ") : void 0;
@@ -142,11 +142,11 @@ export class LikeC4ModelParser {
       astNode.title ?? astNode.body?.props.find((p) => p.key === "title")?.value
     ) ?? "";
     const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
-    const id = objectHash({
+    const id = stringHash(
       astPath,
       source,
       target
-    });
+    );
     return {
       id,
       astPath,
@@ -311,13 +311,23 @@ export class LikeC4ModelParser {
     const body = astNode.body;
     invariant(body, "ElementView body is not defined");
     const astPath = this.getAstNodePath(astNode);
+    let viewOf = null;
+    if ("viewOf" in astNode) {
+      const viewOfEl = elementRef(astNode.viewOf);
+      const _viewOf = viewOfEl && this.resolveFqn(viewOfEl);
+      if (!_viewOf) {
+        logger.warn("viewOf is not resolved: " + astNode.$cstNode?.text);
+      } else {
+        viewOf = _viewOf;
+      }
+    }
     let id = astNode.name;
     if (!id) {
-      const doc = getDocument(astNode).uri.toString();
-      id = objectHash({
-        doc,
-        astPath
-      });
+      id = "view_" + stringHash(
+        getDocument(astNode).uri.toString(),
+        astPath,
+        viewOf ?? ""
+      );
     }
     const title = body.props.find((p) => p.key === "title")?.value;
     const description = body.props.find((p) => p.key === "description")?.value;
@@ -326,6 +336,7 @@ export class LikeC4ModelParser {
     const basic = {
       id,
       astPath,
+      ...viewOf && { viewOf },
       ...title && { title },
       ...description && { description },
       ...tags && { tags },
@@ -340,15 +351,6 @@ export class LikeC4ModelParser {
       })
     };
     ElementViewOps.writeId(astNode, basic.id);
-    if ("viewOf" in astNode) {
-      const viewOfEl = elementRef(astNode.viewOf);
-      const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
-      invariant(viewOf, " viewOf is not resolved: " + astNode.$cstNode?.text);
-      return {
-        ...basic,
-        viewOf
-      };
-    }
     if ("extends" in astNode) {
       const extendsView = astNode.extends.view.ref;
       invariant(extendsView?.name, "view extends is not resolved: " + astNode.$cstNode?.text);

package/dist/model-change/ModelChanges.d.ts

@@ -0,0 +1,15 @@
+import { Location, TextEdit } from 'vscode-languageserver-protocol';
+import { type ParsedLikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+import type { ChangeViewRequestParams } from '../protocol';
+export declare class LikeC4ModelChanges {
+    private services;
+    private locator;
+    constructor(services: LikeC4Services);
+    applyChange(changeView: ChangeViewRequestParams): Promise<Location | null>;
+    protected convertToTextEdit({ viewId, changes }: ChangeViewRequestParams): {
+        doc: ParsedLikeC4LangiumDocument;
+        edits: TextEdit[];
+    };
+}
+//# sourceMappingURL=ModelChanges.d.ts.map

package/dist/model-change/ModelChanges.js

@@ -0,0 +1,94 @@
+import { invariant, nonexhaustive } from "@likec4/core";
+import { Range, TextDocumentEdit } from "vscode-languageserver-protocol";
+import { changeViewLayout } from "./changeViewLayout.js";
+import { changeViewStyle } from "./changeViewStyle.js";
+function unionRangeOfAllEdits(edits) {
+  let start = Number.MAX_SAFE_INTEGER;
+  let end = Number.MIN_SAFE_INTEGER;
+  for (const edit of edits) {
+    start = Math.min(start, edit.range.start.line);
+    end = Math.max(end, edit.range.end.line);
+  }
+  return Range.create(start, 0, end, 0);
+}
+export class LikeC4ModelChanges {
+  constructor(services) {
+    this.services = services;
+    this.locator = services.likec4.ModelLocator;
+  }
+  locator;
+  async applyChange(changeView) {
+    const lspConnection = this.services.shared.lsp.Connection;
+    invariant(lspConnection, "LSP Connection not available");
+    let result = null;
+    await this.services.shared.workspace.WorkspaceLock.write(async () => {
+      const { doc, edits } = this.convertToTextEdit(changeView);
+      const textDocument = {
+        uri: doc.textDocument.uri,
+        version: doc.textDocument.version
+      };
+      if (!edits.length) {
+        return;
+      }
+      const applyResult = await lspConnection.workspace.applyEdit({
+        label: `LikeC4 - change view ${changeView.viewId}`,
+        edit: {
+          documentChanges: [
+            TextDocumentEdit.create(textDocument, edits)
+          ]
+        }
+      });
+      if (!applyResult.applied) {
+        lspConnection.window.showErrorMessage(`Failed to apply changes${applyResult.failureReason}`);
+        return;
+      }
+      result = {
+        uri: textDocument.uri,
+        range: unionRangeOfAllEdits(edits)
+      };
+    });
+    return result;
+  }
+  convertToTextEdit({ viewId, changes }) {
+    const lookup = this.locator.locateViewAst(viewId);
+    if (!lookup) {
+      throw new Error(`View not found: ${viewId}`);
+    }
+    const edits = [];
+    for (const change of changes) {
+      switch (change.op) {
+        case "change-color": {
+          edits.push(...changeViewStyle(this.services, {
+            ...lookup,
+            targets: change.targets,
+            key: "color",
+            value: change.color
+          }));
+          break;
+        }
+        case "change-shape": {
+          edits.push(...changeViewStyle(this.services, {
+            ...lookup,
+            targets: change.targets,
+            key: "shape",
+            value: change.shape
+          }));
+          break;
+        }
+        case "change-autolayout": {
+          edits.push(...changeViewLayout(this.services, {
+            ...lookup,
+            layout: change.layout
+          }));
+          break;
+        }
+        default:
+          nonexhaustive(change);
+      }
+    }
+    return {
+      doc: lookup.doc,
+      edits
+    };
+  }
+}

package/dist/model-change/changeViewLayout.d.ts

@@ -0,0 +1,13 @@
+import { type AutoLayoutDirection } from '@likec4/core';
+import { TextEdit } from 'vscode-languageserver-protocol';
+import { ast, type ParsedAstElementView, type ParsedLikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+type ChangeViewLayoutArg = {
+    view: ParsedAstElementView;
+    doc: ParsedLikeC4LangiumDocument;
+    viewAst: ast.ElementView;
+    layout: AutoLayoutDirection;
+};
+export declare function changeViewLayout(services: LikeC4Services, { view, viewAst, layout }: ChangeViewLayoutArg): TextEdit[];
+export {};
+//# sourceMappingURL=changeViewLayout.d.ts.map

package/dist/model-change/changeViewLayout.js

@@ -0,0 +1,30 @@
+import { invariant } from "@likec4/core";
+import { GrammarUtils } from "langium";
+import { last } from "remeda";
+import { TextEdit } from "vscode-languageserver-protocol";
+import { ast, toAstViewLayoutDirection } from "../ast.js";
+const { findNodeForProperty } = GrammarUtils;
+export function changeViewLayout(services, {
+  view,
+  viewAst,
+  layout
+}) {
+  const viewCstNode = viewAst.$cstNode;
+  invariant(viewCstNode, "viewCstNode");
+  const newlayout = toAstViewLayoutDirection(layout);
+  const existingRule = viewAst.body.rules.findLast(ast.isViewRuleAutoLayout);
+  if (existingRule && existingRule.$cstNode) {
+    const directionCstNode = findNodeForProperty(existingRule.$cstNode, "direction");
+    if (directionCstNode) {
+      return [TextEdit.replace(directionCstNode.range, newlayout)];
+    }
+    return [TextEdit.replace(existingRule.$cstNode.range, `autoLayout ${newlayout}`)];
+  }
+  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? last(viewAst.body.props)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.start;
+  invariant(insertPos, "insertPos is not defined");
+  const indent = " ".repeat(2 + viewCstNode.range.start.character);
+  const insert = `
+
+${indent}autoLayout ${newlayout}`;
+  return [TextEdit.insert(insertPos, insert)];
+}

package/dist/model-change/changeViewStyle.d.ts

@@ -0,0 +1,15 @@
+import { type Fqn, type NonEmptyArray } from '@likec4/core';
+import { TextEdit } from 'vscode-languageserver-protocol';
+import { ast, type ParsedAstElementView, type ParsedLikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+type ChangeViewStyleArg = {
+    view: ParsedAstElementView;
+    doc: ParsedLikeC4LangiumDocument;
+    viewAst: ast.ElementView;
+    key: string;
+    value: string;
+    targets: NonEmptyArray<Fqn>;
+};
+export declare function changeViewStyle(services: LikeC4Services, { view, viewAst, targets, key, value }: ChangeViewStyleArg): TextEdit[];
+export {};
+//# sourceMappingURL=changeViewStyle.d.ts.map

package/dist/model-change/changeViewStyle.js

@@ -0,0 +1,123 @@
+import { invariant, isAncestor, nonNullable } from "@likec4/core";
+import { GrammarUtils } from "langium";
+import { findLast, last, partition } from "remeda";
+import { TextEdit } from "vscode-languageserver-protocol";
+import { ast } from "../ast.js";
+const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
+const asViewStyleRule = (target, key, value, indent = 0) => {
+  const indentStr = indent > 0 ? " ".repeat(indent) : "";
+  return [
+    indentStr + `style ${target} {`,
+    indentStr + `  ${key} ${value}`,
+    indentStr + `}`
+  ].join("\n");
+};
+const isMatchingViewRule = (fqn, index) => (rule) => {
+  if (!ast.isViewRuleStyle(rule)) {
+    return false;
+  }
+  const [target, ...rest] = rule.targets;
+  if (!target || rest.length > 0 || !ast.isElementRef(target)) {
+    return false;
+  }
+  const ref = target.el.ref;
+  const _fqn = ref ? index.getFqn(ref) : null;
+  return _fqn === fqn;
+};
+export function changeViewStyle(services, {
+  view,
+  viewAst,
+  targets,
+  key,
+  value
+}) {
+  const viewCstNode = viewAst.$cstNode;
+  invariant(viewCstNode, "viewCstNode");
+  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? last(viewAst.body.props)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.start;
+  invariant(insertPos, "insertPos is not defined");
+  const indent = viewCstNode.range.start.character + 2;
+  const fqnIndex = services.likec4.FqnIndex;
+  const styleRules = viewAst.body.rules.filter(ast.isViewRuleStyle);
+  const viewOf = view.viewOf;
+  const targetsWithRules = targets.map((target) => {
+    const rule = findLast(styleRules, isMatchingViewRule(target, fqnIndex));
+    const fqn = viewOf && isAncestor(viewOf, target) ? target.substring(viewOf.length + 1) : target;
+    if (rule) {
+      return {
+        fqn,
+        rule
+      };
+    } else {
+      return {
+        fqn
+      };
+    }
+  });
+  const [existing, insert] = partition(
+    targetsWithRules,
+    (a) => !!a.rule
+  );
+  const modifiedRange = {
+    start: insertPos,
+    end: insertPos
+  };
+  const includeRange = (range) => {
+    if (range.start.line < modifiedRange.start.line) {
+      modifiedRange.start = range.start;
+    }
+    if (range.end.line > modifiedRange.end.line) {
+      modifiedRange.end = range.end;
+    }
+  };
+  const edits = [];
+  if (insert.length > 0) {
+    const linesToInsert = [
+      "",
+      ...insert.map(({ fqn }) => asViewStyleRule(fqn, key, value, indent))
+    ];
+    edits.push(
+      TextEdit.insert(
+        insertPos,
+        linesToInsert.join("\n")
+      )
+    );
+    modifiedRange.end = {
+      line: modifiedRange.end.line + linesToInsert.length,
+      character: last(linesToInsert)?.length ?? insertPos.character
+    };
+  }
+  if (existing.length > 0) {
+    for (const { rule } of existing) {
+      const ruleCstNode = rule.$cstNode;
+      invariant(ruleCstNode, "RuleCstNode not found");
+      const ruleProp = rule.styleprops.find((p) => p.key === key);
+      if (ruleProp && ruleProp.$cstNode) {
+        const { range: { start, end } } = nonNullable(
+          findNodeForProperty(ruleProp.$cstNode, "value"),
+          "cant find value cst node"
+        );
+        includeRange(ruleProp.$cstNode.range);
+        edits.push(TextEdit.replace({ start, end }, value));
+        continue;
+      }
+      const insertPos2 = findNodeForKeyword(ruleCstNode, "{")?.range.end;
+      invariant(insertPos2, "Opening brace not found");
+      const indentStr = " ".repeat(2 + ruleCstNode.range.start.character);
+      const insertKeyValue = indentStr + key + " " + value;
+      edits.push(
+        TextEdit.insert(
+          insertPos2,
+          "\n" + insertKeyValue
+        )
+      );
+      includeRange({
+        start: insertPos2,
+        end: {
+          line: insertPos2.line + 1,
+          character: insertKeyValue.length
+        }
+      });
+    }
+  }
+  return edits;
+}

package/dist/module.d.ts

@@ -2,6 +2,7 @@ import { type Module, WorkspaceCache } from 'langium';
 import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
 import { LikeC4CodeLensProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
 import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
+import { LikeC4ModelChanges } from './model-change/ModelChanges';
 import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { Rpc } from './Rpc';
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared';
@@ -26,6 +27,7 @@ export interface LikeC4AddedServices {
         ModelParser: LikeC4ModelParser;
         ModelBuilder: LikeC4ModelBuilder;
         ModelLocator: LikeC4ModelLocator;
+        ModelChanges: LikeC4ModelChanges;
     };
     lsp: {
         DocumentHighlightProvider: LikeC4DocumentHighlightProvider;

package/dist/module.js

@@ -15,6 +15,7 @@ import {
   LikeC4SemanticTokenProvider
 } from "./lsp/index.js";
 import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from "./model/index.js";
+import { LikeC4ModelChanges } from "./model-change/ModelChanges.js";
 import { LikeC4ScopeComputation, LikeC4ScopeProvider } from "./references/index.js";
 import { Rpc } from "./Rpc.js";
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from "./shared/index.js";
@@ -35,6 +36,7 @@ export const LikeC4Module = {
   WorkspaceCache: (services) => new WorkspaceCache(services.shared),
   Rpc: bind(Rpc),
   likec4: {
+    ModelChanges: bind(LikeC4ModelChanges),
     FqnIndex: bind(FqnIndex),
     ModelParser: bind(LikeC4ModelParser),
     ModelBuilder: bind(LikeC4ModelBuilder),

package/dist/protocol.d.ts

@@ -1,22 +1,27 @@
-import type { ComputedView, Fqn, LikeC4Model, LikeC4RawModel, RelationID, ViewID } from '@likec4/core';
+import type { AutoLayoutDirection, ComputedView, ElementShape, Fqn, LikeC4ComputedModel, LikeC4Model, NonEmptyArray, RelationID, ThemeColor, ViewID } from '@likec4/core';
 import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
 import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
 export declare const onDidChangeModel: NotificationType<string>;
-export declare const fetchRawModel: RequestType0<{
-    rawmodel: LikeC4RawModel | null;
-}, void>;
+export type OnDidChangeModelNotification = typeof onDidChangeModel;
 export declare const fetchModel: RequestType0<{
     model: LikeC4Model | null;
 }, void>;
+export type FetchModelRequest = typeof fetchModel;
+export declare const fetchComputedModel: RequestType0<{
+    model: LikeC4ComputedModel | null;
+}, void>;
+export type FetchComputedModelRequest = typeof fetchComputedModel;
 export declare const computeView: RequestType<{
     viewId: ViewID;
 }, {
     view: ComputedView | null;
 }, void>;
-interface BuildDocumentsParams {
+export type ComputeViewRequest = typeof computeView;
+export interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
 export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
+export type BuildDocumentsRequest = typeof buildDocuments;
 export type LocateParams = {
     element: Fqn;
     property?: string;
@@ -26,5 +31,28 @@ export type LocateParams = {
     view: ViewID;
 };
 export declare const locate: RequestType<LocateParams, Location | null, void>;
-export {};
+export type LocateRequest = typeof locate;
+export declare namespace ChangeView {
+    interface ChangeColor {
+        op: 'change-color';
+        color: ThemeColor;
+        targets: NonEmptyArray<Fqn>;
+    }
+    interface ChangeShape {
+        op: 'change-shape';
+        shape: ElementShape;
+        targets: NonEmptyArray<Fqn>;
+    }
+    interface ChangeAutoLayout {
+        op: 'change-autolayout';
+        layout: AutoLayoutDirection;
+    }
+}
+export type ChangeView = ChangeView.ChangeColor | ChangeView.ChangeShape | ChangeView.ChangeAutoLayout;
+export interface ChangeViewRequestParams {
+    viewId: ViewID;
+    changes: NonEmptyArray<ChangeView>;
+}
+export declare const changeView: RequestType<ChangeViewRequestParams, Location | null, void>;
+export type ChangeViewRequest = typeof changeView;
 //# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -1,11 +1,14 @@
 import { NotificationType, RequestType, RequestType0 } from "vscode-languageserver-protocol";
 export const onDidChangeModel = new NotificationType("likec4/onDidChangeModel");
-export const fetchRawModel = new RequestType0(
-  "likec4/fetchRaw"
+export const fetchModel = new RequestType0(
+  "likec4/fetchModel"
+);
+export const fetchComputedModel = new RequestType0(
+  "likec4/fetchComputedModel"
 );
-export const fetchModel = new RequestType0("likec4/fetchModel");
 export const computeView = new RequestType(
   "likec4/computeView"
 );
 export const buildDocuments = new RequestType("likec4/build");
 export const locate = new RequestType("likec4/locate");
+export const changeView = new RequestType("likec4/change-view");

package/dist/references/scope-computation.d.ts

@@ -1,4 +1,4 @@
-import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
+import { type AstNodeDescription, DefaultScopeComputation, MultiMap, type PrecomputedScopes } from 'langium';
 import type { CancellationToken } from 'vscode-languageserver';
 import { ast, type LikeC4LangiumDocument } from '../ast';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;

package/dist/reset.d.ts

@@ -0,0 +1,2 @@
+// Do not add any other lines of code to this file!
+import '@total-typescript/ts-reset'

package/dist/shared/index.d.ts

@@ -1,4 +1,4 @@
-export * from './WorkspaceManager';
 export * from './NodeKindProvider';
+export * from './WorkspaceManager';
 export * from './WorkspaceSymbolProvider';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/index.js

@@ -1,3 +1,3 @@
-export * from "./WorkspaceManager.js";
 export * from "./NodeKindProvider.js";
+export * from "./WorkspaceManager.js";
 export * from "./WorkspaceSymbolProvider.js";

package/dist/test/testServices.d.ts

@@ -14,7 +14,7 @@ export declare function createTestServices(workspace?: string): {
         errors: string[];
         warnings: string[];
     }>;
-    buildModel: () => Promise<import("@likec4/core").LikeC4Model>;
+    buildModel: () => Promise<import("@likec4/core").LikeC4ComputedModel>;
     resetState: () => Promise<void>;
 };
 export type TestServices = ReturnType<typeof createTestServices>;

package/dist/test/testServices.js

@@ -80,7 +80,7 @@ export function createTestServices(workspace = "file:///test/workspace") {
   };
   const buildModel = async () => {
     await validateAll();
-    const model = await modelBuilder.buildModel();
+    const model = await modelBuilder.buildComputedModel();
     if (!model)
       throw new Error("No model found");
     return model;

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './stringHash';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from "./stringHash.js";

package/dist/utils/stringHash.d.ts

@@ -0,0 +1,2 @@
+export declare function stringHash(...str: [string, ...string[]]): string;
+//# sourceMappingURL=stringHash.d.ts.map

package/dist/utils/stringHash.js

@@ -0,0 +1,5 @@
+import hash from "string-hash";
+export function stringHash(...str) {
+  var s = str.length > 1 ? str.join(":::") : str[0];
+  return hash(s).toString(36);
+}

package/dist/validation/view-predicates/incoming.js

@@ -1,10 +1,10 @@
+import { isNullish } from "remeda";
 import { ast } from "../../ast.js";
-import { isNil } from "remeda";
 export const incomingExpressionChecks = (_services) => {
   return (el, accept) => {
     if (ast.isWildcardExpr(el.to) && ast.isViewRulePredicate(el.$container)) {
       const view = el.$container.$container.$container;
-      if (isNil(view.viewOf)) {
+      if (isNullish(view.viewOf)) {
         accept("warning", "Predicate is ignored as it concerns all relationships", {
           node: el
         });

package/dist/validation/view-predicates/index.d.ts

@@ -1,4 +1,4 @@
+export * from './custom-element-expr';
 export * from './incoming';
 export * from './outgoing';
-export * from './custom-element-expr';
 //# sourceMappingURL=index.d.ts.map

package/dist/validation/view-predicates/index.js

@@ -1,3 +1,3 @@
+export * from "./custom-element-expr.js";
 export * from "./incoming.js";
 export * from "./outgoing.js";
-export * from "./custom-element-expr.js";

package/dist/validation/view-predicates/outgoing.js

@@ -1,5 +1,5 @@
-import { ast } from "../../ast.js";
 import { isNil } from "remeda";
+import { ast } from "../../ast.js";
 export const outgoingExpressionChecks = (_services) => {
   return (el, accept) => {
     if (ast.isWildcardExpr(el.from)) {

package/dist/view-utils/resolve-relative-paths.js

@@ -1,6 +1,6 @@
+import { invariant } from "@likec4/core";
 import { uniq, zip } from "rambdax";
 import { hasAtLeast } from "remeda";
-import { invariant } from "@likec4/core";
 function commonAncestorPath(views, sep = "/") {
   if (views.length <= 1)
     return "";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.60.2",
+  "version": "1.0.0-next.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -29,6 +29,10 @@
       "types": "./dist/browser/index.d.ts",
       "default": "./dist/browser/index.js"
     },
+    "./protocol": {
+      "types": "./dist/protocol.d.ts",
+      "default": "./dist/protocol.js"
+    },
     "./node": {
       "types": "./dist/node/index.d.ts",
       "default": "./dist/node/index.js"
@@ -46,6 +50,10 @@
         "types": "./dist/browser/index.d.ts",
         "default": "./dist/browser/index.js"
       },
+      "./protocol": {
+        "types": "./dist/protocol.d.ts",
+        "default": "./dist/protocol.js"
+      },
       "./node": {
         "types": "./dist/node/index.d.ts",
         "default": "./dist/node/index.js"
@@ -66,16 +74,19 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "0.60.2",
-    "@likec4/graph": "0.60.2",
+    "@likec4/core": "1.0.0-next.0",
+    "@likec4/graph": "1.0.0-next.0",
+    "@total-typescript/ts-reset": "^0.5.1",
     "debounce-fn": "^6.0.0",
+    "fast-equals": "^5.0.1",
     "langium": "^3.0.0",
     "object-hash": "^3.0.0",
     "p-debounce": "^4.0.0",
     "rambdax": "^9.1.1",
-    "remeda": "^1.40.1",
+    "remeda": "^1.56.0",
+    "string-hash": "^1.1.3",
     "strip-indent": "^4.0.0",
-    "type-fest": "^4.10.3",
+    "type-fest": "^4.13.1",
     "ufo": "^1.3.2",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-protocol": "3.17.5",
@@ -84,15 +95,13 @@
   "devDependencies": {
     "@types/node": "^20.11.25",
     "@types/object-hash": "^3.0.6",
+    "@types/string-hash": "^1",
     "execa": "^8.0.1",
     "langium-cli": "^3.0.1",
-    "npm-run-all2": "^5.0.2",
-    "typescript": "^5.4.2",
+    "npm-run-all2": "^6.1.2",
+    "typescript": "^5.4.3",
     "unbuild": "^2.0.0",
     "vitest": "^1.4.0"
   },
-  "packageManager": "yarn@4.1.1",
-  "volta": {
-    "extends": "../../package.json"
-  }
+  "packageManager": "yarn@4.1.1"
 }