@likec4/language-server 1.17.1 → 1.19.0

package/dist/model/parser/ViewsParser.d.ts

@@ -0,0 +1,64 @@
+import type * as c4 from '@likec4/core';
+import { ast, type ParsedAstDynamicView, type ParsedAstElementView } from '../../ast';
+import type { NotationProperty } from '../../generated/ast';
+import type { WithDeploymentView } from './DeploymentViewParser';
+import type { WithPredicates } from './PredicatesParser';
+export type WithViewsParser = ReturnType<typeof ViewsParser>;
+export declare function ViewsParser<TBase extends WithPredicates & WithDeploymentView>(B: TBase): {
+    new (...args: any[]): {
+        parseViews(): void;
+        parseElementView(astNode: ast.ElementView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): ParsedAstElementView;
+        parseViewRule(astRule: ast.ViewRule): c4.ViewRule;
+        parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ViewRulePredicate;
+        parseViewRuleGlobalPredicateRef(astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef): c4.ViewRuleGlobalPredicateRef;
+        parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleStyleOrGlobalRef;
+        parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ViewRuleGroup;
+        parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ViewRuleStyle;
+        parseRuleStyle(styleProperties: ast.StyleProperty[], elementExpressionsIterator: ast.ElementExpressionsIterator, notationProperty?: NotationProperty): c4.ViewRuleStyle;
+        parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
+        parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): ParsedAstDynamicView;
+        parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
+        parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
+        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps;
+        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep;
+        parsePredicate(astNode: ast.Predicate): c4.Expression;
+        parseElementPredicate(astNode: ast.ElementPredicate): c4.ElementPredicateExpression;
+        parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[];
+        parseElementExpression(astNode: ast.ElementExpression): c4.ElementExpression;
+        parseElementPredicateWhere(astNode: ast.ElementPredicateWhere): c4.ElementWhereExpr;
+        parseElementPredicateWith(astNode: ast.ElementPredicateWith): c4.CustomElementExpr;
+        parseRelationPredicate(astNode: ast.RelationPredicate): c4.RelationPredicateExpression;
+        parseRelationPredicateWhere(astNode: ast.RelationPredicateWhere): c4.RelationWhereExpr;
+        parseRelationPredicateWith(astNode: ast.RelationPredicateWith, relation: c4.RelationExpression | c4.RelationWhereExpr): c4.CustomRelationExpr;
+        parseRelationExpression(astNode: ast.RelationExpression): c4.RelationExpression;
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+        getAstNodePath(node: c4): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
+        parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
+        parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate;
+        parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle;
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        parseDeployment(): void;
+        parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
+        parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
+        parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
+    };
+} & TBase;

package/dist/model/parser/ViewsParser.js

