@likec4/language-server 1.42.1 → 1.44.0

package/dist/model/parser/ModelParser.mjs

@@ -1,190 +0,0 @@
-import { invariant, isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from "@likec4/core";
-import { exact, FqnRef } from "@likec4/core/types";
-import { loggable } from "@likec4/log";
-import { filter, first, isDefined, isEmpty, isTruthy, map, mapToObj, pipe } from "remeda";
-import {
-  ast,
-  toRelationshipStyle
-} from "../../ast.mjs";
-import { logger as mainLogger } from "../../logger.mjs";
-import { stringHash } from "../../utils/stringHash.mjs";
-const logger = mainLogger.getChild("ModelParser");
-function* streamModel(doc) {
-  const traverseStack = LinkedList.from(doc.parseResult.value.models.flatMap((m) => m.elements));
-  const relations = [];
-  let el;
-  while (el = traverseStack.shift()) {
-    if (ast.isRelation(el)) {
-      relations.push(el);
-      continue;
-    }
-    if (el.body && el.body.elements && el.body.elements.length > 0) {
-      for (const child of el.body.elements) {
-        traverseStack.push(child);
-      }
-    }
-    yield el;
-  }
-  yield* relations;
-  return;
-}
-export function ModelParser(B) {
-  return class ModelParser extends B {
-    parseModel() {
-      const doc = this.doc;
-      for (const el of streamModel(doc)) {
-        try {
-          if (ast.isElement(el)) {
-            doc.c4Elements.push(this.parseElement(el));
-            continue;
-          }
-          if (ast.isRelation(el)) {
-            if (this.isValid(el)) {
-              doc.c4Relations.push(this.parseRelation(el));
-            }
-            continue;
-          }
-          if (ast.isExtendElement(el)) {
-            const parsed = this.parseExtendElement(el);
-            if (parsed) {
-              doc.c4ExtendElements.push(parsed);
-            }
-            continue;
-          }
-          nonexhaustive(el);
-        } catch (e) {
-          const astPath = this.getAstNodePath(el);
-          const error = loggable(e);
-          const message = e instanceof Error ? e.message : String(error);
-          logger.warn(`Error on {eltype}: ${message}
- document: {path}
- astpath: {astPath}
-${error}`, {
-            path: doc.uri.path,
-            eltype: el.$type,
-            astPath
-          });
-        }
-      }
-    }
-    parseElement(astNode) {
-      const isValid = this.isValid;
-      const id = this.resolveFqn(astNode);
-      const kind = nonNullable(astNode.kind.ref, "Element kind is not resolved").name;
-      const tags = this.parseTags(astNode.body);
-      const style = this.parseElementStyle(astNode.body?.props);
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-      const astPath = this.getAstNodePath(astNode);
-      let [_title, _summary, _technology] = astNode.props ?? [];
-      const bodyProps = pipe(
-        astNode.body?.props ?? [],
-        filter(isValid),
-        filter(ast.isElementStringProperty),
-        mapToObj((p) => [p.key, p.value])
-      );
-      const { title, ...descAndTech } = this.parseBaseProps(bodyProps, {
-        title: _title,
-        summary: _summary,
-        technology: _technology
-      });
-      const links = this.parseLinks(astNode.body);
-      return exact({
-        id,
-        kind,
-        astPath,
-        title: title ?? astNode.name,
-        metadata,
-        tags: tags ?? void 0,
-        ...links && isNonEmptyArray(links) && { links },
-        ...descAndTech,
-        style
-      });
-    }
-    parseExtendElement(astNode) {
-      const id = this.resolveFqn(astNode);
-      const tags = this.parseTags(astNode.body);
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-      const astPath = this.getAstNodePath(astNode);
-      const links = this.parseLinks(astNode.body) ?? [];
-      if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
-        return null;
-      }
-      return exact({
-        id,
-        astPath,
-        metadata,
-        tags,
-        links: isNonEmptyArray(links) ? links : null
-      });
-    }
-    _resolveRelationSource(node) {
-      if (isDefined(node.source)) {
-        const source = this.parseFqnRef(node.source);
-        invariant(FqnRef.isModelRef(source) || FqnRef.isImportRef(source), "Relation source must be a model reference");
-        return source;
-      }
-      if (ast.isElementBody(node.$container)) {
-        return {
-          model: this.resolveFqn(node.$container.$container)
-        };
-      }
-      if (ast.isExtendElementBody(node.$container)) {
-        return {
-          model: this.resolveFqn(node.$container.$container)
-        };
-      }
-      throw new Error("RelationRefError: Invalid container for sourceless relation");
-    }
-    parseRelation(astNode) {
-      const isValid = this.isValid;
-      const source = this._resolveRelationSource(astNode);
-      const target = this.parseFqnRef(astNode.target);
-      invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), "Target must be a model reference");
-      const tags = this.parseTags(astNode) ?? this.parseTags(astNode.body);
-      const links = this.parseLinks(astNode.body);
-      const kind = (astNode.kind ?? astNode.dotKind?.kind)?.ref?.name;
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-      const astPath = this.getAstNodePath(astNode);
-      const bodyProps = pipe(
-        astNode.body?.props ?? [],
-        filter(ast.isRelationStringProperty),
-        filter((p) => isTruthy(p.value)),
-        mapToObj((p) => [p.key, p.value])
-      );
-      const navigateTo = pipe(
-        astNode.body?.props ?? [],
-        filter(ast.isRelationNavigateToProperty),
-        map((p) => p.value.view.ref?.name),
-        filter(isTruthy),
-        first()
-      );
-      const { title = "", description, technology } = this.parseBaseProps(bodyProps, {
-        // inline props
-        title: astNode.title,
-        description: astNode.description,
-        technology: astNode.technology
-      });
-      const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
-      const id = stringHash(
-        astPath,
-        source.model,
-        target.model
-      );
-      return exact({
-        id,
-        astPath,
-        source,
-        target,
-        title,
-        metadata,
-        kind,
-        tags: tags ?? void 0,
-        links: isNonEmptyArray(links) ? links : void 0,
-        navigateTo: navigateTo ? navigateTo : void 0,
-        description,
-        technology,
-        ...toRelationshipStyle(styleProp?.props, isValid)
-      });
-    }
-  };
-}

