@likec4/language-server 1.2.0 → 1.2.2

package/dist/model/model-parser.js

@@ -1,520 +0,0 @@
-import { InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { AstUtils } from "langium";
-import { isTruthy } from "remeda";
-import stripIndent from "strip-indent";
-import {
-  ast,
-  checksFromDiagnostics,
-  cleanParsedModel,
-  isFqnIndexedDocument,
-  parseAstOpacityProperty,
-  resolveRelationPoints,
-  streamModel,
-  toAutoLayout,
-  toElementStyle,
-  toRelationshipStyleExcludeDefaults,
-  ViewOps
-} 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;
-}
-function removeIndent(str) {
-  return str ? stripIndent(str).trim() : void 0;
-}
-export class LikeC4ModelParser {
-  constructor(services) {
-    this.services = services;
-    this.fqnIndex = services.likec4.FqnIndex;
-    logger.debug(`[ModelParser] Created`);
-  }
-  fqnIndex;
-  parse(doc) {
-    const docs = Array.isArray(doc) ? doc : [doc];
-    const result = [];
-    for (const doc2 of docs) {
-      if (!isFqnIndexedDocument(doc2)) {
-        logger.warn(`Not a FqnIndexedDocument: ${doc2.uri.toString(true)}`);
-        continue;
-      }
-      try {
-        result.push(this.parseLikeC4Document(doc2));
-      } catch (cause) {
-        logError(new InvalidModelError(`Error parsing document ${doc2.uri.toString()}`, { cause }));
-      }
-    }
-    return result;
-  }
-  parseLikeC4Document(_doc) {
-    const doc = cleanParsedModel(_doc);
-    const { isValid } = checksFromDiagnostics(doc);
-    this.parseSpecification(doc, isValid);
-    this.parseModel(doc, isValid);
-    this.parseViews(doc, isValid);
-    return doc;
-  }
-  parseSpecification(doc, isValid) {
-    const { parseResult, c4Specification } = doc;
-    const specifications = parseResult.value.specifications.filter(isValid);
-    const element_specs = specifications.flatMap((s) => s.elements.filter(isValid));
-    for (const { kind, style } of element_specs) {
-      try {
-        const kindName = kind.name;
-        c4Specification.kinds[kindName] = {
-          ...c4Specification.kinds[kindName],
-          ...toElementStyle(style?.props)
-        };
-      } catch (e) {
-        logWarnError(e);
-      }
-    }
-    const relations_specs = specifications.flatMap((s) => s.relationships.filter(isValid));
-    for (const { kind, props } of relations_specs) {
-      try {
-        const kindName = kind.name;
-        c4Specification.relationships[kindName] = {
-          ...c4Specification.relationships[kindName],
-          ...toRelationshipStyleExcludeDefaults(props)
-        };
-      } catch (e) {
-        logWarnError(e);
-      }
-    }
-  }
-  parseModel(doc, isValid) {
-    for (const el of streamModel(doc, isValid)) {
-      if (ast.isElement(el)) {
-        try {
-          doc.c4Elements.push(this.parseElement(el));
-        } catch (e) {
-          logWarnError(e);
-        }
-        continue;
-      }
-      if (ast.isRelation(el)) {
-        try {
-          doc.c4Relations.push(this.parseRelation(el));
-        } catch (e) {
-          logWarnError(e);
-        }
-        continue;
-      }
-      nonexhaustive(el);
-    }
-  }
-  parseElement(astNode) {
-    const id = this.resolveFqn(astNode);
-    const kind = astNode.kind.$refText;
-    const tags = this.convertTags(astNode.body);
-    const stylePropsAst = astNode.body?.props.find(ast.isStyleProperties)?.props;
-    const style = toElementStyle(stylePropsAst);
-    const astPath = this.getAstNodePath(astNode);
-    let [title, description, technology] = astNode.props ?? [];
-    const bodyProps = astNode.body?.props.filter(ast.isElementStringProperty) ?? [];
-    title = toSingleLine(title ?? bodyProps.find((p) => p.key === "title")?.value);
-    description = removeIndent(description ?? bodyProps.find((p) => p.key === "description")?.value);
-    technology = toSingleLine(technology ?? bodyProps.find((p) => p.key === "technology")?.value);
-    const links = astNode.body?.props.filter(ast.isLinkProperty).map((p) => p.value);
-    return {
-      id,
-      kind,
-      astPath,
-      title: title ?? astNode.name,
-      ...tags && { tags },
-      ...links && isNonEmptyArray(links) && { links },
-      ...isTruthy(technology) && { technology },
-      ...isTruthy(description) && { description },
-      style
-    };
-  }
-  parseRelation(astNode) {
-    const coupling = resolveRelationPoints(astNode);
-    const target = this.resolveFqn(coupling.target);
-    const source = this.resolveFqn(coupling.source);
-    const tags = this.convertTags(astNode) ?? this.convertTags(astNode.body);
-    const links = astNode.body?.props.filter(ast.isLinkProperty).map((p) => p.value);
-    const kind = astNode.kind?.ref?.name;
-    const astPath = this.getAstNodePath(astNode);
-    const title = toSingleLine(
-      astNode.title ?? astNode.body?.props.find((p) => p.key === "title")?.value
-    ) ?? "";
-    const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
-    const id = stringHash(
-      astPath,
-      source,
-      target
-    );
-    return {
-      id,
-      astPath,
-      source,
-      target,
-      title,
-      ...kind && { kind },
-      ...tags && { tags },
-      ...isNonEmptyArray(links) && { links },
-      ...toRelationshipStyleExcludeDefaults(styleProp?.props)
-    };
-  }
-  parseViews(doc, isValid) {
-    const views = doc.parseResult.value.views.flatMap((v) => isValid(v) ? v.views : []);
-    for (const view of views) {
-      try {
-        if (!isValid(view)) {
-          continue;
-        }
-        doc.c4Views.push(
-          ast.isElementView(view) ? this.parseElementView(view, isValid) : this.parseDynamicElementView(view, isValid)
-        );
-      } catch (e) {
-        logWarnError(e);
-      }
-    }
-  }
-  parseElementExpr(astNode) {
-    if (ast.isWildcardExpr(astNode)) {
-      return {
-        wildcard: true
-      };
-    }
-    if (ast.isElementKindExpr(astNode)) {
-      return {
-        elementKind: astNode.kind.$refText,
-        isEqual: astNode.isEqual
-      };
-    }
-    if (ast.isElementTagExpr(astNode)) {
-      let elementTag = astNode.tag.$refText;
-      if (elementTag.startsWith("#")) {
-        elementTag = elementTag.slice(1);
-      }
-      return {
-        elementTag,
-        isEqual: astNode.isEqual
-      };
-    }
-    if (ast.isExpandElementExpr(astNode)) {
-      const elementNode = elementRef(astNode.parent);
-      invariant(elementNode, "Element not found " + astNode.parent.$cstNode?.text);
-      const expanded = this.resolveFqn(elementNode);
-      return {
-        expanded
-      };
-    }
-    if (ast.isDescedantsExpr(astNode)) {
-      const elementNode = elementRef(astNode.parent);
-      invariant(elementNode, "Element not found " + astNode.parent.$cstNode?.text);
-      const element = this.resolveFqn(elementNode);
-      return {
-        element,
-        isDescedants: true
-      };
-    }
-    if (ast.isElementRef(astNode)) {
-      const elementNode = elementRef(astNode);
-      invariant(elementNode, "Element not found " + astNode.$cstNode?.text);
-      const element = this.resolveFqn(elementNode);
-      return {
-        element
-      };
-    }
-    nonexhaustive(astNode);
-  }
-  parseCustomElementExpr(astNode) {
-    let targetRef;
-    if (ast.isElementRef(astNode.target)) {
-      targetRef = astNode.target;
-    } else if (ast.isExpandElementExpr(astNode.target)) {
-      targetRef = astNode.target.parent;
-    } else {
-      invariant(false, "ElementRef expected as target of custom element");
-    }
-    const elementNode = elementRef(targetRef);
-    invariant(elementNode, "element not found: " + astNode.$cstNode?.text);
-    const element = this.resolveFqn(elementNode);
-    const props = astNode.body?.props ?? [];
-    return props.reduce(
-      (acc, prop) => {
-        if (ast.isNavigateToProperty(prop)) {
-          const viewId = prop.value.view.$refText;
-          if (isTruthy(viewId)) {
-            acc.custom.navigateTo = viewId;
-          }
-          return acc;
-        }
-        if (ast.isElementStringProperty(prop)) {
-          const value = prop.key === "description" ? removeIndent(prop.value) : toSingleLine(prop.value);
-          acc.custom[prop.key] = value.trim();
-          return acc;
-        }
-        if (ast.isIconProperty(prop)) {
-          acc.custom[prop.key] = prop.value;
-          return acc;
-        }
-        if (ast.isColorProperty(prop)) {
-          acc.custom[prop.key] = prop.value;
-          return acc;
-        }
-        if (ast.isShapeProperty(prop)) {
-          acc.custom[prop.key] = prop.value;
-          return acc;
-        }
-        if (ast.isBorderProperty(prop)) {
-          acc.custom[prop.key] = prop.value;
-          return acc;
-        }
-        if (ast.isOpacityProperty(prop)) {
-          acc.custom[prop.key] = parseAstOpacityProperty(prop);
-          return acc;
-        }
-        nonexhaustive(prop);
-      },
-      {
-        custom: {
-          element
-        }
-      }
-    );
-  }
-  parsePredicateExpr(astNode) {
-    if (ast.isRelationExpr(astNode)) {
-      return {
-        source: this.parseElementExpr(astNode.source),
-        target: this.parseElementExpr(astNode.target),
-        isBidirectional: astNode.isBidirectional
-      };
-    }
-    if (ast.isInOutExpr(astNode)) {
-      return {
-        inout: this.parseElementExpr(astNode.inout.to)
-      };
-    }
-    if (ast.isOutgoingExpr(astNode)) {
-      return {
-        outgoing: this.parseElementExpr(astNode.from)
-      };
-    }
-    if (ast.isIncomingExpr(astNode)) {
-      return {
-        incoming: this.parseElementExpr(astNode.to)
-      };
-    }
-    if (ast.isCustomElementExpr(astNode)) {
-      return this.parseCustomElementExpr(astNode);
-    }
-    if (ast.isElementExpr(astNode)) {
-      return this.parseElementExpr(astNode);
-    }
-    nonexhaustive(astNode);
-  }
-  parseViewRule(astRule, isValid) {
-    if (ast.isIncludePredicate(astRule) || ast.isExcludePredicate(astRule)) {
-      const exprs = astRule.expressions.flatMap((n) => {
-        try {
-          return isValid(n) ? this.parsePredicateExpr(n) : [];
-        } catch (e) {
-          logWarnError(e);
-          return [];
-        }
-      });
-      return ast.isIncludePredicate(astRule) ? { include: exprs } : { exclude: exprs };
-    }
-    if (ast.isViewRuleStyle(astRule)) {
-      const styleProps = toElementStyle(astRule.styleprops);
-      return {
-        targets: astRule.targets.map((n) => this.parseElementExpr(n)),
-        style: {
-          ...styleProps
-        }
-      };
-    }
-    if (ast.isViewRuleAutoLayout(astRule)) {
-      return {
-        autoLayout: toAutoLayout(astRule.direction)
-      };
-    }
-    nonexhaustive(astRule);
-  }
-  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);
-    if (node.isBackward) {
-      ;
-      [source, target] = [target, source];
-    }
-    const title = toSingleLine(node.title) ?? null;
-    return {
-      source,
-      target,
-      title,
-      isBackward: node.isBackward
-    };
-  }
-  parseElementView(astNode, isValid) {
-    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(
-        getDocument(astNode).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 = body.props.filter(ast.isLinkProperty).map((p) => p.value);
-    const view = {
-      __: "element",
-      id,
-      astPath,
-      ...viewOf && { viewOf },
-      title,
-      description,
-      tags,
-      links: isNonEmptyArray(links) ? links : null,
-      rules: body.rules.flatMap((n) => {
-        try {
-          return isValid(n) ? this.parseViewRule(n, isValid) : [];
-        } catch (e) {
-          logWarnError(e);
-          return [];
-        }
-      })
-    };
-    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;
-  }
-  parseDynamicElementView(astNode, isValid) {
-    const body = astNode.body;
-    invariant(body, "ElementView body is not defined");
-    const props = body.props.filter(isValid);
-    const astPath = this.getAstNodePath(astNode);
-    let id = astNode.name;
-    if (!id) {
-      id = "dynamic_" + stringHash(
-        getDocument(astNode).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 = props.filter(ast.isLinkProperty).map((p) => p.value);
-    ViewOps.writeId(astNode, id);
-    return {
-      __: "dynamic",
-      id,
-      astPath,
-      title,
-      description,
-      tags,
-      links: isNonEmptyArray(links) ? links : null,
-      rules: body.rules.reduce((acc, n) => {
-        if (!isValid(n)) {
-          return acc;
-        }
-        try {
-          if (ast.isDynamicViewRulePredicate(n)) {
-            const include = [];
-            for (const expr of n.expressions) {
-              if (ast.isElementExpr(expr)) {
-                include.push(this.parseElementExpr(expr));
-                continue;
-              }
-              if (ast.isCustomElementExpr(expr)) {
-                include.push(this.parseCustomElementExpr(expr));
-                continue;
-              }
-            }
-            if (include.length > 0) {
-              acc.push({ include });
-            }
-            return acc;
-          }
-          if (ast.isViewRuleStyle(n)) {
-            const styleProps = toElementStyle(n.styleprops);
-            const targets = n.targets.map((n2) => this.parseElementExpr(n2));
-            if (targets.length > 0) {
-              acc.push({
-                targets,
-                style: {
-                  ...styleProps
-                }
-              });
-            }
-            return acc;
-          }
-          if (ast.isViewRuleAutoLayout(n)) {
-            acc.push({
-              autoLayout: toAutoLayout(n.direction)
-            });
-            return acc;
-          }
-          nonexhaustive(n);
-        } catch (e) {
-          logWarnError(e);
-          return acc;
-        }
-      }, []),
-      steps: body.steps.reduce((acc, n) => {
-        try {
-          if (isValid(n)) {
-            acc.push(this.parseDynamicStep(n));
-          }
-        } catch (e) {
-          logWarnError(e);
-        }
-        return acc;
-      }, [])
-    };
-  }
-  resolveFqn(node) {
-    if (ast.isExtendElement(node)) {
-      return getFqnElementRef(node.element);
-    }
-    const fqn = this.fqnIndex.getFqn(node);
-    invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
-    return fqn;
-  }
-  getAstNodePath(node) {
-    return this.services.workspace.AstNodeLocator.getAstNodePath(node);
-  }
-  convertTags(withTags) {
-    if (!withTags) {
-      return null;
-    }
-    const tags = withTags.tags?.value.flatMap(({ ref }) => ref ? ref.name : []);
-    return isNonEmptyArray(tags) ? tags : null;
-  }
-}

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

@@ -1,16 +0,0 @@
-import { Location, Range, 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;
-        ranges: Range[];
-        edits: TextEdit[];
-    };
-}
-//# sourceMappingURL=ModelChanges.d.ts.map

package/dist/model-change/ModelChanges.js

@@ -1,106 +0,0 @@
-import { invariant, nonexhaustive } from "@likec4/core";
-import { Range } from "vscode-languageserver-protocol";
-import { changeElementStyle } from "./changeElementStyle.js";
-import { changeViewLayout } from "./changeViewLayout.js";
-function unionRangeOfAllEdits(ranges) {
-  let startLine = Number.MAX_SAFE_INTEGER;
-  let endLine = Number.MIN_SAFE_INTEGER;
-  let startCharacter = Number.MAX_SAFE_INTEGER;
-  let endCharacter = Number.MIN_SAFE_INTEGER;
-  for (const { start, end } of ranges) {
-    if (start.line <= startLine) {
-      if (startLine == start.line) {
-        startCharacter = Math.min(start.character, startCharacter);
-      } else {
-        startLine = start.line;
-        startCharacter = start.character;
-      }
-    }
-    if (endLine <= end.line) {
-      if (endLine == end.line) {
-        endCharacter = Math.max(end.character, endCharacter);
-      } else {
-        endLine = end.line;
-        endCharacter = end.character;
-      }
-    }
-  }
-  return Range.create(startLine, startCharacter, endLine, endCharacter);
-}
-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: {
-          changes: {
-            [textDocument.uri]: edits
-          }
-        }
-      });
-      if (!applyResult.applied) {
-        lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`);
-        return;
-      }
-      result = {
-        uri: textDocument.uri,
-        range: unionRangeOfAllEdits(edits.map((edit) => edit.range))
-      };
-    });
-    return result;
-  }
-  convertToTextEdit({ viewId, changes }) {
-    const lookup = this.locator.locateViewAst(viewId);
-    if (!lookup) {
-      throw new Error(`View not found: ${viewId}`);
-    }
-    const ranges = [];
-    const edits = [];
-    for (const change of changes) {
-      switch (change.op) {
-        case "change-element-style": {
-          const { edits: elementEdits, modifiedRange } = changeElementStyle(this.services, {
-            ...lookup,
-            targets: change.targets,
-            style: change.style
-          });
-          ranges.push(modifiedRange);
-          edits.push(...elementEdits);
-          break;
-        }
-        case "change-autolayout": {
-          const edit = changeViewLayout(this.services, {
-            ...lookup,
-            layout: change.layout
-          });
-          edits.push(edit);
-          ranges.push(edit.range);
-          break;
-        }
-        default:
-          nonexhaustive(change);
-      }
-    }
-    return {
-      doc: lookup.doc,
-      ranges,
-      edits
-    };
-  }
-}

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

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