@heartlandone/vega 2.102.0 → 2.103.0

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

@@ -1,13 +1,18 @@
 import { VegaRTEExtension } from '../extension.abstract';
-import { RTEPasteChooserUI } from './paste-chooser-ui';
-import { RTE_PASTE_MODE_DATA_TYPE } from '../../constants/constant';
 import { PasteStrategySelector } from './strategies/paste-strategy-selector';
-import { RTEPasteMode, } from './strategies/paste-processing-strategy.abstract';
 import { PasteImageParser } from './parse-local-images-helper/paste-image-parser';
 import { RTEImageNode } from '../../dto/nodes/image-node';
 import { REPLACE_IMAGE_SRC } from './actions/image-replace-src-action';
 import { ImageReplaceSrcStrategy } from './action-handler-strategies/image-replace-src-strategy';
 import { PendingImageRegistry } from './parse-local-images-helper/pending-image-registry';
+import { ChooserPositioner } from './controllers/chooser-positioner';
+import { ImageExtractor } from './parse-local-images-helper/image-extractor';
+import { PasteProcessingPipeline } from './pipeline/paste-processing-pipeline';
+import { PasteDataTransferBuilder } from './pipeline/data-transfer-builder';
+import { PasteDispatcher } from './pipeline/paste-dispatcher';
+import { SelectionSnapshotService } from './controllers/selection-snapshot-service';
+import { PasteEventInterceptor } from './controllers/paste-event-interceptor';
+import { PasteChooserController } from './controllers/paste-chooser-controller';
 /**
  * Vega Rich Text Editor paste extension.
  * Intercepts keyboard paste and allows users to choose paste mode.
@@ -17,16 +22,7 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
     super();
     this.editableEl = null;
     this.contentHostEl = null;
-    this.chooserUI = null;
     this.pendingPastePayload = null;
-    this.listenerDocument = null;
-    this.listenerWindow = null;
-    this.options = {};
-    this.strategySelector = new PasteStrategySelector();
-    this.clipboardFileContent = null;
-    this.imageParser = new PasteImageParser();
-    /** Owns pending pasted-image previews awaiting upload and their URL replacement. */
-    this.pendingImageRegistry = new PendingImageRegistry();
     /**
      * Handles a native paste event by capturing the clipboard payload and
      * rendering the paste-mode chooser.
@@ -34,33 +30,7 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
      * @param {ClipboardEvent} event Native clipboard paste event.
      */
     this.handlePasteEvent = (event) => {
-      var _a, _b;
-      const clipboardData = event.clipboardData;
-      if (!clipboardData) {
-        return;
-      }
-      // HTML is sanitized via DOMParser and ElementToDtoStrategyProcessor pipeline
-      const html = clipboardData.getData('text/html') || '';
-      const text = clipboardData.getData('text/plain') || '';
-      // RTF must be read synchronously here: the paste event's DataTransfer is only
-      // readable during event dispatch, so reading it later (after the chooser) returns ''.
-      const rtf = clipboardData.getData('text/rtf') || '';
-      if (!html && !text) {
-        // Empty clipboard paste should not mutate editor content.
-        event.preventDefault();
-        event.stopPropagation();
-        return;
-      }
-      event.preventDefault();
-      event.stopPropagation();
-      const range = this.cloneCurrentSelectionRange();
-      const selectedNodes = ((_b = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelectedNodes) === null || _b === void 0 ? void 0 : _b.call(_a)) || [];
-      this.pendingPastePayload = { html, text, range, selectedNodes: [...selectedNodes] };
-      this.clipboardFileContent = {
-        files: clipboardData.files ? Array.from(clipboardData.files) : [],
-        rtf,
-      };
-      this.renderPasteChooser(event);
+      this.pasteEventInterceptor.handlePasteEvent(event);
     };
     /**
      * Dismisses the chooser when a pointer interaction occurs outside of it.
@@ -68,14 +38,7 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
      * @param {Event} event Pointer event captured on the document.
      */
     this.handleOutsidePointerDown = (event) => {
-      if (!this.chooserUI) {
-        return;
-      }
-      const eventPath = typeof event.composedPath === 'function' ? event.composedPath() : [];
-      if (this.chooserUI.includesEventPath(eventPath)) {
-        return;
-      }
-      this.clearPasteChooser();
+      this.pasteChooserController.handleOutsidePointerDown(event);
     };
     /**
      * Dismisses the chooser when the Escape key is pressed.
@@ -83,17 +46,30 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
      * @param {KeyboardEvent} event Keyboard event captured on the document.
      */
     this.handleOutsideKeyDown = (event) => {
-      if (event.key === 'Escape') {
-        this.clearPasteChooser();
-      }
+      this.pasteChooserController.handleOutsideKeyDown(event);
     };
     /**
      * Dismisses the chooser when any relevant scroll container scrolls.
      */
     this.handleOutsideScroll = () => {
-      this.clearPasteChooser();
+      this.pasteChooserController.handleOutsideScroll();
     };
     this.options = options;
