@heartlandone/vega 2.76.0 → 2.77.1

package/dist/collection/polyfill/libphonenumber/test/index.test.js

@@ -0,0 +1,16 @@
+import { getCountryCallingCode, getCountries, parseIncompletePhoneNumber, parsePhoneNumber, formatIncompletePhoneNumber, AsYouType, PhoneNumber, PARSE_ERROR_NOT_A_NUMBER, PARSE_ERROR_INVALID_COUNTRY, } from '../index';
+describe('libphonenumber polyfill index', () => {
+  it('should export all required functions and classes', () => {
+    expect(getCountryCallingCode).toBeDefined();
+    expect(getCountries).toBeDefined();
+    expect(parseIncompletePhoneNumber).toBeDefined();
+    expect(parsePhoneNumber).toBeDefined();
+    expect(formatIncompletePhoneNumber).toBeDefined();
+    expect(AsYouType).toBeDefined();
+    expect(PhoneNumber).toBeDefined();
+  });
+  it('should export error constants', () => {
+    expect(PARSE_ERROR_NOT_A_NUMBER).toBeDefined();
+    expect(PARSE_ERROR_INVALID_COUNTRY).toBeDefined();
+  });
+});

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

@@ -0,0 +1,196 @@
+import { META, getCountryCallingCode, getCountries, getFormats, detectCallingCode, getCountryByNationalNumber, } from '../metadata';
+// ---------------------------------------------------------------------------
+// META singleton
+// ---------------------------------------------------------------------------
+describe('META singleton', () => {
+  it('should have a version number', () => {
+    expect(META.version).toBeDefined();
+    expect(typeof META.version).toBe('number');
+  });
+  it('should contain countryCallingCode mapping', () => {
+    expect(META.countryCallingCode).toBeDefined();
+    expect(META.countryCallingCode['1']).toContain('US');
+  });
+  it('should contain countries mapping', () => {
+    expect(META.countries).toBeDefined();
+    expect(META.countries['US']).toBeDefined();
+  });
+});
+// ---------------------------------------------------------------------------
+// getCountryCallingCode
+// ---------------------------------------------------------------------------
+describe('getCountryCallingCode', () => {
+  it('should return "1" for US', () => {
+    expect(getCountryCallingCode('US')).toBe('1');
+  });
+  it('should return "44" for GB', () => {
+    expect(getCountryCallingCode('GB')).toBe('44');
+  });
+  it('should return "86" for CN', () => {
+    expect(getCountryCallingCode('CN')).toBe('86');
+  });
+  it('should return "49" for DE', () => {
+    expect(getCountryCallingCode('DE')).toBe('49');
+  });
+  it('should return "61" for AU', () => {
+    expect(getCountryCallingCode('AU')).toBe('61');
+  });
+  it('should throw for unknown country', () => {
+    expect(() => getCountryCallingCode('ZZ')).toThrow('Unknown country: ZZ');
+  });
+});
+// ---------------------------------------------------------------------------
+// getCountries
+// ---------------------------------------------------------------------------
+describe('getCountries', () => {
+  it('should return an array of country codes', () => {
+    const countries = getCountries();
+    expect(Array.isArray(countries)).toBe(true);
+    expect(countries.length).toBeGreaterThan(0);
+  });
+  it('should include common countries', () => {
+    const countries = getCountries();
+    expect(countries).toContain('US');
+    expect(countries).toContain('GB');
+    expect(countries).toContain('CN');
+    expect(countries).toContain('DE');
+    expect(countries).toContain('JP');
+  });
+});
+// ---------------------------------------------------------------------------
+// getFormats
+// ---------------------------------------------------------------------------
+describe('getFormats', () => {
+  it('should return format rules for US', () => {
+    const formats = getFormats('US');
+    expect(formats).toBeDefined();
+    expect(Array.isArray(formats)).toBe(true);
+    const definedFormats = formats;
+    expect(definedFormats.length).toBeGreaterThan(0);
+  });
+  it('should return format rules for GB', () => {
+    const formats = getFormats('GB');
+    expect(formats).toBeDefined();
+    const definedFormats = formats;
+    expect(definedFormats.length).toBeGreaterThan(0);
+  });
+  it('should inherit formats from primary country for NANPA siblings', () => {
+    // CA and VI share calling code '1' with US and have no own formats
+    const caFormats = getFormats('CA');
+    const usFormats = getFormats('US');
+    expect(caFormats).toBeDefined();
+    // CA inherits from US, so they should be the same formats
+    expect(caFormats).toEqual(usFormats);
+  });
+  it('should return undefined for unknown country', () => {
+    const formats = getFormats('ZZ');
+    expect(formats).toBeUndefined();
+  });
+  it('should return format tuples with correct structure', () => {
+    const formats = getFormats('US');
+    expect(formats).toBeDefined();
+    const definedFormats = formats;
+    const firstFormat = definedFormats[0];
+    // [0] pattern (string), [1] replacement (string), [2] leadingDigitsPatterns (string[])
+    expect(typeof firstFormat[0]).toBe('string');
+    expect(typeof firstFormat[1]).toBe('string');
+    expect(Array.isArray(firstFormat[2])).toBe(true);
+  });
+});
+// ---------------------------------------------------------------------------
+// detectCallingCode
+// ---------------------------------------------------------------------------
+describe('detectCallingCode', () => {
+  it('should detect US calling code from digits starting with 1', () => {
+    const result = detectCallingCode('13023334444');
+    expect(result.callingCode).toBe('1');
+    expect(result.countries).toContain('US');
+  });
+  it('should detect UK calling code from digits starting with 44', () => {
+    const result = detectCallingCode('447911123456');
+    expect(result.callingCode).toBe('44');
+    expect(result.countries).toContain('GB');
+  });
+  it('should detect CN calling code from digits starting with 86', () => {
+    const result = detectCallingCode('8613812345678');
+    expect(result.callingCode).toBe('86');
+    expect(result.countries).toContain('CN');
+  });
+  it('should detect 3-digit calling codes (e.g., 375 for BY)', () => {
+    const result = detectCallingCode('375291234567');
+    expect(result.callingCode).toBe('375');
+    expect(result.countries).toContain('BY');
+  });
+  it('should return undefined for unrecognized digits', () => {
+    const result = detectCallingCode('');
+    expect(result.callingCode).toBeUndefined();
+    expect(result.countries).toBeUndefined();
+  });
+  it('should return NANPA countries for calling code 1', () => {
+    const result = detectCallingCode('1');
+    expect(result.callingCode).toBe('1');
+    expect(result.countries).toBeDefined();
+    const definedCountries = result.countries;
+    expect(definedCountries.length).toBeGreaterThan(1);
+    expect(result.countries).toContain('US');
+  });
+});
+// ---------------------------------------------------------------------------
+// getCountryByNationalNumber
+// ---------------------------------------------------------------------------
+describe('getCountryByNationalNumber', () => {
+  it('should distinguish VI from US by leading digits 340', () => {
+    // eslint-disable-next-line spellcheck/spell-checker
+    const nanpaCountries = META.countryCallingCode['1'];
+    // eslint-disable-next-line spellcheck/spell-checker
+    expect(nanpaCountries).toBeDefined();
+    // eslint-disable-next-line spellcheck/spell-checker
+    const country = getCountryByNationalNumber(nanpaCountries, '3405100000');
+    expect(country).toBe('VI');
+  });
+  it('should distinguish PR from US by leading digits 787/939', () => {
+    // eslint-disable-next-line spellcheck/spell-checker
+    const nanpaCountries = META.countryCallingCode['1'];
+    // eslint-disable-next-line spellcheck/spell-checker
+    const country = getCountryByNationalNumber(nanpaCountries, '7871234567');
+    expect(country).toBe('PR');
+  });
+  it('should fall back to type-based matching when no leading digits', () => {
+    // eslint-disable-next-line spellcheck/spell-checker
+    const nanpaCountries = META.countryCallingCode['1'];
+    // eslint-disable-next-line spellcheck/spell-checker
+    const country = getCountryByNationalNumber(nanpaCountries, '2025551234');
+    // US numbers with area code 202 should match US
+    expect(country).toBeDefined();
+  });
+  it('should return undefined when no country matches', () => {
+    const country = getCountryByNationalNumber(['US'], '');
+    expect(country).toBeUndefined();
+  });
+  it('should skip non-existent countries in first pass', () => {
+    // 'FAKE' does not exist in META.countries — the loop should skip it via `if (!entry) continue`
+    const country = getCountryByNationalNumber(['FAKE', 'VI'], '3405100000');
+    expect(country).toBe('VI');
+  });
+  it('should skip non-existent countries in second pass', () => {
+    // 'FAKE' is checked in both passes — first pass skips (no entry), second pass also skips
+    // US has no leadingDigits so it falls to second pass for type matching
+    const country = getCountryByNationalNumber(['FAKE', 'US'], '2025551234');
+    expect(country).toBe('US');
+  });
+  it('should return country from first-pass leading digits match', () => {
+    // VI has leadingDigits '340'. When possibleCountries includes VI
+    // and nationalNumber starts with 340, the first pass matches and returns VI.
+    // eslint-disable-next-line spellcheck/spell-checker
+    const country = getCountryByNationalNumber(['VI', 'US'], '3405100000');
+    expect(country).toBe('VI');
+  });
+  it('should not match leading digits when nationalNumber is empty', () => {
+    // eslint-disable-next-line spellcheck/spell-checker
+    const country = getCountryByNationalNumber(['VI', 'US'], '');
+    // VI has leadingDigits '340' but nationalNumber '' fails the check
+    // Falls through to second pass, US has no leadingDigits → type matching
+    // Empty string won't match US type patterns either
+    expect(country).toBeUndefined();
+  });
+});