package/dist/model/parser/PredicatesParser.mjs

@@ -1,45 +0,0 @@
-import { nonexhaustive } from "@likec4/core";
-import { ast } from "../../ast.mjs";
-export function PredicatesParser(B) {
-  return class PredicatesParser extends B {
-    parsePredicate(astNode) {
-      return this.parseExpressionV2(astNode);
-    }
-    parseElementPredicate(astNode) {
-      if (ast.isFqnExprWith(astNode)) {
-        return this.parseFqnExprWith(astNode);
-      }
-      if (ast.isFqnExprOrWhere(astNode)) {
-        return this.parseFqnExprOrWhere(astNode);
-      }
-      nonexhaustive(astNode);
-    }
-    parseElementPredicateOrWhere(astNode) {
-      return this.parseFqnExprOrWhere(astNode);
-    }
-    parseElementExpression(astNode) {
-      return this.parseFqnExpr(astNode);
-    }
-    parseElementPredicateWhere(astNode) {
-      return this.parseFqnExprWhere(astNode);
-    }
-    parseElementPredicateWith(astNode) {
-      return this.parseFqnExprWith(astNode);
-    }
-    parseRelationPredicate(astNode) {
-      return this.parseRelationExprOrWith(astNode);
-    }
-    parseRelationPredicateOrWhere(astNode) {
-      return this.parseRelationExprOrWhere(astNode);
-    }
-    parseRelationPredicateWhere(astNode) {
-      return this.parseRelationExprWhere(astNode);
-    }
-    parseRelationPredicateWith(astNode) {
-      return this.parseRelationExprWith(astNode);
-    }
-    parseRelationExpression(astNode) {
-      return this.parseRelationExpr(astNode);
-    }
-  };
-}

package/dist/model/parser/SpecificationParser.mjs

