@superdispatch/phones 0.25.2 → 0.26.1

package/dist-src/phone-service/PhoneService.js

@@ -4,83 +4,68 @@ import { DEFAULT_COUNTRY, getCountryCode, toCountryISO } from "../country-code-m
 var PLUS_SIGN = '+';
 var NON_PHONE_SYMBOLS_PATTERN = /[^+\d]/g;
 var PHONE_PATTERN = /^\+?\d+/g;
-
 function getPrefix(country) {
   return PLUS_SIGN + String(getCountryCode(toCountryISO(country)));
 }
-
 function trim(input) {
   return typeof input == 'string' ? input.trim() : undefined;
 }
-
 function normalize(input) {
   if (typeof input == 'string') {
     var matches = input.replace(NON_PHONE_SYMBOLS_PATTERN, '').match(PHONE_PATTERN);
     if (matches !== null && matches !== void 0 && matches[0]) return matches[0];
   }
-
   return '';
 }
-
 function normalizeNationalNumber(country, input) {
   var phone = normalize(input);
   var prefix = getPrefix(country);
-
   if (phone.startsWith(PLUS_SIGN)) {
     return phone.slice(prefix.length);
   }
-
   return phone;
 }
-
 export class PhoneService {
   static load() {
     return loadAPN().then(APN => new PhoneService(APN));
   }
-
   static checkPossibility(input) {
     return this.load().then(phoneService => phoneService.checkPossibility(input));
   }
-
   static validate(input, rules) {
     return this.load().then(phoneService => phoneService.validate(input, rules));
   }
-
   constructor(APN) {
     this.APN = APN;
   }
-
   createAPN(phone, country) {
     var asYouType = this.APN.getAsYouType(toCountryISO(country));
     asYouType.reset(normalize(phone));
     return asYouType.getPhoneNumber();
   }
-
   getJSON(phone, country) {
-    return this.createAPN(phone, country).toJSON();
+    return this.createAPN(phone, country);
   }
-
   checkPossibility(input) {
     var phone = trim(input);
-
     if (!phone) {
       return 'unknown';
     }
-
-    var apn = phone.startsWith(PLUS_SIGN) ? new this.APN(phone) : new this.APN(phone, DEFAULT_COUNTRY);
+    var apn = phone.startsWith(PLUS_SIGN) ? this.APN.parsePhoneNumber(phone) : this.APN.parsePhoneNumber(phone, {
+      regionCode: DEFAULT_COUNTRY
+    });
     var {
       valid,
       possible,
       possibility
-    } = apn.toJSON(); // Avoid false positive short phone numbers.
+    } = apn;
 
+    // Avoid false positive short phone numbers.
     if (!valid && possible) {
       return 'invalid-number';
     }
-
     return possibility;
   }
