@likec4/language-server 1.40.0 → 1.41.0

package/dist/model/parser/DeploymentModelParser.mjs

@@ -1,11 +1,22 @@
-import { FqnRef, invariant, isNonEmptyArray, LinkedList, nameFromFqn, nonexhaustive, nonNullable } from "@likec4/core";
-import { filter, first, isDefined, isEmpty, isTruthy, map, mapToObj, pipe } from "remeda";
+import {
+  FqnRef,
+  invariant,
+  isNonEmptyArray,
+  LinkedList,
+  nameFromFqn,
+  nonexhaustive,
+  nonNullable,
+  omitUndefined
+} from "@likec4/core";
+import { loggable } from "@likec4/log";
+import { filter, first, isDefined, isEmpty, isTruthy, mapToObj, pipe } from "remeda";
 import {
   ast,
   toRelationshipStyleExcludeDefaults
 } from "../../ast.mjs";
-import { logWarnError } from "../../logger.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)
@@ -58,7 +69,7 @@ export function DeploymentModelParser(B) {
               nonexhaustive(el);
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
     }
@@ -75,23 +86,21 @@ export function DeploymentModelParser(B) {
         filter(ast.isElementStringProperty),
         mapToObj((p) => [p.key, p.value])
       );
-      const { title, ...descAndTech } = this.parseTitleDescriptionTechnology(
-        {
-          title: astNode.title
-        },
-        bodyProps
-      );
+      const { title, ...descAndTech } = this.parseBaseProps(bodyProps, {
+        title: astNode.title,
+        summary: astNode.summary
+      });
       const links = this.convertLinks(astNode.body);
-      return {
+      return omitUndefined({
         id,
         kind,
         title: title ?? nameFromFqn(id),
-        ...metadata && { metadata },
-        ...tags && { tags },
-        ...links && isNonEmptyArray(links) && { links },
         ...descAndTech,
-        style
-      };
+        tags: tags ?? void 0,
+        ...links && isNonEmptyArray(links) && { links },
+        style,
+        metadata
+      });
     }
     parseDeployedInstance(astNode) {
       const isValid = this.isValid;
@@ -107,22 +116,20 @@ export function DeploymentModelParser(B) {
         filter(ast.isElementStringProperty),
         mapToObj((p) => [p.key, p.value])
       );
-      const titleDescAndTech = this.parseTitleDescriptionTechnology(
-        {
-          title: astNode.title
-        },
-        bodyProps
-      );
+      const baseProps = this.parseBaseProps(bodyProps, {
+        title: astNode.title,
+        summary: astNode.summary
+      });
       const links = this.convertLinks(astNode.body);
-      return {
+      return omitUndefined({
         id,
         element: target,
-        ...metadata && { metadata },
-        ...tags && { tags },
+        tags: tags ?? void 0,
         ...links && isNonEmptyArray(links) && { links },
-        ...titleDescAndTech,
-        style
-      };
+        ...baseProps,
+        style,
+        metadata
+      });
     }
     parseExtendDeployment(astNode) {
       if (!this.isValid(astNode)) {
@@ -140,8 +147,8 @@ export function DeploymentModelParser(B) {
         id,
         astPath,
         ...metadata && { metadata },
-        ...tags && { tags },
-        ...links && isNonEmptyArray(links) && { links }
+        tags,
+        links: isNonEmptyArray(links) ? links : null
       };
     }
     _resolveDeploymentRelationSource(node) {
@@ -175,16 +182,11 @@ export function DeploymentModelParser(B) {
       const navigateTo = pipe(
         astNode.body?.props ?? [],
         filter(ast.isRelationNavigateToProperty),
-        map((p) => p.value.view.ref?.name),
-        filter(isTruthy),
         first()
-      );
-      const titleDescAndTech = this.parseTitleDescriptionTechnology(
-        {
-          title: astNode.title
-        },
-        bodyProps
-      );
+      )?.value.view.ref?.name;
+      const titleDescAndTech = this.parseBaseProps(bodyProps, {
+        title: astNode.title
+      });
       const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
       const id = stringHash(
         "deployment",
@@ -192,19 +194,19 @@ export function DeploymentModelParser(B) {
         source.deployment,
         target.deployment
       );
-      return {
+      return omitUndefined({
         id,
         source,
         target,
         ...titleDescAndTech,
-        ...metadata && { metadata },
-        ...kind && { kind },
-        ...tags && { tags },
+        metadata,
+        kind,
+        tags: tags ?? void 0,
         ...isNonEmptyArray(links) && { links },
         ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid),
-        ...navigateTo && { navigateTo },
+        navigateTo,
         astPath
-      };
+      });
     }
   };
 }

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

