@likec4/language-server 1.42.1 → 1.44.0

package/dist/model/parser/DeploymentViewParser.mjs

@@ -1,95 +0,0 @@
-import * as c4 from "@likec4/core";
-import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { filter, isNonNullish, mapToObj, pipe } from "remeda";
-import { ast, parseMarkdownAsString, toAutoLayout, ViewOps } from "../../ast.mjs";
-import { logWarnError } from "../../logger.mjs";
-import { stringHash } from "../../utils/index.mjs";
-import { parseViewManualLayout } from "../../view-utils/manual-layout.mjs";
-import { removeIndent, toSingleLine } from "./Base.mjs";
-export function DeploymentViewParser(B) {
-  return class DeploymentViewParser extends B {
-    parseDeploymentView(astNode) {
-      const body = astNode.body;
-      invariant(body, "DynamicElementView body is not defined");
-      const props = body.props.filter(this.isValid);
-      const astPath = this.getAstNodePath(astNode);
-      let id = astNode.name;
-      if (!id) {
-        id = "deployment_" + 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);
-      return {
-        [c4._type]: "deployment",
-        id,
-        astPath,
-        title: toSingleLine(title) ?? null,
-        description,
-        tags,
-        links: isNonEmptyArray(links) ? links : null,
-        rules: body.rules.flatMap((n) => {
-          try {
-            return this.isValid(n) ? this.parseDeploymentViewRule(n) : [];
-          } catch (e) {
-            logWarnError(e);
-            return [];
-          }
-        }),
-        ...manualLayout && { manualLayout }
-      };
-    }
-    parseDeploymentViewRule(astRule) {
-      if (ast.isDeploymentViewRulePredicate(astRule)) {
-        return this.parseDeploymentViewRulePredicate(astRule);
-      }
-      if (ast.isViewRuleAutoLayout(astRule)) {
-        return toAutoLayout(astRule);
-      }
-      if (ast.isDeploymentViewRuleStyle(astRule)) {
-        return this.parseDeploymentViewRuleStyle(astRule);
-      }
-      nonexhaustive(astRule);
-    }
-    parseDeploymentViewRulePredicate(astRule) {
-      const exprs = [];
-      let iterator = astRule.expr;
-      while (iterator) {
-        try {
-          const expr = iterator.value;
-          if (isNonNullish(expr) && this.isValid(expr)) {
-            exprs.unshift(this.parseExpressionV2(expr));
-          }
-        } catch (e) {
-          logWarnError(e);
-        }
-        iterator = iterator.prev;
-      }
-      return astRule.isInclude ? { include: exprs } : { exclude: exprs };
-    }
-    parseDeploymentViewRuleStyle(astRule) {
-      const style = this.parseStyleProps(astRule.props.filter(ast.isStyleProperty));
-      const notation = removeIndent(parseMarkdownAsString(astRule.props.find(ast.isNotationProperty)?.value));
-      const targets = this.parseFqnExpressions(astRule.targets);
-      return {
-        targets,
-        style,
-        ...notation && { notation }
-      };
-    }
-  };
-}

package/dist/model/parser/FqnRefParser.mjs

