@heartlandone/vega 2.79.0 → 2.80.0

package/dist/collection/components/vega-rich-text-editor/dto/filter-styles-strategies/text-node/text-format-filter-styles-strategy.js

@@ -0,0 +1,89 @@
+import { RTEFilterStylesStrategy } from '../filter-styles-strategy.abstract';
+import { BOLD_FONT_WEIGHT, ITALIC_FONT_STYLE, STRIKETHROUGH_TEXT_DECORATION, UNDERLINE_TEXT_DECORATION, } from '../../annotations/text-format-default-styles';
+/**
+ * Filters redundant inline text formatting styles from `customStyle` when
+ * parsing an RTETextNode. These styles are already represented by semantic
+ * annotations and should not be persisted as custom overrides after source
+ * edit round-trips.
+ */
+export class TextFormatFilterStylesStrategy extends RTEFilterStylesStrategy {
+  constructor() {
+    super(...arguments);
+    this.stylesToBeFiltered = {};
+  }
+  /**
+   * @returns {boolean} Always `true` — this strategy runs regardless of `autoMatchFormat`.
+   */
+  get alwaysFilter() {
+    return true;
+  }
+  /**
+   * Filter redundant text format styles from `customStyle`.
+   *
+   * @param {VegaRTEAnnotations} annotations - The annotations to filter.
+   * @returns {VegaRTEAnnotations} The same annotations reference with customStyle cleaned up.
+   */
+  filterAnnotations(annotations) {
+    const textAnnotations = annotations;
+    const customStyle = textAnnotations.customStyle;
+    if (!customStyle) {
+      return annotations;
+    }
+    // Only delete styles that match the default values(BOLD_FONT_WEIGHT) to avoid affecting normal-source conversion.
+    if (textAnnotations.bold && customStyle.fontWeight === BOLD_FONT_WEIGHT) {
+      delete customStyle.fontWeight;
+    }
+    if (textAnnotations.italic && customStyle.fontStyle === ITALIC_FONT_STYLE) {
+      delete customStyle.fontStyle;
+    }
+    const normalizedTextDecoration = this.normalizeTextDecoration(customStyle.textDecoration);
+    if (normalizedTextDecoration &&
+      this.shouldRemoveTextDecoration(normalizedTextDecoration, textAnnotations)) {
+      delete customStyle.textDecoration;
+    }
+    if (Object.keys(customStyle).length === 0) {
+      delete textAnnotations.customStyle;
+    }
+    return annotations;
+  }
+  /**
+   * Normalizes a `text-decoration` CSS value to a sorted, unique token string of
+   * toolbar-only tokens (`underline`, `line-through`). Returns `undefined` if the
+   * value contains any non-toolbar token (e.g. `wavy`, a color).
+   *
+   * @param {string | undefined} value - The raw `textDecoration` CSS value.
+   * @returns {string | undefined} Normalized token string, or `undefined` if the value cannot be safely removed.
+   */
+  normalizeTextDecoration(value) {
+    if (!value) {
+      return undefined;
+    }
+    const tokens = value.trim().toLowerCase().split(/\s+/);
+    if (tokens.some((token) => token !== UNDERLINE_TEXT_DECORATION && token !== STRIKETHROUGH_TEXT_DECORATION)) {
+      return undefined;
+    }
+    return Array.from(new Set(tokens)).sort().join(' ');
+  }
+  /**
+   * Determines whether the `textDecoration` custom style should be removed based on the
+   * semantic annotations present. Removal happens only when the normalized value exactly
+   * matches the set of `{underline, strikethrough}` annotations.
+   *
+   * @param {string} normalizedTextDecoration - The normalized `textDecoration` token string.
+   * @param {VegaRTETextAnnotations} annotations - The text annotations to check against.
+   * @returns {boolean} `true` if the `textDecoration` style is redundant and should be removed.
+   */
+  shouldRemoveTextDecoration(normalizedTextDecoration, annotations) {
+    const expectedTokens = [];
+    if (annotations.underline) {
+      expectedTokens.push(UNDERLINE_TEXT_DECORATION);
+    }
+    if (annotations.strikethrough) {
+      expectedTokens.push(STRIKETHROUGH_TEXT_DECORATION);
+    }
+    if (expectedTokens.length === 0) {
+      return false;
+    }
+    return normalizedTextDecoration === expectedTokens.sort().join(' ');
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/setup.js

@@ -23,6 +23,14 @@ import { SpanImageToRTEImageBlockStrategy } from '../slimmers/controllers/helper
 import { ContinueInlineToRTETextBlockStrategy } from '../slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy';
 import { PlainTextToTextNodeStrategy } from '../slimmers/controllers/helper/element-to-dto-strategy/plain-text-to-text-node-strategy';
 import { InlineElementToTextNodeStrategy } from '../slimmers/controllers/helper/element-to-dto-strategy/inline-element-to-text-node-strategy';
+import { RTEFilterStylesStrategyRegistry } from './filter-styles-strategies/filter-styles-strategy-registry';
+import { ImageFilterStylesStrategy } from './filter-styles-strategies/image-node/image-filter-styles-strategy';
+import { ListBlockFilterStylesStrategy } from './filter-styles-strategies/list-block/list-block-filter-styles-strategy';
+import { ListItemBlockFilterStylesStrategy } from './filter-styles-strategies/list-block/list-item-block-filter-styles-strategy';
+import { AlignmentFilterStylesStrategy } from './filter-styles-strategies/text-block/alignment-filter-styles-strategy';
+import { CodeFilterStylesStrategy } from './filter-styles-strategies/text-node/code-filter-styles-strategy';
+import { LinkFilterStylesStrategy } from './filter-styles-strategies/text-node/link-filter-styles-strategy';
+import { TextFormatFilterStylesStrategy } from './filter-styles-strategies/text-node/text-format-filter-styles-strategy';
 /**
  * Register and setup the default DTO classes and their basic action strategies.
  */
@@ -67,3 +75,13 @@ ElementToDTOClassStrategyManager.registerElementToBlockStrategy(new UlToRTEListB
 ElementToDTOClassStrategyManager.registerElementToBlockStrategy(new HtmlBlockStrategy());
 ElementToDTOClassStrategyManager.registerElementToNodeStrategy(new InlineElementToTextNodeStrategy());
 ElementToDTOClassStrategyManager.registerElementToNodeStrategy(new PlainTextToTextNodeStrategy());
+// Register filter styles strategies (remove redundant default styles during HTML → DTO conversion)
+RTEFilterStylesStrategyRegistry.register(RTEListBlock.name, new ListBlockFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.name, new ListItemBlockFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextBlock.name, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListBlock.name, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEListItemBlock.name, new AlignmentFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTEImageNode.name, new ImageFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.name, new LinkFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.name, new TextFormatFilterStylesStrategy());
+RTEFilterStylesStrategyRegistry.register(RTETextNode.name, new CodeFilterStylesStrategy());

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/bold-annotaion-handler.js

@@ -1,4 +1,5 @@
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { BOLD_FONT_WEIGHT, BOLD_FONT_WEIGHT_KEYWORD, } from '../../../../../dto/annotations/text-format-default-styles';
 /** Handle bold annotation */
 export class BoldAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
@@ -26,8 +27,8 @@ export class BoldAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   isBold(element) {
     return (element.nodeName === 'STRONG' ||
       element.nodeName === 'B' ||
-      element.style.fontWeight === 'bold' ||
-      element.style.fontWeight === '700' ||
+      element.style.fontWeight === BOLD_FONT_WEIGHT_KEYWORD ||
+      element.style.fontWeight === BOLD_FONT_WEIGHT ||
       element.classList.contains('v-rte--bold'));
   }
 }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator.js

@@ -10,6 +10,8 @@ import { ItalicAnnotationHandler } from './italic-annotation-handler';
 import { LinkAnnotationHandler } from './link-annotation-handler';
 import { StrikeThroughAnnotationHandler } from './strike-through-annotation-handler';
 import { UnderlineAnnotationHandler } from './underline-annotation-handler';
+import { TextStyleAnnotation } from '../../../../../dto/annotations/text-style-annotation';
+import { RTEFilterStylesStrategyRegistry } from '../../../../../dto/filter-styles-strategies/filter-styles-strategy-registry';
 import { TextStyleAnnotationHandler } from './text-style-annotation-handler';
 import { ImageSizeAnnotationHandler } from './image-size-annotation-handler';
 import { ImageAltAnnotationHandler } from './image-alt-annotation-handler';
@@ -32,7 +34,6 @@ class HtmlElementToAnnotationGenerator {
       new CustomAttributeAnnotationHandler(),
       new CustomClassAnnotationHandler(),
       new CustomStyleAnnotationHandler(),
-      new LinkAnnotationHandler(),
       new TextStyleAnnotationHandler(),
       new InlineHtmlAnnotationHandler(),
     ];
@@ -60,7 +61,7 @@ class HtmlElementToAnnotationGenerator {
    */
   generate(targetDto, element, options = { autoMatchFormat: true }) {
     const isLinkElement = element.tagName === 'A';
-    return this.handlers
+    const annotations = this.handlers
       .filter((handler) => !options.autoMatchFormat && isLinkElement ? handler instanceof LinkAnnotationHandler : true)
       .filter((handler) => element.nodeType !== Node.TEXT_NODE &&
       handler.canHandle(targetDto, {
@@ -71,6 +72,43 @@ class HtmlElementToAnnotationGenerator {
       const result = handler.handle(element, options.parentAnnotations);
       return Object.assign(Object.assign({}, annotations), result);
     }, {});
+    this.removeTextStyleDefaultsFromCustomStyle(annotations);
+    const strategies = RTEFilterStylesStrategyRegistry.getStrategies(targetDto.name);
+    for (const strategy of strategies) {
+      if (options.autoMatchFormat || strategy.alwaysFilter) {
+        strategy.filterAnnotations(annotations);
+      }
+    }
+    return annotations;
+  }
+  /**
+   * Remove default text-style properties from customStyle.
+   * This prevents repeated styling when switching between source edit and normal mode.
+   *
+   * Note: This method mutates the customStyle object inside `annotations` in place and returns the same reference.
+   *
+   * @param {V} annotations - The generated annotations.
+   * @returns {V} The same annotations reference with customStyle cleaned up.
+   */
+  removeTextStyleDefaultsFromCustomStyle(annotations) {
+    const textStyle = 'textStyle' in annotations ? annotations.textStyle : undefined;
+    const customStyle = annotations.customStyle;
+    if (!textStyle || !customStyle) {
+      return annotations;
+    }
+    const defaultStyles = TextStyleAnnotation.getDefaultStyles(textStyle);
+    if (!defaultStyles) {
+      return annotations;
+    }
+    for (const key of Object.keys(defaultStyles)) {
+      if (customStyle[key] === defaultStyles[key]) {
+        delete customStyle[key];
+      }
+    }
+    if (Object.keys(customStyle).length === 0) {
+      delete annotations.customStyle;
+    }
+    return annotations;
   }
 }
 export default new HtmlElementToAnnotationGenerator();

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/italic-annotation-handler.js

@@ -1,4 +1,5 @@
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { ITALIC_FONT_STYLE } from '../../../../../dto/annotations/text-format-default-styles';
 /** Handle italic annotation */
 export class ItalicAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
@@ -25,7 +26,7 @@ export class ItalicAnnotationHandler extends AnnotationGeneratorStrategyAbstract
    */
   isItalic(element) {
     return (element.nodeName === 'I' ||
-      element.style.fontStyle === 'italic' ||
+      element.style.fontStyle === ITALIC_FONT_STYLE ||
       element.nodeName === 'EM' ||
       element.classList.contains('v-rte--italic'));
   }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/strike-through-annotation-handler.js

@@ -1,4 +1,5 @@
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { STRIKETHROUGH_TEXT_DECORATION } from '../../../../../dto/annotations/text-format-default-styles';
 /** Handle strike through annotation */
 export class StrikeThroughAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
@@ -26,7 +27,7 @@ export class StrikeThroughAnnotationHandler extends AnnotationGeneratorStrategyA
    * @returns {boolean} - boolean.
    */
   isStrikethrough(element) {
-    return (element.style.textDecoration.includes('line-through') ||
+    return (element.style.textDecoration.includes(STRIKETHROUGH_TEXT_DECORATION) ||
       element.nodeName === 'S' ||
       element.nodeName === 'DEL' ||
       element.classList.contains('v-rte--strikethrough'));

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/text-style-annotation-handler.js

@@ -86,6 +86,8 @@ export class TextStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstr
    */
   getElementTypeByNodeName(element) {
     switch (element.nodeName) {
+      case 'P':
+        return 'paragraph';
       case 'H1':
         return 'heading-1';
       case 'H2':
@@ -110,7 +112,7 @@ export class TextStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstr
    */
   getElementTypeByClassName(element) {
     if (element.className) {
-      const match = /\bv-rte--text-style-(title|subtitle|heading-1|heading-2|heading-3|paragraph)\b/.exec(element.className);
+      const match = /\bv-rte--text-style-(title|subtitle|heading-1|heading-2|heading-3|heading-4|heading-5|heading-6|paragraph)\b/.exec(element.className);
       if (match) {
         return match[1];
       }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/underline-annotation-handler.js

@@ -1,4 +1,5 @@
 import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { UNDERLINE_TEXT_DECORATION } from '../../../../../dto/annotations/text-format-default-styles';
 /** Handle underline annotation */
 export class UnderlineAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   /**
@@ -24,7 +25,7 @@ export class UnderlineAnnotationHandler extends AnnotationGeneratorStrategyAbstr
    * @returns {boolean} - boolean.
    */
   isUnderline(element) {
-    return (element.style.textDecoration.includes('underline') ||
+    return (element.style.textDecoration.includes(UNDERLINE_TEXT_DECORATION) ||
       element.nodeName === 'U' ||
       element.nodeName === 'INS' ||
       element.classList.contains('v-rte--underline'));

package/dist/collection/helpers/calendar/calendar-date.js

@@ -3,6 +3,7 @@ import { CalendarDateTime } from './calendar-date-time';
 import { getSystemTimezone } from './utils';
 import { DateFormatParserRegex } from '../../constants/regex';
 import { compareIsAfter, compareIsBefore, pad } from '../../utils/date';
+export const WEEKDAYS_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 // TODO: Need rename calendar-date as vega-date to manage all date operation in vega project
 // https://gethired.atlassian.net/browse/VD-5918
 /**
@@ -373,6 +374,15 @@ export class CalendarDate {
     const adjustedDate = new Date(currentDate.getFullYear() + years, currentDate.getMonth() + months, currentDate.getDate() + days);
     return CalendarDate.from(adjustedDate);
   }
+  /**
+   * Get the short name of the week day for the calendar date.
+   *
+   * @returns {string} - The short name of the week day.
+   */
+  getWeekDayShortName() {
+    const currentDate = this.toDate();
+    return WEEKDAYS_SHORT[currentDate.getDay()];
+  }
   /**
    * Get year, month and day value by format token.
    *

package/dist/collection/helpers/calendar/calendar-view-generator/calendar-view-generator.abstract.js

@@ -1,10 +1,10 @@
 import { getWeekdays } from '../utils';
+import { WEEKDAYS_SHORT } from '../calendar-date';
 /**
  * Calendar view generator abstract class.
  */
 export class CalendarViewGenerator {
   constructor() {
-    this.WEEKDAYS_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
     this.weekdays = getWeekdays();
   }
   /**
@@ -13,7 +13,7 @@ export class CalendarViewGenerator {
    * @returns {string[]} - The weekday strings
    */
   getWeekdayNames() {
-    return this.WEEKDAYS_SHORT;
+    return WEEKDAYS_SHORT;
   }
   /**
    * Generate calendar dates

package/dist/collection/helpers/event-manager/event-id/vega-internal-event-id.js

@@ -57,6 +57,7 @@ export const VegaInternalCalendarEventPreviewClear = new VegaInternalEventID('ca
 export const VegaInternalUpdateRTECursorPosition = new VegaInternalEventID('InternalUpdateRTECursorPosition');
 export const VegaInternalLeftNavLinkSelectedTopic = new VegaInternalEventID('leftNavLinkSelectedTopic');
 export const VegaInternalCalendarEventPreviewHide = new VegaInternalEventID('calendarEventPreviewHide');
+export const VegaInternalDialogContentReady = new VegaInternalEventID('dialogContentReady');
 export const VegaInternalFormSubmit = new VegaInternalEventID('formSubmit');
 export const VegaInternalFormReset = new VegaInternalEventID('formReset');
 export const VegaInternalProgressTrackerStepClick = new VegaInternalEventID('progressTrackerStepClick');

package/dist/collection/helpers/formatter/string-formatter/custom-formatter-strategy.js

@@ -13,12 +13,14 @@ export class CustomFormatterStrategy extends StringFormatStrategy {
    * formatter class likely contains methods or properties related to formatting strings in a specific
    * way according to your requirements.
    * @param {boolean} resetCaretPosition - The caret position should update to the last or keep the current position after format
+   * @param {boolean} overrideValue - Whether to override the value after blur, default is false
    */
-  constructor(formatter, resetCaretPosition = false) {
+  constructor(formatter, resetCaretPosition = false, overrideValue = false) {
     super();
     this.resetCaretPositionFlag = false;
     this.formatter = formatter;
     this.resetCaretPositionFlag = resetCaretPosition;
+    this.overrideValue = overrideValue;
   }
   /**
    * The format function in TypeScript takes a string input and returns the formatted output using a

package/dist/collection/helpers/formatter/string-formatter/number-mask-strategy.js

@@ -8,8 +8,9 @@ export class NumberMaskStrategy extends StringFormatStrategy {
    * It creates a new instance of the Mask class.
    *
    * @param {NumberMaskConfig} maskConfig - MaskConfig
+   * @param {boolean} overrideValue - Whether to override the value after blur, default is false
    */
-  constructor(maskConfig) {
+  constructor(maskConfig, overrideValue = false) {
     super();
     this.maskConfig = { allowNegative: true };
     /**
@@ -28,6 +29,7 @@ export class NumberMaskStrategy extends StringFormatStrategy {
           !input.startsWith('.')));
     };
     this.maskConfig = Object.assign(Object.assign({}, this.maskConfig), maskConfig);
+    this.overrideValue = overrideValue;
     this.mask = new RegExp(this.getRegExp());
   }
   /**

package/dist/collection/helpers/formatter/string-formatter/number-thousand-comma-strategy.js

@@ -7,9 +7,10 @@ export class NumberThousandCommaStrategy extends NumberMaskStrategy {
    * It creates a new instance of the Mask class.
    *
    * @param {NumberMaskConfig} maskConfig - MaskConfig
+   * @param {boolean} overrideValue - Whether to override the value after blur, default is false
    */
-  constructor(maskConfig) {
-    super(maskConfig);
+  constructor(maskConfig, overrideValue = false) {
+    super(maskConfig, overrideValue);
   }
   /**
    * If the input is a number, format it as a thousand comma string

package/dist/collection/helpers/formatter/string-formatter/string-format-strategy.abstract.js

@@ -3,6 +3,9 @@ import { isNonNullable } from '../../../types/type-guard';
  * String format strategy abstract class
  */
 export class StringFormatStrategy {
+  constructor() {
+    this.overrideValue = false;
+  }
   /**
    * Check if the {@link format} should be applied
    *
@@ -42,7 +45,7 @@ export class StringFormatStrategy {
    * @returns {boolean} - Whether the component value should be overridden.
    */
   shouldOverrideComponentValueAfterBlur() {
-    return false;
+    return this.overrideValue;
   }
   /**
    * Determines whether the format should be triggered at init.

package/dist/collection/helpers/formatter/string-formatter/string-mask-strategy.js

@@ -10,8 +10,9 @@ export class StringMaskStrategy extends StringFormatStrategy {
    * It creates a new instance of the Mask class.
    *
    * @param {MaskConfig} maskConfig - MaskConfig
+   * @param {boolean} overrideValue - Whether to override the value after blur, default is false
    */
-  constructor(maskConfig) {
+  constructor(maskConfig, overrideValue = false) {
     super();
     /**
      * The insert mode means adding some special character in the input string, will replace part of input string if insertMode set to false.
@@ -26,10 +27,38 @@ export class StringMaskStrategy extends StringFormatStrategy {
      */
     this.insertMode = true;
     this.maskConfig = maskConfig;
+    this.overrideValue = overrideValue;
     this.slotRegex = new RegExp(maskConfig.slot);
     this.acceptRegex = new RegExp(maskConfig.accept, 'g');
     this.insertMode = maskConfig.insertMode === false ? false : true;
   }
+  /**
+   * A static method that generates a phone mask strategy based on the provided mask configuration.
+   *
+   * @param {boolean} overrideValue - The `overrideValue` parameter determines whether the component value should be overridden on blur.
+   * @returns {StringMaskStrategy} Returns an instance of the `StringMaskStrategy` class.
+   */
+  static getPhoneMaskStrategy(overrideValue = false) {
+    return new StringMaskStrategy(this.DEFAULT_PHONE_MASK_CONFIG, overrideValue);
+  }
+  /**
+   * A static method that generates a zipcode mask strategy based on the provided mask configuration.
+   *
+   * @param {boolean} overrideValue - The `overrideValue` parameter determines whether the component value should be overridden on blur.
+   * @returns {StringMaskStrategy} Returns an instance of the `StringMaskStrategy` class.
+   */
+  static getZipcodeMaskStrategy(overrideValue = false) {
+    return new StringMaskStrategy(this.DEFAULT_ZIPCODE_MASK_CONFIG, overrideValue);
+  }
+  /**
+   * A static method that generates a tax ID mask strategy based on the provided mask configuration.
+   *
+   * @param {boolean} overrideValue - The `overrideValue` parameter determines whether the component value should be overridden on blur.
+   * @returns {StringMaskStrategy} Returns an instance of the `StringMaskStrategy` class.
+   */
+  static getTaxIdMaskStrategy(overrideValue = false) {
+    return new StringMaskStrategy(this.DEFAULT_TAX_ID_MASK_CONFIG, overrideValue);
+  }
   /**
    * Set the mask config
    *
@@ -76,6 +105,8 @@ export class StringMaskStrategy extends StringFormatStrategy {
    * return false if property overrideValue is not exist or set to true, return false if maskConfig is not exist
    */
   shouldOverrideComponentValueAfterBlur() {
+    if (this.overrideValue)
+      return true;
     if (!this.maskConfig || this.maskConfig.overrideValue !== true) {
       return false;
     }
@@ -150,18 +181,18 @@ export class StringMaskStrategy extends StringFormatStrategy {
     return resultStringBuilder.join('').slice(0, resultLength);
   }
 }
-StringMaskStrategy.PHONE_MASK = new StringMaskStrategy({
+StringMaskStrategy.DEFAULT_PHONE_MASK_CONFIG = {
   mask: '(999) 999-9999',
   slot: '9',
   accept: /\d/g,
-});
-StringMaskStrategy.ZIPCODE_MASK = new StringMaskStrategy({
+};
+StringMaskStrategy.DEFAULT_ZIPCODE_MASK_CONFIG = {
   mask: '99999',
   slot: '9',
   accept: /\d/g,
-});
-StringMaskStrategy.TAX_ID_MASK = new StringMaskStrategy({
+};
+StringMaskStrategy.DEFAULT_TAX_ID_MASK_CONFIG = {
   mask: '99-9999999',
   slot: '9',
   accept: /\d/g,
-});
+};

package/dist/collection/helpers/formatter/string-formatter/thousand-comma-strategy.js

@@ -5,6 +5,10 @@ import { StringFormatStrategy } from './string-format-strategy.abstract';
  * @augments StringFormatStrategy
  */
 export class ThousandCommaStrategy extends StringFormatStrategy {
+  constructor(overrideValue = false) {
+    super();
+    this.overrideValue = overrideValue;
+  }
   /**
    * If the input is a number, format it as a string
    *

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

@@ -58,7 +58,12 @@ class KeyboardManager {
   invokeListeners(eventName, event) {
     this.listeners
       .filter((listener) => listener.eventName === eventName && this.shouldInvokeListener(listener, event))
-      .forEach((listener) => listener.callback(event));
+      .forEach((listener) => {
+      if (listener.preventDefault) {
+        event.preventDefault();
+      }
+      listener.callback(event);
+    });
   }
   /**
    * > If the keyCode is accepted, and the activeElement is in the scope, and the activeElement is not
@@ -101,14 +106,17 @@ class KeyboardManager {
     }
     const isActiveElementInScope = listener.activeElementInScope
       ? activeElementInScope.some((element) => {
-        return isParent(getDeepActiveElementInShadow(), element);
+        // eslint-disable-next-line no-restricted-globals
+        return isParent(getDeepActiveElementInShadow(document, true), element);
       })
       : true;
     if (!isActiveElementInScope) {
       return false;
     }
     const isActiveElementOutScope = listener.activeElementOutScope
-      ? activeElementOutScope.every((element) => !isParent(getDeepActiveElementInShadow(), element))
+      ? activeElementOutScope.every((element) => 
+      // eslint-disable-next-line no-restricted-globals
+      !isParent(getDeepActiveElementInShadow(document, true), element))
       : true;
     const isExpectedModifierPressed = isNonNullable(listener.modifierPressed)
       ? listener.modifierPressed === this.isModifierPressed(event)

package/dist/collection/helpers/slimmers/aria-dialog-focusable-trap-slimmer.js

@@ -7,6 +7,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
 import { checkIsVoiceOverClick, getDeepActiveElementInShadow } from '../../utils/ui';
 import { SynchronizeTaskQueue } from '../queue/synchronize-task-queue';
+import { Observer } from '../change-manager/observer/observer';
+import ChangeManager from '../change-manager/change-manager';
+import { VegaInternalDialogContentReady } from '../event-manager/event-id/vega-internal-event-id';
+import domNodeSubjectFactory from '../change-manager/subject/dom-node-subject/dom-node-subject-factory';
 const focusableSelector = [
   'a[href]',
   'area[href]',
@@ -33,6 +37,9 @@ export class AriaDialogFocusableTrapSlimmer extends VegaSlimmer {
     this.isVoiceOverClick = false;
     this.focusTriggerElement = null;
     this.focusDialogTaskQueue = new SynchronizeTaskQueue();
+    this.dialogContentReadyObserver = null;
+    this.dialogContentReadySubject = null;
+    this.isChildFocused = false;
     /**
      * Sets up the event listener for click events on the trigger element or the window.
      */
@@ -118,6 +125,24 @@ export class AriaDialogFocusableTrapSlimmer extends VegaSlimmer {
         return false;
       return element.tabIndex >= 0;
     };
+    /**
+     * Focuses on the first focusable element within the dialog when the dialog content is ready and the last interaction was detected as a VoiceOver click. This method is called in response to the dialog content ready notification, ensuring that focus is set appropriately when the dialog is shown after being triggered by VoiceOver.
+     * It retrieves the currently active element, stores it as the trigger element, and then focuses on the first focusable element within the dialog content.
+     *
+     */
+    this.focusOnFirstFocusableElement = () => {
+      if (!this.isChildFocused) {
+        const dialogElement = this.entry.dialogEl();
+        const focusableElement = this.getFirstFocusableElement(dialogElement);
+        if (focusableElement) {
+          this.isChildFocused = true;
+          focusableElement.focus();
+        }
+        else {
+          dialogElement.focus();
+        }
+      }
+    };
     this.entry = entry;
   }
   /**
@@ -125,18 +150,21 @@ export class AriaDialogFocusableTrapSlimmer extends VegaSlimmer {
    */
   connectedCallback() {
     this.eventListenerHandler();
+    this.subscribeDialogContentReady();
   }
   /**
    * Removes the event listener for click events from the trigger element or the window when the component is disconnected from the DOM.
    */
   disconnectedCallback() {
     this.eventListenerRemover();
+    this.unsubscribeDialogContentReady();
   }
   /**
    * Sets up the event listener for click events on the trigger element or the window after the component has loaded.
    */
   componentDidLoad() {
     this.eventListenerHandler();
+    this.subscribeDialogContentReady();
   }
   /**
    * Ensures that any pending focus actions are executed after the component has rendered.
@@ -165,17 +193,16 @@ export class AriaDialogFocusableTrapSlimmer extends VegaSlimmer {
    * @returns {Promise<void>} A promise that resolves when the focus action is complete.
    */
   async show() {
-    const activeEl = getDeepActiveElementInShadow();
+    // eslint-disable-next-line no-restricted-globals
+    const activeEl = getDeepActiveElementInShadow(document, true);
     if (activeEl) {
+      this.isChildFocused = false;
       await this.focusDialogTaskQueue.enqueue({
         // eslint-disable-next-line jsdoc/require-jsdoc
         run: async () => {
           if (this.isVoiceOverClick) {
             this.focusTriggerElement = activeEl;
-            const dialogElement = this.entry.dialogEl();
-            const focusableElement = this.getFirstFocusableElement(dialogElement) || dialogElement;
-            focusableElement.focus();
-            this.isVoiceOverClick = false;
+            this.focusOnFirstFocusableElement();
           }
         },
       }, false);
@@ -198,6 +225,33 @@ export class AriaDialogFocusableTrapSlimmer extends VegaSlimmer {
       }, false);
     }
   }
+  /**
+   * Subscribes to the dialog content ready ChangeManager subject if configured.
+   * When the external component notifies that dialog content is rendered,
+   * the observer retries focusing the first focusable element in the dialog.
+   */
+  subscribeDialogContentReady() {
+    const dialogElement = this.entry.dialogEl();
+    if (dialogElement && !this.dialogContentReadySubject) {
+      this.dialogContentReadySubject = domNodeSubjectFactory.getSubject(this.entry.dialogEl(), VegaInternalDialogContentReady);
+      this.dialogContentReadyObserver = new Observer((_payload) => true, () => {
+        if (this.isVoiceOverClick) {
+          this.focusOnFirstFocusableElement();
+        }
+      });
+      ChangeManager.register(this.dialogContentReadySubject, this.dialogContentReadyObserver);
+    }
+  }
+  /**
+   * Unsubscribes from the dialog content ready ChangeManager subject.
+   */
+  unsubscribeDialogContentReady() {
+    if (this.dialogContentReadyObserver && this.dialogContentReadySubject) {
+      ChangeManager.unregister(this.dialogContentReadySubject, this.dialogContentReadyObserver);
+      this.dialogContentReadyObserver = null;
+      this.dialogContentReadySubject = null;
+    }
+  }
 }
 __decorate([
   MapToComponentMethod('connectedCallback')