-
   validate(input) {
     var {
       required,
@@ -90,40 +75,30 @@ export class PhoneService {
       tooShortMessage = 'Phone number is too short'
     } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var phone = trim(input);
-
     if (!phone) {
       if (required) {
         return requiredMessage;
       }
-
       return undefined;
     }
-
     switch (this.checkPossibility(phone)) {
       case 'is-possible':
         return undefined;
-
       case 'too-long':
         return tooLongMessage;
-
       case 'too-short':
         return tooShortMessage;
     }
-
     return invalidMessage;
   }
-
   deletePrefix(phone, country) {
     var prefix = getPrefix(country);
-
     if (phone.startsWith(PLUS_SIGN)) {
       var subNumber = phone.slice(prefix.length);
       return trim(subNumber);
     }
-
     return phone;
   }
-
   getInfo(phone) {
     var {
       regionCode,
@@ -134,82 +109,70 @@ export class PhoneService {
     } = this.getJSON(phone);
     var nationalNumber = '';
     var country = toCountryISO(regionCode);
-
     if (!internationalNumber) {
       nationalNumber = normalizeNationalNumber(country, input);
     } else {
       nationalNumber = this.deletePrefix(internationalNumber, country);
     }
-
     return {
       country,
       nationalNumber
     };
   }
-
   format(input) {
+    var _apn$number;
     var {
       fallback = '',
       format = 'e164',
       country: countryOption
     } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var phone = normalize(input);
-
     if (!phone) {
       return fallback;
     }
-
-    var apn = this.createAPN(phone, countryOption);
-    var country = countryOption || toCountryISO(apn.getRegionCode());
-    var formatted = format === 'national' ? this.formatNationalNumber(apn, country) : apn.getNumber(format);
-
+    var apn = this.APN.parsePhoneNumber(phone, {
+      regionCode: countryOption
+    });
+    var country = countryOption || toCountryISO(apn.regionCode);
+    var international = (_apn$number = apn.number) === null || _apn$number === void 0 ? void 0 : _apn$number.international;
+    var formattedNumber = apn.number ? apn.number[format] : '';
+    var {
+      regionCode
+    } = apn;
+    var formatted = format === 'national' ? this.formatNationalNumber(country, international) : formattedNumber;
     if (!formatted) {
-      return this.customFormat(apn, phone, format);
+      return this.customFormat(phone, format, regionCode);
     }
-
     return formatted;
   }
-
-  formatNationalNumber(apn, country) {
-    var internationalNumber = apn.getNumber('international');
-
+  formatNationalNumber(country, internationalNumber) {
     if (!internationalNumber) {
       return undefined;
     }
-
     return this.deletePrefix(internationalNumber, country);
   }
-
-  customFormat(apn, phone, format) {
+  customFormat(phone, format, regionCode) {
     var formatted = '';
-    var country = toCountryISO(apn.getRegionCode());
+    var country = toCountryISO(regionCode);
     var nationalNumber = normalizeNationalNumber(country, phone);
-
     if (format === 'national') {
       return nationalNumber;
     }
-
     var prefix = '';
     var separator = '';
-
     if (format === 'rfc3966') {
       prefix = 'tel:';
       separator = '-';
     }
-
     if (format === 'international') {
       separator = ' ';
     }
-
     formatted = prefix + getPrefix(country);
-
     if (nationalNumber) {
       formatted += separator + nationalNumber;
     }
-
     return formatted;
   }
-
 }
 export function usePhoneService() {
   var APN = getAPN();

package/dist-src/phone-text/PhoneText.js

@@ -20,10 +20,9 @@ export function PhoneText(_ref) {
 }
 export function SuspendedPhoneText(_ref2) {
   var {
-    suspenseFallback = null
-  } = _ref2,
-      props = _objectWithoutProperties(_ref2, _excluded);
-
+      suspenseFallback = null
+    } = _ref2,
+    props = _objectWithoutProperties(_ref2, _excluded);
   return /*#__PURE__*/_jsx(Suspense, {
     fallback: suspenseFallback,
     children: /*#__PURE__*/_jsx(PhoneText, _objectSpread({}, props))

package/dist-types/index.d.ts

@@ -1,4 +1,4 @@
-import AwesomePhoneNumber, { PhoneNumber } from 'awesome-phonenumber';
+import { PhoneNumberParseOptions, ParsedPhoneNumber, AsYouType, PhoneNumberTypes } from 'awesome-phonenumber';
 import { ForwardRefExoticComponent, RefAttributes, ReactNode, ReactElement } from 'react';
 import { BaseTextFieldProps, LinkProps } from '@material-ui/core';
 
@@ -11,8 +11,11 @@ declare function toCountryISO(value: unknown): CountryISO;
 declare function getCountryCode(country: CountryISO): number;
 declare function formatCountry(country: CountryISO): string;
 
-declare type APNType = AwesomePhoneNumber;
-declare type APNStatic = typeof AwesomePhoneNumber;
+interface APNStatic {
+    parsePhoneNumber: (input: string, options?: PhoneNumberParseOptions) => ParsedPhoneNumber;
+    getAsYouType: (regionCode: string) => AsYouType;
+    getExample: (regionCode: string, type?: PhoneNumberTypes) => ParsedPhoneNumber;
+}
 
 declare type PhoneNumberPossibility = 'is-possible' | 'invalid-country-code' | 'invalid-number' | 'too-long' | 'too-short' | 'unknown';
 interface PhoneNumberJSON {
@@ -23,6 +26,7 @@ interface PhoneNumberJSON {
     number: {
         input: string;
         international?: string;
+        national?: string;
     };
 }
 interface PhoneNumberInfo {
@@ -46,16 +50,16 @@ declare class PhoneService {
     static load(): Promise<PhoneService>;
     static checkPossibility(input: unknown): Promise<PhoneNumberPossibility>;
     static validate(input: unknown, rules?: PhoneValidationRules): Promise<string | undefined>;
-    readonly APN: typeof PhoneNumber;
+    readonly APN: APNStatic;
     constructor(APN: APNStatic);
-    createAPN(phone: string, country?: CountryISO): APNType;
+    createAPN(phone: string, country?: CountryISO): ParsedPhoneNumber;
     getJSON(phone: string, country?: CountryISO): PhoneNumberJSON;
     checkPossibility(input: unknown): PhoneNumberPossibility;
     validate(input: unknown, { required, requiredMessage, invalidMessage, tooLongMessage, tooShortMessage, }?: PhoneValidationRules): string | undefined;
     deletePrefix(phone: string, country: CountryISO): string;
     getInfo(phone: string): PhoneNumberInfo;
     format(input: unknown, { fallback, format, country: countryOption, }?: PhoneFormatOptions): string;
-    formatNationalNumber(apn: APNType, country: CountryISO): string | undefined;
+    formatNationalNumber(country: CountryISO, internationalNumber?: string): string | undefined;
     private customFormat;
 }
 declare function usePhoneService(): PhoneService;