@@ -1,398 +0,0 @@
-import { invariant, nonexhaustive, nonNullable } from "@likec4/core";
-import { loggable } from "@likec4/log";
-import { AstUtils } from "langium";
-import { isBoolean, isDefined, isNonNullish, isTruthy } from "remeda";
-import { ast, parseAstOpacityProperty, parseAstSizeValue, parseMarkdownAsString, toColor } from "../../ast.mjs";
-import { serverLogger } from "../../logger.mjs";
-import { projectIdFrom } from "../../utils/index.mjs";
-import { importsRef, instanceRef } from "../../utils/fqnRef.mjs";
-import { createBinaryOperator, parseWhereClause } from "../model-parser-where.mjs";
-import { removeIndent } from "./Base.mjs";
-const logger = serverLogger.getChild("ExpressionV2Parser");
-const location = (astNode) => {
-  const cst = astNode.$cstNode;
-  const position = cst ? `:${cst.range.start.line + 1}:${cst.range.start.character + 1}` : "";
-  return `${AstUtils.getDocument(astNode).uri.fsPath}${position}`;
-};
-export function ExpressionV2Parser(B) {
-  return class ExpressionV2Parser extends B {
-    parseFqnRef(astNode) {
-      const refValue = nonNullable(
-        astNode.value?.ref,
-        () => `FqnRef "${astNode.$cstNode?.text}" is empty at ${location(astNode)}`
-      );
-      if (ast.isImported(refValue)) {
-        const fqnRef = {
-          project: projectIdFrom(refValue),
-          model: this.resolveFqn(
-            nonNullable(refValue.imported.ref, `FqnRef is empty of imported: ${refValue.$cstNode?.text}`)
-          )
-        };
-        this.doc.c4Imports.set(fqnRef.project, fqnRef.model);
-        return fqnRef;
-      }
-      if (ast.isElement(refValue)) {
-        const imported = importsRef(astNode);
-        if (imported) {
-          const fqnRef = {
-            project: projectIdFrom(imported),
-            model: this.resolveFqn(refValue)
-          };
-          this.doc.c4Imports.set(fqnRef.project, fqnRef.model);
-          return fqnRef;
-        }
-        const deployedInstanceAst = instanceRef(astNode);
-        if (!deployedInstanceAst) {
-          return {
-            model: this.resolveFqn(refValue)
-          };
-        }
-        const deployment = this.resolveFqn(deployedInstanceAst);
-        const element = this.resolveFqn(refValue);
-        return {
-          deployment,
-          element
-        };
-      }
-      if (ast.isDeploymentElement(refValue)) {
-        return {
-          deployment: this.resolveFqn(refValue)
-        };
-      }
-      nonexhaustive(refValue);
-    }
-    parseExpressionV2(astNode) {
-      if (ast.isFqnExprOrWith(astNode)) {
-        return this.parseFqnExprOrWith(astNode);
-      }
-      if (ast.isRelationExprOrWith(astNode)) {
-        return this.parseRelationExprOrWith(astNode);
-      }
-      nonexhaustive(astNode);
-    }
-    parseFqnExprOrWith(astNode) {
-      if (ast.isFqnExprWith(astNode)) {
-        return this.parseFqnExprWith(astNode);
-      }
-      if (ast.isFqnExprOrWhere(astNode)) {
-        return this.parseFqnExprOrWhere(astNode);
-      }
-      nonexhaustive(astNode);
-    }
-    parseFqnExprWith(astNode) {
-      const expr = this.parseFqnExprOrWhere(astNode.subject);
-      const props = astNode.custom?.props ?? [];
-      return props.reduce(
-        (acc, prop) => {
-          if (!this.isValid(prop)) {
-            return acc;
-          }
-          if (ast.isNavigateToProperty(prop)) {
-            const viewId = prop.value.view.$refText;
-            if (isTruthy(viewId)) {
-              acc.custom.navigateTo = viewId;
-            }
-            return acc;
-          }
-          if (ast.isElementStringProperty(prop)) {
-            if (isDefined(prop.value) && prop.key !== "summary") {
-              if (prop.key === "description") {
-                const parsed = this.parseMarkdownOrString(prop.value);
-                if (parsed) {
-                  acc.custom["description"] = parsed;
-                }
-              } else {
-                acc.custom[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) || "";
-              }
-            }
-            return acc;
-          }
-          if (ast.isIconProperty(prop)) {
-            const value = this.parseIconProperty(prop);
-            if (isDefined(value)) {
-              acc.custom[prop.key] = value;
-            }
-            return acc;
-          }
-          if (ast.isColorProperty(prop)) {
-            const value = toColor(prop);
-            if (isDefined(value)) {
-              acc.custom[prop.key] = value;
-            }
-            return acc;
-          }
-          if (ast.isShapeProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.custom[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isBorderProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.custom[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isOpacityProperty(prop)) {
-            if (isDefined(prop.value)) {
-              acc.custom[prop.key] = parseAstOpacityProperty(prop);
-            }
-            return acc;
-          }
-          if (ast.isNotationProperty(prop)) {
-            const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : void 0;
-            if (value) {
-              acc.custom[prop.key] = value;
-            }
-            return acc;
-          }
-          if (ast.isMultipleProperty(prop)) {
-            if (isBoolean(prop.value)) {
-              acc.custom[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isShapeSizeProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.custom[prop.key] = parseAstSizeValue(prop);
-            }
-            return acc;
-          }
-          if (ast.isTextSizeProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.custom[prop.key] = parseAstSizeValue(prop);
-            }
-            return acc;
-          }
-          if (ast.isPaddingSizeProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc.custom[prop.key] = parseAstSizeValue(prop);
-            }
-            return acc;
-          }
-          nonexhaustive(prop);
-        },
-        {
-          custom: {
-            expr
-          }
-        }
-      );
-    }
-    parseFqnExprOrWhere(astNode) {
-      if (ast.isFqnExprWhere(astNode)) {
-        return this.parseFqnExprWhere(astNode);
-      }
-      if (ast.isFqnExpr(astNode)) {
-        return this.parseFqnExpr(astNode);
-      }
-      nonexhaustive(astNode);
-    }
-    parseFqnExprWhere(astNode) {
-      invariant(!ast.isFqnExprWhere(astNode.subject), "FqnExprWhere is not allowed as subject of FqnExprWhere");
-      return {
-        where: {
-          expr: this.parseFqnExpr(astNode.subject),
-          condition: astNode.where ? parseWhereClause(astNode.where) : {
-            kind: { neq: "--always-true--" }
-          }
-        }
-      };
-    }
-    parseFqnExpr(astNode) {
-      if (ast.isWildcardExpression(astNode)) {
-        return {
-          wildcard: true
-        };
-      }
-      if (ast.isElementKindExpression(astNode)) {
-        invariant(astNode.kind?.ref, "ElementKindExpr kind is not resolved: " + astNode.$cstNode?.text);
-        return {
-          elementKind: astNode.kind.ref.name,
-          isEqual: astNode.isEqual
-        };
-      }
-      if (ast.isElementTagExpression(astNode)) {
-        invariant(astNode.tag.tag.ref, "ElementTagExpr tag is not resolved: " + astNode.$cstNode?.text);
-        let elementTag = astNode.tag.tag.$refText;
-        return {
-          elementTag,
-          isEqual: astNode.isEqual
-        };
-      }
-      if (ast.isFqnRefExpr(astNode)) {
-        return this.parseFqnRefExpr(astNode);
-      }
-      nonexhaustive(astNode);
-    }
-    parseFqnRefExpr(astNode) {
-      const ref = this.parseFqnRef(astNode.ref);
-      switch (true) {
-        case astNode.selector === "._":
-          return {
-            ref,
-            selector: "expanded"
-          };
-        case astNode.selector === ".**":
-          return {
-            ref,
-            selector: "descendants"
-          };
-        case astNode.selector === ".*":
-          return {
-            ref,
-            selector: "children"
-          };
-        default:
-          return { ref };
-      }
-    }
-    parseFqnExpressions(astNode) {
-      const exprs = [];
-      let iter = astNode;
-      while (iter) {
-        try {
-          if (isNonNullish(iter.value) && this.isValid(iter.value)) {
-            exprs.push(this.parseFqnExpr(iter.value));
-          }
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-        iter = iter.prev;
-      }
-      return exprs.reverse();
-    }
-    parseRelationExprOrWith(astNode) {
-      if (ast.isRelationExprWith(astNode)) {
-        return this.parseRelationExprWith(astNode);
-      }
-      if (ast.isRelationExprOrWhere(astNode)) {
-        return this.parseRelationExprOrWhere(astNode);
-      }
-      nonexhaustive(astNode);
-    }
-    parseRelationExprWith(astNode) {
-      const expr = this.parseRelationExprOrWhere(astNode.subject);
-      const customProps = this.parseCustomRelationProperties(astNode.custom);
-      return {
-        customRelation: {
-          ...customProps,
-          expr
-        }
-      };
-    }
-    parseCustomRelationProperties(custom) {
-      const props = custom?.props ?? [];
-      return props.reduce(
-        (acc, prop) => {
-          if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
-            const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : void 0;
-            if (value) {
-              acc[prop.key] = value;
-            }
-            return acc;
-          }
-          if (ast.isArrowProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isColorProperty(prop)) {
-            const value = toColor(prop);
-            if (isTruthy(value)) {
-              acc[prop.key] = value;
-            }
-            return acc;
-          }
-          if (ast.isLineProperty(prop)) {
-            if (isTruthy(prop.value)) {
-              acc[prop.key] = prop.value;
-            }
-            return acc;
-          }
-          if (ast.isRelationNavigateToProperty(prop)) {
-            const viewId = prop.value.view.ref?.name;
-            if (isTruthy(viewId)) {
-              acc[prop.key] = viewId;
-            }
-            return acc;
-          }
-          nonexhaustive(prop);
-        },
-        {}
-      );
-    }
-    parseRelationExprOrWhere(astNode) {
-      if (ast.isRelationExprWhere(astNode)) {
-        return this.parseRelationExprWhere(astNode);
-      }
-      if (ast.isRelationExpr(astNode)) {
-        return this.parseRelationExpr(astNode);
-      }
-      nonexhaustive(astNode);
-    }
-    parseRelationExprWhere(astNode) {
-      invariant(
-        !ast.isRelationExprWhere(astNode.subject),
-        "RelationExprWhere is not allowed as subject of RelationExprWhere"
-      );
-      const relationOrWhereExpr = this.parseRelationExpr(astNode.subject);
-      const expr = relationOrWhereExpr.where?.expr ?? relationOrWhereExpr;
-      const kindCondition = relationOrWhereExpr.where?.condition;
-      const whereCondition = astNode.where ? parseWhereClause(astNode.where) : null;
-      let condition;
-      if (whereCondition && kindCondition) {
-        condition = createBinaryOperator(
-          "and",
-          kindCondition,
-          whereCondition
-        );
-      } else {
-        condition = whereCondition ?? kindCondition ?? { kind: { neq: "--always-true--" } };
-      }
-      return {
-        where: {
-          expr,
-          condition
-        }
-      };
-    }
-    parseRelationExpr(astNode) {
-      switch (astNode.$type) {
-        case "DirectedRelationExpr":
-          return this.wrapInWhere({
-            source: this.parseFqnExpr(astNode.source.from),
-            target: this.parseFqnExpr(astNode.target),
-            isBidirectional: astNode.source.isBidirectional
-          }, this.parseInlineKindCondition(astNode.source));
-        case "InOutRelationExpr":
-          return {
-            inout: this.parseFqnExpr(astNode.inout.to)
-          };
-        case "OutgoingRelationExpr":
-          return this.wrapInWhere(
-            { outgoing: this.parseFqnExpr(astNode.from) },
-            this.parseInlineKindCondition(astNode)
-          );
-        case "IncomingRelationExpr":
-          return {
-            incoming: this.parseFqnExpr(astNode.to)
-          };
-        default:
-          nonexhaustive(astNode);
-      }
-    }
-    parseInlineKindCondition(astNode) {
-      const kind = astNode.kind ?? astNode.dotKind?.kind;
-      if (kind) {
-        invariant(kind.ref, "Kind is not resolved: " + astNode.$cstNode?.text);
-        return { kind: { eq: kind.ref?.name } };
-      }
-      return null;
-    }
-    wrapInWhere(expr, condition) {
-      return condition ? { where: { expr, condition } } : expr;
-    }
-  };
-}

package/dist/model/parser/GlobalsParser.mjs

@@ -1,82 +0,0 @@
-import { nonexhaustive } from "@likec4/core";
-import { loggable } from "@likec4/log";
-import { hasAtLeast, isTruthy } from "remeda";
-import { ast } from "../../ast.mjs";
-import { serverLogger } from "../../logger.mjs";
-const logger = serverLogger.getChild("GlobalsParser");
-export function GlobalsParser(B) {
-  return class GlobalsParser extends B {
-    parseGlobals() {
-      const { parseResult, c4Globals } = this.doc;
-      const isValid = this.isValid;
-      const globals = parseResult.value.globals.filter(isValid);
-      const elRelPredicates = globals.flatMap((r) => r.predicates.filter(isValid));
-      for (const predicate of elRelPredicates) {
-        try {
-          const globalPredicateId = predicate.name;
-          if (!isTruthy(globalPredicateId)) {
-            continue;
-          }
-          if (globalPredicateId in c4Globals.predicates) {
-            logger.warn(`Global predicate named "${globalPredicateId}" is already defined`);
-            continue;
-          }
-          this.parseAndStoreGlobalPredicateGroupOrDynamic(predicate, globalPredicateId, c4Globals);
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-      const styles = globals.flatMap((r) => r.styles.filter(isValid));
-      for (const style of styles) {
-        try {
-          const globalStyleId = style.id.name;
-          if (!isTruthy(globalStyleId)) {
-            continue;
-          }
-          if (globalStyleId in c4Globals.styles) {
-            logger.warn(`Global style named "${globalStyleId}" is already defined`);
-            continue;
-          }
-          const styles2 = this.parseGlobalStyleOrGroup(style);
-          if (hasAtLeast(styles2, 1)) {
-            c4Globals.styles[globalStyleId] = styles2;
-          }
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-    }
-    parseAndStoreGlobalPredicateGroupOrDynamic(astRule, id, c4Globals) {
-      if (ast.isGlobalPredicateGroup(astRule)) {
-        const predicates = this.parseGlobalPredicateGroup(astRule);
-        if (hasAtLeast(predicates, 1)) {
-          c4Globals.predicates[id] = predicates;
-        }
-        return;
-      }
-      if (ast.isGlobalDynamicPredicateGroup(astRule)) {
-        const predicates = this.parseGlobalDynamicPredicateGroup(astRule);
-        if (hasAtLeast(predicates, 1)) {
-          c4Globals.dynamicPredicates[id] = predicates;
-        }
-        return;
-      }
-      nonexhaustive(astRule);
-    }
-    parseGlobalPredicateGroup(astRule) {
-      return astRule.predicates.map((p) => this.parseViewRulePredicate(p));
-    }
-    parseGlobalDynamicPredicateGroup(astRule) {
-      return astRule.predicates.map((p) => this.parseDynamicViewIncludePredicate(p));
-    }
-    parseGlobalStyleOrGroup(astRule) {
-      if (ast.isGlobalStyle(astRule)) {
-        return [this.parseViewRuleStyle(astRule)];
-      }
-      if (ast.isGlobalStyleGroup(astRule)) {
-        return astRule.styles.map((s) => this.parseViewRuleStyle(s));
-      }
-      nonexhaustive(astRule);
-    }
-  };
-}

package/dist/model/parser/ImportsParser.mjs

@@ -1,28 +0,0 @@
-import { nonNullable } from "@likec4/core";
-import { loggable } from "@likec4/log";
-import { serverLogger } from "../../logger.mjs";
-const logger = serverLogger.getChild("ImportsParser");
-export function ImportsParser(B) {
-  return class ImportsParser extends B {
-    parseImports() {
-      const imports = this.doc.parseResult.value.imports ?? [];
-      for (const importsFromPoject of imports) {
-        const project = importsFromPoject.project;
-        let imported = importsFromPoject.imports;
-        while (imported) {
-          try {
-            this.doc.c4Imports.set(
-              project,
-              this.resolveFqn(
-                nonNullable(imported.imported.ref, `ElementRef is empty of imported: ${imported.imported.$refText}`)
-              )
-            );
-          } catch (e) {
-            logger.warn(loggable(e));
-          }
-          imported = imported.prev;
-        }
-      }
-    }
-  };
-}