@globalpayments/vega 2.97.0 → 2.99.0

package/dist/collection/components/vega-rich-text-editor/extensions/block-boundary-registry.js

@@ -0,0 +1,34 @@
+/**
+ * Per-editor registry for block-boundary predicates contributed by extensions.
+ */
+export class BlockBoundaryRegistry {
+  constructor() {
+    this.predicates = new Set();
+  }
+  /**
+   * Register a block-boundary predicate.
+   *
+   * @param {BlockBoundaryPredicate} predicate - Predicate to register.
+   * @returns {() => void} Unregister callback.
+   */
+  register(predicate) {
+    this.predicates.add(predicate);
+    return () => {
+      this.predicates.delete(predicate);
+    };
+  }
+  /**
+   * Returns true when any registered predicate marks the element as a boundary.
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @returns {boolean} Whether the element is a boundary.
+   */
+  isBoundary(element) {
+    for (const predicate of this.predicates) {
+      if (predicate(element)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

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

@@ -10,6 +10,7 @@ import { methodPlaceholder } from 'vega-slimmer/core';
 import htmlElementToAnnotationGenerator from '../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
 import { RTEFilterStylesStrategyRegistry } from '../dto/filter-styles-strategies/filter-styles-strategy-registry';
 import { RTEExtensionStateStore } from './rte-extension-state-store';
+import stateEntityRenderingRegistry from '../slimmers/controllers/state-entity-rendering-registry';
 const patchedBlockClasses = new WeakSet();
 const annotationHandlersByClass = new WeakMap();
 /**
@@ -258,4 +259,23 @@ export class VegaRTEExtension {
   registerAnnotationHandler(handler) {
     htmlElementToAnnotationGenerator.registerHandler(handler);
   }
+  /**
+   * Register an extension-defined block-boundary predicate for the current editor instance.
+   *
+   * @param {BlockBoundaryPredicate} predicate - Predicate to register.
+   * @returns {Nullable<() => void>} Unregister callback when context is available.
+   */
+  registerBlockBoundaryPredicate(predicate) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.blockBoundaryRegistry) === null || _b === void 0 ? void 0 : _b.register(predicate)) !== null && _c !== void 0 ? _c : null;
+  }
+  /**
+   * Get the registered dto by dom element.
+   *
+   * @param {HTMLElement} el - The DOM element to get the registered DTO for.
+   * @returns {Nullable<RTENode | RTEBlock>} - The registered DTO associated with the DOM element.
+   */
+  getDTOEntityByDom(el) {
+    return stateEntityRenderingRegistry.getEntityByDOM(el);
+  }
 }

package/dist/collection/components/vega-rich-text-editor/extensions/functions/action-handler-strategies/insert-function-block-strategy.js

@@ -4,6 +4,7 @@ import { generateUUID } from '../../../../../utils/misc';
 import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
 import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
 import { RTEFunctionBlock } from '../dto/function-block';
+import { FUNCTION_CONTENT_CLASS } from '../constants';
 /**
  * Strategy to handle the insertion of a function block into the rich text editor.
  */
