@webority-technologies/mobile-core 0.0.6 → 0.0.7

package/lib/module/formatters/windowsToIanaTable.js

@@ -0,0 +1,160 @@
+"use strict";
+
+/**
+ * .NET-style Windows time zone ID → IANA time zone name, one entry per
+ * Windows zone, generated from CLDR's `windowsZones.xml` (the same
+ * upstream source the retired `windows-iana` npm package derived its own
+ * table from). Only the `territory="001"` (world-default) row is kept per
+ * Windows zone — `formatTimeInWindowsZone` only ever reads the first IANA
+ * candidate, and CLDR's `001` row is exactly that default candidate, so
+ * per-country territory variants (`US`, `CA`, `ZZ`, …) carry no information
+ * this table's one caller uses.
+ *
+ * Regenerate with `node packages/core/scripts/generate-windows-to-iana-table.mjs
+ * <path-to-windowsZones.xml>` (CLDR: `common/supplemental/windowsZones.xml` in
+ * https://github.com/unicode-org/cldr) whenever CLDR adds/renames a zone —
+ * this is a committed, static table; nothing fetches CLDR at build or test
+ * time.
+ */
+export const WINDOWS_TO_IANA = {
+  'AUS Central Standard Time': 'Australia/Darwin',
+  'AUS Eastern Standard Time': 'Australia/Sydney',
+  'Afghanistan Standard Time': 'Asia/Kabul',
+  'Alaskan Standard Time': 'America/Anchorage',
+  'Aleutian Standard Time': 'America/Adak',
+  'Altai Standard Time': 'Asia/Barnaul',
+  'Arab Standard Time': 'Asia/Riyadh',
+  'Arabian Standard Time': 'Asia/Dubai',
+  'Arabic Standard Time': 'Asia/Baghdad',
+  'Argentina Standard Time': 'America/Buenos_Aires',
+  'Astrakhan Standard Time': 'Europe/Astrakhan',
+  'Atlantic Standard Time': 'America/Halifax',
+  'Aus Central W. Standard Time': 'Australia/Eucla',
+  'Azerbaijan Standard Time': 'Asia/Baku',
+  'Azores Standard Time': 'Atlantic/Azores',
+  'Bahia Standard Time': 'America/Bahia',
+  'Bangladesh Standard Time': 'Asia/Dhaka',
+  'Belarus Standard Time': 'Europe/Minsk',
+  'Bougainville Standard Time': 'Pacific/Bougainville',
+  'Canada Central Standard Time': 'America/Regina',
+  'Cape Verde Standard Time': 'Atlantic/Cape_Verde',
+  'Caucasus Standard Time': 'Asia/Yerevan',
+  'Cen. Australia Standard Time': 'Australia/Adelaide',
+  'Central America Standard Time': 'America/Guatemala',
+  'Central Asia Standard Time': 'Asia/Almaty',
+  'Central Brazilian Standard Time': 'America/Cuiaba',
+  'Central Europe Standard Time': 'Europe/Budapest',
+  'Central European Standard Time': 'Europe/Warsaw',
+  'Central Pacific Standard Time': 'Pacific/Guadalcanal',
+  'Central Standard Time': 'America/Chicago',
+  'Central Standard Time (Mexico)': 'America/Mexico_City',
+  'Chatham Islands Standard Time': 'Pacific/Chatham',
+  'China Standard Time': 'Asia/Shanghai',
+  'Cuba Standard Time': 'America/Havana',
+  'Dateline Standard Time': 'Etc/GMT+12',
+  'E. Africa Standard Time': 'Africa/Nairobi',
+  'E. Australia Standard Time': 'Australia/Brisbane',
+  'E. Europe Standard Time': 'Europe/Chisinau',
+  'E. South America Standard Time': 'America/Sao_Paulo',
+  'Easter Island Standard Time': 'Pacific/Easter',
+  'Eastern Standard Time': 'America/New_York',
+  'Eastern Standard Time (Mexico)': 'America/Cancun',
+  'Egypt Standard Time': 'Africa/Cairo',
+  'Ekaterinburg Standard Time': 'Asia/Yekaterinburg',
+  'FLE Standard Time': 'Europe/Kiev',
+  'Fiji Standard Time': 'Pacific/Fiji',
+  'GMT Standard Time': 'Europe/London',
+  'GTB Standard Time': 'Europe/Bucharest',
+  'Georgian Standard Time': 'Asia/Tbilisi',
+  'Greenland Standard Time': 'America/Godthab',
+  'Greenwich Standard Time': 'Atlantic/Reykjavik',
+  'Haiti Standard Time': 'America/Port-au-Prince',
+  'Hawaiian Standard Time': 'Pacific/Honolulu',
+  'India Standard Time': 'Asia/Calcutta',
+  'Iran Standard Time': 'Asia/Tehran',
+  'Israel Standard Time': 'Asia/Jerusalem',
+  'Jordan Standard Time': 'Asia/Amman',
+  'Kaliningrad Standard Time': 'Europe/Kaliningrad',
+  'Korea Standard Time': 'Asia/Seoul',
+  'Libya Standard Time': 'Africa/Tripoli',
+  'Line Islands Standard Time': 'Pacific/Kiritimati',
+  'Lord Howe Standard Time': 'Australia/Lord_Howe',
+  'Magadan Standard Time': 'Asia/Magadan',
+  'Magallanes Standard Time': 'America/Punta_Arenas',
+  'Marquesas Standard Time': 'Pacific/Marquesas',
+  'Mauritius Standard Time': 'Indian/Mauritius',
+  'Middle East Standard Time': 'Asia/Beirut',
+  'Montevideo Standard Time': 'America/Montevideo',
+  'Morocco Standard Time': 'Africa/Casablanca',
+  'Mountain Standard Time': 'America/Denver',
+  'Mountain Standard Time (Mexico)': 'America/Chihuahua',
+  'Myanmar Standard Time': 'Asia/Rangoon',
+  'N. Central Asia Standard Time': 'Asia/Novosibirsk',
+  'Namibia Standard Time': 'Africa/Windhoek',
+  'Nepal Standard Time': 'Asia/Katmandu',
+  'New Zealand Standard Time': 'Pacific/Auckland',
+  'Newfoundland Standard Time': 'America/St_Johns',
+  'Norfolk Standard Time': 'Pacific/Norfolk',
+  'North Asia East Standard Time': 'Asia/Irkutsk',
+  'North Asia Standard Time': 'Asia/Krasnoyarsk',
+  'North Korea Standard Time': 'Asia/Pyongyang',
+  'Omsk Standard Time': 'Asia/Omsk',
+  'Pacific SA Standard Time': 'America/Santiago',
+  'Pacific Standard Time': 'America/Los_Angeles',
+  'Pacific Standard Time (Mexico)': 'America/Tijuana',
+  'Pakistan Standard Time': 'Asia/Karachi',
+  'Paraguay Standard Time': 'America/Asuncion',
+  'Qyzylorda Standard Time': 'Asia/Qyzylorda',
+  'Romance Standard Time': 'Europe/Paris',
+  'Russia Time Zone 10': 'Asia/Srednekolymsk',
+  'Russia Time Zone 11': 'Asia/Kamchatka',
+  'Russia Time Zone 3': 'Europe/Samara',
+  'Russian Standard Time': 'Europe/Moscow',
+  'SA Eastern Standard Time': 'America/Cayenne',
+  'SA Pacific Standard Time': 'America/Bogota',
+  'SA Western Standard Time': 'America/La_Paz',
+  'SE Asia Standard Time': 'Asia/Bangkok',
+  'Saint Pierre Standard Time': 'America/Miquelon',
+  'Sakhalin Standard Time': 'Asia/Sakhalin',
+  'Samoa Standard Time': 'Pacific/Apia',
+  'Sao Tome Standard Time': 'Africa/Sao_Tome',
+  'Saratov Standard Time': 'Europe/Saratov',
+  'Singapore Standard Time': 'Asia/Singapore',
+  'South Africa Standard Time': 'Africa/Johannesburg',
+  'South Sudan Standard Time': 'Africa/Juba',
+  'Sri Lanka Standard Time': 'Asia/Colombo',
+  'Sudan Standard Time': 'Africa/Khartoum',
+  'Syria Standard Time': 'Asia/Damascus',
+  'Taipei Standard Time': 'Asia/Taipei',
+  'Tasmania Standard Time': 'Australia/Hobart',
+  'Tocantins Standard Time': 'America/Araguaina',
+  'Tokyo Standard Time': 'Asia/Tokyo',
+  'Tomsk Standard Time': 'Asia/Tomsk',
+  'Tonga Standard Time': 'Pacific/Tongatapu',
+  'Transbaikal Standard Time': 'Asia/Chita',
+  'Turkey Standard Time': 'Europe/Istanbul',
+  'Turks And Caicos Standard Time': 'America/Grand_Turk',
+  'US Eastern Standard Time': 'America/Indianapolis',
+  'US Mountain Standard Time': 'America/Phoenix',
+  UTC: 'Etc/UTC',
+  'UTC+12': 'Etc/GMT-12',
+  'UTC+13': 'Etc/GMT-13',
+  'UTC-02': 'Etc/GMT+2',
+  'UTC-08': 'Etc/GMT+8',
+  'UTC-09': 'Etc/GMT+9',
+  'UTC-11': 'Etc/GMT+11',
+  'Ulaanbaatar Standard Time': 'Asia/Ulaanbaatar',
+  'Venezuela Standard Time': 'America/Caracas',
+  'Vladivostok Standard Time': 'Asia/Vladivostok',
+  'Volgograd Standard Time': 'Europe/Volgograd',
+  'W. Australia Standard Time': 'Australia/Perth',
+  'W. Central Africa Standard Time': 'Africa/Lagos',
+  'W. Europe Standard Time': 'Europe/Berlin',
+  'W. Mongolia Standard Time': 'Asia/Hovd',
+  'West Asia Standard Time': 'Asia/Tashkent',
+  'West Bank Standard Time': 'Asia/Hebron',
+  'West Pacific Standard Time': 'Pacific/Port_Moresby',
+  'Yakutsk Standard Time': 'Asia/Yakutsk',
+  'Yukon Standard Time': 'America/Whitehorse'
+};
+//# sourceMappingURL=windowsToIanaTable.js.map

