@heartlandone/vega 2.88.0 → 2.90.0

package/dist/collection/components/vega-input-select/vega-input-select.js

@@ -99,6 +99,16 @@ export class VegaInputSelect {
      * @vegaVersion 1.0.7
      */
     this.required = false;
+    /**
+     * Indicates whether the field should be presented as optional.
+     *
+     * This property only takes effect when `required` is `false`.
+     * When `true`, an "optional" label is displayed next to the field label.
+     *
+     * @default false
+     * @vegaVersion 2.89.0
+     */
+    this.optional = false;
     /**
      * Allows customization of the text displayed within the
      *    select field when single or multiple items are selected.
@@ -341,6 +351,30 @@ export class VegaInputSelect {
       "reflect": true,
       "defaultValue": "false"
     },
+    "optional": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [{
+            "name": "default",
+            "text": "false"
+          }, {
+            "name": "vegaVersion",
+            "text": "2.89.0"
+          }],
+        "text": "Indicates whether the field should be presented as optional.\n\nThis property only takes effect when `required` is `false`.\nWhen `true`, an \"optional\" label is displayed next to the field label."
+      },
+      "attribute": "optional",
+      "reflect": true,
+      "defaultValue": "false"
+    },
     "selectedLabel": {
       "type": "unknown",
       "mutable": false,

package/dist/collection/components/vega-radio/vega-radio-group/vega-radio-group.css

@@ -51,20 +51,19 @@
   display: none;
 }
 
-.vega-label {
+vega-field-label {
   margin-bottom: 16px;
+  display: block;
 }
-
-.vega-label label {
+vega-field-label::part(container) {
   font-family: "Inter", sans-serif;
   font-size: 18px;
   font-weight: 500;
   line-height: 30px;
   letter-spacing: 0px;
-  color: rgba(var(--v-text-primary, 32, 54, 69, 1));
 }
 @media screen and (min-width: 768px) and (max-width: 1023px) {
-  .vega-label label {
+  vega-field-label::part(container) {
     font-family: "Inter", sans-serif;
     font-size: 16px;
     font-weight: 500;
@@ -73,7 +72,7 @@
   }
 }
 @media screen and (min-width: 1024px) and (max-width: 1439px) {
-  .vega-label label {
+  vega-field-label::part(container) {
     font-family: "Inter", sans-serif;
     font-size: 16px;
     font-weight: 500;
@@ -82,7 +81,7 @@
   }
 }
 @media screen and (min-width: 1440px) and (max-width: 9999px) {
-  .vega-label label {
+  vega-field-label::part(container) {
     font-family: "Inter", sans-serif;
     font-size: 16px;
     font-weight: 500;
@@ -90,10 +89,8 @@
     letter-spacing: 0px;
   }
 }
-
-.vega-require {
-  color: rgba(var(--v-text-error, 189, 41, 71, 1));
-  margin-left: 4px;
+vega-field-label::part(label) {
+  word-break: normal;
 }
 
 .vega-hint {

package/dist/collection/components/vega-radio/vega-radio-group/vega-radio-group.js

@@ -88,6 +88,16 @@ export class VegaRadioGroup {
      * @vegaVersion 1.3.0
      */
     this.required = false;
+    /**
+     * Indicates whether the field should be presented as optional.
+     *
+     * This property only takes effect when `required` is `false`.
+     * When `true`, an "optional" label is displayed next to the field label.
+     *
+     * @default false
+     * @vegaVersion 2.90.0
+     */
+    this.optional = false;
     /**
      * Provides a supplementary prompt message that assists users
      *    in selecting the appropriate value for the radio group.
@@ -165,13 +175,7 @@ export class VegaRadioGroup {
       this.renderHintDom()), this.host);
   }
   renderLabelDom() {
-    return (this.label && (h("div", { class: "vega-label" },
-      h("label", { "aria-label": this.label },
-        this.label,
-        this.renderRequireDom()))));
-  }
-  renderRequireDom() {
-    return this.required ? h("span", { class: "vega-require" }, "*") : null;
+    return (this.label && (h("vega-field-label", { label: this.label, isFieldRequired: this.required, disabled: this.disabled, optional: this.optional })));
   }
   renderHintDom() {
     return (this.hint && (h("div", { class: "vega-hint" },
@@ -307,6 +311,30 @@ export class VegaRadioGroup {
       "reflect": true,
       "defaultValue": "false"
     },
+    "optional": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [{
+            "name": "default",
+            "text": "false"
+          }, {
+            "name": "vegaVersion",
+            "text": "2.90.0"
+          }],
+        "text": "Indicates whether the field should be presented as optional.\n\nThis property only takes effect when `required` is `false`.\nWhen `true`, an \"optional\" label is displayed next to the field label."
+      },
+      "attribute": "optional",
+      "reflect": true,
+      "defaultValue": "false"
+    },
     "hint": {
       "type": "string",
       "mutable": false,

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/link-wrapper-renderer.js

@@ -9,6 +9,8 @@ import RTETextNodeRenderer from '../nodes/text-node-renderer';
 import { isNonNullable } from '../../../../../types/type-guard';
 import { UnlinkLinkGroupAction } from '../../actions/unlink-link-group-action';
 import RTEDTORendererManager from '../../../../../helpers/rte-manager/dto-renderer-manager';
+import { VegaRTELinkExtension } from '../../../extensions/link/link-extension';
+import { normalizeUrlByDefaultProtocol } from '../../../extensions/link/utils';
 /**
  * Renders link nodes and wraps them with link editor or anchor element based on edit mode.
  */
@@ -50,7 +52,7 @@ class RTELinkWrapperRenderer {
    * @param {RTERenderContext} context - Context containing render options.
    * @returns {VegaRTERenderResult[]} - Array of rendered HTML elements.
    */
-  render(nodes, linkGroupAnnotation, { editable }) {
+  render(nodes, linkGroupAnnotation, { editable, host }) {
     const blockNodes = this.groupNodesByLink(nodes);
     return blockNodes
       .flatMap((item) => {
@@ -67,6 +69,8 @@ class RTELinkWrapperRenderer {
             return true;
           }
         });
+        this.normalizeLinkNodesByDefaultProtocol(item, host);
+        linkAnnotation = item[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
         return editable
           ? this.renderLinkEditorWrapper(item, linkAnnotation, linkGroupAnnotation)
           : this.renderLink(item, linkAnnotation, linkGroupAnnotation);
@@ -127,5 +131,36 @@ class RTELinkWrapperRenderer {
   renderLink(linkNodes, linkAnnotation, linkGroupAnnotation) {
     return (h("a", Object.assign({}, linkGroupAnnotation.toJsx(linkAnnotation)), linkNodes.map((node) => RTETextNodeRenderer.render(node))));
   }
+  normalizeLinkNodesByDefaultProtocol(linkNodes, host) {
+    if (!host || linkNodes.length === 0) {
+      return;
+    }
+    const firstLinkAnnotation = linkNodes[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+    if (!firstLinkAnnotation) {
+      return;
+    }
+    const normalizedUrl = this.normalizeUrlByDefaultProtocol(firstLinkAnnotation.link.href, host);
+    if (!normalizedUrl || normalizedUrl === firstLinkAnnotation.link.href) {
+      return;
+    }
+    linkNodes.forEach((node) => {
+      const currentLinkAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+      if (!currentLinkAnnotation || currentLinkAnnotation.link.href === normalizedUrl) {
+        return;
+      }
+      node.apply(new LinkAnnotationAction({
+        link: {
+          href: normalizedUrl,
+          groupKey: currentLinkAnnotation.link.groupKey,
+        },
+        type: 'update_link',
+        doSplit: false,
+      }));
+    });
+  }
+  normalizeUrlByDefaultProtocol(url, host) {
+    const linkConfig = VegaRTELinkExtension.configStore.get(host) || {};
+    return normalizeUrlByDefaultProtocol(url, linkConfig.defaultProtocol);
+  }
 }
 export default new RTELinkWrapperRenderer();

package/dist/collection/components/vega-rich-text-editor/extensions/base-toolbar-button-renderer.js

@@ -65,9 +65,10 @@ export class VegaRTEToolbarButtonRenderer {
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {(RTEDropdownListItem | RTEDropdownListGroup)[]} itemList - The list of dropdown items.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
    * @returns {VegaRTERenderResult} - The render result for the dropdown list.
    */
-  renderDropdownListTemplate(h, itemList) {
+  renderDropdownListTemplate(h, itemList, editorContext) {
     return h('div', {
       slot: 'items',
       onMouseDown: this.preventDefault,
@@ -82,8 +83,8 @@ export class VegaRTEToolbarButtonRenderer {
       h('style', { nonce: vegaNonceManager.nonce }, '.rte-dropdown-list vega-dropdown-group vega-dropdown-group { padding-left: 4px }'),
       ...itemList.map((item) => {
         return 'children' in item
-          ? this.renderDropdownGroup(h, item)
-          : this.renderDropdownItem(h, item);
+          ? this.renderDropdownGroup(h, item, editorContext)
+          : this.renderDropdownItem(h, item, editorContext);
       }),
     ]);
   }
@@ -92,32 +93,34 @@ export class VegaRTEToolbarButtonRenderer {
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {RTEDropdownListItem} item - The dropdown item.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
    * @returns {VegaRTERenderResult} - The render result for the dropdown item.
    */
-  renderDropdownItem(h, item) {
+  renderDropdownItem(h, item, editorContext) {
     return h('vega-dropdown-item', {
       key: item.key,
       itemKey: item.key,
-      label: item.label,
+      label: editorContext.translation.t(item.label),
       prefixIcon: item.icon,
     });
   }
   /**
-   * Renders a dropdown item for the toolbar button.
+   * Renders a dropdown group for the toolbar button.
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {RTEDropdownListGroup} item - The dropdown group.
-   * @returns {VegaRTERenderResult} - The render result for the dropdown item.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The render result for the dropdown group.
    */
-  renderDropdownGroup(h, item) {
+  renderDropdownGroup(h, item, editorContext) {
     return h('vega-dropdown-group', {
       key: item.key,
-      label: item.label,
+      label: editorContext.translation.t(item.label),
       divide: false,
     }, item.children.map((child) => {
       return 'children' in child
-        ? this.renderDropdownGroup(h, child)
-        : this.renderDropdownItem(h, child);
+        ? this.renderDropdownGroup(h, child, editorContext)
+        : this.renderDropdownItem(h, child, editorContext);
     }));
   }
   /**
@@ -176,7 +179,7 @@ export class VegaRTEToolbarButtonRenderer {
       return h('vega-font', {
         variant: 'font-field-label-sm',
         color: isDisabled ? 'text-disabled' : 'text-primary',
-      }, label);
+      }, editorContext.translation.t(label));
     }
     return null;
   }

package/dist/collection/components/vega-rich-text-editor/extensions/extension.abstract.js

@@ -9,6 +9,7 @@ import { ActionHandlerInterceptorRegistry } from '../dto/action-handle-strategie
 import { methodPlaceholder } from 'vega-slimmer/core';
 import htmlElementToAnnotationGenerator from '../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
 import { RTEFilterStylesStrategyRegistry } from '../dto/filter-styles-strategies/filter-styles-strategy-registry';
+import { RTEExtensionStateStore } from './rte-extension-state-store';
 const patchedBlockClasses = new WeakSet();
 const annotationHandlersByClass = new WeakMap();
 /**
@@ -98,6 +99,16 @@ export class VegaRTEExtension {
       return instance;
     };
   }
+  /**
+   * Create a per-host state store for this extension.
+   * Declare as `static readonly` to share store across extension instances while isolating state per RTE host.
+   *
+   * @template T - The type of the state value to store per host.
+   * @returns {RTEExtensionStateStore<T>} A new state store instance.
+   */
+  static createStateStore() {
+    return new RTEExtensionStateStore();
+  }
   /**
    * Lifecycle hook called by the rich text editor before the first render
    * (during `componentWillLoad`).  Override this method to perform per-host

package/dist/collection/components/vega-rich-text-editor/extensions/functions/renderers/function-toolbar-button-renderer.js

@@ -16,7 +16,7 @@ export class FunctionToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer
         showArrowIcon: true,
         tooltip: { text: 'Insert function' },
       }),
-      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST),
+      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST, editorContext),
     ]);
   }
   /**

package/dist/collection/components/vega-rich-text-editor/extensions/horizontal-line/action-handler-strategies/horizontal-line-block-insert-strategy.js

@@ -0,0 +1,79 @@
+import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
+import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
+import { SplitBlockWithNodeAction } from '../../../dto/actions/split-block-with-node-action';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTEHorizontalLineBlock } from '../dto/horizontal-line-block';
+import { RTETextNode } from '../../../dto/nodes/text-node';
+/**
+ * Strategy to handle the insertion of a horizontal line block into the rich text editor.
+ * Follows the same pattern as BlockInsertImageIntoTextStrategy (before/after/split).
+ */
+export class InsertHorizontalLineBlockStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const hrBlock = RTEHorizontalLineBlock.create();
+    if (action.splitPointNode instanceof RTETextNode) {
+      const splitNode = action.splitPointNode;
+      const startOffsetOfNode = action.startOffsetOfNode;
+      if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
+        this.insertAfterWithFocus(action, target, hrBlock);
+      }
+      else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
+        target.parent.apply(new InsertChildrenBeforeAction(target, hrBlock));
+        action.nextFocusNode = target.getFirstNode();
+      }
+      else {
+        const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+        target.apply(splitBlockAction);
+        const nextBlock = this.getNextSiblingBlock(target);
+        target.parent.apply(new InsertChildrenAfterAction(target, hrBlock));
+        action.nextFocusNode = nextBlock.getFirstNode();
+      }
+    }
+    else if (action.splitPointNode) {
+      // Decorator node selected (image, HR, etc.) — insert after current block
+      this.insertAfterWithFocus(action, target, hrBlock);
+    }
+    else {
+      const emptyParagraph = super.createNewParagraph('');
+      target.apply(new AppendChildrenAction([hrBlock, emptyParagraph]));
+      action.nextFocusNode = emptyParagraph.children[0];
+    }
+  }
+  /**
+   * Insert HR after target. If next sibling is focusable (has a text node), move cursor there;
+   * otherwise create an empty paragraph after HR.
+   *
+   * @param {InsertHorizontalLineBlockAction} action - The insert action whose `nextFocusNode` is updated.
+   * @param {RTEBlock} target - The block after which the HR is inserted.
+   * @param {RTEHorizontalLineBlock} hrBlock - The HR block to insert.
+   */
+  insertAfterWithFocus(action, target, hrBlock) {
+    const nextBlock = this.getNextSiblingBlock(target);
+    const nextFirstNode = nextBlock === null || nextBlock === void 0 ? void 0 : nextBlock.getFirstNode();
+    if (nextFirstNode instanceof RTETextNode) {
+      target.parent.apply(new InsertChildrenAfterAction(target, hrBlock));
+      action.nextFocusNode = nextFirstNode;
+    }
+    else {
+      const emptyParagraph = super.createNewParagraph('');
+      target.parent.apply(new InsertChildrenAfterAction(target, hrBlock, emptyParagraph));
+      action.nextFocusNode = emptyParagraph.children[0];
+    }
+  }
+  /**
+   * Get the next sibling block of the given block.
+   *
+   * @param {RTEBlock} block - The current block.
+   * @returns {RTEBlock | undefined} The next sibling block, or undefined if none.
+   */
+  getNextSiblingBlock(block) {
+    const parent = block.parent;
+    const siblings = parent.children;
+    const index = siblings.indexOf(block);
+    return siblings[index + 1];
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/horizontal-line/action-handler-strategies/hr-to-horizontal-line-block-strategy.js

@@ -0,0 +1,45 @@
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import { RTEHorizontalLineBlock } from '../dto/horizontal-line-block';
+import htmlElementToAnnotationGenerator from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
+/**
+ * Strategy to convert `<hr>` HTML elements into RTEHorizontalLineBlock instances.
+ */
+export class HrToHorizontalLineBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * Determines if this strategy can handle the current element.
+   *
+   * @param {HTMLElement[]} elementsArray - Array of elements to process.
+   * @param {number} currentIndex - The current index in the array.
+   * @returns {number} The number of elements this strategy can handle (1 for `<hr>`, 0 otherwise).
+   */
+  canHandle(elementsArray, currentIndex) {
+    return elementsArray[currentIndex].tagName === 'HR' ? 1 : 0;
+  }
+  /**
+   * Converts the `<hr>` element to an RTEHorizontalLineBlock.
+   * Uses `htmlElementToAnnotationGenerator` to extract annotations (handles refill + filter).
+   *
+   * @param {HTMLElement[]} elementsArray - Array of elements.
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {Nullable<RTEContentBlock>} The created horizontal line block.
+   */
+  handle(elementsArray, options) {
+    const element = elementsArray[0];
+    const annotations = htmlElementToAnnotationGenerator.generate(RTEHorizontalLineBlock, element, options);
+    return RTEHorizontalLineBlock.create(annotations, options);
+  }
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks() {
+    // `<hr>` is a void element — no children to append.
+  }
+  /**
+   * `<hr>` is a void element — no children to process.
+   *
+   * @returns {boolean} Always false.
+   */
+  shouldProceedToElementChildren() {
+    return false;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/horizontal-line/actions/insert-horizontal-line-block-action.js

@@ -0,0 +1,14 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export const INSERT_HORIZONTAL_LINE_BLOCK = 'INSERT_HORIZONTAL_LINE_BLOCK';
+/**
+ * Action to insert a horizontal line block into the rich text editor.
+ * Carries cursor position info to support split-paragraph insertion (same pattern as InsertImageToBlockAction).
+ */
+export class InsertHorizontalLineBlockAction extends ModifyContentAction {
+  constructor(splitPointNode, startOffsetOfNode = 0) {
+    super();
+    this.type = INSERT_HORIZONTAL_LINE_BLOCK;
+    this.splitPointNode = splitPointNode;
+    this.startOffsetOfNode = startOffsetOfNode;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/horizontal-line/assets/horizontal-line.js

@@ -0,0 +1,3 @@
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor"  d="M0 224H32 608h32v64H608 32 0V224z"/></svg>`,
+};

package/dist/collection/components/vega-rich-text-editor/extensions/horizontal-line/dto/horizontal-line-annotation.js

@@ -0,0 +1,63 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { HR_DEFAULT_STYLES } from '../filter-styles-strategies/horizontal-line-block/horizontal-line-filter-styles-strategy';
+export var RTEHorizontalLineExtensionAnnotationTypeEnum;
+(function (RTEHorizontalLineExtensionAnnotationTypeEnum) {
+  RTEHorizontalLineExtensionAnnotationTypeEnum["HORIZONTAL_LINE"] = "HORIZONTAL_LINE";
+})(RTEHorizontalLineExtensionAnnotationTypeEnum || (RTEHorizontalLineExtensionAnnotationTypeEnum = {}));
+/**
+ * Horizontal line annotation.
+ * Mirrors {@link TextStyleAnnotation}: emits the HR default visual styles in
+ * standalone mode (source edit) and the corresponding class in normal mode.
+ * Only added to the block when `autoMatchFormat` is enabled.
+ */
+export class HorizontalLineAnnotation extends BlockAnnotation {
+  constructor() {
+    super(...arguments);
+    this.type = RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE;
+  }
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE, HorizontalLineAnnotation]} Map item.
+   */
+  static from() {
+    return [RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE, new HorizontalLineAnnotation()];
+  }
+  /**
+   * Get the default styles for the horizontal line element.
+   *
+   * @returns {AnnotationStyle} The default styles.
+   */
+  static getDefaultStyles() {
+    return HR_DEFAULT_STYLES;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    // HR identity is captured by the block type; nothing to serialize.
+    return null;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new HorizontalLineAnnotation();
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return 'v-rte-horizontal-line-hr';
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return HorizontalLineAnnotation.getDefaultStyles();
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/horizontal-line/dto/horizontal-line-block.js

@@ -0,0 +1,89 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTEHorizontalLineNode } from './horizontal-line-node';
+import { generateUUID } from '../../../../../utils/misc';
+import { HorizontalLineAnnotation } from './horizontal-line-annotation';
+/**
+ * Horizontal line block — a block containing a single `<hr>` decorator node.
+ */
+export class RTEHorizontalLineBlock extends RTEBlock {
+  constructor(id, options) {
+    super(id);
+    this.dtoName = RTEHorizontalLineBlock.dtoName;
+    this.type = 'horizontal-line';
+    this.children = [];
+    const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
+    if (autoMatchFormat) {
+      this.annotationMap = new Map([HorizontalLineAnnotation.from()]);
+    }
+  }
+  /**
+   * Creates an RTEHorizontalLineBlock from a JSON representation.
+   *
+   * @param {VegaRTECustomBlock} block - The block JSON to convert.
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {RTEHorizontalLineBlock} The created block instance.
+   */
+  static from(block, options = { autoMatchFormat: true }) {
+    var _a, _b;
+    const hrBlock = new RTEHorizontalLineBlock(block.id, options);
+    const nodeId = ((_b = (_a = block.children) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.id) || generateUUID();
+    const node = new RTEHorizontalLineNode(nodeId, hrBlock);
+    hrBlock.children = [node];
+    if (block.annotations) {
+      RTEBlock.convertAnnotationsToMap(hrBlock.annotationMap, block.annotations);
+    }
+    return hrBlock;
+  }
+  /**
+   * Creates a new RTEHorizontalLineBlock with a child node.
+   *
+   * @param {VegaRTEBlockAnnotations} [annotations] - Optional annotations (e.g. customStyle overrides).
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {RTEHorizontalLineBlock} A new block instance.
+   */
+  static create(annotations, options = { autoMatchFormat: true }) {
+    const hrBlock = new RTEHorizontalLineBlock(generateUUID(), options);
+    const node = new RTEHorizontalLineNode(generateUUID(), hrBlock);
+    hrBlock.children = [node];
+    if (annotations) {
+      RTEBlock.convertAnnotationsToMap(hrBlock.annotationMap, annotations);
+    }
+    return hrBlock;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { type: 'horizontal-line', children: this.children.map((node) => node.toJSON()) });
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    const attrStr = super.generateAttributeString(options);
+    return `<hr${attrStr}>`;
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    return this.children.length > 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1];
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const clonedBlock = new RTEHorizontalLineBlock(this.id);
+    clonedBlock.children = this.children.map((node) => node.clone(clonedBlock));
+    clonedBlock.annotationMap = super.cloneAnnotations();
+    clonedBlock.parent = parent;
+    return clonedBlock;
+  }
+}
+RTEHorizontalLineBlock.dtoName = 'RTEHorizontalLineBlock';

package/dist/collection/components/vega-rich-text-editor/extensions/horizontal-line/dto/horizontal-line-node.js

@@ -0,0 +1,32 @@
+import { RTEDecoratorNode } from '../../../dto/nodes/decorator-node';
+/**
+ * Horizontal line node — a decorator node representing `<hr>` in the editor.
+ */
+export class RTEHorizontalLineNode extends RTEDecoratorNode {
+  constructor(id, parentBlock, annotationMap) {
+    super(id, annotationMap);
+    this.type = 'horizontal-line';
+    this.parent = parentBlock;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      type: 'horizontal-line',
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    return new RTEHorizontalLineNode(this.id, parent, super.cloneAnnotations());
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml() {
+    return '<hr>';
+  }
+}