@@ -0,0 +1,377 @@
+import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
+import { isArray, isDefined, isNonNullish, isTruthy } from "remeda";
+import {
+  ast,
+  toAutoLayout,
+  toColor,
+  toElementStyle,
+  ViewOps
+} from "../../ast.js";
+import { logger, logWarnError } from "../../logger.js";
+import { stringHash } from "../../utils/index.js";
+import { elementRef } from "../../utils/elementRef.js";
+import { parseViewManualLayout } from "../../view-utils/manual-layout.js";
+import { removeIndent, toSingleLine } from "./Base.js";
+export function ViewsParser(B) {
+  return class ViewsParser extends B {
+    parseViews() {
+      const isValid = this.isValid;
+      for (const viewBlock of this.doc.parseResult.value.views) {
+        const localStyles = viewBlock.styles.flatMap((s) => {
+          try {
+            return isValid(s) ? this.parseViewRuleStyleOrGlobalRef(s) : [];
+          } catch (e) {
+            logWarnError(e);
+            return [];
+          }
+        });
+        for (const view of viewBlock.views) {
+          try {
+            if (!isValid(view)) {
+              continue;
+            }
+            switch (true) {
+              case ast.isElementView(view):
+                this.doc.c4Views.push(this.parseElementView(view, localStyles));
+                break;
+              case ast.isDynamicView(view):
+                this.doc.c4Views.push(this.parseDynamicElementView(view, localStyles));
+                break;
+              case ast.isDeploymentView(view):
+                this.doc.c4Views.push(this.parseDeploymentView(view));
+                break;
+              default:
+                nonexhaustive(view);
+            }
+          } catch (e) {
+            logWarnError(e);
+          }
+        }
+      }
+    }
+    parseElementView(astNode, additionalStyles) {
+      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) {
+        id = "view_" + stringHash(
+          this.doc.uri.toString(),
+          astPath,
+          viewOf ?? ""
+        );
+      }
+      const title = toSingleLine(body.props.find((p) => p.key === "title")?.value) ?? null;
+      const description = removeIndent(body.props.find((p) => p.key === "description")?.value) ?? null;
+      const tags = this.convertTags(body);
+      const links = this.convertLinks(body);
+      const manualLayout = parseViewManualLayout(astNode);
+      const view = {
+        __: "element",
+        id,
+        astPath,
+        title,
+        description,
+        tags,
+        links: isNonEmptyArray(links) ? links : null,
+        rules: [
+          ...additionalStyles,
+          ...body.rules.flatMap((n) => {
+            try {
+              return this.isValid(n) ? this.parseViewRule(n) : [];
+            } catch (e) {
+              logWarnError(e);
+              return [];
+            }
+          })
+        ],
+        ...viewOf && { viewOf },
+        ...manualLayout && { manualLayout }
+      };
+      ViewOps.writeId(astNode, view.id);
+      if ("extends" in astNode) {
+        const extendsView = astNode.extends.view.ref;
+        invariant(extendsView?.name, "view extends is not resolved: " + astNode.$cstNode?.text);
+        return Object.assign(view, {
+          extends: extendsView.name
+        });
+      }
+      return view;
+    }
+    parseViewRule(astRule) {
+      if (ast.isViewRulePredicate(astRule)) {
+        return this.parseViewRulePredicate(astRule);
+      }
+      if (ast.isViewRuleGlobalPredicateRef(astRule)) {
+        return this.parseViewRuleGlobalPredicateRef(astRule);
+      }
+      if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
+        return this.parseViewRuleStyleOrGlobalRef(astRule);
+      }
+      if (ast.isViewRuleAutoLayout(astRule)) {
+        return toAutoLayout(astRule);
+      }
+      if (ast.isViewRuleGroup(astRule)) {
+        return this.parseViewRuleGroup(astRule);
+      }
+      nonexhaustive(astRule);
+    }
+    parseViewRulePredicate(astNode) {
+      const exprs = [];
+      let predicate = astNode.predicates;
+      while (predicate) {
+        const { value, prev } = predicate;
+        try {
+          if (isTruthy(value) && this.isValid(value)) {
+            exprs.unshift(this.parsePredicate(value));
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+        if (!prev) {
+          break;
+        }
+        predicate = prev;
+      }
+      return ast.isIncludePredicate(astNode) ? { include: exprs } : { exclude: exprs };
+    }
+    parseViewRuleGlobalPredicateRef(astRule) {
+      return {
+        predicateId: astRule.predicate.$refText
+      };
+    }
+    parseViewRuleStyleOrGlobalRef(astRule) {
+      if (ast.isViewRuleStyle(astRule)) {
+        return this.parseViewRuleStyle(astRule);
+      }
+      if (ast.isViewRuleGlobalStyle(astRule)) {
+        return this.parseViewRuleGlobalStyle(astRule);
+      }
+      nonexhaustive(astRule);
+    }
+    parseViewRuleGroup(astNode) {
+      const groupRules = [];
+      for (const rule of astNode.groupRules) {
+        try {
+          if (!this.isValid(rule)) {
+            continue;
+          }
+          if (ast.isViewRulePredicate(rule)) {
+            groupRules.push(this.parseViewRulePredicate(rule));
+            continue;
+          }
+          if (ast.isViewRuleGroup(rule)) {
+            groupRules.push(this.parseViewRuleGroup(rule));
+            continue;
+          }
+          nonexhaustive(rule);
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+      return {
+        title: toSingleLine(astNode.title) ?? null,
+        groupRules,
+        ...toElementStyle(astNode.props, this.isValid)
+      };
+    }
+    parseViewRuleStyle(astRule) {
+      const styleProps = astRule.props.filter(ast.isStyleProperty);
+      const targets = astRule.target;
+      const notation = astRule.props.find(ast.isNotationProperty);
+      return this.parseRuleStyle(styleProps, targets, notation);
+    }
+    parseRuleStyle(styleProperties, elementExpressionsIterator, notationProperty) {
+      const styleProps = toElementStyle(styleProperties, this.isValid);
+      const notation = removeIndent(notationProperty?.value);
+      const targets = this.parseElementExpressionsIterator(elementExpressionsIterator);
+      return {
+        targets,
+        ...notation && { notation },
+        style: {
+          ...styleProps
+        }
+      };
+    }
+    parseViewRuleGlobalStyle(astRule) {
+      return {
+        styleId: astRule.style.$refText
+      };
+    }
+    parseDynamicElementView(astNode, additionalStyles) {
+      const body = astNode.body;
+      invariant(body, "DynamicElementView body is not defined");
+      const isValid = this.isValid;
+      const props = body.props.filter(isValid);
+      const astPath = this.getAstNodePath(astNode);
+      let id = astNode.name;
+      if (!id) {
+        id = "dynamic_" + stringHash(
+          this.doc.uri.toString(),
+          astPath
+        );
+      }
+      const title = toSingleLine(props.find((p) => p.key === "title")?.value) ?? null;
+      const description = removeIndent(props.find((p) => p.key === "description")?.value) ?? null;
+      const tags = this.convertTags(body);
+      const links = this.convertLinks(body);
+      ViewOps.writeId(astNode, id);
+      const manualLayout = parseViewManualLayout(astNode);
+      return {
+        __: "dynamic",
+        id,
+        astPath,
+        title,
+        description,
+        tags,
+        links: isNonEmptyArray(links) ? links : null,
+        rules: [
+          ...additionalStyles,
+          ...body.rules.flatMap((n) => {
+            try {
+              return isValid(n) ? this.parseDynamicViewRule(n) : [];
+            } catch (e) {
+              logWarnError(e);
+              return [];
+            }
+          }, [])
+        ],
+        steps: body.steps.reduce((acc, n) => {
+          try {
+            if (isValid(n)) {
+              if (ast.isDynamicViewParallelSteps(n)) {
+                acc.push(this.parseDynamicParallelSteps(n));
+              } else {
+                acc.push(this.parseDynamicStep(n));
+              }
+            }
+          } catch (e) {
+            logWarnError(e);
+          }
+          return acc;
+        }, []),
+        ...manualLayout && { manualLayout }
+      };
+    }
+    parseDynamicViewRule(astRule) {
+      if (ast.isDynamicViewIncludePredicate(astRule)) {
+        return this.parseDynamicViewIncludePredicate(astRule);
+      }
+      if (ast.isDynamicViewGlobalPredicateRef(astRule)) {
+        return this.parseViewRuleGlobalPredicateRef(astRule);
+      }
+      if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
+        return this.parseViewRuleStyleOrGlobalRef(astRule);
+      }
+      if (ast.isViewRuleAutoLayout(astRule)) {
+        return toAutoLayout(astRule);
+      }
+      nonexhaustive(astRule);
+    }
+    parseDynamicViewIncludePredicate(astRule) {
+      const include = [];
+      let iter = astRule.predicates;
+      while (iter) {
+        try {
+          if (isNonNullish(iter.value) && this.isValid(iter.value)) {
+            const c4expr = this.parseElementPredicate(iter.value);
+            include.unshift(c4expr);
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+        iter = iter.prev;
+      }
+      return { include };
+    }
+    parseDynamicParallelSteps(node) {
+      return {
+        __parallel: node.steps.map((step) => this.parseDynamicStep(step))
+      };
+    }
+    parseDynamicStep(node) {
+      const sourceEl = elementRef(node.source);
+      if (!sourceEl) {
+        throw new Error("Invalid reference to source");
+      }
+      const targetEl = elementRef(node.target);
+      if (!targetEl) {
+        throw new Error("Invalid reference to target");
+      }
+      let source = this.resolveFqn(sourceEl);
+      let target = this.resolveFqn(targetEl);
+      const title = removeIndent(node.title) ?? null;
+      let step = {
+        source,
+        target,
+        title
+      };
+      if (node.isBackward) {
+        step = {
+          source: target,
+          target: source,
+          title,
+          isBackward: true
+        };
+      }
+      if (!isArray(node.custom?.props)) {
+        return step;
+      }
+      for (const prop of node.custom.props) {
+        try {
+          switch (true) {
+            case ast.isRelationNavigateToProperty(prop): {
+              const viewId = prop.value.view.ref?.name;
+              if (isTruthy(viewId)) {
+                step.navigateTo = viewId;
+              }
+              break;
+            }
+            case ast.isRelationStringProperty(prop):
+            case ast.isNotationProperty(prop):
+            case ast.isNotesProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = removeIndent(prop.value) ?? "";
+              }
+              break;
+            }
+            case ast.isArrowProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = prop.value;
+              }
+              break;
+            }
+            case ast.isColorProperty(prop): {
+              const value = toColor(prop);
+              if (isDefined(value)) {
+                step[prop.key] = value;
+              }
+              break;
+            }
+            case ast.isLineProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = prop.value;
+              }
+              break;
+            }
+            default:
+              nonexhaustive(prop);
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+      return step;
+    }
+  };
+}

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