@@ -48,16 +48,19 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        parseBaseProps(props: {
             title?: ast.MarkdownOrString | undefined;
+            summary?: ast.MarkdownOrString | undefined;
             description?: ast.MarkdownOrString | undefined;
             technology?: ast.MarkdownOrString | undefined;
+        }, override?: {
+            title?: string | undefined;
+            summary?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
         }): {
             title?: string;
+            summary?: c4.MarkdownOrString;
             description?: c4.MarkdownOrString;
             technology?: string;
         };

package/dist/model/parser/DeploymentViewParser.mjs

@@ -23,8 +23,7 @@ export function DeploymentViewParser(B) {
       const {
         title = null,
         description = null
-      } = this.parseTitleDescriptionTechnology(
-        {},
+      } = this.parseBaseProps(
         pipe(
           props,
           filter(ast.isViewStringProperty),

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

@@ -1,4 +1,5 @@
 import type * as c4 from '@likec4/core';
+import { type AstNode } from 'langium';
 import { ast } from '../../ast';
 import { type Base } from './Base';
 export type WithExpressionV2 = ReturnType<typeof ExpressionV2Parser>;
@@ -25,7 +26,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: AstNode): any;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
@@ -43,16 +44,19 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        parseBaseProps(props: {
             title?: ast.MarkdownOrString | undefined;
+            summary?: ast.MarkdownOrString | undefined;
             description?: ast.MarkdownOrString | undefined;
             technology?: ast.MarkdownOrString | undefined;
+        }, override?: {
+            title?: string | undefined;
+            summary?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
         }): {
             title?: string;
+            summary?: c4.MarkdownOrString;
             description?: c4.MarkdownOrString;
             technology?: string;
         };

package/dist/model/parser/FqnRefParser.mjs

@@ -1,17 +1,25 @@
 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 { logWarnError } from "../../logger.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 is empty ${astNode.$cstNode?.range.start.line}:${astNode.$cstNode?.range.start.character}`
+        () => `FqnRef "${astNode.$cstNode?.text}" is empty at ${location(astNode)}`
       );
       if (ast.isImported(refValue)) {
         const fqnRef = {
@@ -87,7 +95,7 @@ export function ExpressionV2Parser(B) {
             return acc;
           }
           if (ast.isElementStringProperty(prop)) {
-            if (isDefined(prop.value)) {
+            if (isDefined(prop.value) && prop.key !== "summary") {
               if (prop.key === "description") {
                 const parsed = this.parseMarkdownOrString(prop.value);
                 if (parsed) {
@@ -248,7 +256,7 @@ export function ExpressionV2Parser(B) {
             exprs.push(this.parseFqnExpr(iter.value));
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
         iter = iter.prev;
       }

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

@@ -72,16 +72,19 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        parseBaseProps(props: {
             title?: ast.MarkdownOrString | undefined;
+            summary?: ast.MarkdownOrString | undefined;
             description?: ast.MarkdownOrString | undefined;
             technology?: ast.MarkdownOrString | undefined;
+        }, override?: {
+            title?: string | undefined;
+            summary?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
         }): {
             title?: string;
+            summary?: c4.MarkdownOrString;
             description?: c4.MarkdownOrString;
             technology?: string;
         };

package/dist/model/parser/GlobalsParser.mjs

@@ -1,7 +1,9 @@
 import { nonexhaustive } from "@likec4/core";
+import { loggable } from "@likec4/log";
 import { hasAtLeast, isTruthy } from "remeda";
 import { ast } from "../../ast.mjs";
-import { logger, logWarnError } from "../../logger.mjs";
+import { serverLogger } from "../../logger.mjs";
+const logger = serverLogger.getChild("GlobalsParser");
 export function GlobalsParser(B) {
   return class GlobalsParser extends B {
     parseGlobals() {
@@ -21,7 +23,7 @@ export function GlobalsParser(B) {
           }
           this.parseAndStoreGlobalPredicateGroupOrDynamic(predicate, globalPredicateId, c4Globals);
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       const styles = globals.flatMap((r) => r.styles.filter(isValid));
@@ -40,7 +42,7 @@ export function GlobalsParser(B) {
             c4Globals.styles[globalStyleId] = styles2;
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
     }

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

@@ -27,16 +27,19 @@ export declare function ImportsParser<TBase extends Base>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        parseBaseProps(props: {
             title?: ast.MarkdownOrString | undefined;
+            summary?: ast.MarkdownOrString | undefined;
             description?: ast.MarkdownOrString | undefined;
             technology?: ast.MarkdownOrString | undefined;
+        }, override?: {
+            title?: string | undefined;
+            summary?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
         }): {
             title?: string;
+            summary?: ProjectId;
             description?: ProjectId;
             technology?: string;
         };

package/dist/model/parser/ImportsParser.mjs

@@ -1,5 +1,7 @@
 import { nonNullable } from "@likec4/core";
-import { logWarnError } from "../../logger.mjs";
+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() {
@@ -16,7 +18,7 @@ export function ImportsParser(B) {
               )
             );
           } catch (e) {
-            logWarnError(e);
+            logger.warn(loggable(e));
           }
           imported = imported.prev;
         }

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

@@ -49,16 +49,19 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        parseBaseProps(props: {
             title?: ast.MarkdownOrString | undefined;
+            summary?: ast.MarkdownOrString | undefined;
             description?: ast.MarkdownOrString | undefined;
             technology?: ast.MarkdownOrString | undefined;
+        }, override?: {
+            title?: string | undefined;
+            summary?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
         }): {
             title?: string;
+            summary?: c4.MarkdownOrString;
             description?: c4.MarkdownOrString;
             technology?: string;
         };

package/dist/model/parser/ModelParser.mjs

@@ -1,5 +1,5 @@
 import { invariant, isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from "@likec4/core";
-import { FqnRef } from "@likec4/core/types";
+import { FqnRef, omitUndefined } from "@likec4/core/types";
 import { loggable } from "@likec4/log";
 import { filter, first, isDefined, isEmpty, isTruthy, map, mapToObj, pipe } from "remeda";
 import {
@@ -75,33 +75,30 @@ ${error}`, {
       const style = this.parseElementStyle(astNode.body?.props);
       const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
       const astPath = this.getAstNodePath(astNode);
-      let [_title, _description, _technology] = astNode.props ?? [];
+      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.parseTitleDescriptionTechnology(
-        {
-          title: _title,
-          description: _description,
-          technology: _technology
-        },
-        bodyProps
-      );
+      const { title, ...descAndTech } = this.parseBaseProps(bodyProps, {
+        title: _title,
+        summary: _summary,
+        technology: _technology
+      });
       const links = this.parseLinks(astNode.body);
-      return {
+      return omitUndefined({
         id,
         kind,
         astPath,
         title: title ?? astNode.name,
-        ...metadata && { metadata },
-        ...tags && { tags },
+        metadata,
+        tags: tags ?? void 0,
         ...links && isNonEmptyArray(links) && { links },
         ...descAndTech,
         style
-      };
+      });
     }
     parseExtendElement(astNode) {
       const id = this.resolveFqn(astNode);
@@ -112,13 +109,13 @@ ${error}`, {
       if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
         return null;
       }
-      return {
+      return omitUndefined({
         id,
         astPath,
-        ...metadata && { metadata },
-        ...tags && { tags },
-        ...links && isNonEmptyArray(links) && { links }
-      };
+        metadata,
+        tags,
+        links: isNonEmptyArray(links) ? links : null
+      });
     }
     _resolveRelationSource(node) {
       if (isDefined(node.source)) {
@@ -156,35 +153,33 @@ ${error}`, {
         filter(isTruthy),
         first()
       );
-      const { title = "", ...descAndTech } = this.parseTitleDescriptionTechnology(
+      const { title = "", description, technology } = this.parseBaseProps(bodyProps, {
         // inline props
-        {
-          title: astNode.title,
-          description: astNode.description,
-          technology: astNode.technology
-        },
-        bodyProps
-      );
+        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 {
+      return omitUndefined({
         id,
         astPath,
         source,
         target,
         title,
-        ...metadata && { metadata },
-        ...descAndTech,
-        ...kind && { kind },
-        ...tags && { tags },
-        ...isNonEmptyArray(links) && { links },
-        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid),
-        ...navigateTo && { navigateTo }
-      };
+        metadata,
+        kind,
+        tags: tags ?? void 0,
+        links: isNonEmptyArray(links) ? links : void 0,
+        navigateTo: navigateTo ? navigateTo : void 0,
+        description,
+        technology,
+        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid)
+      });
     }
   };
 }

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

@@ -54,16 +54,19 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        parseBaseProps(props: {
             title?: ast.MarkdownOrString | undefined;
+            summary?: ast.MarkdownOrString | undefined;
             description?: ast.MarkdownOrString | undefined;
             technology?: ast.MarkdownOrString | undefined;
+        }, override?: {
+            title?: string | undefined;
+            summary?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
         }): {
             title?: string;
+            summary?: c4.MarkdownOrString;
             description?: c4.MarkdownOrString;
             technology?: string;
         };

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

@@ -33,16 +33,19 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        parseBaseProps(props: {
             title?: ast.MarkdownOrString | undefined;
+            summary?: ast.MarkdownOrString | undefined;
             description?: ast.MarkdownOrString | undefined;
             technology?: ast.MarkdownOrString | undefined;
+        }, override?: {
+            title?: string | undefined;
+            summary?: string | undefined;
+            description?: string | undefined;
+            technology?: string | undefined;
         }): {
             title?: string;
+            summary?: c4.MarkdownOrString;
             description?: c4.MarkdownOrString;
             technology?: string;
         };

package/dist/model/parser/SpecificationParser.mjs

@@ -1,9 +1,12 @@
 import * as c4 from "@likec4/core";
+import { omitUndefined } 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, toRelationshipStyleExcludeDefaults } from "../../ast.mjs";
-import { logger, logWarnError } from "../../logger.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() {
@@ -20,14 +23,14 @@ export function SpecificationParser(B) {
         try {
           Object.assign(c4Specification.elements, this.parseElementSpecificationNode(elementSpec));
         } catch (e) {
-          logWarnError(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) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       const relations_specs = specifications.flatMap((s) => s.relationships.filter(this.isValid));
@@ -52,7 +55,7 @@ export function SpecificationParser(B) {
             ...toRelationshipStyleExcludeDefaults(props, this.isValid)
           };
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       const tags_specs = specifications.flatMap((s) => s.tags.filter(this.isValid));
@@ -68,7 +71,7 @@ export function SpecificationParser(B) {
             };
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       const colors_specs = specifications.flatMap((s) => s.colors.filter(isValid));
@@ -83,7 +86,7 @@ export function SpecificationParser(B) {
             color: nonNullable(this.parseColorLiteral(color), `Color "${colorName}" is not valid: ${color}`)
           };
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
     }
@@ -101,25 +104,16 @@ export function SpecificationParser(B) {
         filter((p) => this.isValid(p)),
         mapToObj((p) => [p.key, p.value])
       );
-      const { title, description, technology } = this.parseTitleDescriptionTechnology(
-        {
-          title: void 0,
-          description: void 0,
-          technology: void 0
-        },
-        bodyProps
-      );
+      const baseProps = this.parseBaseProps(bodyProps);
       const notation = removeIndent(parseMarkdownAsString(bodyProps.notation));
       return {
-        [kindName]: {
-          ...title && { title },
-          ...description && { description },
-          ...technology && { technology },
-          ...notation && { notation },
-          ...tags && { tags },
+        [kindName]: omitUndefined({
+          ...baseProps,
+          notation,
+          tags: tags ?? void 0,
           ...links && c4.isNonEmptyArray(links) && { links },
           style
-        }
+        })
       };
     }
   };