@heartlandone/vega 2.101.0 → 2.103.0

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/user-input-controller.js

@@ -15,7 +15,6 @@ import { InsertPasteHandler } from './helper/input-event-handler/insert-paste-ha
 import { KeyboardLinkHandler } from './helper/input-event-handler/keyboard-link-handler';
 import { generateUUID } from '../../../../utils/misc';
 import { RTECodeBlock } from '../../dto/blocks/code-block';
-import { RTE_UPDATE_SOURCE_KEY, RTEUpdateSource } from '../../constants/constant';
 /** Used to monitoring the user input actions by event listener */
 export class UserInputController extends VegaSlimmer {
   constructor() {
@@ -37,6 +36,8 @@ export class UserInputController extends VegaSlimmer {
     };
     /**
      * When a user performs an input action within the editable element, this function is triggered.
+     * Each handler owns its own `flushOptions` on `BaseHandler`, so the value update flows through
+     * the shared flush-changes action pipeline without this method having to construct or forward it.
      *
      * @param {InputEvent} e the before input event object
      */
@@ -50,41 +51,26 @@ export class UserInputController extends VegaSlimmer {
         return;
       }
       this.insertCompositionTextController.removeObserver();
-      let updateFlag = false;
-      let updateSource = RTEUpdateSource.Default;
       switch (inputType) {
         case 'insertParagraph':
-          updateFlag = true;
           this.insertParagraphHandler.execute(this.value, this.selectionController, this.host, e);
           break;
         case 'insertText':
-          updateFlag = true;
-          updateSource =
-            e[RTE_UPDATE_SOURCE_KEY] === RTEUpdateSource.Composition
-              ? RTEUpdateSource.Composition
-              : RTEUpdateSource.Default;
           this.insertTextHandler.execute(this.value, this.selectionController, this.host, e);
           break;
         case 'insertLineBreak':
-          updateFlag = true;
           this.insertLineBreakHandler.execute(this.value, this.selectionController, this.host, e);
           break;
         case 'deleteContentForward':
-          updateFlag = true;
           this.forwardDeleteContentHandler.execute(this.value, this.selectionController, this.host, e);
           break;
         case 'deleteContentBackward':
-          updateFlag = true;
           this.backwardDeleteContentHandler.execute(this.value, this.selectionController, this.host, e);
           break;
         case 'insertFromPaste':
-          updateFlag = true;
           this.insertPasteHandler.execute(this.value, this.selectionController, this.host, e);
           break;
       }
-      if (updateFlag) {
-        void this.valueController.flushChanges(this.value, true, updateSource);
-      }
     };
   }
   /**

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/value-controller.js

@@ -36,7 +36,17 @@ export class ValueController extends VegaSlimmer {
     const flushChangesWithDebounce = debounce(() => {
       void this.valueController.flushChanges(this.value);
     }, ValueController.VALUE_CHANGE_DEBOUNCE_TIME, this);
-    this.flushChangeObserver = new Observer(this.isAcceptableFlushChange.bind(this), flushChangesWithDebounce);
+    this.flushChangeObserver = new Observer(this.isAcceptableFlushChange.bind(this), (payload) => {
+      // When a handler asks to bypass the debounce (direct user gestures like `beforeinput`),
+      // invoke `flushChanges` immediately with the payload as-is. Defaults live on the emitter
+      // side (`BaseHandler.flushOptions`) — the observer trusts the payload and does not
+      // re-apply fallback values, so there is a single source of truth.
+      if (payload && payload.bypassDebounce) {
+        void this.valueController.flushChanges(this.value, payload.recordHistory, payload.updateSource);
+        return;
+      }
+      flushChangesWithDebounce();
+    });
     ChangeManager.register(domNodeSubjectFactory.getSubject(this.host, VegaInternalRichTextEditorFlushChanges), this.flushChangeObserver);
   }
   /**

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

@@ -40,7 +40,7 @@ export class BoldToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
       selectedNodes.some((node) => {
         var _a;
         return ((_a = node.getAnnotationByType(NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
-          this.shouldDisabledToolbar(node, BoldAnnotationAction.name);
+          this.shouldDisabledToolbar(node, BoldAnnotationAction.typeName);
       }));
   }
 }

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

@@ -33,7 +33,7 @@ export class ClearStyleToolbarButtonSlimmer extends VisualModeToolbarButtonSlimm
   isDisabled() {
     const selectedNodes = this.selectionController.getSelectedNodes();
     return (super.isDisabled() ||
-      selectedNodes.some((node) => this.shouldDisabledToolbar(node, ClearFormattingAnnotationAction.name)));
+      selectedNodes.some((node) => this.shouldDisabledToolbar(node, ClearFormattingAnnotationAction.typeName)));
   }
 }
 (() => {

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

@@ -37,7 +37,7 @@ export class CodeToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
     const selectedNodes = this.selectionController.getSelectedNodes();
     return (super.isDisabled() ||
       selectedNodes.some((node) => node.getAnnotationByType(NodeAnnotationTypeEnum.LINK) ||
-        this.shouldDisabledToolbar(node, CodeAnnotationAction.name)));
+        this.shouldDisabledToolbar(node, CodeAnnotationAction.typeName)));
   }
 }
 (() => {

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

@@ -62,7 +62,7 @@ export class HorizontalAlignmentToolbarButtonSlimmer extends VisualModeToolbarBu
     return (super.isDisabled() ||
       this.selectionController
         .getSelectedBlocks()
-        .some((block) => this.shouldDisabledToolbar(block, HorizontalAlignmentAnnotationAction.name)));
+        .some((block) => this.shouldDisabledToolbar(block, HorizontalAlignmentAnnotationAction.typeName)));
   }
 }
 __decorate([

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

@@ -38,7 +38,7 @@ export class ItalicToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
       selectedNodes.some((node) => {
         var _a;
         return ((_a = node.getAnnotationByType(NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
-          this.shouldDisabledToolbar(node, ItalicAnnotationAction.name);
+          this.shouldDisabledToolbar(node, ItalicAnnotationAction.typeName);
       }));
   }
 }

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

@@ -25,7 +25,7 @@ export class LessIndentToolbarButtonSlimmer extends VisualModeToolbarButtonSlimm
   isDisabled() {
     const selectedBlocks = this.selectionController.getSelectedBlocks();
     return (super.isDisabled() ||
-      selectedBlocks.some((node) => this.shouldDisabledToolbar(node, IndentAnnotationAction.name)));
+      selectedBlocks.some((node) => this.shouldDisabledToolbar(node, IndentAnnotationAction.typeName)));
   }
   onClick() {
     this.selectionController.getSelectedBlocks().forEach((item) => {

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

@@ -175,7 +175,7 @@ export class LinkToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
       selectedBlocks.length > 1 ||
       selectedNodes.some((node) => {
         var _a;
-        return this.shouldDisabledToolbar(node, LinkAnnotationAction.name) ||
+        return this.shouldDisabledToolbar(node, LinkAnnotationAction.typeName) ||
           node.getAnnotationByType(NodeAnnotationTypeEnum.LINK) ||
           ((_a = node.getAnnotationByType(NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code);
       }));

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

@@ -25,7 +25,7 @@ export class MoreIndentToolbarButtonSlimmer extends VisualModeToolbarButtonSlimm
   isDisabled() {
     const selectedBlocks = this.selectionController.getSelectedBlocks();
     return (super.isDisabled() ||
-      selectedBlocks.some((node) => this.shouldDisabledToolbar(node, IndentAnnotationAction.name)));
+      selectedBlocks.some((node) => this.shouldDisabledToolbar(node, IndentAnnotationAction.typeName)));
   }
   onClick() {
     this.selectionController.getSelectedBlocks().forEach((item) => {

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

@@ -32,6 +32,9 @@ export class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer {
     // the source-edit button can be re-activated from the keyboard without
     // the selection being reset out from under the user.
     this.sourceView = !isSelected;
+    if (!this.sourceView) {
+      void this.focusController.focusOnCurrentTextNode();
+    }
   }
   // VD-8789 (keyboard a11y): the default `preventLostFocus` calls
   // `e.preventDefault()` on mousedown so the button never receives focus and

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

@@ -41,7 +41,7 @@ export class StrikethroughToolbarButtonSlimmer extends VisualModeToolbarButtonSl
       selectedNodes.some((node) => {
         var _a;
         return ((_a = node.getAnnotationByType(NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
-          this.shouldDisabledToolbar(node, StrikethroughAnnotationAction.name);
+          this.shouldDisabledToolbar(node, StrikethroughAnnotationAction.typeName);
       }));
   }
 }

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

@@ -110,7 +110,7 @@ export class TextColorToolbarButtonSlimmer extends VisualModeToolbarButtonSlimme
         var _a;
         return ((_a = node.getAnnotationByType(NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
           node.getAnnotationByType(NodeAnnotationTypeEnum.LINK) ||
-          this.shouldDisabledToolbar(node, TextColorAnnotationAction.name);
+          this.shouldDisabledToolbar(node, TextColorAnnotationAction.typeName);
       }));
   }
 }

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

@@ -69,7 +69,7 @@ export class TextStylesToolbarButtonSlimmer extends VisualModeToolbarButtonSlimm
   isDisabled() {
     const selectedBlocks = this.selectionController.getSelectedBlocks();
     return (super.isDisabled() ||
-      selectedBlocks.some((node) => this.shouldDisabledToolbar(node, TextStyleAnnotationAction.name)));
+      selectedBlocks.some((node) => this.shouldDisabledToolbar(node, TextStyleAnnotationAction.typeName)));
   }
   addDropdownObserver(dropdownRef) {
     DomNodeSubjectObserverFactory.addUniqueObserverToNode(dropdownRef, VegaDropdownClick, this.handleDropdownItemClick);

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

@@ -41,7 +41,7 @@ export class UnderlineToolbarButtonSlimmer extends VisualModeToolbarButtonSlimme
       selectedNodes.some((node) => {
         var _a;
         return ((_a = node.getAnnotationByType(NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
-          this.shouldDisabledToolbar(node, UnderlineAnnotationAction.name);
+          this.shouldDisabledToolbar(node, UnderlineAnnotationAction.typeName);
       }));
   }
 }

package/dist/collection/components/vega-rich-text-editor/utils/html-to-plain-text-utils.js

@@ -0,0 +1,240 @@
+import { normalizePlainTextLines, PRESERVED_SPACE, PRESERVED_TAB } from '../helpers/utils';
+/**
+ * Block-level HTML tags that introduce a visible line break when converting
+ * HTML to plain text. Hard-coded because this is HTML spec knowledge that
+ * cannot be derived at runtime and must be kept in sync with the spec.
+ *
+ * Trade-off: this is a blocklist, so unknown/custom elements default to inline.
+ * That is acceptable for this plain-text fallback (clipboard HTML rarely
+ * contains custom block elements); an inline allowlist would be more robust
+ * but is unnecessary here.
+ *
+ * @see https://developer.mozilla.org/docs/Glossary/Block-level_content
+ */
+const BLOCK_LEVEL_TAGS = new Set([
+  'address',
+  'article',
+  'aside',
+  'blockquote',
+  'dd',
+  'details',
+  'dialog',
+  'div',
+  'dl',
+  'dt',
+  'figure',
+  'footer',
+  'form',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'header',
+  'hr',
+  'li',
+  'main',
+  'nav',
+  'ol',
+  'p',
+  'pre',
+  'section',
+  'table',
+  'tbody',
+  'tfoot',
+  'thead',
+  'tr',
+  'ul',
+]);
+/**
+ * Inline `display` values that turn a nominally inline tag into a visual block-level box
+ * (e.g. Jira/Confluence code lines: `<span style="display: flex; white-space: pre-wrap;">`).
+ */
+const BLOCK_LIKE_DISPLAY_VALUES = new Set([
+  'block',
+  'flex',
+  'grid',
+  'table',
+  'list-item',
+  'flow-root',
+]);
+/**
+ * @param {Element} el Candidate element.
+ * @returns {boolean} Whether the element's inline `style="display: ..."` puts it in the block flow.
+ */
+function hasBlockLikeInlineDisplay(el) {
+  const inlineStyle = el.style;
+  if (!inlineStyle) {
+    return false;
+  }
+  return BLOCK_LIKE_DISPLAY_VALUES.has(inlineStyle.display);
+}
+// `pre-line` intentionally excluded: it keeps `\n` but collapses spaces/tabs.
+const WHITESPACE_PRESERVING_VALUES = new Set(['pre', 'pre-wrap', 'break-spaces']);
+/**
+ * @param {Element} el Candidate element.
+ * @returns {boolean} Whether the element's inline `style="white-space: ..."` preserves source whitespace.
+ */
+function preservesWhitespaceInlineStyle(el) {
+  const inlineStyle = el.style;
+  if (!inlineStyle) {
+    return false;
+  }
+  return WHITESPACE_PRESERVING_VALUES.has(inlineStyle.whiteSpace);
+}
+/**
+ * Resolves the preformatted text of a code-block element, or `null` when the element is not a
+ * code block. A Vega code block serializes to `<vega-code-block data-content data-language>` whose
+ * `data-content` attribute is the authoritative source (its shadow-DOM `<code>` may be empty in some
+ * browsers); external editors emit `<pre>`/`<code data-language>` whose `textContent` carries the
+ * code. Both keep their newlines/indentation so plain paste renders one paragraph per line.
+ *
+ * @param {Element} el Candidate element.
+ * @returns {string | null} Code text with line breaks preserved, or `null` when not a code block.
+ */
+function resolveCodeBlockText(el) {
+  var _a, _b, _c;
+  const tagName = el.tagName.toLowerCase();
+  if (tagName === 'vega-code-block') {
+    return (_b = (_a = el.getAttribute('data-content')) !== null && _a !== void 0 ? _a : el.textContent) !== null && _b !== void 0 ? _b : '';
+  }
+  if ((tagName === 'pre' || tagName === 'code') && el.hasAttribute('data-language')) {
+    return (_c = el.textContent) !== null && _c !== void 0 ? _c : '';
+  }
+  return null;
+}
+/**
+ * Recursively builds text content, inserting `\n` at block-level element and `<br>` boundaries.
+ *
+ * @param {Node} node DOM node to extract text from.
+ * @param {boolean} preserveWhitespace Whether whitespace should be retained for preformatted content.
+ * @param {boolean} preserveNewlines Keep literal `\n` in text nodes as line breaks (used inside table
+ * cells, where a Vega line break is a text node rendered as `<span>\n</span>` rather than a `<br>`).
+ * @returns {string} Extracted text with line breaks preserved.
+ */
+function extractBlockAwareText(node, preserveWhitespace, preserveNewlines = false) {
+  let text = '';
+  node.childNodes.forEach((child) => {
+    var _a, _b, _c;
+    if (child.nodeType === Node.TEXT_NODE) {
+      const textContent = (_a = child.textContent) !== null && _a !== void 0 ? _a : '';
+      if (preserveWhitespace) {
+        text += textContent.replace(/ /g, PRESERVED_SPACE).replace(/\t/g, PRESERVED_TAB);
+        return;
+      }
+      const parentElement = child.parentElement;
+      const hasBlockChild = Array.from((_b = parentElement === null || parentElement === void 0 ? void 0 : parentElement.children) !== null && _b !== void 0 ? _b : []).some((element) => BLOCK_LEVEL_TAGS.has(element.tagName.toLowerCase()));
+      if (!/\S/.test(textContent) && hasBlockChild) {
+        return;
+      }
+      // Collapse only whitespace runs that cross a markup newline (source-format indentation
+      // between tags); real space/tab runs inside a text node are user content and stay verbatim.
+      // Inside a cell (preserveNewlines) the collapse keeps the newline as-is.
+      text += textContent.replace(preserveNewlines ? /[^\S\u00A0\n]*\n[^\S\u00A0\n]*/g : /[^\S\u00A0]*\n[^\S\u00A0]*/g, preserveNewlines ? '\n' : ' ');
+      return;
+    }
+    if (child.nodeType !== Node.ELEMENT_NODE) {
+      return;
+    }
+    const el = child;
+    const tagName = el.tagName.toLowerCase();
+    if (tagName === 'br') {
+      text += '\n';
+      return;
+    }
+    if (tagName === 'img') {
+      text += (_c = el.getAttribute('alt')) !== null && _c !== void 0 ? _c : '';
+      return;
+    }
+    // Code blocks keep their newlines/indentation verbatim so each line becomes its own
+    // paragraph on plain paste, instead of collapsing to a single line.
+    const codeBlockText = resolveCodeBlockText(el);
+    if (codeBlockText !== null) {
+      const preservedCode = codeBlockText
+        .replace(/ /g, PRESERVED_SPACE)
+        .replace(/\t/g, PRESERVED_TAB);
+      if (text !== '' && !text.endsWith('\n')) {
+        text += '\n';
+      }
+      text += preservedCode;
+      if (preservedCode === '' || !text.endsWith('\n')) {
+        text += '\n';
+      }
+      return;
+    }
+    if (BLOCK_LEVEL_TAGS.has(tagName) || hasBlockLikeInlineDisplay(el)) {
+      const blockText = extractBlockAwareText(el, preserveWhitespace || tagName === 'pre', preserveNewlines);
+      // Empty list items and empty structural `div`s (ProseMirror table scaffolding: sticky
+      // sentinels, row-control wrappers, borders) are artifacts, not intentional blank lines, so
+      // skip them. Keep meaningful empty blocks: break-only div and div containing an image but
+      // no extractable text. Empty `<p>`/headings still keep their blank line via the logic below.
+      if ((tagName === 'li' && blockText.trim() === '') ||
+        (tagName === 'div' && blockText === '' && el.querySelector('img') === null)) {
+        return;
+      }
+      if (text !== '' && !text.endsWith('\n')) {
+        text += '\n';
+      }
+      text += blockText;
+      if (blockText === '' || !text.endsWith('\n')) {
+        text += '\n';
+      }
+      return;
+    }
+    // Put each cell on its own line while keeping the cell's own blank lines (empty
+    // paragraphs and Vega text-node line breaks); tabs inside a cell collapse to a space so
+    // they don't look like columns.
+    if (tagName === 'td' || tagName === 'th') {
+      const cellText = extractBlockAwareText(el, preserveWhitespace, true)
+        .replace(/\t+/g, ' ')
+        .replace(/^\n+|\n+$/g, '');
+      text += `${cellText}\n`;
+      return;
+    }
+    text += extractBlockAwareText(el, preserveWhitespace || tagName === 'pre', preserveNewlines || preservesWhitespaceInlineStyle(el));
+  });
+  return text;
+}
+/**
+ * Converts HTML to plain text, preserving line breaks introduced by block-level elements and `<br>`.
+ * Used as a fallback when clipboard data lacks a `text/plain` payload, so structural breaks
+ * (e.g. `<h1>Heading</h1><p>Body</p>`) survive as `Heading\nBody` instead of being flattened.
+ *
+ * @param {string} html HTML content to convert.
+ * @param {HtmlToPlainTextOptions} options Plain-text conversion options.
+ * @returns {string} Block-aware plain text with normalized `\n` line endings.
+ */
+export function htmlToPlainText(html, options = {}) {
+  if (!html) {
+    return '';
+  }
+  const parsed = new DOMParser().parseFromString(html, 'text/html');
+  if (!parsed.body) {
+    return '';
+  }
+  // Per-paragraph trim: sentinels (`\u0001`/`\u0002`) are not in `\s`, so code-block indentation
+  // emitted by the preservation branch survives; NBSP is in `\s`, so noise from non-code sources is dropped.
+  const normalizedText = normalizePlainTextLines(extractBlockAwareText(parsed.body, false))
+    .map((line) => line.trim())
+    .join('\n');
+  const textWithoutStructuralBreak = options.preserveBoundaryBlankLines
+    ? normalizedText.replace(/\n$/, '')
+    : normalizedText.replace(/^\n+|\n+$/g, '');
+  if (options.keepPreservedWhitespaceMarkers) {
+    return textWithoutStructuralBreak;
+  }
+  return textWithoutStructuralBreak.split(PRESERVED_SPACE).join(' ').split(PRESERVED_TAB).join('\t');
+}
+/**
+ * Detects whether the clipboard HTML contains a table anywhere. Plain paste uses this together
+ * with a tab check on `text/plain`: a tab-separated `text/plain` only reflects a table's row/
+ * column layout when the clipboard actually has a table, so that combination is pasted from
+ * `text/plain` verbatim (its line breaks are trusted as-is), regardless of any surrounding content.
+ *
+ * @param {string} html HTML content to inspect.
+ * @returns {boolean} Whether the HTML contains a table.
+ */
+export function htmlContainsTable(html) {
+  return /<table[\s/>]/i.test(html);
+}

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

