@globalpayments/vega 2.58.0 → 2.59.0

package/dist/collection/helpers/rte-manager/dto-class-manager.js

@@ -0,0 +1,51 @@
+import { RTEBlock } from '../../components/vega-rich-text-editor/dto/blocks/block.abstract';
+import { RTENode } from '../../components/vega-rich-text-editor/dto/nodes/node.abstract';
+/**
+ * RTEDTOClassManager is a singleton class that manages the registration and retrieval of RTE DTO classes.
+ * It allows for the dynamic handling of different RTE blocks and nodes by their types.
+ */
+class RTEDTOClassManager {
+  constructor() {
+    // Register RTE Block DTO classes.
+    this.RTE_BLOCK_DTO_CLASS_MAP = new Map();
+    // Register RTE Block DTO classes.
+    this.RTE_NODE_DTO_CLASS_MAP = new Map();
+  }
+  /**
+   * Registers a new RTE DTO class.
+   *
+   * @typedef T - The type of the RTE DTO class to register.
+   * @param {string} type - The type identifier for the RTE DTO class.
+   * @param {ClassType<T>} RTEDTOClass - The class constructor for the RTE DTO.
+   */
+  registerRTEDTOClass(type, RTEDTOClass) {
+    if (RTEDTOClass.prototype instanceof RTEBlock) {
+      this.RTE_BLOCK_DTO_CLASS_MAP.set(type, RTEDTOClass);
+    }
+    else if (RTEDTOClass.prototype instanceof RTENode) {
+      this.RTE_NODE_DTO_CLASS_MAP.set(type, RTEDTOClass);
+    }
+    else {
+      throw new Error(`Invalid RTE DTO class type: ${type}`);
+    }
+  }
+  /**
+   * Retrieves the RTE block class for a given type.
+   *
+   * @param {string} type - The type identifier for the RTE block.
+   * @returns {Nullable<RTEBlockDTOClass>} - The class constructor for the RTE block, or null if not found.
+   */
+  getRTEBlockClass(type) {
+    return this.RTE_BLOCK_DTO_CLASS_MAP.get(type);
+  }
+  /**
+   * Retrieves the RTE node class for a given type.
+   *
+   * @param {string} type - The type identifier for the RTE node.
+   * @returns {Nullable<RTENodeDTOClass>} - The class constructor for the RTE node, or null if not found.
+   */
+  getRTENodeClass(type) {
+    return this.RTE_NODE_DTO_CLASS_MAP.get(type);
+  }
+}
+export default new RTEDTOClassManager();

package/dist/collection/helpers/rte-manager/dto-renderer-manager.js

@@ -0,0 +1,54 @@
+/**
+ * RTEDTORendererManager is a singleton class that manages the registration and retrieval of RTE DTO renderers.
+ */
+class RTEDTORendererManager {
+  constructor() {
+    // Register RTE DTO renderers, mapping type strings to their respective renderer instances.
+    this.RTE_DTO_RENDERER_MAP = new Map();
+    // Register RTE Toolbar Button Renderers, mapping type strings to their respective renderer instances.
+    this.RTE_TOOLBAR_BUTTON_RENDERER_MAP = new Map();
+  }
+  /**
+   * Registers a new RTE DTO renderer.
+   *
+   * @param {string} type - The type identifier for the RTE DTO renderer.
+   * @param {VegaRTEBaseRenderer} RTEDTORenderer - The renderer instance for the RTE DTO.
+   */
+  registerRTEDTORenderer(type, RTEDTORenderer) {
+    const existRenderer = this.RTE_DTO_RENDERER_MAP.get(type);
+    if (RTEDTORenderer &&
+      existRenderer &&
+      existRenderer.constructor.name !== RTEDTORenderer.constructor.name) {
+      throw new Error(`Renderer for type ${type} is already registered with a different class(${existRenderer.constructor.name}).`);
+    }
+    this.RTE_DTO_RENDERER_MAP.set(type, RTEDTORenderer);
+  }
+  /**
+   * Registers a new RTE Toolbar Button Renderer.
+   *
+   * @param {string} type - The type identifier for the RTE Toolbar Button Renderer.
+   * @param {VegaRTEToolbarButtonRenderer} RTEToolbarButtonRenderer - The renderer instance for the RTE Toolbar Button.
+   */
+  registerRTEToolbarButtonRenderer(type, RTEToolbarButtonRenderer) {
+    this.RTE_TOOLBAR_BUTTON_RENDERER_MAP.set(type, RTEToolbarButtonRenderer);
+  }
+  /**
+   * Retrieves the RTE renderer for a given type.
+   *
+   * @param {string} type - The type identifier for the RTE block.
+   * @returns {Nullable<BaseRenderer>} - The renderer instance for the RTE block, or null if not found.
+   */
+  getRTERenderer(type) {
+    return this.RTE_DTO_RENDERER_MAP.get(type);
+  }
+  /**
+   * Retrieves the RTE Toolbar Button Renderer for a given type.
+   *
+   * @param {string} type - The type identifier for the RTE Toolbar Button Renderer.
+   * @returns {Nullable<VegaRTEToolbarButtonRenderer>} - The renderer instance for the RTE Toolbar Button, or null if not found.
+   */
+  getRTEToolbarButtonRenderer(type) {
+    return this.RTE_TOOLBAR_BUTTON_RENDERER_MAP.get(type);
+  }
+}
+export default new RTEDTORendererManager();

