@webority-technologies/mobile-core 0.0.2 → 0.0.4

package/lib/commonjs/formatters/index.js

@@ -69,12 +69,30 @@ Object.defineProperty(exports, "getInitials", {
     return _initials.getInitials;
   }
 });
+Object.defineProperty(exports, "isValidPhoneNumber", {
+  enumerable: true,
+  get: function () {
+    return _phone.isValidPhoneNumber;
+  }
+});
 Object.defineProperty(exports, "normalizePhone", {
   enumerable: true,
   get: function () {
     return _phone.normalizePhone;
   }
 });
+Object.defineProperty(exports, "parsePhoneNumber", {
+  enumerable: true,
+  get: function () {
+    return _phone.parsePhoneNumber;
+  }
+});
+Object.defineProperty(exports, "parsePhoneNumberFromString", {
+  enumerable: true,
+  get: function () {
+    return _phone.parsePhoneNumberFromString;
+  }
+});
 var _currency = require("./currency.js");
 var _date = require("./date.js");
 var _initials = require("./initials.js");

package/lib/commonjs/formatters/phone.js

@@ -5,7 +5,42 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.detectPhoneCountry = void 0;
 exports.formatPhone = formatPhone;
+Object.defineProperty(exports, "isValidPhoneNumber", {
+  enumerable: true,
+  get: function () {
+    return _max.isValidPhoneNumber;
+  }
+});
 exports.normalizePhone = void 0;
+Object.defineProperty(exports, "parsePhoneNumber", {
+  enumerable: true,
+  get: function () {
+    return _max.parsePhoneNumber;
+  }
+});
+Object.defineProperty(exports, "parsePhoneNumberFromString", {
+  enumerable: true,
+  get: function () {
+    return _max.parsePhoneNumberFromString;
+  }
+});
+var _max = require("libphonenumber-js/max");
+/**
+ * The bare 'libphonenumber-js' entry point actually resolves to the library's
+ * OWN slimmed-down min/ metadata internally, not its full data - './max' is
+ * the variant with complete per-country metadata. Since the reason this
+ * module exists is validation and formatting accuracy, the more accurate
+ * variant wins throughout this file, not just for validation.
+ */
+
+/**
+ * Re-exported under our own name rather than importing CountryCode directly
+ * everywhere, so a future need to diverge (or re-narrow) has one place to do
+ * it. Every ISO 3166-1 alpha-2 code libphonenumber-js recognises - formatPhone
+ * and detectPhoneCountry below are genuinely correct for all of them, not a
+ * curated subset.
+ */
+
 /**
  * Strip everything except digits and a leading `+` (preserved if present).
  */
@@ -18,82 +53,32 @@ const normalizePhone = input => {
   const digits = trimmed.replace(/\D/g, '');
   return hasPlus ? `+${digits}` : digits;
 };
-exports.normalizePhone = normalizePhone;
-const groupIndianMobile = digits => {
-  // Indian mobile is 10 digits: format as `XXXXX XXXXX`.
-  if (digits.length !== 10) {
-    return digits;
-  }
-  return `${digits.slice(0, 5)} ${digits.slice(5)}`;
-};
-
-// Longest calling code first so a 3-digit code is never shadowed by a shorter one.
-const COUNTRY_RULES = [{
-  country: 'AE',
-  callingCode: '971',
-  nationalLength: 9,
-  group: n => `${n.slice(0, 2)} ${n.slice(2, 5)} ${n.slice(5)}`
-}, {
-  country: 'IN',
-  callingCode: '91',
-  nationalLength: 10,
-  group: groupIndianMobile
-}, {
-  country: 'GB',
-  callingCode: '44',
-  nationalLength: 10,
-  group: n => `${n.slice(0, 4)} ${n.slice(4, 7)} ${n.slice(7)}`
-}, {
-  country: 'AU',
-  callingCode: '61',
-  nationalLength: 9,
-  group: n => `${n.slice(0, 3)} ${n.slice(3, 6)} ${n.slice(6)}`
-}, {
-  country: 'SG',
-  callingCode: '65',
-  nationalLength: 8,
-  group: n => `${n.slice(0, 4)} ${n.slice(4)}`
-}, {
-  country: 'US',
-  callingCode: '1',
-  nationalLength: 10,
-  group: n => `(${n.slice(0, 3)}) ${n.slice(3, 6)}-${n.slice(6)}`
-},
-// US and CA share a calling code and are indistinguishable from it alone;
-// this row only serves an explicit `country: 'CA'` override, never detection
-// (it sits after the US row, and findRuleByCallingCode returns the first match).
-{
-  country: 'CA',
-  callingCode: '1',
-  nationalLength: 10,
-  group: n => `(${n.slice(0, 3)}) ${n.slice(3, 6)}-${n.slice(6)}`
-}];
-const findRuleByCallingCode = rest => COUNTRY_RULES.find(rule => rest.startsWith(rule.callingCode));
-const findRuleByCountry = country => COUNTRY_RULES.find(rule => rule.country === country);
 
 /**
  * Detect the country of a phone number: from its own `+` country code when
  * present, otherwise from `defaultCountryCode`. Returns null when neither
- * carries a recognised calling code.
+ * parses to a recognised country.
  */
