@likec4/language-server 1.1.0 → 1.2.0

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

@@ -0,0 +1,18 @@
+import { type Fqn, type NonEmptyArray } from '@likec4/core';
+import { type Range, TextEdit } from 'vscode-languageserver-protocol';
+import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+import type { ChangeView } from '../protocol';
+type ChangeElementStyleArg = {
+    view: ParsedAstView;
+    doc: ParsedLikeC4LangiumDocument;
+    viewAst: ast.LikeC4View;
+    targets: NonEmptyArray<Fqn>;
+    style: ChangeView.ChangeElementStyle['style'];
+};
+export declare function changeElementStyle(services: LikeC4Services, { view, viewAst, targets, style }: ChangeElementStyleArg): {
+    modifiedRange: Range;
+    edits: TextEdit[];
+};
+export {};
+//# sourceMappingURL=changeElementStyle.d.ts.map

package/dist/model-change/changeElementStyle.js

@@ -0,0 +1,141 @@
+import { invariant, isAncestor, nonNullable } from "@likec4/core";
+import { GrammarUtils } from "langium";
+import { entries, filter, findLast, last } from "remeda";
+import { TextEdit } from "vscode-languageserver-protocol";
+import { ast } from "../ast.js";
+const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
+const asViewStyleRule = (target, style, indent = 0) => {
+  const indentStr = indent > 0 ? " ".repeat(indent) : "";
+  return [
+    indentStr + `style ${target} {`,
+    ...entries.strict(style).map(
+      ([key, value]) => indentStr + `  ${key} ${key === "opacity" ? value.toString() + "%" : value}`
+    ),
+    indentStr + `}`
+  ];
+};
+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 changeElementStyle(services, {
+  view,
+  viewAst,
+  targets,
+  style
+}) {
+  const viewCstNode = viewAst.$cstNode;
+  invariant(viewCstNode, "viewCstNode");
+  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.end;
+  invariant(insertPos, "insertPos is not defined");
+  const indent = viewCstNode.range.start.character + 2;
+  const fqnIndex = services.likec4.FqnIndex;
+  const styleRules = filter(viewAst.body.rules, ast.isViewRuleStyle);
+  const viewOf = view.__ === "element" ? view.viewOf : null;
+  const existing = [];
+  const insert = [];
+  targets.forEach((target) => {
+    const rule = findLast(styleRules, isMatchingViewRule(target, fqnIndex));
+    const fqn = viewOf && isAncestor(viewOf, target) ? target.substring(viewOf.length + 1) : target;
+    if (rule) {
+      existing.push({ fqn, rule });
+    } else {
+      insert.push({ fqn });
+    }
+  });
+  const modifiedRange = {
+    start: insertPos,
+    end: insertPos
+  };
+  const includeRange = (range) => {
+    if (range.start.line <= modifiedRange.start.line) {
+      if (range.start.line == modifiedRange.start.line) {
+        modifiedRange.start.character = Math.min(range.start.character, modifiedRange.start.character);
+      } else {
+        modifiedRange.start = range.start;
+      }
+    }
+    if (range.end.line >= modifiedRange.end.line) {
+      if (range.end.line == modifiedRange.end.line) {
+        modifiedRange.end.character = Math.max(range.end.character, modifiedRange.end.character);
+      } else {
+        modifiedRange.end = range.end;
+      }
+    }
+  };
+  const edits = [];
+  if (insert.length > 0) {
+    const linesToInsert = insert.flatMap(({ fqn }) => asViewStyleRule(fqn, style, indent));
+    edits.push(
+      TextEdit.insert(
+        insertPos,
+        "\n" + linesToInsert.join("\n")
+      )
+    );
+    modifiedRange.start = {
+      line: insertPos.line + 1,
+      character: indent + 1
+    };
+    modifiedRange.end = {
+      line: insertPos.line + linesToInsert.length,
+      character: last(linesToInsert)?.length ?? 0
+    };
+  }
+  if (existing.length > 0) {
+    for (const { rule } of existing) {
+      const ruleCstNode = rule.$cstNode;
+      invariant(ruleCstNode, "RuleCstNode not found");
+      for (const [key, _value] of entries.strict(style)) {
+        const value = key === "opacity" ? _value.toString() + "%" : _value;
+        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({
+            start,
+            end: {
+              line: start.line,
+              character: start.character + value.length
+            }
+          });
+          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: {
+            line: insertPos2.line + 1,
+            character: indentStr.length
+          },
+          end: {
+            line: insertPos2.line + 1,
+            character: insertKeyValue.length
+          }
+        });
+      }
+    }
+  }
+  return {
+    modifiedRange,
+    edits
+  };
+}

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

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