@@ -46,7 +47,7 @@ export class InsertFunctionBlockStrategy extends ActionHandleStrategy {
         {
           id: `${id}-2`,
           annotations: {
-            customClass: ['statementelement'],
+            customClass: [FUNCTION_CONTENT_CLASS],
           },
           type: 'paragraph',
           nodes: [
@@ -65,7 +66,7 @@ export class InsertFunctionBlockStrategy extends ActionHandleStrategy {
         {
           id: `${id}-4`,
           annotations: {
-            customClass: ['statementelement'],
+            customClass: [FUNCTION_CONTENT_CLASS],
           },
           type: 'paragraph',
           nodes: [

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

@@ -0,0 +1,8 @@
+export const FUNCTION_BLOCK_CLASS = 'statement';
+export const FUNCTION_CONTENT_CLASS = 'statementelement';
+export const FUNCTION_SYNTAX_CLASS = 'statementsyntax';
+export const FUNCTION_ELEMENT_CLASSES = [
+  FUNCTION_BLOCK_CLASS,
+  FUNCTION_CONTENT_CLASS,
+  FUNCTION_SYNTAX_CLASS,
+];

package/dist/collection/components/vega-rich-text-editor/extensions/functions/dto/function-block.js

@@ -2,6 +2,8 @@ import { generateUUID } from '../../../../../utils/misc';
 import { RTEAnnotationStyle } from '../../../dto/annotations/annotation-style';
 import { RTEBlock } from '../../../dto/blocks/block.abstract';
 import { RTETextBlock } from '../../../dto/blocks/text-block';
+import { FUNCTION_BLOCK_CLASS, FUNCTION_CONTENT_CLASS } from '../constants';
+import { RTE_BLOCK_BOUNDARY_ATTRIBUTE } from '../../../constants/constant';
 /**
  * RTE Function Block
  */
@@ -21,7 +23,7 @@ export class RTEFunctionBlock extends RTEBlock {
    */
   static from(block, options) {
     const functionBlock = new RTEFunctionBlock(block.id);
-    const defaultAnnotation = { customClass: ['statement'] };
+    const defaultAnnotation = { customClass: [FUNCTION_BLOCK_CLASS] };
     let { annotations } = block;
     annotations = annotations
       ? Object.assign(Object.assign({}, annotations), defaultAnnotation) : defaultAnnotation;
@@ -39,14 +41,14 @@ export class RTEFunctionBlock extends RTEBlock {
       .map((child) => {
       if (child instanceof RTETextBlock) {
         const attrStr = this.getFunctionContentStyle(child);
-        return `<div class="statementelement"${attrStr}>${child.getChildrenHtml()}</div>`;
+        return `<div class="${FUNCTION_CONTENT_CLASS}"${attrStr}>${child.getChildrenHtml()}</div>`;
       }
       else {
         return child.toHtml();
       }
     })
       .join('');
-    return `<div class="statement">${childrenHtml}</div>`;
+    return `<div class="${FUNCTION_BLOCK_CLASS}" ${RTE_BLOCK_BOUNDARY_ATTRIBUTE}>${childrenHtml}</div>`;
   }
   /**
    * @inheritDoc
@@ -67,6 +69,15 @@ export class RTEFunctionBlock extends RTEBlock {
   getLastNode() {
     return this.children[this.children.length - 1].getLastNode();
   }
+  /**
+   * The function block is an atomic caret boundary: descending would resolve the caret onto a
+   * `contenteditable="false"` logic-control node instead of staying anchored to the block.
+   *
+   * @inheritDoc
+   */
+  allowsCaretDescend() {
+    return false;
+  }
   /**
    * @inheritDoc
    */

package/dist/collection/components/vega-rich-text-editor/extensions/functions/dto/logic-control-block.js

@@ -1,4 +1,5 @@
 import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { FUNCTION_SYNTAX_CLASS } from '../constants';
 import { RTELogicControlNode } from '../dto/logic-control-node';
 /**
  * Class representing a logic control block in the rich text editor.
@@ -48,7 +49,7 @@ export class RTELogicControlBlock extends RTEBlock {
    * @returns {string} - The HTML string of the logic control block.
    */
   toHtml() {
-    return `<div class='statementsyntax' contenteditable='false'>${this.statementText}</div>`;
+    return `<div class='${FUNCTION_SYNTAX_CLASS}' contenteditable='false'>${this.statementText}</div>`;
   }
   /**
    * Clone the current block instance.

package/dist/collection/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-containing-function-block-strategy.js

@@ -0,0 +1,19 @@
+import { HtmlBlockStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/html-block-strategy';
+import { FUNCTION_BLOCK_CLASS } from '../constants';
+import { RTE_BLOCK_BOUNDARY_ATTRIBUTE } from '../../../constants/constant';
+import { isFunctionBlockElement } from '../utils';
+/** Preserve a div that contains a function block during auto-formatting. */
+export class FunctionBlockContainerStrategy extends HtmlBlockStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    if (element.nodeType !== Node.ELEMENT_NODE)
+      return 0;
+    const containsFunctionBlock = !!element.querySelector(`[${RTE_BLOCK_BOUNDARY_ATTRIBUTE}], .${FUNCTION_BLOCK_CLASS}`);
+    return element.nodeName === 'DIV' && !isFunctionBlockElement(element) && containsFunctionBlock
+      ? 1
+      : 0;
+  }
+}

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

@@ -1,6 +1,8 @@
 import { generateUUID } from '../../../../../utils/misc';
 import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
 import { RTEFunctionBlock } from '../dto/function-block';
+import { FUNCTION_BLOCK_CLASS, FUNCTION_SYNTAX_CLASS } from '../constants';
+import { isFunctionBoundaryContainer } from '../utils';
 /**
  * Strategy to convert a div with class 'statement' into an function block.
  */
@@ -10,11 +12,13 @@ export class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
    */
   canHandle(elementsArray, currentIndex) {
     const element = elementsArray[currentIndex];
-    return element &&
-      element.tagName === 'DIV' &&
-      element.classList.contains('statement') &&
+    if (element.nodeType !== Node.ELEMENT_NODE)
+      return 0;
+    const isFunctionBoundary = isFunctionBoundaryContainer(element);
+    return element.tagName === 'DIV' &&
+      isFunctionBoundary &&
       element.childNodes.length &&
-      element.querySelector('.statementsyntax')
+      element.querySelector(`.${FUNCTION_SYNTAX_CLASS}`)
       ? 1
       : 0;
   }
@@ -26,7 +30,7 @@ export class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
       id: generateUUID(),
       type: 'function-block',
       annotations: {
-        customClass: ['statement'],
+        customClass: [FUNCTION_BLOCK_CLASS],
       },
       children: [],
     });

package/dist/collection/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-to-function-content-strategy.js

@@ -2,13 +2,14 @@ import { generateUUID } from '../../../../../utils/misc';
 import { RTETextBlock } from '../../../dto/blocks/text-block';
 import htmlElementToAnnotationGenerator from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
 import { DivToLogicControlBlockStrategy } from './div-to-logic-control-block-strategy';
+import { FUNCTION_CONTENT_CLASS } from '../constants';
 /**
  * Strategy to convert a div with class 'statementelement' into an function block.
  */
 export class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementelement';
+    this.blockClassName = FUNCTION_CONTENT_CLASS;
   }
   /**
    * @inheritDoc
@@ -16,12 +17,11 @@ export class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy
   handle(elementsArray, options) {
     const element = elementsArray[0];
     const annotations = htmlElementToAnnotationGenerator.generate(RTETextBlock, element);
-    const nodes = Array.from(elementsArray[0].childNodes);
     return RTETextBlock.from({
       id: generateUUID(),
       type: 'paragraph',
       annotations: Object.assign({ customClass: [this.blockClassName] }, annotations),
-      nodes: this.generateChildNodes(nodes, undefined, options),
+      nodes: this.generateChildNodes(Array.from(elementsArray[0].childNodes), undefined, options),
     });
   }
 }

package/dist/collection/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-to-logic-control-block-strategy.js

@@ -1,13 +1,15 @@
 import { generateUUID } from '../../../../../utils/misc';
 import { RTELogicControlBlock } from '../dto/logic-control-block';
 import { BlockToRTEBlockStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
+import { FUNCTION_SYNTAX_CLASS } from '../constants';
+import { isFunctionBoundaryContainer } from '../utils';
 /**
  * Strategy to convert a div with class 'statementsyntax' into an RTELogicControlBlock DTO.
  */
 export class DivToLogicControlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementsyntax';
+    this.blockClassName = FUNCTION_SYNTAX_CLASS;
   }
   /**
    * @inheritDoc
@@ -50,6 +52,6 @@ export class DivToLogicControlBlockStrategy extends BlockToRTEBlockStrategyAbstr
    * @returns {boolean} True if the element is a child of a function block, false otherwise
    */
   isFunctionBlockChild(element) {
-    return !!(element.parentElement && element.parentElement.classList.contains('statement'));
+    return !!(element.parentElement && isFunctionBoundaryContainer(element.parentElement));
   }
 }

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

@@ -10,6 +10,7 @@ import { RTELogicControlBlockRenderer } from './renderers/logic-control-block-re
 import { DivToLogicControlBlockStrategy } from './element-to-dto-strategies/div-to-logic-control-block-strategy';
 import { DivToFunctionBlockStrategy } from './element-to-dto-strategies/div-to-function-block-strategy';
 import { DivToFunctionContentStrategy } from './element-to-dto-strategies/div-to-function-content-strategy';
+import { FunctionBlockContainerStrategy } from './element-to-dto-strategies/div-containing-function-block-strategy';
 import { RTEFunctionBlock } from './dto/function-block';
 import { RTEFunctionBlockRenderer } from './renderers/function-block-renderer';
 import { ModifyContentActionType } from '../../dto/actions/modify-content-action.abstract';
@@ -18,15 +19,18 @@ import { FunctionBlockInsertParagraphStrategy } from './action-handler-strategie
 import { PreventPasteContentInterceptor } from './action-handler-interceptor/prevent-paste-content-interceptor';
 import { PASTE_PLAIN_TEXT } from './actions/paste-plain-text-action';
 import { PastePlainTextStrategy } from './action-handler-strategies/paste-plain-text-strategy';
+import { isFunctionBlockElement } from './utils';
 const convertLogicControlBlockStrategy = new DivToLogicControlBlockStrategy();
 const convertFunctionContentStrategy = new DivToFunctionContentStrategy();
 const convertFunctionBlockStrategy = new DivToFunctionBlockStrategy();
+const convertFunctionBlockContainerStrategy = new FunctionBlockContainerStrategy();
 /**
  * Function extension class for Vega Rich Text Editor.
  */
 export class VegaRTEFunctionExtension extends VegaRTEExtension {
   constructor() {
     super();
+    this.unregisterBlockBoundaryPredicate = null;
     this.registerBlockBasicStrategies(RTELogicControlBlock.name);
     this.registerBlockBasicStrategies(RTEFunctionBlock.name);
     this.preventFunctionBlockDefaultInsertNewParagraph();
@@ -37,11 +41,25 @@ export class VegaRTEFunctionExtension extends VegaRTEExtension {
     this.registerElementToBlockDTOClassStrategy(convertLogicControlBlockStrategy);
     this.registerElementToBlockDTOClassStrategy(convertFunctionContentStrategy);
     this.registerElementToBlockDTOClassStrategy(convertFunctionBlockStrategy);
+    this.registerElementToBlockDTOClassStrategy(convertFunctionBlockContainerStrategy);
   }
   /** @inheritDoc */
   prepareBeforeLoad(host) {
     this.registerToolbarButtonRenderer(VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY, new FunctionToolbarButtonRenderer(), host);
   }
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context) {
+    var _a;
+    super.initialExtensionAfterLoad(context);
+    (_a = this.unregisterBlockBoundaryPredicate) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unregisterBlockBoundaryPredicate = this.registerBlockBoundaryPredicate(isFunctionBlockElement);
+  }
+  /** @inheritDoc */
+  destroyExtension() {
+    var _a;
+    (_a = this.unregisterBlockBoundaryPredicate) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unregisterBlockBoundaryPredicate = null;
+  }
   /**
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
    */

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

@@ -1,4 +1,6 @@
 import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { FUNCTION_BLOCK_CLASS } from '../constants';
+import { RTE_BLOCK_BOUNDARY_ATTRIBUTE } from '../../../constants/constant';
 import styles from './function-block-styles.css';
 /**
  * Renderer for Function Block
@@ -11,6 +13,7 @@ export class RTEFunctionBlockRenderer extends VegaRTEExtensionRenderer {
     return createElement('div', {
       key: renderData.id,
       class: this.getElementClassName(renderData),
+      [RTE_BLOCK_BOUNDARY_ATTRIBUTE]: '',
       ref: this.useRef(renderData),
     });
   }
@@ -30,8 +33,8 @@ export class RTEFunctionBlockRenderer extends VegaRTEExtensionRenderer {
    */
   getElementClassName(block) {
     let classes = block.getClasses();
-    if (classes.indexOf('statement') < 0) {
-      classes = 'statement ' + classes;
+    if (classes.indexOf(FUNCTION_BLOCK_CLASS) < 0) {
+      classes = FUNCTION_BLOCK_CLASS + ' ' + classes;
     }
     return classes.trim();
   }

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

@@ -1,4 +1,5 @@
 import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { FUNCTION_SYNTAX_CLASS } from '../constants';
 /**
  * Renders a logic control block in the rich text editor.
  */
@@ -9,7 +10,7 @@ export class RTELogicControlBlockRenderer extends VegaRTEExtensionRenderer {
   doRender(h, renderData) {
     return h('div', {
       key: renderData.id,
-      class: 'statementsyntax',
+      class: FUNCTION_SYNTAX_CLASS,
       ref: this.useRef(renderData),
     }, h('span', {
       key: `${renderData.id}-1`,

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

@@ -0,0 +1,36 @@
+import { RTE_BLOCK_BOUNDARY_ATTRIBUTE } from '../../constants/constant';
+import { FUNCTION_BLOCK_CLASS, FUNCTION_ELEMENT_CLASSES } from './constants';
+/**
+ * Returns true when the element belongs to function extension blocks by semantic
+ * boundary attribute or known function element classes.
+ *
+ * Use this helper for broad detection (e.g., extension-level boundary predicate
+ * registration) where both container and child function elements should be
+ * treated as part of the function block structure.
+ *
+ * @param {HTMLElement} element - Element to inspect.
+ * @returns {boolean} Whether the element belongs to a function block structure.
+ * @example
+ * this.registerBlockBoundaryPredicate(isFunctionBlockElement);
+ */
+export const isFunctionBlockElement = (element) => {
+  return (element.hasAttribute(RTE_BLOCK_BOUNDARY_ATTRIBUTE) ||
+    FUNCTION_ELEMENT_CLASSES.some((functionClass) => element.classList.contains(functionClass)));
+};
+/**
+ * Returns true when the element is a function block boundary container.
+ *
+ * Use this helper when conversion logic must identify only the function block
+ * container element (the DIV that maps to RTEFunctionBlock), not function child
+ * elements such as syntax/content nodes.
+ *
+ * @param {HTMLElement} element - Element to inspect.
+ * @returns {boolean} Whether the element is a function block boundary container.
+ * @example
+ * if (isFunctionBoundaryContainer(element)) {
+ *     // map the DIV to RTEFunctionBlock
+ * }
+ */
+export const isFunctionBoundaryContainer = (element) => {
+  return (element.hasAttribute(RTE_BLOCK_BOUNDARY_ATTRIBUTE) || element.classList.contains(FUNCTION_BLOCK_CLASS));
+};

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

@@ -130,6 +130,7 @@ export class VegaRTELanguageExtension extends VegaRTEExtension {
           options = {
             autoMatchFormat: (_a = host.sourceEditConfig.autoMatchFormat) !== null && _a !== void 0 ? _a : true,
             filterInlineStyles: host.sourceEditConfig.filterInlineStyles,
+            blockBoundaryRegistry: this.extensionContext.blockBoundaryRegistry,
           };
         }
         result = VegaRTEContent.fromHtml(codeBlock.value.code, options);

package/dist/collection/components/vega-rich-text-editor/extensions/paste/action-handler-strategies/image-replace-src-strategy.js

@@ -0,0 +1,21 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { PasteImageParser } from '../parse-local-images-helper/paste-image-parser';
+/**
+ * Strategy to handle the `ImageReplaceSrcAction` for replacing the `src` attribute of an `<img>` element in the RTE content.
+ */
+export class ImageReplaceSrcStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const { img, url } = action;
+    img.setAttribute('src', url);
+    img.removeAttribute(PasteImageParser.PREVIEW_IMG_KEY);
+    target.url = url;
+    if (target.annotationMap && target.annotationMap.has('CUSTOM_ATTRIBUTE')) {
+      const customAttributeAnnotation = target.annotationMap.get('CUSTOM_ATTRIBUTE');
+      customAttributeAnnotation.customAttribute.src = url;
+      delete customAttributeAnnotation.customAttribute[PasteImageParser.PREVIEW_IMG_KEY];
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/paste/actions/image-replace-src-action.js

@@ -0,0 +1,13 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export const REPLACE_IMAGE_SRC = 'REPLACE_IMAGE_SRC';
+/**
+ * Action to replace the `src` attribute of an `<img>` element in the RTE content.
+ */
+export class ImageReplaceSrcAction extends ModifyContentAction {
+  constructor(imageElement, url) {
+    super();
+    this.type = REPLACE_IMAGE_SRC;
+    this.img = imageElement;
+    this.url = url;
+  }
+}