package/lib/module/geolocation/index.js

@@ -131,7 +131,7 @@ const ensureLocationPermission = async () => {
     return;
   }
   if (status === 'unavailable') {
-    Logger.warn(`${PREFIX} Location permission status is unavailable (react-native-permissions is not ` + 'installed, or this platform has no mapping); attempting the location request anyway.');
+    Logger.warn(`${PREFIX} Location permission status is unavailable (expo-location is not installed, ` + 'or the check failed); attempting the location request anyway.');
     return;
   }
   throw new GeolocationError('permission-denied', `${PREFIX} Location permission is "${status}". Grant it before requesting a position` + (status === 'blocked' ? ', or call Permissions.openSettings() to let the user fix it.' : '.'));

package/lib/module/index.js

@@ -7,11 +7,12 @@
  * for anyone importing anything at all. Those live behind their own import
  * paths instead:
  *
- *   @webority-technologies/mobile-core/permissions  react-native-permissions
+ *   @webority-technologies/mobile-core/permissions  per kind, its own Expo module
  *   @webority-technologies/mobile-core/compressor   react-native-compressor
  *   @webority-technologies/mobile-core/geolocation  a geolocation provider
- *   @webority-technologies/mobile-core/sqlite       a SQLite driver
+ *   @webority-technologies/mobile-core/sqlite       expo-sqlite
  *   @webority-technologies/mobile-core/download     a filesystem module