package/dist/collection/helpers/rte-manager/element-dto-class-strategy-manager.js

@@ -0,0 +1,56 @@
+/**
+ * Manager for registering and retrieving strategies that convert HTML elements to DTOs.
+ */
+class elementToDTOClassStrategyManager {
+  constructor() {
+    this.elementToBlockStrategies = [];
+    this.elementToNodeStrategies = [];
+  }
+  /**
+   * Registers a element to block strategy for converting HTML elements to DTOs. The new strategy is added to the beginning of the list to give it higher priority.
+   *
+   * @param {ElementToDTOStrategy} strategy - The strategy to register.
+   */
+  registerElementToBlockStrategy(strategy) {
+    if (!this.hasDuplicateStrategy(strategy, this.elementToBlockStrategies)) {
+      this.elementToBlockStrategies.unshift(strategy);
+    }
+  }
+  /**
+   * Registers an element to node strategy for converting HTML elements to DTOs. The new strategy is added to the beginning of the list to give it higher priority.
+   *
+   * @param {ElementToDTOStrategy} strategy - The strategy to register.
+   */
+  registerElementToNodeStrategy(strategy) {
+    if (!this.hasDuplicateStrategy(strategy, this.elementToNodeStrategies)) {
+      this.elementToNodeStrategies.unshift(strategy);
+    }
+  }
+  /**
+   * Retrieves all registered element to block strategies for converting HTML elements to DTOs.
+   *
+   * @returns {ElementToDTOStrategy[]} - A set of all registered element to block strategies.
+   */
+  getElementToBlockStrategies() {
+    return this.elementToBlockStrategies;
+  }
+  /**
+   * Retrieves all registered element to node strategies for converting HTML elements to DTOs.
+   *
+   * @returns {ElementToDTOStrategy[]} - A set of all registered element to node strategies.
+   */
+  getElementToNodeStrategies() {
+    return this.elementToNodeStrategies;
+  }
+  /**
+   * Checks if a strategy is already registered in the provided strategy list.
+   *
+   * @param {ElementToDTOStrategy} strategy - The strategy to check for duplicates.
+   * @param {ElementToDTOStrategy[]} strategyList - The list of strategies to check against.
+   * @returns {boolean} - True if the strategy is a duplicate, false otherwise.
+   */
+  hasDuplicateStrategy(strategy, strategyList) {
+    return strategyList.includes(strategy);
+  }
+}
+export default new elementToDTOClassStrategyManager();

package/dist/collection/helpers/rte-manager/rte.manager.test.js

