craft-native 0.0.55 → 0.0.74

package/dist/mobile.js

@@ -0,0 +1,755 @@
+// src/bridge/ids.ts
+function secureUUID() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  if (c && typeof c.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    c.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+  }
+  throw new Error("[Craft] No Web Crypto available; cannot generate secure IDs");
+}
+
+// src/api/mobile.ts
+var WEB_DEVICE_ID_KEY = "__craft_web_device_id__";
+function _webFallbackDeviceId() {
+  if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+    try {
+      const ls = globalThis.localStorage;
+      const existing = ls.getItem(WEB_DEVICE_ID_KEY);
+      if (existing && /^web-[0-9a-f-]+$/i.test(existing))
+        return existing;
+      const fresh = `web-${secureUUID()}`;
+      ls.setItem(WEB_DEVICE_ID_KEY, fresh);
+      return fresh;
+    } catch {}
+  }
+  return `web-${secureUUID()}`;
+}
+function _resetWebFallbackDeviceIdForTests() {
+  if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+    try {
+      globalThis.localStorage.removeItem(WEB_DEVICE_ID_KEY);
+    } catch {}
+  }
+}
+var device = {
+  async getInfo() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.device) {
+      return craft.device.getInfo();
+    }
+    return {
+      platform: detectPlatform(),
+      osVersion: "unknown",
+      model: "unknown",
+      manufacturer: "unknown",
+      deviceId: _webFallbackDeviceId(),
+      isTablet: false,
+      screen: {
+        width: typeof window !== "undefined" ? window.innerWidth || 0 : 0,
+        height: typeof window !== "undefined" ? window.innerHeight || 0 : 0,
+        scale: typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1
+      },
+      battery: { level: 100, isCharging: false },
+      network: { type: "wifi", isConnected: typeof navigator !== "undefined" ? navigator.onLine ?? true : true }
+    };
+  },
+  async getCapabilities() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.device) {
+      return craft.device.getCapabilities();
+    }
+    return {
+      camera: true,
+      biometrics: false,
+      nfc: false,
+      bluetooth: false,
+      gps: "geolocation" in navigator,
+      accelerometer: false,
+      gyroscope: false,
+      haptics: "vibrate" in navigator,
+      ar: false,
+      faceId: false,
+      touchId: false
+    };
+  },
+  isMobile() {
+    const platform = detectPlatform();
+    return platform === "ios" || platform === "android";
+  },
+  isIOS() {
+    return detectPlatform() === "ios";
+  },
+  isAndroid() {
+    return detectPlatform() === "android";
+  },
+  getLocale() {
+    return navigator?.language || "en-US";
+  },
+  getTimezone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  }
+};
+var haptics = {
+  async impact(style = "medium") {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.haptics) {
+      return craft.haptics.impact(style);
+    }
+    if ("vibrate" in navigator) {
+      const duration = { light: 10, medium: 20, heavy: 30, soft: 5, rigid: 25 }[style];
+      navigator.vibrate(duration);
+    }
+  },
+  async notification(type = "success") {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.haptics) {
+      return craft.haptics.notification(type);
+    }
+    if ("vibrate" in navigator) {
+      const patterns = {
+        success: [10, 30, 10],
+        warning: [30, 30, 30],
+        error: [50, 50, 50, 50, 50]
+      };
+      navigator.vibrate(patterns[type]);
+    }
+  },
+  async selection() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.haptics) {
+      return craft.haptics.selection();
+    }
+    if ("vibrate" in navigator) {
+      navigator.vibrate(5);
+    }
+  },
+  async vibrate(pattern) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.haptics) {
+      return craft.haptics.vibrate(pattern);
+    }
+    if ("vibrate" in navigator) {
+      navigator.vibrate(pattern);
+    }
+  }
+};
+var permissions = {
+  async check(permission) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.permissions) {
+      return craft.permissions.check(permission);
+    }
+    try {
+      const webPermission = mapToWebPermission(permission);
+      if (webPermission && navigator.permissions) {
+        const result = await navigator.permissions.query({ name: webPermission });
+        return mapWebPermissionStatus(result.state);
+      }
+    } catch {}
+    return "undetermined";
+  },
+  async request(permission) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.permissions) {
+      return craft.permissions.request(permission);
+    }
+    try {
+      if (permission === "camera" || permission === "microphone") {
+        const constraints = {};
+        if (permission === "camera")
+          constraints.video = true;
+        if (permission === "microphone")
+          constraints.audio = true;
+        const stream = await navigator.mediaDevices.getUserMedia(constraints);
+        stream.getTracks().forEach((track) => track.stop());
+        return "granted";
+      }
+      if (permission === "location") {
+        return new Promise((resolve) => {
+          navigator.geolocation.getCurrentPosition(() => resolve("granted"), () => resolve("denied"));
+        });
+      }
+      if (permission === "notifications") {
+        const result = await Notification.requestPermission();
+        return result === "granted" ? "granted" : "denied";
+      }
+    } catch {
+      return "denied";
+    }
+    return "undetermined";
+  },
+  async checkMultiple(permissionList) {
+    const results = {};
+    for (const perm of permissionList) {
+      results[perm] = await this.check(perm);
+    }
+    return results;
+  },
+  async requestMultiple(permissionList) {
+    const results = {};
+    for (const perm of permissionList) {
+      results[perm] = await this.request(perm);
+    }
+    return results;
+  },
+  async openSettings() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.permissions) {
+      return craft.permissions.openSettings();
+    }
+  }
+};
+var camera = {
+  async takePicture(options = {}) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.camera) {
+      return craft.camera.takePicture(options);
+    }
+    throw new Error("Camera API not available. Must run in Craft environment.");
+  },
+  async pickImage() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.camera) {
+      return craft.camera.pickImage();
+    }
+    return new Promise((resolve, reject) => {
+      const input = document.createElement("input");
+      input.type = "file";
+      input.accept = "image/*";
+      input.onchange = async () => {
+        const file = input.files?.[0];
+        if (file) {
+          const reader = new FileReader;
+          reader.onload = () => {
+            const base64 = reader.result.split(",")[1];
+            resolve({
+              base64,
+              uri: URL.createObjectURL(file),
+              width: 0,
+              height: 0,
+              mimeType: file.type
+            });
+          };
+          reader.onerror = () => reject(new Error("Failed to read file"));
+          reader.readAsDataURL(file);
+        } else {
+          reject(new Error("No file selected"));
+        }
+      };
+      input.click();
+    });
+  },
+  async pickMultiple(options = {}) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.camera) {
+      return craft.camera.pickMultiple(options);
+    }
+    throw new Error("Camera API not available. Must run in Craft environment.");
+  },
+  async isAvailable() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.camera) {
+      return craft.camera.isAvailable();
+    }
+    try {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      return devices.some((d) => d.kind === "videoinput");
+    } catch {
+      return false;
+    }
+  }
+};
+var biometrics = {
+  async isAvailable() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.biometrics) {
+      return craft.biometrics.isAvailable();
+    }
+    return false;
+  },
+  async getBiometricType() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.biometrics) {
+      return craft.biometrics.getBiometricType();
+    }
+    return null;
+  },
+  async authenticate(reason) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.biometrics) {
+      return craft.biometrics.authenticate(reason);
+    }
+    throw new Error("Biometrics not available");
+  }
+};
+var secureStorage = {
+  async set(key, value) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.secureStorage) {
+      return craft.secureStorage.set(key, value);
+    }
+    if (typeof window !== "undefined" && window.craft)
+      throw new Error("Craft secure storage bridge is unavailable");
+    localStorage.setItem(`secure_${key}`, value);
+  },
+  async get(key) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.secureStorage) {
+      return craft.secureStorage.get(key);
+    }
+    if (typeof window !== "undefined" && window.craft)
+      throw new Error("Craft secure storage bridge is unavailable");
+    return localStorage.getItem(`secure_${key}`);
+  },
+  async delete(key) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.secureStorage) {
+      return craft.secureStorage.delete(key);
+    }
+    if (typeof window !== "undefined" && window.craft)
+      throw new Error("Craft secure storage bridge is unavailable");
+    localStorage.removeItem(`secure_${key}`);
+  },
+  async clear() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.secureStorage) {
+      return craft.secureStorage.clear();
+    }
+    if (typeof window !== "undefined" && window.craft)
+      throw new Error("Craft secure storage bridge is unavailable");
+    Object.keys(localStorage).filter((k) => k.startsWith("secure_")).forEach((k) => localStorage.removeItem(k));
+  }
+};
+var webLocationRecording = {
+  id: null,
+  active: false,
+  paused: false,
+  startedAt: null,
+  locations: []
+};
+var webLocationRecordingWatchId = null;
+var location = {
+  async getCurrentPosition(options = {}) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location) {
+      return craft.location.getCurrentPosition(options);
+    }
+    return new Promise((resolve, reject) => {
+      navigator.geolocation.getCurrentPosition((pos) => resolve({
+        latitude: pos.coords.latitude,
+        longitude: pos.coords.longitude,
+        altitude: pos.coords.altitude ?? undefined,
+        accuracy: pos.coords.accuracy,
+        heading: pos.coords.heading ?? undefined,
+        speed: pos.coords.speed ?? undefined,
+        timestamp: pos.timestamp
+      }), reject, {
+        enableHighAccuracy: options.enableHighAccuracy,
+        timeout: options.timeout,
+        maximumAge: options.maximumAge
+      });
+    });
+  },
+  watchPosition(callback, options = {}) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location) {
+      return craft.location.watchPosition(callback, options);
+    }
+    return navigator.geolocation.watchPosition((pos) => callback({
+      latitude: pos.coords.latitude,
+      longitude: pos.coords.longitude,
+      altitude: pos.coords.altitude ?? undefined,
+      accuracy: pos.coords.accuracy,
+      heading: pos.coords.heading ?? undefined,
+      speed: pos.coords.speed ?? undefined,
+      timestamp: pos.timestamp
+    }), console.error, {
+      enableHighAccuracy: options.enableHighAccuracy,
+      timeout: options.timeout,
+      maximumAge: options.maximumAge
+    });
+  },
+  clearWatch(watchId) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location) {
+      return craft.location.clearWatch(watchId);
+    }
+    navigator.geolocation.clearWatch(watchId);
+  },
+  async startRecording(options = {}) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location?.startRecording)
+      return craft.location.startRecording(options);
+    if (webLocationRecordingWatchId !== null)
+      navigator.geolocation.clearWatch(webLocationRecordingWatchId);
+    webLocationRecording = {
+      id: secureUUID(),
+      active: true,
+      paused: false,
+      startedAt: Date.now(),
+      locations: []
+    };
+    webLocationRecordingWatchId = location.watchPosition((position) => {
+      if (!webLocationRecording.paused)
+        webLocationRecording.locations.push(position);
+    }, options);
+    return { ...webLocationRecording, sampleCount: 0 };
+  },
+  async pauseRecording() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location?.pauseRecording)
+      return craft.location.pauseRecording();
+    webLocationRecording.paused = true;
+    return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
+  },
+  async resumeRecording() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location?.resumeRecording)
+      return craft.location.resumeRecording();
+    webLocationRecording.paused = false;
+    return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
+  },
+  async stopRecording() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location?.stopRecording)
+      return craft.location.stopRecording();
+    if (webLocationRecordingWatchId !== null) {
+      location.clearWatch(webLocationRecordingWatchId);
+      webLocationRecordingWatchId = null;
+    }
+    webLocationRecording.active = false;
+    webLocationRecording.paused = false;
+    return { ...webLocationRecording, locations: [...webLocationRecording.locations] };
+  },
+  async getRecordingState() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location?.getRecordingState)
+      return craft.location.getRecordingState();
+    return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
+  },
+  async readRecording() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location?.readRecording)
+      return craft.location.readRecording();
+    return [...webLocationRecording.locations];
+  }
+};
+var share = {
+  async share(options) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.share) {
+      return craft.share.share(options);
+    }
+    if (navigator.share) {
+      await navigator.share({
+        title: options.title,
+        text: options.text,
+        url: options.url
+      });
+    } else {
+      throw new Error("Share API not available");
+    }
+  },
+  isAvailable() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.share) {
+      return true;
+    }
+    return "share" in navigator;
+  }
+};
+var lifecycle = {
+  getState() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.lifecycle) {
+      return craft.lifecycle.getState();
+    }
+    return document.visibilityState === "visible" ? "active" : "background";
+  },
+  onStateChange(callback) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.lifecycle) {
+      return craft.lifecycle.onStateChange(callback);
+    }
+    const handler = () => {
+      callback(document.visibilityState === "visible" ? "active" : "background");
+    };
+    document.addEventListener("visibilitychange", handler);
+    return () => document.removeEventListener("visibilitychange", handler);
+  }
+};
+var notifications = {
+  async show(options) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.notifications) {
+      return craft.notifications.show(options);
+    }
+    if ("Notification" in window && Notification.permission === "granted") {
+      new Notification(options.title, { body: options.body });
+    }
+  },
+  async schedule(options) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.notifications) {
+      return craft.notifications.schedule(options);
+    }
+    throw new Error("Scheduled notifications not available in web");
+  },
+  async cancelAll() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.notifications) {
+      return craft.notifications.cancelAll();
+    }
+  },
+  async setBadge(count) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.notifications) {
+      return craft.notifications.setBadge(count);
+    }
+  }
+};
+var webWakeLock = null;
+var keepAwake = {
+  async enable() {
+    const craft = getCraftRoot();
+    if (craft?.setKeepAwake) {
+      await craft.setKeepAwake(true);
+      return;
+    }
+    const wakeLock = navigator.wakeLock;
+    webWakeLock = await wakeLock?.request("screen") ?? null;
+  },
+  async disable() {
+    const craft = getCraftRoot();
+    if (craft?.setKeepAwake) {
+      await craft.setKeepAwake(false);
+      return;
+    }
+    await webWakeLock?.release();
+    webWakeLock = null;
+  }
+};
+var deepLinks = {
+  async getInitialURL() {
+    return normalizeDeepLinkURL(await getCraftRoot()?.deepLinks?.getInitialURL?.());
+  },
+  onLink(callback) {
+    const craft = getCraftRoot();
+    if (craft?.deepLinks?.onLink) {
+      return craft.deepLinks.onLink((value) => {
+        const url = normalizeDeepLinkURL(value);
+        if (url)
+          callback(url);
+      }) ?? (() => {});
+    }
+    if (typeof globalThis === "undefined")
+      return () => {};
+    const listener = (event) => {
+      const url = normalizeDeepLinkURL(event.detail);
+      if (url)
+        callback(url);
+    };
+    globalThis.addEventListener("craftDeepLink", listener);
+    return () => globalThis.removeEventListener("craftDeepLink", listener);
+  }
+};
+function normalizeDeepLinkURL(value) {
+  if (typeof value === "string")
+    return value.trim() || null;
+  if (!value || typeof value !== "object")
+    return null;
+  const url = value.url;
+  return typeof url === "string" && url.trim() ? url : null;
+}
+var network = {
+  async getStatus() {
+    const craft = getCraftRoot();
+    if (craft?.getNetworkStatus)
+      return await craft.getNetworkStatus();
+    return {
+      type: "unknown",
+      isConnected: typeof navigator === "undefined" ? false : navigator.onLine
+    };
+  },
+  onChange(callback) {
+    const craft = getCraftRoot();
+    if (craft?.onNetworkChange) {
+      craft.onNetworkChange(callback);
+      return () => craft.offNetworkChange?.();
+    }
+    if (typeof globalThis === "undefined")
+      return () => {};
+    const listener = () => callback({ type: "unknown", isConnected: navigator.onLine });
+    globalThis.addEventListener("online", listener);
+    globalThis.addEventListener("offline", listener);
+    return () => {
+      globalThis.removeEventListener("online", listener);
+      globalThis.removeEventListener("offline", listener);
+    };
+  }
+};
+var appReview = {
+  async request() {
+    const craft = getCraftRoot();
+    if (!craft?.requestReview)
+      return false;
+    return Boolean(await craft.requestReview());
+  }
+};
+var pushNotifications = {
+  async register() {
+    const craft = getCraftRoot();
+    if (!craft?.registerPush)
+      throw new Error("Push notifications are unavailable");
+    return craft.registerPush();
+  },
+  onToken(callback) {
+    return onCraftEvent("craftPushToken", (detail) => callback(String(detail.token ?? "")));
+  },
+  onNotification(callback) {
+    return onCraftEvent("craftNotificationResponse", (detail) => callback(detail));
+  }
+};
+var health = {
+  async requestAuthorization(types) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.requestAuthorization)
+      throw new Error("Health data is unavailable");
+    return Boolean(await craft.health.requestAuthorization(types));
+  },
+  async getData(type, options = {}) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.getData)
+      throw new Error("Health data is unavailable");
+    return craft.health.getData(type, options);
+  },
+  async saveWorkout(workout) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.saveWorkout)
+      throw new Error("Saving health workouts is unavailable");
+    return craft.health.saveWorkout(workout);
+  }
+};
+var liveActivities = {
+  async start(options) {
+    const craft = getCraftRoot();
+    if (!craft?.liveActivity?.start)
+      throw new Error("Live Activities are unavailable");
+    return craft.liveActivity.start(options);
+  },
+  async update(state) {
+    const craft = getCraftRoot();
+    if (!craft?.liveActivity?.update)
+      return;
+    await craft.liveActivity.update(state);
+  },
+  async end() {
+    const craft = getCraftRoot();
+    if (!craft?.liveActivity?.end)
+      return;
+    await craft.liveActivity.end();
+  }
+};
+var watchConnectivity = {
+  async send(message) {
+    const craft = getCraftRoot();
+    if (!craft?.watch?.send)
+      throw new Error("Apple Watch connectivity is unavailable");
+    return craft.watch.send(message);
+  },
+  async updateContext(context) {
+    const craft = getCraftRoot();
+    if (!craft?.watch?.updateContext)
+      throw new Error("Apple Watch connectivity is unavailable");
+    await craft.watch.updateContext(context);
+  },
+  async isReachable() {
+    const result = await getCraftRoot()?.watch?.isReachable?.();
+    return Boolean(result?.reachable);
+  },
+  onMessage(callback) {
+    return onCraftEvent("craftWatchMessage", callback);
+  },
+  onReachabilityChange(callback) {
+    return onCraftEvent("craftWatchReachability", (detail) => callback(Boolean(detail.reachable)));
+  }
+};
+function onCraftEvent(eventName, callback) {
+  if (typeof globalThis === "undefined")
+    return () => {};
+  const listener = (event) => callback(event.detail ?? {});
+  globalThis.addEventListener(eventName, listener);
+  return () => globalThis.removeEventListener(eventName, listener);
+}
+function getCraftRoot() {
+  if (typeof window === "undefined")
+    return;
+  return window.craft;
+}
+function detectPlatform() {
+  if (typeof window === "undefined")
+    return "linux";
+  const ua = navigator.userAgent.toLowerCase();
+  if (/iphone|ipad|ipod/.test(ua))
+    return "ios";
+  if (/android/.test(ua))
+    return "android";
+  if (/macintosh|mac os x/.test(ua))
+    return "macos";
+  if (/windows/.test(ua))
+    return "windows";
+  return "linux";
+}
+function mapToWebPermission(permission) {
+  const mapping = {
+    camera: "camera",
+    microphone: "microphone",
+    location: "geolocation",
+    notifications: "notifications"
+  };
+  return mapping[permission] || null;
+}
+function mapWebPermissionStatus(state) {
+  const mapping = {
+    granted: "granted",
+    denied: "denied",
+    prompt: "undetermined"
+  };
+  return mapping[state];
+}
+function getCraftMobile() {
+  if (typeof window !== "undefined") {
+    return window.craft;
+  }
+  return;
+}
+export {
+  watchConnectivity,
+  share,
+  secureStorage,
+  pushNotifications,
+  permissions,
+  notifications,
+  normalizeDeepLinkURL,
+  network,
+  location,
+  liveActivities,
+  lifecycle,
+  keepAwake,
+  health,
+  haptics,
+  device,
+  deepLinks,
+  camera,
+  biometrics,
+  appReview,
+  _webFallbackDeviceId,
+  _resetWebFallbackDeviceIdForTests
+};