@ateam-ai-mobile/expo 0.1.7 → 0.1.8

package/dist/device/createDeviceProvider.js

@@ -94,7 +94,7 @@ var init_cookies = __esm({
 var nfc_exports = {};
 __export(nfc_exports, {
   isEnabled: () => isEnabled,
-  isSupported: () => isSupported2,
+  isSupported: () => isSupported3,
   readOnce: () => readOnce
 });
 async function ensureInit() {
@@ -109,7 +109,7 @@ async function ensureInit() {
     return false;
   }
 }
-async function isSupported2() {
+async function isSupported3() {
   try {
     return await import_react_native_nfc_manager.default.isSupported();
   } catch {
@@ -177,7 +177,7 @@ __export(createDeviceProvider_exports, {
 });
 module.exports = __toCommonJS(createDeviceProvider_exports);
 var Haptics = __toESM(require("expo-haptics"));
-var ExpoLocation2 = __toESM(require("expo-location"));
+var ExpoLocation3 = __toESM(require("expo-location"));
 var ImagePicker = __toESM(require("expo-image-picker"));
 var Notifications = __toESM(require("expo-notifications"));
 var DocumentPicker = __toESM(require("expo-document-picker"));
@@ -312,6 +312,202 @@ async function detectObjects(id, maxItems = 10, minConfidence = 0.25) {
   return native.detectObjects(id, maxItems, minConfidence);
 }
 
+// src/maps/index.ts
+var import_react_native = require("react-native");
+var import_expo_modules_core2 = require("expo-modules-core");
+var ExpoLocation = __toESM(require("expo-location"));
+
+// src/geo.ts
+function distanceOf(path) {
+  const R = 6371e3;
+  let total = 0;
+  for (let i = 1; i < path.length; i++) {
+    const a = path[i - 1], b = path[i];
+    const dLat = (b.latitude - a.latitude) * Math.PI / 180;
+    const dLon = (b.longitude - a.longitude) * Math.PI / 180;
+    const la1 = a.latitude * Math.PI / 180, la2 = b.latitude * Math.PI / 180;
+    const h = Math.sin(dLat / 2) ** 2 + Math.cos(la1) * Math.cos(la2) * Math.sin(dLon / 2) ** 2;
+    total += 2 * R * Math.asin(Math.sqrt(h));
+  }
+  return Math.round(total);
+}
+
+// src/args.ts
+var shown = (v) => {
+  let s;
+  try {
+    s = JSON.stringify(v, (_k, x) => typeof x === "number" && !Number.isFinite(x) ? `
${x}
` : x)?.replace(/"\\u0001(NaN|-?Infinity)\\u0001"/g, "$1");
+  } catch {
+  }
+  s = s ?? String(v);
+  return s.length > 80 ? `${s.slice(0, 77)}...` : s;
+};
+function refuseArgument(capability, verb, problem, nothing) {
+  const e = new Error(`${capability}.${verb}: ${problem}; ${nothing}.`);
+  e.code = "INVALID_ARGUMENT";
+  return e;
+}
+function countArg(capability, verb, name, value, def, max, nothing) {
+  const v = value ?? def;
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 1) {
+    throw refuseArgument(capability, verb, `${name} must be a number from 1 (at most ${max} are used), not ${shown(value)}`, nothing);
+  }
+  return Math.min(max, Math.floor(v));
+}
+function fractionArg(capability, verb, name, value, def, nothing) {
+  const v = value ?? def;
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || v > 1) {
+    throw refuseArgument(capability, verb, `${name} must be a number from 0 to 1, not ${shown(value)}`, nothing);
+  }
+  return v;
+}
+
+// src/maps/normalize.ts
+var SEARCH_RADIUS_DEFAULT_M = 3e3;
+var SEARCH_RADIUS_MAX_M = 1e5;
+var SEARCH_LIMIT_DEFAULT = 8;
+var SEARCH_LIMIT_MAX = 25;
+var text = (v) => typeof v === "string" && v.trim() !== "" ? v : null;
+var refuseArgument2 = (verb, problem, nothing) => refuseArgument("maps", verb, problem, nothing);
+function coordinateArg(verb, name, value, nothing) {
+  const c = value;
+  const latitude = c?.latitude, longitude = c?.longitude;
+  if (typeof latitude === "number" && Number.isFinite(latitude) && Math.abs(latitude) <= 90 && typeof longitude === "number" && Number.isFinite(longitude) && Math.abs(longitude) <= 180) {
+    return { latitude, longitude };
+  }
+  throw refuseArgument2(
+    verb,
+    `${name} must be { latitude, longitude } numbers (latitude -90..90, longitude -180..180), not ${shown(value)}`,
+    nothing
+  );
+}
+function searchArgs(query, opts) {
+  const nothing = "nothing was searched";
+  if (typeof query !== "string" || query.trim() === "") {
+    throw refuseArgument2("search", `query must be a non-empty string, not ${shown(query)}`, nothing);
+  }
+  const near = opts?.near == null ? null : coordinateArg("search", "near", opts.near, nothing);
+  const radiusM = opts?.radiusM ?? SEARCH_RADIUS_DEFAULT_M;
+  if (typeof radiusM !== "number" || !(radiusM > 0 && radiusM <= SEARCH_RADIUS_MAX_M)) {
+    throw refuseArgument2(
+      "search",
+      `radiusM must be metres above 0 and at most ${SEARCH_RADIUS_MAX_M}, not ${shown(radiusM)}`,
+      nothing
+    );
+  }
+  const limit = countArg("maps", "search", "limit", opts?.limit, SEARCH_LIMIT_DEFAULT, SEARCH_LIMIT_MAX, nothing);
+  return { query, near, radiusM, limit };
+}
+var point = (c) => ({
+  latitude: Number(c.latitude),
+  longitude: Number(c.longitude)
+});
+function toMapsAddress(raw) {
+  const r = raw ?? {};
+  return {
+    name: text(r.name),
+    street: text(r.street),
+    streetNumber: text(r.streetNumber),
+    district: text(r.district),
+    city: text(r.city),
+    region: text(r.region),
+    postalCode: text(r.postalCode),
+    country: text(r.country),
+    isoCountryCode: text(r.isoCountryCode)
+  };
+}
+function toMapsCategory(raw) {
+  const c = text(raw);
+  return c ? c.replace(/^MKPOICategory/, "") || null : null;
+}
+function toMapsPlaces(raw, near) {
+  return (raw ?? []).map((r) => {
+    const coordinate = point(r);
+    return {
+      name: text(r.name),
+      coordinate,
+      address: toMapsAddress(r.address),
+      category: toMapsCategory(r.category),
+      distanceM: near ? distanceOf([near, coordinate]) : null
+    };
+  });
+}
+function toReverseGeocodedPlace(at, address) {
+  return {
+    name: address.name,
+    coordinate: point(at),
+    address,
+    category: null,
+    distanceM: null
+  };
+}
+function toMapsRoute(raw) {
+  const steps = (raw.steps ?? []).map((s) => ({
+    instructions: typeof s.instructions === "string" ? s.instructions : "",
+    distanceM: Number(s.distance),
+    notice: text(s.notice),
+    polyline: (s.polyline ?? []).map(point)
+  }));
+  return {
+    mode: "walking",
+    distanceM: Number(raw.distance),
+    expectedTravelTimeMs: Math.round(Number(raw.expectedTravelTime) * 1e3),
+    steps,
+    polyline: (raw.polyline ?? []).map(point)
+  };
+}
+function mapsFailure(verb, err) {
+  const nativeCode = String(err?.code ?? "");
+  const detail = String(err?.message ?? err ?? "").trim();
+  let code;
+  let why;
+  if (nativeCode === "THROTTLED") {
+    code = "THROTTLED";
+    why = "Apple is rate-limiting map requests from this app \u2014 wait before retrying";
+  } else if (nativeCode === "OFFLINE") {
+    code = "OFFLINE";
+    why = "the map service could not be reached \u2014 the phone may be offline";
+  } else if (nativeCode === "ERR_GEOCODING_NETWORK") {
+    code = "OFFLINE";
+    why = "the geocoder could not be reached \u2014 the phone may be offline, or Apple is rate-limiting requests (iOS reports both the same way)";
+  } else {
+    code = "UNAVAILABLE";
+    why = "the map service failed";
+  }
+  const failure = new Error(
+    `maps.${verb} could not look: ${why}. This is not "found nothing".` + (detail ? ` (${nativeCode ? nativeCode + ": " : ""}${detail})` : "")
+  );
+  failure.code = code;
+  return failure;
+}
+
+// src/maps/index.ts
+var native2 = (0, import_expo_modules_core2.requireOptionalNativeModule)("AdaMaps");
+function missingReason() {
+  if (import_react_native.Platform.OS !== "ios") return `iOS (Apple MapKit) \u2014 ${import_react_native.Platform.OS} has no implementation yet`;
+  if (!native2) return "the app build with the AdaMaps module (this build predates it \u2014 a native rebuild is needed)";
+  return null;
+}
+function isSupported2() {
+  try {
+    return missingReason() === null && (native2?.isSupported() ?? false);
+  } catch {
+    return false;
+  }
+}
+async function search(query, near, radiusM, limit) {
+  if (!native2) throw new Error("ada-maps native module not present in this build");
+  return near ? native2.search(query, near.latitude, near.longitude, true, radiusM, limit) : native2.search(query, 0, 0, false, radiusM, limit);
+}
+async function route(from, to) {
+  if (!native2) throw new Error("ada-maps native module not present in this build");
+  return native2.route(from.latitude, from.longitude, to.latitude, to.longitude);
+}
+async function reverseGeocode(at) {
+  const [first] = await ExpoLocation.reverseGeocodeAsync({ latitude: at.latitude, longitude: at.longitude });
+  return first ? toMapsAddress(first) : null;
+}
+
 // src/device-bridge/actions/messaging.ts
 var SMS = __toESM(require("expo-sms"));
 
@@ -320,10 +516,10 @@ var ExpoCalendar = __toESM(require("expo-calendar"));
 
 // src/device-bridge/actions/navigation.ts
 var Linking = __toESM(require("expo-linking"));
-var import_react_native = require("react-native");
+var import_react_native2 = require("react-native");
 
 // src/device-bridge/collectors/health.ts
-var import_react_native2 = require("react-native");
+var import_react_native3 = require("react-native");
 
 // src/device-bridge/background.ts
 var TaskManager = __toESM(require("expo-task-manager"));
@@ -337,7 +533,13 @@ var ExpoContacts = __toESM(require("expo-contacts"));
 var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
 
 // src/device-bridge/collectors/location.ts
-var ExpoLocation = __toESM(require("expo-location"));
+var ExpoLocation2 = __toESM(require("expo-location"));
+var WATCH_TIER = {
+  navigation: ExpoLocation2.Accuracy.BestForNavigation,
+  high: ExpoLocation2.Accuracy.High,
+  balanced: ExpoLocation2.Accuracy.Balanced,
+  low: ExpoLocation2.Accuracy.Low
+};
 
 // src/device-bridge/collectors/battery.ts
 var ExpoBattery = __toESM(require("expo-battery"));
@@ -349,7 +551,7 @@ var ExpoNetwork = __toESM(require("expo-network"));
 var ExpoNotifications = __toESM(require("expo-notifications"));
 
 // src/device-bridge/collectors/appEngagement.ts
-var import_react_native3 = require("react-native");
+var import_react_native4 = require("react-native");
 var import_async_storage2 = __toESM(require("@react-native-async-storage/async-storage"));
 
 // src/device-bridge/collectors/camera.ts
@@ -464,9 +666,9 @@ function stubApi(capability) {
 }
 function createLocationAPI() {
   const ensurePermission = async () => {
-    const existing = await ExpoLocation2.getForegroundPermissionsAsync();
+    const existing = await ExpoLocation3.getForegroundPermissionsAsync();
     if (existing.status === "granted") return;
-    const asked = await ExpoLocation2.requestForegroundPermissionsAsync();
+    const asked = await ExpoLocation3.requestForegroundPermissionsAsync();
     if (asked.status !== "granted") {
       throw new Error(
         "Location permission was not granted. Enable it for this app in Settings > Privacy > Location Services."
@@ -476,8 +678,8 @@ function createLocationAPI() {
   return {
     async getCurrent(opts) {
       await ensurePermission();
-      const fix = await ExpoLocation2.getCurrentPositionAsync({
-        accuracy: opts?.accuracy === "high" ? ExpoLocation2.Accuracy.High : ExpoLocation2.Accuracy.Balanced
+      const fix = await ExpoLocation3.getCurrentPositionAsync({
+        accuracy: opts?.accuracy === "high" ? ExpoLocation3.Accuracy.High : ExpoLocation3.Accuracy.Balanced
       });
       return {
         latitude: fix.coords.latitude,
@@ -492,8 +694,8 @@ function createLocationAPI() {
         try {
           await ensurePermission();
           if (cancelled) return;
-          subscription = await ExpoLocation2.watchPositionAsync(
-            { accuracy: ExpoLocation2.Accuracy.Balanced },
+          subscription = await ExpoLocation3.watchPositionAsync(
+            { accuracy: ExpoLocation3.Accuracy.Balanced },
             (fix) => cb({ latitude: fix.coords.latitude, longitude: fix.coords.longitude })
           );
           if (cancelled) {
@@ -905,18 +1107,27 @@ function createVisionAPI() {
     // pixels). [] = looked, found no text (a real finding); throws = could not
     // look (unknown/aged-out id). describe (VNClassifyImage) is the next pass.
     async readText(frameId, opts) {
-      return readText(frameId, opts?.languages);
+      const langs = opts?.languages;
+      if (langs != null && (!Array.isArray(langs) || langs.some((l) => typeof l !== "string"))) {
+        throw refuseArgument("vision", "readText", `languages must be an array of language codes, not ${shown(langs)}`, "nothing was read");
+      }
+      return readText(frameId, langs);
     },
     // describe: on-device labels (VNClassifyImage), not prose — the sentence is
     // the skill's job. [] = looked, recognised nothing.
     async describe(frameId, opts) {
-      return describe(frameId, opts?.maxLabels ?? 5);
+      return describe(frameId, countArg("vision", "describe", "maxLabels", opts?.maxLabels, 5, 50, "nothing was labelled"));
     },
     // detectObjects: on-device located objects (bundled detector), each with a
     // box — what a guidance loop reads to say WHERE a thing is, not just that the
     // scene contains it. [] = looked, found nothing; throws = could not look.
     async detectObjects(frameId, opts) {
-      return detectObjects(frameId, opts?.maxItems ?? 10, opts?.minConfidence ?? 0.25);
+      const nothing = "nothing was detected";
+      return detectObjects(
+        frameId,
+        countArg("vision", "detectObjects", "maxItems", opts?.maxItems, 10, 50, nothing),
+        fractionArg("vision", "detectObjects", "minConfidence", opts?.minConfidence, 0.25, nothing)
+      );
     },
     // assessQuality: resolve the frame id to its LOCAL file, measure on-device,
     // and record the result back onto the frame so a later read of
@@ -934,6 +1145,55 @@ function createVisionAPI() {
     }
   };
 }
+function createMapsAPI() {
+  const refuseIfMissing = (verb, nothing) => {
+    const missing = missingReason();
+    if (missing) {
+      throw new CapabilityUnavailableError(`maps.${verb}`, `maps.${verb} needs ${missing}; ${nothing}.`);
+    }
+  };
+  return {
+    async isSupported() {
+      return isSupported2();
+    },
+    // [] = Apple looked and found nothing (a real finding); throws = could not
+    // look. The defaults (radiusM 3000, limit 8) live in searchArgs.
+    async search(query, opts) {
+      const args = searchArgs(query, opts);
+      refuseIfMissing("search", "nothing was searched");
+      const raw = await search(args.query, args.near, args.radiusM, args.limit).catch((err) => {
+        throw mapsFailure("search", err);
+      });
+      return toMapsPlaces(raw, args.near);
+    },
+    // null = nothing at that point; throws = could not look.
+    async reverseGeocode(at) {
+      const point2 = coordinateArg("reverseGeocode", "at", at, "nothing was looked up");
+      const address = await reverseGeocode(point2).catch((err) => {
+        throw mapsFailure("reverseGeocode", err);
+      });
+      return address ? toReverseGeocodedPlace(point2, address) : null;
+    },
+    // null = Apple found no route. Never an empty 0 m route, which would read as
+    // "you have arrived". A remote bundle can pass any string as `mode`, so a
+    // mode this build cannot honour refuses rather than silently walking.
+    async route(from, to, opts) {
+      if (opts?.mode !== void 0 && opts.mode !== "walking") {
+        throw new CapabilityUnavailableError(
+          "maps.route",
+          `maps.route supports walking only, not "${String(opts.mode)}"; no route was requested.`
+        );
+      }
+      const a = coordinateArg("route", "from", from, "no route was requested");
+      const b = coordinateArg("route", "to", to, "no route was requested");
+      refuseIfMissing("route", "no route was requested");
+      const raw = await route(a, b).catch((err) => {
+        throw mapsFailure("route", err);
+      });
+      return raw ? toMapsRoute(raw) : null;
+    }
+  };
+}
 function createDeviceProvider(config) {
   const connectivity = createConnectivityAPI(config?.reachabilityUrl);
   return {
@@ -956,7 +1216,8 @@ function createDeviceProvider(config) {
     scanner: createScannerAPI(),
     nfc: createNfcAPI(),
     bluetooth: createBluetoothAPI(),
-    vision: createVisionAPI()
+    vision: createVisionAPI(),
+    maps: createMapsAPI()
   };
 }
 // Annotate the CommonJS export names for ESM import in node: