@globalpayments/vega 2.92.0 → 2.93.0

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/action-handler-interceptors/blockquote-exit-on-enter-interceptor.js

@@ -0,0 +1,61 @@
+import RTEDTOClassManager from '../../../../../helpers/rte-manager/dto-class-manager';
+import { generateUUID } from '../../../../../utils/misc';
+import { ActionHandlerInterceptor, } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-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 class BlockquoteExitOnEnterInterceptor extends ActionHandlerInterceptor {
+  /**
+   * 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, target) {
+    const parent = target.parent;
+    return (parent instanceof RTEBlockquoteBlock &&
+      !target.isNotEmpty() &&
+      parent.children[parent.children.length - 1] === target);
+  }
+  /**
+   * 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, action, target) {
+    const blockquote = target.parent;
+    const newParagraph = this.createNewParagraph('');
+    if (newParagraph) {
+      // Insert the replacement paragraph after the blockquote before removing the
+      // empty one so the blockquote is still present as an anchor for the insert.
+      blockquote.parent.apply(new InsertChildrenAfterAction(blockquote, newParagraph));
+      blockquote.apply(new RemoveChildrenAction(target));
+      action.newBlock = newParagraph;
+    }
+  }
+  /**
+   * Create a new empty paragraph block.
+   *
+   * @param {string} text - paragraph text
+   * @returns {Nullable<RTETextBlock>} - paragraph block when paragraph dto class is available
+   */
+  createNewParagraph(text) {
+    const dtoClass = RTEDTOClassManager.getRTEBlockClass('paragraph');
+    if (dtoClass) {
+      return dtoClass.from({
+        id: generateUUID(),
+        type: 'paragraph',
+        nodes: [{ id: generateUUID(), type: 'text', text }],
+      });
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/action-handler-strategies/block-transform-to-blockquote-strategy.js

@@ -0,0 +1,40 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+/**
+ * Wrap the selected blocks into a new `<blockquote>` block while preserving
+ * their order.
+ */
+export class BlockTransformToBlockquoteStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const selectedBlocks = action.selectedBlocks;
+    const children = target.children;
+    const selectedSet = new Set(selectedBlocks);
+    const firstIndex = children.indexOf(selectedBlocks[0]);
+    // The selected blocks may not be contiguous in `children` (e.g. a table
+    // sitting between two selected paragraphs must stay untouched), so the
+    // insert position is the first selected block's index, adjusted for any
+    // non-selected siblings that come before it.
+    const insertIndex = children
+      .slice(0, firstIndex)
+      .filter((block) => !selectedSet.has(block)).length;
+    const blockquote = new RTEBlockquoteBlock(generateUUID());
+    blockquote.parent = target;
+    blockquote.children = selectedBlocks;
+    selectedBlocks.forEach((block) => {
+      block.parent = blockquote;
+    });
+    // Remove selected blocks individually rather than assuming a single
+    // contiguous run, so non-selected siblings interleaved with the
+    // selection (e.g. a table) are preserved instead of being spliced away.
+    for (let i = children.length - 1; i >= 0; i--) {
+      if (selectedSet.has(children[i])) {
+        children.splice(i, 1);
+      }
+    }
+    children.splice(insertIndex, 0, blockquote);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/action-handler-strategies/remove-blockquote-strategy.js

@@ -0,0 +1,20 @@
+import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Unwrap a `<blockquote>` — lift its children to the parent in their original
+ * order and remove the blockquote.
+ */
+export class RemoveBlockquoteStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(_action, target) {
+    const parent = target.parent;
+    const childrenToLift = [...target.children];
+    if (childrenToLift.length > 0) {
+      parent.apply(new InsertChildrenBeforeAction(target, ...childrenToLift));
+    }
+    parent.apply(new RemoveChildrenAction(target));
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/actions/remove-blockquote-action.js

@@ -0,0 +1,17 @@
+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 const REMOVE_BLOCKQUOTE = 'REMOVE_BLOCKQUOTE';
+/**
+ * Unwrap a `<blockquote>` block — lift its children into the parent in place
+ * and remove the blockquote wrapper. Targets the blockquote block itself.
+ */
+export class RemoveBlockquoteAction extends ModifyContentAction {
+  constructor() {
+    super(...arguments);
+    this.isFlushable = true;
+    this.type = REMOVE_BLOCKQUOTE;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/actions/transform-to-blockquote-action.js

@@ -0,0 +1,19 @@
+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 const TRANSFORM_TO_BLOCKQUOTE = 'TRANSFORM_TO_BLOCKQUOTE';
+/**
+ * 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 class TransformToBlockquoteAction extends ModifyContentAction {
+  constructor(selectedBlocks) {
+    super();
+    this.isFlushable = true;
+    this.type = TRANSFORM_TO_BLOCKQUOTE;
+    this.selectedBlocks = selectedBlocks;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/assets/quote-left.js

@@ -0,0 +1,4 @@
+// FontAwesome 7.2.0 — `quote-left` (solid).
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><path fill="currentColor" d="M0 216C0 149.7 53.7 96 120 96l8 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-8 0c-30.9 0-56 25.1-56 56l0 8 64 0c35.3 0 64 28.7 64 64l0 64c0 35.3-28.7 64-64 64l-64 0c-35.3 0-64-28.7-64-64L0 216zm256 0c0-66.3 53.7-120 120-120l8 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-8 0c-30.9 0-56 25.1-56 56l0 8 64 0c35.3 0 64 28.7 64 64l0 64c0 35.3-28.7 64-64 64l-64 0c-35.3 0-64-28.7-64-64l0-136z"/></svg>`,
+};

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

@@ -0,0 +1,47 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { VegaRTEContent } from '../../dto/content-state';
+import { RTETableCellBlock } from '../table/dto/table-cell-block';
+import { RTETableHeadCellBlock } from '../table/dto/table-head-cell-block';
+import { ModifyContentActionType } from '../../dto/actions/modify-content-action.abstract';
+import { RTETextBlock } from '../../dto/blocks/text-block';
+import { BlockTransformToBlockquoteStrategy } from './action-handler-strategies/block-transform-to-blockquote-strategy';
+import { RemoveBlockquoteStrategy } from './action-handler-strategies/remove-blockquote-strategy';
+import { BlockquoteExitOnEnterInterceptor } from './action-handler-interceptors/blockquote-exit-on-enter-interceptor';
+import { TRANSFORM_TO_BLOCKQUOTE } from './actions/transform-to-blockquote-action';
+import { REMOVE_BLOCKQUOTE } from './actions/remove-blockquote-action';
+import { RTEBlockquoteBlock } from './dto/rte-blockquote-block';
+import { BlockquoteToBlockquoteBlockStrategy } from './element-to-dto-strategies/blockquote-to-blockquote-block-strategy';
+import RTEBlockquoteBlockRenderer from './renderers/blockquote-block-renderer';
+import { RTEBlockquoteToolbarButtonRenderer } from './renderers/blockquote-toolbar-button-renderer';
+import { BlockquoteFilterStylesStrategy } from './filter-styles-strategies/blockquote-block/blockquote-filter-styles-strategy';
+/**
+ * Adds `<blockquote>` support to the Vega Rich Text Editor.
+ */
+export class VegaRTEBlockquoteExtension extends VegaRTEExtension {
+  constructor() {
+    super();
+    this.toolbarButtonRenderer = new RTEBlockquoteToolbarButtonRenderer();
+    this.registerBlockBasicStrategies(RTEBlockquoteBlock.name);
+    this.registerNode('blockquote', RTEBlockquoteBlock);
+    this.registerRenderer('blockquote', RTEBlockquoteBlockRenderer);
+    this.registerToolbarButtonRenderer(VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY, this.toolbarButtonRenderer);
+    this.registerElementToBlockDTOClassStrategy(new BlockquoteToBlockquoteBlockStrategy());
+    // Register filter styles strategy for source edit round-trip.
+    VegaRTEExtension.registerFilterStylesStrategy(RTEBlockquoteBlock.dtoName, new BlockquoteFilterStylesStrategy());
+  }
+}
+(() => {
+  const wrapStrategy = new BlockTransformToBlockquoteStrategy();
+  // Root container — wrap top-level blocks.
+  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  // Table cells (body + header) — wrap is scoped to the closest cell.
+  // Other container blocks (code, list item, function) are intentionally
+  // not registered, so the toolbar stays disabled inside them.
+  VegaRTEExtension.registerActionHandleStrategy(RTETableCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETableHeadCellBlock.name, TRANSFORM_TO_BLOCKQUOTE, wrapStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEBlockquoteBlock.name, REMOVE_BLOCKQUOTE, new RemoveBlockquoteStrategy());
+  // Enables exiting the blockquote via the keyboard: pressing Enter on an empty
+  // trailing paragraph breaks out to a new paragraph after the blockquote.
+  VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new BlockquoteExitOnEnterInterceptor());
+})();
+VegaRTEBlockquoteExtension.TOOLBAR_BUTTON_KEY = 'blockquote';

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/dto/blockquote-annotation.js

@@ -0,0 +1,76 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { camelToDashCase } from '../../../../../utils/string';
+export var RTEBlockquoteExtensionAnnotationTypeEnum;
+(function (RTEBlockquoteExtensionAnnotationTypeEnum) {
+  RTEBlockquoteExtensionAnnotationTypeEnum["BLOCKQUOTE"] = "BLOCKQUOTE";
+})(RTEBlockquoteExtensionAnnotationTypeEnum || (RTEBlockquoteExtensionAnnotationTypeEnum = {}));
+/**
+ * CSS class applied to `<blockquote>` elements rendered inside the editor.
+ */
+export const BLOCKQUOTE_CLASS_NAME = 'v-rte-blockquote';
+/**
+ * Default visual styles for the `<blockquote>` element in the RTE.
+ */
+export const BLOCKQUOTE_DEFAULT_STYLES = {
+  overflow: 'hidden',
+  marginInline: '0',
+  paddingInline: '24px',
+  borderInlineStart: 'solid 5px hsl(0, 0%, 80%)',
+};
+/**
+ * Blockquote annotation.
+ */
+export class BlockquoteAnnotation extends BlockAnnotation {
+  constructor() {
+    super(...arguments);
+    this.type = RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE;
+  }
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, BlockquoteAnnotation]} Map item.
+   */
+  static from() {
+    return [RTEBlockquoteExtensionAnnotationTypeEnum.BLOCKQUOTE, new BlockquoteAnnotation()];
+  }
+  /**
+   * Get the default CSS rule for the blockquote element.
+   *
+   * @returns {string} The default CSS rule.
+   */
+  static getDefaultCssText() {
+    const declarations = Object.entries(BLOCKQUOTE_DEFAULT_STYLES)
+      .map(([key, value]) => `\t${camelToDashCase(key)}: ${value};`)
+      .join('\n');
+    return `.${BLOCKQUOTE_CLASS_NAME} {\n${declarations}\n}`;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    // Blockquote identity is captured by the block type; nothing to serialize.
+    return null;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new BlockquoteAnnotation();
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return BLOCKQUOTE_CLASS_NAME;
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return BLOCKQUOTE_DEFAULT_STYLES;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/dto/rte-blockquote-block.js

@@ -0,0 +1,70 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { BlockquoteAnnotation } from './blockquote-annotation';
+/**
+ * DTO representing a `<blockquote>` block.
+ */
+export class RTEBlockquoteBlock extends RTEBlock {
+  constructor(id, options) {
+    super(id);
+    this.dtoName = RTEBlockquoteBlock.dtoName;
+    this.type = 'blockquote';
+    this.children = [];
+    const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
+    if (autoMatchFormat) {
+      this.annotationMap = new Map([BlockquoteAnnotation.from()]);
+    }
+  }
+  /**
+   * 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, options) {
+    const blockquote = new RTEBlockquoteBlock(block.id, options);
+    if (block.annotations) {
+      RTEBlock.convertAnnotationsToMap(blockquote.annotationMap, block.annotations);
+    }
+    blockquote.children = RTEBlock.generateBlockChildren(block.children, options, blockquote);
+    return blockquote;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const cloned = new RTEBlockquoteBlock(this.id);
+    const clonedAsChildParent = cloned;
+    cloned.children = this.children.map((child) => child.clone(clonedAsChildParent));
+    cloned.annotationMap = this.cloneAnnotations();
+    cloned.parent = parent;
+    return cloned;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1].getLastNode();
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    return this.children.length > 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    const attrStr = this.generateAttributeString(options);
+    const inner = this.children.map((child) => child.toHtml(options)).join('');
+    return `<blockquote${attrStr}>${inner}</blockquote>`;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: 'blockquote', children: this.children.map((child) => child.toJSON()) });
+  }
+}
+RTEBlockquoteBlock.dtoName = 'RTEBlockquoteBlock';

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/element-to-dto-strategies/blockquote-to-blockquote-block-strategy.js

@@ -0,0 +1,53 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import htmlElementToAnnotationGenerator from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
+import { RTEBlockquoteBlock } from '../dto/rte-blockquote-block';
+/**
+ * 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 class BlockquoteToBlockquoteBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    return elementsArray[currentIndex].tagName === 'BLOCKQUOTE' ? 1 : 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray, options) {
+    const element = elementsArray[0];
+    const annotations = htmlElementToAnnotationGenerator.generate(RTEBlockquoteBlock, element, options);
+    return RTEBlockquoteBlock.from({
+      id: generateUUID(),
+      type: 'blockquote',
+      annotations,
+      children: [],
+    }, options);
+  }
+  /**
+   * 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, childBlocks) {
+    const flattened = childBlocks.flatMap((child) => child instanceof RTEBlockquoteBlock ? child.children : [child]);
+    currentBlock.children = flattened.map((block) => {
+      block.parent = currentBlock;
+      return block;
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren() {
+    return true;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/filter-styles-strategies/blockquote-block/blockquote-filter-styles-strategy.js

@@ -0,0 +1,41 @@
+import { RTEFilterStylesStrategy, } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+import { BLOCKQUOTE_DEFAULT_STYLES } from '../../dto/blockquote-annotation';
+/**
+ * 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 class BlockquoteFilterStylesStrategy extends RTEFilterStylesStrategy {
+  constructor() {
+    super(...arguments);
+    this.stylesToBeFiltered = BLOCKQUOTE_DEFAULT_STYLES;
+    this.elementTagName = 'blockquote';
+  }
+  /**
+   * 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.
+   */
+  static isBlockquoteBlock(className) {
+    return className === 'RTEBlockquoteBlock';
+  }
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance) {
+    return BlockquoteFilterStylesStrategy.isBlockquoteBlock(blockOrNodeInstance.dtoName);
+  }
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName, element) {
+    return element.tagName.toLowerCase() === this.elementTagName;
+  }
+  /**
+   * @inheritDoc
+   */
+  toCssText() {
+    return this.buildCssTextForStyles(this.elementTagName, this.classNameToBeAdded);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/blockquote/renderers/blockquote-block-renderer.js

@@ -0,0 +1,21 @@
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { BlockquoteAnnotation } from '../dto/blockquote-annotation';
+/**
+ * Renderer for blockquote blocks in the rich text editor.
+ */
+export class RTEBlockquoteBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(createElement, block, rteContext) {
+    var _a;
+    return createElement('blockquote', Object.assign({ key: block.id, class: block.getClasses(rteContext), style: block.getStyles(rteContext), ref: this.useRef(block) }, (_a = block.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.render()));
+  }
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles() {
+    return BlockquoteAnnotation.getDefaultCssText();
+  }
+}
+export default new RTEBlockquoteBlockRenderer();