@globalpayments/vega 2.34.0 → 2.35.0

package/dist/collection/components/vega-pagination/vega-pagination.js

@@ -104,7 +104,6 @@ export class VegaPagination {
     };
     this.onPageSizeSelectorChange = (pageSize) => {
       this.pageSize = pageSize;
-      this.vegaPageSizeChangeEventEmitter.emit(this.pageSize);
     };
     this.calculatePages = () => {
       if (!this.total) {
@@ -155,7 +154,11 @@ export class VegaPagination {
     this.currentValueGuard();
     this.vegaChangeEventEmitter.emit(this.current);
   }
+  watchTotal() {
+    this.pageCount = this.calculatePages();
+  }
   watchPageSize() {
+    this.vegaPageSizeChangeEventEmitter.emit(this.pageSize);
     this.pageCount = this.calculatePages();
   }
   componentWillLoad() {
@@ -375,7 +378,7 @@ export class VegaPagination {
       "methodName": "watchCurrent"
     }, {
       "propName": "total",
-      "methodName": "watchPageSize"
+      "methodName": "watchTotal"
     }, {
       "propName": "pageSize",
       "methodName": "watchPageSize"

package/dist/collection/components/vega-rich-text-content/slimmers/renderers/vega-rich-text-content-renderer.js

@@ -8,9 +8,17 @@ import { MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
 import { h, Host } from '@stencil/core';
 import { VegaDarkModeStyleController } from '../../../../helpers/theme/controllers/dark-mode-style-controller';
 import { TextColorToolbarButtonSlimmer } from '../../../vega-rich-text-editor/slimmers/renderers/tools/text-color-toolbar-button-slimmer';
+import RTETextBlockRenderer from '../../../vega-rich-text-editor/dto/renderers/blocks/text-block-renderer';
+import RTEImageBlockRenderer from '../../../vega-rich-text-editor/dto/renderers/blocks/image-block-renderer';
+import RTEListBlockRenderer from '../../../vega-rich-text-editor/dto/renderers/blocks/list-block-renderer';
 export class VegaRichTextContentRenderer extends VegaSlimmer {
   constructor() {
     super();
+    this.blockRenderers = [
+      RTETextBlockRenderer,
+      RTEImageBlockRenderer,
+      RTEListBlockRenderer,
+    ];
     VegaDarkModeStyleController.registerCustomDarkModeColor(TextColorToolbarButtonSlimmer.formatDarkModeColor());
   }
   /**
@@ -30,7 +38,16 @@ export class VegaRichTextContentRenderer extends VegaSlimmer {
   }
   renderContent() {
     var _a;
-    return (_a = this.content) === null || _a === void 0 ? void 0 : _a.blocks.map((block) => block.render({ editable: this.contentEditable }));
+    const renderContext = { editable: this.contentEditable };
+    return (_a = this.content) === null || _a === void 0 ? void 0 : _a.blocks.map((block) => {
+      const blockRenderer = this.getBlockRenderer(block);
+      if (blockRenderer) {
+        return blockRenderer.render(block, renderContext);
+      }
+    });
+  }
+  getBlockRenderer(block) {
+    return this.blockRenderers.find((renderer) => renderer.canHandle(block));
   }
   shouldShowPlaceholder() {
     var _a;

package/dist/collection/components/vega-rich-text-editor/dto/annotations/bold-annotation.js

@@ -17,16 +17,6 @@ export class BoldAnnotation extends NodeAnnotation {
   static from(bold) {
     return [NodeAnnotationTypeEnum.BOLD, new BoldAnnotation(bold)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.BOLD, BoldAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    const style = node.style;
-    return this.from(node.nodeName === 'STRONG' || style.fontWeight === 'bold' || style.fontWeight === '700');
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/code-annotation.js

@@ -17,15 +17,6 @@ export class CodeAnnotation extends NodeAnnotation {
   static from(code) {
     return [NodeAnnotationTypeEnum.CODE, new CodeAnnotation(code)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.CODE, CodeAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return this.from(node.classList.contains('v-rte--code') || node.nodeName === 'CODE');
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/horizontal-alignment-annotation.js

@@ -17,50 +17,6 @@ export class HorizontalAlignmentAnnotation extends BlockAnnotation {
   static from(textAlign) {
     return [BlockAnnotationTypeEnum.ALIGNMENT, new HorizontalAlignmentAnnotation(textAlign)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[BlockAnnotationTypeEnum.ALIGNMENT, HorizontalAlignmentAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    const alignment = this.getTextAlign(node);
-    return alignment ? this.from(alignment) : null;
-  }
-  /**
-   * Get the text alignment of an HTML element.
-   *
-   * @param {HTMLElement} node - An HTMLElement.
-   * @returns {Nullable<VegaRTEBlockAlignment>} text alignment.
-   */
-  static getTextAlign(node) {
-    const classList = node.classList;
-    if (classList.contains(`v-rte--horizontal-alignment-left`)) {
-      return 'left';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-center`)) {
-      return 'center';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-right`)) {
-      return 'right';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-justify`)) {
-      return 'justify';
-    }
-    const style = node.style;
-    switch (style.textAlign) {
-      case 'center':
-        return 'center';
-      case 'right':
-        return 'right';
-      case 'justify':
-        return 'justify';
-      case 'left':
-        return 'left';
-      default:
-        return null;
-    }
-  }
   /**
    * Generate the JSON item of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/image-annotation.js

@@ -20,16 +20,6 @@ export class ImageAnnotation extends NodeAnnotation {
   static from(size, alt) {
     return [NodeAnnotationTypeEnum.IMAGE, new ImageAnnotation(size, alt)];
   }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {VegaRichTextImageEditorSizeType} size - size.
-   * @param {string} alt - alt.
-   * @returns {[NodeAnnotationTypeEnum.IMAGE, ImageAnnotation]} Map item for the annotation
-   */
-  static fromHTML(size, alt) {
-    return this.from(size || 'md', alt);
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/indent-annotation.js

@@ -17,48 +17,6 @@ export class IndentAnnotation extends BlockAnnotation {
   static from(indent) {
     return [BlockAnnotationTypeEnum.INDENT, new IndentAnnotation(indent)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[BlockAnnotationTypeEnum.INDENT, IndentAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    const marginLeft = this.getMarginLeft(node);
-    return marginLeft && marginLeft >= 0 ? this.from(Math.floor(marginLeft / 16)) : null;
-  }
-  /**
-   * Retrieves the left margin value of an HTML element.
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {number} margin left.
-   */
-  static getMarginLeft(node) {
-    const style = node.style;
-    let marginLeft;
-    if (style.marginLeft) {
-      marginLeft = style.marginLeft;
-    }
-    else if (style.margin) {
-      const margins = style.margin.split(' ');
-      switch (margins.length) {
-        case 4:
-          marginLeft = margins[3];
-          break;
-        case 2:
-        case 3:
-          marginLeft = margins[1];
-          break;
-        default:
-          marginLeft = margins[0];
-          break;
-      }
-    }
-    else {
-      return null;
-    }
-    return Number(marginLeft.replace('px', ''));
-  }
   /**
    * Generate the JSON item of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/italic-annotation.js

@@ -17,15 +17,6 @@ export class ItalicAnnotation extends NodeAnnotation {
   static from(italic) {
     return [NodeAnnotationTypeEnum.ITALIC, new ItalicAnnotation(italic)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.ITALIC, ItalicAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return this.from(node.nodeName === 'I' || node.style.fontStyle === 'italic' || node.nodeName === 'EM');
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/link-annotation.js

@@ -20,20 +20,6 @@ export class LinkAnnotation extends NodeAnnotation {
       new LinkAnnotation({ href: link.href, groupKey: link.groupKey }),
     ];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.LINK, LinkAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return node.hasAttribute('data-href')
-      ? this.from({
-        href: node.getAttribute('data-href'),
-        groupKey: node.getAttribute('data-group-key'),
-      })
-      : null;
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/link-group-annotation.js

@@ -1,12 +1,4 @@
-import { h } from '@stencil/core';
 import { Annotation, InternalAnnotationTypeEnum } from './annotation.abstract';
-import { generateUUID } from '../../../../utils/misc';
-import { LinkAnnotationAction } from '../actions/link-annotation-action';
-import { NodeAnnotationTypeEnum } from './node-annotation.abstract';
-import { DomNodeSubjectObserverFactory } from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-observer-factory';
-import { VegaChange } from '../../../../helpers/event-manager/event-id/vega-event-id';
-import { isNonNullable } from '../../../../types/type-guard';
-import { createEnterKeyHandlerToTriggerClick } from '../../../../utils/accessibility';
 /**
  * Annotation to represent a link of grouped nodes
  */
@@ -17,86 +9,4 @@ export class LinkGroupAnnotation extends Annotation {
     this.linkGroups = new Map();
     this.linkGroups = new Map([[groupKey, []]]);
   }
-  renderNodes(nodes, { editable }) {
-    const blockNodes = this.groupNodesByLink(nodes);
-    return blockNodes.flatMap((item) => {
-      if (this.isLinkGroup(item)) {
-        const linkAnnotation = item[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
-        return editable
-          ? this.renderLinkEditorWrapper(item, linkAnnotation)
-          : this.renderLink(item, linkAnnotation);
-      }
-      return item.render();
-    });
-  }
-  renderLinkEditorWrapper(linkNodes, linkAnnotation) {
-    const { href } = linkAnnotation.link;
-    const textFromNodes = linkNodes.map((node) => node.text).join('');
-    const handleChange = ({ detail, }) => {
-      switch (detail.action) {
-        case 'link': {
-          const { url, text } = detail.payload;
-          const textChanged = text !== textFromNodes;
-          const groupKey = generateUUID();
-          linkNodes.forEach((node) => {
-            const linkAnnotationAction = new LinkAnnotationAction({
-              link: { href: url, groupKey: groupKey },
-              newText: textChanged ? text : undefined,
-              needMergeNode: textChanged && linkNodes.length > 1,
-              doSplit: false,
-            });
-            node.apply(linkAnnotationAction);
-          });
-          return;
-        }
-        case 'unlink': {
-          linkNodes.forEach((node) => node.deleteAnnotationByType(NodeAnnotationTypeEnum.LINK));
-          return;
-        }
-      }
-    };
-    let linkWrapperRef;
-    return (h("span", { class: "link-editor-wrapper", role: "link", tabIndex: 0, onKeyDown: createEnterKeyHandlerToTriggerClick(), ref: (ref) => {
-        if (ref) {
-          linkWrapperRef = ref;
-        }
-      } },
-      this.renderLink(linkNodes, linkAnnotation),
-      h("vega-rich-text-link-editor", { record: {
-          text: textFromNodes,
-          url: href,
-        }, ref: (ref) => {
-          if (ref) {
-            ref.target = linkWrapperRef;
-            DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, handleChange);
-          }
-        } })));
-  }
-  renderLink(linkNodes, linkAnnotation) {
-    const { href } = linkAnnotation.link;
-    return (h("a", { class: "v-rte--link", href: href, target: "_blank" }, linkNodes.map((node) => node.render())));
-  }
-  isLinkGroup(item) {
-    return Array.isArray(item);
-  }
-  groupNodesByLink(nodes) {
-    return nodes.reduce((acc, node) => {
-      const nodeLinkAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
-      const lastGroup = acc[acc.length - 1];
-      if (isNonNullable(nodeLinkAnnotation)) {
-        if (lastGroup &&
-          this.isLinkGroup(lastGroup) &&
-          lastGroup[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK).toEqual(nodeLinkAnnotation)) {
-          lastGroup.push(node);
-        }
-        else {
-          acc.push([node]);
-        }
-      }
-      else {
-        acc.push(node);
-      }
-      return acc;
-    }, []);
-  }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/strikethrough-annotation.js

@@ -17,17 +17,6 @@ export class StrikethroughAnnotation extends NodeAnnotation {
   static from(strikethrough) {
     return [NodeAnnotationTypeEnum.STRIKETHROUGH, new StrikethroughAnnotation(strikethrough)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.STRIKETHROUGH, StrikethroughAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return this.from(node.style.textDecoration.includes('line-through') ||
-      node.nodeName === 'S' ||
-      node.classList.contains('v-rte--strikethrough'));
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/text-color-annotation.js

@@ -1,6 +1,5 @@
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
 import { RTE_TEXT_COLORS } from '../../constants/constant';
-import { rgbToHex } from '../../../../utils/ui';
 import { VegaThemeManager } from '../../../../helpers/theme/theme-manager';
 /**
  * Annotation to make text with text color
@@ -20,31 +19,6 @@ export class TextColorAnnotation extends NodeAnnotation {
   static from(textColor) {
     return [NodeAnnotationTypeEnum.TEXT_COLOR, new TextColorAnnotation(textColor)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    var _a;
-    const color = node.style.color;
-    const hexColor = (_a = rgbToHex(color)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-    if (hexColor) {
-      const colorSchema = RTE_TEXT_COLORS.find((schema) => schema.light === hexColor || schema.dark === hexColor);
-      if (colorSchema)
-        return this.from(colorSchema.key);
-      return null;
-    }
-    else {
-      for (const color of RTE_TEXT_COLORS) {
-        if (node.style.color.includes(color.key)) {
-          return this.from(color.key);
-        }
-      }
-      return null;
-    }
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/text-style-annotation.js

@@ -17,50 +17,6 @@ export class TextStyleAnnotation extends BlockAnnotation {
   static from(textStyle) {
     return [BlockAnnotationTypeEnum.TEXT_STYLE, new TextStyleAnnotation(textStyle)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return this.from(this.getTextStyle(node));
-  }
-  /**
-   * Get the type of block.
-   *
-   * @param {HTMLElement} node - An HTMLElement.
-   * @returns {VegaRTETextStyleType} text style type.
-   */
-  static getTextStyle(node) {
-    if (node.nodeType !== Node.TEXT_NODE && node.hasAttribute('data-type')) {
-      return node.getAttribute('data-type');
-    }
-    switch (node.style.fontSize) {
-      case '36px':
-        return 'title';
-      case '28px':
-        return 'subtitle';
-      case '22px':
-        return 'heading-1';
-      case '20px':
-        return 'heading-2';
-      case '18px':
-        return 'heading-3';
-      default:
-        break;
-    }
-    switch (node.nodeName) {
-      case 'H1':
-        return 'heading-1';
-      case 'H2':
-        return 'heading-2';
-      case 'H3':
-        return 'heading-3';
-      default:
-        return 'paragraph';
-    }
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/annotations/underline-annotation.js

@@ -17,17 +17,6 @@ export class UnderlineAnnotation extends NodeAnnotation {
   static from(underline) {
     return [NodeAnnotationTypeEnum.UNDERLINE, new UnderlineAnnotation(underline)];
   }
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node) {
-    return this.from(node.style.textDecoration.includes('underline') ||
-      node.nodeName === 'U' ||
-      node.classList.contains('v-rte--underline'));
-  }
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/collection/components/vega-rich-text-editor/dto/blocks/block.abstract.js

@@ -3,7 +3,6 @@ import ChangeManager from '../../../../helpers/change-manager/change-manager';
 import domNodeSubjectFactory from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
 import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
 import { VegaInternalRichTextEditorFlushChanges } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
-import { isNonNullable } from '../../../../types/type-guard';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { HorizontalAlignmentAnnotation } from '../annotations/horizontal-alignment-annotation';
 import { IndentAnnotation } from '../annotations/indent-annotation';
@@ -11,7 +10,6 @@ import { BlockBaseOperator } from '../helper/block-base-operator';
 import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { RemoveChildAction } from '../actions/remove-child-action';
 import { ZERO_WIDTH_SPACE } from '../../constants/constant';
-import { TextStyleAnnotation } from '../annotations/text-style-annotation';
 /**
  * Abstract class for block
  */
@@ -41,23 +39,6 @@ export class RTEBlock extends BlockBaseOperator {
         return IndentAnnotation.from(value);
     }
   }
-  /**
-   * Create annotations for block element.
-   *
-   * @param {string} type - Annotations type.
-   * @param {HTMLElement} node - current node.
-   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} - result.
-   */
-  static createAnnotationEntityFromHTML(type, node) {
-    switch (type) {
-      case 'ALIGNMENT':
-        return HorizontalAlignmentAnnotation.fromHTML(node);
-      case 'TEXT_STYLE':
-        return TextStyleAnnotation.fromHTML(node);
-      case 'INDENT':
-        return IndentAnnotation.fromHTML(node);
-    }
-  }
   /**
    * Class to JSON object
    *
@@ -120,29 +101,6 @@ export class RTEBlock extends BlockBaseOperator {
     this.annotationMap.set(annotation.type, annotation);
     typeof this.doAnnotationActionApply === 'function' && this.doAnnotationActionApply(action);
   }
-  /**
-   * Get styles from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  getStyles() {
-    return Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof BlockAnnotation)
-      .map((annotation) => annotation.render())
-      .filter(isNonNullable)
-      .reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {});
-  }
-  /**
-   * Get classes from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  getClasses() {
-    return Array.from(this.annotationMap.values())
-      .map((annotation) => { var _a; return (_a = annotation.renderClass) === null || _a === void 0 ? void 0 : _a.call(annotation); })
-      .filter(isNonNullable)
-      .reduce((pre, cur) => [pre, cur].join(' '), '');
-  }
   /**
    * Appends a list of RTENode objects to the current node's child nodes and sets the parent block of each node to the current node.
    *