@likec4/language-server 1.17.1 → 1.19.0

package/dist/model/parser/GlobalsParser.js

@@ -0,0 +1,80 @@
+import { nonexhaustive } from "@likec4/core";
+import { isTruthy } from "remeda";
+import { ast } from "../../ast.js";
+import { logger, logWarnError } from "../../logger.js";
+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) {
+          logWarnError(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 (styles2.length > 0) {
+            c4Globals.styles[globalStyleId] = styles2;
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+    }
+    parseAndStoreGlobalPredicateGroupOrDynamic(astRule, id, c4Globals) {
+      if (ast.isGlobalPredicateGroup(astRule)) {
+        const predicates = this.parseGlobalPredicateGroup(astRule);
+        if (predicates.length > 0) {
+          c4Globals.predicates[id] = predicates;
+        }
+        return;
+      }
+      if (ast.isGlobalDynamicPredicateGroup(astRule)) {
+        const predicates = this.parseGlobalDynamicPredicateGroup(astRule);
+        if (predicates.length > 0) {
+          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/ModelParser.d.ts

@@ -0,0 +1,27 @@
+import type * as c4 from '@likec4/core';
+import { type ParsedAstElement, type ParsedAstRelation, ast } from '../../ast';
+import { type Base } from './Base';
+export type WithModel = ReturnType<typeof ModelParser>;
+export declare function ModelParser<TBase extends Base>(B: TBase): {
+    new (...args: any[]): {
+        parseModel(): void;
+        parseElement(astNode: ast.Element): ParsedAstElement;
+        parseRelation(astNode: ast.Relation): ParsedAstRelation;
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+        getAstNodePath(node: c4): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+    };
+} & TBase;

package/dist/model/parser/ModelParser.js

@@ -0,0 +1,122 @@
+import { isNonEmptyArray, nonexhaustive, nonNullable } from "@likec4/core";
+import { filter, first, isNonNullish, isTruthy, map, mapToObj, pipe } from "remeda";
+import {
+  ast,
+  resolveRelationPoints,
+  streamModel,
+  toElementStyle,
+  toRelationshipStyleExcludeDefaults
+} from "../../ast.js";
+import { logWarnError } from "../../logger.js";
+import { stringHash } from "../../utils/stringHash.js";
+import { removeIndent, toSingleLine } from "./Base.js";
+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;
+          }
+          nonexhaustive(el);
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+    }
+    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 stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props;
+      const style = toElementStyle(stylePropsAst, isValid);
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+      const astPath = this.getAstNodePath(astNode);
+      let [title, description, technology] = astNode.props ?? [];
+      const bodyProps = pipe(
+        astNode.body?.props ?? [],
+        filter(isValid),
+        filter(ast.isElementStringProperty),
+        mapToObj((p) => [p.key, p.value || void 0])
+      );
+      title = removeIndent(title ?? bodyProps.title);
+      description = removeIndent(bodyProps.description ?? description);
+      technology = toSingleLine(bodyProps.technology ?? technology);
+      const links = this.parseLinks(astNode.body);
+      const iconProp = astNode.body?.props.find(ast.isIconProperty);
+      if (iconProp && isValid(iconProp)) {
+        const value = iconProp.libicon?.ref?.name ?? iconProp.value;
+        if (isTruthy(value)) {
+          style.icon = value;
+        }
+      }
+      return {
+        id,
+        kind,
+        astPath,
+        title: title ?? astNode.name,
+        ...metadata && { metadata },
+        ...tags && { tags },
+        ...links && isNonEmptyArray(links) && { links },
+        ...isTruthy(technology) && { technology },
+        ...isTruthy(description) && { description },
+        style
+      };
+    }
+    parseRelation(astNode) {
+      const isValid = this.isValid;
+      const coupling = resolveRelationPoints(astNode);
+      const target = this.resolveFqn(coupling.target);
+      const source = this.resolveFqn(coupling.source);
+      const tags = this.parseTags(astNode) ?? this.parseTags(astNode.body);
+      const links = this.parseLinks(astNode.body);
+      const kind = astNode.kind?.ref?.name;
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+      const astPath = this.getAstNodePath(astNode);
+      const bodyProps = mapToObj(
+        astNode.body?.props.filter(ast.isRelationStringProperty).filter((p) => isNonNullish(p.value)) ?? [],
+        (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 = removeIndent(astNode.title ?? bodyProps.title) ?? "";
+      const description = removeIndent(bodyProps.description);
+      const technology = toSingleLine(astNode.technology) ?? removeIndent(bodyProps.technology);
+      const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
+      const id = stringHash(
+        astPath,
+        source,
+        target
+      );
+      return {
+        id,
+        astPath,
+        source,
+        target,
+        title,
+        ...metadata && { metadata },
+        ...isTruthy(technology) && { technology },
+        ...isTruthy(description) && { description },
+        ...kind && { kind },
+        ...tags && { tags },
+        ...isNonEmptyArray(links) && { links },
+        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid),
+        ...navigateTo && { navigateTo }
+      };
+    }
+  };
+}

package/dist/model/parser/PredicatesParser.d.ts

@@ -0,0 +1,34 @@
+import type * as c4 from '@likec4/core';
+import { ast } from '../../ast';
+import { type Base } from './Base';
+export type WithPredicates = ReturnType<typeof PredicatesParser>;
+export declare function PredicatesParser<TBase extends Base>(B: TBase): {
+    new (...args: any[]): {
+        parsePredicate(astNode: ast.Predicate): c4.Expression;
+        parseElementPredicate(astNode: ast.ElementPredicate): c4.ElementPredicateExpression;
+        parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[];
+        parseElementExpression(astNode: ast.ElementExpression): c4.ElementExpression;
+        parseElementPredicateWhere(astNode: ast.ElementPredicateWhere): c4.ElementWhereExpr;
+        parseElementPredicateWith(astNode: ast.ElementPredicateWith): c4.CustomElementExpr;
+        parseRelationPredicate(astNode: ast.RelationPredicate): c4.RelationPredicateExpression;
+        parseRelationPredicateWhere(astNode: ast.RelationPredicateWhere): c4.RelationWhereExpr;
+        parseRelationPredicateWith(astNode: ast.RelationPredicateWith, relation: c4.RelationExpression | c4.RelationWhereExpr): c4.CustomRelationExpr;
+        parseRelationExpression(astNode: ast.RelationExpression): c4.RelationExpression;
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+        getAstNodePath(node: c4): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+    };
+} & TBase;

package/dist/model/parser/PredicatesParser.js

@@ -0,0 +1,272 @@
+import { invariant, nonexhaustive } from "@likec4/core";
+import { isDefined, isTruthy } from "remeda";
+import { ast, parseAstOpacityProperty, toColor } from "../../ast.js";
+import { logWarnError } from "../../logger.js";
+import { elementRef } from "../../utils/elementRef.js";
+import { parseWhereClause } from "../model-parser-where.js";
+import { removeIndent } from "./Base.js";
+export function PredicatesParser(B) {
+  return class PredicatesParser extends B {
+    parsePredicate(astNode) {
+      if (ast.isElementPredicate(astNode)) {
+        return this.parseElementPredicate(astNode);
+      }
+      if (ast.isRelationPredicate(astNode)) {
+        return this.parseRelationPredicate(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseElementPredicate(astNode) {
+      if (ast.isElementPredicateWith(astNode)) {
+        return this.parseElementPredicateWith(astNode);
+      }
+      if (ast.isElementPredicateWhere(astNode)) {
+        return this.parseElementPredicateWhere(astNode);
+      }
+      if (ast.isElementExpression(astNode)) {
+        return this.parseElementExpression(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseElementExpressionsIterator(astNode) {
+      const exprs = [];
+      let iter = astNode;
+      while (iter) {
+        try {
+          if (iter.value) {
+            exprs.unshift(this.parseElementExpression(iter.value));
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+        iter = iter.prev;
+      }
+      return exprs;
+    }
+    parseElementExpression(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?.ref, "ElementTagExpr tag is not resolved: " + astNode.$cstNode?.text);
+        let elementTag = astNode.tag.$refText;
+        if (elementTag.startsWith("#")) {
+          elementTag = elementTag.slice(1);
+        }
+        return {
+          elementTag,
+          isEqual: astNode.isEqual
+        };
+      }
+      if (ast.isExpandElementExpression(astNode)) {
+        const elementNode = elementRef(astNode.expand);
+        invariant(elementNode, "Element not found " + astNode.expand.$cstNode?.text);
+        const expanded = this.resolveFqn(elementNode);
+        return {
+          expanded
+        };
+      }
+      if (ast.isElementDescedantsExpression(astNode)) {
+        const elementNode = elementRef(astNode.parent);
+        invariant(elementNode, "Element not found " + astNode.parent.$cstNode?.text);
+        const element = this.resolveFqn(elementNode);
+        return {
+          element,
+          isChildren: astNode.suffix === ".*",
+          isDescendants: astNode.suffix === ".**"
+        };
+      }
+      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);
+    }
+    parseElementPredicateWhere(astNode) {
+      const expr = this.parseElementExpression(astNode.subject);
+      return {
+        where: {
+          expr,
+          condition: astNode.where ? parseWhereClause(astNode.where) : {
+            kind: { neq: "--always-true--" }
+          }
+        }
+      };
+    }
+    parseElementPredicateWith(astNode) {
+      const expr = this.parseElementPredicate(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)) {
+              acc.custom[prop.key] = removeIndent(prop.value) || "";
+            }
+            return acc;
+          }
+          if (ast.isIconProperty(prop)) {
+            const value = prop.libicon?.ref?.name ?? prop.value;
+            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)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = removeIndent(prop.value);
+            }
+            return acc;
+          }
+          nonexhaustive(prop);
+        },
+        {
+          custom: {
+            expr
+          }
+        }
+      );
+    }
+    parseRelationPredicate(astNode) {
+      if (ast.isRelationPredicateWith(astNode)) {
+        let relation = ast.isRelationPredicateWhere(astNode.subject) ? this.parseRelationPredicateWhere(astNode.subject) : this.parseRelationExpression(astNode.subject);
+        return this.parseRelationPredicateWith(astNode, relation);
+      }
+      if (ast.isRelationPredicateWhere(astNode)) {
+        return this.parseRelationPredicateWhere(astNode);
+      }
+      if (ast.isRelationExpression(astNode)) {
+        return this.parseRelationExpression(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseRelationPredicateWhere(astNode) {
+      const expr = this.parseRelationExpression(astNode.subject);
+      return {
+        where: {
+          expr,
+          condition: astNode.where ? parseWhereClause(astNode.where) : {
+            kind: { neq: "--always-true--" }
+          }
+        }
+      };
+    }
+    parseRelationPredicateWith(astNode, relation) {
+      const props = astNode.custom?.props ?? [];
+      return props.reduce(
+        (acc, prop) => {
+          if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.customRelation[prop.key] = removeIndent(prop.value) ?? "";
+            }
+            return acc;
+          }
+          if (ast.isArrowProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.customRelation[prop.key] = prop.value;
+            }
+            return acc;
+          }
+          if (ast.isColorProperty(prop)) {
+            const value = toColor(prop);
+            if (isTruthy(value)) {
+              acc.customRelation[prop.key] = value;
+            }
+            return acc;
+          }
+          if (ast.isLineProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.customRelation[prop.key] = prop.value;
+            }
+            return acc;
+          }
+          if (ast.isRelationNavigateToProperty(prop)) {
+            const viewId = prop.value.view.ref?.name;
+            if (isTruthy(viewId)) {
+              acc.customRelation.navigateTo = viewId;
+            }
+            return acc;
+          }
+          nonexhaustive(prop);
+        },
+        {
+          customRelation: {
+            relation
+          }
+        }
+      );
+    }
+    parseRelationExpression(astNode) {
+      if (ast.isDirectedRelationExpression(astNode)) {
+        return {
+          source: this.parseElementExpression(astNode.source.from),
+          target: this.parseElementExpression(astNode.target),
+          isBidirectional: astNode.source.isBidirectional
+        };
+      }
+      if (ast.isInOutRelationExpression(astNode)) {
+        return {
+          inout: this.parseElementExpression(astNode.inout.to)
+        };
+      }
+      if (ast.isOutgoingRelationExpression(astNode)) {
+        return {
+          outgoing: this.parseElementExpression(astNode.from)
+        };
+      }
+      if (ast.isIncomingRelationExpression(astNode)) {
+        return {
+          incoming: this.parseElementExpression(astNode.to)
+        };
+      }
+      nonexhaustive(astNode);
+    }
+  };
+}

