@globalpayments/vega 2.70.0 → 2.75.1

package/dist/collection/helpers/ui/element-appender.js

@@ -31,7 +31,7 @@ export class ElementAppender {
    * target for the showConfigCallback.
    */
   constructor(showConfigCallback, showConfigCallbackTarget) {
-    var _a, _b;
+    var _a;
     this.resizeObserverSlimmer = createDynamicSlimmer(ElementAppender, PageResizeObserverSlimmer, [], [
       { mapFrom: 'connectResizeObserver', mapTo: 'connectResizeObserver' },
       { mapFrom: 'disconnectResizeObserver', mapTo: 'disconnectResizeObserver' },
@@ -61,8 +61,8 @@ export class ElementAppender {
     this.showConfigCallback = showConfigCallback;
     this.showConfigCallbackTarget = showConfigCallbackTarget;
     const config = this.getShowConfig();
-    (_a = config.appendableElement) === null || _a === void 0 ? void 0 : _a.classList.add('vega-force-hidden');
-    (_b = config.appendableElement) === null || _b === void 0 ? void 0 : _b.classList.add('vega-element-appender-appendable');
+    this.hideElementAppender(config.appendableElement);
+    (_a = config.appendableElement) === null || _a === void 0 ? void 0 : _a.classList.add('vega-element-appender-appendable');
   }
   /**
    * It takes an element and appends it to the DOM, then adjusts its position and size to match the
@@ -143,14 +143,44 @@ export class ElementAppender {
    */
   toggleShow(show) {
     if (show) {
-      this.showConfig.appendableElement.classList.remove('vega-force-hidden');
+      this.showElementAppender(this.showConfig.appendableElement);
       this.saveVisibleAppendElement(this.showConfig.appendableElement);
     }
     else {
-      this.showConfig.appendableElement.classList.add('vega-force-hidden');
+      this.hideElementAppender(this.showConfig.appendableElement);
       this.removeVisibleAppendElement(this.showConfig.appendableElement);
     }
   }
+  /**
+   * Show the appendable element by removing hidden styles
+   * TODO: should directly control display style. https://gethired.atlassian.net/browse/VD-7884
+   *
+   * @param {HTMLElement} appendableElement - Appendable element controlled by ElementAppender
+   */
+  showElementAppender(appendableElement) {
+    if (appendableElement.classList.contains('date-picker-content-box')) {
+      appendableElement.style.display = 'block';
+    }
+    else {
+      appendableElement.classList.remove('vega-force-hidden');
+    }
+  }
+  /**
+   * Hide the appendable element by adding hidden styles.
+   * TODO: should directly control display style. https://gethired.atlassian.net/browse/VD-7884
+   *
+   * @param {HTMLElement} appendableElement - Appendable element controlled by ElementAppender
+   */
+  hideElementAppender(appendableElement) {
+    if (!appendableElement)
+      return;
+    if (appendableElement.classList.contains('date-picker-content-box')) {
+      appendableElement.style.display = 'none';
+    }
+    else {
+      appendableElement.classList.add('vega-force-hidden');
+    }
+  }
   /**
    * Save visible AppendableElement from the container state
    *

package/dist/collection/types/test/type-guard.test.js

@@ -1,4 +1,5 @@
-import { isFlexWrapType, isResponsiveType, isSpacingDirection, isStateVariantTokenType } from '../type-guard';
+import { ClickOutsideOnlyToDismissStrategy } from '../../helpers/slimmers/element-appender/trigger-strategies/click-outside-only-to-dismiss-strategy';
+import { isEATriggerStrategy, isFlexWrapType, isResponsiveType, isSpacingDirection, isStateVariantTokenType, } from '../type-guard';
 test('should get expect result when call function isResponsiveType', async () => {
   const sizeWithDefault = {
     default: 'default',
@@ -37,3 +38,9 @@ test('should get expect result when call function isFlexWrapType', async () => {
   expect(isFlexWrapType('wrap')).toBeTruthy();
   expect(isFlexWrapType('wrap1')).toBeFalsy();
 });
+test('should get expect result when call function isEATriggerStrategy', async () => {
+  expect(isEATriggerStrategy(undefined)).toBeFalsy();
+  expect(isEATriggerStrategy(null)).toBeFalsy();
+  expect(isEATriggerStrategy('wrap')).toBeFalsy();
+  expect(isEATriggerStrategy(new ClickOutsideOnlyToDismissStrategy())).toBeTruthy();
+});

package/dist/collection/types/type-guard.js

@@ -7,6 +7,7 @@ import { BorderStyle, BoxDisplay, CssStates, FlexAlignItem, FlexDirections, Flex
 import { GridColumnsRegex, GridRowsRegex } from '../constants/regex';
 import { TypographyKeys } from '../constants/public-api';
 import { Borders } from '../constants/tokens/borders';
+import { CalendarDate } from '../helpers/calendar';
 /**
  * Returns true if the input is a string that is one of the four directions.
  *
@@ -385,3 +386,23 @@ export const isVegaTableColumnGroupingModelType = (input) => {
     'label' in input &&
     typeof input.label === 'string');
 };
+/**
+ * Check is calendar date type
+ *
+ * @param {unknown} input - Value to test.
+ * @returns {input is CalendarDate} True when input matches the calendar date type.
+ */
+export const isCalendarDateType = (input) => {
+  return input instanceof CalendarDate;
+};
+/**
+ * Type guard to check if the provided instance implements the VegaEATriggerStrategy interface
+ *
+ * @param {unknown} instance - The instance to check.
+ * @returns {instance is VegaEATriggerStrategy} True if the instance implements VegaEATriggerStrategy.
+ */
+export const isEATriggerStrategy = (instance) => {
+  return (!!instance &&
+    typeof instance.evaluate === 'function' &&
+    typeof instance.canEvaluate === 'function');
+};

package/dist/collection/utils/date.js

@@ -1,6 +1,15 @@
 import { LogUtility } from './log';
+// TODO: Need rename calendar-date as vega-date to manage all date operation in vega project
+// https://gethired.atlassian.net/browse/VD-5918
 /**
- * It returns true if the input is a valid date string, and false otherwise
+ * It returns true if the input is a valid date string, and false otherwise.
+ * Note:
+ *  This is not a strict date validation, it just use Date.parse to check the input string can be parsed to a valid date or not.
+ *  For strict date validation, please use CalendarDate.fromString method in calendar-date.ts
+ *  Example:
+ *      For Chrome: Date.parse('Jan/08/2026') => 1767801600000
+ *      For Safari: Date.parse('Jan/08/2026') => NaN
+ *      Format is DD/MM/YYYY: Date.parse('20/11/2024') => NaN
  *
  * @param {string} input - The string to check.
  * @returns {boolean} is a valid date string or not
@@ -52,11 +61,13 @@ export const isTimeStr = (input, timeFormat) => {
  * It takes a number and returns a string
  *
  * @param {number} number - number - The number to pad
+ * @param {number} [length=2] - The length of the resulting string.
+ * @param {string} [padChar='0'] - The character to pad the number with.
  * @returns {Nullable<string>} A function that takes a number as an argument and returns a nullable string.
  */
-export const pad = (number) => {
+export const pad = (number, length = 2, padChar = '0') => {
   if (number || number === 0) {
-    return number.toString().padStart(2, '0');
+    return number.toString().padStart(length, padChar);
   }
   else {
     LogUtility.error(`The input should be a number`);

package/dist/collection/utils/e2e-utils.js

@@ -239,8 +239,10 @@ export const getScreenshotDiffResults = async (page, desc, selector) => {
  * @param {EventSemanticsConfig} config.eventSemanticsConfig - sets the event semantics configuration for the EventManager
  * @param {string} config.date --sets the date want to mock
  * @param {number} config.timeout --sets the content timeout
+ * @param {InjectFeatureFlagsConfig} config.featureFlags -inject feature flags.
  */
 export const initVegaE2EPage = async (content, config) => {
+  var _a, _b;
   const page = await newE2EPage();
   await mockDate(page, config === null || config === void 0 ? void 0 : config.date);
   const script = (config === null || config === void 0 ? void 0 : config.eventSemanticsConfig)
@@ -249,9 +251,13 @@ export const initVegaE2EPage = async (content, config) => {
   const injectTestIcons = `<script type='module'>
     window.VegaIconManager.register(${JSON.stringify(TestIcons)});
   </script>`;
+  const injectFeatureFlags = `<script>
+		window.VegaEnabledFeatureKeys = ${JSON.stringify(((_a = config === null || config === void 0 ? void 0 : config.featureFlags) === null || _a === void 0 ? void 0 : _a.enabled) || [])};
+		window.VegaDisabledFeatureKeys = ${JSON.stringify(((_b = config === null || config === void 0 ? void 0 : config.featureFlags) === null || _b === void 0 ? void 0 : _b.disabled) || [])};
+	</script>`;
   const contentHtml = (config === null || config === void 0 ? void 0 : config.wrapped)
-    ? `${injectTestIcons}${script}<div style="padding: 10px" id="visual-container">${content}</div>`
-    : injectTestIcons + script + content;
+    ? `${injectTestIcons}${script}${injectFeatureFlags}<div style="padding: 10px" id="visual-container">${content}</div>`
+    : injectTestIcons + script + injectFeatureFlags + content;
   (config === null || config === void 0 ? void 0 : config.timeout)
     ? await page.setContent(contentHtml, { timeout: config.timeout })
     : await page.setContent(contentHtml);

package/dist/collection/utils/sanitize.js

@@ -0,0 +1,126 @@
+import { tryGetDocument } from './try-get-document';
+/**
+ * Helper utilities for sanitizing string from harmful tags
+ * This utility is intentionally restrictive of allowed tags depending on expected output.
+ *
+ * - Uses DOM-based parsing (no regex)
+ * - All attributes are stripped
+ * - Disallowed elements are unwrapped (children preserved)
+ */
+export class SanitizeUtility {
+  /**
+   * It cleans up string for labels and allow minor formatting like bold, italic, strong
+   *
+   * @param {string} input - the passed label input string for sanitization
+   * @returns {string} returns sanitized string
+   */
+  static sanitizeHtmlLabel(input) {
+    return this.sanitize(input, this.LABEL_ALLOWED_TAGS);
+  }
+  /**
+   * Sanitizes the provided HTML string by parsing it into a DOM tree and
+   * removing all disallowed elements and attributes.
+   *
+   * @param {string} input - raw HTML string to sanitize
+   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
+   * @returns {string} sanitized HTML string
+   */
+  static sanitize(input, allowedTags) {
+    if (input.trim() === '')
+      return '';
+    const doc = tryGetDocument();
+    if (!doc)
+      return '';
+    const parser = new DOMParser();
+    const parsedDocument = parser.parseFromString(input, 'text/html');
+    const outputFragment = doc.createDocumentFragment();
+    parsedDocument.body.childNodes.forEach((node) => {
+      const cleanNode = this.sanitizeNode(node, allowedTags, doc);
+      if (cleanNode) {
+        outputFragment.appendChild(cleanNode);
+      }
+    });
+    return this.serializeFragment(outputFragment, doc);
+  }
+  /**
+   * Sanitizes a DOM node recursively.
+   * - Text nodes are preserved
+   * - Element nodes are sanitized based on allowed tags
+   * - Other node types are discarded
+   *
+   * @param {Node} node - DOM node to sanitize
+   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
+   * @param {Document} doc - document reference
+   * @returns {Nullable<Node>} sanitized node or null if not allowed
+   */
+  static sanitizeNode(node, allowedTags, doc) {
+    switch (node.nodeType) {
+      case Node.TEXT_NODE:
+        return node.cloneNode(true);
+      case Node.ELEMENT_NODE:
+        return this.sanitizeElement(node, allowedTags, doc);
+      default:
+        return null;
+    }
+  }
+  /**
+   * Sanitizes an HTML element.
+   * - If the element tag is not allowed, it is removed but its children are preserved
+   * - If allowed, a clean element is created with no attributes
+   *
+   * @param {HTMLElement} element - element to sanitize
+   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
+   * @param {Document} doc - document reference
+   * @returns {Node} sanitized node or fragment
+   */
+  static sanitizeElement(element, allowedTags, doc) {
+    if (!allowedTags.has(element.tagName)) {
+      const fragment = doc.createDocumentFragment();
+      element.childNodes.forEach((child) => {
+        const cleanChild = this.sanitizeNode(child, allowedTags, doc);
+        if (cleanChild) {
+          fragment.appendChild(cleanChild);
+        }
+      });
+      return fragment;
+    }
+    const cleanElement = doc.createElement(element.tagName.toLowerCase());
+    element.childNodes.forEach((child) => {
+      const cleanChild = this.sanitizeNode(child, allowedTags, doc);
+      if (cleanChild) {
+        cleanElement.appendChild(cleanChild);
+      }
+    });
+    return cleanElement;
+  }
+  /**
+   * Serializes a DocumentFragment back into an HTML string.
+   *
+   * @param {DocumentFragment} fragment - fragment to serialize
+   * @param {Document} doc - document reference
+   * @returns {string} serialized HTML string
+   */
+  static serializeFragment(fragment, doc) {
+    var _a;
+    const container = doc.createElement('div');
+    container.appendChild(fragment);
+    // If no HTML elements exist, return textContent
+    return container.children.length === 0 ? (_a = container.textContent) !== null && _a !== void 0 ? _a : '' : container.innerHTML;
+  }
+}
+/**
+ * Set of allowed HTML tags for label rendering.
+ * Tags must be uppercase to match DOMParser element.tagName output.
+ */
+SanitizeUtility.LABEL_ALLOWED_TAGS = new Set(['B', 'I', 'STRONG', 'EM']);
+/**
+ * Standalone helper (keeps parity with existing utility exports pattern)
+ *
+ * It cleans up string for labels and allow minor formatting like bold, italic, strong
+ *
+ * @param {string} input - the passed label input string for sanitization
+ * @returns {string} returns sanitized string
+ */
+export function sanitizeHtmlLabel(input) {
+  return SanitizeUtility.sanitizeHtmlLabel(input);
+}

package/dist/collection/utils/test/date.test.js

@@ -78,6 +78,8 @@ describe('pad', () => {
     expect(pad(1)).toEqual('01');
     expect(pad(0)).toEqual('00');
     expect(pad(102)).toEqual('102');
+    expect(pad(26, 4, '20')).toEqual('2026');
+    expect(pad(2126, 4, '20')).toEqual('2126');
   });
   test('return value should log an error', () => {
     spyOn(LogUtility, 'error');

package/dist/collection/utils/test/sanitize.test.js

@@ -0,0 +1,65 @@
+import { tryGetDocument } from '../try-get-document';
+import { sanitizeHtmlLabel } from '../sanitize';
+test('sanitizeHtmlLabel should render simple string as it is', () => {
+  expect(sanitizeHtmlLabel('Hello')).toEqual('Hello');
+  expect(sanitizeHtmlLabel('Hello world paragraph text')).toEqual('Hello world paragraph text');
+  expect(sanitizeHtmlLabel('')).toBe('');
+  expect(sanitizeHtmlLabel('   ')).toBe('');
+  expect(sanitizeHtmlLabel('\n\t')).toBe('');
+});
+test('sanitizeHtmlLabel should preserve allowed formatting tags', () => {
+  // bold
+  expect(sanitizeHtmlLabel('<b>Hello</b>')).toEqual('<b>Hello</b>');
+  // italic
+  expect(sanitizeHtmlLabel('<i>Hello</i>')).toEqual('<i>Hello</i>');
+  // em
+  expect(sanitizeHtmlLabel('<em>Em</em>')).toEqual('<em>Em</em>');
+  // strong
+  expect(sanitizeHtmlLabel('<strong>Strong text</strong>')).toEqual('<strong>Strong text</strong>');
+});
+test('sanitizeHtmlLabel should not allow executable tags and functions', () => {
+  expect(sanitizeHtmlLabel('<script>window.__xssExecuted = true</script>')).toEqual('');
+  expect(sanitizeHtmlLabel('<img src="x" onerror="window.__xssImg = true">')).toEqual('');
+  expect(sanitizeHtmlLabel('<span onclick="window.__xssClick = true">Span</span>')).toEqual('Span');
+});
+test('sanitizeHtmlLabel should unwrap disallowed elements but preserve their children', () => {
+  expect(sanitizeHtmlLabel('<div>Hello <span>World</span></div>')).toEqual('Hello World');
+});
+test('sanitizeHtmlLabel should ignore non-element, non-text nodes', () => {
+  expect(sanitizeHtmlLabel('Text <!-- malicious comment --><script>alert(1)</script>')).toEqual('Text alert(1)');
+});
+it('sanitizeHtmlLabel should not return empty string if document is available', () => {
+  expect(typeof document).toBe('object');
+  expect(tryGetDocument()).toBe(document);
+  expect(sanitizeHtmlLabel('<b>Some</b> text')).toEqual('<b>Some</b> text');
+});
+it('sanitizeHtmlLabel should return empty string if document is not available', () => {
+  const originalDocument = globalThis.document;
+  delete globalThis.document;
+  expect(tryGetDocument()).toBeUndefined();
+  expect(sanitizeHtmlLabel('<b>Some</b> text')).toEqual('');
+  globalThis.document = originalDocument;
+});
+test('sanitizeHtmlLabel should return textContent if no HTML elements exist', () => {
+  expect(sanitizeHtmlLabel('>hello')).toEqual('>hello');
+  expect(sanitizeHtmlLabel('Me > You')).toEqual('Me > You');
+  expect(sanitizeHtmlLabel('Me <b>></b> You')).toEqual('Me <b>&gt;</b> You');
+});
+test('serializeFragment should return innerHTML when HTML elements exist', () => {
+  expect(sanitizeHtmlLabel('<b>Bold</b>')).toBe('<b>Bold</b>');
+});
+test('serializeFragment falls back to empty string when textContent is null', () => {
+  const originalCreateElement = document.createElement;
+  jest.spyOn(document, 'createElement').mockImplementation((tagName) => {
+    const el = originalCreateElement.call(document, tagName);
+    if (tagName === 'div') {
+      Object.defineProperty(el, 'textContent', {
+        get: () => null,
+        configurable: true,
+      });
+    }
+    return el;
+  });
+  expect(sanitizeHtmlLabel('plain text')).toBe('');
+  document.createElement.mockRestore();
+});

package/dist/esm/{app-globals-fd4b7d97.js → app-globals-2ac60ff5.js}

@@ -1,18 +1,19 @@
 import { F as FeatureFlag } from './feature-flag-controller-51659753.js';
-import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaDialog, d as VegaEventManager, e as VegaZIndexManager, f as VegaSkeletonLoader, g as VegaRTETokenExtension, h as VegaRTEFunctionExtension } from './function-extension-8d39db56.js';
+import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaDialog, d as VegaEventManager, e as VegaZIndexManager, f as VegaSkeletonLoader, g as VegaRTETokenExtension, h as VegaRTEFunctionExtension } from './function-extension-e8c0e43e.js';
 import { M as MapToComponentMethod, V as VegaSlimmer, s as setVegaLogLevel, G as GlobalSlimmersRegistry } from './global-slimmer-registry-17c4efd4.js';
 import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.js';
 import { V as VegaIconManager } from './internal-icon-manager-f0486245.js';
 import './wait-for-vega-handler-c2c07ac3.js';
 import './ui-bb99c0c2.js';
 import { V as VegaInternalTranslation, a as VegaTranslation, s as staticTranslations } from './translation-96e5debd.js';
-import { V as VegaRTEContent } from './dto-renderer-manager-d862ae78.js';
+import { V as VegaRTEContent } from './dto-renderer-manager-ee1a5864.js';
 import { v as vegaNonceManager, s as setVegaNonce } from './vega-nonce-manager-497e5eb5.js';
-import { V as VegaRTEPresetToolbarItems } from './code-block-ecb4491b.js';
+import { V as VegaRTEPresetToolbarItems } from './code-block-8ee34ab6.js';
+import './type-guard-c65a227d.js';
 import { T as TypographyUrls } from './typography-396de03f.js';
-import { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-81443274.js';
-import { w as waitForVega } from './index-c943d263.js';
-import { V as VegaRTELanguageExtension } from './language-extension-8f51f5ff.js';
+import { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-666c415d.js';
+import { w as waitForVega } from './index-51a7da7f.js';
+import { V as VegaRTELanguageExtension } from './language-extension-29bf8acd.js';
 import { U as UPDATE_TRANSLATION } from './static-subject-title-52f93124.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import { O as Observer } from './observer-3959f9dd.js';
@@ -397,7 +398,7 @@ function injectVegaRichTextEditorClassIntoGlobal() {
  * Inject VegaPublicValidationRules to global as a public api
  */
 function injectVegaPublicValidationRules() {
-  void import('./public-rules-d10e76f4.js').then((module) => {
+  void import('./public-rules-724873f5.js').then((module) => {
     Object.entries(module).forEach(([name, value]) => {
       globalThis[name] = value;
     });

package/dist/esm/{child-nodes-event-prevent-slimmer-76331524.js → child-nodes-event-prevent-slimmer-e662bee2.js}

@@ -1,5 +1,5 @@
 import { c as MapToComponentField, M as MapToComponentMethod, V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
-import { i as internalVegaEventManager, j as jqueryDelegatedStrategyController } from './internal-vega-event-manager-516aa721.js';
+import { i as internalVegaEventManager, j as jqueryDelegatedStrategyController } from './internal-vega-event-manager-efb6786e.js';
 import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.js';
 import { F as FeatureFlag } from './feature-flag-controller-51659753.js';
 

package/dist/esm/click-outside-only-to-dismiss-strategy-3d286c1b.js

@@ -0,0 +1,30 @@
+/**
+ * A trigger strategy that hides the appendable element when a global mouse down event occurs outside the element.
+ */
+class ClickOutsideOnlyToDismissStrategy {
+  /**
+   * Determines if the strategy can evaluate the given event type.
+   *
+   * @param {VegaEAEventType} type - The type of the event.
+   * @returns {boolean} True if the event type is 'globalMouseDown', otherwise false.
+   */
+  canEvaluate(type) {
+    return type === 'click-outside';
+  }
+  /**
+   * Evaluates the trigger context and determines whether to hide the appendable element.
+   *
+   * @param {VegaEATriggerContext} context - The context of the trigger event.
+   * @returns {VegaEATriggerResult} An object indicating whether to hide the appendable element.
+   */
+  evaluate(context) {
+    if (context.eventType === 'click-outside' && context.currentState.isVisible) {
+      return {
+        nextAction: 'hide',
+      };
+    }
+    return {};
+  }
+}
+
+export { ClickOutsideOnlyToDismissStrategy as C };

package/dist/esm/{code-block-ecb4491b.js → code-block-8ee34ab6.js}

@@ -1,9 +1,9 @@
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-dca87b70.js';
-import { b as VegaInternalRichTextEditorFlushChanges, c as VegaInternalRichTextEditorSelectionRangeChange } from './vega-internal-event-id-5c3e5f7f.js';
+import { d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-064ee2b2.js';
+import { b as VegaInternalRichTextEditorFlushChanges, c as VegaInternalRichTextEditorSelectionRangeChange } from './vega-internal-event-id-4a06d705.js';
 import { c as camelToDashCase } from './string-a953eafc.js';
 import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
-import { i as isNonNullable } from './type-guard-12f7654b.js';
+import { i as isNonNullable } from './type-guard-c65a227d.js';
 import { g as generateUUID } from './create-public-api-runtime-metrics-slimmer-bedf3a1e.js';
 import { V as VegaInternalThemeManager } from './dark-mode-style-controller-de88a117.js';
 import { c as cleanObject } from './object-66c37948.js';
@@ -2620,7 +2620,7 @@ class PlainTextAnnotation extends NodeAnnotation {
    * @inheritDoc
    */
   toJSON() {
-    return { plainText: this.plainText };
+    return this.plainText ? { plainText: this.plainText } : undefined;
   }
 }
 
@@ -3029,93 +3029,41 @@ class TextStyleAnnotation extends BlockAnnotation {
   renderStyle(options) {
     if (!(options === null || options === void 0 ? void 0 : options.standalone))
       return null;
-    const paragraphStyle = {
+    const textStyleBase = {
       fontFamily: 'Inter',
       fontSize: '16px',
       lineHeight: '22px',
+      minHeight: '22px',
       fontWeight: '500',
-      marginTop: '0px',
-      marginBottom: '0px',
     };
+    const paragraphStyle = Object.assign(Object.assign({}, textStyleBase), { marginTop: '0px', marginBottom: '0px' });
     switch (this.textStyle) {
       case 'paragraph': {
         return paragraphStyle;
       }
       case 'title': {
-        return {
-          fontFamily: 'Inter',
-          fontSize: '36px',
-          lineHeight: '40px',
-          fontWeight: '500',
-        };
+        return Object.assign(Object.assign({}, textStyleBase), { fontSize: '36px', lineHeight: '40px', minHeight: '40px' });
       }
       case 'subtitle': {
-        return {
-          fontFamily: 'Inter',
-          fontSize: '28px',
-          lineHeight: '32px',
-          fontWeight: '500',
-        };
+        return Object.assign(Object.assign({}, textStyleBase), { fontSize: '28px', lineHeight: '32px', minHeight: '32px' });
       }
       case 'heading-1': {
-        return {
-          fontFamily: 'Inter',
-          fontSize: '22px',
-          lineHeight: '24px',
-          fontWeight: '500',
-          marginTop: '0px',
-          marginBottom: '0px',
-        };
+        return Object.assign(Object.assign({}, textStyleBase), { fontSize: '22px', lineHeight: '24px', minHeight: '24px', marginTop: '0px', marginBottom: '0px' });
       }
       case 'heading-2': {
-        return {
-          fontFamily: 'Inter',
-          fontSize: '20px',
-          lineHeight: '24px',
-          fontWeight: '500',
-          marginTop: '0px',
-          marginBottom: '0px',
-        };
+        return Object.assign(Object.assign({}, textStyleBase), { fontSize: '20px', lineHeight: '24px', minHeight: '24px', marginTop: '0px', marginBottom: '0px' });
       }
       case 'heading-3': {
-        return {
-          fontFamily: 'Inter',
-          fontSize: '18px',
-          lineHeight: '22px',
-          fontWeight: '500',
-          marginTop: '0px',
-          marginBottom: '0px',
-        };
+        return Object.assign(Object.assign({}, textStyleBase), { fontSize: '18px', lineHeight: '22px', minHeight: '22px', marginTop: '0px', marginBottom: '0px' });
       }
       case 'heading-4': {
-        return {
-          fontFamily: 'Inter',
-          fontSize: '16px',
-          lineHeight: '22px',
-          fontWeight: '500',
-          marginTop: '0px',
-          marginBottom: '0px',
-        };
+        return Object.assign(Object.assign({}, textStyleBase), { fontSize: '16px', lineHeight: '22px', minHeight: '22px', marginTop: '0px', marginBottom: '0px' });
       }
       case 'heading-5': {
-        return {
-          fontFamily: 'Inter',
-          fontSize: '14px',
-          lineHeight: '22px',
-          fontWeight: '500',
-          marginTop: '0px',
-          marginBottom: '0px',
-        };
+        return Object.assign(Object.assign({}, textStyleBase), { fontSize: '14px', lineHeight: '22px', minHeight: '22px', marginTop: '0px', marginBottom: '0px' });
       }
       case 'heading-6': {
-        return {
-          fontFamily: 'Inter',
-          fontSize: '12px',
-          lineHeight: '22px',
-          fontWeight: '500',
-          marginTop: '0px',
-          marginBottom: '0px',
-        };
+        return Object.assign(Object.assign({}, textStyleBase), { fontSize: '12px', lineHeight: '22px', minHeight: '22px', marginTop: '0px', marginBottom: '0px' });
       }
     }
   }
@@ -4413,4 +4361,4 @@ class RTECodeBlock extends RTEBlock {
 })();
 RTECodeBlock.CODE_BLOCK_PLACEHOLDER_CLASS_NAME = 'code-block-placeholder-element';
 
-export { TextColorAnnotationAction as $, ActionHandleStrategyRegistry as A, BlockUpdateTextStyleStrategy as B, CustomStyleAnnotation as C, NodeTypeEnum as D, CommonAnnotation as E, AnnotationAction as F, ReplaceChildNodesAction as G, HorizontalAlignmentAnnotationAction as H, InsertChildrenAfterAction as I, SplitBlockWithNodeAction as J, BlockDeleteNodeContentStrategy as K, RemoveChildrenStrategy as L, ModifyContentAction as M, NodeAnnotation as N, RTE_TEXT_COLORS as O, RTE_DEFAULT_TEXT_COLOR as P, CodeLanguage as Q, RTEDTOClassManager$1 as R, SyncUpSelectionAction as S, TextStyleAnnotationAction as T, UpdateTextAction as U, VegaRTEPresetToolbarItems as V, LinkAnnotationAction as W, CommonAnnotationTypeEnum as X, UpdateCodeBlockAction as Y, ZERO_WIDTH_SPACE as Z, SelectionChangeAction as _, ActionHandlerInterceptorRegistry as a, RTECodeBlockNode as a0, BoldAnnotationAction as a1, ItalicAnnotationAction as a2, UnderlineAnnotationAction as a3, TextStyleAnnotation as a4, BoldAnnotation as a5, ClearFormattingAnnotationAction as a6, CodeAnnotationAction as a7, StrikethroughAnnotationAction as a8, IndentAnnotationAction as a9, RTETextNode as b, ModifyContentActionType as c, ActionHandleStrategy as d, RTETextBlock as e, RTEBlock as f, RTEAnnotationStyle as g, AppendChildrenAction as h, RTENode as i, InsertChildrenBeforeAction as j, InternalAnnotationTypeEnum as k, BlockUpdateHorizontalAlignmentStrategy as l, BlockInsertLineBreakStrategy as m, BlockInsertLineBreakWithBlocksStrategy as n, BlockSplitWithTextNodeStrategy as o, BlockReplaceNodesStrategy as p, BlockMergeNodesStrategy as q, RemoveChildrenAction as r, stateEntityRenderingRegistry as s, BlockAnnotation as t, BlockAnnotationTypeEnum as u, CustomClassAnnotation as v, CustomAttributeAnnotation as w, RTECodeBlock as x, NodeAnnotationTypeEnum as y, RTEDecoratorNode as z };
+export { TextColorAnnotationAction as $, ActionHandleStrategyRegistry as A, BlockUpdateTextStyleStrategy as B, CustomAttributeAnnotation as C, NodeTypeEnum as D, CommonAnnotation as E, AnnotationAction as F, ReplaceChildNodesAction as G, HorizontalAlignmentAnnotationAction as H, InsertChildrenAfterAction as I, SplitBlockWithNodeAction as J, BlockDeleteNodeContentStrategy as K, RemoveChildrenStrategy as L, ModifyContentAction as M, NodeAnnotation as N, RTE_TEXT_COLORS as O, RTE_DEFAULT_TEXT_COLOR as P, CodeLanguage as Q, RTEDTOClassManager$1 as R, SyncUpSelectionAction as S, TextStyleAnnotationAction as T, UpdateTextAction as U, VegaRTEPresetToolbarItems as V, LinkAnnotationAction as W, CommonAnnotationTypeEnum as X, UpdateCodeBlockAction as Y, ZERO_WIDTH_SPACE as Z, SelectionChangeAction as _, ActionHandlerInterceptorRegistry as a, RTECodeBlockNode as a0, BoldAnnotationAction as a1, ItalicAnnotationAction as a2, UnderlineAnnotationAction as a3, TextStyleAnnotation as a4, BoldAnnotation as a5, ClearFormattingAnnotationAction as a6, CodeAnnotationAction as a7, StrikethroughAnnotationAction as a8, IndentAnnotationAction as a9, RTETextNode as b, ModifyContentActionType as c, ActionHandleStrategy as d, RTETextBlock as e, RTEBlock as f, RTEAnnotationStyle as g, AppendChildrenAction as h, RTENode as i, InsertChildrenBeforeAction as j, InternalAnnotationTypeEnum as k, BlockUpdateHorizontalAlignmentStrategy as l, BlockInsertLineBreakStrategy as m, BlockInsertLineBreakWithBlocksStrategy as n, BlockSplitWithTextNodeStrategy as o, BlockReplaceNodesStrategy as p, BlockMergeNodesStrategy as q, RemoveChildrenAction as r, stateEntityRenderingRegistry as s, BlockAnnotation as t, BlockAnnotationTypeEnum as u, CustomStyleAnnotation as v, CustomClassAnnotation as w, RTECodeBlock as x, NodeAnnotationTypeEnum as y, RTEDecoratorNode as z };

package/dist/esm/{component-value-history-controller-slimmer.abstract-5d618b88.js → component-value-history-controller-slimmer.abstract-a61bf821.js}

@@ -1,15 +1,15 @@
 import { M as MapToComponentMethod, V as VegaSlimmer, L as LogUtility, c as MapToComponentField } from './global-slimmer-registry-17c4efd4.js';
-import { a0 as RTECodeBlockNode, b as RTETextNode, Z as ZERO_WIDTH_SPACE, _ as SelectionChangeAction, k as InternalAnnotationTypeEnum, s as stateEntityRenderingRegistry, f as RTEBlock, i as RTENode, z as RTEDecoratorNode, x as RTECodeBlock } from './code-block-ecb4491b.js';
+import { a0 as RTECodeBlockNode, b as RTETextNode, Z as ZERO_WIDTH_SPACE, _ as SelectionChangeAction, k as InternalAnnotationTypeEnum, s as stateEntityRenderingRegistry, f as RTEBlock, i as RTENode, z as RTEDecoratorNode, x as RTECodeBlock } from './code-block-8ee34ab6.js';
 import { d as debounce } from './timer-9321173b.js';
 import { g as getActiveElement } from './component-7d906393.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { d as domNodeSubjectFactory, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-dca87b70.js';
-import { c as VegaInternalRichTextEditorSelectionRangeChange, a as VegaInternalUpdateRTECursorPosition } from './vega-internal-event-id-5c3e5f7f.js';
+import { d as domNodeSubjectFactory, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-064ee2b2.js';
+import { c as VegaInternalRichTextEditorSelectionRangeChange, a as VegaInternalUpdateRTECursorPosition } from './vega-internal-event-id-4a06d705.js';
 import { O as Observer } from './observer-3959f9dd.js';
-import { R as RTERange } from './range-f7b9e2fb.js';
+import { R as RTERange } from './range-5257c062.js';
 import { S as SynchronizeTaskQueue } from './synchronize-task-queue-ac8acc3b.js';
 import { i as isHTMLElement } from './ui-bb99c0c2.js';
-import { K as KeyboardManagerSlimmer } from './keyboard-manager-slimmer-f39214e4.js';
+import { K as KeyboardManagerSlimmer } from './keyboard-manager-slimmer-79c78ce8.js';
 
 let processing = false;
 /**

package/dist/esm/{date-required-rule-8944f3bf.js → date-required-rule-47ecc28f.js}

@@ -1,4 +1,4 @@
-import { i as isDateStr } from './date-c55b97f0.js';
+import { Q as isDateStr } from './type-guard-c65a227d.js';
 import { I as InternalFormFieldValidationRule } from './internal-form-field-validation-rule.abstract-f5b6bdbf.js';
 
 /**

package/dist/esm/{design-token-2d77e8f5.js → design-token-007efbaa.js}

@@ -1,10 +1,9 @@
-import { j as isBorderColorTokenType, b as BorderColors, e as BorderColorMap, k as isShadowsTokenType, f as Shadows, g as ShadowMap, l as isBorderTokenType, m as Borders, n as BorderMap, o as isSpacingTokenType, p as isBorderRadiusTokenType, q as isBackgroundColorTokenType, r as isTextColorTokenType, s as isBreakpointsTokenType, h as Spacing, t as isBorderStyleType, B as BorderRadius, C as Colors, u as isTypographyTokenType } from './type-guard-12f7654b.js';
+import { j as StateVariantFormatter, k as isBorderColorTokenType, b as BorderColors, e as BorderColorMap, l as isShadowsTokenType, f as Shadows, g as ShadowMap, m as isBorderTokenType, n as Borders, o as BorderMap, p as StateBackgroundColorFormatter, q as isSpacingTokenType, r as isBorderRadiusTokenType, s as isBackgroundColorTokenType, t as isTextColorTokenType, u as isBreakpointsTokenType, h as Spacing, v as isBorderStyleType, B as BorderRadius, C as Colors, w as isTypographyTokenType } from './type-guard-c65a227d.js';
 import { B as Breakpoints } from './breakpoints-d9faf11c.js';
 import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
-import { R as ResponsiveFormatFacade } from './responsive-format-facade-267935ae.js';
+import { R as ResponsiveFormatFacade } from './responsive-format-facade-28ee2dbd.js';
 import { a as TypographyKeys } from './typography-396de03f.js';
-import { S as StateVariantFormatter, s as stateBackgroundColorFormatter } from './state-background-color-formatter-0f01d27a.js';
-import { a as BorderStyle } from './ui-8424715a.js';
+import { B as BorderStyle } from './ui-28fd4193.js';
 
 /**
  * The `StateBorderColorFormatter` class in TypeScript formats border color tokens based on
@@ -156,7 +155,7 @@ class StateFormatFacade {
   format(input, flag) {
     switch (flag) {
       case 'backgroundColor':
-        return stateBackgroundColorFormatter.format(input);
+        return StateBackgroundColorFormatter.format(input);
       case 'borderColor':
         return StateBorderColorFormatter$1.format(input);
       case 'shadow':