@heartlandone/vega 2.102.0 → 2.103.0

package/dist/types/components/vega-input/slimmers/controllers/vega-input-state-controller.d.ts

@@ -6,8 +6,6 @@ import { VegaInput } from '../../vega-input';
  */
 export declare class VegaInputStateController extends SubStateObserverSlimmer<HTMLVegaInputElement> {
   host: VegaInput['host'];
-  prefixText: VegaInput['prefixText'];
-  suffixText: VegaInput['suffixText'];
   isCompactInputWidth: VegaInput['isCompactInputWidth'];
   constructor();
 }

package/dist/types/components/vega-input/slimmers/renderers/vega-input-input-container-renderer.d.ts

@@ -13,8 +13,12 @@ export declare class VegaInputInputContainerRenderer extends VegaSlimmer {
   private prefixSlotRenderer;
   private passwordEyeRenderer;
   private inputRenderer;
+  private readonly prefixTextId;
+  private readonly suffixTextId;
   private inputContainerRef;
   getInputContainerRef(): HTMLElement;
+  getPrefixTextId(): Nullable<string>;
+  getSuffixTextId(): Nullable<string>;
   render(): Nullable<HTMLElement>;
   private renderClearIcon;
   private renderPrefixText;

package/dist/types/components/vega-input/slimmers/renderers/vega-input-input-renderer.d.ts

@@ -20,6 +20,7 @@ export declare class VegaInputInputRenderer extends VegaSlimmer {
   private pasteEventEmitter;
   private copyPasteController;
   private nativeInputChangeEventEmitter;
+  private inputContainerRenderer;
   private inputRef;
   connectedCallback(): void;
   disconnectedCallback(): void;
@@ -28,6 +29,7 @@ export declare class VegaInputInputRenderer extends VegaSlimmer {
   getInputRef(): HTMLInputElement;
   render(): Nullable<HTMLElement>;
   private setInputRef;
+  private getAriaDescribedBy;
   private getInputType;
   private handleInputFocus;
   private handleInputBlur;

package/dist/types/components/vega-input/vega-input.d.ts

@@ -55,9 +55,6 @@ export declare class VegaInput {
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaInputElement>;
   protected readonly passwordEyeRenderer: VegaInputPasswordEyeRenderer;
   host: HTMLVegaInputElement;
-  prefixText: string;
-  suffixText: string;
-  watchSuffixText(): void;
   isCompactInputWidth: boolean;
   isPasswordDisplay: boolean;
   suggestionsDropdownConfig: VegaInputSuggestionsDropdownConfig;
@@ -438,6 +435,21 @@ export declare class VegaInput {
    * releated issue: https://gitlab.com/heartland1/vega/tiger/-/issues/646
    */
   watchMaskChange(newValue: MaskConfigType | MaskConfigType[], oldValue: MaskConfigType | MaskConfigType[]): void;
+  /**
+   * Text displayed before (to the left of) the input value inside the input field.
+   *
+   * @default undefined
+   * @vegaVersion 2.103.0
+   */
+  prefixText: string;
+  /**
+   * Text displayed after (to the right of) the input value inside the input field.
+   *
+   * @default undefined
+   * @vegaVersion 2.103.0
+   */
+  suffixText: string;
+  watchSuffixText(): void;
   /**
    * When `true`, disables the ability to copy from or paste into the input field.
    *

package/dist/types/components/vega-input-numeric/slimmers/renderers/vega-input-numeric-renderer.d.ts

@@ -1,6 +1,8 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 export declare class VegaInputNumericRenderer extends VegaSlimmer {
   private prefixIcon;
+  private prefixText;
+  private suffixText;
   private showClearIcon;
   private value;
   private size;

package/dist/types/components/vega-input-numeric/vega-input-numeric.d.ts

@@ -22,8 +22,6 @@ export declare class VegaInputNumeric {
   protected changeEventEmitter: EventEmitSlimmerBase;
   protected inputEventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly formFieldController: FormFieldControllerSlimmer<string>;
-  protected readonly prefixTextNotifySlimmer: SubStateNotifySlimmerBase;
-  protected readonly suffixTextNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly isCompactInputWidthNotifySlimmer: SubStateNotifySlimmerBase;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaInputNumericElement>;
   host: HTMLVegaInputNumericElement;

package/dist/types/components/vega-rich-text-editor/constants/constant.d.ts

@@ -33,9 +33,13 @@ export declare const RTE_BLOCK_BOUNDARY_ATTRIBUTE: string;
  * whether to preserve the original inline styles.
  */
 export declare const RTE_PASTE_MODE_DATA_TYPE: string;
+/** Marks synthetic plain-paste text whose preserved-whitespace sentinels require decoding. */
+export declare const RTE_PRESERVED_WHITESPACE_DATA_TYPE: string;
 /**
  * Custom DataTransfer MIME type value used to indicate that the paste content
  * originated from Microsoft Word.
  */
 export declare const RTE_PASTE_MODE_WORD: string;
 export declare const RTE_WORD_COUNT_KEY: string;
+/** Custom paste mode value used to insert clipboard content without formatting. */
+export declare const RTE_PASTE_MODE_PLAIN: string;

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/sequential-composition-strategy.d.ts

@@ -0,0 +1,14 @@
+import { SequentialCompositionAction } from '../../actions/sequential-composition-action';
+import type { VegaRTEContent } from '../../content-state';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Runs each step of a `SequentialCompositionAction` against its own target. Inner leaf actions stay
+ * non-flushable, so only the outer composition emits the single flush notification. A step can be a
+ * factory that builds its operation(s) at apply time, reading earlier applied actions by their type.
+ */
+export declare class SequentialCompositionStrategy extends ActionHandleStrategy<SequentialCompositionAction, VegaRTEContent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: SequentialCompositionAction): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/actions/modify-content-action.abstract.d.ts

@@ -1,3 +1,4 @@
+import { RTEFlushChangesPayload } from '../flush-changes-payload';
 export declare enum ModifyContentActionType {
   'DELETE_CHILDREN' = "DELETE_CHILDREN",
   'DELETE_NEST_LIST' = "DELETE_NEST_LIST",
@@ -31,12 +32,14 @@ export declare enum ModifyContentActionType {
   'INSERT_TEXT_TO_DECORATOR_NODE' = "INSERT_TEXT_TO_DECORATOR_NODE",
   'INSERT_NODE_TO_NEAREST_ROOT' = "INSERT_NODE_TO_NEAREST_ROOT",
   'PASTE_CONTENT' = "PASTE_CONTENT",
-  'DELETE_SELECTED_CONTENT' = "DELETE_SELECTED_CONTENT"
+  'DELETE_SELECTED_CONTENT' = "DELETE_SELECTED_CONTENT",
+  'SEQUENTIAL_COMPOSITION' = "SEQUENTIAL_COMPOSITION"
 }
 /**
  * Abstract class for update node content, delete node, insert node
  */
 export declare abstract class ModifyContentAction {
   isFlushable: boolean;
+  flushPayload?: RTEFlushChangesPayload;
   abstract type: string;
 }

package/dist/types/components/vega-rich-text-editor/dto/actions/sequential-composition-action.d.ts

@@ -0,0 +1,30 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+import type { RTEBlock } from '../blocks/block.abstract';
+import type { RTENode } from '../nodes/node.abstract';
+import type { VegaRTEContent } from '../content-state';
+import { RTEFlushChangesPayload } from '../flush-changes-payload';
+/** A target that a composition step's action is applied against. */
+export declare type CompositionTarget = VegaRTEContent | RTEBlock | RTENode;
+/** A single content-modification applied against its own target within a composition. */
+export interface CompositionOperation {
+  target: CompositionTarget;
+  action: ModifyContentAction;
+}
+/** Read-only view of applied actions, keyed by action type, exposed to later factory steps. */
+export interface CompositionContext {
+  getAction<T extends ModifyContentAction>(type: ModifyContentActionType): T | undefined;
+}
+/** Lazily builds the operation(s) to run at apply time, using results produced by earlier steps. */
+export declare type CompositionStepFactory = (context: CompositionContext) => CompositionOperation | CompositionOperation[] | void;
+/** A composition step is either an eager operation or a factory evaluated when the composition runs. */
+export declare type CompositionStep = CompositionOperation | CompositionStepFactory;
+/**
+ * Applies an ordered list of leaf content actions as one flushable unit, so a `beforeinput` handler
+ * emits a single flush through the shared action pipeline instead of marking each leaf action flushable.
+ */
+export declare class SequentialCompositionAction extends ModifyContentAction {
+  readonly steps: CompositionStep[];
+  isFlushable: boolean;
+  type: ModifyContentActionType;
+  constructor(steps: CompositionStep[], flushPayload?: RTEFlushChangesPayload);
+}

package/dist/types/components/vega-rich-text-editor/dto/flush-changes-payload.d.ts

@@ -0,0 +1,16 @@
+import { RTEUpdateSource } from '../constants/constant';
+/**
+ * Payload dispatched with `VegaInternalRichTextEditorFlushChanges` notifications.
+ * Carries the parameters that the `ValueController` flush observer needs so it can
+ * invoke the flush immediately (bypassing the debounce) for `beforeinput`-driven
+ * updates instead of relying on the debounced default path.
+ *
+ * Owned by handlers (see `BaseHandler.flushOptions`). The observer treats a missing
+ * payload — or missing fields — as "use the debounced default"; the defaults live
+ * on the emitter side so there is a single source of truth.
+ */
+export interface RTEFlushChangesPayload {
+  bypassDebounce?: boolean;
+  recordHistory?: boolean;
+  updateSource?: RTEUpdateSource;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/dto/function-block.d.ts

@@ -27,6 +27,13 @@ export declare class RTEFunctionBlock extends RTEBlock<VegaRTEContent | RTEHtmlB
    * @returns {RTEFunctionBlock} The resulting RTEFunctionBlock.
    */
   static from(block: VegaFunctionBlock, options?: VegaRTETransformOptions): RTEFunctionBlock;
+  /**
+   * Removes a redundant div wrapper from FOREACH content so it is rendered inline
+   * with the FOREACH control. SHOW content retains its wrapper to preserve line breaks.
+   *
+   * @param {RTEFunctionBlockChild[]} children - The function block children to normalize.
+   */
+  static unwrapForeachContent(children: RTEFunctionBlockChild[]): void;
   /**
    * Converts the RTEFunctionBlock and its children to an HTML string.
    *

package/dist/types/components/vega-rich-text-editor/extensions/paste/controllers/chooser-positioner.d.ts

@@ -0,0 +1,33 @@
+export declare type ChooserPosition = {
+  left: number;
+  top: number;
+  placement: ['bottom', 'top'] | ['top', 'bottom'];
+};
+/** Computes paste chooser placement from the paste pointer or saved caret range. */
+export declare class ChooserPositioner {
+  private readonly getHostElement;
+  private readonly getSelectionRange;
+  constructor(getHostElement: () => HTMLVegaRichTextEditorElement | null, getSelectionRange: () => Range | null);
+  /**
+   * @param {ClipboardEvent} event Originating paste event.
+   * @returns {ChooserPosition} Position in viewport coordinates.
+   */
+  compute(event: ClipboardEvent): ChooserPosition;
+  /** @returns {DOMRect | null} Best available caret rectangle. */
+  getCaretRect(): DOMRect | null;
+  /**
+   * @param {DOMRect} rect Rectangle to inspect.
+   * @returns {boolean} Whether the rectangle has no usable position or dimensions.
+   */
+  isUnavailableRect(rect: DOMRect): boolean;
+  /**
+   * @param {Range} range Selection range whose container should be measured.
+   * @returns {DOMRect | null} Best available rectangle for the range container.
+   */
+  getRangeContainerRect(range: Range): DOMRect | null;
+  /**
+   * @param {Node | null} node DOM node to measure.
+   * @returns {DOMRect | null} Element-backed rectangle for the node.
+   */
+  getNodeRect(node: Node | null): DOMRect | null;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/controllers/paste-chooser-controller.d.ts

@@ -0,0 +1,43 @@
+import { ChooserPositioner } from './chooser-positioner';
+import { RTEPasteChooserUI } from '../paste-chooser-ui';
+import { RTEPasteMode } from '../strategies/paste-processing-strategy.abstract';
+/** Owns chooser rendering and all listener bookkeeping used to dismiss it. */
+export declare class PasteChooserController {
+  private readonly positioner;
+  private readonly onModeSelect;
+  private readonly onClearPayload;
+  private chooserUI;
+  private listenerDocument;
+  private listenerWindow;
+  private contentHostEl;
+  constructor(positioner: ChooserPositioner, onModeSelect: (mode: RTEPasteMode) => void, onClearPayload: () => void);
+  /**
+   * @returns {RTEPasteChooserUI | null} Current chooser UI, or `null` when closed.
+   */
+  get ui(): RTEPasteChooserUI | null;
+  /**
+   * @param {HTMLElement | null} hostEl Rich text editor host element.
+   * @param {HTMLElement | null} contentHostEl Scrollable content host element.
+   * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
+   * @param {boolean} showWordOption Whether to display the Word paste option.
+   */
+  open(hostEl: HTMLVegaRichTextEditorElement | null, contentHostEl: HTMLVegaRichTextContentElement | null, pasteEvent: ClipboardEvent, showWordOption: boolean): void;
+  /**
+   * @param {Event} event Pointer event captured on the document.
+   */
+  readonly handleOutsidePointerDown: (event: Event) => void;
+  /**
+   * @param {KeyboardEvent} event Keyboard event captured on the document.
+   */
+  readonly handleOutsideKeyDown: (event: KeyboardEvent) => void;
+  /**
+   * Clears the chooser when a relevant scroll container scrolls.
+   *
+   * @returns {void}
+   */
+  readonly handleOutsideScroll: () => void;
+  /**
+   * @param {boolean} [clearPayload] Whether to also clear the pending paste payload.
+   */
+  clear(clearPayload?: boolean): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/controllers/paste-event-interceptor.d.ts

@@ -0,0 +1,22 @@
+import { SelectionSnapshotService } from './selection-snapshot-service';
+import { PendingPastePayload } from '../type';
+export declare type PasteCaptured = (payload: PendingPastePayload, event: ClipboardEvent) => void;
+/** Owns the native paste listener and synchronous clipboard payload capture. */
+export declare class PasteEventInterceptor {
+  private readonly selectionSnapshotService;
+  private readonly onPasteCaptured;
+  private editableEl;
+  constructor(selectionSnapshotService: SelectionSnapshotService, onPasteCaptured: PasteCaptured);
+  /**
+   * @param {HTMLDivElement | null} editableEl Editable content element to observe.
+   */
+  attach(editableEl: HTMLDivElement | null): void;
+  /**
+   * Detaches the current native paste listener.
+   */
+  detach(): void;
+  /**
+   * @param {ClipboardEvent} event Native paste event to capture.
+   */
+  readonly handlePasteEvent: (event: ClipboardEvent) => void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/controllers/selection-snapshot-service.d.ts

@@ -0,0 +1,29 @@
+import { RTEExtensionContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+import { PendingPastePayload, SelectedNodes } from '../type';
+declare type SelectionSnapshot = {
+  range: Range | null;
+  selectedNodes: SelectedNodes;
+};
+/** Captures and restores native and editor selection state around chooser interaction. */
+export declare class SelectionSnapshotService {
+  private readonly getContext;
+  constructor(getContext: () => Nullable<RTEExtensionContext>);
+  /**
+   * @returns {SelectionSnapshot} Captured native and editor selection state.
+   */
+  capture(): SelectionSnapshot;
+  /**
+   * @param {PendingPastePayload} payload Paste payload containing captured selection state.
+   */
+  restore(payload: PendingPastePayload): void;
+  /**
+   * @param {PendingPastePayload} payload Paste payload containing editor selection state.
+   */
+  restoreControllerState(payload: PendingPastePayload): void;
+  /**
+   * @param {Range | null} range Native selection range to restore.
+   */
+  restoreRange(range: Range | null): void;
+}
+export {};

package/dist/types/components/vega-rich-text-editor/extensions/paste/parse-local-images-helper/image-extractor.d.ts

@@ -0,0 +1,13 @@
+import { PasteImageParser, ParseLocalImagesResult } from './paste-image-parser';
+/** Extracts local image previews from strategy output. */
+export declare class ImageExtractor {
+  private readonly parser;
+  constructor(parser?: PasteImageParser);
+  /**
+   * @param {string} html HTML content containing local image references.
+   * @param {File[]} files Clipboard image files.
+   * @param {string} rtf Rich text clipboard content used to resolve images.
+   * @returns {ParseLocalImagesResult} HTML and extracted local image previews.
+   */
+  extract(html: string, files: File[], rtf: string): ParseLocalImagesResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/parse-local-images-helper/paste-image-parser.d.ts

@@ -1,4 +1,4 @@
-import { ClipboardFileContent, VegaRTEPasteImage } from '../paste-extension';
+import { ClipboardFileContent, VegaRTEPasteImage } from '../type';
 /**
  * A pasted image whose upload is still pending: the public
  * {@link VegaRTEPasteImage} payload plus the local object URL currently used as

package/dist/types/components/vega-rich-text-editor/extensions/paste/parse-local-images-helper/pending-image-registry.d.ts

@@ -1,6 +1,6 @@
 import { RTEImageNode } from '../../../dto/nodes/image-node';
 import { PasteImagePreview } from './paste-image-parser';
-import type { VegaRTEPasteImage } from '../paste-extension';
+import type { VegaRTEPasteImage } from '../type';
 /** Consumer callback invoked once pasted images are inserted into the editor. */
 export declare type ImageInsertedCallback = (images: VegaRTEPasteImage[], replaceUrl: (imageId: string, url: string) => void) => void;
 /** Resolves the editable content element currently backing the editor. */

package/dist/types/components/vega-rich-text-editor/extensions/paste/paste-chooser-ui.d.ts

@@ -19,6 +19,7 @@ export declare class RTEPasteChooserUI {
   private readonly options;
   static readonly CHOOSER_ATTR: string;
   static readonly CHOOSER_RICH_ATTR: string;
+  static readonly CHOOSER_PLAIN_ATTR: string;
   static readonly CHOOSER_WORD_ATTR: string;
   static readonly CHOOSER_TRIGGER_ATTR: string;
   private chooserEl;

package/dist/types/components/vega-rich-text-editor/extensions/paste/paste-extension.d.ts

@@ -1,15 +1,17 @@
 import { VegaRTEExtension } from '../extension.abstract';
+import { RTEPasteChooserUI } from './paste-chooser-ui';
+import { PasteStrategySelector } from './strategies/paste-strategy-selector';
 import { RTEExtensionContext } from '../../interface';
-export declare type ClipboardFileContent = {
-  files: File[];
-  rtf: string;
-};
-export declare type VegaRTEPasteImage = {
-  /** Unique identifier used to fill in the uploaded URL later. */
-  id: string;
-  /** Pasted image file to upload. */
-  file: File;
-};
+import { PasteImageParser } from './parse-local-images-helper/paste-image-parser';
+import { PendingImageRegistry } from './parse-local-images-helper/pending-image-registry';
+import { ChooserPositioner } from './controllers/chooser-positioner';
+import { VegaRTEPasteImage } from './type';
+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';
 export declare type VegaRTEPasteExtensionOptions = {
   enableWordPaste?: boolean;
   imageInsertedCallback?: (images: VegaRTEPasteImage[], replaceUrl: (imageId: string, url: string) => void) => void;
@@ -19,47 +21,51 @@ export declare type VegaRTEPasteExtensionOptions = {
  * Intercepts keyboard paste and allows users to choose paste mode.
  */
 export declare class VegaRTEPasteExtension extends VegaRTEExtension {
+  protected readonly strategySelector: PasteStrategySelector;
+  protected readonly imageParser: PasteImageParser;
+  protected readonly pendingImageRegistry: PendingImageRegistry;
+  protected readonly chooserPositioner: ChooserPositioner;
+  protected readonly processingPipeline: PasteProcessingPipeline;
+  protected readonly dataTransferBuilder: PasteDataTransferBuilder;
+  protected readonly pasteDispatcher: PasteDispatcher;
+  protected readonly selectionSnapshotService: SelectionSnapshotService;
+  protected readonly pasteEventInterceptor: PasteEventInterceptor;
+  protected readonly pasteChooserController: PasteChooserController;
   private hostEl;
   private editableEl;
   private contentHostEl;
-  private chooserUI;
   private pendingPastePayload;
-  private listenerDocument;
-  private listenerWindow;
   private options;
-  private strategySelector;
-  private clipboardFileContent;
-  private imageParser;
-  /** Owns pending pasted-image previews awaiting upload and their URL replacement. */
-  private readonly pendingImageRegistry;
   constructor(options?: VegaRTEPasteExtensionOptions);
   /** @inheritDoc */
   initialExtensionAfterLoad(context: RTEExtensionContext): void;
   /** @inheritDoc */
   destroyExtension(): void;
+  /** @returns {RTEPasteChooserUI | null} Currently open chooser UI, or `null` when closed. */
+  protected get chooserUI(): RTEPasteChooserUI | null;
   /**
    * Handles a native paste event by capturing the clipboard payload and
    * rendering the paste-mode chooser.
    *
    * @param {ClipboardEvent} event Native clipboard paste event.
    */
-  private readonly handlePasteEvent;
+  protected readonly handlePasteEvent: (event: ClipboardEvent) => void;
   /**
    * Dismisses the chooser when a pointer interaction occurs outside of it.
    *
    * @param {Event} event Pointer event captured on the document.
    */
-  private readonly handleOutsidePointerDown;
+  protected readonly handleOutsidePointerDown: (event: Event) => void;
   /**
    * Dismisses the chooser when the Escape key is pressed.
    *
    * @param {KeyboardEvent} event Keyboard event captured on the document.
    */
-  private readonly handleOutsideKeyDown;
+  protected readonly handleOutsideKeyDown: (event: KeyboardEvent) => void;
   /**
    * Dismisses the chooser when any relevant scroll container scrolls.
    */
-  private readonly handleOutsideScroll;
+  protected readonly handleOutsideScroll: () => void;
   /**
    * Attaches the paste listener to the editable element.
    */
@@ -93,40 +99,6 @@ export declare class VegaRTEPasteExtension extends VegaRTEExtension {
    * @param {ClipboardEvent} pasteEvent Originating paste event used for positioning.
    */
   private renderPasteChooser;
-  /**
-   * 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.
-   */
-  private computeChooserPosition;
-  /**
-   * Resolves the bounding rect of the pending caret position.
-   *
-   * @returns {DOMRect | null} Caret rect or `null` when it cannot be determined.
-   */
-  private getCaretRect;
-  /**
-   * Returns whether the browser could not resolve a meaningful caret rectangle.
-   *
-   * @param {DOMRect} rect Candidate caret rect.
-   * @returns {boolean} Whether the rect is unusable.
-   */
-  private isUnavailableRect;
-  /**
-   * 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.
-   */
-  private getRangeContainerRect;
-  /**
-   * Returns an element-backed rectangle from a DOM node.
-   *
-   * @param {Node | null} node Candidate node.
-   * @returns {DOMRect | null} Node rectangle when resolvable.
-   */
-  private getNodeRect;
   /**
    * Applies the chosen paste mode by dispatching a synthetic paste input event.
    *
@@ -136,48 +108,11 @@ export declare class VegaRTEPasteExtension extends VegaRTEExtension {
    * @param {RTEPasteMode} mode Selected paste mode.
    */
   private applyPasteMode;
-  /**
-   * 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.
-   */
-  private parseLocalImages;
   /**
    * Emits the `imageInsertedCallback` for any pending previews, allowing the
    * consumer to upload them and resolve their URLs.
    */
   private emitLocalImageInsertedEvent;
-  /**
-   * 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.
-   */
-  private restoreSelectionControllerState;
-  /**
-   * Restores a previously cloned selection range.
-   *
-   * @param {Range | null} range Range to restore.
-   */
-  private restoreSelectionRange;
-  /**
-   * Dispatches a synthetic `beforeinput` paste event into the editor pipeline.
-   *
-   * @param {HTMLDivElement} editableEl Editable content element.
-   * @param {DataTransfer} dataTransfer Clipboard payload for the paste.
-   */
-  private dispatchBeforeInputPaste;
-  /**
-   * 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.
-   */
-  private createDataTransfer;
   /**
    * Tears down the chooser UI and removes dismissal listeners.
    *

package/dist/types/components/vega-rich-text-editor/extensions/paste/pipeline/data-transfer-builder.d.ts

@@ -0,0 +1,10 @@
+import { PasteOutput } from '../type';
+/** Builds the DataTransfer contract consumed by InsertPasteHandler. */
+export declare class PasteDataTransferBuilder {
+  private static readonly RESERVED_KEYS;
+  /**
+   * @param {PasteOutput} output Processed paste output to serialize.
+   * @returns {DataTransfer} Data transfer payload consumed by the paste handler.
+   */
+  build(output: PasteOutput): DataTransfer;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/pipeline/paste-dispatcher.d.ts

@@ -0,0 +1,8 @@
+/** Dispatches processed paste data through the editor's existing beforeinput pipeline. */
+export declare class PasteDispatcher {
+  /**
+   * @param {HTMLDivElement} editableEl Editable content element receiving the event.
+   * @param {DataTransfer} dataTransfer Processed clipboard payload.
+   */
+  dispatch(editableEl: HTMLDivElement, dataTransfer: DataTransfer): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/pipeline/paste-processing-pipeline.d.ts

@@ -0,0 +1,18 @@
+import { PendingImageRegistry } from '../parse-local-images-helper/pending-image-registry';
+import { PasteStrategySelector } from '../strategies/paste-strategy-selector';
+import { RTEPasteMode } from '../strategies/paste-processing-strategy.abstract';
+import { ImageExtractor } from '../parse-local-images-helper/image-extractor';
+import { PasteOutput, PendingPastePayload } from '../type';
+/** Selects and executes one paste strategy, then performs declared post-processing. */
+export declare class PasteProcessingPipeline {
+  private readonly selector;
+  private readonly imageExtractor;
+  private readonly pendingImageRegistry;
+  constructor(selector: PasteStrategySelector, imageExtractor: ImageExtractor, 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: PendingPastePayload, explicitMode: RTEPasteMode): PasteOutput;
+}