@heartlandone/vega 2.80.0 → 2.81.0

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/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/text-style-annotation-handler.js

@@ -112,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|heading-4|heading-5|heading-6|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/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));
     }

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

@@ -0,0 +1,29 @@
+import { TextStyleAnnotationHandler } from './annotation-handler/text-style-annotation-handler';
+/**
+ * Predicate class provides static methods to check specific conditions on HTML elements.
+ */
+export class Predicate {
+  /**
+   * Checks if the given element is a title or subtitle.
+   *
+   * @param {HTMLElement} element The element to check.
+   * @returns {boolean} True if the element is a title or subtitle, false otherwise.
+   */
+  static isTitleOrSubtitle(element) {
+    if (element.nodeName === 'DIV') {
+      const textBlockType = Predicate.textStyleHandler['getTextStyle'](element);
+      return textBlockType === 'title' || textBlockType === 'subtitle';
+    }
+    return false;
+  }
+  /**
+   * Check if the given element is a link element (anchor tag).
+   *
+   * @param {HTMLElement} element The element to check.
+   * @returns {boolean} True if the element is a link element, false otherwise.
+   */
+  static isLinkElement(element) {
+    return element.nodeName === 'A';
+  }
+}
+Predicate.textStyleHandler = new TextStyleAnnotationHandler();

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

@@ -0,0 +1,142 @@
+/**
+ * Tags whose direct children are always phrasing (inline) content (P, H1-H6, LI).
+ *
+ * This is spec knowledge from the HTML Living Standard — these grouping-content
+ * elements have a phrasing-content content model and cannot contain block-level
+ * descendants. It cannot be derived from the strategy registry and must be
+ * maintained alongside the HTML spec.
+ *
+ * @see https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+ */
+export const BLOCK_TEXT_CONTAINER_TAGS = new Set([
+  'P',
+  'H1',
+  'H2',
+  'H3',
+  'H4',
+  'H5',
+  'H6',
+  'LI',
+]);
+/**
+ * Tags with dedicated element-to-DTO block strategies
+ * (P, H1-H6, LI, UL, OL, IMG, CODE).
+ *
+ * HtmlBlockStrategy skips these to avoid double-processing or overriding their
+ * specialized block semantics.
+ *
+ * Why hard-coded: strategies use heterogeneous matching (`tagName ===`,
+ * `matchTextBlockType` via font-size/class, etc.) so there is no single
+ * declarative contract to derive this set from. It must be kept in sync with
+ * the strategies registered in `dto/setup.ts`.
+ *
+ * Intentionally independent of {@link BLOCK_TEXT_CONTAINER_TAGS} — the two
+ * sets encode different concepts (app architecture vs. HTML spec) and must
+ * be maintained separately.
+ */
+export const DEDICATED_STRATEGY_TAGS = new Set([
+  'P',
+  'H1',
+  'H2',
+  'H3',
+  'H4',
+  'H5',
+  'H6',
+  'LI',
+  'UL',
+  'OL',
+  'IMG',
+  'CODE',
+]);
+/**
+ * Tags that are always treated as phrasing (inline) content, even when they
+ * also appear in {@link DEDICATED_STRATEGY_TAGS} (CODE).
+ * A tag in this set overrides the dedicated-strategy skip in HtmlBlockStrategy.
+ *
+ * Mix of HTML5 spec phrasing-content elements (BR, CODE, A) and
+ * RTE-internal custom elements (VEGA-RICH-TEXT-LINK-EDITOR).
+ */
+export const ALWAYS_INLINE_TAGS = new Set(['BR', 'VEGA-RICH-TEXT-LINK-EDITOR', 'CODE', 'A']);
+/**
+ * Tags whose content model requires each child to be a distinct block-level
+ * element (table model and definition list).
+ *
+ * TABLE expects CAPTION/THEAD/TBODY/TFOOT/TR; TR expects TH/TD;
+ * THEAD/TBODY/TFOOT expect TR; DL expects DT/DD.
+ *
+ * Used by HtmlBlockStrategy to prevent text-only children (e.g. CAPTION,
+ * TH, TD) from being treated as inline — they must become html-blocks so
+ * the table structure round-trips correctly.
+ *
+ * Note: COLGROUP is intentionally excluded. Its only permitted child is the
+ * void element COL, which can never produce text-node children, so the
+ * text-only heuristic in HtmlBlockStrategy can never fire for a COLGROUP
+ * parent.
+ *
+ * @see https://html.spec.whatwg.org/multipage/tables.html#the-table-element
+ * @see https://html.spec.whatwg.org/multipage/grouping-content.html#the-dl-element
+ */
+export const STRUCTURED_CONTAINER_TAGS = new Set([
+  'TABLE',
+  'THEAD',
+  'TBODY',
+  'TFOOT',
+  'TR',
+  'DL',
+]);
+/**
+ * Formatting phrasing-content elements that CAN remain inline even when empty.
+ *
+ * Any element NOT in this set (DIV, SECTION, ARTICLE, custom elements, etc.)
+ * is treated as a block separator. Phrasing content is a closed, finite set
+ * per the HTML Living Standard, making an allowlist safer than blocklisting
+ * block containers (which is open-ended — custom elements default to block).
+ *
+ * Intentionally excludes:
+ * - BR, CODE, A, VEGA-RICH-TEXT-LINK-EDITOR → handled by {@link ALWAYS_INLINE_TAGS}
+ * - P, H1-H6, LI, UL, OL, IMG → handled by {@link DEDICATED_STRATEGY_TAGS}
+ * - VIDEO, AUDIO, EMBED → embedded content that carries media even when empty;
+ *   must be treated as block-level, not as inline formatting artifacts
+ *
+ * @see https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+ */
+export const PHRASING_CONTENT_TAGS = new Set([
+  'ABBR',
+  'B',
+  'BDI',
+  'BDO',
+  'CITE',
+  'DEL',
+  'DFN',
+  'EM',
+  'I',
+  'INS',
+  'KBD',
+  'MARK',
+  'METER',
+  'OUTPUT',
+  'PROGRESS',
+  'Q',
+  'S',
+  'SAMP',
+  'SMALL',
+  'SPAN',
+  'STRONG',
+  'SUB',
+  'SUP',
+  'TIME',
+  'U',
+  'VAR',
+]);
+/**
+ * Returns true when the element is a direct child of a block text container
+ * (P, H1-H6, LI), meaning it must be treated as phrasing content regardless
+ * of its own DOM structure.
+ *
+ * @param {HTMLElement} element - Element to test.
+ * @returns {boolean} True if the element is inside a block text container.
+ */
+export function isInBlockTextContext(element) {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  return BLOCK_TEXT_CONTAINER_TAGS.has(element.parentElement.nodeName);
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/tools/source-edit-toolbar-button-slimmer.js

@@ -43,6 +43,7 @@ export class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer {
     if (typeof sourceViewValue === 'string') {
       await this.valueController.flushChanges(VegaRTEContent.fromHtml(sourceViewValue, {
         autoMatchFormat: this.sourceEditConfig.autoMatchFormat,
+        filterInlineStyles: this.sourceEditConfig.filterInlineStyles,
       }));
     }
   }