@lion/ui 0.23.0 → 0.25.0

package/components/input-stepper/translations/sk-SK.js

@@ -1,5 +1,4 @@
 import sk from './sk.js';
-
 export default {
   ...sk,
 };

package/components/input-stepper/translations/uk-UA.js

@@ -1,5 +1,4 @@
 import uk from './uk.js';
-
 export default {
   ...uk,
 };

package/components/input-tel/src/LionInputTel.js

@@ -1,6 +1,5 @@
 import { LocalizeMixin } from '@lion/ui/localize-no-side-effects.js';
 import { LionInput } from '@lion/ui/input.js';
-
 import { PhoneUtilManager } from './PhoneUtilManager.js';
 import { liveFormatPhoneNumber } from './preprocessors.js';
 import { formatPhoneNumber } from './formatters.js';
@@ -10,10 +9,10 @@ import { localizeNamespaceLoader } from './localizeNamespaceLoader.js';
 
 /**
  * @typedef {import('../types/index.js').RegionCode} RegionCode
- * @typedef {import('awesome-phonenumber').PhoneNumberFormat} PhoneNumberFormat
- * @typedef {import('awesome-phonenumber').PhoneNumberTypes} PhoneNumberTypes
+ * @typedef {import('#awesome-phonenumber').PhoneNumberFormat} PhoneNumberFormat
+ * @typedef {import('#awesome-phonenumber').PhoneNumberTypes} PhoneNumberTypes
  * @typedef {import('../../form-core/types/FormatMixinTypes.js').FormatOptions} FormatOptions
- * @typedef {* & typeof import('awesome-phonenumber')} AwesomePhoneNumber
+ * @typedef {* & typeof import('#awesome-phonenumber')} AwesomePhoneNumber
  * @typedef {FormatOptions & {regionCode: RegionCode; formatStrategy: PhoneNumberFormat; formatCountryCodeStyle: string;}} FormatOptionsTel
  */
 
@@ -25,16 +24,32 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
    * @configure LitElement
    */
   static properties = {
-    allowedRegions: { type: Array },
-    formatStrategy: { type: String, attribute: 'format-strategy' },
-    formatCountryCodeStyle: { type: String, attribute: 'format-country-code-style' },
-    activeRegion: { type: String },
-    preferredRegions: { type: Array },
-    _phoneUtil: { type: Object, state: true },
+    allowedRegions: {
+      type: Array,
+    },
+    formatStrategy: {
+      type: String,
+      attribute: 'format-strategy',
+    },
+    formatCountryCodeStyle: {
+      type: String,
+      attribute: 'format-country-code-style',
+    },
+    activeRegion: {
+      type: String,
+    },
+    preferredRegions: {
+      type: Array,
+    },
+    _phoneUtil: {
+      type: Object,
+      state: true,
+    },
   };
-
   static localizeNamespaces = [
-    { 'lion-input-tel': localizeNamespaceLoader },
+    {
+      'lion-input-tel': localizeNamespaceLoader,
+    },
     ...super.localizeNamespaces,
   ];
 
@@ -74,7 +89,9 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
     try {
       pn =
         this._phoneUtil &&
-        this._phoneUtil.parsePhoneNumber(this.modelValue, { regionCode: this.activeRegion });
+        this._phoneUtil.parsePhoneNumber(this.modelValue, {
+          regionCode: this.activeRegion,
+        });
       // eslint-disable-next-line no-empty
     } catch (_) {}
     return pn?.type || 'unknown';
@@ -171,7 +188,6 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
      * @type {RegionCode[]}
      */
     this.preferredRegions = [];
-
     this.__isPhoneNumberValidatorInstance = new PhoneNumber();
     /**  @configures ValidateMixin */
     this.defaultValidators.push(this.__isPhoneNumberValidatorInstance);
@@ -182,9 +198,8 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
      * @type {AwesomePhoneNumber|null}
      */
     this._phoneUtil = PhoneUtilManager.isLoaded
-      ? /** @type {AwesomePhoneNumber} */ (PhoneUtilManager.PhoneUtil)
+      ? /** @type {AwesomePhoneNumber} */ PhoneUtilManager.PhoneUtil
       : null;
