@ateam-ai-mobile/expo 0.1.5 → 0.1.8

package/dist/chunk-GF2MPTAB.mjs

@@ -0,0 +1,647 @@
+import {
+  describe,
+  detectObjects,
+  isSupported,
+  qualityById,
+  readText
+} from "./chunk-PCAEUX2N.mjs";
+import {
+  cameraTasks
+} from "./chunk-6LXF3JVX.mjs";
+import {
+  cookies_exports,
+  init_cookies
+} from "./chunk-FF6ZZZXH.mjs";
+import {
+  biometrics_exports,
+  scanner_exports,
+  sharing_exports
+} from "./chunk-Z5AI2SXX.mjs";
+import {
+  init_nfc,
+  nfc_exports
+} from "./chunk-4BMWVN25.mjs";
+import {
+  coordinateArg,
+  countArg,
+  fractionArg,
+  isSupported as isSupported2,
+  mapsFailure,
+  missingReason,
+  refuseArgument,
+  reverseGeocode,
+  route,
+  search,
+  searchArgs,
+  shown,
+  toMapsPlaces,
+  toMapsRoute,
+  toReverseGeocodedPlace
+} from "./chunk-7FWYEHN5.mjs";
+import {
+  __toCommonJS
+} from "./chunk-WMJKH4XE.mjs";
+
+// src/device/createDeviceProvider.ts
+import * as Haptics from "expo-haptics";
+import * as ExpoLocation from "expo-location";
+import * as ImagePicker from "expo-image-picker";
+import * as Notifications from "expo-notifications";
+import * as DocumentPicker from "expo-document-picker";
+import * as FS from "expo-file-system";
+import * as SQLite from "expo-sqlite";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+function getDeviceCookies() {
+  try {
+    return init_cookies(), __toCommonJS(cookies_exports);
+  } catch {
+    return null;
+  }
+}
+function getDeviceNfc() {
+  try {
+    return init_nfc(), __toCommonJS(nfc_exports);
+  } catch {
+    return null;
+  }
+}
+var CapabilityUnavailableError = class extends Error {
+  constructor(capability, reason) {
+    super(reason || `${capability} is not yet implemented. Coming in Phase 2.`);
+    this.code = "UNAVAILABLE";
+    this.name = "CapabilityUnavailableError";
+  }
+};
+function stubApi(capability) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "string") {
+        return () => {
+          throw new CapabilityUnavailableError(capability);
+        };
+      }
+    }
+  });
+}
+function createLocationAPI() {
+  const ensurePermission = async () => {
+    const existing = await ExpoLocation.getForegroundPermissionsAsync();
+    if (existing.status === "granted") return;
+    const asked = await ExpoLocation.requestForegroundPermissionsAsync();
+    if (asked.status !== "granted") {
+      throw new Error(
+        "Location permission was not granted. Enable it for this app in Settings > Privacy > Location Services."
+      );
+    }
+  };
+  return {
+    async getCurrent(opts) {
+      await ensurePermission();
+      const fix = await ExpoLocation.getCurrentPositionAsync({
+        accuracy: opts?.accuracy === "high" ? ExpoLocation.Accuracy.High : ExpoLocation.Accuracy.Balanced
+      });
+      return {
+        latitude: fix.coords.latitude,
+        longitude: fix.coords.longitude,
+        altitude: fix.coords.altitude ?? void 0
+      };
+    },
+    watchPosition(cb) {
+      let subscription = null;
+      let cancelled = false;
+      void (async () => {
+        try {
+          await ensurePermission();
+          if (cancelled) return;
+          subscription = await ExpoLocation.watchPositionAsync(
+            { accuracy: ExpoLocation.Accuracy.Balanced },
+            (fix) => cb({ latitude: fix.coords.latitude, longitude: fix.coords.longitude })
+          );
+          if (cancelled) {
+            subscription?.remove();
+            subscription = null;
+          }
+        } catch (err) {
+          console.warn("[location] watchPosition failed:", err?.message || String(err));
+        }
+      })();
+      return () => {
+        cancelled = true;
+        subscription?.remove();
+        subscription = null;
+      };
+    }
+  };
+}
+function createCameraAPI() {
+  const ensurePermission = async () => {
+    const existing = await ImagePicker.getCameraPermissionsAsync();
+    if (existing.granted) return;
+    const asked = await ImagePicker.requestCameraPermissionsAsync();
+    if (!asked.granted) {
+      throw new Error(
+        "Camera permission was not granted. Enable it for this app in Settings > Privacy > Camera."
+      );
+    }
+  };
+  return {
+    async takePhoto(opts) {
+      await ensurePermission();
+      const res = await ImagePicker.launchCameraAsync({
+        quality: opts?.quality ?? 0.7,
+        cameraType: opts?.facing === "front" ? ImagePicker.CameraType.front : ImagePicker.CameraType.back
+      });
+      if (res.canceled || !res.assets?.[0]) {
+        throw new Error("No photo taken \u2014 the camera was dismissed.");
+      }
+      const a = res.assets[0];
+      return { uri: a.uri, width: a.width, height: a.height };
+    },
+    async scanBarcode(opts) {
+      throw new CapabilityUnavailableError(
+        "camera.scanBarcode",
+        "Use native.scanner.scanOnce() instead \u2014 scanning needs a mounted camera, which this call cannot provide. Same arguments, and it returns { data, format }." + (opts?.formats?.length ? " Pass your formats through to scanOnce." : "")
+      );
+    },
+    async recordVideo(opts) {
+      return cameraTasks.run("record", {
+        maxDurationMs: opts?.maxDurationMs,
+        withAudio: opts?.withAudio ?? false
+      });
+    },
+    async pickImage(opts) {
+      const existing = await ImagePicker.getMediaLibraryPermissionsAsync();
+      if (!existing.granted) {
+        const asked = await ImagePicker.requestMediaLibraryPermissionsAsync();
+        if (!asked.granted) {
+          throw new Error(
+            "Photo library permission was not granted. Enable it for this app in Settings > Privacy > Photos."
+          );
+        }
+      }
+      const res = await ImagePicker.launchImageLibraryAsync({
+        allowsMultipleSelection: !!opts?.multiple
+      });
+      if (res.canceled) return [];
+      return (res.assets || []).map((a) => ({ uri: a.uri }));
+    }
+  };
+}
+var _pluginDbs = /* @__PURE__ */ new Map();
+function openPluginDb(file) {
+  const existing = _pluginDbs.get(file);
+  if (existing) return existing;
+  const opened = SQLite.openDatabaseAsync(file);
+  _pluginDbs.set(file, opened);
+  return opened;
+}
+function sqlLeadingKeyword(sql) {
+  let s = String(sql);
+  for (; ; ) {
+    const before = s;
+    s = s.replace(/^\s+/, "");
+    if (s.startsWith("--")) {
+      const nl = s.indexOf("\n");
+      s = nl === -1 ? "" : s.slice(nl + 1);
+    } else if (s.startsWith("/*")) {
+      const end = s.indexOf("*/");
+      s = end === -1 ? "" : s.slice(end + 2);
+    }
+    if (s === before) break;
+  }
+  const m = s.match(/^[A-Za-z]+/);
+  return m ? m[0].toUpperCase() : "";
+}
+function createStorageAPI(pluginId) {
+  const ns = encodeURIComponent(pluginId);
+  const key = (k) => `@plugin:${ns}:${k}`;
+  const dbFile = `plugin-storage-${ns}.db`;
+  return {
+    get: (k) => AsyncStorage.getItem(key(k)),
+    set: (k, v) => AsyncStorage.setItem(key(k), v),
+    delete: (k) => AsyncStorage.removeItem(key(k)),
+    db: {
+      async execute(sql, params) {
+        const verb = sqlLeadingKeyword(sql);
+        if (verb === "ATTACH" || verb === "DETACH" || verb === "VACUUM") {
+          throw new CapabilityUnavailableError(
+            "storage.db",
+            `SQL '${verb}' is not permitted: a plugin's storage is confined to its own database and cannot reach another file.`
+          );
+        }
+        const db = await openPluginDb(dbFile);
+        const returnsRows = verb === "SELECT" || verb === "PRAGMA" || verb === "WITH";
+        if (returnsRows) {
+          const rows = await db.getAllAsync(sql, params ?? []);
+          return { rows, changes: 0 };
+        }
+        const res = await db.runAsync(sql, params ?? []);
+        return { rows: [], changes: res.changes ?? 0 };
+      }
+    }
+  };
+}
+async function clearAllPluginData() {
+  try {
+    const keys = await AsyncStorage.getAllKeys();
+    const mine = keys.filter((k) => k.startsWith("@plugin:"));
+    if (mine.length) await AsyncStorage.multiRemove(mine);
+  } catch (e) {
+    console.warn("[adas] clearAllPluginData: KV clear failed:", e?.message || e);
+  }
+  try {
+    for (const [, p] of _pluginDbs) {
+      try {
+        const db = await p;
+        await db.closeAsync?.();
+      } catch {
+      }
+    }
+    _pluginDbs.clear();
+    const sqliteDir = new FS.Directory(FS.Paths.document, "SQLite");
+    if (sqliteDir.exists) {
+      for (const entry of sqliteDir.list()) {
+        if (/^plugin-storage-.*\.db$/.test(String(entry.name ?? ""))) {
+          try {
+            entry.delete();
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[adas] clearAllPluginData: SQLite clear failed:", e?.message || e);
+  }
+  try {
+    const dir = new FS.Directory(FS.Paths.document, "plugin-files");
+    if (dir.exists) dir.delete();
+  } catch (e) {
+    console.warn("[adas] clearAllPluginData: file sandbox clear failed:", e?.message || e);
+  }
+}
+function createNotificationsAPI() {
+  return {
+    async schedule({ title, body, trigger }) {
+      const perm = await Notifications.getPermissionsAsync();
+      if (!perm.granted) {
+        const asked = await Notifications.requestPermissionsAsync();
+        if (!asked.granted) {
+          throw new Error(
+            "Notification permission was not granted. Enable it for this app in Settings > Notifications."
+          );
+        }
+      }
+      const when = typeof trigger?.seconds === "number" ? { type: "timeInterval", seconds: trigger.seconds, repeats: false } : trigger?.date ? { type: "date", date: new Date(trigger.date) } : null;
+      if (!when) {
+        throw new Error("schedule() needs trigger.seconds or trigger.date.");
+      }
+      return Notifications.scheduleNotificationAsync({
+        content: { title, body },
+        trigger: when
+      });
+    },
+    cancel: (id) => Notifications.cancelScheduledNotificationAsync(id),
+    onReceived(cb) {
+      const sub = Notifications.addNotificationReceivedListener((n) => {
+        cb({
+          id: n.request.identifier,
+          title: n.request.content.title || "",
+          body: n.request.content.body || "",
+          data: n.request.content.data
+        });
+      });
+      return () => sub.remove();
+    }
+  };
+}
+function createFileSystemAPI(pluginId) {
+  let _root = null;
+  const rootDir = () => _root ?? (_root = new FS.Directory(FS.Paths.document, "plugin-files", pluginId));
+  const resolve = (p) => {
+    const root = rootDir();
+    const file = new FS.File(root, p);
+    if (!file.uri.startsWith(root.uri)) {
+      throw new CapabilityUnavailableError(
+        "fileSystem",
+        `Path escapes the plugin's storage area: ${p}. Plugin files live under plugin-files/ and paths cannot traverse out of it.`
+      );
+    }
+    return file;
+  };
+  return {
+    async readFile(path) {
+      const file = resolve(path);
+      if (!file.exists) {
+        throw new CapabilityUnavailableError(
+          "fileSystem.readFile",
+          `No such file: ${path}. Nothing was read.`
+        );
+      }
+      return file.text();
+    },
+    async writeFile(path, content) {
+      const file = resolve(path);
+      const parent = file.parentDirectory;
+      if (!parent.exists) parent.create({ intermediates: true });
+      if (!file.exists) file.create();
+      file.write(content);
+    },
+    async pickDocument(opts) {
+      const res = await DocumentPicker.getDocumentAsync({
+        type: opts?.types?.length ? opts.types : "*/*",
+        copyToCacheDirectory: true
+      });
+      if (res.canceled || !res.assets?.[0]) {
+        throw new Error("No document chosen \u2014 the picker was dismissed.");
+      }
+      const a = res.assets[0];
+      return { uri: a.uri, name: a.name, size: a.size ?? 0 };
+    }
+  };
+}
+function createHapticsAPI() {
+  return {
+    impact(style) {
+      const map = {
+        light: Haptics.ImpactFeedbackStyle.Light,
+        medium: Haptics.ImpactFeedbackStyle.Medium,
+        heavy: Haptics.ImpactFeedbackStyle.Heavy
+      };
+      Haptics.impactAsync(map[style]);
+    },
+    notification(type) {
+      const map = {
+        success: Haptics.NotificationFeedbackType.Success,
+        warning: Haptics.NotificationFeedbackType.Warning,
+        error: Haptics.NotificationFeedbackType.Error
+      };
+      Haptics.notificationAsync(map[type]);
+    },
+    // Shorthand for notification('error'). Plugins call this; it was never
+    // implemented, and optional chaining meant the failure the user was meant
+    // to FEEL simply did not happen.
+    error() {
+      Haptics.notificationAsync(Haptics.NotificationFeedbackType.Error);
+    },
+    selection() {
+      Haptics.selectionAsync();
+    }
+  };
+}
+function createConnectivityAPI(reachabilityUrl) {
+  let online = true;
+  const listeners = /* @__PURE__ */ new Set();
+  let interval = null;
+  const checkOnline = async () => {
+    if (!reachabilityUrl) return true;
+    try {
+      const res = await fetch(reachabilityUrl, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(5e3)
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  };
+  const startPolling = () => {
+    if (!reachabilityUrl) return;
+    if (interval) return;
+    interval = setInterval(async () => {
+      const newState = await checkOnline();
+      if (newState !== online) {
+        online = newState;
+        listeners.forEach((cb) => cb(online));
+      }
+    }, 3e4);
+  };
+  return {
+    isOnline() {
+      return online;
+    },
+    onChange(cb) {
+      listeners.add(cb);
+      startPolling();
+      return () => {
+        listeners.delete(cb);
+        if (listeners.size === 0 && interval) {
+          clearInterval(interval);
+          interval = null;
+        }
+      };
+    }
+  };
+}
+function createCookiesAPI() {
+  return {
+    async get(url) {
+      const mod = getDeviceCookies();
+      if (!mod) throw new CapabilityUnavailableError("cookies (native module not available \u2014 use a dev build)");
+      const list = await mod.get(url, true);
+      return list;
+    },
+    async clear(_url) {
+      const mod = getDeviceCookies();
+      if (!mod) throw new CapabilityUnavailableError("cookies (native module not available \u2014 use a dev build)");
+      const r = await mod.clearAll();
+      return { ok: r.ok };
+    }
+  };
+}
+function createBiometricsAPIv2() {
+  return {
+    capabilities: () => biometrics_exports.capabilities(),
+    authenticate: (opts) => biometrics_exports.authenticate(opts)
+  };
+}
+function createSharingAPI() {
+  return {
+    isAvailable: () => sharing_exports.isAvailable(),
+    shareFile: (fileUri, opts) => sharing_exports.shareFile(fileUri, opts)
+  };
+}
+function createScannerAPI() {
+  return {
+    requestPermissions: () => scanner_exports.requestPermissions(),
+    // Raises the shared camera surface and settles on the first code read.
+    // The plugin mounts nothing — that lifecycle is owned once, by
+    // CameraTaskHost, instead of by every plugin that wants to scan.
+    scanOnce: (opts) => cameraTasks.run("scan", {
+      formats: opts?.formats,
+      timeoutMs: opts?.timeoutMs
+    })
+  };
+}
+function createNfcAPI() {
+  return {
+    async isSupported() {
+      const mod = getDeviceNfc();
+      if (!mod) return false;
+      return mod.isSupported();
+    },
+    async isEnabled() {
+      const mod = getDeviceNfc();
+      if (!mod) return false;
+      return mod.isEnabled();
+    },
+    readOnce(timeoutMs) {
+      const mod = getDeviceNfc();
+      if (!mod) return Promise.resolve({ ok: false, error: "nfc_unavailable" });
+      return mod.readOnce(timeoutMs);
+    }
+  };
+}
+function createBluetoothAPI() {
+  const refuse = (method) => new CapabilityUnavailableError(
+    `bluetooth.${method}`,
+    "Bluetooth is not implemented in this build \u2014 no BLE native module is installed. The capability is declared so it fails by name rather than silently; nothing was scanned."
+  );
+  return {
+    // These two answer `false` rather than throwing, because "is BLE usable?"
+    // is exactly the question a plugin should be allowed to ask before
+    // committing to a flow, and `false` is the true answer here.
+    async isSupported() {
+      return false;
+    },
+    async isEnabled() {
+      return false;
+    },
+    // scan() THROWS, because there is no honest empty result: an empty device
+    // list is a real finding ("nothing is advertising nearby") and returning
+    // one would report a scan that never happened.
+    async scan() {
+      throw refuse("scan");
+    }
+  };
+}
+function createVisionAPI() {
+  return {
+    // "Can I see?" — true once the native module is present in the binary. On a
+    // build without it, adaVision.isSupported() answers false, and assessQuality
+    // below refuses cleanly (no crash), exactly the pre-module behaviour.
+    async isSupported() {
+      return isSupported();
+    },
+    // readText: on-device OCR on a published frame (native resolves the id →
+    // 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) {
+      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, 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) {
+      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
+    // VisualFrameRef.quality reflects it. Throwing here means "could not look"
+    // (unknown/aged-out id, or no native module) — never a measured verdict.
+    async assessQuality(frameId) {
+      const q = qualityById(frameId);
+      if (!q) {
+        throw new CapabilityUnavailableError(
+          "vision.assessQuality",
+          `No frame for id "${frameId}" \u2014 unknown or aged out of the ring. This is "could not look", not a measurement.`
+        );
+      }
+      return q;
+    }
+  };
+}
+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 point = coordinateArg("reverseGeocode", "at", at, "nothing was looked up");
+      const address = await reverseGeocode(point).catch((err) => {
+        throw mapsFailure("reverseGeocode", err);
+      });
+      return address ? toReverseGeocodedPlace(point, 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 {
+    camera: createCameraAPI(),
+    location: createLocationAPI(),
+    // Only the per-plugin storageFor/fileSystemFor are exposed — NO shared
+    // `storage`/`fileSystem` bucket. The gate scopes by pluginId and fails
+    // closed without one, so a shared instance would be an unreachable
+    // (and dangerous) fallback. Each plugin gets its own namespace + db file /
+    // sandbox directory, or nothing.
+    storageFor: (pluginId) => createStorageAPI(pluginId),
+    biometrics: stubApi("biometrics"),
+    biometricsV2: createBiometricsAPIv2(),
+    notifications: createNotificationsAPI(),
+    haptics: createHapticsAPI(),
+    connectivity,
+    fileSystemFor: (pluginId) => createFileSystemAPI(pluginId),
+    cookies: createCookiesAPI(),
+    sharing: createSharingAPI(),
+    scanner: createScannerAPI(),
+    nfc: createNfcAPI(),
+    bluetooth: createBluetoothAPI(),
+    vision: createVisionAPI(),
+    maps: createMapsAPI()
+  };
+}
+
+export {
+  clearAllPluginData,
+  createDeviceProvider
+};
+//# sourceMappingURL=chunk-GF2MPTAB.mjs.map