libphonenumber-js
Version:
A simpler (and smaller) rewrite of Google Android's libphonenumber library in javascript
207 lines (201 loc) • 10.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
var _metadata = _interopRequireWildcard(require("./metadata.js"));
var _isPossible = _interopRequireDefault(require("./isPossible.js"));
var _isValid = _interopRequireDefault(require("./isValid.js"));
var _getNumberType = _interopRequireDefault(require("./helpers/getNumberType.js"));
var _getPossibleCountriesForNumber = _interopRequireDefault(require("./helpers/getPossibleCountriesForNumber.js"));
var _extractCountryCallingCode = _interopRequireDefault(require("./helpers/extractCountryCallingCode.js"));
var _isObject = _interopRequireDefault(require("./helpers/isObject.js"));
var _format2 = _interopRequireDefault(require("./format.js"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // import checkNumberLength from './helpers/checkNumberLength.js'
var USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;
var PhoneNumber = exports["default"] = /*#__PURE__*/function () {
/**
* @param {string} countryOrCountryCallingCode
* @param {string} nationalNumber
* @param {object} metadata — Metadata JSON
* @return {PhoneNumber}
*/
function PhoneNumber(countryOrCountryCallingCode, nationalNumber, metadata) {
_classCallCheck(this, PhoneNumber);
// Validate `countryOrCountryCallingCode` argument.
if (!countryOrCountryCallingCode) {
throw new TypeError('First argument is required');
}
if (typeof countryOrCountryCallingCode !== 'string') {
throw new TypeError('First argument must be a string');
}
// In case of public API use: `constructor(number, metadata)`.
// Transform the arguments from `constructor(number, metadata)` to
// `constructor(countryOrCountryCallingCode, nationalNumber, metadata)`.
if (countryOrCountryCallingCode[0] === '+' && !nationalNumber) {
throw new TypeError('`metadata` argument not passed');
}
if ((0, _isObject["default"])(nationalNumber) && (0, _isObject["default"])(nationalNumber.countries)) {
metadata = nationalNumber;
var e164Number = countryOrCountryCallingCode;
if (!E164_NUMBER_REGEXP.test(e164Number)) {
throw new Error('Invalid `number` argument passed: must consist of a "+" followed by digits');
}
var _extractCountryCallin = (0, _extractCountryCallingCode["default"])(e164Number, undefined, undefined, metadata),
_countryCallingCode = _extractCountryCallin.countryCallingCode,
number = _extractCountryCallin.number;
nationalNumber = number;
countryOrCountryCallingCode = _countryCallingCode;
if (!nationalNumber) {
throw new Error('Invalid `number` argument passed: too short');
}
}
// Validate `nationalNumber` argument.
if (!nationalNumber) {
throw new TypeError('`nationalNumber` argument is required');
}
if (typeof nationalNumber !== 'string') {
throw new TypeError('`nationalNumber` argument must be a string');
}
// Validate `metadata` argument.
(0, _metadata.validateMetadata)(metadata);
// Initialize properties.
var _getCountryAndCountry = getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadata),
country = _getCountryAndCountry.country,
countryCallingCode = _getCountryAndCountry.countryCallingCode;
this.country = country;
this.countryCallingCode = countryCallingCode;
this.nationalNumber = nationalNumber;
this.number = '+' + this.countryCallingCode + this.nationalNumber;
// Exclude `metadata` property output from `PhoneNumber.toString()`
// so that it doesn't clutter the console output of Node.js.
// Previously, when Node.js did `console.log(new PhoneNumber(...))`,
// it would output the whole internal structure of the `metadata` object.
this.getMetadata = function () {
return metadata;
};
}
return _createClass(PhoneNumber, [{
key: "setExt",
value: function setExt(ext) {
this.ext = ext;
}
}, {
key: "getPossibleCountries",
value: function getPossibleCountries() {
if (this.country) {
return [this.country];
}
return (0, _getPossibleCountriesForNumber["default"])(this.countryCallingCode, this.nationalNumber, this.getMetadata());
}
}, {
key: "isPossible",
value: function isPossible() {
return (0, _isPossible["default"])(this, {
v2: true
}, this.getMetadata());
}
}, {
key: "isValid",
value: function isValid() {
return (0, _isValid["default"])(this, {
v2: true
}, this.getMetadata());
}
}, {
key: "isNonGeographic",
value: function isNonGeographic() {
var metadata = new _metadata["default"](this.getMetadata());
return metadata.isNonGeographicCallingCode(this.countryCallingCode);
}
}, {
key: "isEqual",
value: function isEqual(phoneNumber) {
return this.number === phoneNumber.number && this.ext === phoneNumber.ext;
}
// This function was originally meant to be an equivalent for `validatePhoneNumberLength()`,
// but later it was found out that it doesn't include the possible `TOO_SHORT` result
// returned from `parsePhoneNumberWithError()` in the original `validatePhoneNumberLength()`,
// so eventually I simply commented out this method from the `PhoneNumber` class
// and just left the `validatePhoneNumberLength()` function, even though that one would require
// and additional step to also validate the actual country / calling code of the phone number.
// validateLength() {
// const metadata = new Metadata(this.getMetadata())
// metadata.selectNumberingPlan(this.countryCallingCode)
// const result = checkNumberLength(this.nationalNumber, metadata)
// if (result !== 'IS_POSSIBLE') {
// return result
// }
// }
}, {
key: "getType",
value: function getType() {
return (0, _getNumberType["default"])(this, {
v2: true
}, this.getMetadata());
}
}, {
key: "format",
value: function format(_format, options) {
return (0, _format2["default"])(this, _format, options ? _objectSpread(_objectSpread({}, options), {}, {
v2: true
}) : {
v2: true
}, this.getMetadata());
}
}, {
key: "formatNational",
value: function formatNational(options) {
return this.format('NATIONAL', options);
}
}, {
key: "formatInternational",
value: function formatInternational(options) {
return this.format('INTERNATIONAL', options);
}
}, {
key: "getURI",
value: function getURI(options) {
return this.format('RFC3966', options);
}
}]);
}();
var isCountryCode = function isCountryCode(value) {
return /^[A-Z]{2}$/.test(value);
};
function getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadataJson) {
var country;
var countryCallingCode;
var metadata = new _metadata["default"](metadataJson);
// If country code is passed then derive `countryCallingCode` from it.
// Also store the country code as `.country`.
if (isCountryCode(countryOrCountryCallingCode)) {
country = countryOrCountryCallingCode;
metadata.selectNumberingPlan(country);
countryCallingCode = metadata.countryCallingCode();
} else {
countryCallingCode = countryOrCountryCallingCode;
/* istanbul ignore if */
if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {
if (metadata.isNonGeographicCallingCode(countryCallingCode)) {
country = '001';
}
}
}
return {
country: country,
countryCallingCode: countryCallingCode
};
}
var E164_NUMBER_REGEXP = /^\+\d+$/;
//# sourceMappingURL=PhoneNumber.js.map