package/dist/model/parser/SpecificationParser.d.ts

@@ -0,0 +1,27 @@
+import type * as c4 from '@likec4/core';
+import { ast } from '../../ast';
+import { type Base } from './Base';
+export declare function SpecificationParser<TBase extends Base>(B: TBase): {
+    new (...args: any[]): {
+        parseSpecification(): void;
+        parseSpecificationDeploymentNodeKind({ kind, props }: ast.SpecificationDeploymentNodeKind): {
+            [key: c4.DeploymentNodeKind]: c4.DeploymentNodeKindSpecification;
+        };
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+        getAstNodePath(node: c4): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+    };
+} & TBase;

package/dist/model/parser/SpecificationParser.js

@@ -0,0 +1,120 @@
+import { filter, isNonNullish, isTruthy, mapToObj, pipe } from "remeda";
+import { ast, toElementStyle, toRelationshipStyleExcludeDefaults } from "../../ast.js";
+import { logger, logWarnError } from "../../logger.js";
+import { removeIndent } from "./Base.js";
+export function SpecificationParser(B) {
+  return class SpecificationParser extends B {
+    parseSpecification() {
+      const {
+        parseResult: {
+          value: {
+            specifications
+          }
+        },
+        c4Specification
+      } = this.doc;
+      const isValid = this.isValid;
+      const element_specs = specifications.flatMap((s) => s.elements.filter(this.isValid));
+      for (const { kind, props } of element_specs) {
+        try {
+          const kindName = kind.name;
+          if (!isTruthy(kindName)) {
+            continue;
+          }
+          if (kindName in c4Specification.elements) {
+            logger.warn(`Element kind "${kindName}" is already defined`);
+            continue;
+          }
+          const style = props.find(ast.isElementStyleProperty);
+          const bodyProps = pipe(
+            props.filter(ast.isSpecificationElementStringProperty) ?? [],
+            filter((p) => this.isValid(p) && isNonNullish(p.value)),
+            mapToObj((p) => [p.key, removeIndent(p.value)])
+          );
+          c4Specification.elements[kindName] = {
+            ...bodyProps,
+            style: {
+              ...toElementStyle(style?.props, this.isValid)
+            }
+          };
+        } catch (e) {
+          logWarnError(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(p.value)])
+          );
+          c4Specification.relationships[kindName] = {
+            ...bodyProps,
+            ...toRelationshipStyleExcludeDefaults(props, this.isValid)
+          };
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+      const tags_specs = specifications.flatMap((s) => s.tags.filter(this.isValid));
+      for (const tagSpec of tags_specs) {
+        const tag = tagSpec.tag.name;
+        if (isTruthy(tag)) {
+          c4Specification.tags.add(tag);
+        }
+      }
+      const deploymentNodes_specs = specifications.flatMap((s) => s.deploymentNodes.filter(isValid));
+      for (const deploymentNode of deploymentNodes_specs) {
+        try {
+          Object.assign(c4Specification.deployments, this.parseSpecificationDeploymentNodeKind(deploymentNode));
+        } catch (e) {
+          logWarnError(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
+          };
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+    }
+    parseSpecificationDeploymentNodeKind({ kind, props }) {
+      const kindName = kind.name;
+      if (!isTruthy(kindName)) {
+        throw new Error("DeploymentNodeKind name is not resolved");
+      }
+      const style = props.find(ast.isElementStyleProperty);
+      const bodyProps = pipe(
+        props.filter(ast.isSpecificationElementStringProperty) ?? [],
+        filter((p) => this.isValid(p) && isNonNullish(p.value)),
+        mapToObj((p) => [p.key, removeIndent(p.value)])
+      );
+      return {
+        [kindName]: {
+          ...bodyProps,
+          style: {
+            ...toElementStyle(style?.props, this.isValid)
+          }
+        }
+      };
+    }
+  };
+}