-
     if (!PhoneUtilManager.isLoaded) {
       PhoneUtilManager.loadComplete.then(() => {
         this._onPhoneNumberUtilReady();
@@ -206,30 +221,31 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
    */
   updated(changedProperties) {
     super.updated(changedProperties);
-
     if (changedProperties.has('activeRegion')) {
       // Make sure new modelValue is computed, but prevent formattedValue from being set when focused
       this.__isUpdatingRegionWhileFocused = this.focused;
-      this._calculateValues({ source: null });
+      this._calculateValues({
+        source: null,
+      });
       this.__isUpdatingRegionWhileFocused = false;
-
       this.__isPhoneNumberValidatorInstance.param = this.activeRegion;
       /** @type {FormatOptionsTel} */
-      (this.formatOptions).regionCode = /** @type {RegionCode} */ (this.activeRegion);
+      this.formatOptions.regionCode = /** @type {RegionCode} */ this.activeRegion;
     }
-
     if (changedProperties.has('formatStrategy')) {
-      this._calculateValues({ source: null });
+      this._calculateValues({
+        source: null,
+      });
       /** @type {FormatOptionsTel} */
-      (this.formatOptions).formatStrategy = this.formatStrategy;
+      this.formatOptions.formatStrategy = this.formatStrategy;
     }
-
     if (changedProperties.has('formatCountryCodeStyle')) {
-      this._calculateValues({ source: null });
+      this._calculateValues({
+        source: null,
+      });
       /** @type {FormatOptionsTel} */
-      (this.formatOptions).formatCountryCodeStyle = this.formatCountryCodeStyle;
+      this.formatOptions.formatCountryCodeStyle = this.formatCountryCodeStyle;
     }
-
     if (changedProperties.has('modelValue') || changedProperties.has('allowedRegions')) {
       this.__calculateActiveRegion();
     }
@@ -240,15 +256,14 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
    */
   onLocaleUpdated() {
     super.onLocaleUpdated();
-
     const localeSplitted = this._localizeManager.locale.split('-');
     /**
      * @protected
      * @type {RegionCode}
      */
-    this._langIso = /** @type {RegionCode} */ (
-      localeSplitted[localeSplitted.length - 1].toUpperCase()
-    );
+    this._langIso =
+      /** @type {RegionCode} */
+      localeSplitted[localeSplitted.length - 1].toUpperCase();
     this.__calculateActiveRegion();
   }
 
@@ -259,7 +274,7 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
    */
   formatter(modelValue) {
     return formatPhoneNumber(modelValue, {
-      regionCode: /** @type {RegionCode} */ (this.activeRegion),
+      regionCode: /** @type {RegionCode} */ this.activeRegion,
       formatStrategy: this.formatStrategy,
       formatCountryCodeStyle: this.formatCountryCodeStyle,
     });
@@ -272,7 +287,7 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
    */
   parser(viewValue) {
     return parsePhoneNumber(viewValue, {
-      regionCode: /** @type {RegionCode} */ (this.activeRegion),
+      regionCode: /** @type {RegionCode} */ this.activeRegion,
     });
   }
 
@@ -286,7 +301,7 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
    */
   preprocessor(viewValue, { currentCaretIndex, prevViewValue }) {
     return liveFormatPhoneNumber(viewValue, {
-      regionCode: /** @type {RegionCode} */ (this.activeRegion),
+      regionCode: /** @type {RegionCode} */ this.activeRegion,
       formatStrategy: this.formatStrategy,
       formatCountryCodeStyle: this.formatCountryCodeStyle,
       currentCaretIndex,
@@ -310,10 +325,12 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
    */
   _onPhoneNumberUtilReady() {
     // This should trigger a rerender in shadow dom
-    this._phoneUtil = /** @type {AwesomePhoneNumber} */ (PhoneUtilManager.PhoneUtil);
+    this._phoneUtil = /** @type {AwesomePhoneNumber} */ PhoneUtilManager.PhoneUtil;
     // This should trigger a rerender in light dom
     // Format when libPhoneNumber is loaded
-    this._calculateValues({ source: null });
+    this._calculateValues({
+      source: null,
+    });
     this.__calculateActiveRegion();
   }
 
@@ -332,7 +349,6 @@ export class LionInputTel extends LocalizeMixin(LionInput) {
     const value = this.value.match(regex)?.join('');
     const regionDerivedFromValue =
       value && this._phoneUtil && this._phoneUtil.parsePhoneNumber(value).regionCode;
-
     if (regionDerivedFromValue && this._allowedOrAllRegions.includes(regionDerivedFromValue)) {
       this._setActiveRegion(regionDerivedFromValue);
       return;

package/components/input-tel/src/PhoneUtilManager.js

@@ -2,7 +2,7 @@
 let resolveLoaded;
 
 /**
- * @typedef {* & typeof import('awesome-phonenumber')} AwesomePhoneNumber
+ * @typedef {* & typeof import('#awesome-phonenumber')} AwesomePhoneNumber
  */
 
 /**
@@ -13,8 +13,10 @@ let resolveLoaded;
  */
 export class PhoneUtilManager {
   static async loadLibPhoneNumber() {
-    const PhoneUtil = /** @type {AwesomePhoneNumber} */ (await import('awesome-phonenumber'));
-    this.PhoneUtil = { ...PhoneUtil };
+    const PhoneUtil = /** @type {AwesomePhoneNumber} */ await import('#awesome-phonenumber');
+    this.PhoneUtil = {
+      ...PhoneUtil,
+    };
     resolveLoaded(undefined);
     return PhoneUtil;
   }
@@ -34,7 +36,7 @@ export class PhoneUtilManager {
  * await PhoneUtilManager.loadComplete;
  * ```
  */
-PhoneUtilManager.loadComplete = new Promise(resolve => {
+PhoneUtilManager.loadComplete = new Promise((resolve) => {
   resolveLoaded = resolve;
 });
 

package/components/input-tel/src/formatters.js

@@ -1,7 +1,7 @@
 import { PhoneUtilManager } from './PhoneUtilManager.js';
 
 /**
- * @typedef {import('awesome-phonenumber').PhoneNumberFormat} PhoneNumberFormat
+ * @typedef {import('#awesome-phonenumber').PhoneNumberFormat} PhoneNumberFormat
  * @typedef {import('../types/index.js').RegionCode} RegionCode
  */
 
@@ -40,18 +40,16 @@ export function formatPhoneNumber(
   if (!PhoneUtilManager.isLoaded) {
     return modelValue;
   }
-
   const AwesomePhoneNumber = PhoneUtilManager.PhoneUtil;
-
   let pn;
   try {
-    pn = AwesomePhoneNumber.parsePhoneNumber(modelValue, { regionCode });
+    pn = AwesomePhoneNumber.parsePhoneNumber(modelValue, {
+      regionCode,
+    });
     // eslint-disable-next-line no-empty
   } catch (_) {}
-
   if (modelValue?.length >= 4 && modelValue?.length <= 16 && pn?.valid) {
     let formattedValue;
-
     switch (formatStrategy) {
       case 'e164':
         formattedValue = pn.number.e164; // -> '+46707123456' (default)
@@ -71,15 +69,19 @@ export function formatPhoneNumber(
       default:
         break;
     }
-
     if (formatCountryCodeStyle !== 'default') {
-      return getFormatCountryCodeStyle(formattedValue, { regionCode, formatCountryCodeStyle });
+      return getFormatCountryCodeStyle(formattedValue, {
+        regionCode,
+        formatCountryCodeStyle,
+      });
     }
     return formattedValue;
   }
-
   if (formatCountryCodeStyle !== 'default') {
-    return getFormatCountryCodeStyle(modelValue, { regionCode, formatCountryCodeStyle });
+    return getFormatCountryCodeStyle(modelValue, {
+      regionCode,
+      formatCountryCodeStyle,
+    });
   }
   return modelValue;
 }

package/components/input-tel/src/parsers.js

@@ -21,13 +21,13 @@ export function parsePhoneNumber(viewValue, { regionCode }) {
   const strippedViewValue = viewValue.match(regex)?.join('');
   let pn;
   try {
-    pn = AwesomePhoneNumber.parsePhoneNumber(strippedViewValue, { regionCode });
+    pn = AwesomePhoneNumber.parsePhoneNumber(strippedViewValue, {
+      regionCode,
+    });
     // eslint-disable-next-line no-empty
   } catch (_) {}
-
   if (pn?.number) {
     return pn.number.e164;
   }
-
   return viewValue;
 }

package/components/input-tel/src/preprocessors.js

@@ -3,7 +3,7 @@ import { PhoneUtilManager } from './PhoneUtilManager.js';
 
 /**
  * @typedef {import('../types/index.js').RegionCode} RegionCode
- * @typedef {import('awesome-phonenumber').PhoneNumberFormat} PhoneNumberFormat
+ * @typedef {import('#awesome-phonenumber').PhoneNumberFormat} PhoneNumberFormat
  */
 
 /**
@@ -25,20 +25,23 @@ export function liveFormatPhoneNumber(
   if (diff <= 0 || !PhoneUtilManager.isLoaded) {
     return undefined;
   }
-
   const AwesomePhoneNumber = PhoneUtilManager.PhoneUtil;
   const ayt = AwesomePhoneNumber.getAsYouType(regionCode);
-
   for (const char of viewValue) {
     if (char !== '') {
       ayt.addChar(char);
     }
   }
-
   let parenthesesAdded = false;
-  let newViewValue = formatPhoneNumber(ayt.number(), { regionCode, formatStrategy });
+  let newViewValue = formatPhoneNumber(ayt.number(), {
+    regionCode,
+    formatStrategy,
+  });
   if (formatCountryCodeStyle === 'parentheses' && regionCode && !newViewValue.includes(`(`)) {
-    newViewValue = getFormatCountryCodeStyle(newViewValue, { regionCode, formatCountryCodeStyle });
+    newViewValue = getFormatCountryCodeStyle(newViewValue, {
+      regionCode,
+      formatCountryCodeStyle,
+    });
     parenthesesAdded = true;
   }
 
@@ -60,5 +63,10 @@ export function liveFormatPhoneNumber(
   ) {
     newCaretIndex -= 2;
   }
-  return newViewValue ? { viewValue: newViewValue, caretIndex: newCaretIndex } : undefined;
+  return newViewValue
+    ? {
+        viewValue: newViewValue,
+        caretIndex: newCaretIndex,
+      }
+    : undefined;
 }

package/components/input-tel/src/validators.js

@@ -14,11 +14,12 @@ import { PhoneUtilManager } from './PhoneUtilManager.js';
 function hasFeedback(modelValue, regionCode) {
   const AwesomePhoneNumber = PhoneUtilManager.PhoneUtil;
   let invalidCountryCode = false;
-
   if (regionCode && modelValue?.length >= 4 && modelValue?.length <= 16) {
     let pn;
     try {
-      pn = AwesomePhoneNumber.parsePhoneNumber(modelValue, { regionCode });
+      pn = AwesomePhoneNumber.parsePhoneNumber(modelValue, {
+        regionCode,
+      });
       invalidCountryCode = pn.regionCode !== regionCode;
       if (invalidCountryCode) {
         return 'invalid-country-code';
@@ -32,13 +33,10 @@ function hasFeedback(modelValue, regionCode) {
     }
     return enumValue;
   }
-
   return 'unknown';
 }
-
 export class PhoneNumber extends Validator {
   static validatorName = 'PhoneNumber';
-
   static get async() {
     // Will be run as async the first time if PhoneUtilManager hasn't loaded yet, sync afterwards
     return !PhoneUtilManager.isLoaded;
@@ -53,7 +51,7 @@ export class PhoneNumber extends Validator {
     if (!PhoneUtilManager.isLoaded) {
       // Return a Promise once not loaded yet. Since async Validators are meant for things like
       // loading server side data (in this case a lib), we continue as a sync Validator once loaded
-      return new Promise(resolve => {
+      return new Promise((resolve) => {
         PhoneUtilManager.loadComplete.then(() => {
           resolve(hasFeedback(modelValue, regionCode));
         });

package/components/input-tel/test/LionInputTel.test.js

@@ -1,5 +1,7 @@
 import { runInputTelSuite } from '@lion/ui/input-tel-test-suites.js';
 import { LionInputTel } from '@lion/ui/input-tel.js';
-
 runInputTelSuite();
-runInputTelSuite({ klass: LionInputTel, hasParentheses: true });
+runInputTelSuite({
+  klass: LionInputTel,
+  hasParentheses: true,
+});

package/components/input-tel/test/formatters.test.js

@@ -1,30 +1,42 @@
 import { expect } from '@open-wc/testing';
 import { formatPhoneNumber, PhoneUtilManager } from '@lion/ui/input-tel.js';
-
 describe('formatPhoneNumber', () => {
   beforeEach(async () => {
     // Wait till PhoneUtilManager has been loaded
     await PhoneUtilManager.loadComplete;
   });
-
   it('formats a phone number according to provided formatStrategy', () => {
-    expect(formatPhoneNumber('0707123456', { regionCode: 'SE', formatStrategy: 'e164' })).to.equal(
-      '+46707123456',
-    );
     expect(
-      formatPhoneNumber('+46707123456', { regionCode: 'SE', formatStrategy: 'international' }),
+      formatPhoneNumber('0707123456', {
+        regionCode: 'SE',
+        formatStrategy: 'e164',
+      }),
+    ).to.equal('+46707123456');
+    expect(
+      formatPhoneNumber('+46707123456', {
+        regionCode: 'SE',
+        formatStrategy: 'international',
+      }),
     ).to.equal('+46 70 712 34 56');
     expect(
-      formatPhoneNumber('+46707123456', { regionCode: 'SE', formatStrategy: 'national' }),
+      formatPhoneNumber('+46707123456', {
+        regionCode: 'SE',
+        formatStrategy: 'national',
+      }),
     ).to.equal('070-712 34 56');
     expect(
-      formatPhoneNumber('+46707123456', { regionCode: 'SE', formatStrategy: 'rfc3966' }),
+      formatPhoneNumber('+46707123456', {
+        regionCode: 'SE',
+        formatStrategy: 'rfc3966',
+      }),
     ).to.equal('tel:+46-70-712-34-56');
     expect(
-      formatPhoneNumber('+46707123456', { regionCode: 'SE', formatStrategy: 'significant' }),
+      formatPhoneNumber('+46707123456', {
+        regionCode: 'SE',
+        formatStrategy: 'significant',
+      }),
     ).to.equal('707123456');
   });
-
   it('formats a phone number according to provided formatCountryCodeStyle', () => {
     expect(
       formatPhoneNumber('0707123456', {

package/components/input-tel/test/parsers.test.js

@@ -1,24 +1,140 @@
 import { expect } from '@open-wc/testing';
 import { PhoneUtilManager } from '@lion/ui/input-tel.js';
 import { parsePhoneNumber } from '../src/parsers.js';
-
+import { formatPhoneNumber } from '../src/formatters.js';
+import {
+  mockPhoneUtilManager,
+  restorePhoneUtilManager,
+} from '../test-helpers/mockPhoneUtilManager.js';
 describe('parsePhoneNumber', () => {
   beforeEach(async () => {
     // Wait till PhoneUtilManager has been loaded
     await PhoneUtilManager.loadComplete;
   });
-
   it('parses a a view value to e164 standard', () => {
-    expect(parsePhoneNumber('0707123456', { regionCode: 'SE' })).to.equal('+46707123456');
-    expect(parsePhoneNumber('0707123456', { regionCode: 'NL' })).to.equal('+31707123456');
-    expect(parsePhoneNumber('0707123456', { regionCode: 'DE' })).to.equal('+49707123456');
+    expect(
+      parsePhoneNumber('0707123456', {
+        regionCode: 'SE',
+      }),
+    ).to.equal('+46707123456');
+    expect(
+      parsePhoneNumber('0707123456', {
+        regionCode: 'NL',
+      }),
+    ).to.equal('+31707123456');
+    expect(
+      parsePhoneNumber('0707123456', {
+        regionCode: 'DE',
+      }),
+    ).to.equal('+49707123456');
   });
-
   it('removes unwanted characters', () => {
-    expect(parsePhoneNumber('(+31)707123456', { regionCode: 'NL' })).to.equal('+31707123456');
-    expect(parsePhoneNumber('+31 70 7123456', { regionCode: 'NL' })).to.equal('+31707123456');
-    expect(parsePhoneNumber('+31-70-7123456', { regionCode: 'NL' })).to.equal('+31707123456');
-    expect(parsePhoneNumber('+31|70|7123456', { regionCode: 'NL' })).to.equal('+31707123456');
-    expect(parsePhoneNumber('tel:+31707123456', { regionCode: 'NL' })).to.equal('+31707123456');
+    expect(
+      parsePhoneNumber('(+31)707123456', {
+        regionCode: 'NL',
+      }),
+    ).to.equal('+31707123456');
+    expect(
+      parsePhoneNumber('+31 70 7123456', {
+        regionCode: 'NL',
+      }),
+    ).to.equal('+31707123456');
+    expect(
+      parsePhoneNumber('+31-70-7123456', {
+        regionCode: 'NL',
+      }),
+    ).to.equal('+31707123456');
+    expect(
+      parsePhoneNumber('+31|70|7123456', {
+        regionCode: 'NL',
+      }),
+    ).to.equal('+31707123456');
+    expect(
+      parsePhoneNumber('tel:+31707123456', {
+        regionCode: 'NL',
+      }),
+    ).to.equal('+31707123456');
+  });
+  it('keeps parsing enabled after restoring the lazy-loading mock', async () => {
+    const value = '+32 6 12345678';
+    const parsedBeforeMock = parsePhoneNumber(value, {
+      regionCode: 'BE',
+    });
+    const { resolveLoaded } = mockPhoneUtilManager();
+    try {
+      expect(PhoneUtilManager.isLoaded).to.be.false;
+      expect(
+        parsePhoneNumber(value, {
+          regionCode: 'BE',
+        }),
+      ).to.equal(value);
+      resolveLoaded(undefined);
+      await PhoneUtilManager.loadComplete;
+    } finally {
+      restorePhoneUtilManager();
+    }
+    expect(PhoneUtilManager.isLoaded).to.be.true;
+    expect(
+      parsePhoneNumber(value, {
+        regionCode: 'BE',
+      }),
+    ).to.equal(parsedBeforeMock);
+    expect(parsedBeforeMock).to.equal('+32612345678');
+  });
+  it('restores real loaded parsing and formatting without resolving the mock', () => {
+    const viewValue = '+32 6 12345678';
+    const modelValue = '+32612345678';
+    const realLoadComplete = PhoneUtilManager.loadComplete;
+    mockPhoneUtilManager();
+    try {
+      expect(PhoneUtilManager.isLoaded).to.be.false;
+      expect(
+        parsePhoneNumber(viewValue, {
+          regionCode: 'BE',
+        }),
+      ).to.equal(viewValue);
+    } finally {
+      restorePhoneUtilManager();
+    }
+    expect(PhoneUtilManager.loadComplete).to.equal(realLoadComplete);
+    expect(PhoneUtilManager.isLoaded).to.be.true;
+    expect(
+      parsePhoneNumber(viewValue, {
+        regionCode: 'BE',
+      }),
+    ).to.equal(modelValue);
+    expect(
+      formatPhoneNumber(modelValue, {
+        regionCode: 'BE',
+        formatCountryCodeStyle: 'parentheses',
+      }),
+    ).to.equal('(+32)612345678');
+  });
+  it('restores a live getter that tracks the real utility before and after loading', () => {
+    const utility = Object.getOwnPropertyDescriptor(PhoneUtilManager, 'PhoneUtil');
+    if (!utility) {
+      throw new Error('The real phone utility must be loaded for this regression');
+    }
+    const realLoadComplete = PhoneUtilManager.loadComplete;
+    try {
+      Object.defineProperty(PhoneUtilManager, 'PhoneUtil', {
+        ...utility,
+        value: undefined,
+      });
+      mockPhoneUtilManager();
+      restorePhoneUtilManager();
+      expect(PhoneUtilManager.isLoaded).to.be.false;
+      expect(PhoneUtilManager.loadComplete).to.equal(realLoadComplete);
+      Object.defineProperty(PhoneUtilManager, 'PhoneUtil', utility);
+      expect(PhoneUtilManager.isLoaded).to.be.true;
+      expect(
+        parsePhoneNumber('+32 6 12345678', {
+          regionCode: 'BE',
+        }),
+      ).to.equal('+32612345678');
+    } finally {
+      Object.defineProperty(PhoneUtilManager, 'PhoneUtil', utility);
+      restorePhoneUtilManager();
+    }
   });
 });