@kaisarsofi/react-native-phone-input 1.0.0

package/lib/module/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export { COUNTRIES, getCountryByCode, groupCountriesByLetter, sectionLetterFor } from "./countries.js";
+export { Flag } from "./Flag.js";
+export { PhoneInput } from "./PhoneInput.js";
+export { CountryPicker } from "./CountryPicker.js";
+export { LIGHT_PALETTE, DARK_PALETTE, usePhoneInputPalette } from "./theme.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["COUNTRIES","getCountryByCode","groupCountriesByLetter","sectionLetterFor","Flag","PhoneInput","CountryPicker","LIGHT_PALETTE","DARK_PALETTE","usePhoneInputPalette"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SACEA,SAAS,EACTC,gBAAgB,EAChBC,sBAAsB,EACtBC,gBAAgB,QACX,gBAAa;AAEpB,SAASC,IAAI,QAAQ,WAAQ;AAC7B,SAASC,UAAU,QAAQ,iBAAc;AACzC,SAASC,aAAa,QAAQ,oBAAiB;AAC/C,SAASC,aAAa,EAAEC,YAAY,EAAEC,oBAAoB,QAAQ,YAAS","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/safeArea.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import { createContext, useContext } from 'react';
+/**
+ * `react-native-safe-area-context` is an *optional* peer: this library ships no
+ * native modules, so it is never installed on our account. The guarded require
+ * is what makes that safe — Metro registers a `require` inside a try/catch as
+ * an optional dependency and emits a runtime throw instead of failing the
+ * build (`allowOptionalDependencies`, enabled by default in both
+ * `@expo/metro-config` and `@react-native/metro-config`). The catch also covers
+ * bundlers that hand the ESM build a scope with no `require` at all.
+ */
+let optionalModule = null;
+try {
+  optionalModule = require('react-native-safe-area-context');
+} catch {
+  optionalModule = null;
+}
+const FallbackContext = /*#__PURE__*/createContext(null);
+
+/**
+ * Deliberately the *context* rather than `useSafeAreaInsets()`: that hook
+ * throws when no `SafeAreaProvider` is mounted above it, and plenty of apps
+ * carry the package transitively (React Navigation depends on it) without a
+ * provider in scope. Reading the context degrades to `null` instead.
+ *
+ * Resolved once at module scope so the identity is stable, which keeps the
+ * `useContext` call below an unconditional, rules-of-hooks-safe one.
+ */
+const InsetsContext = optionalModule?.SafeAreaInsetsContext ?? FallbackContext;
+
+/** The ambient safe-area insets, or null when unavailable. */
+export function useOptionalSafeAreaInsets() {
+  return useContext(InsetsContext);
+}
+
+/** Whether the optional peer resolved. Exported for diagnostics and tests. */
+export const hasSafeAreaContext = optionalModule?.SafeAreaInsetsContext != null;
+//# sourceMappingURL=safeArea.js.map

package/lib/module/safeArea.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createContext","useContext","optionalModule","require","FallbackContext","InsetsContext","SafeAreaInsetsContext","useOptionalSafeAreaInsets","hasSafeAreaContext"],"sourceRoot":"../../src","sources":["safeArea.ts"],"mappings":";;AAAA,SAASA,aAAa,EAAEC,UAAU,QAAsB,OAAO;AAa/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAIC,cAAqC,GAAG,IAAI;AAChD,IAAI;EACFA,cAAc,GAAGC,OAAO,CAAC,gCAAgC,CAAmB;AAC9E,CAAC,CAAC,MAAM;EACND,cAAc,GAAG,IAAI;AACvB;AAEA,MAAME,eAAe,gBAAGJ,aAAa,CAAoB,IAAI,CAAC;;AAE9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMK,aAAyC,GAC7CH,cAAc,EAAEI,qBAAqB,IAAIF,eAAe;;AAE1D;AACA,OAAO,SAASG,yBAAyBA,CAAA,EAAsB;EAC7D,OAAON,UAAU,CAACI,aAAa,CAAC;AAClC;;AAEA;AACA,OAAO,MAAMG,kBAAkB,GAAGN,cAAc,EAAEI,qBAAqB,IAAI,IAAI","ignoreList":[]}

package/lib/module/theme.js