package/dist/collection/polyfill/libphonenumber/test/parse-phone-number.test.js

@@ -0,0 +1,218 @@
+import { parseIncompletePhoneNumber, parsePhoneNumber } from '../parse-phone-number';
+// ---------------------------------------------------------------------------
+// parseIncompletePhoneNumber
+// ---------------------------------------------------------------------------
+describe('parseIncompletePhoneNumber', () => {
+  it('should strip non-digit characters', () => {
+    expect(parseIncompletePhoneNumber('(302) 333-4444')).toBe('3023334444');
+  });
+  it('should keep a leading +', () => {
+    expect(parseIncompletePhoneNumber('+1 (302) 333-4444')).toBe('+13023334444');
+  });
+  it('should only keep the first + (at position 0)', () => {
+    expect(parseIncompletePhoneNumber('1+2+3')).toBe('123');
+  });
+  it('should return empty string for empty input', () => {
+    expect(parseIncompletePhoneNumber('')).toBe('');
+  });
+  it('should return "+" for input containing only "+"', () => {
+    expect(parseIncompletePhoneNumber('+')).toBe('+');
+  });
+  it('should strip letters and special characters', () => {
+    // eslint-disable-next-line spellcheck/spell-checker
+    expect(parseIncompletePhoneNumber('abc 123 def 456')).toBe('123456');
+  });
+  it('should handle input with only non-digit characters', () => {
+    // eslint-disable-next-line spellcheck/spell-checker
+    expect(parseIncompletePhoneNumber('abc def')).toBe('');
+  });
+});
+// ---------------------------------------------------------------------------
+// parsePhoneNumber — international format (+)
+// ---------------------------------------------------------------------------
+describe('parsePhoneNumber (international)', () => {
+  it('should parse a US number with country code', () => {
+    const phoneNumber = parsePhoneNumber('+1 (302) 333-4444');
+    expect(phoneNumber.countryCallingCode).toBe('1');
+    expect(phoneNumber.nationalNumber).toBe('3023334444');
+    expect(phoneNumber.country).toBe('US');
+  });
+  it('should parse a GB number', () => {
+    const phoneNumber = parsePhoneNumber('+44 2012345678');
+    expect(phoneNumber.countryCallingCode).toBe('44');
+    expect(phoneNumber.nationalNumber).toBe('2012345678');
+    // Calling code 44 is shared by GB/GG/JE/IM; country resolved by type matching
+    expect(phoneNumber.country).toBeDefined();
+  });
+  it('should parse a CN number', () => {
+    const phoneNumber = parsePhoneNumber('+86 138 1234 5678');
+    expect(phoneNumber.countryCallingCode).toBe('86');
+    expect(phoneNumber.nationalNumber).toBe('13812345678');
+    expect(phoneNumber.country).toBe('CN');
+  });
+  it('should parse a DE number', () => {
+    const phoneNumber = parsePhoneNumber('+49 30 12345678');
+    expect(phoneNumber.countryCallingCode).toBe('49');
+    expect(phoneNumber.country).toBe('DE');
+  });
+  it('should detect VI by leading digits 340', () => {
+    const phoneNumber = parsePhoneNumber('+1 340 510 0000');
+    expect(phoneNumber.country).toBe('VI');
+    expect(phoneNumber.nationalNumber).toBe('3405100000');
+  });
+  it('should detect PR by leading digits 787', () => {
+    const phoneNumber = parsePhoneNumber('+1 787 123 4567');
+    expect(phoneNumber.country).toBe('PR');
+  });
+  // eslint-disable-next-line spellcheck/spell-checker
+  it('should strip NANPA trunk prefix when parsing +1 with 11 digits starting with 1', () => {
+    const phoneNumber = parsePhoneNumber('+113405100000');
+    expect(phoneNumber.country).toBe('VI');
+    expect(phoneNumber.nationalNumber).toBe('3405100000');
+  });
+});
+// ---------------------------------------------------------------------------
+// parsePhoneNumber — national format (with defaultCountry)
+// ---------------------------------------------------------------------------
+describe('parsePhoneNumber (national / defaultCountry)', () => {
+  it('should parse a US national number with default country', () => {
+    const phoneNumber = parsePhoneNumber('(302) 333-4444', 'US');
+    expect(phoneNumber.countryCallingCode).toBe('1');
+    expect(phoneNumber.nationalNumber).toBe('3023334444');
+    expect(phoneNumber.country).toBe('US');
+  });
+  it('should parse a GB national number', () => {
+    const phoneNumber = parsePhoneNumber('07911 123456', {
+      defaultCountry: 'GB',
+    });
+    expect(phoneNumber.countryCallingCode).toBe('44');
+    expect(phoneNumber.country).toBe('GB');
+  });
+  // eslint-disable-next-line spellcheck/spell-checker
+  it('should detect NANPA sibling country in national mode', () => {
+    // 340 area code → VI
+    const phoneNumber = parsePhoneNumber('3405100000', 'US');
+    expect(phoneNumber.country).toBe('VI');
+  });
+  // eslint-disable-next-line spellcheck/spell-checker
+  it('should strip NANPA trunk prefix 1 from 11-digit national number', () => {
+    const phoneNumber = parsePhoneNumber('13405100000', 'US');
+    expect(phoneNumber.nationalNumber).toBe('3405100000');
+    expect(phoneNumber.country).toBe('VI');
+  });
+});
+// ---------------------------------------------------------------------------
+// parsePhoneNumber — national format with unique calling code
+// ---------------------------------------------------------------------------
+describe('parsePhoneNumber (unique calling code)', () => {
+  it('should fall back to defaultCountry when calling code has no siblings', () => {
+    // DE has calling code 49, which is unique (not shared with other countries)
+    const phoneNumber = parsePhoneNumber('3012345678', 'DE');
+    expect(phoneNumber.countryCallingCode).toBe('49');
+    expect(phoneNumber.country).toBe('DE');
+  });
+  it('should use defaultCountry for CN national number', () => {
+    // CN has calling code 86, unique
+    const phoneNumber = parsePhoneNumber('13812345678', 'CN');
+    expect(phoneNumber.countryCallingCode).toBe('86');
+    expect(phoneNumber.country).toBe('CN');
+  });
+});
+// ---------------------------------------------------------------------------
+// parsePhoneNumber — national prefix extraction
+// ---------------------------------------------------------------------------
+describe('parsePhoneNumber (return with resolved country and number)', () => {
+  it('should return a PhoneNumber for a country without nationalPrefixForParsing', () => {
+    // KR (South Korea) has no nationalPrefixForParsing (entry[7] is falsy),
+    // so the prefix-extraction block is skipped entirely and execution
+    // falls through to the final return statement.
+    const phoneNumber = parsePhoneNumber('+82 10 1234 5678');
+    expect(phoneNumber.countryCallingCode).toBe('82');
+    expect(phoneNumber.country).toBe('KR');
+    expect(phoneNumber.nationalNumber).toBe('1012345678');
+  });
+});
+describe('parsePhoneNumber (national prefix extraction)', () => {
+  it('should strip national prefix when stripped version matches but original does not', () => {
+    // GB has nationalPrefixForParsing = '0' (entry[7]).
+    // If we parse a GB national number starting with '0', the prefix '0' is matched.
+    // '07911123456': original '07911123456' fails validation (starts with 0),
+    // afterPrefix '7911123456' passes validation → nationalNumber = '7911123456'
+    const phoneNumber = parsePhoneNumber('07911123456', 'GB');
+    expect(phoneNumber.countryCallingCode).toBe('44');
+    expect(phoneNumber.country).toBe('GB');
+    expect(phoneNumber.nationalNumber).toBe('7911123456');
+  });
+  it('should NOT strip prefix if original already matches validation', () => {
+    // A CN number that already matches validation shouldn't have prefix stripped
+    const phoneNumber = parsePhoneNumber('+8613812345678');
+    expect(phoneNumber.country).toBe('CN');
+    expect(phoneNumber.nationalNumber).toBe('13812345678');
+  });
+  it('should not strip when afterPrefix is empty', () => {
+    // If the entire national number IS the prefix match, afterPrefix = ''
+    // strippedMatches should be false (afterPrefix.length > 0 fails)
+    // Use IT which has nationalPrefixForParsing. Parse a number where the
+    // entire string matches the prefix pattern but nothing is left after.
+    // Simplest: use a defaultCountry with prefix, where the number = prefix.
+    // GB prefix is '0'. Parsing '0' as national GB: prefix '0' matched,
+    // afterPrefix is '', strippedMatches is false, number stays '0'.
+    const phoneNumber = parsePhoneNumber('0', 'GB');
+    expect(phoneNumber.nationalNumber).toBe('0');
+  });
+  it('should not strip when prefix match length is 0', () => {
+    // Some nationalPrefixForParsing patterns can match zero-length strings.
+    // The code checks match[0].length > 0. If 0, the block is skipped entirely.
+    // JP has nationalPrefixForParsing = '0' which shouldn't match zero-length
+    // but a number not starting with '0' simply won't match → block skipped
+    const phoneNumber = parsePhoneNumber('3012345678', 'JP');
+    expect(phoneNumber.nationalNumber).toBe('3012345678');
+  });
+});
+// ---------------------------------------------------------------------------
+// parsePhoneNumber — error handling
+// ---------------------------------------------------------------------------
+describe('parsePhoneNumber (errors)', () => {
+  it('should throw NOT_A_NUMBER for empty input', () => {
+    expect(() => parsePhoneNumber('')).toThrow('NOT_A_NUMBER');
+  });
+  it('should throw NOT_A_NUMBER for just "+"', () => {
+    expect(() => parsePhoneNumber('+')).toThrow('NOT_A_NUMBER');
+  });
+  it('should throw NOT_A_NUMBER for non-numeric text', () => {
+    // eslint-disable-next-line spellcheck/spell-checker
+    expect(() => parsePhoneNumber('abc')).toThrow('NOT_A_NUMBER');
+  });
+  it('should throw INVALID_COUNTRY when no + and no defaultCountry', () => {
+    expect(() => parsePhoneNumber('3023334444')).toThrow('INVALID_COUNTRY');
+  });
+  it('should throw INVALID_COUNTRY for unrecognized calling code', () => {
+    expect(() => parsePhoneNumber('+99999999999')).toThrow('INVALID_COUNTRY');
+  });
+  it('should throw NOT_A_NUMBER with extract=false when input contains letters', () => {
+    // eslint-disable-next-line spellcheck/spell-checker
+    expect(() => parsePhoneNumber('abc123', { extract: false })).toThrow('NOT_A_NUMBER');
+  });
+});
+// ---------------------------------------------------------------------------
+// parsePhoneNumber — options object
+// ---------------------------------------------------------------------------
+describe('parsePhoneNumber (options)', () => {
+  it('should accept string shorthand for defaultCountry', () => {
+    const phoneNumber = parsePhoneNumber('2025551234', 'US');
+    expect(phoneNumber.country).toBe('US');
+  });
+  it('should accept options object with defaultCountry', () => {
+    const phoneNumber = parsePhoneNumber('2025551234', {
+      defaultCountry: 'US',
+    });
+    expect(phoneNumber.country).toBe('US');
+  });
+  it('should accept options with extract=true (default)', () => {
+    const phoneNumber = parsePhoneNumber('Call me at 2025551234', {
+      defaultCountry: 'US',
+      extract: true,
+    });
+    expect(phoneNumber.nationalNumber).toBe('2025551234');
+  });
+});