+ *   @webority-technologies/mobile-core/smsRetriever Android only, own TurboModule
  *
  * react-native-keychain is the exception and is a REQUIRED peer: the HTTP client
  * reads the bearer token, so it is reachable from the main barrel by design.

package/lib/module/permissions/index.js

@@ -1,202 +1,201 @@
 "use strict";
 
-import { Linking, Platform } from 'react-native';
+import { Linking } from 'react-native';
 import { Logger } from "../logger/index.js";
 
 // Android only — legacy WRITE_EXTERNAL_STORAGE
 
-let permsModule = null;
-let resolved = false;
-const resolveModule = () => {
-  if (resolved) {
-    return permsModule;
-  }
-  resolved = true;
-  try {
-    const mod = require('react-native-permissions');
-    permsModule = mod.default ?? mod;
-  } catch {
-    Logger.warn('[permissions] react-native-permissions is not installed; ' + 'permission checks will report "unavailable".');
-    permsModule = null;
-  }
-  return permsModule;
-};
+/** The shared response shape every Expo permission function returns. */
 
 /**
- * Inject a custom permissions implementation at runtime.
- * Pass `null` to reset to the default lazily-resolved native module.
+ * Every permission-bearing kind resolves through its own Expo module — no
+ * single "permissions package" exists, so each kind names the one Expo module
+ * that owns it and is required lazily, the same discipline every other Expo
+ * surface in this library follows (an app that never asks for a permission
+ * never names its package to Metro). `bluetooth` and `storage` have no Expo
+ * module at all; they resolve through `setPermissionsImplementation` only,
+ * same as the test/showcase injection seam every other surface has.
  *
- * `resolved` goes FALSE on null, never true. Marking it resolved with a null
- * backend would permanently disable permissions: the resolver short-circuits and the
- * real module is never loaded again, which contradicts this function's own
- * documented contract. That exact bug shipped once, in the storage seam.
+ */
+let backend = null;
+
+/**
+ * Inject a custom permissions backend at runtime. Pass `null` to reset to the
+ * default per-kind Expo resolution.
  *
- * THIS MODULE IS THE EXPO-FIRST EXCEPTION, and deliberately keeps the old
- * shape. Expo ships no permissions package: each module carries its own
- * (expo-location's requestForegroundPermissionsAsync, expo-image-picker's, and
- * so on), so there is no single object to adapt and the library must not guess
- * which Expo modules an app installed. react-native-permissions stays, behind
- * this module's own import path so an app that never asks for permissions
- * never names the package to Metro.
+ * Two legitimate reasons to call this: tests/the showcase reaching a denied,
+ * blocked or unavailable path a healthy device never takes; and an app that
+ * genuinely needs `bluetooth` or `storage`, which no Expo module covers.
  */
 export const setPermissionsImplementation = impl => {
-  permsModule = impl;
-  resolved = impl !== null;
+  backend = impl;
 };