package/dist/model-change/changeViewLayout.js

@@ -5,7 +5,6 @@ import { TextEdit } from "vscode-languageserver-protocol";
 import { ast, toAstViewLayoutDirection } from "../ast.js";
 const { findNodeForProperty } = GrammarUtils;
 export function changeViewLayout(services, {
-  view,
   viewAst,
   layout
 }) {
@@ -16,15 +15,15 @@ export function changeViewLayout(services, {
   if (existingRule && existingRule.$cstNode) {
     const directionCstNode = findNodeForProperty(existingRule.$cstNode, "direction");
     if (directionCstNode) {
-      return [TextEdit.replace(directionCstNode.range, newlayout)];
+      return TextEdit.replace(directionCstNode.range, newlayout);
     }
-    return [TextEdit.replace(existingRule.$cstNode.range, `autoLayout ${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;
+  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.end;
   invariant(insertPos, "insertPos is not defined");
   const indent = " ".repeat(2 + viewCstNode.range.start.character);
   const insert = `
 
 ${indent}autoLayout ${newlayout}`;
-  return [TextEdit.insert(insertPos, insert)];
+  return TextEdit.insert(insertPos, insert);
 }

package/dist/protocol.d.ts

@@ -1,4 +1,4 @@
-import type { AutoLayoutDirection, ComputedView, ElementShape, Fqn, LikeC4ComputedModel, LikeC4Model, NonEmptyArray, RelationID, ThemeColor, ViewID } from '@likec4/core';
+import type { AutoLayoutDirection, BorderStyle, 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>;
@@ -33,22 +33,22 @@ export type LocateParams = {
 export declare const locate: RequestType<LocateParams, Location | null, void>;
 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;
     }
+    interface ChangeElementStyle {
+        op: 'change-element-style';
+        style: {
+            border?: BorderStyle;
+            opacity?: number;
+            shape?: ElementShape;
+            color?: ThemeColor;
+        };
+        targets: NonEmptyArray<Fqn>;
+    }
 }
-export type ChangeView = ChangeView.ChangeColor | ChangeView.ChangeShape | ChangeView.ChangeAutoLayout;
+export type ChangeView = ChangeView.ChangeAutoLayout | ChangeView.ChangeElementStyle;
 export interface ChangeViewRequestParams {
     viewId: ViewID;
     changes: NonEmptyArray<ChangeView>;

package/dist/references/scope-computation.js

@@ -6,52 +6,55 @@ import { isTruthy } from "remeda";
 import { ast } from "../ast.js";
 import { logError } from "../logger.js";
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
-  computeExports(document, _cancelToken) {
-    return new Promise((resolve) => {
-      const docExports = [];
+  async computeExports(document, _cancelToken) {
+    const docExports = [];
+    try {
       const { specifications, models, views } = document.parseResult.value;
-      try {
-        for (const spec of specifications.flatMap((s) => [...s.elements, ...s.relationships])) {
+      for (const spec of specifications.flatMap((s) => [
+        ...s.elements,
+        ...s.relationships,
+        ...s.tags
+      ])) {
+        try {
+          if (ast.isSpecificationTag(spec)) {
+            if (spec.tag && isTruthy(spec.tag.name)) {
+              docExports.push(
+                this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
+              );
+            }
+            continue;
+          }
           if (spec.kind && isTruthy(spec.kind.name)) {
             docExports.push(
               this.descriptions.createDescription(spec.kind, spec.kind.name, document)
             );
           }
+        } catch (e) {
+          logError(e);
         }
-      } catch (e) {
-        logError(e);
-      }
-      try {
-        for (const spec of specifications.flatMap((s) => s.tags)) {
-          if (spec.tag && isTruthy(spec.tag.name)) {
-            docExports.push(
-              this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
-            );
-          }
-        }
-      } catch (e) {
-        logError(e);
       }
-      try {
-        for (const elAst of models.flatMap((m) => m.elements)) {
+      for (const elAst of models.flatMap((m) => m.elements)) {
+        try {
           if (ast.isElement(elAst) && isTruthy(elAst.name)) {
             docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
           }
+        } catch (e) {
+          logError(e);
         }
-      } catch (e) {
-        logError(e);
       }
-      try {
-        for (const viewAst of views.flatMap((v) => v.views)) {
+      for (const viewAst of views.flatMap((v) => v.views)) {
+        try {
           if (isTruthy(viewAst.name)) {
             docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
           }
+        } catch (e) {
+          logError(e);
         }
-      } catch (e) {
-        logError(e);
       }
-      resolve(docExports);
-    });
+    } catch (e) {
+      logError(e);
+    }
+    return docExports;
   }
   computeLocalScopes(document, _cancelToken) {
     return new Promise((resolve) => {
@@ -95,9 +98,11 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         }
       }
     }
-    for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
-      if (!localScope.has(name) && descriptions.length === 1) {
-        localScope.add(name, descriptions[0]);
+    if (nestedScopes.size > 0) {
+      for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
+        if (!localScope.has(name) && descriptions.length === 1) {
+          localScope.add(name, descriptions[0]);
+        }
       }
     }
     scopes.addAll(container, localScope.values());

package/dist/shared/NodeKindProvider.js

@@ -17,7 +17,7 @@ export class NodeKindProvider {
       case (ast.isModel(node) || ast.isModelViews(node) || ast.isSpecificationRule(node) || hasType(ast.Model) || hasType(ast.ModelViews) || hasType(ast.SpecificationRule)): {
         return SymbolKind.Namespace;
       }
-      case (ast.isElementView(node) || hasType(ast.ElementView)): {
+      case (ast.isLikeC4View(node) || hasType(ast.LikeC4View)): {
         return SymbolKind.Class;
       }
       case (ast.isTag(node) || hasType(ast.Tag) || (ast.isSpecificationTag(node) || hasType(ast.SpecificationTag))): {
@@ -43,6 +43,8 @@ export class NodeKindProvider {
         return CompletionItemKind.Module;
       case SymbolKind.Class:
         return CompletionItemKind.Class;
+      case SymbolKind.Enum:
+        return CompletionItemKind.Enum;
       case SymbolKind.EnumMember:
         return CompletionItemKind.EnumMember;
       case SymbolKind.TypeParameter:
@@ -52,7 +54,7 @@ export class NodeKindProvider {
       case SymbolKind.Event:
         return CompletionItemKind.Event;
       default:
-        return CompletionItemKind.Keyword;
+        return CompletionItemKind.Reference;
     }
   }
 }

package/dist/validation/dynamic-view-rule.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const dynamicViewRulePredicate: (_services: LikeC4Services) => ValidationCheck<ast.DynamicViewRulePredicate>;
+//# sourceMappingURL=dynamic-view-rule.d.ts.map

package/dist/validation/dynamic-view-rule.js

@@ -0,0 +1,32 @@
+import { nonexhaustive } from "@likec4/core";
+import { ast } from "../ast.js";
+import { logError } from "../logger.js";
+export const dynamicViewRulePredicate = (_services) => {
+  return (el, accept) => {
+    try {
+      for (const expr of el.expressions) {
+        switch (true) {
+          case ast.isElementRef(expr):
+          case ast.isDescedantsExpr(expr):
+          case ast.isCustomElementExpr(expr):
+          case ast.isExpandElementExpr(expr):
+            return;
+          case ast.isRelationExpr(expr):
+          case ast.isInOutExpr(expr):
+          case ast.isIncomingExpr(expr):
+          case ast.isOutgoingExpr(expr):
+          case ast.isElementKindExpr(expr):
+          case ast.isElementTagExpr(expr):
+          case ast.isWildcardExpr(expr):
+            return accept("warning", `Expression is not supported by dynamic views`, {
+              node: expr
+            });
+          default:
+            nonexhaustive(expr);
+        }
+      }
+    } catch (e) {
+      logError(e);
+    }
+  };
+};

package/dist/validation/dynamic-view-step.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const dynamicViewStep: (services: LikeC4Services) => ValidationCheck<ast.DynamicViewStep>;
+//# sourceMappingURL=dynamic-view-step.d.ts.map

package/dist/validation/dynamic-view-step.js

@@ -0,0 +1,33 @@
+import { isAncestor } from "@likec4/core";
+import { elementRef } from "../elementRef.js";
+import { logError } from "../logger.js";
+export const dynamicViewStep = (services) => {
+  const fqnIndex = services.likec4.FqnIndex;
+  return (el, accept) => {
+    try {
+      const sourceEl = elementRef(el.source);
+      const source = sourceEl && fqnIndex.getFqn(sourceEl);
+      if (!source) {
+        accept("error", "Source not found (not parsed/indexed yet)", {
+          node: el,
+          property: "source"
+        });
+      }
+      const targetEl = elementRef(el.target);
+      const target = targetEl && fqnIndex.getFqn(targetEl);
+      if (!target) {
+        accept("error", "Target not found (not parsed/indexed yet)", {
+          node: el,
+          property: "target"
+        });
+      }
+      if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
+        accept("error", "Invalid parent-child relationship", {
+          node: el
+        });
+      }
+    } catch (e) {
+      logError(e);
+    }
+  };
+};

package/dist/validation/index.js

@@ -1,4 +1,6 @@
 import { logger } from "../logger.js";
+import { dynamicViewRulePredicate } from "./dynamic-view-rule.js";
+import { dynamicViewStep } from "./dynamic-view-step.js";
 import { elementChecks } from "./element.js";
 import { opacityPropertyRuleChecks } from "./property-checks.js";
 import { relationChecks } from "./relation.js";
@@ -25,11 +27,13 @@ export function registerValidationChecks(services) {
     SpecificationRule: specificationRuleChecks(services),
     Model: modelRuleChecks(services),
     ModelViews: modelViewsChecks(services),
-    ElementView: viewChecks(services),
+    DynamicViewStep: dynamicViewStep(services),
+    LikeC4View: viewChecks(services),
     Element: elementChecks(services),
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
     Tag: tagChecks(services),
+    DynamicViewRulePredicate: dynamicViewRulePredicate(services),
     CustomElementExpr: customElementExprChecks(services),
     ExpandElementExpr: expandElementExprChecks(services),
     RelationshipKind: relationshipChecks(services),

package/dist/validation/view-predicates/expanded-element.js

@@ -4,6 +4,7 @@ export const expandElementExprChecks = (_services) => {
   return (el, accept) => {
     switch (true) {
       case ast.isIncludePredicate(el.$container):
+      case ast.isDynamicViewRulePredicate(el.$container):
       case ast.isViewRuleStyle(el.$container):
         return;
       case ast.isCustomElementExpr(el.$container):

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

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

package/dist/validation/view.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
-export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementView>;
+export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.LikeC4View>;
 //# sourceMappingURL=view.d.ts.map

package/dist/validation/view.js

@@ -2,12 +2,10 @@ import { ast } from "../ast.js";
 export const viewChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return (el, accept) => {
-    if (el.extends) {
-    }
     if (!el.name) {
       return;
     }
-    const anotherViews = index.allElements(ast.ElementView).filter((n) => n.name === el.name).limit(2).count();
+    const anotherViews = index.allElements(ast.LikeC4View).filter((n) => n.name === el.name).limit(2).count();
     if (anotherViews > 1) {
       accept("error", `Duplicate view '${el.name}'`, {
         node: el,

package/dist/view-utils/assignNavigateTo.d.ts

@@ -1,3 +1,3 @@
-import type { ComputedView } from '@likec4/core';
+import { type ComputedView } from '@likec4/core';
 export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;
 //# sourceMappingURL=assignNavigateTo.d.ts.map

package/dist/view-utils/assignNavigateTo.js

@@ -1,8 +1,9 @@
+import { isComputedElementView } from "@likec4/core";
 import { find } from "remeda";
 export function assignNavigateTo(views) {
   const allElementViews = /* @__PURE__ */ new Map();
   for (const v of views) {
-    if (v.viewOf && !v.extends) {
+    if (isComputedElementView(v) && v.viewOf && !v.extends) {
       const viewsOf = allElementViews.get(v.viewOf) ?? [];
       viewsOf.push(v.id);
       allElementViews.set(v.viewOf, viewsOf);

package/dist/view-utils/resolve-extended-views.d.ts

@@ -1,7 +1,7 @@
-import { type ElementView } from '@likec4/core';
+import { type View } from '@likec4/core';
 /**
  * Resolve rules of extended views
  * (Removes invalid views)
  */
-export declare function resolveRulesExtendedViews<V extends Record<any, ElementView>>(unresolvedViews: V): V;
+export declare function resolveRulesExtendedViews<V extends Record<any, View>>(unresolvedViews: V): V;
 //# sourceMappingURL=resolve-extended-views.d.ts.map

package/dist/view-utils/resolve-relative-paths.d.ts

@@ -1,3 +1,3 @@
-import type { ElementView } from '@likec4/core';
-export declare function resolveRelativePaths(views: ElementView[]): ElementView[];
+import type { View } from '@likec4/core';
+export declare function resolveRelativePaths(views: View[]): View[];
 //# sourceMappingURL=resolve-relative-paths.d.ts.map

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

@@ -1,10 +1,9 @@
 import { invariant } from "@likec4/core";
-import { uniq, zip } from "rambdax";
-import { hasAtLeast } from "remeda";
+import { hasAtLeast, unique, zip } from "remeda";
 function commonAncestorPath(views, sep = "/") {
   if (views.length <= 1)
     return "";
-  const uniqURIs = uniq(views.flatMap(({ docUri }) => docUri ? [docUri] : []));
+  const uniqURIs = unique(views.flatMap(({ docUri }) => docUri ? [docUri] : []));
   if (uniqURIs.length === 0)
     return "";
   if (uniqURIs.length === 1) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -61,7 +61,7 @@
     }
   },
   "scripts": {
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc -b",
     "watch:langium": "langium generate --watch",
     "watch:ts": "tsc --watch",
     "generate": "langium generate",
@@ -74,8 +74,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "1.1.0",
-    "@likec4/graph": "1.1.0",
+    "@likec4/core": "1.2.0",
+    "@likec4/graph": "1.2.0",
     "@total-typescript/ts-reset": "^0.5.1",
     "fast-equals": "^5.0.1",
     "langium": "^3.0.0",
@@ -92,7 +92,7 @@
     "vscode-uri": "3.0.8"
   },
   "devDependencies": {
-    "@types/node": "^20.12.7",
+    "@types/node": "^20.13.0",
     "@types/object-hash": "^3.0.6",
     "@types/string-hash": "^1",
     "execa": "^9.1.0",
@@ -102,5 +102,5 @@
     "unbuild": "^2.0.0",
     "vitest": "~1.5.2"
   },
-  "packageManager": "yarn@4.2.2"
+  "packageManager": "yarn@4.3.0"
 }

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

@@ -1,15 +0,0 @@
-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