@webority-technologies/mobile-core 0.0.5 → 0.0.7

package/lib/commonjs/permissions/index.js

@@ -8,199 +8,198 @@ var _reactNative = require("react-native");
 var _index = require("../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 {
-    _index.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.
  */
 const setPermissionsImplementation = impl => {
-  permsModule = impl;
-  resolved = impl !== null;
+  backend = impl;
 };
 exports.setPermissionsImplementation = setPermissionsImplementation;
-const mapToNative = kind => {
-  const m = resolveModule();
-  if (!m) {
-    return null;
-  }
-  const {
-    IOS,
-    ANDROID
-  } = m.PERMISSIONS;
-  if (_reactNative.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) {
     _index.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) {
     _index.Logger.error(`[permissions] request(${kind}) failed`, error);
     return 'unavailable';
   }
 };
 const openAppSettings = async () => {
-  const m = resolveModule();
-  if (!m) {
-    try {
-      await _reactNative.Linking.openSettings();
-      return true;
-    } catch (error) {
-      _index.Logger.error('[permissions] openAppSettings fallback failed', error);
-      return false;
-    }
-  }
   try {
-    await m.openSettings();
+    await _reactNative.Linking.openSettings();
     return true;
   } catch (error) {
-    _index.Logger.error('[permissions] openSettings failed', error);
+    _index.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.
  */
 const Permissions = exports.Permissions = {
   check: checkPermission,

package/lib/commonjs/smsRetriever/index.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setSmsRetrieverImplementation = exports.SmsRetriever = void 0;
+var _reactNative = require("react-native");
+var _index = require("../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. */
+const setSmsRetrieverImplementation = impl => {
+  backend = impl;
+};
+exports.setSmsRetrieverImplementation = setSmsRetrieverImplementation;
+let nativeModule;
+const resolveNativeModule = () => {
+  if (nativeModule !== undefined) {
+    return nativeModule;
+  }
+  if (_reactNative.Platform.OS !== 'android') {
+    nativeModule = null;
+    return null;
+  }
+  try {
+    nativeModule = require('../specs/NativeSmsRetriever').default ?? null;
+  } catch (error) {
+    _index.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 = _reactNative.DeviceEventEmitter.addListener(OTP_EVENT, payload => onMessage(payload.message));
+    const errorSub = onError ? _reactNative.DeviceEventEmitter.addListener(ERROR_EVENT, payload => onError(payload)) : null;
+    try {
+      m.startSMSListener();
+    } catch (error) {
+      _index.Logger.error('[smsRetriever] startSMSListener failed', error);
+    }
+    return {
+      remove: () => {
+        messageSub.remove();
+        errorSub?.remove();
+        try {
+          m.stopSMSListener();
+        } catch (error) {
+          _index.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.
+ */
+const SmsRetriever = exports.SmsRetriever = {
+  isAvailable: () => resolveNativeModule() !== null,
+  getAppHash: () => (backend ?? defaultBackend).getAppHash(),
+  startListening: (onMessage, onError) => (backend ?? defaultBackend).startListening(onMessage, onError)
+};
+//# sourceMappingURL=index.js.map

package/lib/commonjs/specs/NativeSmsRetriever.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("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`.
+ */
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('WeborityMobileCoreSmsRetriever');
+//# sourceMappingURL=NativeSmsRetriever.js.map

package/lib/commonjs/sqlite/index.js

@@ -9,40 +9,25 @@ var _index = require("../logger/index.js");
 var _expo = require("./adapters/expo.js");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /**
- * This module names NO native package. Metro resolves requires statically, so a
- * driver named here would be bundled by every consumer and would have to be
- * installed by every app, whichever driver it actually chose. Each driver lives
- * behind its own import path, and the app wires one at startup:
- *
- *   import { setSqliteImplementation } from '@webority-technologies/mobile-core/sqlite';
- *   import { opSqliteDriver } from '@webority-technologies/mobile-core/sqlite/op';
- *   setSqliteImplementation(opSqliteDriver());
- *
- * Supported entry points: /sqlite/op, /sqlite/nitro, /sqlite/quick,
- * /sqlite/storage. Any object matching SqliteDriver also works.
+ * expo-sqlite is the fleet's only sanctioned SQLite driver (react-native.md:
+ * "we will always use expo-sqlite, what Expo gives, we don't look elsewhere
+ * ever") — this module resolves it automatically, with no app-side wiring.
+ * `setSqliteImplementation` still exists, narrowed to tests and the showcase:
+ * it injects a denying/failing backend to reach error paths a healthy device
+ * never takes, the same pattern every other injectable surface in this
+ * library follows. It is not a way to pick an alternate real driver.
  */
 
 /** Only what a test or an app injected; null means use expo-sqlite. */
 let backend = null;
 
-/**
- * expo-sqlite, adapted once and memoised.
- *
- * Unlike the other surfaces this one keeps a real reason to inject: an app with
- * an existing database on another driver (op-sqlite, nitro, quick,
- * sqlite-storage) can hand it over, and those entry points stay published for
- * exactly that. expo-sqlite is simply what happens when nobody does.
- */
+/** expo-sqlite, adapted once and memoised. The only driver this module resolves. */
 let expoDriver;
 
 /**
- * Inject the SQLite driver. Pass `null` to clear it.
- *
- * `@webority-technologies/mobile-core` ships no database: it is pure JavaScript
- * and defines only this interface. Wire a driver once at startup:
- *
- *   import { opSqliteDriver } from '@webority-technologies/mobile-core/sqlite/op';
- *   setSqliteImplementation(opSqliteDriver());
+ * Test/showcase-only injection point — see the module header. Not a way to
+ * pick an alternate real driver; `@webority-technologies/mobile-core` always
+ * resolves expo-sqlite when nothing is injected. Pass `null` to clear it.
  */
 const setSqliteImplementation = impl => {
   backend = impl;
@@ -62,10 +47,7 @@ exports.isSqliteAvailable = isSqliteAvailable;
 const requireBackend = op => {
   const b = resolveDriver();
   if (!b) {
-    // Naming the SETTER and an import path, not just packages to install:
-    // installing a driver alone does nothing here, and the previous wording
-    // ("Install one of ...") sent people to fix a thing that was not broken.
-    const err = new Error(`[@webority-technologies/mobile-core] No SQLite driver injected; cannot ${op}. ` + 'Install a driver and wire it once at startup, e.g. ' + "`import { opSqliteDriver } from '@webority-technologies/mobile-core/sqlite/op'` " + 'then `setSqliteImplementation(opSqliteDriver())`. Drivers: @op-engineering/op-sqlite ' + '(recommended), expo-sqlite, react-native-nitro-sqlite, react-native-quick-sqlite, ' + 'react-native-sqlite-storage.');
+    const err = new Error(`[@webority-technologies/mobile-core] No SQLite driver available; cannot ${op}. ` + 'Install expo-sqlite (the only sanctioned driver) in the consuming app.');
     _index.Logger.error(err.message);
     throw err;
   }

package/lib/module/formatters/dateMath.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { WINDOWS_TO_IANA } from "./windowsToIanaTable.js";
 const toDate = value => {
   if (value instanceof Date) {
     return Number.isNaN(value.getTime()) ? null : value;
@@ -274,4 +275,20 @@ export const formatTimeInZone = (value, ianaTimeZone) => {
   const period = get('dayPeriod').toLowerCase();
   return `${PAD(hour)}:${minute} ${period}`;
 };
+
+/**
+ * Same as {@link formatTimeInZone}, but for a .NET-style Windows timezone ID
+ * (e.g. `"India Standard Time"`) rather than an IANA one. .NET's own
+ * `TimeZoneInfo` API only knows Windows IDs, so a backend built on it hands
+ * these to clients directly — `Intl`, by contrast, only recognises IANA
+ * names, so the ID has to be translated before it can be used here. Throws
+ * if `windowsTimeZoneId` has no known IANA mapping.
+ */
+export const formatTimeInWindowsZone = (value, windowsTimeZoneId) => {
+  const ianaTimeZone = WINDOWS_TO_IANA[windowsTimeZoneId];
+  if (!ianaTimeZone) {
+    throw new Error(`Mapping for Windows time zone '${windowsTimeZoneId}' not found.`);
+  }
+  return formatTimeInZone(value, ianaTimeZone);
+};
 //# sourceMappingURL=dateMath.js.map

package/lib/module/formatters/index.js

@@ -2,7 +2,7 @@
 
 export { formatCurrency } from "./currency.js";
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from "./date.js";
-export { addDays, diffMs, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatTime12h, formatTimeInZone, isDateAfter, isDateBefore, isSameDay, startOfDay } from "./dateMath.js";
+export { addDays, diffMs, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, isDateAfter, isDateBefore, isSameDay, startOfDay } from "./dateMath.js";
 export { getInitials } from "./initials.js";
 export { formatCompactNumber, formatNumber, formatPercent } from "./number.js";
 export { detectPhoneCountry, formatPhone, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from "./phone.js";