@webority-technologies/mobile-core 0.0.1 → 0.0.3

package/lib/module/download/index.js

@@ -0,0 +1,264 @@
+"use strict";
+
+import * as ExpoFileSystem from 'expo-file-system';
+import { Linking, Platform } from 'react-native';
+import { ACCESS_TOKEN_KEY, getToken } from "../auth/authStore.js";
+import { Logger } from "../logger/index.js";
+import { Permissions } from "../permissions/index.js";
+import { adaptExpoFileSystem } from "./adapters/expoFs.js";
+import { asNumber } from "./adapters/shared.js";
+
+/**
+ * This module names NO native package, for the same reason as the SQLite core.
+ * The app wires a filesystem once at startup:
+ *
+ *   import { setFileSystemImplementation } from '@webority-technologies/mobile-core/download';
+ *   import { blobUtilFileSystem } from '@webority-technologies/mobile-core/download/blob-util';
+ *   setFileSystemImplementation(blobUtilFileSystem());
+ */
+
+const PREFIX = '[@webority-technologies/mobile-core]';
+
+/** Android stopped requiring a storage permission for a Downloads write at API 29. */
+const SCOPED_STORAGE_API_LEVEL = 29;
+
+/**
+ * The slice of a native filesystem module this module actually uses. Both
+ * `react-native-blob-util` and `react-native-fs` are adapted onto it, and an app
+ * can inject its own with `setFileSystemImplementation`.
+ */
+
+export class DownloadError extends Error {
+  constructor(code, message, status) {
+    super(`${PREFIX} ${message}`);
+    this.name = 'DownloadError';
+    this.code = code;
+    this.status = status;
+    // Babel's class transform can drop the prototype link, which makes
+    // `instanceof DownloadError` false in the transpiled build.
+    Object.setPrototypeOf(this, DownloadError.prototype);
+  }
+}
+const describe = error => error instanceof Error ? error.message : String(error);
+
+/** Only what a test or the showcase injected; null means use expo-file-system. */
+let backend = null;
+
+/**
+ * expo-file-system, adapted once and memoised. The adapter is shape-checked, so
+ * a build where the native module did not link returns null and the guided
+ * error below still fires rather than a confusing property access.
+ */
+let expoBackend;
+const resolveBackend = () => {
+  if (backend) {
+    return backend;
+  }
+  if (expoBackend === undefined) {
+    expoBackend = adaptExpoFileSystem(ExpoFileSystem);
+  }
+  return expoBackend;
+};
+
+/**
+ * Replace the filesystem backend. Intended for TESTS and for the showcase,
+ * which injects a denying backend to demo the permission error; an app gets
+ * expo-file-system without wiring anything. Pass `null` to restore it.
+ */
+export const setFileSystemImplementation = impl => {
+  backend = impl;
+};
+const requireBackend = () => {
+  const fs = resolveBackend();
+  if (!fs) {
+    throw new DownloadError('unsupported', 'No filesystem module is available, so files cannot be downloaded. ' + 'expo-file-system did not load, which on a real build means the native module ' + 'was not linked.');
+  }
+  return fs;
+};
+const stripControlChars = value => Array.from(value).filter(char => (char.codePointAt(0) ?? 0) > 0x1f).join('');
+const lastSegment = raw => {
+  const segments = raw.split(/[/\\]/);
+  return stripControlChars(segments[segments.length - 1] ?? '').trim();
+};
+
+/**
+ * Reduce a caller- or server-supplied name to a single path segment: `../../evil.pdf`
+ * must land inside the destination directory as `evil.pdf` rather than escaping it.
+ */
+const sanitiseFileName = raw => {
+  const base = lastSegment(raw);
+  if (base === '' || base === '.' || base === '..') {
+    throw new DownloadError('write-failed', `"${raw}" does not contain a usable file name. Pass an explicit fileName.`);
+  }
+  return base;
+};
+const fileNameFromUrl = url => {
+  const withoutQuery = url.split('#')[0]?.split('?')[0] ?? '';
+  const last = withoutQuery.split('/').pop() ?? '';
+  let decoded = last;
+  try {
+    decoded = decodeURIComponent(last);
+  } catch {
+    // A malformed escape sequence is not a reason to fail the download.
+  }
+  const base = lastSegment(decoded);
+  return base === '' || base === '.' || base === '..' ? 'download' : base;
+};
+const androidApiLevel = () => typeof Platform.Version === 'number' ? Platform.Version : Number.parseInt(String(Platform.Version), 10);
+const ensureStoragePermission = async destination => {
+  if (Platform.OS !== 'android' || destination !== 'downloads') {
+    return;
+  }
+  if (androidApiLevel() >= SCOPED_STORAGE_API_LEVEL) {
+    return;
+  }
+  const status = await Permissions.ensure('storage');
+  if (status === 'granted' || status === 'limited') {
+    return;
+  }
+  throw new DownloadError('permission-denied', `Storage permission is "${status}", so nothing can be written to the Downloads folder ` + 'on this Android version. Ask the user to grant it (Permissions.openSettings()), or ' + 'download to the "documents" destination instead.');
+};
+const buildHeaders = async options => {
+  const headers = {
+    ...options.headers
+  };
+  if (options.authenticated === false) {
+    return headers;
+  }
+  const stored = await getToken(ACCESS_TOKEN_KEY);
+  if (stored?.token) {
+    headers.Authorization = `Bearer ${stored.token}`;
+  }
+  return headers;
+};
+const discardPartial = async (fs, path) => {
+  try {
+    if (await fs.exists(path)) {
+      await fs.unlink(path);
+    }
+  } catch (error) {
+    Logger.warn(`${PREFIX} Failed to remove the partial download at ${path}`, error);
+  }
+};
+
+/**
+ * Download a file to the device, attaching the stored bearer token by default.
+ *
+ * A finished download is always verified to be non-empty: a 0-byte file looks
+ * like a success to every caller and then wedges whatever consumes it, so it is
+ * deleted and reported as `empty-file`.
+ */
+export const downloadFile = async options => {
+  const fs = requireBackend();
+  const destination = options.destination ?? 'documents';
+  const fileName = options.fileName ? sanitiseFileName(options.fileName) : fileNameFromUrl(options.url);
+  await ensureStoragePermission(destination);
+  const directory = fs.dirs[destination];
+  const path = `${directory}/${fileName}`;
+  if (options.signal?.aborted) {
+    throw new DownloadError('aborted', `The download of ${fileName} was aborted before it started.`);
+  }
+  let reuseExisting = false;
+  try {
+    await fs.mkdir(directory);
+    const exists = await fs.exists(path);
+    if (exists && options.overwrite === false) {
+      reuseExisting = true;
+    } else if (exists) {
+      await fs.unlink(path);
+    }
+  } catch (error) {
+    throw new DownloadError('write-failed', `Could not prepare ${path} for writing: ${describe(error)}`);
+  }
+  if (reuseExisting) {
+    const stat = await fs.stat(path);
+    return {
+      path,
+      bytes: asNumber(stat?.size),
+      mimeType: options.mimeType,
+      fromCache: true
+    };
+  }
+  const headers = await buildHeaders(options);
+  const {
+    onProgress
+  } = options;
+  const handle = fs.download({
+    url: options.url,
+    path,
+    headers,
+    onProgress: onProgress ? (received, total) => onProgress(received, total, total > 0 ? received / total : 0) : undefined
+  });
+  let aborted = false;
+  let rejectOnAbort = null;
+  // Raced against the transfer rather than relied upon to settle it: cancelling a
+  // native download is best-effort, and a backend whose promise never settles
+  // after cancel would otherwise leave the caller waiting forever.
+  const abortRequested = new Promise((_, reject) => {
+    rejectOnAbort = () => reject(new DownloadError('aborted', `The download of ${fileName} was aborted.`));
+  });
+  const onAbort = () => {
+    aborted = true;
+    handle.cancel?.();
+    rejectOnAbort?.();
+  };
+  options.signal?.addEventListener('abort', onAbort);
+  // The signal can fire between the aborted-check above and this listener being
+  // attached (token read, mkdir); a listener added after the fact never fires.
+  if (options.signal?.aborted) {
+    onAbort();
+  }
+  let status;
+  try {
+    ({
+      status
+    } = await Promise.race([handle.promise, abortRequested]));
+  } catch (error) {
+    await discardPartial(fs, path);
+    if (aborted || options.signal?.aborted) {
+      throw new DownloadError('aborted', `The download of ${fileName} was aborted.`);
+    }
+    throw new DownloadError('network', `The download of ${options.url} failed: ${describe(error)}`);
+  } finally {
+    options.signal?.removeEventListener('abort', onAbort);
+  }
+  if (aborted || options.signal?.aborted) {
+    await discardPartial(fs, path);
+    throw new DownloadError('aborted', `The download of ${fileName} was aborted.`);
+  }
+  if (status !== undefined && (status < 200 || status >= 300)) {
+    await discardPartial(fs, path);
+    throw new DownloadError('http-error', `The server answered ${status} for ${options.url}, so no file was saved.`, status);
+  }
+  let bytes = 0;
+  try {
+    bytes = (await fs.exists(path)) ? asNumber((await fs.stat(path)).size) : 0;
+  } catch (error) {
+    await discardPartial(fs, path);
+    throw new DownloadError('write-failed', `The download of ${fileName} finished but ${path} could not be read back: ${describe(error)}`);
+  }
+  if (bytes <= 0) {
+    await discardPartial(fs, path);
+    throw new DownloadError('empty-file', `The download of ${options.url} produced an empty file, which has been deleted. ` + 'Check that the URL is correct and that the request carried the credentials the ' + 'server expects.');
+  }
+  return {
+    path,
+    bytes,
+    mimeType: options.mimeType,
+    fromCache: false
+  };
+};
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+
+/**
+ * Hand a downloaded file to the OS, to open in whichever app claims it.
+ */
+export const openFile = async (path, mimeType) => {
+  const url = HAS_SCHEME.test(path) ? path : `file://${path}`;
+  try {
+    await Linking.openURL(url);
+  } catch (error) {
+    throw new DownloadError('unsupported', `No installed app could open ${url}${mimeType ? ` (${mimeType})` : ''}: ${describe(error)}`);
+  }
+};
+//# sourceMappingURL=index.js.map

