@heartlandone/vega 2.79.0 → 2.81.0

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/custom-style-annotation-handler.js

@@ -1,4 +1,4 @@
-import { dashCaseToCamel } from '../../../../../../../utils/string';
+import { createStyleMapFromElement } from '../../../../../helpers/utils';
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
 /** Handle custom style annotation */
 export class CustomStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
@@ -19,30 +19,7 @@ export class CustomStyleAnnotationHandler extends AnnotationGeneratorStrategyAbs
    * @returns {VegaRTETextAnnotations} - Annotation.
    */
   handle(element) {
-    const styles = this.generateCustomStyleAnnotations(element);
+    const styles = createStyleMapFromElement(element);
     return Object.keys(styles).length > 0 ? { customStyle: styles } : {};
   }
-  /**
-   * Obtain and format the style of element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {AnnotationStyle} - Record<string, string>.
-   */
-  generateCustomStyleAnnotations(element) {
-    const customStyle = element.getAttribute('style');
-    if (!customStyle)
-      return {};
-    const styleValue = customStyle.split(';').filter(Boolean);
-    return styleValue
-      .filter((key) => key !== ' ')
-      .map((key) => {
-      // to remove redundant quote pairs if needed, for example: ['fontFamily: "Roboto Mono"'] will be updated to ['fontFamily: Roboto Mono']
-      const styleObject = key.replace(/(['"])(.*?)\1/g, '$2').split(':');
-      const styleKey = dashCaseToCamel(styleObject[0].trim());
-      return {
-        [styleKey]: styleObject[1].trim().replace(';', ''),
-      };
-    })
-      .reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {});
-  }
 }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator.js

@@ -10,10 +10,13 @@ import { ItalicAnnotationHandler } from './italic-annotation-handler';
 import { LinkAnnotationHandler } from './link-annotation-handler';
 import { StrikeThroughAnnotationHandler } from './strike-through-annotation-handler';
 import { UnderlineAnnotationHandler } from './underline-annotation-handler';
+import { TextStyleAnnotation } from '../../../../../dto/annotations/text-style-annotation';
 import { TextStyleAnnotationHandler } from './text-style-annotation-handler';
 import { ImageSizeAnnotationHandler } from './image-size-annotation-handler';
 import { ImageAltAnnotationHandler } from './image-alt-annotation-handler';
 import { InlineHtmlAnnotationHandler } from './inline-html-annotation-handler';
+import { RTEFilterStylesStrategyRegistry } from '../../../../../dto/filter-styles-strategies/filter-styles-strategy-registry';
+import { Predicate } from '../predicate';
 /** Html element to annotations generator */
 class HtmlElementToAnnotationGenerator {
   constructor() {
@@ -32,7 +35,6 @@ class HtmlElementToAnnotationGenerator {
       new CustomAttributeAnnotationHandler(),
       new CustomClassAnnotationHandler(),
       new CustomStyleAnnotationHandler(),
-      new LinkAnnotationHandler(),
       new TextStyleAnnotationHandler(),
       new InlineHtmlAnnotationHandler(),
     ];
@@ -59,8 +61,13 @@ class HtmlElementToAnnotationGenerator {
    * @returns {V} Generated annotations.
    */
   generate(targetDto, element, options = { autoMatchFormat: true }) {
-    const isLinkElement = element.tagName === 'A';
-    return this.handlers
+    if (options && options.filterInlineStyles) {
+      RTEFilterStylesStrategyRegistry.executeTheStrategyRefillAction(targetDto.name, element);
+    }
+    // Guard against <a> wrapping block content (e.g. <a><video></a>), which is processed as an
+    // html-block (targetDto !== RTETextNode) — link-only mode should not apply in that case.
+    const isLinkElement = Predicate.isLinkElement(element) && targetDto.name === 'RTETextNode';
+    const annotations = this.handlers
       .filter((handler) => !options.autoMatchFormat && isLinkElement ? handler instanceof LinkAnnotationHandler : true)
       .filter((handler) => element.nodeType !== Node.TEXT_NODE &&
       handler.canHandle(targetDto, {
@@ -71,6 +78,43 @@ class HtmlElementToAnnotationGenerator {
       const result = handler.handle(element, options.parentAnnotations);
       return Object.assign(Object.assign({}, annotations), result);
     }, {});
+    this.removeTextStyleDefaultsFromCustomStyle(annotations);
+    const strategies = RTEFilterStylesStrategyRegistry.getStrategies(targetDto.name);
+    for (const strategy of strategies) {
+      if (options.autoMatchFormat || strategy.alwaysFilter) {
+        strategy.filterAnnotations(annotations);
+      }
+    }
+    return annotations;
+  }
+  /**
+   * Remove default text-style properties from customStyle.
+   * This prevents repeated styling when switching between source edit and normal mode.
+   *
+   * Note: This method mutates the customStyle object inside `annotations` in place and returns the same reference.
+   *
+   * @param {V} annotations - The generated annotations.
+   * @returns {V} The same annotations reference with customStyle cleaned up.
+   */
+  removeTextStyleDefaultsFromCustomStyle(annotations) {
+    const textStyle = 'textStyle' in annotations ? annotations.textStyle : undefined;
+    const customStyle = annotations.customStyle;
+    if (!textStyle || !customStyle) {
+      return annotations;
+    }
+    const defaultStyles = TextStyleAnnotation.getDefaultStyles(textStyle);
+    if (!defaultStyles) {
+      return annotations;
+    }
+    for (const key of Object.keys(defaultStyles)) {
+      if (customStyle[key] === defaultStyles[key]) {
+        delete customStyle[key];
+      }
+    }
+    if (Object.keys(customStyle).length === 0) {
+      delete annotations.customStyle;
+    }
+    return annotations;
   }
 }
 export default new HtmlElementToAnnotationGenerator();

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/inline-html-annotation-handler.js

@@ -3,6 +3,8 @@ import { CustomAttributeAnnotationHandler } from './custom-attribute-annotation-
 import { CustomStyleAnnotationHandler } from './custom-style-annotation-handler';
 import { CustomClassAnnotationHandler } from './custom-class-annotation-handler';
 import { RTETextNode } from '../../../../../dto/nodes/text-node';
+import { ALWAYS_INLINE_TAGS, DEDICATED_STRATEGY_TAGS } from '../strategy-tags';
+import { generateUUID } from '../../../../../../../utils/misc';
 /**
  * Handle inline html annotation
  */
@@ -23,12 +25,14 @@ export class InlineHtmlAnnotationHandler extends AnnotationGeneratorStrategyAbst
    * @inheritDoc
    */
   handle(element, parentAnnotations) {
-    const canHandle = InlineHtmlAnnotationHandler.canHandleTags.includes(element.nodeName);
-    if (canHandle) {
-      const inlineHtml = this.generateInlineHtmlAnnotation(element, Object.assign({}, parentAnnotations));
-      if (inlineHtml) {
-        return { inlineHtml: inlineHtml };
-      }
+    // Skip block-level dedicated tags (P, H1-H6, LI, UL, OL, IMG).
+    // Tags in ALWAYS_INLINE_TAGS (CODE, A) are exempt and still produce inlineHtml annotations.
+    if (DEDICATED_STRATEGY_TAGS.has(element.nodeName) && !ALWAYS_INLINE_TAGS.has(element.nodeName)) {
+      return {};
+    }
+    const inlineHtml = this.generateInlineHtmlAnnotation(element, Object.assign({}, parentAnnotations));
+    if (inlineHtml) {
+      return { inlineHtml: inlineHtml };
     }
     return {};
   }
@@ -41,59 +45,32 @@ export class InlineHtmlAnnotationHandler extends AnnotationGeneratorStrategyAbst
    */
   generateInlineHtmlAnnotation(child, annotations) {
     let { inlineHtml } = annotations;
-    if (!RTETextNode.supportsHtmlTag(child.nodeName.toLowerCase()) ||
-      (child.childNodes.length === 1 && child.childNodes[0].nodeType !== Node.TEXT_NODE)) {
-      const childInlineHtmlNode = {
-        htmlTag: child.nodeName.toLowerCase(),
-        customAttribute: this.customAttributeHandler.handle(child).customAttribute,
-        customStyle: this.customStyleAnnotationHandler.handle(child).customStyle,
-        customClass: this.customClassAnnotationHandler.handle(child).customClass,
-      };
+    const hasElementChildren = Array.from(child.childNodes).some((c) => c.nodeType === Node.ELEMENT_NODE);
+    if (!RTETextNode.supportsHtmlTag(child.nodeName.toLowerCase()) || hasElementChildren) {
+      const childInlineHtmlNode = Object.assign(Object.assign({ htmlTag: child.nodeName.toLowerCase() }, (hasElementChildren ? { groupId: generateUUID() } : {})), { customAttribute: this.customAttributeHandler.handle(child).customAttribute, customStyle: this.customStyleAnnotationHandler.handle(child).customStyle, customClass: this.customClassAnnotationHandler.handle(child).customClass });
       if (!inlineHtml) {
         inlineHtml = childInlineHtmlNode;
       }
       else {
-        let lastChild = inlineHtml;
-        while (lastChild.child &&
-          child.parentNode &&
-          lastChild.child.htmlTag === child.parentNode.nodeName.toLowerCase()) {
-          lastChild = lastChild.child;
-        }
-        lastChild.child = childInlineHtmlNode;
+        inlineHtml = this.appendToInlineHtmlChain(inlineHtml, childInlineHtmlNode, child.parentNode);
       }
     }
     return inlineHtml ? Object.assign({}, inlineHtml) : null;
   }
+  /**
+   * Immutably appends `toAppend` at the correct position in the chain — the
+   * deepest node whose `child.htmlTag` still matches `parentNode.nodeName`.
+   * Each level is reconstructed via spread so the original chain is never mutated.
+   *
+   * @param {VegaInlineHtmlSchema} node - Current chain node.
+   * @param {VegaInlineHtmlSchema} toAppend - Node to append at the tail.
+   * @param {ParentNode | null} parentNode - DOM parent of the element being processed.
+   * @returns {VegaInlineHtmlSchema} A new chain with `toAppend` inserted.
+   */
+  appendToInlineHtmlChain(node, toAppend, parentNode) {
+    if (node.child && parentNode && node.child.htmlTag === parentNode.nodeName.toLowerCase()) {
+      return Object.assign(Object.assign({}, node), { child: this.appendToInlineHtmlChain(node.child, toAppend, parentNode) });
+    }
+    return Object.assign(Object.assign({}, node), { child: toAppend });
+  }
 }
-InlineHtmlAnnotationHandler.canHandleTags = [
-  'A',
-  'ABBR',
-  'AUDIO',
-  'B',
-  'BDI',
-  'BDO',
-  'CITE',
-  'CODE',
-  'DEL',
-  'DFN',
-  'EMBED',
-  'EM',
-  'I',
-  'INS',
-  'KBD',
-  'MARK',
-  'METER',
-  'OUTPUT',
-  'PROGRESS',
-  'Q',
-  'S',
-  'SMALL',
-  'SPAN',
-  'STRONG',
-  'SUB',
-  'SUP',
-  'TIME',
-  'U',
-  'VAR',
-  'VIDEO',
-];

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/italic-annotation-handler.js

@@ -1,4 +1,5 @@
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { ITALIC_FONT_STYLE } from '../../../../../dto/annotations/text-format-default-styles';
 /** Handle italic annotation */
 export class ItalicAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
@@ -25,7 +26,7 @@ export class ItalicAnnotationHandler extends AnnotationGeneratorStrategyAbstract
    */
   isItalic(element) {
     return (element.nodeName === 'I' ||
-      element.style.fontStyle === 'italic' ||
+      element.style.fontStyle === ITALIC_FONT_STYLE ||
       element.nodeName === 'EM' ||
       element.classList.contains('v-rte--italic'));
   }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/link-annotation-handler.js

@@ -1,4 +1,5 @@
 import { generateUUID } from '../../../../../../../utils/misc';
+import { Predicate } from '../predicate';
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
 import { CustomAttributeAnnotationHandler } from './custom-attribute-annotation-handler';
 import { CustomClassAnnotationHandler } from './custom-class-annotation-handler';
@@ -32,7 +33,7 @@ export class LinkAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   handle(element, parentAnnotations = {}) {
     if (parentAnnotations.link)
       return { link: parentAnnotations.link };
-    return element.tagName === 'A' ? { link: this.generateLinkAnnotations(element) } : {};
+    return Predicate.isLinkElement(element) ? { link: this.generateLinkAnnotations(element) } : {};
   }
   /**
    * Generate link annotations.

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/strike-through-annotation-handler.js

@@ -1,4 +1,5 @@
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { STRIKETHROUGH_TEXT_DECORATION } from '../../../../../dto/annotations/text-format-default-styles';
 /** Handle strike through annotation */
 export class StrikeThroughAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
@@ -26,7 +27,7 @@ export class StrikeThroughAnnotationHandler extends AnnotationGeneratorStrategyA
    * @returns {boolean} - boolean.
    */
   isStrikethrough(element) {
-    return (element.style.textDecoration.includes('line-through') ||
+    return (element.style.textDecoration.includes(STRIKETHROUGH_TEXT_DECORATION) ||
       element.nodeName === 'S' ||
       element.nodeName === 'DEL' ||
       element.classList.contains('v-rte--strikethrough'));

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/text-style-annotation-handler.js

@@ -86,6 +86,8 @@ export class TextStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstr
    */
   getElementTypeByNodeName(element) {
     switch (element.nodeName) {
+      case 'P':
+        return 'paragraph';
       case 'H1':
         return 'heading-1';
       case 'H2':
@@ -110,7 +112,8 @@ export class TextStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstr
    */
   getElementTypeByClassName(element) {
     if (element.className) {
-      const match = /\bv-rte--text-style-(title|subtitle|heading-1|heading-2|heading-3|paragraph)\b/.exec(element.className);
+      // Match class name with pattern "v-rte--text-style-{textStyle}" or "v-rte-{textStyle}".
+      const match = /\bv-rte-(?:-text-style-)?(title|subtitle|heading-1|heading-2|heading-3|heading-4|heading-5|heading-6|paragraph)\b/.exec(element.className);
       if (match) {
         return match[1];
       }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/underline-annotation-handler.js

@@ -1,4 +1,5 @@
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { UNDERLINE_TEXT_DECORATION } from '../../../../../dto/annotations/text-format-default-styles';
 /** Handle underline annotation */
 export class UnderlineAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
@@ -24,7 +25,7 @@ export class UnderlineAnnotationHandler extends AnnotationGeneratorStrategyAbstr
    * @returns {boolean} - boolean.
    */
   isUnderline(element) {
-    return (element.style.textDecoration.includes('underline') ||
+    return (element.style.textDecoration.includes(UNDERLINE_TEXT_DECORATION) ||
       element.nodeName === 'U' ||
       element.nodeName === 'INS' ||
       element.classList.contains('v-rte--underline'));

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy.js

@@ -3,23 +3,17 @@ import { RTETextBlock } from '../../../../dto/blocks/text-block';
 import { RTETextNode } from '../../../../dto/nodes/text-node';
 import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
-import { InlineHtmlAnnotationHandler } from './annotation-handler/inline-html-annotation-handler';
+import { ALWAYS_INLINE_TAGS, DEDICATED_STRATEGY_TAGS, PHRASING_CONTENT_TAGS, isInBlockTextContext, } from './strategy-tags';
 /** Transform continue inline block elements to text block DTO */
 export class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   /**
-   * Can be handle.
-   *
-   * @param {HTMLElement[]} elementsArray - Current elements.
-   * @param {number} currentIndex - Current element index.
-   * @returns {number} - can be handled element count.
+   * @inheritDoc
    */
-  canHandle(elementsArray, currentIndex) {
+  canHandle(elementsArray, currentIndex, options) {
     let count = 0;
     for (let i = currentIndex; i < elementsArray.length; i++) {
       const element = elementsArray[i];
-      if (element.nodeType === Node.TEXT_NODE ||
-        (ContinueInlineToRTETextBlockStrategy.canHandleTags.includes(element.nodeName) &&
-          !(element.textContent === '' && element.querySelector('IMG')))) {
+      if (this.isInlineCandidate(element, options)) {
         count++;
       }
       else {
@@ -79,11 +73,85 @@ export class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrateg
         return null;
     }
   }
+  /**
+   * Check if the element is an inline candidate to be included in the text block.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
+   * @returns {boolean} - Whether the element is an inline candidate.
+   */
+  isInlineCandidate(element, options) {
+    if (element.nodeType === Node.TEXT_NODE)
+      return true;
+    if (ALWAYS_INLINE_TAGS.has(element.nodeName))
+      return true;
+    if (this.isDedicatedBlockTag(element.nodeName))
+      return false;
+    if (options.autoMatchFormat === false && isInBlockTextContext(element))
+      return true;
+    return this.isInlineLeafOrWrapper(element);
+  }
+  /**
+   * Returns true when the tag has a dedicated block strategy (excludes inline annotation tags CODE and A).
+   *
+   * @param {string} nodeName - The node name to check.
+   * @returns {boolean} - Whether the tag is a dedicated block tag.
+   */
+  isDedicatedBlockTag(nodeName) {
+    return DEDICATED_STRATEGY_TAGS.has(nodeName) && !ALWAYS_INLINE_TAGS.has(nodeName);
+  }
+  /**
+   * Returns true for empty elements, text-only elements, or elements whose entire
+   * descendant tree contains no block-level elements (e.g. {@code <u><i><b>text</b></i></u>}).
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} - Whether the element is an inline leaf or wrapper.
+   */
+  isInlineLeafOrWrapper(element) {
+    if (element.childNodes.length === 0) {
+      // An empty element is inline only if it is a known HTML phrasing-content
+      // element (SPAN, EM, STRONG, …). Block containers (DIV, SECTION, …)
+      // and unknown/custom elements default to block separators.
+      return PHRASING_CONTENT_TAGS.has(element.nodeName);
+    }
+    if (this.isTextOnlyElement(element)) {
+      return PHRASING_CONTENT_TAGS.has(element.nodeName) || ALWAYS_INLINE_TAGS.has(element.nodeName);
+    }
+    return this.hasOnlyInlineDescendants(element);
+  }
+  /**
+   * Returns true when the element has text-node children but no element children.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} - Whether the element contains only text nodes.
+   */
+  isTextOnlyElement(element) {
+    const childNodes = Array.from(element.childNodes);
+    return (!childNodes.some((child) => child.nodeType === Node.ELEMENT_NODE) &&
+      childNodes.some((child) => child.nodeType === Node.TEXT_NODE));
+  }
+  /**
+   * Returns true if the element's subtree contains only inline formatting wrappers.
+   * Instead of maintaining a hard coded tag allowlist, the check derives from:
+   *  1. {@link DEDICATED_STRATEGY_TAGS} — rejects known block/media tags
+   *  2. Void-element check — elements with no child nodes (INPUT, COL, HR, …)
+   *     are replaced/embedded content, not formatting wrappers
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @returns {boolean} True if the element has no block-level descendants.
+   */
+  hasOnlyInlineDescendants(element) {
+    for (let i = 0; i < element.children.length; i++) {
+      const child = element.children[i];
+      if (this.isDedicatedBlockTag(child.nodeName))
+        return false;
+      // An empty element is not a formatting wrapper — it is likely a void/embedded
+      // element (INPUT, HR, COL, empty SPAN) that acts as a block separator.
+      if (!child.hasChildNodes())
+        return false;
+      if (!this.hasOnlyInlineDescendants(child))
+        return false;
+    }
+    return true;
+  }
 }
-ContinueInlineToRTETextBlockStrategy.canHandleTags = [
-  ...InlineHtmlAnnotationHandler.canHandleTags,
-  'CODE',
-  'A',
-  'VEGA-RICH-TEXT-LINK-EDITOR',
-  'BR',
-];

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy-processor.js

@@ -13,7 +13,7 @@ class ElementToDtoStrategyProcessor {
     const strategies = this.getElementToBlockStrategies();
     const outputs = [];
     for (let i = 0; i < elements.length; i++) {
-      if (this.isInvalidElement(elements[i]))
+      if (this.isInvalidElement(elements[i], options))
         continue;
       let canHandledCount = 0;
       for (const strategy of strategies) {
@@ -40,14 +40,21 @@ class ElementToDtoStrategyProcessor {
     return outputs;
   }
   /**
-   * Checks if the given element is valid to parse.
+   * Checks if the given element should be skipped during processing.
    *
-   * @param {HTMLElement} element - The pasted element.
-   * @returns {boolean} Is valid
+   * Comment nodes are always skipped. META and STYLE elements are skipped only
+   * in auto-match mode; in raw-HTML mode (autoMatchFormat: false) they are passed
+   * through so downstream strategies can decide how to handle them.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @param {VegaRTETransformOptions} options - Transform options.
+   * @returns {boolean} True when the element should be skipped.
    */
-  isInvalidElement(element) {
+  isInvalidElement(element, options) {
     if (element.nodeType === Node.COMMENT_NODE)
       return true;
+    if (options.autoMatchFormat === false)
+      return false;
     return ['META', 'STYLE'].includes(element.nodeName);
   }
   /**

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/html-block-strategy.js

@@ -2,6 +2,8 @@ import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.a
 import { RTEHtmlBlock } from '../../../../dto/blocks/html-block';
 import { generateUUID } from '../../../../../../utils/misc';
 import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
+import { Predicate } from './predicate';
+import { ALWAYS_INLINE_TAGS, DEDICATED_STRATEGY_TAGS, PHRASING_CONTENT_TAGS, STRUCTURED_CONTAINER_TAGS, isInBlockTextContext, } from './strategy-tags';
 /**
  * Converting HTML block elements into RTE blocks.
  */
@@ -11,13 +13,17 @@ export class HtmlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
    */
   canHandle(elementsArray, currentIndex, options) {
     const element = elementsArray[currentIndex];
-    // - div + img should be handled by RTEImageBlock
-    const isCustomContainer = element.nodeName === 'DIV'
-      ? element.childNodes.length > 0 && element.childNodes[0].nodeName !== 'IMG'
-      : true;
+    if (element.nodeType === Node.TEXT_NODE || this.isInlineTagWithoutBlockChildren(element, options)) {
+      return 0;
+    }
+    // Skip dedicated-strategy tags unless all children are block-level embedded
+    // elements (e.g. <p><video></p>), in which case fall back to html-block.
+    if (DEDICATED_STRATEGY_TAGS.has(element.nodeName) && !this.shouldFallBackToHtmlBlock(element)) {
+      return 0;
+    }
     return !options.autoMatchFormat &&
-      isCustomContainer &&
-      HtmlBlockStrategy.canHandleTags.includes(elementsArray[currentIndex].nodeName)
+      this.isCustomHtmlContainer(element) &&
+      !Predicate.isTitleOrSubtitle(element)
       ? 1
       : 0;
   }
@@ -43,6 +49,89 @@ export class HtmlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   shouldProceedToElementChildren() {
     return true;
   }
+  /**
+   * Returns true for elements that should be treated as inline content even if they have no element children (e.g. <span>text</span>).
+   * This includes any element in a block text context (P, H1-H6, LI) and any element with text-node children but no element-node children.
+   *
+   * In raw-HTML mode (autoMatchFormat: false), the text-only heuristic only
+   * applies to elements whose parent is itself a text-only wrapper (e.g.
+   * {@code <div><span>Title</span></div>}). Structural children of non-text
+   * containers (TABLE → CAPTION, TR → TH/TD, etc.) skip this heuristic so
+   * they reach {@link isCustomHtmlContainer} and become html-blocks.
+   *
+   * @param {HTMLElement} element - Element to check.
+   * @param {VegaRTETransformOptions} options - Transform options.
+   * @returns {boolean} True if the element should be treated as inline content.
+   */
+  isInlineTagWithoutBlockChildren(element, options) {
+    if (isInBlockTextContext(element)) {
+      // Empty elements that are not recognized inline elements should not
+      // be forced inline — they may represent block-level embedded content
+      // (e.g. <video src="...">, <audio>, <iframe src="...">).
+      if (element.childNodes.length === 0 &&
+        element.textContent === '' &&
+        !ALWAYS_INLINE_TAGS.has(element.nodeName) &&
+        !PHRASING_CONTENT_TAGS.has(element.nodeName)) {
+        return false;
+      }
+      return true;
+    }
+    const childNodes = Array.from(element.childNodes);
+    const isTextOnly = !childNodes.some((child) => child.nodeType === Node.ELEMENT_NODE) &&
+      childNodes.some((child) => child.nodeType === Node.TEXT_NODE);
+    if (!isTextOnly) {
+      return false;
+    }
+    // In raw-HTML mode, a text-only element is inline only if:
+    // 1. Its parent is not a structured container (TABLE, TR, …)
+    // 2. The element itself is phrasing content (SPAN, EM, …)
+    // Non-phrasing text-only elements (SUMMARY, FIGCAPTION, OPTION, SVG TEXT,
+    // etc.) must fall through to become html-blocks.
+    if (options.autoMatchFormat === false) {
+      if (STRUCTURED_CONTAINER_TAGS.has(element.parentElement.nodeName))
+        return false; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+      return PHRASING_CONTENT_TAGS.has(element.nodeName) || ALWAYS_INLINE_TAGS.has(element.nodeName);
+    }
+    return true;
+  }
+  /**
+   * Returns true when a dedicated-strategy element should fall back to html-block
+   * because all its children are non-text, non-inline, non-dedicated elements
+   * — indicating purely block-level embedded content that the dedicated text-block
+   * strategy cannot represent.
+   *
+   * @param {HTMLElement} element - The dedicated-strategy element to check.
+   * @returns {boolean} True when the element should be treated as html-block.
+   */
+  shouldFallBackToHtmlBlock(element) {
+    const childNodes = Array.from(element.childNodes);
+    if (childNodes.length === 0)
+      return false;
+    // List items are structural children whose dedicated strategies manage
+    // both block and inline children independently — never override them.
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const parentTag = element.parentElement.nodeName;
+    if (parentTag === 'UL' || parentTag === 'OL')
+      return false;
+    return childNodes.every((child) => child.nodeType === Node.ELEMENT_NODE &&
+      child.textContent === '' &&
+      !ALWAYS_INLINE_TAGS.has(child.nodeName) &&
+      !PHRASING_CONTENT_TAGS.has(child.nodeName));
+  }
+  /**
+   * Returns true for elements that should be treated as html containers.
+   * A DIV is only a valid container when its first child is not an IMG
+   * (IMG children are handled by the image strategy instead).
+   *
+   * @param {HTMLElement} element - Element to check.
+   * @returns {boolean} True if the element qualifies as a html container.
+   */
+  isCustomHtmlContainer(element) {
+    if (element.nodeName !== 'DIV') {
+      return true;
+    }
+    return element.childNodes.length > 0 && element.childNodes[0].nodeName !== 'IMG';
+  }
   /**
    * Generate HTML block DTO from an HTML element.
    *
@@ -60,40 +149,3 @@ export class HtmlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
     };
   }
 }
-HtmlBlockStrategy.canHandleTags = [
-  'ADDRESS',
-  'ARTICLE',
-  'ASIDE',
-  'BLOCKQUOTE',
-  'BUTTON',
-  'CAPTION',
-  'COL',
-  'COLGROUP',
-  'DIV',
-  'DD',
-  'DETAILS',
-  'DL',
-  'DT',
-  'FIELDSET',
-  'FIGCAPTION',
-  'FIGURE',
-  'FOOTER',
-  'FORM',
-  'HEADER',
-  'HR',
-  'HX',
-  'INPUT',
-  'LEGEND',
-  'MAIN',
-  'NAV',
-  'PRE',
-  'SECTION',
-  'SUMMARY',
-  'TABLE',
-  'TBODY',
-  'TD',
-  'TFOOT',
-  'TH',
-  'THEAD',
-  'TR',
-];

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/inline-element-to-text-node-strategy.js

@@ -2,7 +2,6 @@ import { isHTMLElement } from '../../../../../../utils/ui';
 import { ElementToTextNodeStrategy } from './element-to-text-node-strategy';
 import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
 import { RTETextNode } from '../../../../dto/nodes/text-node';
-import { isNonNullable } from '../../../../../../types/type-guard';
 import { cleanObject } from '../../../../../../utils/object';
 /**
  * Class to handle inline html element to text node dto
@@ -38,7 +37,7 @@ export class InlineElementToTextNodeStrategy extends ElementToTextNodeStrategy {
       // For empty dom, there will be no internal iteration, we need to handle it directly here.
       // Example: <span></span>, <video src='...'></video>
       const emptyNodeAnnotations = disableAutoMatchFormat
-        ? cleanObject(Object.assign(Object.assign({}, (RTETextNode.supportsHtmlTag(child.nodeName.toLowerCase()) ? curAnnotations : {})), { inlineHtml: curAnnotations.inlineHtml, plainText: isNonNullable(curAnnotations.inlineHtml) }))
+        ? cleanObject(Object.assign(Object.assign({}, (RTETextNode.supportsHtmlTag(child.nodeName.toLowerCase()) ? curAnnotations : {})), { inlineHtml: curAnnotations.inlineHtml }))
         : curAnnotations;
       return Object.assign({}, this.generateTextNode('', emptyNodeAnnotations));
     }