@@ -0,0 +1,15 @@
+import { Location, Range, TextEdit } from 'vscode-languageserver-types';
+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, change }: ChangeViewRequestParams): {
+        doc: ParsedLikeC4LangiumDocument;
+        modifiedRange: Range;
+        edits: TextEdit[];
+    };
+}

package/dist/model-change/ModelChanges.js

@@ -0,0 +1,89 @@
+import { invariant, nonexhaustive } from "@likec4/core";
+import { logger } from "@likec4/log";
+import { changeElementStyle } from "./changeElementStyle.js";
+import { changeViewLayout } from "./changeViewLayout.js";
+import { saveManualLayout } from "./saveManualLayout.js";
+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;
+    try {
+      await this.services.shared.workspace.WorkspaceLock.write(async () => {
+        const { doc, edits, modifiedRange } = 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: {
+            changes: {
+              [textDocument.uri]: edits
+            }
+          }
+        });
+        if (!applyResult.applied) {
+          lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`);
+          return;
+        }
+        result = {
+          uri: textDocument.uri,
+          range: modifiedRange
+        };
+      });
+    } catch (e) {
+      logger.error(`Failed to apply change ${changeView.change.op} ${changeView.viewId}`, e);
+    }
+    return result;
+  }
+  convertToTextEdit({ viewId, change }) {
+    const lookup = this.locator.locateViewAst(viewId);
+    if (!lookup) {
+      throw new Error(`LikeC4ModelChanges: view not found: ${viewId}`);
+    }
+    switch (change.op) {
+      case "change-element-style": {
+        return {
+          doc: lookup.doc,
+          ...changeElementStyle(this.services, {
+            ...lookup,
+            targets: change.targets,
+            style: change.style
+          })
+        };
+      }
+      case "change-autolayout": {
+        const edit2 = changeViewLayout(this.services, {
+          ...lookup,
+          layout: change.layout
+        });
+        return {
+          doc: lookup.doc,
+          modifiedRange: edit2.range,
+          edits: [edit2]
+        };
+      }
+      case "save-manual-layout":
+        const edit = saveManualLayout(this.services, {
+          ...lookup,
+          layout: change.layout
+        });
+        return {
+          doc: lookup.doc,
+          modifiedRange: edit.range,
+          edits: [edit]
+        };
+      default:
+        nonexhaustive(change);
+    }
+  }
+}

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

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

package/dist/model-change/changeElementStyle.js

@@ -0,0 +1,136 @@
+import { invariant, isAncestor } from "@likec4/core";
+import { GrammarUtils } from "langium";
+import { entries, filter, findLast, isTruthy, last } from "remeda";
+import { TextEdit } from "vscode-languageserver-types";
+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(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 = rule.target.value;
+  if (!target || isTruthy(rule.target.prev) || !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
+}) {
+  invariant(viewAst.body, `View ${view.id} has no body`);
+  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
+    };
+    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(style)) {
+        const value = key === "opacity" ? _value.toString() + "%" : _value;
+        const ruleProp = rule.props.find((p) => p.key === key);
+        if (ruleProp && ruleProp.$cstNode) {
+          const { range: { start, end } } = ruleProp.$cstNode;
+          includeRange({
+            start,
+            end
+          });
+          edits.push(TextEdit.replace({ start, end }, key + " " + 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
+  };
+}