package/lib/module/formatters/date.js

@@ -142,7 +142,7 @@ export const formatRelativeTime = (value, base = new Date(), locale = 'en-IN') =
     unit = 'year';
     amount = Math.round(diffMs / YEAR);
   }
-  const Rtf = Intl.RelativeTimeFormat;
+  const Rtf = hasIntl() ? Intl.RelativeTimeFormat : undefined;
   if (typeof Rtf === 'function') {
     try {
       return new Rtf(locale, {

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 { 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,16 @@
 "use strict";
 
+/**
+ * Real cross-country validation, re-exported rather than reimplemented.
+ * formatPhone/normalizePhone/detectPhoneCountry below are a fast, dependency-
+ * light DISPLAY formatter for a fixed set of countries; they are not a
+ * validator. Real phone number plans have country-specific area-code and
+ * mobile-prefix rules that only a maintained metadata table gets right -
+ * hand-rolling that risks silently-wrong validation for a country nobody
+ * tests against. Both live here so consumers get one phone module, not two.
+ */
+
+export { isValidPhoneNumber, parsePhoneNumber, parsePhoneNumberFromString } from 'libphonenumber-js';
 /**
  * Strip everything except digits and a leading `+` (preserved if present).
  */
@@ -20,14 +31,90 @@ const groupIndianMobile = 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.
+ */
+export const detectPhoneCountry = (input, defaultCountryCode = '+91') => {
+  const normalized = normalizePhone(input);
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.startsWith('+')) {
+    return findRuleByCallingCode(normalized.slice(1))?.country ?? null;
+  }
+  const normalizedDefault = normalizePhone(defaultCountryCode);
+  if (!normalizedDefault.startsWith('+')) {
+    return null;
+  }
+  return findRuleByCallingCode(normalizedDefault.slice(1))?.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.
+  const ccLen = rest.length > 11 ? 3 : rest.length > 10 ? 2 : 1;
+  const cc = rest.slice(0, ccLen);
+  const number = rest.slice(ccLen);
+  const grouped = number.replace(/(.{4})(?=.)/g, '$1 ').trim();
+  return `+${cc} ${grouped}`.trim();
+};
+
 /**
  * Format a phone number for human display.
  *
  * - 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.
  */
-export const formatPhone = (input, defaultCountryCode = '+91') => {
+
+export function formatPhone(input, arg) {
   if (!input) {
     return '';
   }
@@ -35,20 +122,30 @@ export const formatPhone = (input, defaultCountryCode = '+91') => {
   if (!normalized) {
     return '';
   }
-
-  // Already starts with +
+  const options = typeof arg === 'string' ? {} : arg ?? {};
+  const defaultCountryCode = typeof arg === 'string' ? arg : options.defaultCountryCode ?? '+91';
   if (normalized.startsWith('+')) {
     const rest = normalized.slice(1);
-    // Indian
-    if (rest.startsWith('91') && rest.length === 12) {
-      return `+91 ${groupIndianMobile(rest.slice(2))}`;
+    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;
+      }
     }
-    // Generic — split country code (first 1–3 digits) and group the rest in 4s.
-    const ccLen = rest.length > 11 ? 3 : rest.length > 10 ? 2 : 1;
-    const cc = rest.slice(0, ccLen);
-    const number = rest.slice(ccLen);
-    const grouped = number.replace(/(.{4})(?=.)/g, '$1 ').trim();
-    return `+${cc} ${grouped}`.trim();
+    return bestEffortGroup(rest);
+  }
+  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;
+    }
+    return normalized.replace(/(.{4})(?=.)/g, '$1 ').trim();
   }
 
   // No country code; assume default if length matches Indian mobile.
@@ -57,5 +154,5 @@ export const formatPhone = (input, defaultCountryCode = '+91') => {
   }
   // Otherwise just return groups of 4.
   return normalized.replace(/(.{4})(?=.)/g, '$1 ').trim();
-};
+}
 //# sourceMappingURL=phone.js.map

package/lib/module/geolocation/adapters/expoLocation.js

@@ -0,0 +1,121 @@
+"use strict";
+
+/**
+ * The slice of expo-location this adapter uses. Verified against 57.0.14.
+ *
+ * The REQUIRE lives in the entry point beside this file, never here.
+ */
+
+/**
+ * expo-location's Accuracy enum is numeric (`Balanced = 3`, `Highest = 5`,
+ * verified in Location.types.d.ts). The numbers are inlined rather than
+ * imported so this file names no expo module and stays bundlable by an app
+ * without expo installed.
+ */
+const ACCURACY_BALANCED = 3;
+const ACCURACY_HIGHEST = 5;
+const toExpoOptions = options => {
+  const expo = {
+    accuracy: options?.enableHighAccuracy ? ACCURACY_HIGHEST : ACCURACY_BALANCED
+  };
+  if (typeof options?.distanceFilter === 'number') {
+    expo.distanceInterval = options.distanceFilter;
+  }
+  return expo;
+};
+
+/**
+ * expo-location rejects with an Error; the seam expects the W3C-style numeric
+ * codes the RN geolocation modules use, which the library then maps to its own
+ * GeolocationError kinds. Classifying here rather than passing the raw Error
+ * through is what makes an expo-backed app produce the same `permission-denied`
+ * / `services-disabled` / `timeout` values as a NetInfo-backed one — which is
+ * the whole point of having a seam.
+ */
+const PERMISSION_PATTERN = /permission|denied|not (been )?granted|authoriz/i;
+const SERVICES_PATTERN = /location services|provider|disabled|switched off|turned off/i;
+const TIMEOUT_PATTERN = /time ?d? ?out|timeout/i;
+const toNativeError = raw => {
+  const message = raw instanceof Error ? raw.message : String(raw);
+  if (PERMISSION_PATTERN.test(message)) {
+    return {
+      code: 1,
+      message
+    };
+  }
+  if (TIMEOUT_PATTERN.test(message)) {
+    return {
+      code: 3,
+      message
+    };
+  }
+  // Code 2 covers both "services off" and "no fix". The library separates them
+  // by reading the message, so the message must travel intact — and where expo
+  // does not say "location services", the wording is normalised so it can.
+  if (SERVICES_PATTERN.test(message)) {
+    return {
+      code: 2,
+      message
+    };
+  }
+  return {
+    code: 2,
+    message
+  };
+};
+const toNativePosition = location => ({
+  coords: {
+    latitude: location.coords?.latitude ?? null,
+    longitude: location.coords?.longitude ?? null,
+    accuracy: location.coords?.accuracy ?? null,
+    altitude: location.coords?.altitude ?? null,
+    heading: location.coords?.heading ?? null,
+    speed: location.coords?.speed ?? null
+  },
+  timestamp: location.timestamp ?? null
+});
+
+/**
+ * Adapts expo-location to the library's geolocation seam.
+ *
+ * The interesting half is `watchPosition`. The seam must hand back a numeric
+ * watch id SYNCHRONOUSLY, while `watchPositionAsync` only resolves its
+ * subscription later. So the adapter mints its own id immediately and stores
+ * the subscription against it on arrival. `clearWatch` called during that
+ * window records the id as cancelled, and the subscription is removed the
+ * moment it lands — without that, a screen that unmounts before the watch
+ * starts leaks a live GPS listener for the rest of the session, which is a
+ * battery drain nobody would attribute to this code.
+ */
+export const adaptExpoLocation = mod => {
+  const subscriptions = new Map();
+  let nextWatchId = 1;
+  return {
+    getCurrentPosition: (onSuccess, onError, options) => {
+      mod.getCurrentPositionAsync(toExpoOptions(options)).then(location => onSuccess(toNativePosition(location))).catch(error => onError?.(toNativeError(error)));
+    },
+    watchPosition: (onSuccess, onError, options) => {
+      const watchId = nextWatchId++;
+      subscriptions.set(watchId, null);
+      mod.watchPositionAsync(toExpoOptions(options), location => onSuccess(toNativePosition(location))).then(subscription => {
+        if (!subscriptions.has(watchId)) {
+          // clearWatch already ran. Remove immediately rather than storing a
+          // subscription nothing will ever clear.
+          subscription.remove();
+          return;
+        }
+        subscriptions.set(watchId, subscription);
+      }).catch(error => {
+        subscriptions.delete(watchId);
+        onError?.(toNativeError(error));
+      });
+      return watchId;
+    },
+    clearWatch: watchId => {
+      const subscription = subscriptions.get(watchId);
+      subscriptions.delete(watchId);
+      subscription?.remove();
+    }
+  };
+};
+//# sourceMappingURL=expoLocation.js.map