@globalpayments/vega 2.98.0 → 2.100.0

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/controllers/link-editor-controller.js

@@ -11,6 +11,7 @@ import { VegaInternalComponentDidRender, VegaInternalPopoverUpdateTarget, } from
 import domNodeSubjectFactory from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
 import ChangeManager from '../../../../../helpers/change-manager/change-manager';
 import remoteInvocationRegistry from '../../../../../helpers/remote-invocation/remote-invocation-registry';
+import { checkIsVoiceOverClick, getDeepActiveElementInShadow, getFirstFocusableElement, } from '../../../../../utils/ui';
 import { LINK_TYPE_HANDLER_MAP } from '../renderers/link-type-handler';
 import { LinkUrlNormalizer } from '../utils/link-url-normalizer';
 import { RTE_DEFAULT_LINK_TYPE_KEY, RTE_EMAIL_LINK_TYPE_KEY } from '../../../constants/constant';
@@ -22,10 +23,41 @@ export class LinkEditorController extends VegaSlimmer {
     super(...arguments);
     this.linkUrlNormalizer = new LinkUrlNormalizer();
     this.linkTypeHandlers = LINK_TYPE_HANDLER_MAP;
+    /**
+     * The element the trigger click listener is currently attached to (the link
+     * wrapper acting as the popover target).
+     */
+    this.triggerListenerEl = null;
+    /**
+     * Whether the popover was opened via a keyboard or screen-reader (VoiceOver)
+     * activation. When true, focus is moved into the popover so screen reader
+     * users land on the Edit button.
+     */
+    this.isVoiceOverTrigger = false;
+    /**
+     * The element that had focus when the VoiceOver activation happened, so focus
+     * can be restored to the link once the popover is hidden.
+     */
+    this.focusReturnEl = null;
+    /**
+     * Records whether the popover was opened via a keyboard/VoiceOver activation
+     * and, if so, the element to restore focus to when the popover closes.
+     *
+     * @param {MouseEvent} e - The click event on the link wrapper.
+     * @returns {void} No return value.
+     */
+    this.handleTriggerClick = (e) => {
+      this.isVoiceOverTrigger = this.isKeyboardOrScreenReaderActivation(e);
+      this.focusReturnEl = this.isVoiceOverTrigger
+        ? // eslint-disable-next-line no-restricted-globals
+          getDeepActiveElementInShadow(document, true)
+        : null;
+    };
   }
   /** Initializes the popover target after the component loads. */
   componentDidLoad() {
     this.updatePopoverTarget();
+    this.attachTriggerListener();
   }
   /** Notifies observers after each render cycle. */
   componentDidRender() {
@@ -44,6 +76,7 @@ export class LinkEditorController extends VegaSlimmer {
   watchTargetChange() {
     this.linkTypeConfigController.invalidateConfiguredLinkTypesCache();
     this.updatePopoverTarget();
+    this.attachTriggerListener();
   }
   /**
    * Prepares the editor state before the popover is shown.
@@ -74,6 +107,9 @@ export class LinkEditorController extends VegaSlimmer {
       }
       await this.populateEditForm();
     }
+    if (this.status !== 'linkEdit' && this.isVoiceOverTrigger) {
+      this.focusPopoverContentForVoiceOver();
+    }
   }
   /**
    * Clears form state after the popover hides.
@@ -90,6 +126,7 @@ export class LinkEditorController extends VegaSlimmer {
     if (this.resetStatusAfterHide) {
       this.linkEditorStateManager.setShouldResetStatusOnNextShow(true);
     }
+    this.restoreFocusAfterVoiceOver();
   }
   /**
    * Switches the editor into link edit mode.
@@ -251,6 +288,93 @@ export class LinkEditorController extends VegaSlimmer {
   updatePopoverTarget() {
     remoteInvocationRegistry.call(domNodeSubjectFactory.getSubject(this.renderer.getPopoverRef(), VegaInternalPopoverUpdateTarget), this.target);
   }
+  /**
+   * Attaches a capture-phase click listener to the link wrapper (the popover
+   * target) so a keyboard/VoiceOver activation can be distinguished from a real
+   * pointer click before the popover opens. Re-attaches when the target changes.
+   *
+   * @returns {void} No return value.
+   */
+  attachTriggerListener() {
+    if (this.triggerListenerEl === this.target) {
+      return;
+    }
+    this.detachTriggerListener();
+    if (this.target) {
+      this.triggerListenerEl = this.target;
+      this.target.addEventListener('click', this.handleTriggerClick, { capture: true });
+    }
+  }
+  /**
+   * Removes the trigger listener from the previously observed element.
+   *
+   * @returns {void} No return value.
+   */
+  detachTriggerListener() {
+    if (this.triggerListenerEl) {
+      this.triggerListenerEl.removeEventListener('click', this.handleTriggerClick, { capture: true });
+      this.triggerListenerEl = null;
+    }
+  }
+  /**
+   * Determines whether a click on the link wrapper came from a keyboard or
+   * screen reader (VoiceOver) rather than a real pointer.
+   *
+   * A genuine pointer click lands inside the activated element. Keyboard (Enter,
+   * `detail === 0`) and VoiceOver activations dispatch a click with coordinates
+   * that are not on the element, so we treat any click whose point falls outside
+   * the wrapper as an assistive-technology activation.
+   *
+   * @param {MouseEvent} e - The click event on the link wrapper.
+   * @returns {boolean} True when the activation is keyboard/screen-reader driven.
+   */
+  isKeyboardOrScreenReaderActivation(e) {
+    if (checkIsVoiceOverClick(e)) {
+      return true;
+    }
+    const rect = this.target ? this.target.getBoundingClientRect() : null;
+    if (!rect || (rect.width === 0 && rect.height === 0)) {
+      return false;
+    }
+    const isInsideTarget = e.clientX >= rect.left &&
+      e.clientX <= rect.right &&
+      e.clientY >= rect.top &&
+      e.clientY <= rect.bottom;
+    return !isInsideTarget;
+  }
+  /**
+   * Moves focus to the first focusable element within the popover content (the
+   * Edit button) so VoiceOver users land inside the opened toolbar.
+   *
+   * Deferred to the next macrotask so it runs after the editor has finished
+   * placing the caret/focus into the content area on the activating click.
+   *
+   * @returns {void} No return value.
+   */
+  focusPopoverContentForVoiceOver() {
+    setTimeout(() => {
+      const contentRef = this.renderer.getPopoverContentRef();
+      if (!contentRef) {
+        return;
+      }
+      const focusable = getFirstFocusableElement(contentRef);
+      (focusable !== null && focusable !== void 0 ? focusable : contentRef).focus();
+    });
+  }
+  /**
+   * Restores focus to the link wrapper after the popover is hidden following a
+   * VoiceOver activation.
+   *
+   * @returns {void} No return value.
+   */
+  restoreFocusAfterVoiceOver() {
+    if (this.isVoiceOverTrigger && this.focusReturnEl) {
+      const returnEl = this.focusReturnEl;
+      setTimeout(() => returnEl.focus());
+    }
+    this.isVoiceOverTrigger = false;
+    this.focusReturnEl = null;
+  }
   /**
    * Preserves an unchanged mailto URL when the form edits are equivalent.
    *

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

@@ -35,6 +35,11 @@ export class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
     this.handleFormRef = (ref) => {
       this.formRef = ref;
     };
+    this.handlePopoverContentRef = (ref) => {
+      if (ref) {
+        this.popoverContentRef = ref;
+      }
+    };
     this.handleUrlInputRef = (ref) => {
       if (ref) {
         this.urlInputRef = ref;
@@ -68,6 +73,9 @@ export class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   getPopoverRef() {
     return this.popoverRef;
   }
+  getPopoverContentRef() {
+    return this.popoverContentRef;
+  }
   getFormRef() {
     return this.formRef;
   }
@@ -81,7 +89,7 @@ export class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
     return (h("vega-popover", { trigger: "click", alignment: "start", placement: "bottom", showArrow: false, isScreenPosition: true, ref: this.handlePopoverRef },
       h("span", { slot: "popover-content" },
         h("slot", null)),
-      h("div", { slot: "popover" },
+      h("div", { slot: "popover", ref: this.handlePopoverContentRef },
         this.renderLinkUnlinkContent(),
         this.renderLinkEditContent())));
   }

package/dist/collection/components/vega-tab-group/slimmers/vega-tab-group/renderers/vega-tab-group-tab-list-renderer.js

@@ -78,18 +78,24 @@ export class VegaTabGroupTabListRenderer extends VegaSlimmer {
   renderCounterBadgeDom(item) {
     const counterBadge = item.counterBadge;
     const counterBadgeClass = this.getCounterBadgeClassByCount(counterBadge);
-    return ((counterBadge === null || counterBadge === void 0 ? void 0 : counterBadge.count) !== undefined &&
-      counterBadge.count > 0 && (h("div", { class: `vega-counter-badge ${counterBadgeClass}`, "aria-hidden": "true" },
-      h("vega-counter-badge", { count: counterBadge.count, color: counterBadge.color }))));
+    return (counterBadge &&
+      (!!counterBadge.dot || (counterBadge.count !== undefined && counterBadge.count > 0)) && (h("div", { class: `vega-counter-badge ${counterBadgeClass}`, "aria-hidden": "true" },
+      h("vega-counter-badge", { count: counterBadge.count, color: counterBadge.color, dot: counterBadge.dot }))));
   }
   getTabAriaLabel(item) {
     const counterBadge = item.counterBadge;
+    if (counterBadge === null || counterBadge === void 0 ? void 0 : counterBadge.dot) {
+      return `${item.label}, ${this.translationSlimmer.t('notification')}`;
+    }
     return (counterBadge === null || counterBadge === void 0 ? void 0 : counterBadge.count) && counterBadge.count > 0
       ? `${item.label}, ${counterBadge.count}`
       : item.label;
   }
   getCounterBadgeClassByCount(counterBadge) {
-    if (counterBadge && counterBadge.count) {
+    if (counterBadge === null || counterBadge === void 0 ? void 0 : counterBadge.dot) {
+      return 'dot-variant';
+    }
+    if (counterBadge === null || counterBadge === void 0 ? void 0 : counterBadge.count) {
       const digits = counterBadge.count.toString().length;
       if (digits === 1) {
         return 'one-digit';
@@ -101,9 +107,7 @@ export class VegaTabGroupTabListRenderer extends VegaSlimmer {
         return 'multi-digits';
       }
     }
-    else {
-      return '';
-    }
+    return '';
   }
   handleTabItemClick(event, dataTarget) {
     this.selectedTargetController.handleTabItemClick(dataTarget);
@@ -143,3 +147,6 @@ __decorate([
 __decorate([
   MapToComponentField({ componentFieldName: 'vegaTabGroupVoiceOverFocusController' })
 ], VegaTabGroupTabListRenderer.prototype, "voiceOverFocusController", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTabGroupTabListRenderer.prototype, "translationSlimmer", void 0);

package/dist/collection/components/vega-tab-group/vega-tab-group.css

@@ -114,6 +114,12 @@
   padding-left: 8px;
   top: 10px;
 }
+.vega-tab > div > .label .vega-counter-badge.dot-variant {
+  width: 20px;
+}
+.vega-tab > div > .label .vega-counter-badge.dot-variant vega-counter-badge {
+  left: 10px;
+}
 .vega-tab > div > .label .vega-counter-badge.one-digit {
   width: 20px;
 }

package/dist/collection/components/vega-tab-group/vega-tab-group.js

@@ -23,6 +23,7 @@ import { createEventEmitSlimmer, } from '../../helpers/event-manager/slimmers/ev
 import { VegaClick } from '../../helpers/event-manager/event-id/vega-event-id';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 import { VegaTabGroupRuntimeMetricsPayloadDefinition } from '../../constants/runtime-metrics-payload-definition/vega-tab-group/runtime-metrics-payload-definition';
+import { TranslationSlimmer } from '../../helpers/slimmers/translation';
 /**
  * The Tab Group component organizes content into separate views, and allows users to switch between them without navigating away from the parent page.
  *
@@ -32,6 +33,7 @@ export class VegaTabGroup {
   constructor() {
     this.globalSlimmers = {};
     this.vegaTabGroupRenderer = new VegaTabGroupRenderer();
+    this.translationSlimmer = new TranslationSlimmer();
     this.vegaTabGroupDirectionButtonRenderer = new VegaTabGroupSwitchPageButtonRenderer();
     this.vegaTabGroupTabListRenderer = new VegaTabGroupTabListRenderer();
     this.vegaTabGroupCloseButtonRenderer = new VegaTabGroupCloseButtonRenderer();
@@ -402,6 +404,9 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], VegaTabGroup.prototype, "vegaTabGroupRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaTabGroup.prototype, "translationSlimmer", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], VegaTabGroup.prototype, "vegaTabGroupDirectionButtonRenderer", void 0);

package/dist/collection/components/vega-table/slimmers/controllers/vega-table-body-col-span-controller.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
 import { resolveBodyColSpan } from '../renderers/vega-table-body-col-span-resolver';
+import { BreakpointKeys } from '../../../../constants/ui';
 /**
  * Per-row body colspan controller.
  *
@@ -16,6 +17,10 @@ import { resolveBodyColSpan } from '../renderers/vega-table-body-col-span-resolv
  *
  * The structural shape (a {@link VegaSlimmer} controller reading component fields) mirrors the
  * main-branch `VegaTableExpandRowController` paradigm.
+ *
+ * Breakpoint-aware: maps the current breakpoint from the parent vega-table and computes
+ * which columns are hidden at that breakpoint so the colspan resolver can shrink before
+ * breakpoint-hidden columns (instead of mirroring across them).
  */
 export class VegaTableBodyColSpanController extends VegaSlimmer {
   constructor() {
@@ -43,6 +48,8 @@ export class VegaTableBodyColSpanController extends VegaSlimmer {
       this.warnedColSpanKeys.clear();
       this.lastWarnedColumnsRef = this.columns;
     }
+    // Compute per-leaf hidden state based on current breakpoint.
+    const isHiddenAtBreakpoint = leaves.map((leaf) => this.isColumnHiddenAtBreakpoint(leaf));
     const results = new Array(leaves.length).fill(null);
     let skipCount = 0;
     leaves.forEach((leaf, leafIndex) => {
@@ -53,7 +60,7 @@ export class VegaTableBodyColSpanController extends VegaSlimmer {
       }
       const column = this.findColumn(leaf);
       const result = column
-        ? resolveBodyColSpan(column, record, rowIndex, leafIndex, leaves, this.warnedColSpanKeys)
+        ? resolveBodyColSpan(column, record, rowIndex, leafIndex, leaves, this.warnedColSpanKeys, isHiddenAtBreakpoint)
         : { htmlColspan: 1, skipCount: 0 };
       results[leafIndex] = result;
       skipCount = result.skipCount;
@@ -71,7 +78,30 @@ export class VegaTableBodyColSpanController extends VegaSlimmer {
       column.prop === renderInput.key ||
       column.label === renderInput.key);
   }
+  /**
+   * Determine whether a leaf is hidden at the current breakpoint.
+   *
+   * A leaf is hidden when the column's breakpoint threshold is greater than the current breakpoint.
+   * Breakpoint order: 'default' < 'S' < 'M' < 'L' < 'XL'.
+   * Example: if currentBreakpoint is 'S' and column.breakpoint is 'M', the column is hidden (S < M).
+   *
+   * @param {ColumnRenderInputModel} leaf - The leaf render input to check.
+   * @returns {boolean} True if the leaf is hidden at the current breakpoint.
+   */
+  isColumnHiddenAtBreakpoint(leaf) {
+    const column = this.findColumn(leaf);
+    if (!column || !column.breakpoint) {
+      return false; // No breakpoint = never hidden.
+    }
+    const currentBreakpointIndex = BreakpointKeys.indexOf(this.currentBreakpoint);
+    const columnBreakpointIndex = BreakpointKeys.indexOf(column.breakpoint);
+    // Column is hidden when current breakpoint is smaller than the column's breakpoint threshold.
+    return currentBreakpointIndex < columnBreakpointIndex;
+  }
 }
 __decorate([
   MapToComponentField()
 ], VegaTableBodyColSpanController.prototype, "columns", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableBodyColSpanController.prototype, "currentBreakpoint", void 0);

package/dist/collection/components/vega-table/slimmers/renderers/vega-table-body-col-span-resolver.js

@@ -37,16 +37,16 @@ function normalizeSpan(rawSpan) {
  * Walk rightward from the starting leaf to find the widest legal span.
  *
  * Stops (and returns a clamp reason) when the span would either run past the end of the
- * row or cross a pinned ↔ unpinned column boundary (which would break sticky positioning).
- * Breakpoint-hidden columns are intentionally **not** a stop condition — the span mirrors
- * across them (matching header group colSpan).
+ * row, cross a pinned ↔ unpinned column boundary, or encounter a breakpoint-hidden column.
+ * Breakpoint-hidden columns are a shrink trigger (the span stops before them).
  *
  * @param {number} declared - The declared span requested by the column.
  * @param {number} leafIndex - Index of the starting leaf in the flattened render-input array.
  * @param {ColumnRenderInputModel[]} allLeaves - All leaf render inputs for the table (ordered).
+ * @param {boolean[]} isHiddenAtBreakpoint - Per-leaf boolean: true if leaf is hidden at current breakpoint.
  * @returns {MaxSpan} The widest legal span plus the clamp reason (null when unconstrained).
  */
-function computeMaxSpan(declared, leafIndex, allLeaves) {
+function computeMaxSpan(declared, leafIndex, allLeaves, isHiddenAtBreakpoint) {
   var _a, _b;
   const startPinned = (_a = allLeaves[leafIndex]) === null || _a === void 0 ? void 0 : _a.pinned;
   let span = 1;
@@ -58,6 +58,13 @@ function computeMaxSpan(declared, leafIndex, allLeaves) {
         clampReason: `extends past the end of the row (${allLeaves.length} columns total)`,
       };
     }
+    // Reject if the next column is hidden at the current breakpoint.
+    if (isHiddenAtBreakpoint[leafIndex + offset]) {
+      return {
+        span,
+        clampReason: null, // Breakpoint-hidden stop is not a config-error warning — it is legitimate responsive hiding.
+      };
+    }
     // Reject if the next column is in a different pinned group.
     if (nextLeaf.pinned !== startPinned) {
       return {
@@ -87,11 +94,10 @@ function warnClampOnce(colKey, declared, effective, reason, warnedKeys) {
 /**
  * Resolve the effective body-cell colspan for a single source-data row cell.
  *
- * Clamps the declared span so it never runs past the end of the row nor crosses a
- * pinned ↔ unpinned column boundary. Structural clamps (end-of-row / pinned boundary) emit a
- * warning once per column key (tracked via the caller-supplied {@link warnedKeys} set).
- * Breakpoint-hidden columns are **not** clamped — the span mirrors across a `display: none`
- * column (matching header group colSpan) so the body grid stays column-aligned with the header.
+ * Clamps the declared span so it never runs past the end of the row, crosses a
+ * pinned ↔ unpinned column boundary, or encounters a breakpoint-hidden column (shrink before it).
+ * Structural clamps (end-of-row / pinned boundary) emit a warning once per column key
+ * (tracked via the caller-supplied {@link warnedKeys} set). Breakpoint-hidden stops are silent.
  *
  * @param {VegaTableColumnConfig} column - The column configuration for the spanning cell.
  * @param {VegaTableDataSourceItem} record - The row data record.
@@ -99,14 +105,15 @@ function warnClampOnce(colKey, declared, effective, reason, warnedKeys) {
  * @param {number} leafIndex - Index of this column in the flattened leaf render-input array.
  * @param {ColumnRenderInputModel[]} allLeaves - All leaf render inputs for the table (ordered).
  * @param {Set<string>} warnedKeys - Per-instance set tracking column keys that have already received a clamping warning.
+ * @param {boolean[]} isHiddenAtBreakpoint - Per-leaf boolean: true if leaf is hidden at current breakpoint.
  * @returns {BodyColSpanResult} Resolved spanning metadata for the cell.
  */
-export function resolveBodyColSpan(column, record, rowIndex, leafIndex, allLeaves, warnedKeys) {
+export function resolveBodyColSpan(column, record, rowIndex, leafIndex, allLeaves, warnedKeys, isHiddenAtBreakpoint) {
   var _a, _b, _c;
   const declared = getDeclaredSpan(column, record, rowIndex);
   if (!declared || declared <= 1)
     return NO_SPAN;
-  const { span, clampReason } = computeMaxSpan(declared, leafIndex, allLeaves);
+  const { span, clampReason } = computeMaxSpan(declared, leafIndex, allLeaves, isHiddenAtBreakpoint);
   const effectiveSpan = Math.min(declared, span);
   if (clampReason && effectiveSpan < declared) {
     const colKey = (_c = (_b = (_a = column.key) !== null && _a !== void 0 ? _a : column.prop) !== null && _b !== void 0 ? _b : column.label) !== null && _c !== void 0 ? _c : '';

package/dist/collection/global/scripts/before-vega-load.js

@@ -39,6 +39,7 @@ import { VegaRTECopyExtension } from '../../components/vega-rich-text-editor/ext
 import { VegaRTECutExtension } from '../../components/vega-rich-text-editor/extensions/cut/cut-extension';
 import { VegaRTEPasteExtension } from '../../components/vega-rich-text-editor/extensions/paste/paste-extension';
 import { VegaRTEImageExtension } from '../../components/vega-rich-text-editor/extensions/image/image-extension';
+import { VegaRTEWordCountExtension } from '../../components/vega-rich-text-editor/extensions/word-count/word-count-extension';
 /**
  * Default export function that will be used by stencil global script,
  * which will be invoked before library loaded.
@@ -231,6 +232,7 @@ function injectVegaRichTextEditorClassIntoGlobal() {
   globalThis.VegaRTECopyExtension = VegaRTECopyExtension;
   globalThis.VegaRTECutExtension = VegaRTECutExtension;
   globalThis.VegaRTEImageExtension = VegaRTEImageExtension;
+  globalThis.VegaRTEWordCountExtension = VegaRTEWordCountExtension;
 }
 /**
  * Inject VegaCalendarPeriodFactory to global as a public api.

package/dist/collection/helpers/keyboard/keyboard-manager.js

@@ -39,12 +39,16 @@ class KeyboardManager {
   listenKeyPress() {
     // eslint-disable-next-line no-restricted-globals
     document.addEventListener('keydown', (e) => {
-      this.invokeListeners('keydown', e);
+      this.invokeListeners('keydown', e, true);
+    }, true);
+    // eslint-disable-next-line no-restricted-globals
+    document.addEventListener('keydown', (e) => {
+      this.invokeListeners('keydown', e, false);
     });
     // listen keyup is waiting activeElement changed.
     // eslint-disable-next-line no-restricted-globals
     document.addEventListener('keyup', (e) => {
-      this.invokeListeners('keyup', e);
+      this.invokeListeners('keyup', e, false);
     });
   }
   /**
@@ -54,10 +58,13 @@ class KeyboardManager {
    * @param {'keyup' | 'keydown'} eventName - The name of the event that was triggered.
    * @param {KeyboardEvent} event - KeyboardEvent - this is the event that is passed to the event
    * listener.
+   * @param {boolean} capture - Whether to invoke listeners registered for the capture phase.
    */
-  invokeListeners(eventName, event) {
+  invokeListeners(eventName, event, capture) {
     this.listeners
-      .filter((listener) => listener.eventName === eventName && this.shouldInvokeListener(listener, event))
+      .filter((listener) => listener.eventName === eventName &&
+      Boolean(listener.capture) === capture &&
+      this.shouldInvokeListener(listener, event))
       .forEach((listener) => {
       if (listener.preventDefault) {
         event.preventDefault();

package/dist/collection/helpers/keyboard/overlay-escape-coordination.js

@@ -0,0 +1,33 @@
+/**
+ * Cross-overlay coordination for the Escape key.
+ *
+ * Multiple overlay components (vega-modal, vega-popover, vega-dropdown) each
+ * register a capture-phase `keydown` listener on `document`. `stopPropagation`
+ * does not block other listeners attached to the same target, and using
+ * `stopImmediatePropagation` would also block unrelated document-level
+ * listeners (e.g. focus-restore observers). Instead, the overlay that handles
+ * an Escape press marks the event here, and other overlay handlers check the
+ * mark to decide whether to skip.
+ *
+ * A `WeakSet` keyed on the event object keeps the marker out of the event's
+ * own properties (no `as any` casts, no risk of clobbering future DOM fields).
+ */
+const handledEscapeEvents = new WeakSet();
+/**
+ * Mark a keydown event as already handled by an overlay's Escape handler.
+ *
+ * @param {KeyboardEvent} event - The keydown event to mark.
+ */
+export function markOverlayHandledEscape(event) {
+  handledEscapeEvents.add(event);
+}
+/**
+ * Check whether a keydown event has already been handled by an overlay's
+ * Escape handler.
+ *
+ * @param {KeyboardEvent} event - The keydown event to check.
+ * @returns {boolean} True if another overlay has already handled this Escape.
+ */
+export function isOverlayHandledEscape(event) {
+  return handledEscapeEvents.has(event);
+}

package/dist/collection/helpers/slimmers/mutation-observer/aria-attributes-value-mapper.js

@@ -102,7 +102,7 @@ export class AriaAttributesValueMapper extends MutationObserverSlimmer {
         }
       }
       if (finalValue === null || finalValue === undefined || String(finalValue).trim() === '') {
-        finalValue = defaultValue;
+        finalValue = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
       }
       try {
         if (String(finalValue).trim() === '') {

package/dist/collection/helpers/translation/locales/en.js

@@ -188,6 +188,7 @@ export const staticTranslations = {
   'pm': 'pm',
   '{0} Selected': '{0} Selected',
   'date picker': 'Date Picker',
+  'notification': 'notification',
   'Selected result': 'Selected result',
   'Close event preview detail': 'Close event preview detail',
   'Edit event': 'Edit event',
@@ -212,6 +213,7 @@ export const staticTranslations = {
   'Arrows': 'Arrows',
   'Currency': 'Currency',
   'Use rich text': 'Use rich text',
+  'Rich Text Editor. Editing area: main. ': 'Rich Text Editor. Editing area: main. ',
   'Paste options': 'Paste options',
   'Required': 'Required',
   'Disabled': 'Disabled',
@@ -220,5 +222,20 @@ export const staticTranslations = {
   'Next': 'Next',
   'Copy': 'Copy',
   'Cut': 'Cut',
+  'Use Word': 'Use Word',
+  // RTE Table extension
+  'Table tools': 'Table tools',
+  'Table properties': 'Table properties',
+  'Cell properties': 'Cell properties',
+  'Align table left': 'Align table left',
+  'Align table center': 'Align table center',
+  'Align table right': 'Align table right',
+  'Align text left': 'Align text left',
+  'Align text center': 'Align text center',
+  'Align text right': 'Align text right',
+  'Justify text': 'Justify text',
+  'Align vertically top': 'Align vertically top',
+  'Align vertically middle': 'Align vertically middle',
+  'Align vertically bottom': 'Align vertically bottom',
 };
 export default staticTranslations;

package/dist/collection/polyfill/libphonenumber/as-you-type.js

@@ -1,5 +1,5 @@
 import { MIN_LEADING_DIGITS_LENGTH, DIGIT_PLACEHOLDER } from './types';
-import { META, getCountryCallingCode, getFormats, detectCallingCode, getCountryByNationalNumber, } from './metadata';
+import { META, getCountryCallingCode, getFormats, detectCallingCode, getCountryByNationalNumber, countryHasExplicitLeadingDigits, } from './metadata';
 import { isNonAlteringFormat, formatSuits, formatMatchesLeadingDigits, buildTemplate, 
 // eslint-disable-next-line spellcheck/spell-checker
 cutAndStripNonPairedParens, applyInternationalSeparatorStyle, } from './format-helpers';
@@ -45,6 +45,7 @@ export class AsYouType {
      * in the original library.
      */
     this._complexPrefix = '';
+    this._defaultCountry = defaultCountry;
     this._country = defaultCountry;
     if (defaultCountry) {
       this._callingCode = getCountryCallingCode(defaultCountry);
@@ -127,7 +128,15 @@ export class AsYouType {
         }
         else if (detected.countries && detected.countries.length > 1) {
           const matched = getCountryByNationalNumber(detected.countries, this._nationalNumber);
-          this._country = matched;
+          const defaultCountryHasExplicitIdentity = !!this._defaultCountry && countryHasExplicitLeadingDigits(this._defaultCountry);
+          const defaultCountry = this._defaultCountry;
+          const shouldKeepDefaultCountry = defaultCountryHasExplicitIdentity &&
+            defaultCountry !== undefined &&
+            this._country === defaultCountry &&
+            detected.countries.includes(defaultCountry);
+          if (!shouldKeepDefaultCountry) {
+            this._country = matched;
+          }
           if (prevCallingCode !== detected.callingCode) {
             this.initFormats(detected.countries[0]);
             this.resetFormat();
@@ -350,8 +359,17 @@ export class AsYouType {
       return;
     const allDigits = this._allDigits;
     const match = allDigits.match(new RegExp('^(?:' + prefixPattern + ')'));
-    if (!match || match[0].length === 0)
+    if (!match || match[0].length === 0) {
+      if (this._complexPrefix) {
+        this._complexPrefix = '';
+        this._nationalNumber = allDigits;
+        this.resetFormat();
+        if (this._country) {
+          this.initFormats(this._country);
+        }
+      }
       return;
+    }
     const newPrefix = match[0];
     const remaining = allDigits.substring(newPrefix.length);
     // If the prefix hasn't changed, just re-apply the split and return.

package/dist/collection/polyfill/libphonenumber/metadata.js

@@ -125,6 +125,22 @@ export function getCountryByNationalNumber(possibleCountries, nationalNumber) {
   }
   return undefined;
 }
+/**
+ * Check whether a country has a non-empty leading-digits pattern in metadata
+ * (metadata index [10]).  Countries with such a pattern can be uniquely
+ * identified by their dialled prefix and should remain "sticky" during
+ * shared-calling-code disambiguation.
+ *
+ * @param {VegaCountryCode} country - country code to evaluate
+ * @returns {boolean} true if metadata contains a non-empty leading-digits pattern
+ */
+export function countryHasExplicitLeadingDigits(country) {
+  const entry = META.countries[country];
+  if (!entry)
+    return false;
+  const leadingDigits = entry[10];
+  return typeof leadingDigits === 'string' && leadingDigits.length > 0;
+}
 /**
  * Check if a national number matches any of the type patterns.
  *

package/dist/collection/utils/accessibility.js

@@ -27,3 +27,23 @@ export function createEnterKeyHandlerToTriggerClick(options) {
     }
   };
 }
+/**
+ * Returns a handler that dispatches a click event on Enter OR Space.
+ * Use for ARIA listbox options (e.g. dropdown items) where both keys should activate the element.
+ * Do NOT use in place of createEnterKeyHandlerToTriggerClick for elements that should only respond to Enter.
+ *
+ * @param {ClickEventOptions} options - An optional object that can contain a "composed" and "preventDefault" property.
+ * @returns {(e: KeyboardEvent) => void} A function that takes a KeyboardEvent and dispatches a click event on Enter or Space.
+ */
+export function createActivationKeyHandlerToTriggerClick(options) {
+  const _a = options || {}, { preventDefault = false } = _a, mouseEventOptions = __rest(_a, ["preventDefault"]);
+  return function (e) {
+    var _a;
+    if (e.key === 'Enter' || e.key === ' ') {
+      if (preventDefault) {
+        e.preventDefault();
+      }
+      (_a = e.currentTarget) === null || _a === void 0 ? void 0 : _a.dispatchEvent(new MouseEvent('click', Object.assign({ bubbles: true, cancelable: true, view: window }, mouseEventOptions)));
+    }
+  };
+}