@globalpayments/vega 2.92.0 → 2.94.0

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

@@ -1,12 +1,22 @@
 import { PasteContentAction } from '../../actions/paste-content-action';
 import { RTEBlock } from '../../blocks/block.abstract';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
-/**
- * Strategy to handle the paste content into function block.
- */
+/** Handles pasted content in a block. */
 export declare class PasteContentStrategy extends ActionHandleStrategy<PasteContentAction, RTEBlock> {
   /**
-   * @inheritDoc
+   * Handles pasted content for the target block.
+   *
+   * @param {PasteContentAction} action - The paste action to apply.
+   * @param {RTEBlock} target - The block receiving the pasted content.
+   * @returns {void}
    */
   protected handleAction(action: PasteContentAction, target: RTEBlock): void;
+  /**
+   * Merges a single pasted block inline at the cursor position.
+   *
+   * @param {PasteContentAction} action - The paste action being processed.
+   * @param {RTEBlock} target - The block receiving the inline merge.
+   * @returns {void}
+   */
+  private inlineMergeSingleBlock;
 }

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

@@ -16,5 +16,12 @@ export declare class PasteContentAction extends ModifyContentAction {
   startOffset: number;
   rteRange: Nullable<RTERange>;
   futureFocusBlock: RTEBlock;
+  futureFocusAtEnd: boolean;
+  /**
+   * When set by PasteContentStrategy after an inline single-block merge, the caret
+   * is placed at this node / offset instead of the block-level fallback position.
+   */
+  futureFocusNode?: RTENode;
+  futureFocusNodeOffset?: number;
   constructor(blocksToBeInserted: RTEBlock[], startNode: RTENode, startOffset: number, rteRange?: RTERange);
 }

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/action-handler-interceptors/blockquote-exit-on-enter-interceptor.d.ts

