@webority-technologies/mobile-core 0.0.1 → 0.0.2

package/lib/commonjs/geolocation/index.js

@@ -0,0 +1,339 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCurrentPosition = exports.setGeolocationImplementation = exports.GeolocationError = exports.Geolocation = void 0;
+var ExpoLocation = _interopRequireWildcard(require("expo-location"));
+var _react = require("react");
+var _index = require("../logger/index.js");
+var _index2 = require("../permissions/index.js");
+var _expoLocation2 = require("./adapters/expoLocation.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); }
+const PREFIX = '[@webority-technologies/mobile-core]';
+class GeolocationError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'GeolocationError';
+    this.code = code;
+    // Babel downlevels `class extends Error`, which breaks `instanceof` for
+    // subclasses unless the prototype is restored explicitly.
+    Object.setPrototypeOf(this, GeolocationError.prototype);
+  }
+}
+
+/** Minimal shape of the native geolocation module we depend on. */
+exports.GeolocationError = GeolocationError;
+const DEFAULT_TIMEOUT_MS = 15000;
+const DEFAULT_RETRIES = 1;
+const DEFAULT_RETRY_DELAY_MS = 800;
+const isGeolocationLike = value => {
+  const candidate = value;
+  return typeof candidate?.getCurrentPosition === 'function' && typeof candidate?.watchPosition === 'function' && typeof candidate?.clearWatch === 'function';
+};
+
+/** Only what a test or the showcase injected; null means use expo-location. */
+let backend = null;
+let expoBackend;
+const resolveBackend = () => {
+  if (backend) {
+    return backend;
+  }
+  if (!expoBackend) {
+    expoBackend = (0, _expoLocation2.adaptExpoLocation)(ExpoLocation);
+  }
+  return expoBackend;
+};
+
+/**
+ * Replace the geolocation provider. Intended for TESTS and for the showcase,
+ * which injects a denying provider to demo the permission and services-off
+ * errors; an app gets expo-location without wiring anything. Pass `null` to
+ * restore it.
+ */
+const setGeolocationImplementation = impl => {
+  backend = impl;
+};
+exports.setGeolocationImplementation = setGeolocationImplementation;
+const requireBackend = op => {
+  const b = resolveBackend();
+  if (!b) {
+    throw new GeolocationError('unsupported', `${PREFIX} No geolocation provider is available; cannot ${op}. ` + 'expo-location did not load, which on a real build means the native ' + 'module was not linked.');
+  }
+  return b;
+};
+
+/**
+ * Android reports "location services are switched off" through the same code 2
+ * that also covers a genuine failure to fix a position, and the two need
+ * different handling: one is fixed by the user in system settings, the other is
+ * worth retrying. The message is the only signal that separates them.
+ */
+const SERVICES_OFF_PATTERN = /(location|gps)[^.]{0,40}(disabled|switched off|turned off|not enabled)|no location provider|settings_not_satisfied|location services (are |is )?off/i;
+const toGeoError = raw => {
+  if (raw instanceof GeolocationError) {
+    return raw;
+  }
+  const native = raw ?? {};
+  const detail = typeof native.message === 'string' && native.message.length > 0 ? native.message : 'the provider gave no reason';
+  switch (native.code) {
+    case 1:
+      return new GeolocationError('permission-denied', `${PREFIX} Location permission was denied (${detail}). Request the ` + 'location permission before calling, or send the user to settings.');
+    case 2:
+      return SERVICES_OFF_PATTERN.test(detail) ? new GeolocationError('services-disabled', `${PREFIX} Location services are switched off (${detail}). Ask the user ` + 'to enable location in system settings; retrying will not help.') : new GeolocationError('position-unavailable', `${PREFIX} No position fix (${detail}).`);
+    case 3:
+      return new GeolocationError('timeout', `${PREFIX} Location request timed out (${detail}).`);
+    case 4:
+    case 5:
+      return new GeolocationError('services-disabled', `${PREFIX} Location services are unavailable on this device (${detail}). ` + 'Ask the user to enable location, or install Google Play services.');
+    default:
+      return new GeolocationError('position-unavailable', `${PREFIX} Location request failed (${detail}).`);
+  }
+};
+const RETRYABLE = ['timeout', 'position-unavailable'];
+const normalizeCoords = raw => {
+  const coords = raw?.coords;
+  if (!coords || !Number.isFinite(coords.latitude) || !Number.isFinite(coords.longitude)) {
+    return null;
+  }
+  return {
+    latitude: coords.latitude,
+    longitude: coords.longitude,
+    // An absent radius is treated as infinitely bad rather than perfect, so a
+    // provider that omits it can never satisfy `minimumAccuracyM` by accident.
+    accuracy: Number.isFinite(coords.accuracy) ? coords.accuracy : Number.POSITIVE_INFINITY,
+    altitude: Number.isFinite(coords.altitude) ? coords.altitude : null,
+    heading: Number.isFinite(coords.heading) ? coords.heading : null,
+    speed: Number.isFinite(coords.speed) ? coords.speed : null
+  };
+};
+const normalizePosition = raw => {
+  const coords = normalizeCoords(raw);
+  if (!coords) {
+    return null;
+  }
+  return {
+    coords,
+    timestamp: Number.isFinite(raw?.timestamp) ? raw?.timestamp : Date.now()
+  };
+};
+const toNativeOptions = options => {
+  const native = {
+    enableHighAccuracy: (options.accuracy ?? 'fine') === 'fine',
+    timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maximumAge: options.maximumAgeMs ?? 0
+  };
+  if (options.distanceFilterM !== undefined) {
+    native.distanceFilter = options.distanceFilterM;
+  }
+  return native;
+};
+const sleep = ms => new Promise(resolve => {
+  setTimeout(resolve, ms);
+});
+const ensureLocationPermission = async () => {
+  const status = await _index2.Permissions.ensure('location');
+  if (status === 'granted' || status === 'limited') {
+    return;
+  }
+  if (status === 'unavailable') {
+    _index.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.');
+    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.' : '.'));
+};
+const positionOnce = (b, options) => {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    // The native timeout is passed through as well, but a provider that never
+    // calls back at all would otherwise hang the caller forever.
+    const timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(new GeolocationError('timeout', `${PREFIX} Location request timed out after ${timeoutMs}ms. Raise timeoutMs, or use ` + "accuracy: 'coarse' where a network fix is good enough."));
+    }, timeoutMs);
+    const settle = run => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      run();
+    };
+    const onSuccess = raw => settle(() => {
+      const position = normalizePosition(raw);
+      if (!position) {
+        reject(new GeolocationError('position-unavailable', `${PREFIX} The provider returned a fix without usable coordinates.`));
+        return;
+      }
+      const floor = options.minimumAccuracyM;
+      if (floor !== undefined && position.coords.accuracy > floor) {
+        reject(new GeolocationError('position-unavailable', `${PREFIX} Fix accuracy ${position.coords.accuracy}m is worse than the required ` + `${floor}m.`));
+        return;
+      }
+      resolve(position);
+    });
+    const onError = error => settle(() => reject(toGeoError(error)));
+    try {
+      b.getCurrentPosition(onSuccess, onError, toNativeOptions(options));
+    } catch (error) {
+      settle(() => reject(toGeoError(error)));
+    }
+  });
+};
+const getCurrentPosition = async (options = {}) => {
+  const b = requireBackend('get the current position');
+  await ensureLocationPermission();
+  const attempts = Math.max(0, Math.trunc(options.retries ?? DEFAULT_RETRIES)) + 1;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  let lastError = null;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      return await positionOnce(b, options);
+    } catch (error) {
+      const geoError = toGeoError(error);
+      if (!RETRYABLE.includes(geoError.code)) {
+        throw geoError;
+      }
+      lastError = geoError;
+      if (attempt < attempts - 1 && retryDelayMs > 0) {
+        await sleep(retryDelayMs);
+      }
+    }
+  }
+  throw lastError ?? new GeolocationError('position-unavailable', `${PREFIX} Location request failed.`);
+};
+const watchPosition = (listener, options = {}) => {
+  const b = requireBackend('watch the position');
+  let cancelled = false;
+  let watchId = null;
+  const stop = () => {
+    if (cancelled) {
+      return;
+    }
+    cancelled = true;
+    if (watchId !== null) {
+      b.clearWatch(watchId);
+      watchId = null;
+    }
+  };
+  const fail = error => {
+    const geoError = toGeoError(error);
+    _index.Logger.error(geoError.message);
+    options.onError?.(geoError);
+  };
+  void ensureLocationPermission().then(() => {
+    // The caller can unsubscribe while the permission gate is still pending;
+    // registering afterwards would leak a watch nothing can clear.
+    if (cancelled) {
+      return;
+    }
+    watchId = b.watchPosition(raw => {
+      if (cancelled) {
+        return;
+      }
+      const position = normalizePosition(raw);
+      if (!position) {
+        return;
+      }
+      const floor = options.minimumAccuracyM;
+      if (floor !== undefined && position.coords.accuracy > floor) {
+        return;
+      }
+      listener(position);
+    }, error => {
+      if (!cancelled) {
+        fail(error);
+      }
+    }, toNativeOptions(options));
+  }).catch(fail);
+  return stop;
+};
+const isAvailable = () => resolveBackend() !== null;
+const Geolocation = exports.Geolocation = {
+  getCurrentPosition,
+  watchPosition,
+  isAvailable
+};
+const useCurrentPosition = (options = {}) => {
+  const {
+    enabled = true,
+    accuracy,
+    timeoutMs,
+    maximumAgeMs,
+    retries,
+    minimumAccuracyM,
+    retryDelayMs
+  } = options;
+  const [state, setState] = (0, _react.useState)({
+    position: null,
+    error: null,
+    loading: enabled
+  });
+  const mountedRef = (0, _react.useRef)(true);
+  // Identifies the in-flight request so a slow earlier fix cannot overwrite the
+  // result of a later refresh().
+  const requestRef = (0, _react.useRef)(0);
+  (0, _react.useEffect)(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+
+  // Every dependency is a primitive read off `options`, so an inline options
+  // object (the normal call shape) does not re-create this on every render.
+  const run = (0, _react.useCallback)(() => {
+    requestRef.current += 1;
+    const token = requestRef.current;
+    setState(prev => prev.loading ? prev : {
+      ...prev,
+      loading: true
+    });
+    const accept = next => {
+      if (mountedRef.current && requestRef.current === token) {
+        setState(next);
+      }
+    };
+    getCurrentPosition({
+      accuracy,
+      timeoutMs,
+      maximumAgeMs,
+      retries,
+      minimumAccuracyM,
+      retryDelayMs
+    }).then(position => accept({
+      position,
+      error: null,
+      loading: false
+    }), error => accept({
+      position: null,
+      error: toGeoError(error),
+      loading: false
+    }));
+  }, [accuracy, timeoutMs, maximumAgeMs, retries, minimumAccuracyM, retryDelayMs]);
+  (0, _react.useEffect)(() => {
+    if (!enabled) {
+      // Discard any in-flight request so its result cannot land after opting out.
+      requestRef.current += 1;
+      setState(prev => prev.loading || prev.position !== null || prev.error !== null ? {
+        position: null,
+        error: null,
+        loading: false
+      } : prev);
+      return;
+    }
+    run();
+  }, [enabled, run]);
+  return {
+    position: state.position,
+    error: state.error,
+    loading: state.loading,
+    refresh: run
+  };
+};
+exports.useCurrentPosition = useCurrentPosition;
+//# sourceMappingURL=index.js.map