@likec4/language-server 1.42.1 → 1.44.0

package/dist/model/parser/ViewsParser.mjs

@@ -1,490 +0,0 @@
-import * as c4 from "@likec4/core";
-import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { loggable } from "@likec4/log";
-import { filter, find, isDefined, isEmpty, isNonNullish, isNumber, isTruthy, last, mapToObj, pipe } from "remeda";
-import {
-  ast,
-  parseMarkdownAsString,
-  toAutoLayout,
-  toColor,
-  ViewOps
-} from "../../ast.mjs";
-import { logger as mainLogger } from "../../logger.mjs";
-import { stringHash } from "../../utils/index.mjs";
-import { elementRef } from "../../utils/elementRef.mjs";
-import { parseViewManualLayout } from "../../view-utils/manual-layout.mjs";
-import { removeIndent, toSingleLine } from "./Base.mjs";
-const logger = mainLogger.getChild("ViewsParser");
-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) {
-            logger.warn(loggable(e));
-            return [];
-          }
-        });
-        const folder = viewBlock.folder && !isEmpty(viewBlock.folder.trim()) ? toSingleLine(viewBlock.folder) : null;
-        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);
-            }
-            if (folder) {
-              const view2 = this.doc.c4Views.at(-1);
-              view2.title = folder + " / " + (view2.title || view2.id);
-            }
-          } catch (e) {
-            logger.warn(loggable(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 = null, description = null } = this.parseBaseProps(
-        pipe(
-          body.props,
-          filter((p) => this.isValid(p)),
-          filter(ast.isViewStringProperty),
-          mapToObj((p) => [p.key, p.value])
-        )
-      );
-      const tags = this.convertTags(body);
-      const links = this.convertLinks(body);
-      const manualLayout = parseViewManualLayout(astNode);
-      const view = {
-        [c4._type]: "element",
-        id,
-        astPath,
-        title: toSingleLine(title) ?? null,
-        description,
-        tags,
-        links: isNonEmptyArray(links) ? links : null,
-        rules: [
-          ...additionalStyles,
-          ...body.rules.flatMap((n) => {
-            try {
-              return this.isValid(n) ? this.parseElementViewRule(n) : [];
-            } catch (e) {
-              logger.warn(loggable(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;
-    }
-    parseElementViewRule(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.exprs;
-      while (predicate) {
-        const { value, prev } = predicate;
-        try {
-          if (isTruthy(value) && this.isValid(value)) {
-            const expr = this.parsePredicate(value);
-            exprs.unshift(expr);
-          }
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-        if (!prev) {
-          break;
-        }
-        predicate = prev;
-      }
-      return astNode.isInclude ? { 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) {
-          logger.warn(loggable(e));
-        }
-      }
-      return {
-        title: toSingleLine(astNode.title) ?? null,
-        groupRules,
-        ...this.parseStyleProps(astNode.props)
-      };
-    }
-    parseViewRuleStyle(astRule) {
-      const targets = this.parseFqnExpressions(astRule.targets).filter(
-        (e) => c4.ModelExpression.isFqnExpr(e)
-      );
-      const style = this.parseStyleProps(astRule.props.filter(ast.isStyleProperty));
-      const notation = removeIndent(parseMarkdownAsString(astRule.props.find(ast.isNotationProperty)?.value));
-      return {
-        targets,
-        style,
-        ...notation && { notation }
-      };
-    }
-    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 = null, description = null } = this.parseBaseProps(
-        pipe(
-          props,
-          filter(ast.isViewStringProperty),
-          mapToObj((p) => [p.key, p.value])
-        )
-      );
-      const tags = this.convertTags(body);
-      const links = this.convertLinks(body);
-      ViewOps.writeId(astNode, id);
-      const manualLayout = parseViewManualLayout(astNode);
-      const variant = find(props, ast.isDynamicViewDisplayVariantProperty)?.value;
-      return {
-        [c4._type]: "dynamic",
-        id,
-        astPath,
-        title: toSingleLine(title) ?? null,
-        description,
-        tags,
-        links: isNonEmptyArray(links) ? links : null,
-        variant,
-        rules: [
-          ...additionalStyles,
-          ...body.rules.flatMap((n) => {
-            try {
-              return isValid(n) ? this.parseDynamicViewRule(n) : [];
-            } catch (e) {
-              logger.warn(loggable(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) {
-            logger.warn(loggable(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.exprs;
-      while (iter) {
-        try {
-          if (isNonNullish(iter.value) && this.isValid(iter.value)) {
-            if (ast.isFqnExprOrWith(iter.value)) {
-              const c4expr = this.parseElementPredicate(iter.value);
-              include.unshift(c4expr);
-            }
-          }
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-        iter = iter.prev;
-      }
-      return { include };
-    }
-    parseDynamicParallelSteps(node) {
-      const parallelId = pathInsideDynamicView(node);
-      const __parallel = node.steps.map((step) => this.parseDynamicStep(step));
-      invariant(isNonEmptyArray(__parallel), "Dynamic parallel steps must have at least one step");
-      return {
-        parallelId,
-        __parallel
-      };
-    }
-    /**
-     * @returns non-empty array in case of step chain A -> B -> C
-     */
-    parseDynamicStep(node) {
-      if (ast.isDynamicStepSingle(node)) {
-        invariant(this.isValid(node));
-        return this.parseDynamicStepSingle(node);
-      }
-      const __series = this.recursiveParseDynamicStepChain(node);
-      invariant(isNonEmptyArray(__series), "Dynamic step chain must have at least one step");
-      return {
-        seriesId: pathInsideDynamicView(node),
-        __series
-      };
-    }
-    recursiveParseDynamicStepChain(node, callstack) {
-      if (ast.isDynamicStepSingle(node.source)) {
-        if (!this.isValid(node.source)) {
-          return [];
-        }
-        const previous2 = this.parseDynamicStepSingle(node.source);
-        if (previous2.isBackward) {
-          return [];
-        }
-        const thisStep2 = {
-          ...this.parseAbstractDynamicStep(node),
-          source: previous2.target
-        };
-        if (thisStep2.target === previous2.source) {
-          thisStep2.isBackward = true;
-        } else if (callstack) {
-          callstack.push([previous2.source, previous2.target]);
-          callstack.push([thisStep2.source, thisStep2.target]);
-        }
-        return [previous2, thisStep2];
-      }
-      callstack ??= [];
-      const allprevious = this.recursiveParseDynamicStepChain(node.source, callstack);
-      if (!isNonEmptyArray(allprevious) || !this.isValid(node)) {
-        return [];
-      }
-      const previous = last(allprevious);
-      const thisStep = {
-        ...this.parseAbstractDynamicStep(node),
-        source: previous.target
-      };
-      const index = callstack.findIndex(([source, target]) => source === thisStep.target && target === thisStep.source);
-      if (index !== -1) {
-        thisStep.isBackward = true;
-        callstack.splice(index, callstack.length - index);
-      } else {
-        callstack.push([thisStep.source, thisStep.target]);
-      }
-      return [...allprevious, thisStep];
-    }
-    parseDynamicStepSingle(node) {
-      const sourceEl = elementRef(node.source);
-      if (!sourceEl) {
-        throw new Error("Invalid reference to source");
-      }
-      let baseStep = {
-        ...this.parseAbstractDynamicStep(node),
-        source: this.resolveFqn(sourceEl)
-      };
-      if (node.isBackward) {
-        baseStep = {
-          ...baseStep,
-          source: baseStep.target,
-          target: baseStep.source,
-          isBackward: true
-        };
-      }
-      return baseStep;
-    }
-    parseAbstractDynamicStep(astnode) {
-      const targetEl = elementRef(astnode.target);
-      if (!targetEl) {
-        throw new Error("Invalid reference to target");
-      }
-      const step = {
-        target: this.resolveFqn(targetEl),
-        astPath: pathInsideDynamicView(astnode)
-      };
-      const title = removeIndent(astnode.title);
-      if (title) {
-        step.title = title;
-      }
-      const kind = astnode.kind?.ref?.name ?? astnode.dotKind?.kind.ref?.name;
-      if (kind) {
-        step.kind = kind;
-      }
-      for (const prop of astnode.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): {
-              if (isDefined(prop.value)) {
-                if (prop.key === "description") {
-                  const value = removeIndent(prop.value);
-                  if (value) {
-                    step.description = value;
-                  }
-                } else {
-                  step[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) ?? "";
-                }
-              }
-              break;
-            }
-            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) {
-          logger.warn(loggable(e));
-        }
-      }
-      return step;
-    }
-  };
-}
-function pathInsideDynamicView(_node) {
-  let node = _node;
-  let path = [];
-  while (!ast.isDynamicViewBody(node)) {
-    if (isNumber(node.$containerIndex)) {
-      path.unshift(
-        `@${node.$containerIndex}`
-      );
-    }
-    path.unshift(
-      `/${node.$containerProperty ?? "__invalid__"}`
-    );
-    node = node.$container;
-  }
-  return path.join("");
-}

package/dist/model-change/ModelChanges.mjs

@@ -1,89 +0,0 @@
-import { invariant, nonexhaustive } from "@likec4/core";
-import { logger } from "@likec4/log";
-import { changeElementStyle } from "./changeElementStyle.mjs";
-import { changeViewLayout } from "./changeViewLayout.mjs";
-import { saveManualLayout } from "./saveManualLayout.mjs";
-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 (error) {
-      logger.error(`Failed to apply change ${changeView.change.op} ${changeView.viewId}`, { error });
-    }
-    return result;
-  }
-  convertToTextEdit({ viewId, projectId, change }) {
-    const lookup = this.locator.locateViewAst(viewId, projectId);
-    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);
-    }
-  }
-}