@@ -0,0 +1,34 @@
+import { ActionHandlerExecution, ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import type { InsertNewParagraphAction } from '../../../dto/actions/insert-new-paragraph-action';
+import type { RTETextBlock } from '../../../dto/blocks/text-block';
+/**
+ * Lets the caret exit the blockquote via the keyboard. Pressing Enter on an empty
+ * trailing paragraph inside a blockquote (i.e. the second Enter press at the end of
+ * the quote) moves that empty paragraph out to a new paragraph after the blockquote,
+ * instead of stacking another empty line inside the quote.
+ */
+export declare class BlockquoteExitOnEnterInterceptor extends ActionHandlerInterceptor<InsertNewParagraphAction, RTETextBlock> {
+  /**
+   * Intercept only when the caret sits in an empty paragraph that is the last child of a blockquote.
+   *
+   * @param {InsertNewParagraphAction} _action - the action to be intercepted
+   * @param {RTETextBlock} target - the paragraph block receiving the Enter key press
+   * @returns {boolean} - whether the action should be intercepted
+   */
+  canIntercept(_action: InsertNewParagraphAction, target: RTETextBlock): boolean;
+  /**
+   * Move the empty paragraph out of the blockquote and place a new paragraph after it.
+   *
+   * @param {ActionHandlerExecution} _execution - the original execution function
+   * @param {InsertNewParagraphAction} action - the action containing insert metadata
+   * @param {RTETextBlock} target - the empty paragraph block to move out of the blockquote
+   */
+  intercept(_execution: ActionHandlerExecution, action: InsertNewParagraphAction, target: RTETextBlock): void;
+  /**
+   * Create a new empty paragraph block.
+   *
+   * @param {string} text - paragraph text
+   * @returns {Nullable<RTETextBlock>} - paragraph block when paragraph dto class is available
+   */
+  private createNewParagraph;
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/action-handler-strategies/block-transform-to-blockquote-strategy.d.ts

@@ -0,0 +1,13 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { TransformToBlockquoteAction } from '../actions/transform-to-blockquote-action';
+import { RTEBlockquoteParent } from '../dto/rte-blockquote-block';
+/**
+ * Wrap the selected blocks into a new `<blockquote>` block while preserving
+ * their order.
+ */
+export declare class BlockTransformToBlockquoteStrategy extends ActionHandleStrategy<TransformToBlockquoteAction, RTEBlockquoteParent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: TransformToBlockquoteAction, target: RTEBlockquoteParent): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/action-handler-strategies/remove-blockquote-strategy.d.ts

@@ -0,0 +1,13 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+import { RemoveBlockquoteAction } from '../actions/remove-blockquote-action';
+/**
+ * Unwrap a `<blockquote>` — lift its children to the parent in their original
+ * order and remove the blockquote.
+ */
+export declare class RemoveBlockquoteStrategy extends ActionHandleStrategy<RemoveBlockquoteAction, RTEBlockquoteBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(_action: RemoveBlockquoteAction, target: RTEBlockquoteBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/actions/remove-blockquote-action.d.ts

@@ -0,0 +1,14 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+/**
+ * Action type discriminator. Plain string constant — intentionally NOT added
+ * to {@link ModifyContentActionType} enum to keep the extension self-contained.
+ */
+export declare const REMOVE_BLOCKQUOTE: string;
+/**
+ * Unwrap a `<blockquote>` block — lift its children into the parent in place
+ * and remove the blockquote wrapper. Targets the blockquote block itself.
+ */
+export declare class RemoveBlockquoteAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/actions/transform-to-blockquote-action.d.ts

@@ -0,0 +1,18 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+/**
+ * Action type discriminator. Plain string constant — intentionally NOT added
+ * to {@link ModifyContentActionType} enum to keep the extension self-contained.
+ */
+export declare const TRANSFORM_TO_BLOCKQUOTE: string;
+/**
+ * Wrap the supplied blocks into a new `<blockquote>` block while preserving
+ * their order. Strategy reads `selectedBlocks` and replaces them in-place
+ * with a single `RTEBlockquoteBlock` that adopts them as children.
+ */
+export declare class TransformToBlockquoteAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  selectedBlocks: RTEBlock[];
+  constructor(selectedBlocks: RTEBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/assets/quote-left.d.ts

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Adds `<blockquote>` support to the Vega Rich Text Editor.
+ */
+export declare class VegaRTEBlockquoteExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
+  private toolbarButtonRenderer;
+  constructor();
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/dto/blockquote-annotation.d.ts

@@ -0,0 +1,48 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+export declare enum RTEBlockquoteExtensionAnnotationTypeEnum {
+  BLOCKQUOTE = "BLOCKQUOTE"
+}
+/**
+ * CSS class applied to `<blockquote>` elements rendered inside the editor.
+ */
+export declare const BLOCKQUOTE_CLASS_NAME: string;
+/**
+ * Default visual styles for the `<blockquote>` element in the RTE.
+ */
+export declare const BLOCKQUOTE_DEFAULT_STYLES: AnnotationStyle;
+/**
+ * Blockquote annotation.
+ */
+export declare class BlockquoteAnnotation extends BlockAnnotation<RTEBlockquoteExtensionAnnotationTypeEnum> {
+  readonly type: RTEBlockquoteExtensionAnnotationTypeEnum;
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, BlockquoteAnnotation]} Map item.
+   */
+  static from(): [RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, BlockquoteAnnotation];
+  /**
+   * Get the default CSS rule for the blockquote element.
+   *
+   * @returns {string} The default CSS rule.
+   */
+  static getDefaultCssText(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Nullable<Record<string, unknown>>;
+  /**
+   * @inheritDoc
+   */
+  clone(): BlockquoteAnnotation;
+  /**
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
+}

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

@@ -0,0 +1,56 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+/**
+ * JSON payload shape for a blockquote block.
+ */
+export declare type VegaRTEBlockquoteBlock = VegaRTEBlockBase & {
+  type: 'blockquote';
+  children: VegaRTEContentBlock[];
+};
+/**
+ * Containers that may directly hold a blockquote block. Covers the editor
+ * root and any block container (e.g. an HTML wrapper or a table cell)
+ * without coupling this DTO to specific sibling extensions.
+ */
+export declare type RTEBlockquoteParent = VegaRTEContent | RTEBlock;
+/**
+ * DTO representing a `<blockquote>` block.
+ */
+export declare class RTEBlockquoteBlock extends RTEBlock<RTEBlockquoteParent, RTEBlock> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
+  type: string;
+  parent: RTEBlockquoteParent;
+  children: RTEBlock[];
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * Convert a JSON block payload into an `RTEBlockquoteBlock` instance.
+   *
+   * @param {VegaRTEBlockquoteBlock} block - JSON payload.
+   * @param {VegaRTETransformOptions} [options] - Transform options.
+   * @returns {RTEBlockquoteBlock} The created blockquote block.
+   */
+  static from(block: VegaRTEBlockquoteBlock, options?: VegaRTETransformOptions): RTEBlockquoteBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTEBlockquoteParent): RTEBlockquoteBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(options?: VegaRTETransformOptions): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTEBlockquoteBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/element-to-dto-strategies/blockquote-to-blockquote-block-strategy.d.ts

@@ -0,0 +1,35 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Claim every `<blockquote>` element encountered during HTML → DTO conversion
+ * and produce an {@link RTEBlockquoteBlock}.
+ *
+ * Nested `<blockquote>` elements are flattened to a single level in
+ * {@link appendChildBlocks}: any direct child that arrives as another
+ * `<blockquote>` is replaced by its own children, lifting them one level up.
+ */
+export declare class BlockquoteToBlockquoteBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlockquoteBlock>;
+  /**
+   * Flatten nested `<blockquote>` elements: any direct child that is itself
+   * an {@link RTEBlockquoteBlock} is replaced by its own children, lifting
+   * them one level up.
+   *
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTEBlockquoteBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/filter-styles-strategies/blockquote-block/blockquote-filter-styles-strategy.d.ts

@@ -0,0 +1,31 @@
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../../dto/nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+/**
+ * Filter styles strategy for blockquote blocks.
+ * Strips default blockquote visual styles during output and refills them during input,
+ * ensuring source edit round-trips do not lose information.
+ */
+export declare class BlockquoteFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * Checks if the given block dto class name corresponds to a blockquote block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a blockquote block, false otherwise.
+   */
+  private static isBlockquoteBlock;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-block-renderer.d.ts

@@ -0,0 +1,18 @@
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+/**
+ * Renderer for blockquote blocks in the rich text editor.
+ */
+export declare class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(createElement: VegaRTECreateElementFunction, block: RTEBlockquoteBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles(): string;
+}
+declare const _default: RTEBlockquoteBlockRenderer;
+export default _default;

package/dist/types/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-toolbar-button-renderer.d.ts

@@ -0,0 +1,113 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../../base-toolbar-button-renderer';
+/**
+ * Toolbar button renderer for the blockquote extension.
+ *
+ * Behaviors implemented:
+ * - Active (`selected`) when the caret/selection is inside any blockquote
+ *   ancestor.
+ * - Click wraps the current block(s) into a new `<blockquote>`, or unwraps
+ *   the nearest blockquote ancestor when active. Inside a list, the entire
+ *   list is wrapped (escalating to the outermost list block). With no
+ *   selection, a new empty blockquote is appended at the end and focused.
+ * - Disabled when the wrap container does not support the wrap strategy
+ *   (e.g. inside a code block or function block); the button remains
+ *   enabled inside a blockquote so it can be toggled off, and with no
+ *   selection so it can append a new blockquote.
+ * - Hidden in source-edit mode (inherited from {@link VegaRTEToolbarButtonRenderer}).
+ */
+export declare class RTEBlockquoteToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * @inheritDoc
+   */
+  render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  protected isSelected(editorContext: VegaRTEToolbarRenderContext): boolean;
+  /**
+   * @inheritDoc
+   */
+  protected isDisabled(editorContext: VegaRTEToolbarRenderContext): boolean;
+  /**
+   * @inheritDoc
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * @inheritDoc
+   */
+  protected handleDropdownClick(): void;
+  /**
+   * Append an empty paragraph wrapped in a new blockquote to the end of the
+   * content and place the caret inside it.
+   *
+   * @param {VegaRTEContent} content - Editor content to append to.
+   */
+  private appendEmptyBlockquote;
+  /**
+   * Wrap the selection's unique parent blocks into a new blockquote. Blocks
+   * inside a list or other nested container escalate to the top-level block.
+   * When the selection spans multiple top-level (root) blocks, any scoped
+   * container touched along the way (e.g. a table cell) is treated as an
+   * opaque block instead of an independent wrap target — the whole
+   * selection wraps as one, and any blockquote nested deeper than the
+   * top-level block (e.g. inside a table cell) is left untouched. Existing
+   * top-level blockquote blocks in the selection are merged (flattened)
+   * into the new one rather than nested.
+   *
+   * @param {RTENode[]} selectedNodes - Currently selected nodes.
+   */
+  private wrapSelectedBlocks;
+  /**
+   * Resolve the starting node of the current toolbar selection, if any.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - Render context.
+   * @returns {Nullable<RTENode>} The first selected node, or null.
+   */
+  private getStartNode;
+  /**
+   * Collect the unique closest blockquote ancestors of every selected node.
+   * Multiple selected nodes that share the same blockquote ancestor collapse
+   * into a single entry, so applying {@link RemoveBlockquoteAction} to each
+   * result unwraps every distinct blockquote in the selection exactly once.
+   *
+   * @param {RTENode[]} nodes - Selected nodes.
+   * @returns {Set<RTEBlockquoteBlock>} Unique blockquote ancestors, preserving insertion order.
+   */
+  private collectBlockquoteAncestors;
+  /**
+   * Walk up the block ancestors of the supplied node looking for an
+   * {@link RTEBlockquoteBlock}.
+   *
+   * @param {RTENode} node - Starting node.
+   * @returns {Nullable<RTEBlockquoteBlock>} The closest blockquote ancestor, or null.
+   */
+  private findBlockquoteAncestor;
+  /**
+   * Collect unique block ancestors (immediate parent blocks) from a list of
+   * selected nodes, preserving order of first appearance.
+   *
+   * @param {RTENode[]} nodes - Selected nodes.
+   * @returns {RTEBlock[]} Unique parent blocks.
+   */
+  private getUniqueBlocks;
+  /**
+   * Walk up from `block` to find the nearest ancestor that is a direct child
+   * of a container registered to handle {@link TRANSFORM_TO_BLOCKQUOTE}
+   * (e.g. {@link VegaRTEContent}, {@link RTETableCellBlock}).
+   *
+   * Stops as soon as the parent can handle the wrap action, so that blocks
+   * inside a table cell are scoped to the cell (not escalated to the root)
+   * while blocks inside a list are still escalated to the top-level list.
+   * Pass `forceRootScope` to ignore scoped containers and always escalate
+   * to the root — used when the overall selection spans multiple top-level
+   * blocks, so a table (or any other scoped container) is wrapped as a
+   * single opaque block alongside its siblings instead of independently.
+   *
+   * @param {RTEBlock} block - Immediate parent block of the selected node.
+   * @param {boolean} [forceRootScope] - Ignore scoped containers and escalate to the root.
+   * @returns {WrapAnchor} `wrapBlock` is the top-level ancestor when the block
+   *   is nested (otherwise null); `container` is the nearest wrap-capable parent.
+   */
+  private resolveWrapAnchor;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/find-replace-highlight-manager.d.ts

@@ -6,8 +6,9 @@ import type { FindMatch } from './find-replace-state';
  * jumping, and VegaChange events), this manager renders semi-transparent
  * highlight rectangles in an absolutely-positioned overlay container.
  *
- * The overlay lives inside `.rich-text-editor-container` (the RTE's scroll
- * container) so highlight divs scroll naturally with the text content.
+ * The overlay lives inside `vega-rich-text-content`'s internal
+ * `.rich-text-content` container (the actual text scroll coordinate space).
+ * This keeps highlight rectangles aligned when the editable area scrolls.
  * `pointer-events: none` ensures highlights don't interfere with user
  * interaction (selection, typing, clicking).
  *
@@ -34,14 +35,24 @@ export declare class FindReplaceHighlightManager {
    */
   clear(): void;
   /**
-   * Gets the existing overlay container or creates one inside the RTE's
-   * scroll container (`.rich-text-editor-container`).
+   * Gets the existing overlay container or creates one in the same coordinate
+   * space as rendered text.
+   *
+   * Mount target: `vega-rich-text-content` shadow root's
+   * `.rich-text-content` element (actual text scroll layer).
    *
    * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
    * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
    * @returns {HTMLDivElement | null} The overlay container, or null in SSR environments.
    */
   private getOrCreateOverlay;
+  /**
+   * Resolves the overlay mount target that matches the text rendering coordinate space.
+   *
+   * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
+   * @returns {Nullable<HTMLDivElement>} The preferred mount target or null.
+   */
+  private resolveOverlayMountTarget;
   /**
    * Creates absolutely-positioned highlight rectangles for a single node
    * position within a match.

package/dist/types/components/vega-rich-text-editor/extensions/fullscreen/assets/fullscreen-enter.d.ts

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;

package/dist/types/components/vega-rich-text-editor/extensions/fullscreen/assets/fullscreen-exit.d.ts

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;

package/dist/types/components/vega-rich-text-editor/extensions/fullscreen/controller/fullscreen-controller.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Controls fullscreen behavior and DOM manipulation for a single RTE host instance.
+ *
+ * One controller is bound to one host and owns all enter/exit side effects
+ * for that host.
+ *
+ * Strategy: set position:fixed on the host, and inject one <style> rule into
+ * its shadow root to override the inline height Stencil sets on the container.
+ * Exit just restores the original host style and removes the injected rule.
+ */
+export declare class FullscreenController {
+  private static readonly STYLE_TAG_ID;
+  private static readonly HOST_FULLSCREEN_STYLE;
+  /**
+   * Only three things need overriding inside the shadow root:
+   * 1. The outer vega-flex wrapper must fill the host height (`:host >`
+   *    avoids hitting the toolbar's nested vega-flex).
+   * 2. The editor container must grow to fill remaining space and drop
+   *    the fixed pixel height that Stencil injects from the `rows` prop.
+   * 3. The source-view container (shown in source-edit mode) also grows
+   *    and owns vertical scrolling so long source code is reachable.
+   * 4. overflow:auto on the container lets content scroll without clipping
+   *    internal pop-ups (link editor, color picker, etc.) at the host level.
+   */
+  private static readonly INNER_FULLSCREEN_CSS;
+  private static readonly documentScrollLockStates;
+  private readonly host;
+  private active;
+  private hostStyle;
+  private scrollX;
+  private scrollY;
+  constructor(host: HTMLVegaRichTextEditorElement);
+  /**
+   * Returns whether fullscreen mode is currently active.
+   *
+   * @returns {boolean} Whether fullscreen mode is active.
+   */
+  isActive(): boolean;
+  /**
+   * Enters fullscreen mode for the bound RTE host.
+   */
+  enterFullscreen(): void;
+  /**
+   * Exits fullscreen mode for the bound RTE host.
+   */
+  exitFullscreen(): void;
+  /**
+   * Toggles fullscreen mode for the bound RTE host.
+   */
+  toggleFullscreen(): void;
+  /**
+   * Locks document scrolling for the given document and records the first snapshot.
+   *
+   * @param {Document} ownerDocument - The document whose scroll should be locked.
+   */
+  private lockDocumentScroll;
+  /**
+   * Unlocks document scrolling when the last fullscreen owner exits.
+   *
+   * @param {Document} ownerDocument - The document whose scroll should be restored.
+   */
+  private unlockDocumentScroll;
+}

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

@@ -0,0 +1,20 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { FullscreenController } from './controller/fullscreen-controller';
+import { RTEExtensionStateStore } from '../rte-extension-state-store';
+/**
+ * Rich Text Editor extension that adds a toolbar button for viewport fullscreen mode.
+ *
+ * OOP Pattern: Extends VegaRTEExtension with fullscreen feature.
+ * Uses a per-host controller store to isolate state across hosts.
+ */
+export declare class VegaRTEFullscreenExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
+  static readonly controllerStore: RTEExtensionStateStore<FullscreenController>;
+  /** @inheritDoc */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
+  /**
+   * Restore document scroll if the editor is removed while fullscreen is active.
+   * Without this, body overflow:hidden would persist after the host is gone.
+   */
+  destroyExtension(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/fullscreen/fullscreen-toolbar-button-renderer.d.ts

@@ -0,0 +1,40 @@
+import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
+import { VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../interface';
+import { FullscreenController } from './controller/fullscreen-controller';
+/**
+ * Toolbar button renderer for fullscreen toggle.
+ */
+export declare class RTEFullscreenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  private readonly controller;
+  constructor(controller: FullscreenController);
+  /**
+   * Always shows the fullscreen button.
+   *
+   * @returns {boolean} Always false for hidden state.
+   */
+  isHidden(): boolean;
+  /**
+   * Renders the fullscreen toolbar button with current state.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - Toolbar render context.
+   * @returns {VegaRTERenderResult} The toolbar button render result.
+   */
+  render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Returns whether fullscreen mode is currently active.
+   *
+   * @returns {boolean} Whether fullscreen mode is active.
+   */
+  protected isSelected(): boolean;
+  /**
+   * Toggles fullscreen mode and forces toolbar button refresh.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - Toolbar render context.
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * No dropdown behavior for fullscreen button.
+   */
+  protected handleDropdownClick(): void;
+}