+    this.strategySelector = new PasteStrategySelector();
+    this.imageParser = new PasteImageParser();
+    this.pendingImageRegistry = new PendingImageRegistry();
+    this.chooserPositioner = new ChooserPositioner(() => this.hostEl, () => { var _a, _b; return (_b = (_a = this.pendingPastePayload) === null || _a === void 0 ? void 0 : _a.range) !== null && _b !== void 0 ? _b : this.cloneCurrentSelectionRange(); });
+    this.processingPipeline = new PasteProcessingPipeline(this.strategySelector, new ImageExtractor(this.imageParser), this.pendingImageRegistry);
+    this.dataTransferBuilder = new PasteDataTransferBuilder();
+    this.pasteDispatcher = new PasteDispatcher();
+    this.selectionSnapshotService = new SelectionSnapshotService(() => this.extensionContext);
+    this.pasteEventInterceptor = new PasteEventInterceptor(this.selectionSnapshotService, (payload, event) => {
+      this.pendingPastePayload = payload;
+      this.renderPasteChooser(event);
+    });
+    this.pasteChooserController = new PasteChooserController(this.chooserPositioner, (mode) => this.applyPasteMode(mode), () => {
+      this.pendingPastePayload = null;
+    });
   }
   /** @inheritDoc */
   initialExtensionAfterLoad(context) {
@@ -107,6 +83,10 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
     this.clearPasteChooser();
     this.pendingImageRegistry.discardUnsentPreviews();
   }
+  /** @returns {RTEPasteChooserUI | null} Currently open chooser UI, or `null` when closed. */
+  get chooserUI() {
+    return this.pasteChooserController.ui;
+  }
   /**
    * Attaches the paste listener to the editable element.
    */
@@ -114,17 +94,13 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
     const { editableEl, contentHostEl, } = this.getEditorElements();
     this.editableEl = editableEl;
     this.contentHostEl = contentHostEl;
-    if (this.editableEl) {
-      this.editableEl.addEventListener('paste', this.handlePasteEvent);
-    }
+    this.pasteEventInterceptor.attach(this.editableEl);
   }
   /**
    * Detaches the paste listener from the editable element.
    */
   detachPasteListener() {
-    if (this.editableEl) {
-      this.editableEl.removeEventListener('paste', this.handlePasteEvent);
-    }
+    this.pasteEventInterceptor.detach();
     this.editableEl = null;
     this.contentHostEl = null;
   }