@@ -1,120 +0,0 @@
-import * as c4 from "@likec4/core";
-import { exact } from "@likec4/core";
-import { nonNullable } from "@likec4/core/utils";
-import { loggable } from "@likec4/log";
-import { filter, isNonNullish, isNullish, isTruthy, mapToObj, omitBy, pipe } from "remeda";
-import { ast, parseMarkdownAsString, toRelationshipStyle } from "../../ast.mjs";
-import { serverLogger } from "../../logger.mjs";
-import { removeIndent } from "./Base.mjs";
-const logger = serverLogger.getChild("SpecificationParser");
-export function SpecificationParser(B) {
-  return class SpecificationParser extends B {
-    parseSpecification() {
-      const {
-        parseResult: {
-          value: {
-            specifications
-          }
-        },
-        c4Specification
-      } = this.doc;
-      const isValid = this.isValid;
-      for (const elementSpec of specifications.flatMap((s) => s.elements.filter(isValid))) {
-        try {
-          Object.assign(c4Specification.elements, this.parseElementSpecificationNode(elementSpec));
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-      for (const deploymentNodeSpec of specifications.flatMap((s) => s.deploymentNodes.filter(isValid))) {
-        try {
-          Object.assign(c4Specification.deployments, this.parseElementSpecificationNode(deploymentNodeSpec));
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-      const relations_specs = specifications.flatMap((s) => s.relationships.filter(this.isValid));
-      for (const { kind, props } of relations_specs) {
-        try {
-          const kindName = kind.name;
-          if (!isTruthy(kindName)) {
-            continue;
-          }
-          if (kindName in c4Specification.relationships) {
-            logger.warn(`Relationship kind "${kindName}" is already defined`);
-            continue;
-          }
-          const bodyProps = pipe(
-            props.filter(ast.isSpecificationRelationshipStringProperty) ?? [],
-            filter((p) => this.isValid(p) && isNonNullish(p.value)),
-            mapToObj((p) => [p.key, removeIndent(parseMarkdownAsString(p.value))]),
-            omitBy(isNullish)
-          );
-          c4Specification.relationships[kindName] = {
-            ...bodyProps,
-            ...toRelationshipStyle(props.filter(ast.isRelationshipStyleProperty), this.isValid)
-          };
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-      const tags_specs = specifications.flatMap((s) => s.tags.filter(this.isValid));
-      for (const tagSpec of tags_specs) {
-        try {
-          const tag = tagSpec.tag.name;
-          const astPath = this.getAstNodePath(tagSpec.tag);
-          const color = tagSpec.color && this.parseColorLiteral(tagSpec.color);
-          if (isTruthy(tag)) {
-            c4Specification.tags[tag] = {
-              astPath,
-              ...color ? { color } : {}
-            };
-          }
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-      const colors_specs = specifications.flatMap((s) => s.colors.filter(isValid));
-      for (const { name, color } of colors_specs) {
-        try {
-          const colorName = name.name;
-          if (colorName in c4Specification.colors) {
-            logger.warn(`Custom color "${colorName}" is already defined`);
-            continue;
-          }
-          c4Specification.colors[colorName] = {
-            color: nonNullable(this.parseColorLiteral(color), `Color "${colorName}" is not valid: ${color}`)
-          };
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-    }
-    parseElementSpecificationNode(specAst) {
-      const { kind, props } = specAst;
-      const kindName = kind.name;
-      if (!isTruthy(kindName)) {
-        throw new Error("DeploymentNodeKind name is not resolved");
-      }
-      const tags = this.parseTags(specAst);
-      const style = this.parseElementStyle(props.find(ast.isElementStyleProperty));
-      const links = this.parseLinks(specAst);
-      const bodyProps = pipe(
-        props.filter(ast.isSpecificationElementStringProperty) ?? [],
-        filter((p) => this.isValid(p)),
-        mapToObj((p) => [p.key, p.value])
-      );
-      const baseProps = this.parseBaseProps(bodyProps);
-      const notation = removeIndent(parseMarkdownAsString(bodyProps.notation));
-      return {
-        [kindName]: exact({
-          ...baseProps,
-          notation,
-          tags: tags ?? void 0,
-          ...links && c4.isNonEmptyArray(links) && { links },
-          style
-        })
-      };
-    }
-  };
-}

package/dist/model/parser/ValueConverter.mjs

@@ -1,12 +0,0 @@
-import { DefaultValueConverter, ValueConverter } from "langium";
-export class LikeC4ValueConverter extends DefaultValueConverter {
-  runConverter(rule, input, cstNode) {
-    if (rule.name === "MarkdownString") {
-      if (input.startsWith('"""') && input.endsWith('"""') || input.startsWith(`'''`) && input.endsWith(`'''`)) {
-        input = input.slice(2, -2);
-      }
-      return ValueConverter.convertString(input);
-    }
-    return super.runConverter(rule, input, cstNode);
-  }
-}