@@ -0,0 +1,94 @@
+import { methodPlaceholder } from 'vega-slimmer/core';
+import RTEDTOClassManager from './dto-class-manager';
+import RTEDTORendererManager from './dto-renderer-manager';
+import { VegaRTEBaseRenderer } from '../../components/vega-rich-text-editor/dto/renderers/base-renderer';
+import ElementToDtoClassStrategyManager from './element-dto-class-strategy-manager';
+import '../../components/vega-rich-text-editor/dto/setup';
+import { ContinueInlineToRTETextBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy';
+import { SpanImageToRTEImageBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/span-img-to-rte-image-block-strategy';
+import { VegaImageToRTEImageBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/vega-image-to-rte-image-block-strategy';
+import { ImgToRTEImageBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/img-to-rte-image-block-strategy';
+import { InlineBlockToRTETextBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/inline-block-to-rte-text-block-strategy';
+import { JiraCodeToRTECodeBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/jira-code-to-rte-code-block-strategy';
+import { VegaCodeBlockToRTECodeBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/vega-code-block-to-rte-code-block-strategy';
+import { LiToRTEListItemBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/li-to-rte-list-item-block-strategy';
+import { ULNotLiChildToRTEListItemBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/ul-not-li-child-to-rte-list-item-block';
+import { OlToRTEListBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/ol-to-rte-list-block-strategy';
+import { HtmlBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/html-block-strategy';
+import { UlToRTEListBlockStrategy } from '../../components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/ul-to-rte-list-block-strategy';
+class MockDTOClass {
+  constructor(id) {
+    this.type = 'mock-dto';
+    this.nodes = [];
+    this.id = id;
+  }
+  isNotEmpty() {
+    return true;
+  }
+  getLastNode() {
+    return this.nodes[this.nodes.length - 1];
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+    };
+  }
+  clone() {
+    const clonedBlock = new MockDTOClass(this.id);
+    return clonedBlock;
+  }
+}
+class MockNodeRenderer extends VegaRTEBaseRenderer {
+  render(renderData, rteContext, createElement) {
+    return methodPlaceholder(createElement, renderData, rteContext);
+  }
+}
+class MockBlockRenderer extends VegaRTEBaseRenderer {
+  render(renderData, rteContext, createElement) {
+    return methodPlaceholder(createElement, renderData, rteContext);
+  }
+}
+describe('rte manager', () => {
+  it('should register dto class correct', () => {
+    function registerMockDTOClass() {
+      RTEDTOClassManager.registerRTEDTOClass('mock-dto', MockDTOClass);
+    }
+    expect(registerMockDTOClass).toThrowError(`Invalid RTE DTO class type: mock-dto`);
+  });
+  it('should register renderer correct', () => {
+    RTEDTORendererManager.registerRTEDTORenderer('mock-node-renderer', new MockNodeRenderer());
+    RTEDTORendererManager.registerRTEDTORenderer('mock-block-renderer', new MockBlockRenderer());
+    expect(RTEDTORendererManager.getRTERenderer('mock-node-renderer')).toBeInstanceOf(MockNodeRenderer);
+    expect(RTEDTORendererManager.getRTERenderer('mock-block-renderer')).toBeInstanceOf(MockBlockRenderer);
+    function registerMockRenderer() {
+      RTEDTORendererManager.registerRTEDTORenderer('mock-node-renderer', new MockBlockRenderer());
+    }
+    expect(registerMockRenderer).toThrowError(`Renderer for type mock-node-renderer is already registered with a different class(MockNodeRenderer).`);
+  });
+  it('should register the block strategies as fixed order', () => {
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[11] instanceof
+      ContinueInlineToRTETextBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[10] instanceof
+      SpanImageToRTEImageBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[9] instanceof
+      VegaImageToRTEImageBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[8] instanceof
+      ImgToRTEImageBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[7] instanceof
+      InlineBlockToRTETextBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[6] instanceof
+      JiraCodeToRTECodeBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[5] instanceof
+      VegaCodeBlockToRTECodeBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[4] instanceof
+      LiToRTEListItemBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[3] instanceof
+      ULNotLiChildToRTEListItemBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[2] instanceof
+      OlToRTEListBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[1] instanceof
+      UlToRTEListBlockStrategy).toBeTruthy();
+    expect(ElementToDtoClassStrategyManager.getElementToBlockStrategies()[0] instanceof HtmlBlockStrategy).toBeTruthy();
+  });
+});

package/dist/collection/helpers/slimmers/field-error-controller-silmmer.js

@@ -26,8 +26,8 @@ export class FieldErrorControllerSlimmer extends VegaSlimmer {
      * @param {FieldErrorEventPayload} payload payload param
      */
     this.handleFieldErrorMessageUpdate = (payload) => {
-      const { message } = payload;
-      if (message) {
+      const { message, isValid } = payload;
+      if (!isValid) {
         this.fieldErrorUIController.applyInputInvalidUI(message);
       }
       else {
@@ -57,10 +57,8 @@ export class FieldErrorControllerSlimmer extends VegaSlimmer {
   canAcceptFieldErrorMessageUpdate(payload) {
     const { host } = payload;
     const parentFieldBox = this.host.parentElement;
-    if (parentFieldBox && parentFieldBox === host) {
-      return true;
-    }
-    return false;
+    return ((parentFieldBox && parentFieldBox === host && parentFieldBox.tagName === 'VEGA-FIELD-ERROR') ||
+      this.host === host);
   }
 }
 __decorate([

package/dist/collection/helpers/slimmers/field-error-ui-controller-slimmer.js

@@ -34,18 +34,20 @@ export class FieldErrorUIControllerSlimmer extends VegaSlimmer {
    * @param {EvaluateResult['message']} errorMessage - The error message to display.
    */
   applyInputInvalidUI(errorMessage) {
-    this.errorMessage = errorMessage;
     const inputContainer = this.getInputElementContainer();
-    if (errorMessage && inputContainer) {
-      const errorContainer = this.getErrorContainer(inputContainer);
-      errorContainer.innerHTML =
-        this.formFieldMessageTranslatorSlimmer.getTranslatedMessage(errorMessage);
-      errorContainer.classList.remove('vega-hidden');
+    ChangeManager.notify(DomNodeSubjectFactory.getSubject(this.host, VegaInternalFieldErrorStateChange), {
+      host: this.host,
+      showError: true,
+    });
+    if (inputContainer) {
       inputContainer.classList.add('error');
-      ChangeManager.notify(DomNodeSubjectFactory.getSubject(this.host, VegaInternalFieldErrorStateChange), {
-        host: this.host,
-        showError: true,
-      });
+      if (errorMessage) {
+        this.errorMessage = errorMessage;
+        const errorContainer = this.getErrorContainer(inputContainer);
+        errorContainer.innerHTML =
+          this.formFieldMessageTranslatorSlimmer.getTranslatedMessage(errorMessage);
+        errorContainer.classList.remove('vega-hidden');
+      }
     }
   }
   /**

package/dist/collection/helpers/slimmers/global/vega-translate-observer-slimmer.js

@@ -23,10 +23,20 @@ export class VegaTranslateObserverSlimmer extends VegaSlimmer {
    * Registers an observer to watch for translation updates, which triggers a forced update on the component.
    */
   connectedCallback() {
-    const observer = new Observer(this.isAcceptable.bind(this), () => {
+    this.observer = new Observer(this.isAcceptable.bind(this), () => {
       forceUpdate(this.component);
     });
-    ChangeManager.register(UPDATE_TRANSLATION, observer);
+    ChangeManager.register(UPDATE_TRANSLATION, this.observer);
+  }
+  /**
+   * Component lifecycle - [disconnectedCallback]
+   * Unregister the observer when the component is disconnected from the DOM.
+   */
+  disconnectedCallback() {
+    if (this.observer) {
+      ChangeManager.unregister(UPDATE_TRANSLATION, this.observer);
+      this.observer = null;
+    }
   }
   /**
    * Determines whether the observer should accept changes.
@@ -34,11 +44,14 @@ export class VegaTranslateObserverSlimmer extends VegaSlimmer {
    * @returns {boolean} Always returns true in the current implementation.
    */
   isAcceptable() {
-    var _a;
+    var _a, _b;
     const host = this.component['host'];
-    return (_a = VegaInternalTranslation.getConnectedComponents().get(host.tagName)) === null || _a === void 0 ? void 0 : _a.has(host);
+    return (_b = (_a = VegaInternalTranslation.getConnectedComponents().get(host.tagName)) === null || _a === void 0 ? void 0 : _a.has(host)) !== null && _b !== void 0 ? _b : false;
   }
 }
 __decorate([
   MapToComponentMethod('connectedCallback')
 ], VegaTranslateObserverSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  MapToComponentMethod('disconnectedCallback')
+], VegaTranslateObserverSlimmer.prototype, "disconnectedCallback", null);

package/dist/collection/helpers/slimmers/test/field-error-controller-slimmer.test.js

@@ -48,6 +48,7 @@ describe('FieldErrorControllerSlimmer', () => {
       expect(mockedComponent['controller']['canAcceptFieldErrorMessageUpdate']({
         host: mockHost,
         message: '',
+        isValid: false,
       })).toBeFalsy();
     });
   });

package/dist/collection/helpers/slimmers/test/global/vega-translate-observer-slimmer.test.js

@@ -0,0 +1,89 @@
+import { jest } from '@jest/globals';
+jest.mock('@stencil/core', () => {
+  const actual = jest.requireActual('@stencil/core');
+  return Object.assign(Object.assign({}, (typeof actual === 'object' && actual !== null ? actual : {})), { forceUpdate: jest.fn() });
+});
+/* eslint-disable @typescript-eslint/naming-convention */
+jest.mock('../../../../helpers/change-manager/change-manager', () => ({
+  __esModule: true,
+  default: {
+    register: jest.fn(),
+    unregister: jest.fn(),
+  },
+}));
+jest.mock('../../../../helpers/change-manager/observer/observer');
+import { VegaTranslateObserverSlimmer } from '../../global/vega-translate-observer-slimmer';
+import { Observer } from '../../../../helpers/change-manager/observer/observer';
+import { UPDATE_TRANSLATION } from '../../../../helpers/change-manager/subject/static-subject/static-subject-title';
+import { VegaInternalTranslation } from '../../../translation';
+import ChangeManager from '../../../../helpers/change-manager/change-manager';
+import { forceUpdate } from '@stencil/core';
+describe('VegaTranslateObserverSlimmer', () => {
+  let component;
+  let host;
+  let slimmer;
+  let option;
+  beforeEach(() => {
+    host = { tagName: 'MY-COMPONENT' };
+    component = { host };
+    option = { component };
+    ChangeManager.register.mockClear();
+    ChangeManager.unregister.mockClear();
+    Observer.mockClear();
+    jest.spyOn(VegaInternalTranslation, 'getConnectedComponents').mockReturnValue(new Map());
+  });
+  it('should set component in constructor', () => {
+    slimmer = new VegaTranslateObserverSlimmer(option);
+    expect(slimmer['component']).toBe(component);
+  });
+  it('should register observer on connectedCallback', () => {
+    slimmer = new VegaTranslateObserverSlimmer(option);
+    slimmer.connectedCallback();
+    expect(Observer).toHaveBeenCalledWith(expect.any(Function), expect.any(Function));
+    expect(ChangeManager.register).toHaveBeenCalledWith(UPDATE_TRANSLATION, slimmer['observer']);
+  });
+  it('should call forceUpdate when observer triggers', () => {
+    slimmer = new VegaTranslateObserverSlimmer(option);
+    slimmer.connectedCallback();
+    // Simulate observer callback
+    const observerInstance = Observer.mock.calls[0][1];
+    observerInstance();
+    expect(forceUpdate).toHaveBeenCalledWith(component);
+  });
+  it('should unregister observer on disconnectedCallback', () => {
+    slimmer = new VegaTranslateObserverSlimmer(option);
+    slimmer.connectedCallback();
+    const observerRef = slimmer['observer'];
+    slimmer.disconnectedCallback();
+    expect(ChangeManager.unregister).toHaveBeenCalledWith(UPDATE_TRANSLATION, observerRef);
+    expect(slimmer['observer']).toBeNull();
+  });
+  it('should not unregister if observer is not set', () => {
+    slimmer = new VegaTranslateObserverSlimmer(option);
+    slimmer['observer'] = null;
+    slimmer.disconnectedCallback();
+    expect(ChangeManager.unregister).not.toHaveBeenCalled();
+  });
+  describe('isAcceptable', () => {
+    it('should return true if host is in connected components', () => {
+      slimmer = new VegaTranslateObserverSlimmer(option);
+      const mockSet = new Set([host]);
+      const mockMap = new Map([[host['tagName'], mockSet]]);
+      VegaInternalTranslation.getConnectedComponents.mockReturnValue(mockMap);
+      expect(slimmer['isAcceptable']()).toBe(true);
+    });
+    it('should return false if host is not in connected components', () => {
+      slimmer = new VegaTranslateObserverSlimmer(option);
+      const mockSet = new Set();
+      const mockMap = new Map([[host['tagName'], mockSet]]);
+      VegaInternalTranslation.getConnectedComponents.mockReturnValue(mockMap);
+      expect(slimmer['isAcceptable']()).toBe(false);
+    });
+    it('should return false if tagName is not in connected components', () => {
+      slimmer = new VegaTranslateObserverSlimmer(option);
+      const mockMap = new Map();
+      VegaInternalTranslation.getConnectedComponents.mockReturnValue(mockMap);
+      expect(slimmer['isAcceptable']()).toBe(false);
+    });
+  });
+});

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

@@ -58,6 +58,17 @@ export const staticTranslations = {
   'October': 'October',
   'November': 'November',
   'December': 'December',
+  'Jan': 'Jan',
+  'Feb': 'Feb',
+  'Mar': 'Mar',
+  'Apr': 'Apr',
+  'Jun': 'Jun',
+  'Jul': 'Jul',
+  'Aug': 'Aug',
+  'Sep': 'Sep',
+  'Oct': 'Oct',
+  'Nov': 'Nov',
+  'Dec': 'Dec',
   'All Day': 'All Day',
   'Select or drop your file here': 'Select or drop your file here',
   'Please sign here': 'Please sign here',
@@ -113,5 +124,24 @@ export const staticTranslations = {
   'Copy Code': 'Copy Code',
   'Code Block': 'Code Block',
   'Copied': 'Copied',
+  'Repeat every {0} days': 'Repeat every {0} days',
+  'Repeat daily': 'Repeat daily',
+  'Repeat every {0} weeks on {1}': 'Repeat every {0} weeks on {1}',
+  'Repeat weekly on {0}': 'Repeat weekly on {0}',
+  'Repeat every {0} months on day {1}': 'Repeat every {0} months on day {1}',
+  'Repeat monthly on day {0}': 'Repeat monthly on day {0}',
+  'Repeat every {0} years on {1} {2}': 'Repeat every {0} years on {1} {2}',
+  'Repeat yearly on {0} {1}': 'Repeat yearly on {0} {1}',
+  'until {0}': 'until {0}',
+  'after {0} occurrences': 'after {0} occurrences',
+  'Sunday': 'Sunday',
+  'Monday': 'Monday',
+  'Tuesday': 'Tuesday',
+  'Wednesday': 'Wednesday',
+  'Thursday': 'Thursday',
+  'Friday': 'Friday',
+  'Saturday': 'Saturday',
+  'am': 'am',
+  'pm': 'pm',
 };
 export default staticTranslations;

package/dist/collection/helpers/translation/tests/internal-translation-controller.test.js

@@ -148,6 +148,17 @@ describe('VegaTranslationController', () => {
       'October': 'October',
       'November': 'November',
       'December': 'December',
+      'Jan': 'Jan',
+      'Feb': 'Feb',
+      'Mar': 'Mar',
+      'Apr': 'Apr',
+      'Jun': 'Jun',
+      'Jul': 'Jul',
+      'Aug': 'Aug',
+      'Sep': 'Sep',
+      'Oct': 'Oct',
+      'Nov': 'Nov',
+      'Dec': 'Dec',
       'All Day': 'All Day',
       'Select or drop your file here': 'Select or drop your file here',
       'Please sign here': 'Please sign here',
@@ -203,6 +214,25 @@ describe('VegaTranslationController', () => {
       'Select Language': 'Select Language',
       'Code Block': 'Code Block',
       'Copied': 'Copied',
+      'Repeat every {0} days': 'Repeat every {0} days',
+      'Repeat daily': 'Repeat daily',
+      'Repeat every {0} weeks on {1}': 'Repeat every {0} weeks on {1}',
+      'Repeat weekly on {0}': 'Repeat weekly on {0}',
+      'Repeat every {0} months on day {1}': 'Repeat every {0} months on day {1}',
+      'Repeat monthly on day {0}': 'Repeat monthly on day {0}',
+      'Repeat every {0} years on {1} {2}': 'Repeat every {0} years on {1} {2}',
+      'Repeat yearly on {0} {1}': 'Repeat yearly on {0} {1}',
+      'until {0}': 'until {0}',
+      'after {0} occurrences': 'after {0} occurrences',
+      'Sunday': 'Sunday',
+      'Monday': 'Monday',
+      'Tuesday': 'Tuesday',
+      'Wednesday': 'Wednesday',
+      'Thursday': 'Thursday',
+      'Friday': 'Friday',
+      'Saturday': 'Saturday',
+      'am': 'am',
+      'pm': 'pm',
     });
     /* eslint-enable @typescript-eslint/naming-convention,spellcheck/spell-checker */
   });

package/dist/collection/polyfill/shadow-selection/shadow-selection-polyfill.js

@@ -108,20 +108,22 @@ export class ShadowSelectionPolyfill {
   getFirefoxSelection() {
     // eslint-disable-next-line no-restricted-globals
     const selection = document.getSelection();
-    const range = selection.getRangeAt(0);
-    const startNode = range.startContainer;
-    const endNode = range.endContainer;
-    if (startNode !== endNode && startNode.textContent.length === range.startOffset) {
-      const nextSibling = startNode.nodeType === Node.TEXT_NODE
-        ? startNode.parentNode.nextSibling
-        : startNode.nextSibling;
-      range.setStart(nextSibling.firstChild, 0);
-    }
-    if (endNode !== startNode && range.endOffset === 0) {
-      const previousSibling = endNode.nodeType === Node.TEXT_NODE
-        ? endNode.parentNode.previousSibling
-        : endNode.previousSibling;
-      range.setEnd(previousSibling.lastChild, previousSibling.lastChild.textContent.length);
+    if (selection.rangeCount > 0) {
+      const range = selection.getRangeAt(0);
+      const startNode = range.startContainer;
+      const endNode = range.endContainer;
+      if (startNode !== endNode && startNode.textContent.length === range.startOffset) {
+        const nextSibling = startNode.nodeType === Node.TEXT_NODE
+          ? startNode.parentNode.nextSibling
+          : startNode.nextSibling;
+        range.setStart(nextSibling.firstChild, 0);
+      }
+      if (endNode !== startNode && range.endOffset === 0) {
+        const previousSibling = endNode.nodeType === Node.TEXT_NODE
+          ? endNode.parentNode.previousSibling
+          : endNode.previousSibling;
+        range.setEnd(previousSibling.lastChild, previousSibling.lastChild.textContent.length);
+      }
     }
     return selection;
   }

package/dist/collection/polyfill/shadow-selection/test/shadow-selection-polyfill.test.js

@@ -11,6 +11,7 @@ describe('ShadowSelectionPolyfill', () => {
   }
   class MockedSelection {
     constructor() {
+      this.rangeCount = 1;
       this.ranges = [];
     }
     removeAllRanges() {

package/dist/collection/polyfill/test-polyfill/unit/methods.js

@@ -36,3 +36,12 @@ MockElement.prototype['replaceChildren'] = function (...nodes) {
 MockElement.prototype['getSelection'] = function () {
   return null;
 };
+/**
+ * A polyfill for the getAttributeNames method
+ * Get the all attributes of this element
+ *
+ * @returns {null} null
+ */
+MockElement.prototype['getAttributeNames'] = function () {
+  return this.attributes.__items.map((attr) => attr._name);
+};

package/dist/collection/utils/object.js

@@ -30,3 +30,15 @@ export function deepEqual(obj, compareTo) {
       }, true)
     : obj === compareTo;
 }
+/**
+ * Cleans an object by removing properties with null or undefined values.
+ *
+ * @template T - The type of the input object.
+ * @param {T} obj - The object to be cleaned.
+ * @returns {Partial<T>} A new object with properties that have non-null and non-undefined values.
+ */
+export function cleanObject(obj) {
+  return Object.fromEntries(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Object.entries(obj).filter(([_k, v]) => v !== null && v !== undefined));
+}

package/dist/collection/utils/string.js

@@ -7,3 +7,13 @@
 export const camelToDashCase = (str) => {
   return str.replace(/([A-Z])/g, (m) => `-${m[0].toLowerCase()}`);
 };
+/**
+ * It capitalizes the first letter after the - in the string.
+ *
+ * @param {string} str - string - The string to convert like: 'white-space'.
+ * @returns {string} The camel case format like: 'whiteSpace'.
+ */
+export const dashCaseToCamel = (str) => str
+  .split('-')
+  .map((word, index) => (index === 0 ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1))
+  .join('');