@@ -22,7 +22,7 @@ import { AriaAttributesValueMapper } from '../../../helpers/slimmers/mutation-ob
  */
 export class VegaRichTextEditorToolbarButton {
   constructor() {
-    this.globalSlimmers = {};
+    this.globalSlimmers = new Map();
     this.vegaComponentUsageRuntimeMetricsSlimmer = new VegaComponentUsageRuntimeMetricsSlimmer();
     this.clickEventEmitter = createEventEmitSlimmer(VegaRichTextEditorToolbarButton, VegaClick);
     this.eventPrevent = new ChildNodesEventPreventSlimmer([VegaClick], () => this.host, {

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

@@ -60,7 +60,7 @@ import { AriaAttributesValueMapper } from '../../helpers/slimmers/mutation-obser
  */
 export class VegaRichTextEditor {
   constructor() {
-    this.globalSlimmers = {};
+    this.globalSlimmers = new Map();
     this.ariaAttributesValueMapper = new AriaAttributesValueMapper(() => this.vegaRichTextEditorRenderer.getRTEEditableElementRef(), {
       'aria-label': {
         dependency: ['data-aria-label', 'label'],

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-image-editor/vega-rich-text-image-editor.js

@@ -20,7 +20,7 @@ import { TranslationSlimmer } from '../../../helpers/slimmers/translation';
  */
 export class VegaRichTextImageEditor {
   constructor() {
-    this.globalSlimmers = {};
+    this.globalSlimmers = new Map();
     this.translationSlimmer = new TranslationSlimmer();
     this.vegaComponentUsageRuntimeMetricsSlimmer = new VegaComponentUsageRuntimeMetricsSlimmer();
     this.renderer = new VegaRichTextImageEditorRenderer();

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/controllers/link-editor-controller.js

@@ -23,6 +23,9 @@ export class LinkEditorController extends VegaSlimmer {
     super(...arguments);
     this.linkUrlNormalizer = new LinkUrlNormalizer();
     this.linkTypeHandlers = LINK_TYPE_HANDLER_MAP;
+    // Single-use markers to ignore the change event echoed back by our own URL/bookmark sync write.
+    this.pendingBookmarkSyncEcho = null;
+    this.pendingUrlSyncEcho = null;
     /**
      * The element the trigger click listener is currently attached to (the link
      * wrapper acting as the popover target).
@@ -86,6 +89,9 @@ export class LinkEditorController extends VegaSlimmer {
    */
   async handlePopoverShow() {
     var _a, _b, _c, _d;
+    // Discard echoes left by the previous popover session.
+    this.pendingBookmarkSyncEcho = null;
+    this.pendingUrlSyncEcho = null;
     this.linkTypeConfigController.invalidateConfiguredLinkTypesCache();
     this.linkEditorStateManager.clearFormValues();
     if (this.linkEditorStateManager.getShouldResetStatusOnNextShow()) {
@@ -156,10 +162,65 @@ export class LinkEditorController extends VegaSlimmer {
    * @returns {void} No return value.
    */
   handleUrlVegaChange(e) {
+    const requiredValue = e.detail;
+    // A matching value was written by a bookmark selection, not typed by the user.
+    const isEcho = this.pendingUrlSyncEcho === requiredValue;
+    this.pendingUrlSyncEcho = null;
+    if (!isEcho &&
+      this.linkEditorStateManager.getSelectedLinkTypeKey() === RTE_DEFAULT_LINK_TYPE_KEY &&
+      this.linkTypeConfigController.isBookmarkEnabled()) {
+      const form = this.renderer.getFormRef();
+      if (form === null || form === void 0 ? void 0 : form.setValue) {
+        const bookmarkName = this.linkTypeConfigController.getBookmarkNameForUrl(requiredValue);
+        // Ignore the change emitted when the select applies this value.
+        this.pendingBookmarkSyncEcho = bookmarkName;
+        void form.setValue({ bookmark: bookmarkName });
+      }
+    }
     if (this.linkTypeConfigController.hasConfiguredLinkTypes()) {
-      this.updateSubmitDisabledState(e.detail);
+      this.updateSubmitDisabledState(requiredValue);
+    }
+  }
+  /**
+   * Updates the URL field from a selected bookmark target.
+   *
+   * @param {CustomEvent<string | string[]>} e - Bookmark selection change event.
+   * @returns {Promise<void>} Resolves after updating the URL field.
+   */
+  async handleBookmarkVegaChange(e) {
+    var _a, _b, _c;
+    const bookmarkName = Array.isArray(e.detail) ? e.detail[0] || '' : e.detail;
+    // Consume the change emitted by URL-to-bookmark synchronization.
+    if (this.pendingBookmarkSyncEcho === bookmarkName) {
+      this.pendingBookmarkSyncEcho = null;
+      return;
+    }
+    this.pendingBookmarkSyncEcho = null;
+    const url = bookmarkName ? `#${bookmarkName}` : '';
+    this.pendingUrlSyncEcho = url;
+    await ((_b = (_a = this.renderer.getFormRef()) === null || _a === void 0 ? void 0 : _a.setValue) === null || _b === void 0 ? void 0 : _b.call(_a, { url }));
+    this.updateSubmitDisabledState(url);
+    if (bookmarkName) {
+      await ((_c = this.renderer.getUrlInputRef()) === null || _c === void 0 ? void 0 : _c.doFocus());
     }
   }
+  /** Navigates to the current link's bookmark within the same rich text content root. */
+  async handleBookmarkNavigation() {
+    var _a, _b, _c;
+    const bookmarkName = this.linkTypeConfigController.getBookmarkNameForUrl((_a = this.record) === null || _a === void 0 ? void 0 : _a.url);
+    const rootNode = (_b = this.target) === null || _b === void 0 ? void 0 : _b.getRootNode();
+    if (!bookmarkName || !rootNode || !('querySelectorAll' in rootNode)) {
+      return;
+    }
+    const bookmarkTarget = Array.from(rootNode.querySelectorAll('a.rte-bookmark[id]')).find((anchor) => anchor.id === bookmarkName);
+    if (!bookmarkTarget) {
+      return;
+    }
+    await ((_c = this.renderer.getPopoverRef()) === null || _c === void 0 ? void 0 : _c.hide());
+    bookmarkTarget.scrollIntoView({ block: 'center', inline: 'nearest' });
+    bookmarkTarget.focus({ preventScroll: true });
+    bookmarkTarget.click();
+  }
   /**
    * Submits the current link when Enter is pressed or hides the popover when Escape is pressed.
    *
@@ -260,7 +321,7 @@ export class LinkEditorController extends VegaSlimmer {
    * @returns {Promise<void>} Resolves when the edit form is populated.
    */
   async populateEditForm() {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     const handler = this.linkTypeHandlers.get(this.linkEditorStateManager.getSelectedLinkTypeKey());
     if (!handler) {
       return;
@@ -273,12 +334,15 @@ export class LinkEditorController extends VegaSlimmer {
       ? handler.getRequiredValue(this.record, deps)
       : '';
     const initialFormValues = handler.getInitialFormValues(this.record, deps);
+    const bookmarkName = this.linkTypeConfigController.getBookmarkNameForUrl((_a = this.record) === null || _a === void 0 ? void 0 : _a.url);
+    if (bookmarkName) {
+      initialFormValues.bookmark = bookmarkName;
+    }
     this.linkEditorStateManager.setSharedTextValue(initialFormValues.text || '');
-    await ((_b = (_a = this.renderer.getFormRef()) === null || _a === void 0 ? void 0 : _a.setValue) === null || _b === void 0 ? void 0 : _b.call(_a, initialFormValues));
+    await ((_c = (_b = this.renderer.getFormRef()) === null || _b === void 0 ? void 0 : _b.reset) === null || _c === void 0 ? void 0 : _c.call(_b, initialFormValues));
     this.syncTextInputValue(initialFormValues.text || '');
     this.updateSubmitDisabledState(requiredValue);
-    await ((_d = (_c = this.renderer.getFormRef()) === null || _c === void 0 ? void 0 : _c.setValue) === null || _d === void 0 ? void 0 : _d.call(_c, handler.getInitialFormValues(this.record, deps)));
-    await ((_e = this.renderer.getUrlInputRef()) === null || _e === void 0 ? void 0 : _e.doFocus());
+    await ((_d = this.renderer.getUrlInputRef()) === null || _d === void 0 ? void 0 : _d.doFocus());
   }
   /**
    * Updates the popover target via the remote invocation registry.