@likec4/language-server 1.43.0 → 1.44.0

package/dist/model/model-parser.mjs

@@ -1,127 +0,0 @@
-import { DefaultWeakMap, invariant, MultiMap } from "@likec4/core/utils";
-import { loggable } from "@likec4/log";
-import { DocumentState } from "langium";
-import { pipe } from "remeda";
-import { DiagnosticSeverity } from "vscode-languageserver-types";
-import { isLikeC4LangiumDocument } from "../ast.mjs";
-import { isLikeC4Builtin } from "../likec4lib.mjs";
-import { logger as rootLogger } from "../logger.mjs";
-import { BaseParser } from "./parser/Base.mjs";
-import { DeploymentModelParser } from "./parser/DeploymentModelParser.mjs";
-import { DeploymentViewParser } from "./parser/DeploymentViewParser.mjs";
-import { ExpressionV2Parser } from "./parser/FqnRefParser.mjs";
-import { GlobalsParser } from "./parser/GlobalsParser.mjs";
-import { ImportsParser } from "./parser/ImportsParser.mjs";
-import { ModelParser } from "./parser/ModelParser.mjs";
-import { PredicatesParser } from "./parser/PredicatesParser.mjs";
-import { SpecificationParser } from "./parser/SpecificationParser.mjs";
-import { ViewsParser } from "./parser/ViewsParser.mjs";
-const DocumentParserFromMixins = pipe(
-  BaseParser,
-  ExpressionV2Parser,
-  ImportsParser,
-  ModelParser,
-  DeploymentModelParser,
-  DeploymentViewParser,
-  PredicatesParser,
-  SpecificationParser,
-  ViewsParser,
-  GlobalsParser
-);
-export class DocumentParser extends DocumentParserFromMixins {
-}
-const logger = rootLogger.getChild("ModelParser");
-export class LikeC4ModelParser {
-  constructor(services) {
-    this.services = services;
-    services.shared.workspace.DocumentBuilder.onDocumentPhase(
-      DocumentState.Linked,
-      (doc) => {
-        try {
-          if (services.shared.workspace.ProjectsManager.checkIfExcluded(doc)) {
-            return;
-          }
-          if (!isLikeC4Builtin(doc.uri)) {
-            this.cachedParsers.set(doc, this.createParser(doc));
-          }
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-    );
-    services.shared.workspace.DocumentBuilder.onDocumentPhase(
-      DocumentState.Validated,
-      (doc) => {
-        if (doc.diagnostics?.some((d) => d.severity === DiagnosticSeverity.Error)) {
-          this.cachedParsers.delete(doc);
-        }
-      }
-    );
-  }
-  cachedParsers = new DefaultWeakMap((doc) => this.createParser(doc));
-  documents(projectId) {
-    return this.services.shared.workspace.LangiumDocuments.projectDocuments(projectId).map(
-      (d) => this.parse(d)
-    );
-  }
-  parse(doc) {
-    try {
-      const parser = this.forDocument(doc);
-      return parser.doc;
-    } catch (cause) {
-      throw new Error(`Error parsing document ${doc.uri.toString()}`, { cause });
-    }
-  }
-  forDocument(doc) {
-    if (doc.state < DocumentState.Linked) {
-      logger.warn(`Document {doc} is not linked`, { doc: doc.uri.toString() });
-    }
-    return this.cachedParsers.get(doc);
-  }
-  createParser(doc) {
-    invariant(isLikeC4LangiumDocument(doc), `Document ${doc.uri.toString()} is not a LikeC4 document`);
-    if (doc.likec4ProjectId) {
-      logger.debug(`create parser {projectId} document {doc}`, {
-        projectId: doc.likec4ProjectId,
-        doc: doc.uri.toString()
-      });
-    } else {
-      logger.warn(`create parser for document without project {doc}`, { doc: doc.uri.toString() });
-    }
-    const props = {
-      c4Specification: {
-        tags: {},
-        elements: {},
-        relationships: {},
-        colors: {},
-        deployments: {}
-      },
-      c4Elements: [],
-      c4ExtendElements: [],
-      c4ExtendDeployments: [],
-      c4Relations: [],
-      c4Deployments: [],
-      c4DeploymentRelations: [],
-      c4Globals: {
-        predicates: {},
-        dynamicPredicates: {},
-        styles: {}
-      },
-      c4Views: [],
-      c4Imports: new MultiMap(Set)
-    };
-    doc = Object.assign(doc, props);
-    const parser = new DocumentParser(this.services, doc);
-    try {
-      parser.parseSpecification();
-      parser.parseImports();
-      parser.parseModel();
-      parser.parseGlobals();
-      parser.parseDeployment();
-      parser.parseViews();
-    } catch (e) {
-      logger.error(`Error parsing document {doc}`, { doc: doc.uri.toString(), error: e });
-    }
-    return parser;
-  }
-}

package/dist/model/parser/Base.mjs

@@ -1,376 +0,0 @@
-import {
-  exact,
-  GlobalFqn,
-  isNonEmptyArray,
-  nonexhaustive,
-  nonNullable
-} from "@likec4/core";
-import {
-  filter,
-  flatMap,
-  groupBy,
-  isArray,
-  isBoolean,
-  isEmpty,
-  isNumber,
-  isString,
-  isTruthy,
-  mapValues,
-  pipe,
-  unique
-} from "remeda";
-import stripIndent from "strip-indent";
-import { hasLeadingSlash, hasProtocol, isRelative, joinRelativeURL, joinURL } from "ufo";
-import {
-  ast,
-  parseAstOpacityProperty,
-  parseAstPercent,
-  parseAstSizeValue,
-  parseMarkdownAsString,
-  toColor
-} from "../../ast.mjs";
-import { serverLogger } from "../../logger.mjs";
-import { projectIdFrom } from "../../utils/index.mjs";
-import { readStrictFqn } from "../../utils/elementRef.mjs";
-import { checksFromDiagnostics } from "../../validation/index.mjs";
-const logger = serverLogger.getChild("BaseParser");
-export function toSingleLine(str) {
-  if (str === null || str === void 0) {
-    return void 0;
-  }
-  const without = removeIndent(str);
-  if (isString(without)) {
-    return without.split("\n").join(" ");
-  }
-  if ("md" in without) {
-    return {
-      md: without.md.split("\n").join("  ")
-    };
-  }
-  return {
-    txt: without.txt.split("\n").join(" ")
-  };
-}
-export function removeIndent(str) {
-  if (str === null || str === void 0) {
-    return void 0;
-  }
-  switch (true) {
-    case isString(str):
-      return stripIndent(str).trim();
-    case (ast.isMarkdownOrString(str) && isTruthy(str.markdown)):
-      return {
-        md: stripIndent(str.markdown).trim()
-      };
-    case (ast.isMarkdownOrString(str) && isTruthy(str.text)):
-      return {
-        txt: stripIndent(str.text).trim()
-      };
-    default:
-      return void 0;
-  }
-}
-export class BaseParser {
-  constructor(services, doc) {
-    this.services = services;
-    this.doc = doc;
-    this.isValid = checksFromDiagnostics(doc).isValid;
-  }
-  isValid;
-  get project() {
-    return this.services.shared.workspace.ProjectsManager.getProject(this.doc);
-  }
-  resolveFqn(node) {
-    if (ast.isImported(node)) {
-      const project = projectIdFrom(node);
-      const fqn = this.resolveFqn(
-        nonNullable(node.imported.ref, `FqnRef is empty of imported: ${node.$cstNode?.text}`)
-      );
-      this.doc.c4Imports.set(project, fqn);
-      return GlobalFqn(project, fqn);
-    }
-    if (ast.isExtendElement(node)) {
-      return readStrictFqn(node.element);
-    }
-    if (ast.isExtendDeployment(node)) {
-      return readStrictFqn(node.deploymentNode);
-    }
-    if (ast.isDeploymentElement(node)) {
-      return this.services.likec4.DeploymentsIndex.getFqn(node);
-    }
-    return this.services.likec4.FqnIndex.getFqn(node);
-  }
-  getAstNodePath(node) {
-    return this.services.workspace.AstNodeLocator.getAstNodePath(node);
-  }
-  getMetadata(metadataAstNode) {
-    if (!metadataAstNode || !this.isValid(metadataAstNode) || isEmpty(metadataAstNode.props)) {
-      return void 0;
-    }
-    const extractValues = (value) => {
-      if (ast.isMarkdownOrString(value)) {
-        const mdOrStr = removeIndent(value);
-        if (!mdOrStr) return [];
-        if (typeof mdOrStr === "string") {
-          return isTruthy(mdOrStr) ? [mdOrStr] : [];
-        } else {
-          const strValue = mdOrStr.md || mdOrStr.txt;
-          return isTruthy(strValue) ? [strValue] : [];
-        }
-      } else if (ast.isMetadataArray(value)) {
-        return value.values.map((v) => removeIndent(v)).map((v) => {
-          if (typeof v === "string") {
-            return v;
-          } else {
-            return v.md || v.txt;
-          }
-        }).filter(isTruthy);
-      }
-      return [];
-    };
-    const keyValuePairs = pipe(
-      metadataAstNode.props,
-      flatMap((p) => extractValues(p.value).map((v) => [p.key, v])),
-      filter(([_, value]) => isTruthy(value))
-    );
-    if (isEmpty(keyValuePairs)) {
-      return void 0;
-    }
-    const groupedData = pipe(
-      keyValuePairs,
-      groupBy(([key]) => key),
-      mapValues((pairs) => pairs.map(([_, value]) => value))
-    );
-    const data = {};
-    for (const [key, values] of Object.entries(groupedData)) {
-      if (values && values.length > 0) {
-        data[key] = values.length === 1 ? values[0] : values;
-      }
-    }
-    return isEmpty(data) ? void 0 : data;
-  }
-  parseMarkdownOrString(markdownOrString) {
-    if (ast.isMarkdownOrString(markdownOrString)) {
-      return removeIndent(markdownOrString);
-    }
-    return void 0;
-  }
-  convertTags(withTags) {
-    return this.parseTags(withTags);
-  }
-  parseTags(withTags) {
-    let iter = withTags?.tags;
-    if (!iter) {
-      return null;
-    }
-    let tags = [];
-    while (iter) {
-      try {
-        if (this.isValid(iter)) {
-          const values = iter.values.map((t) => t.tag.ref?.name).filter(isTruthy);
-          if (values.length > 0) {
-            tags.push(...values);
-          }
-        }
-      } catch {
-      }
-      iter = iter.prev;
-    }
-    return isNonEmptyArray(tags) ? unique(tags) : null;
-  }
-  convertLinks(source) {
-    return this.parseLinks(source);
-  }
-  parseLinks(source) {
-    if (!source?.props || source.props.length === 0) {
-      return void 0;
-    }
-    return pipe(
-      source.props,
-      filter(ast.isLinkProperty),
-      flatMap((p) => {
-        if (!this.isValid(p)) {
-          return [];
-        }
-        const url = p.value;
-        if (isTruthy(url)) {
-          const title = isTruthy(p.title) ? toSingleLine(p.title) : void 0;
-          const relative = this.services.lsp.DocumentLinkProvider.relativeLink(this.doc, url);
-          return {
-            url,
-            ...title && { title },
-            ...relative && relative !== url && { relative }
-          };
-        }
-        return [];
-      })
-    );
-  }
-  parseIconProperty(prop) {
-    if (!prop || !this.isValid(prop)) {
-      return void 0;
-    }
-    const { libicon, value } = prop;
-    switch (true) {
-      case !!libicon: {
-        return libicon.ref?.name;
-      }
-      case (value && value === "none"): {
-        return value;
-      }
-      case (value && hasProtocol(value)): {
-        if (value.startsWith("file:")) {
-          logger.warn(`Icon property '${value}' used the 'file' protocol which is not supported`);
-          return void 0;
-        }
-        return value;
-      }
-      case (value && value.startsWith("@")): {
-        return this.parseImageAlias(value);
-      }
-      case (value && isRelative(value)): {
-        return joinRelativeURL(this.doc.uri.toString(), "../", value);
-      }
-      case (value && hasLeadingSlash(value)): {
-        return joinURL(this.project.folderUri.toString(), value);
-      }
-      default: {
-        logger.warn(`Icon property '${value}' is not a valid URL, library icon, image alias or 'none'`);
-        return void 0;
-      }
-    }
-  }
-  parseImageAlias(value) {
-    const slashIndex = value.indexOf("/");
-    const aliasName = slashIndex > 0 ? value.substring(0, slashIndex) : value;
-    const remainingPath = slashIndex > 0 ? value.substring(slashIndex + 1) : "";
-    const imageAliases = { "@": "./images", ...this.project.config.imageAliases };
-    const aliasPath = imageAliases[aliasName];
-    if (!aliasPath) {
-      logger.warn(`Image alias "${aliasName}" not found in project configuration`);
-      return void 0;
-    }
-    const fullPath = remainingPath ? joinURL(aliasPath, remainingPath) : aliasPath;
-    return joinURL(this.project.folderUri.toString(), fullPath);
-  }
-  parseColorLiteral(astNode) {
-    if (!this.isValid(astNode)) {
-      return void 0;
-    }
-    if (ast.isHexColor(astNode)) {
-      return `#${astNode.hex}`;
-    }
-    if (ast.isRGBAColor(astNode)) {
-      let alpha = isNumber(astNode.alpha) ? astNode.alpha : void 0;
-      if (isString(astNode.alpha)) {
-        alpha = parseAstPercent(astNode.alpha) / 100;
-      }
-      if (alpha !== void 0) {
-        return `rgba(${astNode.red},${astNode.green},${astNode.blue},${alpha})`;
-      }
-      return `rgb(${astNode.red},${astNode.green},${astNode.blue})`;
-    }
-    nonexhaustive(astNode);
-  }
-  parseElementStyle(elementProps) {
-    if (!elementProps) {
-      return {};
-    }
-    if (isArray(elementProps)) {
-      const style = this.parseStyleProps(elementProps.find(ast.isElementStyleProperty)?.props);
-      const iconProp = this.parseIconProperty(elementProps.find(ast.isIconProperty));
-      if (iconProp) {
-        style.icon = iconProp;
-      }
-      return style;
-    }
-    return this.parseStyleProps(elementProps.props);
-  }
-  parseStyleProps(styleProps) {
-    const result = {};
-    if (!styleProps || styleProps.length === 0) {
-      return result;
-    }
-    for (const prop of styleProps) {
-      if (!this.isValid(prop)) {
-        continue;
-      }
-      switch (true) {
-        case ast.isBorderProperty(prop): {
-          if (isTruthy(prop.value)) {
-            result.border = prop.value;
-          }
-          break;
-        }
-        case ast.isColorProperty(prop): {
-          const color = toColor(prop);
-          if (isTruthy(color)) {
-            result.color = color;
-          }
-          break;
-        }
-        case ast.isShapeProperty(prop): {
-          if (isTruthy(prop.value)) {
-            result.shape = prop.value;
-          }
-          break;
-        }
-        case ast.isIconProperty(prop): {
-          const icon = this.parseIconProperty(prop);
-          if (isTruthy(icon)) {
-            result.icon = icon;
-          }
-          break;
-        }
-        case ast.isOpacityProperty(prop): {
-          result.opacity = parseAstOpacityProperty(prop);
-          break;
-        }
-        case ast.isMultipleProperty(prop): {
-          result.multiple = isBoolean(prop.value) ? prop.value : false;
-          break;
-        }
-        case ast.isShapeSizeProperty(prop): {
-          if (isTruthy(prop.value)) {
-            result.size = parseAstSizeValue(prop);
-          }
-          break;
-        }
-        case ast.isPaddingSizeProperty(prop): {
-          if (isTruthy(prop.value)) {
-            result.padding = parseAstSizeValue(prop);
-          }
-          break;
-        }
-        case ast.isTextSizeProperty(prop): {
-          if (isTruthy(prop.value)) {
-            result.textSize = parseAstSizeValue(prop);
-          }
-          break;
-        }
-        default:
-          nonexhaustive(prop);
-      }
-    }
-    return exact(result);
-  }
-  /**
-   * Parse base properties: title, description and technology
-   *
-   * @param props - body properties (inside '{...}')
-   * @param override - optional, inline properties (right on the node)
-   *                   have higher priority and override body properties
-   */
-  parseBaseProps(props, override) {
-    const title = removeIndent(override?.title ?? parseMarkdownAsString(props.title));
-    const description = override?.description ? { txt: removeIndent(override.description) } : this.parseMarkdownOrString(props.description);
-    const summary = override?.summary ? { txt: removeIndent(override.summary) } : this.parseMarkdownOrString(props.summary);
-    const technology = toSingleLine(override?.technology) ?? removeIndent(parseMarkdownAsString(props.technology));
-    return exact({
-      title,
-      summary,
-      description,
-      technology
-    });
-  }
-}

package/dist/model/parser/DeploymentModelParser.mjs

@@ -1,212 +0,0 @@
-import {
-  exact,
-  FqnRef,
-  invariant,
-  isNonEmptyArray,
-  LinkedList,
-  nameFromFqn,
-  nonexhaustive,
-  nonNullable
-} from "@likec4/core";
-import { loggable } from "@likec4/log";
-import { filter, first, isDefined, isEmpty, isTruthy, mapToObj, pipe } from "remeda";
-import {
-  ast,
-  toRelationshipStyle
-} from "../../ast.mjs";
-import { serverLogger } from "../../logger.mjs";
-import { stringHash } from "../../utils/stringHash.mjs";
-const logger = serverLogger.getChild("DeploymentModelParser");
-function* streamDeploymentModel(doc) {
-  const traverseStack = LinkedList.from(
-    doc.parseResult.value.deployments.flatMap((m) => m.elements)
-  );
-  const relations = [];
-  let el;
-  while (el = traverseStack.shift()) {
-    if (ast.isDeploymentRelation(el)) {
-      relations.push(el);
-      continue;
-    }
-    if (el.body && el.body.elements.length > 0) {
-      for (const child of el.body.elements) {
-        traverseStack.push(child);
-      }
-    }
-    yield el;
-  }
-  yield* relations;
-  return;
-}
-export function DeploymentModelParser(B) {
-  return class DeploymentModelParser extends B {
-    parseDeployment() {
-      const doc = this.doc;
-      for (const el of streamDeploymentModel(doc)) {
-        try {
-          switch (true) {
-            case ast.isDeploymentRelation(el): {
-              if (this.isValid(el)) {
-                doc.c4DeploymentRelations.push(this.parseDeploymentRelation(el));
-              }
-              break;
-            }
-            case ast.isDeployedInstance(el):
-              doc.c4Deployments.push(this.parseDeployedInstance(el));
-              break;
-            case ast.isDeploymentNode(el): {
-              doc.c4Deployments.push(this.parseDeploymentNode(el));
-              break;
-            }
-            case ast.isExtendDeployment(el): {
-              const parsed = this.parseExtendDeployment(el);
-              if (parsed) {
-                doc.c4ExtendDeployments.push(parsed);
-              }
-              break;
-            }
-            default:
-              nonexhaustive(el);
-          }
-        } catch (e) {
-          logger.warn(loggable(e));
-        }
-      }
-    }
-    parseDeploymentNode(astNode) {
-      const isValid = this.isValid;
-      const id = this.resolveFqn(astNode);
-      const kind = nonNullable(astNode.kind.ref, "DeploymentKind not resolved").name;
-      const tags = this.convertTags(astNode.body);
-      const style = this.parseElementStyle(astNode.body?.props);
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-      const bodyProps = pipe(
-        astNode.body?.props ?? [],
-        filter(isValid),
-        filter(ast.isElementStringProperty),
-        mapToObj((p) => [p.key, p.value])
-      );
-      const { title, ...descAndTech } = this.parseBaseProps(bodyProps, {
-        title: astNode.title,
-        summary: astNode.summary
-      });
-      const links = this.convertLinks(astNode.body);
-      return exact({
-        id,
-        kind,
-        title: title ?? nameFromFqn(id),
-        ...descAndTech,
-        tags: tags ?? void 0,
-        ...links && isNonEmptyArray(links) && { links },
-        style,
-        metadata
-      });
-    }
-    parseDeployedInstance(astNode) {
-      const isValid = this.isValid;
-      const id = this.resolveFqn(astNode);
-      const target = this.parseFqnRef(astNode.target.modelElement);
-      invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), "Target must be a model reference");
-      const tags = this.convertTags(astNode.body);
-      const style = this.parseElementStyle(astNode.body?.props);
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-      const bodyProps = pipe(
-        astNode.body?.props ?? [],
-        filter(isValid),
-        filter(ast.isElementStringProperty),
-        mapToObj((p) => [p.key, p.value])
-      );
-      const baseProps = this.parseBaseProps(bodyProps, {
-        title: astNode.title,
-        summary: astNode.summary
-      });
-      const links = this.convertLinks(astNode.body);
-      return exact({
-        id,
-        element: target,
-        tags: tags ?? void 0,
-        ...links && isNonEmptyArray(links) && { links },
-        ...baseProps,
-        style,
-        metadata
-      });
-    }
-    parseExtendDeployment(astNode) {
-      if (!this.isValid(astNode)) {
-        return null;
-      }
-      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 {
-        id,
-        astPath,
-        ...metadata && { metadata },
-        tags,
-        links: isNonEmptyArray(links) ? links : null
-      };
-    }
-    _resolveDeploymentRelationSource(node) {
-      if (isDefined(node.source)) {
-        return this.parseFqnRef(node.source);
-      }
-      if (node.$container.$type === "DeploymentNodeBody" || node.$container.$type === "DeployedInstanceBody") {
-        return {
-          deployment: this.resolveFqn(node.$container.$container)
-        };
-      }
-      throw new Error("RelationRefError: Invalid container for sourceless relation");
-    }
-    parseDeploymentRelation(astNode) {
-      const isValid = this.isValid;
-      const astPath = this.getAstNodePath(astNode);
-      const source = this._resolveDeploymentRelationSource(astNode);
-      invariant(FqnRef.isDeploymentRef(source), "Invalid source for deployment relation");
-      const target = this.parseFqnRef(astNode.target);
-      invariant(FqnRef.isDeploymentRef(target), "Invalid target for deployment relation");
-      const tags = this.convertTags(astNode) ?? this.convertTags(astNode.body);
-      const links = this.convertLinks(astNode.body);
-      const kind = (astNode.kind ?? astNode.dotKind?.kind)?.ref?.name;
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
-      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),
-        first()
-      )?.value.view.ref?.name;
-      const titleDescAndTech = this.parseBaseProps(bodyProps, {
-        title: astNode.title
-      });
-      const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
-      const id = stringHash(
-        "deployment",
-        astPath,
-        source.deployment,
-        target.deployment
-      );
-      return exact({
-        id,
-        source,
-        target,
-        ...titleDescAndTech,
-        metadata,
-        kind,
-        tags: tags ?? void 0,
-        ...isNonEmptyArray(links) && { links },
-        ...toRelationshipStyle(styleProp?.props, isValid),
-        navigateTo,
-        astPath
-      });
-    }
-  };
-}