-const mapToNative = kind => {
-  const m = resolveModule();
-  if (!m) {
-    return null;
-  }
-  const {
-    IOS,
-    ANDROID
-  } = m.PERMISSIONS;
-  if (Platform.OS === 'ios') {
+const resolveExpoModule = kind => {
+  try {
     switch (kind) {
       case 'camera':
-        return IOS.CAMERA ?? null;
+        {
+          const m = require('expo-camera');
+          return {
+            check: m.getCameraPermissionsAsync,
+            request: m.requestCameraPermissionsAsync
+          };
+        }
       case 'microphone':
-        return IOS.MICROPHONE ?? null;
+        {
+          const m = require('expo-camera');
+          return {
+            check: m.getMicrophonePermissionsAsync,
+            request: m.requestMicrophonePermissionsAsync
+          };
+        }
       case 'photos':
-        return IOS.PHOTO_LIBRARY ?? null;
+        {
+          const m = require('expo-image-picker');
+          return {
+            check: () => m.getMediaLibraryPermissionsAsync(false),
+            request: () => m.requestMediaLibraryPermissionsAsync(false)
+          };
+        }
       case 'photosAdd':
-        return IOS.PHOTO_LIBRARY_ADD_ONLY ?? null;
+        {
+          const m = require('expo-image-picker');
+          return {
+            check: () => m.getMediaLibraryPermissionsAsync(true),
+            request: () => m.requestMediaLibraryPermissionsAsync(true)
+          };
+        }
       case 'mediaLibrary':
-        return IOS.MEDIA_LIBRARY ?? null;
+        {
+          const m = require('expo-media-library');
+          return {
+            check: m.getPermissionsAsync,
+            request: m.requestPermissionsAsync
+          };
+        }
       case 'location':
-        return IOS.LOCATION_WHEN_IN_USE ?? null;
+        {
+          const m = require('expo-location');
+          return {
+            check: m.getForegroundPermissionsAsync,
+            request: m.requestForegroundPermissionsAsync
+          };
+        }
       case 'locationAlways':
-        return IOS.LOCATION_ALWAYS ?? null;
+        {
+          const m = require('expo-location');
+          return {
+            check: m.getBackgroundPermissionsAsync,
+            request: m.requestBackgroundPermissionsAsync
+          };
+        }
       case 'contacts':
-        return IOS.CONTACTS ?? null;
+        {
+          const m = require('expo-contacts');
+          return {
+            check: m.getPermissionsAsync,
+            request: m.requestPermissionsAsync
+          };
+        }
       case 'calendar':
-        return IOS.CALENDARS ?? null;
+        {
+          const m = require('expo-calendar');
+          return {
+            check: m.getCalendarPermissionsAsync,
+            request: m.requestCalendarPermissionsAsync
+          };
+        }
       case 'reminders':
-        return IOS.REMINDERS ?? null;
+        {
+          const m = require('expo-calendar');
+          return {
+            check: m.getRemindersPermissionsAsync,
+            request: m.requestRemindersPermissionsAsync
+          };
+        }
       case 'notifications':
-        return null;
-      // handled separately on iOS
+        {
+          const m = require('expo-notifications');
+          return {
+            check: m.getPermissionsAsync,
+            request: m.requestPermissionsAsync
+          };
+        }
       case 'bluetooth':
-        return IOS.BLUETOOTH ?? null;
       case 'storage':
+        // No Expo module covers either — the injected backend is the only path.
         return null;
       default:
         return null;
     }
-  }
-  switch (kind) {
-    case 'camera':
-      return ANDROID.CAMERA ?? null;
-    case 'microphone':
-      return ANDROID.RECORD_AUDIO ?? null;
-    case 'photos':
-    case 'mediaLibrary':
-      return ANDROID.READ_MEDIA_IMAGES ?? ANDROID.READ_EXTERNAL_STORAGE ?? null;
-    case 'photosAdd':
-      return ANDROID.READ_MEDIA_IMAGES ?? null;
-    case 'location':
-    case 'locationAlways':
-      return ANDROID.ACCESS_FINE_LOCATION ?? null;
-    case 'contacts':
-      return ANDROID.READ_CONTACTS ?? null;
-    case 'calendar':
-      return ANDROID.READ_CALENDAR ?? null;
-    case 'reminders':
-      return null;
-    case 'notifications':
-      return ANDROID.POST_NOTIFICATIONS ?? null;
-    case 'bluetooth':
-      return ANDROID.BLUETOOTH_CONNECT ?? null;
-    case 'storage':
-      return ANDROID.WRITE_EXTERNAL_STORAGE ?? null;
-    default:
-      return null;
+  } catch {
+    return null;
   }
 };
-const mapResult = raw => {
-  const m = resolveModule();
-  if (!m || !raw) {
+const toStatus = response => {
+  if (!response) {
     return 'unavailable';
   }
-  const {
-    RESULTS
-  } = m;
-  if (raw === RESULTS.GRANTED) {
-    return 'granted';
-  }
-  if (raw === RESULTS.DENIED) {
-    return 'denied';
-  }
-  if (raw === RESULTS.LIMITED) {
+  if (response.accessPrivileges === 'limited') {
     return 'limited';
   }
-  if (raw === RESULTS.BLOCKED) {
-    return 'blocked';
+  if (response.status === 'granted') {
+    return 'granted';
+  }
+  if (response.status === 'denied') {
+    return response.canAskAgain ? 'denied' : 'blocked';
   }
-  return 'unavailable';
+  // 'undetermined' — never asked yet. Treated as 'denied' so callers using
+  // Permissions.ensure() correctly trigger a request() rather than stalling.
+  return 'denied';
 };
 const checkPermission = async kind => {
-  const m = resolveModule();
-  if (!m) {
-    return 'unavailable';
+  if (backend) {
+    return backend.check(kind);
   }
-  const native = mapToNative(kind);
-  if (!native) {
+  const fns = resolveExpoModule(kind);
+  if (!fns) {
     return 'unavailable';
   }
   try {
-    const raw = await m.check(native);
-    return mapResult(raw);
+    return toStatus(await fns.check());
   } catch (error) {
     Logger.error(`[permissions] check(${kind}) failed`, error);
     return 'unavailable';
   }
 };
 const requestPermission = async kind => {
-  const m = resolveModule();
-  if (!m) {
-    return 'unavailable';
+  if (backend) {
+    return backend.request(kind);
   }
-  const native = mapToNative(kind);
-  if (!native) {
+  const fns = resolveExpoModule(kind);
+  if (!fns) {
     return 'unavailable';
   }
   try {
-    const raw = await m.request(native);
-    return mapResult(raw);
+    return toStatus(await fns.request());
   } catch (error) {
     Logger.error(`[permissions] request(${kind}) failed`, error);
     return 'unavailable';
   }
 };
 const openAppSettings = async () => {
-  const m = resolveModule();
-  if (!m) {
-    try {
-      await Linking.openSettings();
-      return true;
-    } catch (error) {
-      Logger.error('[permissions] openAppSettings fallback failed', error);
-      return false;
-    }
-  }
   try {
-    await m.openSettings();
+    await Linking.openSettings();
     return true;
   } catch (error) {
-    Logger.error('[permissions] openSettings failed', error);
+    Logger.error('[permissions] openAppSettings failed', error);
     return false;
   }
 };
 
 /**
  * Cross-platform permissions wrapper. Maps an abstract `PermissionKind`
- * (camera, photos, location, notifications, …) to the right
- * iOS / Android permission string under the hood.
- *
- * Requires `react-native-permissions` as an optional peer dependency;
- * when missing, every check/request resolves to `'unavailable'`.
+ * (camera, photos, location, notifications, …) to the Expo module that owns
+ * it under the hood — expo-camera, expo-image-picker, expo-location,
+ * expo-contacts, expo-calendar, expo-notifications, expo-media-library. Every
+ * one is an optional peer, required lazily; an app installs only the modules
+ * whose kinds it actually asks for.
  */
 export const Permissions = {
   check: checkPermission,

package/lib/module/smsRetriever/index.js

@@ -0,0 +1,86 @@
+"use strict";
+
+import { DeviceEventEmitter, Platform } from 'react-native';
+import { Logger } from "../logger/index.js";
+const OTP_EVENT = 'WeborityMobileCoreSmsRetrieved';
+const ERROR_EVENT = 'WeborityMobileCoreSmsRetrieverError';
+let backend = null;
+
+/** Test-only injection point. Pass `null` to reset to the native module. */
+export const setSmsRetrieverImplementation = impl => {
+  backend = impl;
+};
+let nativeModule;
+const resolveNativeModule = () => {
+  if (nativeModule !== undefined) {
+    return nativeModule;
+  }
+  if (Platform.OS !== 'android') {
+    nativeModule = null;
+    return null;
+  }
+  try {
+    nativeModule = require('../specs/NativeSmsRetriever').default ?? null;
+  } catch (error) {
+    Logger.warn('[smsRetriever] native module not available', error);
+    nativeModule = null;
+  }
+  return nativeModule ?? null;
+};
+const defaultBackend = {
+  getAppHash: async () => {
+    const m = resolveNativeModule();
+    if (!m) {
+      throw new Error('[smsRetriever] getAppHash: native module unavailable (Android only).');
+    }
+    return m.getAppHash();
+  },
+  startListening: (onMessage, onError) => {
+    const m = resolveNativeModule();
+    if (!m) {
+      onError?.({
+        type: 'SERVICE_UNAVAILABLE',
+        message: 'SMS Retriever is Android-only, or the native module is not linked.'
+      });
+      return {
+        remove: () => undefined
+      };
+    }
+    const messageSub = DeviceEventEmitter.addListener(OTP_EVENT, payload => onMessage(payload.message));
+    const errorSub = onError ? DeviceEventEmitter.addListener(ERROR_EVENT, payload => onError(payload)) : null;
+    try {
+      m.startSMSListener();
+    } catch (error) {
+      Logger.error('[smsRetriever] startSMSListener failed', error);
+    }
+    return {
+      remove: () => {
+        messageSub.remove();
+        errorSub?.remove();
+        try {
+          m.stopSMSListener();
+        } catch (error) {
+          Logger.error('[smsRetriever] stopSMSListener failed', error);
+        }
+      }
+    };
+  }
+};
+
+/**
+ * The Play Services SMS Retriever API — auto-reads an incoming OTP SMS with
+ * no SMS permission, matched by an 11-character app-signature hash
+ * (`getAppHash`) the backend appends to the message. Android only; every
+ * method is safe to call on iOS and resolves/reports unavailable rather than
+ * throwing, so a caller doesn't need a platform check at every call site.
+ *
+ * OTP extraction is left to the caller — `onMessage` receives the raw SMS
+ * text, since the expected OTP format (digit count, prefix) is a backend
+ * concern, not this module's.
+ */
+export const SmsRetriever = {
+  isAvailable: () => resolveNativeModule() !== null,
+  getAppHash: () => (backend ?? defaultBackend).getAppHash(),
+  startListening: (onMessage, onError) => (backend ?? defaultBackend).startListening(onMessage, onError)
+};
+//# sourceMappingURL=index.js.map

package/lib/module/specs/NativeSmsRetriever.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * Android-only — the Play Services SMS Retriever API has no iOS equivalent.
+ * The JS wrapper in `smsRetriever/index.ts` never touches this module on
+ * iOS, so `getEnforcing` only ever runs on Android, where autolinking has
+ * registered `SmsRetrieverPackage`.
+ */
+
+export default TurboModuleRegistry.getEnforcing('WeborityMobileCoreSmsRetriever');
+//# sourceMappingURL=NativeSmsRetriever.js.map