+exports.normalizePhone = normalizePhone;
 const detectPhoneCountry = (input, defaultCountryCode = '+91') => {
   const normalized = normalizePhone(input);
   if (!normalized) {
     return null;
   }
   if (normalized.startsWith('+')) {
-    return findRuleByCallingCode(normalized.slice(1))?.country ?? null;
+    return (0, _max.parsePhoneNumberFromString)(normalized)?.country ?? null;
   }
   const normalizedDefault = normalizePhone(defaultCountryCode);
   if (!normalizedDefault.startsWith('+')) {
     return null;
   }
-  return findRuleByCallingCode(normalizedDefault.slice(1))?.country ?? null;
+  return (0, _max.parsePhoneNumberFromString)(normalizedDefault + normalized)?.country ?? null;
 };
 exports.detectPhoneCountry = detectPhoneCountry;
 const bestEffortGroup = rest => {
-  // No known country code matched (or matched but the wrong length): split
-  // the country code (first 1-3 digits) and group the rest in 4s.
+  // Not a parseable number at all (garbage input, or a real number that's an
+  // unsupported length for its country): split the country code (first 1-3
+  // digits) and group the rest in 4s, rather than returning nothing.
   const ccLen = rest.length > 11 ? 3 : rest.length > 10 ? 2 : 1;
   const cc = rest.slice(0, ccLen);
   const number = rest.slice(ccLen);
@@ -102,13 +87,18 @@ const bestEffortGroup = rest => {
 };
 
 /**
- * Format a phone number for human display.
+ * Format a phone number for human display, via libphonenumber-js's own
+ * per-country formatting rather than a hand-rolled grouping table - correct
+ * for every country it recognises, not a curated subset.
  *
- * - Indian mobile (10 digits) → `XXXXX XXXXX`
- * - With `+91` country code → `+91 XXXXX XXXXX`
- * - A number that already carries a recognised country code is grouped for
- *   that country regardless of `defaultCountryCode`.
- * - Other inputs are returned as `+CC NNNN NNNN…` best-effort grouping.
+ * - A number that already carries a `+` country code formats for that country.
+ * - A bare national number formats for `options.country` when given, else for
+ *   the country implied by `defaultCountryCode` (default `+91`).
+ * - `includeCountryCode` controls international vs national format; defaults
+ *   to international whenever the country was detected rather than passed in
+ *   explicitly as `options.country`, and to national when it was.
+ * - Input libphonenumber-js can't parse into a valid number for the resolved
+ *   country falls back to a best-effort `+CC NNNN NNNN…` digit grouping.
  */
 
 function formatPhone(input, arg) {
@@ -121,35 +111,40 @@ function formatPhone(input, arg) {
   }
   const options = typeof arg === 'string' ? {} : arg ?? {};
   const defaultCountryCode = typeof arg === 'string' ? arg : options.defaultCountryCode ?? '+91';
-  if (normalized.startsWith('+')) {
-    const rest = normalized.slice(1);
-    const detectedRule = findRuleByCallingCode(rest);
-    const activeRule = options.country ? findRuleByCountry(options.country) : detectedRule;
-    if (activeRule) {
-      const national = detectedRule ? rest.slice(detectedRule.callingCode.length) : rest;
-      if (national.length === activeRule.nationalLength) {
-        const includeCc = options.includeCountryCode ?? true;
-        const body = activeRule.group(national);
-        return includeCc ? `+${activeRule.callingCode} ${body}` : body;
-      }
-    }
-    return bestEffortGroup(rest);
-  }
+  const hasOwnCountryCode = normalized.startsWith('+');
+  let parsed;
+  // What to best-effort group if parsing fails to produce a valid number.
+  // Defaults to the plain input; the defaultCountryCode branch below points
+  // it at the combined digits instead, so a bare number that turns out
+  // invalid for its detected country still shows that country's code rather
+  // than silently discarding it.
+  let fallbackRest = normalized;
   if (options.country) {
-    const rule = findRuleByCountry(options.country);
-    if (rule && normalized.length === rule.nationalLength) {
-      const includeCc = options.includeCountryCode ?? false;
-      const body = rule.group(normalized);
-      return includeCc ? `+${rule.callingCode} ${body}` : body;
+    // parsePhoneNumberFromString ignores this hint when normalized already
+    // carries its own +, so a real E.164 number is never overridden by a
+    // wrong or stale options.country.
+    parsed = (0, _max.parsePhoneNumberFromString)(normalized, options.country);
+  } else if (hasOwnCountryCode) {
+    parsed = (0, _max.parsePhoneNumberFromString)(normalized);
+  } else {
+    const normalizedDefault = normalizePhone(defaultCountryCode);
+    if (normalizedDefault.startsWith('+')) {
+      const combined = normalizedDefault + normalized;
+      parsed = (0, _max.parsePhoneNumberFromString)(combined);
+      fallbackRest = combined;
+    } else {
+      parsed = undefined;
     }
-    return normalized.replace(/(.{4})(?=.)/g, '$1 ').trim();
   }
 
-  // No country code; assume default if length matches Indian mobile.
-  if (normalized.length === 10) {
-    return `${defaultCountryCode} ${groupIndianMobile(normalized)}`;
+  // International by default whenever the country came from the number
+  // itself (or from defaultCountryCode); national by default only when a
+  // bare number relied on an explicit options.country to resolve at all.
+  const includeCcDefault = hasOwnCountryCode || !options.country;
+  if (parsed?.isValid()) {
+    const includeCc = options.includeCountryCode ?? includeCcDefault;
+    return includeCc ? parsed.formatInternational() : parsed.formatNational();
   }
-  // Otherwise just return groups of 4.
-  return normalized.replace(/(.{4})(?=.)/g, '$1 ').trim();
+  return fallbackRest.startsWith('+') ? bestEffortGroup(fallbackRest.slice(1)) : fallbackRest.replace(/(.{4})(?=.)/g, '$1 ').trim();
 }
 //# sourceMappingURL=phone.js.map

package/lib/commonjs/index.js

@@ -321,6 +321,12 @@ Object.defineProperty(exports, "isUrl", {
     return _index7.isUrl;
   }
 });
+Object.defineProperty(exports, "isValidPhoneNumber", {
+  enumerable: true,
+  get: function () {
+    return _index3.isValidPhoneNumber;
+  }
+});
 Object.defineProperty(exports, "logCurl", {
   enumerable: true,
   get: function () {
@@ -351,6 +357,18 @@ Object.defineProperty(exports, "parseDeepLink", {
     return _index2.parseDeepLink;
   }
 });
+Object.defineProperty(exports, "parsePhoneNumber", {
+  enumerable: true,
+  get: function () {
+    return _index3.parsePhoneNumber;
+  }
+});
+Object.defineProperty(exports, "parsePhoneNumberFromString", {
+  enumerable: true,
+  get: function () {
+    return _index3.parsePhoneNumberFromString;
+  }
+});
 Object.defineProperty(exports, "publicClient", {
   enumerable: true,
   get: function () {

package/lib/commonjs/storage/index.js

@@ -196,7 +196,7 @@ const getAllKeys = async () => {
  * All operations swallow errors (logging them) and return a falsy result
  * so that storage problems never crash the app.
  *
- * Backed by `@react-native-async-storage/async-storage` by default;
+ * Backed by `expo-sqlite/kv-store` by default;
  * override with `setStorageImplementation()` for MMKV or custom adapters.
  */
 const Storage = exports.Storage = {

package/lib/module/formatters/index.js

@@ -4,5 +4,5 @@ export { formatCurrency } from "./currency.js";
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from "./date.js";
 export { getInitials } from "./initials.js";
 export { formatCompactNumber, formatNumber, formatPercent } from "./number.js";
-export { detectPhoneCountry, formatPhone, normalizePhone } from "./phone.js";
+export { detectPhoneCountry, formatPhone, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from "./phone.js";
 //# sourceMappingURL=index.js.map

package/lib/module/formatters/phone.js

@@ -1,5 +1,23 @@
 "use strict";
 
+/**
+ * The bare 'libphonenumber-js' entry point actually resolves to the library's
+ * OWN slimmed-down min/ metadata internally, not its full data - './max' is
+ * the variant with complete per-country metadata. Since the reason this
+ * module exists is validation and formatting accuracy, the more accurate
+ * variant wins throughout this file, not just for validation.
+ */
+import { parsePhoneNumberFromString } from 'libphonenumber-js/max';
+export { isValidPhoneNumber, parsePhoneNumber, parsePhoneNumberFromString } from 'libphonenumber-js/max';
+
+/**
+ * Re-exported under our own name rather than importing CountryCode directly
+ * everywhere, so a future need to diverge (or re-narrow) has one place to do
+ * it. Every ISO 3166-1 alpha-2 code libphonenumber-js recognises - formatPhone
+ * and detectPhoneCountry below are genuinely correct for all of them, not a
+ * curated subset.
+ */
+
 /**
  * Strip everything except digits and a leading `+` (preserved if present).
  */
@@ -12,62 +30,11 @@ export const normalizePhone = input => {
   const digits = trimmed.replace(/\D/g, '');
   return hasPlus ? `+${digits}` : digits;
 };
-const groupIndianMobile = digits => {
-  // Indian mobile is 10 digits: format as `XXXXX XXXXX`.
-  if (digits.length !== 10) {
-    return digits;
-  }
-  return `${digits.slice(0, 5)} ${digits.slice(5)}`;
-};
-
-// Longest calling code first so a 3-digit code is never shadowed by a shorter one.
-const COUNTRY_RULES = [{
-  country: 'AE',
-  callingCode: '971',
-  nationalLength: 9,
-  group: n => `${n.slice(0, 2)} ${n.slice(2, 5)} ${n.slice(5)}`
-}, {
-  country: 'IN',
-  callingCode: '91',
-  nationalLength: 10,
-  group: groupIndianMobile
-}, {
-  country: 'GB',
-  callingCode: '44',
-  nationalLength: 10,
-  group: n => `${n.slice(0, 4)} ${n.slice(4, 7)} ${n.slice(7)}`
-}, {
-  country: 'AU',
-  callingCode: '61',
-  nationalLength: 9,
-  group: n => `${n.slice(0, 3)} ${n.slice(3, 6)} ${n.slice(6)}`
-}, {
-  country: 'SG',
-  callingCode: '65',
-  nationalLength: 8,
-  group: n => `${n.slice(0, 4)} ${n.slice(4)}`
-}, {
-  country: 'US',
-  callingCode: '1',
-  nationalLength: 10,
-  group: n => `(${n.slice(0, 3)}) ${n.slice(3, 6)}-${n.slice(6)}`
-},
-// US and CA share a calling code and are indistinguishable from it alone;
-// this row only serves an explicit `country: 'CA'` override, never detection
-// (it sits after the US row, and findRuleByCallingCode returns the first match).
-{
-  country: 'CA',
-  callingCode: '1',
-  nationalLength: 10,
-  group: n => `(${n.slice(0, 3)}) ${n.slice(3, 6)}-${n.slice(6)}`
-}];
-const findRuleByCallingCode = rest => COUNTRY_RULES.find(rule => rest.startsWith(rule.callingCode));
-const findRuleByCountry = country => COUNTRY_RULES.find(rule => rule.country === country);
 
 /**
  * Detect the country of a phone number: from its own `+` country code when
  * present, otherwise from `defaultCountryCode`. Returns null when neither
- * carries a recognised calling code.
+ * parses to a recognised country.
  */
 export const detectPhoneCountry = (input, defaultCountryCode = '+91') => {
   const normalized = normalizePhone(input);
@@ -75,17 +42,18 @@ export const detectPhoneCountry = (input, defaultCountryCode = '+91') => {
     return null;
   }
   if (normalized.startsWith('+')) {
-    return findRuleByCallingCode(normalized.slice(1))?.country ?? null;
+    return parsePhoneNumberFromString(normalized)?.country ?? null;
   }
   const normalizedDefault = normalizePhone(defaultCountryCode);
   if (!normalizedDefault.startsWith('+')) {
     return null;
   }
-  return findRuleByCallingCode(normalizedDefault.slice(1))?.country ?? null;
+  return parsePhoneNumberFromString(normalizedDefault + normalized)?.country ?? null;
 };
 const bestEffortGroup = rest => {
-  // No known country code matched (or matched but the wrong length): split
-  // the country code (first 1-3 digits) and group the rest in 4s.
+  // Not a parseable number at all (garbage input, or a real number that's an
+  // unsupported length for its country): split the country code (first 1-3
+  // digits) and group the rest in 4s, rather than returning nothing.
   const ccLen = rest.length > 11 ? 3 : rest.length > 10 ? 2 : 1;
   const cc = rest.slice(0, ccLen);
   const number = rest.slice(ccLen);
@@ -94,13 +62,18 @@ const bestEffortGroup = rest => {
 };
 
 /**
- * Format a phone number for human display.
+ * Format a phone number for human display, via libphonenumber-js's own
+ * per-country formatting rather than a hand-rolled grouping table - correct
+ * for every country it recognises, not a curated subset.
  *
- * - Indian mobile (10 digits) → `XXXXX XXXXX`
- * - With `+91` country code → `+91 XXXXX XXXXX`
- * - A number that already carries a recognised country code is grouped for
- *   that country regardless of `defaultCountryCode`.
- * - Other inputs are returned as `+CC NNNN NNNN…` best-effort grouping.
+ * - A number that already carries a `+` country code formats for that country.
+ * - A bare national number formats for `options.country` when given, else for
+ *   the country implied by `defaultCountryCode` (default `+91`).
+ * - `includeCountryCode` controls international vs national format; defaults
+ *   to international whenever the country was detected rather than passed in
+ *   explicitly as `options.country`, and to national when it was.
+ * - Input libphonenumber-js can't parse into a valid number for the resolved
+ *   country falls back to a best-effort `+CC NNNN NNNN…` digit grouping.
  */
 
 export function formatPhone(input, arg) {
@@ -113,35 +86,40 @@ export function formatPhone(input, arg) {
   }
   const options = typeof arg === 'string' ? {} : arg ?? {};
   const defaultCountryCode = typeof arg === 'string' ? arg : options.defaultCountryCode ?? '+91';
-  if (normalized.startsWith('+')) {
-    const rest = normalized.slice(1);
-    const detectedRule = findRuleByCallingCode(rest);
-    const activeRule = options.country ? findRuleByCountry(options.country) : detectedRule;
-    if (activeRule) {
-      const national = detectedRule ? rest.slice(detectedRule.callingCode.length) : rest;
-      if (national.length === activeRule.nationalLength) {
-        const includeCc = options.includeCountryCode ?? true;
-        const body = activeRule.group(national);
-        return includeCc ? `+${activeRule.callingCode} ${body}` : body;
-      }
-    }
-    return bestEffortGroup(rest);
-  }
+  const hasOwnCountryCode = normalized.startsWith('+');
+  let parsed;
+  // What to best-effort group if parsing fails to produce a valid number.
+  // Defaults to the plain input; the defaultCountryCode branch below points
+  // it at the combined digits instead, so a bare number that turns out
+  // invalid for its detected country still shows that country's code rather
+  // than silently discarding it.
+  let fallbackRest = normalized;
   if (options.country) {
-    const rule = findRuleByCountry(options.country);
-    if (rule && normalized.length === rule.nationalLength) {
-      const includeCc = options.includeCountryCode ?? false;
-      const body = rule.group(normalized);
-      return includeCc ? `+${rule.callingCode} ${body}` : body;
+    // parsePhoneNumberFromString ignores this hint when normalized already
+    // carries its own +, so a real E.164 number is never overridden by a
+    // wrong or stale options.country.
+    parsed = parsePhoneNumberFromString(normalized, options.country);
+  } else if (hasOwnCountryCode) {
+    parsed = parsePhoneNumberFromString(normalized);
+  } else {
+    const normalizedDefault = normalizePhone(defaultCountryCode);
+    if (normalizedDefault.startsWith('+')) {
+      const combined = normalizedDefault + normalized;
+      parsed = parsePhoneNumberFromString(combined);
+      fallbackRest = combined;
+    } else {
+      parsed = undefined;
     }
-    return normalized.replace(/(.{4})(?=.)/g, '$1 ').trim();
   }
 
-  // No country code; assume default if length matches Indian mobile.
-  if (normalized.length === 10) {
-    return `${defaultCountryCode} ${groupIndianMobile(normalized)}`;
+  // International by default whenever the country came from the number
+  // itself (or from defaultCountryCode); national by default only when a
+  // bare number relied on an explicit options.country to resolve at all.
+  const includeCcDefault = hasOwnCountryCode || !options.country;
+  if (parsed?.isValid()) {
+    const includeCc = options.includeCountryCode ?? includeCcDefault;
+    return includeCc ? parsed.formatInternational() : parsed.formatNational();
   }
-  // Otherwise just return groups of 4.
-  return normalized.replace(/(.{4})(?=.)/g, '$1 ').trim();
+  return fallbackRest.startsWith('+') ? bestEffortGroup(fallbackRest.slice(1)) : fallbackRest.replace(/(.{4})(?=.)/g, '$1 ').trim();
 }
 //# sourceMappingURL=phone.js.map

package/lib/module/index.js

@@ -29,7 +29,7 @@ export { getConfig, getConfigValue, resetConfig, setConfig } from "./config/inde
 // Deep links
 export { DeepLink, parseDeepLink, useDeepLink } from "./deepLink/index.js";
 // Formatters
-export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, normalizePhone } from "./formatters/index.js";
+export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from "./formatters/index.js";
 // Initialization
 export { initWebority } from "./initSDK.js";
 export { initUserAuth } from "./initUserAuth.js";

package/lib/module/storage/index.js

@@ -190,7 +190,7 @@ const getAllKeys = async () => {
  * All operations swallow errors (logging them) and return a falsy result
  * so that storage problems never crash the app.
  *
- * Backed by `@react-native-async-storage/async-storage` by default;
+ * Backed by `expo-sqlite/kv-store` by default;
  * override with `setStorageImplementation()` for MMKV or custom adapters.
  */
 export const Storage = {

package/lib/typescript/commonjs/formatters/index.d.ts

@@ -4,6 +4,6 @@ export type { DateInput, DateStyle, TimeStyle } from './date';
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date';
 export { getInitials } from './initials';
 export { formatCompactNumber, formatNumber, formatPercent } from './number';
-export type { FormatPhoneOptions, PhoneCountry } from './phone';
-export { detectPhoneCountry, formatPhone, normalizePhone } from './phone';
+export type { FormatPhoneOptions, PhoneCountry, PhoneNumber } from './phone';
+export { detectPhoneCountry, formatPhone, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from './phone';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/formatters/phone.d.ts

@@ -1,4 +1,21 @@
-export type PhoneCountry = 'IN' | 'US' | 'GB' | 'AE' | 'AU' | 'SG' | 'CA';
+/**
+ * The bare 'libphonenumber-js' entry point actually resolves to the library's
+ * OWN slimmed-down min/ metadata internally, not its full data - './max' is
+ * the variant with complete per-country metadata. Since the reason this
+ * module exists is validation and formatting accuracy, the more accurate
+ * variant wins throughout this file, not just for validation.
+ */
+import { type CountryCode } from 'libphonenumber-js/max';
+export type { PhoneNumber } from 'libphonenumber-js/max';
+export { isValidPhoneNumber, parsePhoneNumber, parsePhoneNumberFromString } from 'libphonenumber-js/max';
+/**
+ * Re-exported under our own name rather than importing CountryCode directly
+ * everywhere, so a future need to diverge (or re-narrow) has one place to do
+ * it. Every ISO 3166-1 alpha-2 code libphonenumber-js recognises - formatPhone
+ * and detectPhoneCountry below are genuinely correct for all of them, not a
+ * curated subset.
+ */
+export type PhoneCountry = CountryCode;
 export interface FormatPhoneOptions {
     defaultCountryCode?: string;
     country?: PhoneCountry;
@@ -11,17 +28,22 @@ export declare const normalizePhone: (input: string) => string;
 /**
  * Detect the country of a phone number: from its own `+` country code when
  * present, otherwise from `defaultCountryCode`. Returns null when neither
- * carries a recognised calling code.
+ * parses to a recognised country.
  */
 export declare const detectPhoneCountry: (input: string, defaultCountryCode?: string) => PhoneCountry | null;
 /**
- * Format a phone number for human display.
+ * Format a phone number for human display, via libphonenumber-js's own
+ * per-country formatting rather than a hand-rolled grouping table - correct
+ * for every country it recognises, not a curated subset.
  *
- * - Indian mobile (10 digits) → `XXXXX XXXXX`
- * - With `+91` country code → `+91 XXXXX XXXXX`
- * - A number that already carries a recognised country code is grouped for
- *   that country regardless of `defaultCountryCode`.
- * - Other inputs are returned as `+CC NNNN NNNN…` best-effort grouping.
+ * - A number that already carries a `+` country code formats for that country.
+ * - A bare national number formats for `options.country` when given, else for
+ *   the country implied by `defaultCountryCode` (default `+91`).
+ * - `includeCountryCode` controls international vs national format; defaults
+ *   to international whenever the country was detected rather than passed in
+ *   explicitly as `options.country`, and to national when it was.
+ * - Input libphonenumber-js can't parse into a valid number for the resolved
+ *   country falls back to a best-effort `+CC NNNN NNNN…` digit grouping.
  */
 export declare function formatPhone(input: string, defaultCountryCode?: string): string;
 export declare function formatPhone(input: string, options?: FormatPhoneOptions): string;

package/lib/typescript/commonjs/index.d.ts

@@ -28,8 +28,8 @@ export type { Config, Environment, LogLevel } from './config';
 export { getConfig, getConfigValue, resetConfig, setConfig } from './config';
 export type { DeepLinkConfig, DeepLinkRoute, ParsedLink } from './deepLink';
 export { DeepLink, parseDeepLink, useDeepLink } from './deepLink';
-export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, TimeStyle } from './formatters';
-export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, normalizePhone } from './formatters';
+export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, PhoneNumber, TimeStyle } from './formatters';
+export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from './formatters';
 export type { InitConfig } from './initSDK';
 export { initWebority } from './initSDK';
 export type { AuthActions } from './initUserAuth';

package/lib/typescript/commonjs/storage/index.d.ts

@@ -56,7 +56,7 @@ export interface StorageApi {
  * All operations swallow errors (logging them) and return a falsy result
  * so that storage problems never crash the app.
  *
- * Backed by `@react-native-async-storage/async-storage` by default;
+ * Backed by `expo-sqlite/kv-store` by default;
  * override with `setStorageImplementation()` for MMKV or custom adapters.
  */
 export declare const Storage: StorageApi;

package/lib/typescript/module/formatters/index.d.ts

@@ -4,6 +4,6 @@ export type { DateInput, DateStyle, TimeStyle } from './date.js';
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date.js';
 export { getInitials } from './initials.js';
 export { formatCompactNumber, formatNumber, formatPercent } from './number.js';
-export type { FormatPhoneOptions, PhoneCountry } from './phone.js';
-export { detectPhoneCountry, formatPhone, normalizePhone } from './phone.js';
+export type { FormatPhoneOptions, PhoneCountry, PhoneNumber } from './phone.js';
+export { detectPhoneCountry, formatPhone, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from './phone.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/formatters/phone.d.ts

@@ -1,4 +1,21 @@
-export type PhoneCountry = 'IN' | 'US' | 'GB' | 'AE' | 'AU' | 'SG' | 'CA';
+/**
+ * The bare 'libphonenumber-js' entry point actually resolves to the library's
+ * OWN slimmed-down min/ metadata internally, not its full data - './max' is
+ * the variant with complete per-country metadata. Since the reason this
+ * module exists is validation and formatting accuracy, the more accurate
+ * variant wins throughout this file, not just for validation.
+ */
+import { type CountryCode } from 'libphonenumber-js/max';
+export type { PhoneNumber } from 'libphonenumber-js/max';
+export { isValidPhoneNumber, parsePhoneNumber, parsePhoneNumberFromString } from 'libphonenumber-js/max';
+/**
+ * Re-exported under our own name rather than importing CountryCode directly
+ * everywhere, so a future need to diverge (or re-narrow) has one place to do
+ * it. Every ISO 3166-1 alpha-2 code libphonenumber-js recognises - formatPhone
+ * and detectPhoneCountry below are genuinely correct for all of them, not a
+ * curated subset.
+ */
+export type PhoneCountry = CountryCode;
 export interface FormatPhoneOptions {
     defaultCountryCode?: string;
     country?: PhoneCountry;
@@ -11,17 +28,22 @@ export declare const normalizePhone: (input: string) => string;
 /**
  * Detect the country of a phone number: from its own `+` country code when
  * present, otherwise from `defaultCountryCode`. Returns null when neither
- * carries a recognised calling code.
+ * parses to a recognised country.
  */
 export declare const detectPhoneCountry: (input: string, defaultCountryCode?: string) => PhoneCountry | null;
 /**
- * Format a phone number for human display.
+ * Format a phone number for human display, via libphonenumber-js's own
+ * per-country formatting rather than a hand-rolled grouping table - correct
+ * for every country it recognises, not a curated subset.
  *
- * - Indian mobile (10 digits) → `XXXXX XXXXX`
- * - With `+91` country code → `+91 XXXXX XXXXX`
- * - A number that already carries a recognised country code is grouped for
- *   that country regardless of `defaultCountryCode`.
- * - Other inputs are returned as `+CC NNNN NNNN…` best-effort grouping.
+ * - A number that already carries a `+` country code formats for that country.
+ * - A bare national number formats for `options.country` when given, else for
+ *   the country implied by `defaultCountryCode` (default `+91`).
+ * - `includeCountryCode` controls international vs national format; defaults
+ *   to international whenever the country was detected rather than passed in
+ *   explicitly as `options.country`, and to national when it was.
+ * - Input libphonenumber-js can't parse into a valid number for the resolved
+ *   country falls back to a best-effort `+CC NNNN NNNN…` digit grouping.
  */
 export declare function formatPhone(input: string, defaultCountryCode?: string): string;
 export declare function formatPhone(input: string, options?: FormatPhoneOptions): string;

package/lib/typescript/module/index.d.ts

@@ -28,8 +28,8 @@ export type { Config, Environment, LogLevel } from './config/index.js';
 export { getConfig, getConfigValue, resetConfig, setConfig } from './config/index.js';
 export type { DeepLinkConfig, DeepLinkRoute, ParsedLink } from './deepLink/index.js';
 export { DeepLink, parseDeepLink, useDeepLink } from './deepLink/index.js';
-export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, TimeStyle } from './formatters/index.js';
-export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, normalizePhone } from './formatters/index.js';
+export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, PhoneNumber, TimeStyle } from './formatters/index.js';
+export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from './formatters/index.js';
 export type { InitConfig } from './initSDK.js';
 export { initWebority } from './initSDK.js';
 export type { AuthActions } from './initUserAuth.js';

package/lib/typescript/module/storage/index.d.ts

@@ -56,7 +56,7 @@ export interface StorageApi {
  * All operations swallow errors (logging them) and return a falsy result
  * so that storage problems never crash the app.
  *
- * Backed by `@react-native-async-storage/async-storage` by default;
+ * Backed by `expo-sqlite/kv-store` by default;
  * override with `setStorageImplementation()` for MMKV or custom adapters.
  */
 export declare const Storage: StorageApi;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webority-technologies/mobile-core",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Platform layer for Webority React Native apps: HTTP clients, auth/token storage, config, logging, formatters, validators, network status, permissions, storage and version checks. No UI.",
   "keywords": [
     "react-native",
@@ -133,7 +133,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "axios": "^1.19.0"
+    "axios": "^1.19.0",
+    "libphonenumber-js": "^1.12.41"
   },
   "peerDependencies": {
     "@op-engineering/op-sqlite": "*",