@@ -155,12 +131,7 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
    * @returns {Range | null} Cloned range or `null` when there is no selection.
    */
   cloneCurrentSelectionRange() {
-    var _a;
-    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
-    if (selection && selection.rangeCount > 0) {
-      return selection.getRangeAt(0).cloneRange();
-    }
-    return null;
+    return this.selectionSnapshotService.capture().range;
   }
   /**
    * Renders the paste-mode chooser and wires up dismissal listeners.
@@ -168,145 +139,8 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
    * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
    */
   renderPasteChooser(pasteEvent) {
-    var _a, _b, _c;
-    const hostRoot = (_b = (_a = this.hostEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) !== null && _b !== void 0 ? _b : null;
-    if (!hostRoot) {
-      return;
-    }
-    this.clearPasteChooser(false);
-    const position = this.computeChooserPosition(pasteEvent);
-    this.chooserUI = new RTEPasteChooserUI(hostRoot, {
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      onModeSelect: (mode) => {
-        this.applyPasteMode(mode);
-      },
-    }, {
-      showWordOption: ((_c = this.options) === null || _c === void 0 ? void 0 : _c.enableWordPaste) === true,
-    });
-    this.chooserUI.open(position);
-    this.listenerDocument = this.hostEl.ownerDocument;
-    this.listenerWindow = this.listenerDocument.defaultView;
-    this.listenerDocument.addEventListener('mousedown', this.handleOutsidePointerDown, true);
-    this.listenerDocument.addEventListener('keydown', this.handleOutsideKeyDown, true);
-    this.listenerDocument.addEventListener('scroll', this.handleOutsideScroll, true);
-    if (this.listenerWindow) {
-      this.listenerWindow.addEventListener('scroll', this.handleOutsideScroll, true);
-    }
-    if (this.contentHostEl) {
-      this.contentHostEl.addEventListener('scroll', this.handleOutsideScroll);
-    }
-  }
-  /**
-   * Computes the on-screen position for the chooser based on pointer or caret.
-   *
-   * @param {ClipboardEvent} event Originating paste event.
-   * @returns {ChooserPosition} Position in viewport coordinates.
-   */
-  computeChooserPosition(event) {
-    var _a, _b, _c;
-    const hostRect = this.hostEl.getBoundingClientRect();
-    const viewportHeight = (_b = (_a = this.hostEl.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.innerHeight) !== null && _b !== void 0 ? _b : window.innerHeight;
-    const pointerEvent = event;
-    const hasPointer = typeof pointerEvent.clientX === 'number' &&
-      pointerEvent.clientX > 0 &&
-      typeof pointerEvent.clientY === 'number' &&
-      pointerEvent.clientY > 0;
-    // For keyboard-initiated paste (Command/Control+V) clientX/Y are 0, so anchor
-    // the chooser to the current caret instead of a fixed host-relative spot.
-    const caretRect = hasPointer ? null : this.getCaretRect();
-    const CHOOSER_GAP_PX = 8;
-    const CHOOSER_MIN_MARGIN_PX = 12;
-    const CHOOSER_WIDTH_PX = 220;
-    const CHOOSER_FALLBACK_OFFSET_PX = 40;
-    const CHOOSER_MIN_VISIBLE_BELOW_SPACE_PX = 88;
-    const baseLeft = hasPointer
-      ? pointerEvent.clientX
-      : (_c = caretRect === null || caretRect === void 0 ? void 0 : caretRect.left) !== null && _c !== void 0 ? _c : hostRect.left + CHOOSER_MIN_MARGIN_PX;
-    const baseTop = hasPointer
-      ? pointerEvent.clientY
-      : caretRect
-        ? caretRect.bottom
-        : hostRect.top + CHOOSER_FALLBACK_OFFSET_PX;
-    const maxLeft = Math.max(hostRect.left + CHOOSER_MIN_MARGIN_PX, hostRect.right - CHOOSER_WIDTH_PX);
-    const left = Math.min(Math.max(baseLeft, hostRect.left + CHOOSER_MIN_MARGIN_PX), maxLeft);
-    const top = Math.max(baseTop + CHOOSER_GAP_PX, hostRect.top + CHOOSER_MIN_MARGIN_PX);
-    const availableBelow = viewportHeight - top - CHOOSER_MIN_MARGIN_PX;
-    const availableAbove = top - CHOOSER_MIN_MARGIN_PX;
-    const placement = availableBelow >= CHOOSER_MIN_VISIBLE_BELOW_SPACE_PX || availableBelow >= availableAbove
-      ? ['bottom', 'top']
-      : ['top', 'bottom'];
-    return { left, top, placement };
-  }
-  /**
-   * Resolves the bounding rect of the pending caret position.
-   *
-   * @returns {DOMRect | null} Caret rect or `null` when it cannot be determined.
-   */
-  getCaretRect() {
-    var _a, _b;
-    const range = (_b = (_a = this.pendingPastePayload) === null || _a === void 0 ? void 0 : _a.range) !== null && _b !== void 0 ? _b : this.cloneCurrentSelectionRange();
-    if (!range) {
-      return null;
-    }
-    const rect = range.getBoundingClientRect();
-    if (this.isUnavailableRect(rect)) {
-      // eslint-disable-next-line spellcheck/spell-checker
-      const domRectList = range.getClientRects();
-      if (domRectList.length > 0) {
-        return domRectList[0];
-      }
-      return this.getRangeContainerRect(range);
-    }
-    return rect;
-  }
-  /**
-   * Returns whether the browser could not resolve a meaningful caret rectangle.
-   *
-   * @param {DOMRect} rect Candidate caret rect.
-   * @returns {boolean} Whether the rect is unusable.
-   */
-  isUnavailableRect(rect) {
-    return rect.width === 0 && rect.height === 0 && rect.left === 0 && rect.top === 0;
-  }
-  /**
-   * Falls back to the range container or neighbor child node bounds.
-   *
-   * @param {Range} range Caret/selection range.
-   * @returns {DOMRect | null} Best-effort caret anchor rectangle.
-   */
-  getRangeContainerRect(range) {
-    var _a, _b, _c, _d, _e, _f;
-    const containerNode = (_a = range.startContainer) !== null && _a !== void 0 ? _a : null;
-    if (!containerNode) {
-      return null;
-    }
-    if (containerNode.nodeType === Node.ELEMENT_NODE) {
-      const containerElement = containerNode;
-      const previousNode = (_b = containerElement.childNodes[range.startOffset - 1]) !== null && _b !== void 0 ? _b : null;
-      const currentNode = (_c = containerElement.childNodes[range.startOffset]) !== null && _c !== void 0 ? _c : null;
-      return ((_e = (_d = this.getNodeRect(previousNode)) !== null && _d !== void 0 ? _d : this.getNodeRect(currentNode)) !== null && _e !== void 0 ? _e : this.getNodeRect(containerElement));
-    }
-    return (_f = this.getNodeRect(containerNode)) !== null && _f !== void 0 ? _f : this.getNodeRect(containerNode.parentNode);
-  }
-  /**
-   * Returns an element-backed rectangle from a DOM node.
-   *
-   * @param {Node | null} node Candidate node.
-   * @returns {DOMRect | null} Node rectangle when resolvable.
-   */
-  getNodeRect(node) {
-    var _a, _b;
-    if (!node) {
-      return null;
-    }
-    if (node.nodeType === Node.TEXT_NODE) {
-      return (_b = (_a = node.parentElement) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect()) !== null && _b !== void 0 ? _b : null;
-    }
-    if (node.nodeType === Node.ELEMENT_NODE) {
-      const rect = node.getBoundingClientRect();
-      return this.isUnavailableRect(rect) ? null : rect;
-    }
-    return null;
+    var _a;
+    this.pasteChooserController.open(this.hostEl, this.contentHostEl, pasteEvent, ((_a = this.options) === null || _a === void 0 ? void 0 : _a.enableWordPaste) === true);
   }
   /**
    * Applies the chosen paste mode by dispatching a synthetic paste input event.
@@ -328,36 +162,13 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
       return;
     }
     editableEl.focus();
-    this.restoreSelectionRange(this.pendingPastePayload.range);
-    this.restoreSelectionControllerState(this.pendingPastePayload);
-    const strategy = mode === RTEPasteMode.RICH
-      ? this.strategySelector.selectStrategy(this.pendingPastePayload.html)
-      : this.strategySelector.selectStrategyByType(mode);
-    let processedHtml = strategy.process(this.pendingPastePayload.html);
-    // If the strategy supports image processing and there is clipboard file content, parse local images.
-    if (strategy.supportsImageProcessing && this.clipboardFileContent) {
-      processedHtml = this.parseLocalImages(processedHtml, this.clipboardFileContent);
-    }
-    this.clipboardFileContent = null;
-    const dataTransfer = this.createDataTransfer(processedHtml, this.pendingPastePayload.text, strategy.type);
-    this.dispatchBeforeInputPaste(editableEl, dataTransfer);
+    this.selectionSnapshotService.restore(this.pendingPastePayload);
+    const output = this.processingPipeline.process(this.pendingPastePayload, mode);
+    const dataTransfer = this.dataTransferBuilder.build(output);
+    this.pasteDispatcher.dispatch(editableEl, dataTransfer);
     this.clearPasteChooser();
     this.emitLocalImageInsertedEvent();
   }
-  /**
-   * Parses local images from the HTML and emits events for further processing.
-   *
-   * @param {string} html HTML content to parse.
-   * @param {ClipboardFileContent} clipboardFileContent Clipboard file content for image extraction.
-   * @returns {string} Processed HTML with local image references replaced.
-   */
-  parseLocalImages(html, clipboardFileContent) {
-    const { html: result, previews } = this.imageParser.parseLocalImages(html, clipboardFileContent);
-    if (previews.length > 0) {
-      this.pendingImageRegistry.register(previews);
-    }
-    return result;
-  }
   /**
    * Emits the `imageInsertedCallback` for any pending previews, allowing the
    * consumer to upload them and resolve their URLs.
@@ -367,137 +178,13 @@ export class VegaRTEPasteExtension extends VegaRTEExtension {
       this.pendingImageRegistry.notifyInserted(this.options.imageInsertedCallback, () => { var _a; return (_a = this.editableEl) !== null && _a !== void 0 ? _a : this.getEditableElement(); }, (imageElement) => this.getDTOEntityByDom(imageElement));
     }
   }
-  /**
-   * Restores SelectionController state from the captured selection so synthetic
-   * beforeinput paste can replace the selected content instead of appending.
-   *
-   * @param {PendingPastePayload} payload Pending paste payload.
-   */
-  restoreSelectionControllerState(payload) {
-    if (!payload.range || !this.extensionContext) {
-      return;
-    }
-    const rangeOptions = {
-      startNode: payload.range.startContainer,
-      endNode: payload.range.endContainer,
-      startOffset: payload.range.startOffset,
-      endOffset: payload.range.endOffset,
-    };
-    this.extensionContext.setSelectedNodes(payload.selectedNodes || [], rangeOptions);
-  }
-  /**
-   * Restores a previously cloned selection range.
-   *
-   * @param {Range | null} range Range to restore.
-   */
-  restoreSelectionRange(range) {
-    var _a;
-    if (!range) {
-      return;
-    }
-    const selection = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.getSelection();
-    if (selection) {
-      selection.removeAllRanges();
-      selection.addRange(range);
-    }
-  }
-  /**
-   * Dispatches a synthetic `beforeinput` paste event into the editor pipeline.
-   *
-   * @param {HTMLDivElement} editableEl Editable content element.
-   * @param {DataTransfer} dataTransfer Clipboard payload for the paste.
-   */
-  dispatchBeforeInputPaste(editableEl, dataTransfer) {
-    // This synthetic beforeinput event intentionally reuses the existing
-    // UserInputController -> insertFromPaste -> InsertPasteHandler pipeline.
-    const beforeInputEvent = new CustomEvent('beforeinput', {
-      bubbles: true,
-      cancelable: true,
-    });
-    try {
-      Object.defineProperties(beforeInputEvent, {
-        inputType: {
-          value: 'insertFromPaste',
-          configurable: true,
-        },
-        dataTransfer: {
-          value: dataTransfer,
-          configurable: true,
-        },
-      });
-    }
-    catch (_a) {
-      Object.assign(beforeInputEvent, {
-        inputType: 'insertFromPaste',
-        dataTransfer,
-      });
-    }
-    editableEl.dispatchEvent(beforeInputEvent);
-  }
-  /**
-   * Builds a `DataTransfer` payload carrying the paste content and mode marker.
-   *
-   * @param {string} html HTML clipboard content.
-   * @param {string} text Plain text clipboard content.
-   * @param {RTEPasteMode} [mode] Selected paste mode marker.
-   * @returns {DataTransfer} Populated data transfer payload.
-   */
-  createDataTransfer(html, text, mode) {
-    if (typeof DataTransfer !== 'undefined') {
-      const dataTransfer = new DataTransfer();
-      if (html) {
-        dataTransfer.setData('text/html', html);
-      }
-      if (text) {
-        dataTransfer.setData('text/plain', text);
-      }
-      if (mode) {
-        dataTransfer.setData(RTE_PASTE_MODE_DATA_TYPE, mode);
-      }
-      return dataTransfer;
-    }
-    return {
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      getData: (type) => {
-        if (type === 'text/html') {
-          return html;
-        }
-        if (type === 'text/plain') {
-          return text;
-        }
-        if (type === RTE_PASTE_MODE_DATA_TYPE) {
-          return mode !== null && mode !== void 0 ? mode : '';
-        }
-        return '';
-      },
-    };
-  }
   /**
    * Tears down the chooser UI and removes dismissal listeners.
    *
    * @param {boolean} [clearPayload] Whether to also clear the pending payload.
    */
   clearPasteChooser(clearPayload = true) {
-    if (this.contentHostEl) {
-      this.contentHostEl.removeEventListener('scroll', this.handleOutsideScroll);
-    }
-    if (this.listenerWindow) {
-      this.listenerWindow.removeEventListener('scroll', this.handleOutsideScroll, true);
-      this.listenerWindow = null;
-    }
-    if (this.listenerDocument) {
-      this.listenerDocument.removeEventListener('mousedown', this.handleOutsidePointerDown, true);
-      this.listenerDocument.removeEventListener('keydown', this.handleOutsideKeyDown, true);
-      this.listenerDocument.removeEventListener('scroll', this.handleOutsideScroll, true);
-      this.listenerDocument = null;
-    }
-    if (this.chooserUI) {
-      this.chooserUI.destroy();
-    }
-    this.chooserUI = null;
-    if (clearPayload) {
-      this.pendingPastePayload = null;
-    }
+    this.pasteChooserController.clear(clearPayload);
   }
 }
 (() => {

package/dist/collection/components/vega-rich-text-editor/extensions/paste/pipeline/data-transfer-builder.js

@@ -0,0 +1,36 @@
+import { RTE_PASTE_MODE_DATA_TYPE } from '../../../constants/constant';
+/** Builds the DataTransfer contract consumed by InsertPasteHandler. */
+export class PasteDataTransferBuilder {
+  /**
+   * @param {PasteOutput} output Processed paste output to serialize.
+   * @returns {DataTransfer} Data transfer payload consumed by the paste handler.
+   */
+  build(output) {
+    // Reserved keys always win over `markers` so a strategy cannot clobber the base contract.
+    const safeMarkers = Object.assign({}, output.markers);
+    PasteDataTransferBuilder.RESERVED_KEYS.forEach((key) => delete safeMarkers[key]);
+    const values = Object.assign(Object.assign({}, safeMarkers), { 'text/html': output.html, 'text/plain': output.text, [RTE_PASTE_MODE_DATA_TYPE]: output.mode });
+    if (typeof DataTransfer !== 'undefined') {
+      const dataTransfer = new DataTransfer();
+      Object.keys(values).forEach((type) => {
+        const value = values[type];
+        if (value) {
+          dataTransfer.setData(type, value);
+        }
+      });
+      return dataTransfer;
+    }
+    return {
+      /**
+       * @param {string} type Clipboard data type to read.
+       * @returns {string} Clipboard value for the requested type.
+       */
+      getData: (type) => { var _a; return (_a = values[type]) !== null && _a !== void 0 ? _a : ''; },
+    };
+  }
+}
+PasteDataTransferBuilder.RESERVED_KEYS = [
+  'text/html',
+  'text/plain',
+  RTE_PASTE_MODE_DATA_TYPE,
+];

package/dist/collection/components/vega-rich-text-editor/extensions/paste/pipeline/paste-dispatcher.js

@@ -0,0 +1,23 @@
+/** Dispatches processed paste data through the editor's existing beforeinput pipeline. */
+export class PasteDispatcher {
+  /**
+   * @param {HTMLDivElement} editableEl Editable content element receiving the event.
+   * @param {DataTransfer} dataTransfer Processed clipboard payload.
+   */
+  dispatch(editableEl, dataTransfer) {
+    const beforeInputEvent = new CustomEvent('beforeinput', {
+      bubbles: true,
+      cancelable: true,
+    });
+    try {
+      Object.defineProperties(beforeInputEvent, {
+        inputType: { value: 'insertFromPaste', configurable: true },
+        dataTransfer: { value: dataTransfer, configurable: true },
+      });
+    }
+    catch (_a) {
+      Object.assign(beforeInputEvent, { inputType: 'insertFromPaste', dataTransfer });
+    }
+    editableEl.dispatchEvent(beforeInputEvent);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/paste/pipeline/paste-processing-pipeline.js

@@ -0,0 +1,30 @@
+/** Selects and executes one paste strategy, then performs declared post-processing. */
+export class PasteProcessingPipeline {
+  constructor(selector, imageExtractor, pendingImageRegistry) {
+    this.selector = selector;
+    this.imageExtractor = imageExtractor;
+    this.pendingImageRegistry = pendingImageRegistry;
+  }
+  /**
+   * @param {PendingPastePayload} payload Captured clipboard and selection data.
+   * @param {RTEPasteMode} explicitMode Paste mode selected by the user.
+   * @returns {PasteOutput} Processed paste output and image extraction metadata.
+   */
+  process(payload, explicitMode) {
+    const input = {
+      html: payload.html,
+      text: payload.text,
+      files: payload.files,
+      rtf: payload.rtf,
+    };
+    const output = this.selector.select(input, explicitMode).transform(input);
+    if (!output.extractImages) {
+      return output;
+    }
+    const extraction = this.imageExtractor.extract(output.html, output.imagesToExtract, input.rtf);
+    if (extraction.previews.length > 0) {
+      this.pendingImageRegistry.register(extraction.previews);
+    }
+    return Object.assign(Object.assign({}, output), { html: extraction.html });
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/paste/strategies/paste-processing-strategy.abstract.js

@@ -1,6 +1,7 @@
 export var RTEPasteMode;
 (function (RTEPasteMode) {
   RTEPasteMode["RICH"] = "rich";
+  RTEPasteMode["PLAIN"] = "plain";
   RTEPasteMode["WORD"] = "word";
 })(RTEPasteMode || (RTEPasteMode = {}));
 /**
@@ -52,4 +53,37 @@ export class AbstractPasteProcessingStrategy {
   get supportsImageProcessing() {
     return false;
   }
+  /** @returns {boolean} Whether this strategy consumes `text/plain` instead of `text/html` (default: false). */
+  get consumesPlainText() {
+    return false;
+  }
+  /**
+   * Owns the complete content policy for this paste mode. Subclasses that
+   * only need a different source string should override {@link getSourceContent}
+   * instead of re-implementing this method.
+   *
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Complete downstream paste contract.
+   */
+  transform(input) {
+    const content = this.getSourceContent(input);
+    return {
+      html: this.process(content),
+      text: this.consumesPlainText ? content : input.text,
+      mode: this.type,
+      markers: {},
+      extractImages: this.supportsImageProcessing,
+      imagesToExtract: this.supportsImageProcessing ? input.files : [],
+    };
+  }
+  /**
+   * Resolves the source string passed to {@link process}. Defaults to
+   * `input.text` when {@link consumesPlainText} is true, otherwise `input.html`.
+   *
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {string} Content to feed into `process`.
+   */
+  getSourceContent(input) {
+    return this.consumesPlainText ? input.text : input.html;
+  }
 }

package/dist/collection/components/vega-rich-text-editor/extensions/paste/strategies/paste-strategy-selector.js

@@ -1,5 +1,7 @@
 import { DefaultPasteProcessingStrategy } from './default-paste-strategy';
+import { RTEPasteMode } from './paste-processing-strategy.abstract';
 import { WordPasteProcessingStrategy } from './word-paste-strategy';
+import { PlainPasteProcessingStrategy } from './plain-paste-strategy';
 /**
  * Centralized selector for paste processing strategies.
  *
@@ -12,10 +14,27 @@ export class PasteStrategySelector {
   constructor() {
     this.defaultStrategy = new DefaultPasteProcessingStrategy();
     this.strategies = [
+      new PlainPasteProcessingStrategy(),
       new WordPasteProcessingStrategy(),
       this.defaultStrategy, // Fallback
     ];
   }
+  /**
+   * Selects the strategy that will process this paste.
+   *
+   * When `explicitMode` is provided and not `rich`, the strategy registered for that mode
+   * is used. Otherwise the highest-priority strategy whose `canHandle` matches the HTML
+   * wins, falling back to the default pass-through strategy.
+   *
+   * @param {PasteInput} input Captured clipboard payload used for auto-detection.
+   * @param {RTEPasteMode} [explicitMode] Paste mode the user picked from the chooser.
+   * @returns {AbstractPasteProcessingStrategy} Strategy to run for this paste.
+   */
+  select(input, explicitMode) {
+    return explicitMode && explicitMode !== RTEPasteMode.RICH
+      ? this.selectStrategyByType(explicitMode)
+      : this.selectStrategy(input.html);
+  }
   /**
    * Select the appropriate strategy for the given HTML content.
    * Returns the highest-priority strategy that can handle the content.