@@ -0,0 +1,81 @@
+"use strict";
+
+import { useColorScheme } from 'react-native';
+import { useMemo } from 'react';
+
+/** Which palette to render with. "system" follows the OS appearance. */
+
+/**
+ * Every color the input and the country picker draw with. Both palettes are
+ * complete, so dark mode needs no configuration — pass nothing and the
+ * component follows the OS. Override individual tokens via the `palette`
+ * prop when you want the component to match your own design system.
+ */
+/**
+ * Note the split with `theme`: `theme` styles the text field alone (its fill,
+ * its borders, its text), while this palette covers the field's neutral
+ * defaults *and* the whole picker sheet. Keeping them separate is what lets a
+ * field sitting on a colored background go fully custom without erasing the
+ * picker's separators or A-Z index along with it.
+ */
+
+export const LIGHT_PALETTE = {
+  background: '#FFFFFF',
+  inputBackground: '#FFFFFF',
+  surface: '#F2F2F7',
+  surfacePressed: '#E5E5EA',
+  border: '#D1D1D6',
+  text: '#1C1C1E',
+  textMuted: '#8E8E93',
+  placeholder: '#8E8E93',
+  accent: '#007AFF',
+  accentContrast: '#FFFFFF',
+  danger: '#FF3B30',
+  disabled: '#C7C7CC',
+  handle: '#D1D1D6',
+  bubble: 'rgba(60,60,67,0.85)',
+  bubbleText: '#FFFFFF'
+};
+export const DARK_PALETTE = {
+  background: '#1C1C1E',
+  inputBackground: '#1C1C1E',
+  surface: '#2C2C2E',
+  surfacePressed: '#3A3A3C',
+  border: '#38383A',
+  text: '#FFFFFF',
+  textMuted: '#98989F',
+  placeholder: '#8E8E93',
+  accent: '#0A84FF',
+  accentContrast: '#FFFFFF',
+  danger: '#FF453A',
+  disabled: '#48484A',
+  handle: '#48484A',
+  bubble: 'rgba(120,120,128,0.9)',
+  bubbleText: '#FFFFFF'
+};
+
+/**
+ * Resolves the palette for the current appearance. `colorScheme` forces one;
+ * "system" (the default) follows the OS and re-renders when it changes.
+ */
+export function usePhoneInputPalette(colorScheme = 'system', overrides) {
+  const systemScheme = useColorScheme();
+  const resolved = colorScheme === 'system' ? systemScheme ?? 'light' : colorScheme;
+
+  // Keyed on the overrides' contents rather than their identity, because
+  // callers naturally write `palette={{ ... }}` inline. A new object every
+  // render would give the palette a new identity every render, and the picker
+  // memoizes ~20 style objects and its whole row list on that identity —
+  // serializing a handful of color strings is far cheaper than losing those.
+  const overridesKey = overrides ? JSON.stringify(overrides) : '';
+  return useMemo(() => {
+    const base = resolved === 'dark' ? DARK_PALETTE : LIGHT_PALETTE;
+    return {
+      ...base,
+      ...overrides
+    };
+    // `overrides` is intentionally tracked through `overridesKey`.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [resolved, overridesKey]);
+}
+//# sourceMappingURL=theme.js.map

package/lib/module/theme.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useColorScheme","useMemo","LIGHT_PALETTE","background","inputBackground","surface","surfacePressed","border","text","textMuted","placeholder","accent","accentContrast","danger","disabled","handle","bubble","bubbleText","DARK_PALETTE","usePhoneInputPalette","colorScheme","overrides","systemScheme","resolved","overridesKey","JSON","stringify","base"],"sourceRoot":"../../src","sources":["theme.ts"],"mappings":";;AAAA,SAASA,cAAc,QAAQ,cAAc;AAC7C,SAASC,OAAO,QAAQ,OAAO;;AAE/B;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAgCA,OAAO,MAAMC,aAAgC,GAAG;EAC9CC,UAAU,EAAE,SAAS;EACrBC,eAAe,EAAE,SAAS;EAC1BC,OAAO,EAAE,SAAS;EAClBC,cAAc,EAAE,SAAS;EACzBC,MAAM,EAAE,SAAS;EACjBC,IAAI,EAAE,SAAS;EACfC,SAAS,EAAE,SAAS;EACpBC,WAAW,EAAE,SAAS;EACtBC,MAAM,EAAE,SAAS;EACjBC,cAAc,EAAE,SAAS;EACzBC,MAAM,EAAE,SAAS;EACjBC,QAAQ,EAAE,SAAS;EACnBC,MAAM,EAAE,SAAS;EACjBC,MAAM,EAAE,qBAAqB;EAC7BC,UAAU,EAAE;AACd,CAAC;AAED,OAAO,MAAMC,YAA+B,GAAG;EAC7Cf,UAAU,EAAE,SAAS;EACrBC,eAAe,EAAE,SAAS;EAC1BC,OAAO,EAAE,SAAS;EAClBC,cAAc,EAAE,SAAS;EACzBC,MAAM,EAAE,SAAS;EACjBC,IAAI,EAAE,SAAS;EACfC,SAAS,EAAE,SAAS;EACpBC,WAAW,EAAE,SAAS;EACtBC,MAAM,EAAE,SAAS;EACjBC,cAAc,EAAE,SAAS;EACzBC,MAAM,EAAE,SAAS;EACjBC,QAAQ,EAAE,SAAS;EACnBC,MAAM,EAAE,SAAS;EACjBC,MAAM,EAAE,uBAAuB;EAC/BC,UAAU,EAAE;AACd,CAAC;;AAED;AACA;AACA;AACA;AACA,OAAO,SAASE,oBAAoBA,CAClCC,WAAkC,GAAG,QAAQ,EAC7CC,SAAsC,EACnB;EACnB,MAAMC,YAAY,GAAGtB,cAAc,CAAC,CAAC;EACrC,MAAMuB,QAAQ,GACZH,WAAW,KAAK,QAAQ,GAAIE,YAAY,IAAI,OAAO,GAAIF,WAAW;;EAEpE;EACA;EACA;EACA;EACA;EACA,MAAMI,YAAY,GAAGH,SAAS,GAAGI,IAAI,CAACC,SAAS,CAACL,SAAS,CAAC,GAAG,EAAE;EAE/D,OAAOpB,OAAO,CAAC,MAAM;IACnB,MAAM0B,IAAI,GAAGJ,QAAQ,KAAK,MAAM,GAAGL,YAAY,GAAGhB,aAAa;IAC/D,OAAO;MAAE,GAAGyB,IAAI;MAAE,GAAGN;IAAU,CAAC;IAChC;IACA;EACF,CAAC,EAAE,CAACE,QAAQ,EAAEC,YAAY,CAAC,CAAC;AAC9B","ignoreList":[]}

package/lib/module/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/value.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import { AsYouType, getCountryCallingCode, isValidPhoneNumber, parsePhoneNumberFromString } from 'libphonenumber-js';
+import { getCountryByCallingCode, getCountryByCode } from "./countries.js";
+/**
+ * The country's true calling code ("1" for Jamaica), as opposed to the
+ * extended `dialCode` ("1876") the picker shows to tell the NANP territories
+ * apart. Concatenating the latter with a national number double-counts the
+ * area code, so every international string is built from this instead.
+ */
+export function callingCodeFor(country) {
+  try {
+    return getCountryCallingCode(country.code);
+  } catch {
+    return country.dialCode;
+  }
+}
+export function buildValue(nationalNumber, country) {
+  const digits = nationalNumber.replace(/\D/g, '');
+  const valid = digits.length > 0 && isValidPhoneNumber(digits, country.code);
+  const e164 = valid ? parsePhoneNumberFromString(digits, country.code)?.number ?? null : null;
+  return {
+    nationalNumber: digits,
+    country: country.code,
+    dialCode: country.dialCode,
+    e164,
+    international: digits ? `+${callingCodeFor(country)}${digits}` : '',
+    isValid: valid
+  };
+}
+
+/**
+ * Splits a controlled `value` into the national digits and, when the value is
+ * an international string, the country it implies. `current` is kept whenever
+ * its calling code still matches, so an explicit pick among the countries
+ * sharing a calling code (Jamaica vs the US on "+1") is not undone by the
+ * next keystroke.
+ */
+export function readControlledValue(raw, current) {
+  if (!raw.startsWith('+')) {
+    return {
+      national: raw.replace(/\D/g, ''),
+      country: current
+    };
+  }
+  const formatter = new AsYouType();
+  formatter.input(raw);
+  const callingCode = formatter.getCallingCode();
+  const national = formatter.getNationalNumber() ?? '';
+  if (!callingCode || callingCode === callingCodeFor(current)) {
+    return {
+      national,
+      country: current
+    };
+  }
+  const next = getCountryByCode(formatter.getCountry()) ?? getCountryByCallingCode(callingCode);
+  return {
+    national,
+    country: next ?? current
+  };
+}
+//# sourceMappingURL=value.js.map

package/lib/module/value.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AsYouType","getCountryCallingCode","isValidPhoneNumber","parsePhoneNumberFromString","getCountryByCallingCode","getCountryByCode","callingCodeFor","country","code","dialCode","buildValue","nationalNumber","digits","replace","valid","length","e164","number","international","isValid","readControlledValue","raw","current","startsWith","national","formatter","input","callingCode","getCallingCode","getNationalNumber","next","getCountry"],"sourceRoot":"../../src","sources":["value.ts"],"mappings":";;AAAA,SACEA,SAAS,EACTC,qBAAqB,EACrBC,kBAAkB,EAClBC,0BAA0B,QACrB,mBAAmB;AAC1B,SAASC,uBAAuB,EAAEC,gBAAgB,QAAQ,gBAAa;AAIvE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAACC,OAAgB,EAAU;EACvD,IAAI;IACF,OAAON,qBAAqB,CAACM,OAAO,CAACC,IAAI,CAAC;EAC5C,CAAC,CAAC,MAAM;IACN,OAAOD,OAAO,CAACE,QAAQ;EACzB;AACF;AAEA,OAAO,SAASC,UAAUA,CACxBC,cAAsB,EACtBJ,OAAgB,EACC;EACjB,MAAMK,MAAM,GAAGD,cAAc,CAACE,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;EAChD,MAAMC,KAAK,GAAGF,MAAM,CAACG,MAAM,GAAG,CAAC,IAAIb,kBAAkB,CAACU,MAAM,EAAEL,OAAO,CAACC,IAAI,CAAC;EAC3E,MAAMQ,IAAI,GAAGF,KAAK,GACbX,0BAA0B,CAACS,MAAM,EAAEL,OAAO,CAACC,IAAI,CAAC,EAAES,MAAM,IAAI,IAAI,GACjE,IAAI;EACR,OAAO;IACLN,cAAc,EAAEC,MAAM;IACtBL,OAAO,EAAEA,OAAO,CAACC,IAAI;IACrBC,QAAQ,EAAEF,OAAO,CAACE,QAAQ;IAC1BO,IAAI;IACJE,aAAa,EAAEN,MAAM,GAAG,IAAIN,cAAc,CAACC,OAAO,CAAC,GAAGK,MAAM,EAAE,GAAG,EAAE;IACnEO,OAAO,EAAEL;EACX,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASM,mBAAmBA,CACjCC,GAAW,EACXC,OAAgB,EACwB;EACxC,IAAI,CAACD,GAAG,CAACE,UAAU,CAAC,GAAG,CAAC,EAAE;IACxB,OAAO;MAAEC,QAAQ,EAAEH,GAAG,CAACR,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;MAAEN,OAAO,EAAEe;IAAQ,CAAC;EAC/D;EACA,MAAMG,SAAS,GAAG,IAAIzB,SAAS,CAAC,CAAC;EACjCyB,SAAS,CAACC,KAAK,CAACL,GAAG,CAAC;EACpB,MAAMM,WAAW,GAAGF,SAAS,CAACG,cAAc,CAAC,CAAC;EAC9C,MAAMJ,QAAQ,GAAGC,SAAS,CAACI,iBAAiB,CAAC,CAAC,IAAI,EAAE;EAEpD,IAAI,CAACF,WAAW,IAAIA,WAAW,KAAKrB,cAAc,CAACgB,OAAO,CAAC,EAAE;IAC3D,OAAO;MAAEE,QAAQ;MAAEjB,OAAO,EAAEe;IAAQ,CAAC;EACvC;EACA,MAAMQ,IAAI,GACRzB,gBAAgB,CAACoB,SAAS,CAACM,UAAU,CAAC,CAAC,CAAC,IACxC3B,uBAAuB,CAACuB,WAAW,CAAC;EACtC,OAAO;IAAEH,QAAQ;IAAEjB,OAAO,EAAEuB,IAAI,IAAIR;EAAQ,CAAC;AAC/C","ignoreList":[]}

package/lib/typescript/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/typescript/commonjs/src/CountryPicker.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from 'react';
+import { type Country } from './countries';
+import { type PhoneInputPalette } from './theme';
+import type { CountryPickerRenderItemInfo, CountryPickerStyles, PhoneInputColorScheme } from './types';
+export interface CountryPickerProps {
+    visible: boolean;
+    countries: Country[];
+    selected?: Country;
+    onSelect: (country: Country) => void;
+    onClose: () => void;
+    searchPlaceholder?: string;
+    disableSearch?: boolean;
+    renderCountryItem?: (info: CountryPickerRenderItemInfo) => ReactNode;
+    /**
+     * Safe-area padding for the sheet. Usually unnecessary: when
+     * `react-native-safe-area-context` is installed (an optional peer) the
+     * insets are detected automatically, and the defaults work without it
+     * either way. Any edge set here overrides the detected value for that edge
+     * only — `{ top: 0 }` opts out of the top inset and keeps the rest.
+     */
+    safeAreaInsets?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+    /** Resolved palette. Passed down by PhoneInput; when the picker is used on
+     * its own it resolves one from `colorScheme` instead. */
+    palette?: PhoneInputPalette;
+    colorScheme?: PhoneInputColorScheme;
+    presentationStyle?: 'pageSheet' | 'fullScreen' | 'formSheet';
+    groupAlphabetically?: boolean;
+    showAlphabetIndex?: boolean;
+    styles?: CountryPickerStyles;
+}
+export declare function CountryPicker({ visible, countries, selected, onSelect, onClose, searchPlaceholder, disableSearch, renderCountryItem, palette: providedPalette, colorScheme, safeAreaInsets, presentationStyle, groupAlphabetically, showAlphabetIndex, styles: styleOverrides, }: CountryPickerProps): import("react").JSX.Element;
+//# sourceMappingURL=CountryPicker.d.ts.map

package/lib/typescript/commonjs/src/CountryPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CountryPicker.d.ts","sourceRoot":"","sources":["../../../../src/CountryPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAYf,OAAO,EAA0B,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAGnE,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAC;AACvE,OAAO,KAAK,EACV,2BAA2B,EAC3B,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AASjB,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACrC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,2BAA2B,KAAK,SAAS,CAAC;IACrE;;;;;;OAMG;IACH,cAAc,CAAC,EAAE;QACf,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF;6DACyD;IACzD,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,WAAW,CAAC,EAAE,qBAAqB,CAAC;IACpC,iBAAiB,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,WAAW,CAAC;IAC7D,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,mBAAmB,CAAC;CAC9B;AAED,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,iBAA4C,EAC5C,aAAa,EACb,iBAAiB,EACjB,OAAO,EAAE,eAAe,EACxB,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,mBAA0B,EAC1B,iBAAwB,EACxB,MAAM,EAAE,cAAc,GACvB,EAAE,kBAAkB,+BA+fpB"}

package/lib/typescript/commonjs/src/Flag.d.ts

@@ -0,0 +1,10 @@
+import { type StyleProp, type TextStyle } from 'react-native';
+import type { Country } from './countries';
+export interface FlagProps {
+    country: Country;
+    size?: number;
+    style?: StyleProp<TextStyle>;
+}
+/** Renders a country's Unicode flag emoji, e.g. 🇺🇸. */
+export declare function Flag({ country, size, style }: FlagProps): import("react").JSX.Element;
+//# sourceMappingURL=Flag.d.ts.map

package/lib/typescript/commonjs/src/Flag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Flag.d.ts","sourceRoot":"","sources":["../../../../src/Flag.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B;AAED,yDAAyD;AACzD,wBAAgB,IAAI,CAAC,EAAE,OAAO,EAAE,IAAS,EAAE,KAAK,EAAE,EAAE,SAAS,+BAM5D"}

package/lib/typescript/commonjs/src/PhoneInput.d.ts

@@ -0,0 +1,3 @@
+import type { PhoneInputProps, PhoneInputRef } from './types';
+export declare const PhoneInput: import("react").ForwardRefExoticComponent<PhoneInputProps & import("react").RefAttributes<PhoneInputRef>>;
+//# sourceMappingURL=PhoneInput.d.ts.map

package/lib/typescript/commonjs/src/PhoneInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhoneInput.d.ts","sourceRoot":"","sources":["../../../../src/PhoneInput.tsx"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAW,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEvE,eAAO,MAAM,UAAU,2GAkStB,CAAC"}

package/lib/typescript/commonjs/src/countries.d.ts

@@ -0,0 +1,28 @@
+import type { CountryCode } from 'libphonenumber-js';
+export interface Country {
+    /** ISO 3166-1 alpha-2 country code, e.g. "US" */
+    code: CountryCode;
+    /** Country calling code without the leading "+", e.g. "1" */
+    dialCode: string;
+    /** English display name */
+    name: string;
+    /** Unicode regional-indicator flag emoji, e.g. "🇺🇸" */
+    flag: string;
+}
+export interface CountrySection {
+    letter: string;
+    data: Country[];
+}
+export declare const COUNTRIES: Country[];
+export declare const COUNTRIES_BY_CODE: Record<string, Country>;
+export declare function getCountryByCode(code?: string | null): Country | undefined;
+export declare function getCountryByCallingCode(callingCode?: string | null): Country | undefined;
+/** Reads the device's region from the JS engine's default locale (e.g. "en-IN"
+ * -> "IN"), with no native module required. Used as the initial country when
+ * the consumer doesn't pass `defaultCountry`. Returns undefined if the
+ * runtime can't resolve a locale/region (some Hermes builds, very old engines). */
+export declare function getDeviceCountry(): Country | undefined;
+export declare function sectionLetterFor(name: string): string;
+/** Groups an (already name-sorted) country list into contiguous A–Z sections. */
+export declare function groupCountriesByLetter(list: Country[]): CountrySection[];
+//# sourceMappingURL=countries.d.ts.map

package/lib/typescript/commonjs/src/countries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"countries.d.ts","sourceRoot":"","sources":["../../../../src/countries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,MAAM,WAAW,OAAO;IACtB,iDAAiD;IACjD,IAAI,EAAE,WAAW,CAAC;IAClB,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAED,eAAO,MAAM,SAAS,EAAE,OAAO,EAA+B,CAAC;AAE/D,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAMrD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,CAG1E;AAcD,wBAAgB,uBAAuB,CACrC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAC1B,OAAO,GAAG,SAAS,CAGrB;AAED;;;mFAGmF;AACnF,wBAAgB,gBAAgB,IAAI,OAAO,GAAG,SAAS,CAQtD;AAMD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOrD;AAED,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,cAAc,EAAE,CAYxE"}

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

@@ -0,0 +1,9 @@
+export { COUNTRIES, getCountryByCode, groupCountriesByLetter, sectionLetterFor, } from './countries';
+export type { Country, CountrySection } from './countries';
+export { Flag } from './Flag';
+export { PhoneInput } from './PhoneInput';
+export { CountryPicker } from './CountryPicker';
+export { LIGHT_PALETTE, DARK_PALETTE, usePhoneInputPalette } from './theme';
+export type { PhoneInputPalette, PhoneInputColorScheme } from './theme';
+export type { PhoneInputProps, PhoneInputRef, PhoneInputValue, PhoneInputTheme, CountryPickerRenderItemInfo, CountryDisplayMode, CountryPickerStyles, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAC5E,YAAY,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACxE,YAAY,EACV,eAAe,EACf,aAAa,EACb,eAAe,EACf,eAAe,EACf,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,SAAS,CAAC"}

package/lib/typescript/commonjs/src/safeArea.d.ts

@@ -0,0 +1,11 @@
+export interface EdgeInsets {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+/** The ambient safe-area insets, or null when unavailable. */
+export declare function useOptionalSafeAreaInsets(): EdgeInsets | null;
+/** Whether the optional peer resolved. Exported for diagnostics and tests. */
+export declare const hasSafeAreaContext: boolean;
+//# sourceMappingURL=safeArea.d.ts.map

package/lib/typescript/commonjs/src/safeArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeArea.d.ts","sourceRoot":"","sources":["../../../../src/safeArea.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAoCD,8DAA8D;AAC9D,wBAAgB,yBAAyB,IAAI,UAAU,GAAG,IAAI,CAE7D;AAED,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,SAAgD,CAAC"}

package/lib/typescript/commonjs/src/theme.d.ts

@@ -0,0 +1,53 @@
+/** Which palette to render with. "system" follows the OS appearance. */
+export type PhoneInputColorScheme = 'light' | 'dark' | 'system';
+/**
+ * Every color the input and the country picker draw with. Both palettes are
+ * complete, so dark mode needs no configuration — pass nothing and the
+ * component follows the OS. Override individual tokens via the `palette`
+ * prop when you want the component to match your own design system.
+ */
+/**
+ * Note the split with `theme`: `theme` styles the text field alone (its fill,
+ * its borders, its text), while this palette covers the field's neutral
+ * defaults *and* the whole picker sheet. Keeping them separate is what lets a
+ * field sitting on a colored background go fully custom without erasing the
+ * picker's separators or A-Z index along with it.
+ */
+export interface PhoneInputPalette {
+    /** Picker page background */
+    background: string;
+    /** The text field's own fill */
+    inputBackground: string;
+    /** Raised surfaces: search box, section headers, close button, selected row */
+    surface: string;
+    /** Pressed state for those surfaces */
+    surfacePressed: string;
+    /** Hairline separators, the input border, the country/number divider */
+    border: string;
+    /** Primary text: the number, country names, the picker title */
+    text: string;
+    /** Secondary text: dial codes, section letters, the empty state */
+    textMuted: string;
+    placeholder: string;
+    /** Focus ring and the A–Z index */
+    accent: string;
+    /** Text drawn on top of `accent` */
+    accentContrast: string;
+    /** Border shown when the typed number is invalid */
+    danger: string;
+    /** A–Z index letter with no countries under it */
+    disabled: string;
+    /** The sheet's drag handle */
+    handle: string;
+    /** The letter bubble shown while scrubbing the A–Z index */
+    bubble: string;
+    bubbleText: string;
+}
+export declare const LIGHT_PALETTE: PhoneInputPalette;
+export declare const DARK_PALETTE: PhoneInputPalette;
+/**
+ * Resolves the palette for the current appearance. `colorScheme` forces one;
+ * "system" (the default) follows the OS and re-renders when it changes.
+ */
+export declare function usePhoneInputPalette(colorScheme?: PhoneInputColorScheme, overrides?: Partial<PhoneInputPalette>): PhoneInputPalette;
+//# sourceMappingURL=theme.d.ts.map

package/lib/typescript/commonjs/src/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../../src/theme.ts"],"names":[],"mappings":"AAGA,wEAAwE;AACxE,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEhE;;;;;GAKG;AACH;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,cAAc,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,aAAa,EAAE,iBAgB3B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,iBAgB1B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,GAAE,qBAAgC,EAC7C,SAAS,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,GACrC,iBAAiB,CAkBnB"}

package/lib/typescript/commonjs/src/types.d.ts

@@ -0,0 +1,211 @@
+import type { CountryCode } from 'libphonenumber-js';
+import type { StyleProp, TextInputProps, TextStyle, ViewStyle } from 'react-native';
+import type { Country } from './countries';
+import type { PhoneInputColorScheme, PhoneInputPalette } from './theme';
+export type { Country };
+export type { PhoneInputColorScheme, PhoneInputPalette };
+export interface PhoneInputValue {
+    /** Raw digits the user typed, national significant number, no dial code (e.g. "4155552671") */
+    nationalNumber: string;
+    /** ISO 3166-1 alpha-2 country selected (e.g. "US") */
+    country: CountryCode;
+    /**
+     * Calling code without "+" (e.g. "1"). For the 23 NANP territories that
+     * share "+1" (Jamaica, Bermuda, etc.) this includes the distinguishing area
+     * code (e.g. "1876") so the picker can tell them apart — use `e164`, not
+     * `dialCode` + `nationalNumber`, to reconstruct the full number.
+     */
+    dialCode: string;
+    /** Full E.164 formatted number if valid, e.g. "+14155552671" */
+    e164: string | null;
+    /**
+     * The number as an international string at every keystroke, valid or not
+     * (e.g. "+1415555" while typing). Equals `e164` once the number is valid,
+     * and "" while the field is empty. Built through libphonenumber-js, so
+     * unlike `dialCode` + `nationalNumber` it is always correct for the NANP
+     * territories that share "+1" — use this, not string concatenation, when
+     * you need a value to store on every change.
+     */
+    international: string;
+    /** Whether libphonenumber-js considers the number valid for the selected country */
+    isValid: boolean;
+}
+export interface PhoneInputRef {
+    focus: () => void;
+    blur: () => void;
+    isValid: () => boolean;
+    getValue: () => PhoneInputValue;
+}
+export interface CountryPickerRenderItemInfo {
+    item: Country;
+    isSelected: boolean;
+    onPress: () => void;
+}
+export interface PhoneInputTheme {
+    backgroundColor?: string;
+    borderColor?: string;
+    focusedBorderColor?: string;
+    errorBorderColor?: string;
+    textColor?: string;
+    placeholderColor?: string;
+    dialCodeColor?: string;
+    /** The rule between the country control and the number. Defaults to the
+     * palette's border color — set it explicitly when the field itself is
+     * borderless, so the divider does not disappear with the border. */
+    dividerColor?: string;
+    borderRadius?: number;
+    fontSize?: number;
+}
+/** What the country control (left of the input) shows. */
+export type CountryDisplayMode = 'flag' | 'code' | 'both';
+/**
+ * Per-element style overrides for the country picker modal, so every part of it
+ * can be fully re-skinned — not just colors via `theme`. Each slot is merged on
+ * top of the built-in style, so you only need to specify what you're changing.
+ */
+export interface CountryPickerStyles {
+    /** The modal's root view */
+    container?: StyleProp<ViewStyle>;
+    /** The block holding the title row and search box, ruled off from the list */
+    headerSection?: StyleProp<ViewStyle>;
+    /** Row containing the title and close button */
+    header?: StyleProp<ViewStyle>;
+    title?: StyleProp<TextStyle>;
+    closeButton?: StyleProp<ViewStyle>;
+    closeButtonText?: StyleProp<TextStyle>;
+    /** The search field's box — fill, border, height */
+    searchContainer?: StyleProp<ViewStyle>;
+    /** The search field's text input */
+    search?: StyleProp<TextStyle>;
+    /** A single country row */
+    row?: StyleProp<ViewStyle>;
+    /** Merged on top of `row` when that row is the selected country */
+    rowSelected?: StyleProp<ViewStyle>;
+    flag?: StyleProp<TextStyle>;
+    name?: StyleProp<TextStyle>;
+    dialCode?: StyleProp<TextStyle>;
+    /** The "A", "B", "C"... letter header above each section */
+    sectionHeader?: StyleProp<ViewStyle>;
+    sectionHeaderText?: StyleProp<TextStyle>;
+    /** A single letter in the right-edge alphabet index */
+    sidebarLetter?: StyleProp<TextStyle>;
+    /** Merged on top of `sidebarLetter` for the currently-active letter */
+    sidebarLetterActive?: StyleProp<TextStyle>;
+}
+export interface PhoneInputProps extends Omit<TextInputProps, 'value' | 'onChangeText' | 'onChange' | 'style'> {
+    /**
+     * ISO 3166-1 alpha-2 initial country, e.g. "US" (uncontrolled). Set this
+     * only when you want a *fixed* initial country regardless of the device —
+     * it always wins over locale detection. Leave it unset to prefer the
+     * device's locale region instead (see {@link fallbackCountry}).
+     */
+    defaultCountry?: CountryCode;
+    /**
+     * Initial country used only when `defaultCountry` is unset AND the
+     * device's locale region can't be resolved (or isn't in the current
+     * `countries`/`excludedCountries` list). Default: "US". Precedence for the
+     * initial country is: `defaultCountry` > device locale > `fallbackCountry`.
+     */
+    fallbackCountry?: CountryCode;
+    /** Controlled selected country. Falls back to internal state when omitted. */
+    country?: CountryCode;
+    /**
+     * Controlled value. Accepts either the national number on its own (digits,
+     * no dial code — e.g. "4155552671") or a full international number starting
+     * with "+" (e.g. "+14155552671"), in which case the selected country is
+     * derived from it. The international form lets a form store one string and
+     * hand it straight back, with no country state of its own; it is also what
+     * {@link onChangeInternational} emits. The selected country only changes
+     * when the calling code does, so picking a specific "+1" territory is not
+     * undone by the next keystroke.
+     */
+    value?: string;
+    /** Called with the composed value on every change */
+    onChangeText?: (value: PhoneInputValue) => void;
+    /**
+     * Called on every change with {@link PhoneInputValue.international} alone.
+     * Pairs with the international form of `value` so a form field can be wired
+     * up with just `value` and this callback.
+     */
+    onChangeInternational?: (value: string) => void;
+    /** Called only when the selected country changes */
+    onChangeCountry?: (country: Country) => void;
+    /** Restrict the picker to a subset of ISO codes */
+    countries?: CountryCode[];
+    /** Exclude specific ISO codes from the picker */
+    excludedCountries?: CountryCode[];
+    /** Disable the built-in libphonenumber-js validation styling/behavior */
+    disableValidation?: boolean;
+    /** Format the national number as the user types (default: true) */
+    autoFormat?: boolean;
+    /** Show a country control (flag/code) to the left of the input (default: true) */
+    showCountryPicker?: boolean;
+    /** What the country control shows: 'flag' | 'code' | 'both' (default: 'both') */
+    displayMode?: CountryDisplayMode;
+    /** Render a completely custom flag element instead of the built-in one */
+    renderFlag?: (country: Country) => React.ReactNode;
+    /** Render a fully custom row inside the country picker list */
+    renderCountryItem?: (info: CountryPickerRenderItemInfo) => React.ReactNode;
+    /** Placeholder for the picker search box */
+    searchPlaceholder?: string;
+    /** Hide the search box inside the country picker */
+    disableSearch?: boolean;
+    /**
+     * Group the picker list into A–Z sections with letter headers (default: true).
+     * Independent of {@link showAlphabetIndex} — either can be on without the other.
+     */
+    groupAlphabetically?: boolean;
+    /**
+     * Show an A–Z index sidebar on the right edge of the picker for tap/drag jumping
+     * (default: true). Works whether or not {@link groupAlphabetically} is on: with
+     * it off, the list stays flat but the index still jumps to the right country.
+     */
+    showAlphabetIndex?: boolean;
+    /**
+     * When the user types or pastes a number that starts with "+" and its calling
+     * code resolves to a country in the current list, auto-switch the selected
+     * country to match (e.g. pasting "+911234567890" selects India). Default: true.
+     */
+    autoDetectCountry?: boolean;
+    /** Style for the outer wrapper (equivalent to `containerStyle`, kept as the plain
+     * `style` prop so style-interop tooling like NativeWind's `cssInterop` — the same
+     * mechanism shadcn-style RN kits (e.g. react-native-reusables) rely on — can target
+     * it by the standard prop name). */
+    style?: StyleProp<ViewStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+    inputStyle?: StyleProp<TextStyle>;
+    dialCodeStyle?: StyleProp<TextStyle>;
+    flagStyle?: StyleProp<TextStyle>;
+    countryPickerButtonStyle?: StyleProp<ViewStyle>;
+    /** Per-element style overrides for the country picker modal (see {@link CountryPickerStyles}) */
+    pickerStyles?: CountryPickerStyles;
+    /** Visual theme tokens, merged under the style props above */
+    theme?: PhoneInputTheme;
+    /**
+     * Which palette to draw with. Defaults to "system", which follows the OS
+     * appearance — dark mode needs no setup.
+     */
+    colorScheme?: PhoneInputColorScheme;
+    /**
+     * Override individual palette tokens (separators, surfaces, muted text, the
+     * A-Z index, ...) on top of the resolved light/dark palette. This is the
+     * one knob for recoloring the whole component, picker included.
+     */
+    palette?: Partial<PhoneInputPalette>;
+    /**
+     * Safe-area padding for the picker sheet. Usually unnecessary — when
+     * `react-native-safe-area-context` is installed (an optional peer) the
+     * insets are detected automatically, and the defaults work without it
+     * either way. Any edge set here overrides the detected value for that edge
+     * only, so `{ top: 0 }` opts out of the top inset and keeps the rest.
+     */
+    pickerSafeAreaInsets?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+    /** Modal presentation style for the built-in picker (default: "pageSheet" on iOS, "fullScreen" elsewhere) */
+    pickerPresentationStyle?: 'pageSheet' | 'fullScreen' | 'formSheet';
+}
+//# sourceMappingURL=types.d.ts.map