@globalpayments/vega 2.66.0 → 2.68.0

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

@@ -23,7 +23,7 @@ export class VegaRichTextEditorRenderer extends VegaSlimmer {
           'disabled': this.disabled,
           'vega-hidden': this.sourceView,
         }, style: { minHeight: `${this.rows * 24}px` }, onClick: this.richTextContentFocus, role: "textbox", tabIndex: !this.disabled ? -1 : 0, onKeyDown: createEnterKeyHandlerToTriggerClick(), ref: (node) => (this.richTextContainerRef = node) },
-        h("vega-rich-text-content", { ref: (ref) => (this.richTextContentRef = ref), content: this.value }),
+        h("vega-rich-text-content", { ref: (ref) => (this.richTextContentRef = ref), content: this.value, extensions: this.extensions }),
         this.renderCharacterCounter()));
     };
     this.renderCharacterCounter = () => {
@@ -155,6 +155,9 @@ __decorate([
 __decorate([
   MapToComponentField()
 ], VegaRichTextEditorRenderer.prototype, "allowSourceEdit", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "extensions", void 0);
 __decorate([
   MapToComponentMethod('componentDidRender')
 ], VegaRichTextEditorRenderer.prototype, "componentDidRender", null);

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/action-handle-strategy-registry.test.js

@@ -1,7 +1,13 @@
 import { LogUtility } from '../../../../../utils/log';
+import { ActionHandlerInterceptorRegistry } from '../../../dto/action-handle-strategies/action-handle-interceptor-registry';
+import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
 import { ActionHandleStrategyRegistry } from '../../../dto/action-handle-strategies/action-handle-strategy-registry';
 import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { AppendChildrenStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/append-children-strategy';
 import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
+import { ModifyContentActionType, } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
 import { RTEImageNode } from '../../../dto/nodes/image-node';
 import { RTETextNode } from '../../../dto/nodes/text-node';
 class MockAnnotationAction extends AnnotationAction {
@@ -33,9 +39,33 @@ test('ActionHandleStrategyRegistry methods executeTheStrategy should work proper
   expect(strategy.handleAction).toBeCalledWith(action, target);
 });
 test('ActionHandleStrategyRegistry methods executeTheStrategy should log error if the strategy is not exist', () => {
-  spyOn(LogUtility, 'error');
+  spyOn(LogUtility, 'warn');
   const action = new MockAnnotationAction();
   const target = new RTEImageNode('1', 'test url', null);
   ActionHandleStrategyRegistry.executeTheStrategy(action, target);
-  expect(LogUtility.error).toBeCalledWith(`Type MockAnnotationAction action handle strategy is not registered in class RTEImageNode`);
+  expect(LogUtility.warn).toBeCalledWith(`Type MockAnnotationAction action handle strategy is not registered in class RTEImageNode`);
+});
+test('ActionHandleStrategyRegistry methods executeTheStrategy should work properly when interceptor is present', () => {
+  const customAction = new AppendChildrenAction([new RTETextNode('1', 'child', null)]);
+  const block = new RTETextBlock('block1', 'paragraph');
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILDREN, RTETextBlock.name, new AppendChildrenStrategy());
+  class CustomInterceptorStrategy extends ActionHandlerInterceptor {
+    canIntercept(_action, target) {
+      return !!target;
+    }
+    intercept() {
+      LogUtility.warn('Interceptor executed');
+    }
+  }
+  const interceptor = new CustomInterceptorStrategy();
+  spyOn(interceptor, 'canIntercept').and.callThrough();
+  spyOn(interceptor, 'intercept').and.callThrough();
+  ActionHandlerInterceptorRegistry.register(ModifyContentActionType.APPEND_CHILDREN, RTETextBlock.name, interceptor);
+  block.apply(customAction);
+  expect(interceptor.intercept).toBeCalledTimes(1);
+  expect(interceptor.intercept).toBeCalledTimes(1);
+  expect(block.children.length).toBe(0);
+  ActionHandlerInterceptorRegistry.unregister(ModifyContentActionType.APPEND_CHILDREN, RTETextBlock.name, interceptor);
+  block.apply(customAction);
+  expect(block.children.length).toBe(1);
 });

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/block-delete-node-content-strategy.test.js

@@ -0,0 +1,69 @@
+import { BlockDeleteNodeContentStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-delete-node-content-strategy';
+import { VegaRTEContent } from '../../../dto/content-state';
+class MockDeleteStrategy extends BlockDeleteNodeContentStrategy {
+  getPreviousBlockMethod(currentBlock) {
+    return super['getPreviousBlock'](currentBlock);
+  }
+  handleAction() {
+    throw new Error('Method not implemented.');
+  }
+}
+const strategy = new MockDeleteStrategy();
+test('BlockDeleteNodeContentStrategy#getPreviousBlock should work properly', () => {
+  const content = VegaRTEContent.fromJSON([
+    {
+      id: '1',
+      type: 'paragraph',
+      nodes: [
+        { id: '1-1', type: 'text', text: 'A' },
+        { id: '1-1', type: 'text', text: 'B' },
+      ],
+    },
+    {
+      id: '2',
+      type: 'paragraph',
+      nodes: [],
+    },
+    {
+      id: '2',
+      type: 'html-block',
+      children: [
+        {
+          id: '2-1',
+          type: 'paragraph',
+          nodes: [],
+        },
+        {
+          id: '2-2',
+          type: 'paragraph',
+          nodes: [],
+        },
+      ],
+    },
+    {
+      id: '3',
+      type: 'number-list',
+      blocks: [
+        {
+          id: '3-1',
+          type: 'list-item',
+          nodes: [],
+        },
+        {
+          id: '3-2',
+          type: 'list-item',
+          nodes: [],
+        },
+      ],
+    },
+  ]);
+  const htmlBlock = content.children[2];
+  const list = content.children[3];
+  expect(strategy.getPreviousBlockMethod(content.children[0])).toBeUndefined();
+  expect(strategy.getPreviousBlockMethod(content.children[1])).toEqual(content.children[0]);
+  expect(strategy.getPreviousBlockMethod(htmlBlock)).toEqual(content.children[1]);
+  expect(strategy.getPreviousBlockMethod(htmlBlock.children[0])).toEqual(content.children[1]);
+  expect(strategy.getPreviousBlockMethod(htmlBlock.children[1])).toEqual(htmlBlock.children[0]);
+  expect(strategy.getPreviousBlockMethod(list.children[0])).toEqual(htmlBlock);
+  expect(strategy.getPreviousBlockMethod(list.children[1])).toEqual(list.children[0]);
+});

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

@@ -0,0 +1,70 @@
+import { RTEAnnotationStyle } from '../../dto/annotations/annotation-style';
+import { RTETextBlock } from '../../dto/blocks/text-block';
+import '../../dto/setup';
+describe('annotation-style', () => {
+  it('toCssText', () => {
+    const textBlock = RTETextBlock.from({
+      id: '1',
+      type: 'paragraph',
+      annotations: {
+        textAlign: 'center',
+        customStyle: {
+          color: 'red',
+          fontSize: '16px',
+        },
+      },
+      nodes: [],
+    });
+    const blockAnnotationStyle = new RTEAnnotationStyle(textBlock);
+    expect(blockAnnotationStyle.toCssText()).toEqual('color: red;font-size: 16px;');
+    expect(blockAnnotationStyle.toCssText({ standalone: true })).toEqual('font-family: Inter;font-size: 16px;line-height: 22px;font-weight: 500;margin-top: 0px;margin-bottom: 0px;text-align: center;color: red;');
+    expect(blockAnnotationStyle.toCssText(null, null, {})).toEqual('');
+    expect(blockAnnotationStyle.toCssText(null, null, { color: 'red' })).toEqual('color: red;');
+    expect(blockAnnotationStyle.toCssText(null, null, { backgroundColor: 'blue', fontWeight: 'bold' })).toEqual('background-color: blue;font-weight: bold;');
+  });
+  it('toJSON', () => {
+    const textBlock = RTETextBlock.from({
+      id: '1',
+      type: 'paragraph',
+      annotations: {
+        textAlign: 'center',
+        customStyle: {
+          color: 'red',
+          fontSize: '16px',
+        },
+      },
+      nodes: [
+        {
+          id: 'n1',
+          type: 'text',
+          text: 'Sample text',
+          annotations: {
+            bold: true,
+            italic: false,
+            underline: true,
+            customStyle: {
+              textDecoration: 'line-through',
+            },
+          },
+        },
+      ],
+    });
+    const blockAnnotationStyle = new RTEAnnotationStyle(textBlock);
+    expect(blockAnnotationStyle.toJSON({ standalone: true })).toEqual({
+      color: 'red',
+      fontFamily: 'Inter',
+      fontSize: '16px',
+      fontWeight: '500',
+      lineHeight: '22px',
+      marginBottom: '0px',
+      marginTop: '0px',
+      textAlign: 'center',
+    });
+    const nodeAnnotationStyle = new RTEAnnotationStyle(textBlock.children[0]);
+    expect(nodeAnnotationStyle.toJSON()).toEqual({ textDecoration: 'line-through' });
+    expect(nodeAnnotationStyle.toJSON({ standalone: true }, ['textDecoration'])).toEqual({
+      fontWeight: '700',
+      textDecoration: 'underline line-through',
+    });
+  });
+});

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-editor-toolbar-button/vega-rich-text-editor-toolbar-button.css

@@ -6,6 +6,9 @@
 :host {
   display: inline-block;
 }
+:host ::slotted(vega-font.v-font-field-label-sm) {
+  line-height: 16px;
+}
 
 .rich-text-editor-toolbar-btn {
   display: flex;

package/dist/collection/components/vega-selection-chip/vega-selection-chip.js

@@ -241,7 +241,7 @@ export class VegaSelectionChip {
       "mutable": false,
       "complexType": {
         "original": "VegaSelectionChipTooltipProps",
-        "resolved": "{ size?: ResponsiveType<SizeType>; trigger?: \"hover\" | \"click\" | \"none\"; positionRelativeTo?: string; minWidth?: ResponsiveType<SizeType>; maxWidth?: ResponsiveType<SizeType>; content?: string; disableInteractive?: boolean; text?: string; alignment?: ElementAppenderAlignmentType; placement?: ElementAppenderPlacementType; }",
+        "resolved": "{ size?: ResponsiveType<SizeType>; trigger?: \"hover\" | \"click\" | \"none\"; positionRelativeTo?: string; minWidth?: ResponsiveType<SizeType>; maxWidth?: ResponsiveType<SizeType>; content?: string; disableInteractive?: boolean; text?: string; placement?: ElementAppenderPlacementType; alignment?: ElementAppenderAlignmentType; }",
         "references": {
           "VegaSelectionChipTooltipProps": {
             "location": "import",

package/dist/collection/components/vega-table/vega-table.css

@@ -59,7 +59,8 @@ table.v-table-fixed {
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
   transition-duration: 150ms;
 }
-.vega-table-scrollable-container.scrolled vega-table-head.fixed-header {
+.vega-table-scrollable-container.scrolled vega-table-head.fixed-header,
+.vega-table-scrollable-container.scrolled ::slotted(vega-table-head.fixed-header) {
   box-shadow: 0px 4px 0px rgba(0, 0, 0, 0.1); /* TODO: wait design token upgrade */
 }
 

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

@@ -14,10 +14,11 @@ import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-co
 import { FORM_ELEMENT_VALUE_CHANGE } from '../../helpers/change-manager/subject/static-subject/static-subject-title';
 import ChangeManager from '../../helpers/change-manager/change-manager';
 import { createEventEmitSlimmer, } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
-import { VegaBlur, VegaChange } from '../../helpers/event-manager/event-id/vega-event-id';
+import { VegaBlur, VegaChange, VegaLabelButtonClick, } from '../../helpers/event-manager/event-id/vega-event-id';
 import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 import { VegaTextareaRuntimeMetricsPayloadDefinition } from '../../constants/runtime-metrics-payload-definition/vega-textarea/runtime-metrics-payload-definition';
+import { DomNodeSubjectObserverFactory } from '../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-observer-factory';
 /**
  * @vegaVersion 1.11.0
  */
@@ -47,6 +48,7 @@ export class VegaTextarea {
     });
     this.changeEventEmitter = createEventEmitSlimmer(VegaTextarea, VegaChange);
     this.blurEventEmitter = createEventEmitSlimmer(VegaTextarea, VegaBlur);
+    this.labelButtonClickEventEmitter = createEventEmitSlimmer(VegaTextarea, VegaLabelButtonClick);
     this.textareaEventPrevent = new ChildNodesEventPreventSlimmer([VegaChange], () => this.inputContainerRef);
     this.vegaComponentUsageRuntimeMetricsSlimmer = new VegaComponentUsageRuntimeMetricsSlimmer(VegaTextareaRuntimeMetricsPayloadDefinition);
     this.currentCharCount = 0;
@@ -82,6 +84,15 @@ export class VegaTextarea {
      * @vegaVersion 1.11.0
      */
     this.label = '';
+    /**
+     * Specifies the properties for the suffix button associated with the input.
+     *
+     * It provides essential information and functionality
+     *  related to the suffix button's role and behavior.
+     *
+     * @vegaVersion __VERSION__
+     */
+    this.labelSuffixButtonConfig = null;
     /**
      * Determines whether to display a character counter
      *    for the textarea.
@@ -192,6 +203,9 @@ export class VegaTextarea {
     this.isExceedMaxLength = (value, maxLength) => {
       return maxLength != null ? value.length > maxLength : false;
     };
+    this.handleLabelButtonClick = () => {
+      this.labelButtonClickEventEmitter.emit();
+    };
   }
   watchValue(value) {
     this.changeEventEmitter.emit(value);
@@ -230,7 +244,9 @@ export class VegaTextarea {
       this.hint && this.renderHintMessage()), this.host);
   }
   renderLabelDom() {
-    return (h("vega-field-label", { onClick: this.inputFocus, "is-field-required": this.required, disabled: this.disabled, label: this.label }));
+    return (h("vega-field-label", { onClick: this.inputFocus, "is-field-required": this.required, disabled: this.disabled, label: this.label, suffixButtonConfig: this.labelSuffixButtonConfig, ref: (node) => {
+        DomNodeSubjectObserverFactory.addUniqueObserverToNode(node, VegaLabelButtonClick, this.handleLabelButtonClick);
+      } }));
   }
   static get is() { return "vega-textarea"; }
   static get encapsulation() { return "shadow"; }
@@ -325,6 +341,34 @@ export class VegaTextarea {
       "reflect": false,
       "defaultValue": "''"
     },
+    "labelSuffixButtonConfig": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "Nullable<LabelSuffixButtonConfig>",
+        "resolved": "{ icon: string; } & Partial<Pick<HTMLVegaTooltipElement, \"size\" | \"trigger\" | \"minWidth\" | \"maxWidth\" | \"text\" | \"placement\" | \"alignment\">>",
+        "references": {
+          "Nullable": {
+            "location": "import",
+            "path": "../../types/general"
+          },
+          "LabelSuffixButtonConfig": {
+            "location": "import",
+            "path": "../vega-field-label/types"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [{
+            "name": "vegaVersion",
+            "text": "__VERSION__"
+          }],
+        "text": "Specifies the properties for the suffix button associated with the input.\n\nIt provides essential information and functionality\n related to the suffix button's role and behavior."
+      },
+      "defaultValue": "null"
+    },
     "showCounter": {
       "type": "boolean",
       "mutable": false,
@@ -620,6 +664,45 @@ export class VegaTextarea {
         "resolved": "undefined",
         "references": {}
       }
+    }, {
+      "method": "vegaLabelButtonClick",
+      "name": "vegaLabelButtonClick",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [{
+            "name": "vegaVersion",
+            "text": "2.68.0"
+          }],
+        "text": "An event emitter notifying that the suffix button associated with the field label has been clicked."
+      },
+      "complexType": {
+        "original": "any",
+        "resolved": "any",
+        "references": {}
+      }
+    }, {
+      "method": "labelButtonClick",
+      "name": "labelButtonClick",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [{
+            "name": "eventSemantics",
+            "text": "namespace:native"
+          }, {
+            "name": "vegaVersion",
+            "text": "2.68.0"
+          }],
+        "text": "An event emitter notifying that the suffix button associated with the field label has been clicked."
+      },
+      "complexType": {
+        "original": "any",
+        "resolved": "any",
+        "references": {}
+      }
     }]; }
   static get elementRef() { return "host"; }
   static get watchers() { return [{
@@ -649,6 +732,9 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], VegaTextarea.prototype, "blurEventEmitter", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaTextarea.prototype, "labelButtonClickEventEmitter", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], VegaTextarea.prototype, "textareaEventPrevent", void 0);

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

@@ -22,6 +22,7 @@ import { VegaNonceInjectorSlimmer } from '../../helpers/slimmers/global/vega-non
 import { VegaRTETokenExtension } from '../../components/vega-rich-text-editor/extensions/tokens/token-extension';
 import { VegaRTELanguageExtension } from '../../components/vega-rich-text-editor/extensions/languages/language-extension';
 import { VegaRTEPresetToolbarItems } from '../../components/vega-rich-text-editor/constants/constant';
+import { VegaRTEFunctionExtension } from '../../components/vega-rich-text-editor/extensions/functions/function-extension';
 /**
  * Default export function that will be used by stencil global script,
  * which will be invoked before library loaded.
@@ -193,6 +194,7 @@ function injectVegaRichTextEditorClassIntoGlobal() {
   globalThis.VegaRTETokenExtension = VegaRTETokenExtension;
   globalThis.VegaRTELanguageExtension = VegaRTELanguageExtension;
   globalThis.VegaRTEPresetToolbarItems = VegaRTEPresetToolbarItems;
+  globalThis.VegaRTEFunctionExtension = VegaRTEFunctionExtension;
 }
 /**
  * Inject VegaPublicValidationRules to global as a public api

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

@@ -0,0 +1,136 @@
+import { LogUtility } from '../../utils/log';
+import { CalendarTime } from './calendar-time';
+import { CalendarDate } from './calendar-date';
+import { getSystemTimezone } from './utils';
+/**
+ * CalendarDateTime centralizes timezone-aware conversions between native Date instances and calendar helpers.
+ */
+export class CalendarDateTime {
+  constructor(date, timezone) {
+    this.originalDate = date;
+    this.timezone = timezone;
+    this.syncDateTime();
+  }
+  /**
+   * Build a CalendarDateTime from a native Date while the specific timezone.
+   *
+   * @param {Date} date - The native Date object to convert.
+   * @param {string} timezone - The timezone to apply.
+   * @returns {CalendarDateTime} A timezone-aware CalendarDateTime instance.
+   */
+  static fromDate(date, timezone) {
+    return new CalendarDateTime(date, timezone);
+  }
+  /**
+   * Build a CalendarDateTime from a date input (Date or string) and optional time metadata.
+   *
+   * @param {string | Date} date - The input date value (string or Date).
+   * @param {CalendarDateTimeOptions} options - Additional options for time, timezone, seconds, etc.
+   * @returns {CalendarDateTime} A timezone-aware CalendarDateTime instance.
+   */
+  static fromInitDataSource(date, options) {
+    const baseDate = new Date(date);
+    if (options.time) {
+      const calendarTime = CalendarTime.fromString(options.time);
+      baseDate.setHours(calendarTime.hours, calendarTime.minutes, 0, 0);
+    }
+    else if (options.endTimeMissing) {
+      baseDate.setHours(23, 59, 59, 0);
+    }
+    return CalendarDateTime.fromDate(baseDate, options.timezone);
+  }
+  /**
+   * Get the CalendarDate instance representing the date portion.
+   *
+   * @returns {CalendarDate} The CalendarDate object.
+   */
+  get calendarDate() {
+    return this.date;
+  }
+  /**
+   * Get the CalendarTime instance representing the time portion.
+   *
+   * @returns {CalendarTime} The CalendarTime object.
+   */
+  get calendarTime() {
+    return this.time;
+  }
+  /**
+   * Get a native Date object representing this CalendarDateTime.
+   *
+   * @returns {Date} The native Date object.
+   */
+  toDate() {
+    return this.date.toDate();
+  }
+  /**
+   * Set a new timezone and update CalendarDate/CalendarTime accordingly.
+   *
+   * @param {string} newTimezone - The new timezone to set.
+   */
+  setTimezone(newTimezone) {
+    this.timezone = newTimezone;
+    this.syncDateTime();
+  }
+  /**
+   * Sync CalendarDate and CalendarTime with the current originalDate and timezone.
+   */
+  syncDateTime() {
+    const normalized = this.convertDateToTimezone(this.originalDate);
+    this.date = new CalendarDate(normalized.getFullYear(), normalized.getMonth() + 1, normalized.getDate());
+    this.time = CalendarTime.fromDate(normalized);
+  }
+  /**
+   * Convert a Date to the specific timezone.
+   *
+   * @param {Date} date - The date to convert.
+   * @returns {Date} The date adjusted to the specific timezone.
+   */
+  convertDateToTimezone(date) {
+    if (this.timezone === getSystemTimezone()) {
+      return date;
+    }
+    try {
+      const formatter = new Intl.DateTimeFormat([], {
+        timeZone: this.timezone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+      });
+      const parts = formatter.formatToParts(date);
+      const yearPart = this.findDateTimeFormatPart(parts, 'year');
+      const monthPart = this.findDateTimeFormatPart(parts, 'month');
+      const dayPart = this.findDateTimeFormatPart(parts, 'day');
+      const hourPart = this.findDateTimeFormatPart(parts, 'hour');
+      const minutePart = this.findDateTimeFormatPart(parts, 'minute');
+      const secondPart = this.findDateTimeFormatPart(parts, 'second');
+      if (yearPart && monthPart && dayPart && hourPart && minutePart && secondPart) {
+        const year = parseInt(yearPart.value, 10);
+        const month = parseInt(monthPart.value, 10);
+        const day = parseInt(dayPart.value, 10);
+        const hour = parseInt(hourPart.value, 10);
+        const minute = parseInt(minutePart.value, 10);
+        const second = parseInt(secondPart.value, 10);
+        return new Date(year, month - 1, day, hour, minute, second);
+      }
+    }
+    catch (_a) {
+      LogUtility.warn('Invalid timezone:', this.timezone);
+    }
+    return date;
+  }
+  /**
+   * Find a specific part in the Intl.DateTimeFormatPart array.
+   *
+   * @param {Intl.DateTimeFormatPart[]} parts - The array of date/time format parts.
+   * @param {DateTimeFormatPartType} type - The type of part to find (e.g., 'year', 'month').
+   * @returns {Intl.DateTimeFormatPart | undefined} The matching part, if found.
+   */
+  findDateTimeFormatPart(parts, type) {
+    return parts.find((part) => part.type === type);
+  }
+}

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

@@ -1,5 +1,6 @@
 import { VegaInternalTranslation } from '../translation';
-import { getCurrentDatePartsInTimezone, getSystemTimezone } from './utils';
+import { CalendarDateTime } from './calendar-date-time';
+import { getSystemTimezone } from './utils';
 /**
  * Calendar date class
  */
@@ -17,8 +18,7 @@ export class CalendarDate {
    * @returns {CalendarDate} - Return a CalendarDate object
    */
   static from(currentDate, timezone = getSystemTimezone()) {
-    const { year, month, date } = getCurrentDatePartsInTimezone(timezone, currentDate);
-    return new CalendarDate(year, month, date);
+    return CalendarDateTime.fromDate(currentDate, timezone).calendarDate;
   }
   /**
    * The year of the calendar date
@@ -60,7 +60,13 @@ export class CalendarDate {
    * @returns {boolean} - Return true if the calendar date is today. Otherwise, return false.
    */
   isToday(timezone = getSystemTimezone()) {
-    const { year, month, date } = getCurrentDatePartsInTimezone(timezone, new Date());
+    if (timezone === getSystemTimezone()) {
+      const today = new Date();
+      return (today.getFullYear() === this.year &&
+        today.getMonth() + 1 === this.month &&
+        today.getDate() === this.date);
+    }
+    const { year, month, date } = CalendarDateTime.fromDate(new Date(), timezone).calendarDate;
     return year === this.year && month === this.month && date === this.date;
   }
   /**