package/dist/collection/polyfill/libphonenumber/test/phone-number.test.js

@@ -0,0 +1,56 @@
+import { PhoneNumber } from '../phone-number';
+// ---------------------------------------------------------------------------
+// Constructor & properties
+// ---------------------------------------------------------------------------
+describe('PhoneNumber', () => {
+  describe('constructor and properties', () => {
+    it('should store countryCallingCode, nationalNumber, and country', () => {
+      const phoneNumber = new PhoneNumber('1', '3023334444', 'US');
+      expect(phoneNumber.countryCallingCode).toBe('1');
+      expect(phoneNumber.nationalNumber).toBe('3023334444');
+      expect(phoneNumber.country).toBe('US');
+    });
+    it('should allow undefined country', () => {
+      const phoneNumber = new PhoneNumber('1', '3023334444');
+      expect(phoneNumber.country).toBeUndefined();
+    });
+  });
+  // -----------------------------------------------------------------------
+  // isValid()
+  // -----------------------------------------------------------------------
+  describe('isValid', () => {
+    it('should return true for a valid US number', () => {
+      const phoneNumber = new PhoneNumber('1', '2025551234', 'US');
+      expect(phoneNumber.isValid()).toBe(true);
+    });
+    it('should return false for a too-short US number', () => {
+      const phoneNumber = new PhoneNumber('1', '20255', 'US');
+      expect(phoneNumber.isValid()).toBe(false);
+    });
+    it('should return false for a too-long US number', () => {
+      const phoneNumber = new PhoneNumber('1', '20255512345678', 'US');
+      expect(phoneNumber.isValid()).toBe(false);
+    });
+    it('should return false when country is undefined', () => {
+      const phoneNumber = new PhoneNumber('1', '2025551234');
+      expect(phoneNumber.isValid()).toBe(false);
+    });
+    it('should return true for a valid GB number', () => {
+      const phoneNumber = new PhoneNumber('44', '7911123456', 'GB');
+      expect(phoneNumber.isValid()).toBe(true);
+    });
+    it('should return true for a valid CN mobile number', () => {
+      const phoneNumber = new PhoneNumber('86', '13812345678', 'CN');
+      expect(phoneNumber.isValid()).toBe(true);
+    });
+    it('should return false when national number does not match validation pattern', () => {
+      // US numbers cannot start with 0 or 1 in area code
+      const phoneNumber = new PhoneNumber('1', '0005551234', 'US');
+      expect(phoneNumber.isValid()).toBe(false);
+    });
+    it('should return false when country is not in metadata', () => {
+      const phoneNumber = new PhoneNumber('1', '2025551234', 'ZZ');
+      expect(phoneNumber.isValid()).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,23 @@
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Placeholder character used in formatting templates. */
+export const DIGIT_PLACEHOLDER = 'x';
+/** Dummy digit used to generate formatting templates. */
+export const DUMMY_DIGIT = '9';
+/** Maximum possible national number length. */
+export const LONGEST_NATIONAL_NUMBER_LENGTH = 15;
+/** Minimum digits before progressive leading-digits matching kicks in. */
+export const MIN_LEADING_DIGITS_LENGTH = 3;
+/**
+ * Pattern that matches national prefix formatting rules that are just "$1"
+ * or "($1)" — i.e. rules that don't actually prepend a national prefix digit.
+ */
+export const FIRST_GROUP_ONLY_PREFIX_PATTERN = /^\(?\$1\)?$/;
+// ---------------------------------------------------------------------------
+// Parse error codes
+// ---------------------------------------------------------------------------
+/** Error code thrown when the input does not contain a valid phone number. */
+export const PARSE_ERROR_NOT_A_NUMBER = 'NOT_A_NUMBER';
+/** Error code thrown when the country cannot be determined from the input. */
+export const PARSE_ERROR_INVALID_COUNTRY = 'INVALID_COUNTRY';

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

@@ -1,6 +1,7 @@
 import { newE2EPage } from '@stencil/core/testing';
 import * as axe from 'axe-core';
 import { TestIcons } from '../test-assets/test-icons';
+import { getViewportByDeviceType } from './test-utils';
 /**
  * NOTE: This method is only for **E2E** test cases.
  * Clear the input field and type the input
@@ -241,10 +242,15 @@ export const getScreenshotDiffResults = async (page, desc, selector) => {
  * @param {number} config.timeout --sets the content timeout
  * @param {InjectFeatureFlagsConfig} config.featureFlags -inject feature flags.
  * @param {string} config.timezone -sets the browser timezone (defaults to 'Asia/Shanghai' for consistent behavior across environments).
+ * @param {boolean} config.isMobile - whether to set the viewport to a mobile device size (defaults to false).
  */
 export const initVegaE2EPage = async (content, config) => {
   var _a, _b, _c;
   const page = await newE2EPage();
+  if (config === null || config === void 0 ? void 0 : config.isMobile) {
+    await page.setUserAgent('Mobile');
+    await page.setViewport(getViewportByDeviceType('mobile'));
+  }
   // Set timezone to ensure consistent behavior across different environments
   const timezone = (_a = config === null || config === void 0 ? void 0 : config.timezone) !== null && _a !== void 0 ? _a : 'Asia/Shanghai';
   const pageWithTimezone = page;

package/dist/esm/{app-globals-c0676920.js → app-globals-0b3b7111.js}

@@ -1,19 +1,19 @@
-import { F as FeatureFlag } from './feature-flag-controller-09ea7e87.js';
-import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaEventManager, d as VegaZIndexManager, w as waitForVega, e as VegaSkeletonLoader, f as VegaTranslation, g as VegaRTETokenExtension, h as VegaRTELanguageExtension, i as VegaRTEFunctionExtension } from './token-extension-e33fd151.js';
+import { F as FeatureFlag } from './feature-flag-controller-30f7b625.js';
+import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaEventManager, d as VegaZIndexManager, w as waitForVega, e as VegaSkeletonLoader, f as VegaTranslation, g as VegaRTETokenExtension, h as VegaRTELanguageExtension, i as VegaRTEFunctionExtension } from './token-extension-25df8dbb.js';
 import { M as MapToComponentMethod, V as VegaSlimmer, s as setVegaLogLevel, G as GlobalSlimmersRegistry } from './global-slimmer-registry-17c4efd4.js';
 import { V as VegaDialog } from './vega-dialog-controller-bbb2fc52.js';
 import { T as TypographyUrls } from './typography-396de03f.js';
 import { V as VegaIconManager } from './icon-manager-539d7cf7.js';
-import { V as VegaInternalTranslation, s as staticTranslations } from './internal-translation-controller-911515f9.js';
-import { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-22ce81db.js';
+import { V as VegaInternalTranslation, s as staticTranslations } from './internal-translation-controller-113a6288.js';
+import { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-099dba7d.js';
 import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.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';
 import { f as forceUpdate } from './index-090d31ca.js';
-import { V as VegaRTEContent } from './dto-renderer-manager-6fd22ab7.js';
+import { V as VegaRTEContent } from './dto-renderer-manager-d413de1e.js';
 import { v as vegaNonceManager, s as setVegaNonce } from './vega-nonce-manager-497e5eb5.js';
-import { V as VegaRTEPresetToolbarItems } from './code-block-b6247a45.js';
+import { V as VegaRTEPresetToolbarItems } from './code-block-2408a812.js';
 
 var __decorate$2 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -394,7 +394,7 @@ function injectVegaRichTextEditorClassIntoGlobal() {
  * Inject VegaPublicValidationRules to global as a public api
  */
 function injectVegaPublicValidationRules() {
-  void import('./public-rules-25cc3a39.js').then((module) => {
+  void import('./public-rules-41561e6e.js').then((module) => {
     Object.entries(module).forEach(([name, value]) => {
       globalThis[name] = value;
     });