@lotics/app-sdk 0.100.1 → 0.101.1

package/dist/src/geolocation.js

@@ -1,96 +0,0 @@
-/**
- * Device location for geofenced app actions.
- *
- * The host grants the app iframe the `geolocation` Permissions-Policy, so app
- * code reads the device position directly through the browser — no RPC bridge.
- * This module wraps that with permission handling, a timeout, and a geofence
- * check, and returns a STRUCTURED outcome (`denied` / `unavailable` / `outside`)
- * so the app renders its own guidance. A terse, untranslated "permission denied"
- * dead-end is the single biggest reason a geofenced check-in fails in the field,
- * so the messaging belongs to the app, not buried in here.
- *
- * Self-contained on purpose: `@lotics/app-sdk` is published to npm with a minimal
- * dependency set and cannot pull in the private `@lotics/shared`, so the haversine
- * lives here rather than being imported.
- */
-const EARTH_RADIUS_M = 6_371_000;
-function toRadians(degrees) {
-    return (degrees * Math.PI) / 180;
-}
-/** Great-circle distance between two coordinates, in meters (haversine). */
-function distanceMeters(lat1, lon1, lat2, lon2) {
-    const dLat = toRadians(lat2 - lat1);
-    const dLon = toRadians(lon2 - lon1);
-    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-        Math.cos(toRadians(lat1)) * Math.cos(toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
-    return EARTH_RADIUS_M * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-}
-/** True when `[latitude, longitude]` falls within `zone`'s radius of its center. */
-export function isWithinZone(latitude, longitude, zone) {
-    const [centerLat, centerLon] = zone.coordinates;
-    return distanceMeters(latitude, longitude, centerLat, centerLon) <= zone.radius;
-}
-async function readPermissionState() {
-    // The Permissions API is unavailable on some browsers (notably older Safari);
-    // fall back to `null` and let `getCurrentPosition` surface the real state.
-    if (typeof navigator === "undefined" || !navigator.permissions?.query)
-        return null;
-    try {
-        const status = await navigator.permissions.query({ name: "geolocation" });
-        return status.state;
-    }
-    catch {
-        return null;
-    }
-}
-function getPosition(timeoutMs) {
-    return new Promise((resolve, reject) => {
-        navigator.geolocation.getCurrentPosition(resolve, reject, {
-            enableHighAccuracy: false,
-            timeout: timeoutMs,
-            maximumAge: 0,
-        });
-    });
-}
-/**
- * Get the device position and check it against the allowed zones.
- *
- * Returns `{ ok: true, coords }` when a fix lands inside any zone — the app can
- * forward `coords` to a workflow to record where the action happened. Otherwise
- * `{ ok: false, reason }`; render guidance per `reason`. An empty `zones` array
- * means "no geofence" and resolves `ok` with the raw position (use it for a
- * plain location read).
- *
- * ```tsx
- * const r = await requestGeofencedLocation(DEPOTS);
- * if (!r.ok) return showGeofenceError(r.reason);
- * await chamCong();
- * ```
- */
-export async function requestGeofencedLocation(zones, opts) {
-    const timeoutMs = opts?.timeoutMs ?? 15_000;
-    if (typeof navigator === "undefined" || !navigator.geolocation) {
-        return { ok: false, reason: "unavailable" };
-    }
-    // Fast-path a hard denial: once blocked, the browser will not re-prompt, so
-    // calling getCurrentPosition would just hang until the timeout.
-    if ((await readPermissionState()) === "denied") {
-        return { ok: false, reason: "denied" };
-    }
-    let position;
-    try {
-        position = await getPosition(timeoutMs);
-    }
-    catch (err) {
-        const code = err?.code;
-        // 1 = PERMISSION_DENIED; 2 = POSITION_UNAVAILABLE; 3 = TIMEOUT.
-        return { ok: false, reason: code === 1 ? "denied" : "unavailable" };
-    }
-    const coords = {
-        latitude: position.coords.latitude,
-        longitude: position.coords.longitude,
-        accuracy: position.coords.accuracy,
-    };
-    const inside = zones.length === 0 || zones.some((z) => isWithinZone(coords.latitude, coords.longitude, z));
-    return inside ? { ok: true, coords } : { ok: false, reason: "outside" };
-}