@aippy/runtime 0.2.0 → 0.2.1

package/dist/device/index.js

@@ -1,6 +1,11 @@
-import { c as createError } from "../errors-DAz5_jDJ.js";
-class CameraAPI {
-  stream = null;
+var h = Object.defineProperty;
+var p = (n, e, t) => e in n ? h(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var m = (n, e, t) => p(n, typeof e != "symbol" ? e + "" : e, t);
+import { c as a } from "../errors-CDEBaBxB.js";
+class g {
+  constructor() {
+    m(this, "stream", null);
+  }
   /**
    * Check if camera is supported
    */
@@ -10,23 +15,21 @@ class CameraAPI {
   /**
    * Get camera stream
    */
-  async getStream(options = {}) {
-    if (!this.isSupported()) {
-      throw createError("Camera API is not supported", "NOT_SUPPORTED");
-    }
+  async getStream(e = {}) {
+    if (!this.isSupported())
+      throw a("Camera API is not supported", "NOT_SUPPORTED");
     try {
-      const constraints = {
+      const t = {
         video: {
-          width: options.width,
-          height: options.height,
-          facingMode: options.facingMode || "environment"
+          width: e.width,
+          height: e.height,
+          facingMode: e.facingMode || "environment"
         }
       };
-      this.stream = await navigator.mediaDevices.getUserMedia(constraints);
-      return this.stream;
-    } catch (error) {
-      throw createError(
-        `Failed to access camera: ${error instanceof Error ? error.message : "Unknown error"}`,
+      return this.stream = await navigator.mediaDevices.getUserMedia(t), this.stream;
+    } catch (t) {
+      throw a(
+        `Failed to access camera: ${t instanceof Error ? t.message : "Unknown error"}`,
         "PERMISSION_DENIED"
       );
     }
@@ -34,43 +37,30 @@ class CameraAPI {
   /**
    * Capture photo from stream
    */
-  async capturePhoto(options = {}) {
-    if (!this.stream) {
-      throw createError("No camera stream available", "NOT_SUPPORTED");
-    }
+  async capturePhoto(e = {}) {
+    if (!this.stream)
+      throw a("No camera stream available", "NOT_SUPPORTED");
     try {
-      const video = document.createElement("video");
-      video.srcObject = this.stream;
-      video.play();
-      const canvas = document.createElement("canvas");
-      const ctx = canvas.getContext("2d");
-      if (!ctx) {
-        throw createError("Failed to get canvas context", "UNKNOWN_ERROR");
-      }
-      canvas.width = options.width || video.videoWidth;
-      canvas.height = options.height || video.videoHeight;
-      ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-      const format = options.format || "jpeg";
-      const quality = options.quality === "high" ? 0.9 : options.quality === "medium" ? 0.7 : 0.5;
-      const blob = await new Promise((resolve, reject) => {
-        canvas.toBlob((blob2) => {
-          if (blob2) {
-            resolve(blob2);
-          } else {
-            reject(new Error("Failed to create blob"));
-          }
-        }, `image/${format}`, quality);
-      });
-      const dataUrl = canvas.toDataURL(`image/${format}`, quality);
+      const t = document.createElement("video");
+      t.srcObject = this.stream, t.play();
+      const o = document.createElement("canvas"), i = o.getContext("2d");
+      if (!i)
+        throw a("Failed to get canvas context", "UNKNOWN_ERROR");
+      o.width = e.width || t.videoWidth, o.height = e.height || t.videoHeight, i.drawImage(t, 0, 0, o.width, o.height);
+      const r = e.format || "jpeg", c = e.quality === "high" ? 0.9 : e.quality === "medium" ? 0.7 : 0.5, s = await new Promise((u, w) => {
+        o.toBlob((l) => {
+          l ? u(l) : w(new Error("Failed to create blob"));
+        }, `image/${r}`, c);
+      }), d = o.toDataURL(`image/${r}`, c);
       return {
-        blob,
-        dataUrl,
-        width: canvas.width,
-        height: canvas.height
+        blob: s,
+        dataUrl: d,
+        width: o.width,
+        height: o.height
       };
-    } catch (error) {
-      throw createError(
-        `Failed to capture photo: ${error instanceof Error ? error.message : "Unknown error"}`,
+    } catch (t) {
+      throw a(
+        `Failed to capture photo: ${t instanceof Error ? t.message : "Unknown error"}`,
         "UNKNOWN_ERROR"
       );
     }
@@ -79,14 +69,11 @@ class CameraAPI {
    * Stop camera stream
    */
   stopStream() {
-    if (this.stream) {
-      this.stream.getTracks().forEach((track) => track.stop());
-      this.stream = null;
-    }
+    this.stream && (this.stream.getTracks().forEach((e) => e.stop()), this.stream = null);
   }
 }
-const camera = new CameraAPI();
-class GeolocationAPI {
+const f = new g();
+class v {
   /**
    * Check if geolocation is supported
    */
@@ -96,92 +83,88 @@ class GeolocationAPI {
   /**
    * Get current position
    */
-  async getCurrentPosition(options = {}) {
-    if (!this.isSupported()) {
-      throw createError("Geolocation API is not supported", "NOT_SUPPORTED");
-    }
-    return new Promise((resolve, reject) => {
-      const geoOptions = {
-        enableHighAccuracy: options.enableHighAccuracy ?? true,
-        timeout: options.timeout ?? 1e4,
-        maximumAge: options.maximumAge ?? 6e4
+  async getCurrentPosition(e = {}) {
+    if (!this.isSupported())
+      throw a("Geolocation API is not supported", "NOT_SUPPORTED");
+    return new Promise((t, o) => {
+      const i = {
+        enableHighAccuracy: e.enableHighAccuracy ?? !0,
+        timeout: e.timeout ?? 1e4,
+        maximumAge: e.maximumAge ?? 6e4
       };
       navigator.geolocation.getCurrentPosition(
-        (position) => {
-          const result = {
-            latitude: position.coords.latitude,
-            longitude: position.coords.longitude,
-            accuracy: position.coords.accuracy,
-            altitude: position.coords.altitude ?? void 0,
-            altitudeAccuracy: position.coords.altitudeAccuracy ?? void 0,
-            heading: position.coords.heading ?? void 0,
-            speed: position.coords.speed ?? void 0,
-            timestamp: position.timestamp
+        (r) => {
+          const c = {
+            latitude: r.coords.latitude,
+            longitude: r.coords.longitude,
+            accuracy: r.coords.accuracy,
+            altitude: r.coords.altitude ?? void 0,
+            altitudeAccuracy: r.coords.altitudeAccuracy ?? void 0,
+            heading: r.coords.heading ?? void 0,
+            speed: r.coords.speed ?? void 0,
+            timestamp: r.timestamp
           };
-          resolve(result);
+          t(c);
         },
-        (error) => {
-          let errorCode = "UNKNOWN_ERROR";
-          let errorMessage = "Unknown geolocation error";
-          switch (error.code) {
-            case error.PERMISSION_DENIED:
-              errorCode = "PERMISSION_DENIED";
-              errorMessage = "Geolocation permission denied";
+        (r) => {
+          let c = "UNKNOWN_ERROR", s = "Unknown geolocation error";
+          switch (r.code) {
+            case r.PERMISSION_DENIED:
+              c = "PERMISSION_DENIED", s = "Geolocation permission denied";
               break;
-            case error.POSITION_UNAVAILABLE:
-              errorMessage = "Position unavailable";
+            case r.POSITION_UNAVAILABLE:
+              s = "Position unavailable";
               break;
-            case error.TIMEOUT:
-              errorMessage = "Geolocation timeout";
+            case r.TIMEOUT:
+              s = "Geolocation timeout";
               break;
           }
-          reject(createError(errorMessage, errorCode));
+          o(a(s, c));
         },
-        geoOptions
+        i
       );
     });
   }
   /**
    * Watch position changes
    */
-  watchPosition(callback, options = {}) {
-    if (!this.isSupported()) {
-      throw createError("Geolocation API is not supported", "NOT_SUPPORTED");
-    }
-    const geoOptions = {
-      enableHighAccuracy: options.enableHighAccuracy ?? true,
-      timeout: options.timeout ?? 1e4,
-      maximumAge: options.maximumAge ?? 6e4
+  watchPosition(e, t = {}) {
+    if (!this.isSupported())
+      throw a("Geolocation API is not supported", "NOT_SUPPORTED");
+    const o = {
+      enableHighAccuracy: t.enableHighAccuracy ?? !0,
+      timeout: t.timeout ?? 1e4,
+      maximumAge: t.maximumAge ?? 6e4
     };
     return navigator.geolocation.watchPosition(
-      (position) => {
-        const result = {
-          latitude: position.coords.latitude,
-          longitude: position.coords.longitude,
-          accuracy: position.coords.accuracy,
-          altitude: position.coords.altitude ?? void 0,
-          altitudeAccuracy: position.coords.altitudeAccuracy ?? void 0,
-          heading: position.coords.heading ?? void 0,
-          speed: position.coords.speed ?? void 0,
-          timestamp: position.timestamp
+      (i) => {
+        const r = {
+          latitude: i.coords.latitude,
+          longitude: i.coords.longitude,
+          accuracy: i.coords.accuracy,
+          altitude: i.coords.altitude ?? void 0,
+          altitudeAccuracy: i.coords.altitudeAccuracy ?? void 0,
+          heading: i.coords.heading ?? void 0,
+          speed: i.coords.speed ?? void 0,
+          timestamp: i.timestamp
         };
-        callback(result);
+        e(r);
       },
-      (error) => {
-        console.error("Geolocation watch error:", error);
+      (i) => {
+        console.error("Geolocation watch error:", i);
       },
-      geoOptions
+      o
     );
   }
   /**
    * Clear position watch
    */
-  clearWatch(watchId) {
-    navigator.geolocation.clearWatch(watchId);
+  clearWatch(e) {
+    navigator.geolocation.clearWatch(e);
   }
 }
-const geolocation = new GeolocationAPI();
-class SensorsAPI {
+const N = new v();
+class E {
   /**
    * Check if device orientation is supported
    */
@@ -198,107 +181,93 @@ class SensorsAPI {
    * Get device orientation data
    */
   async getOrientation() {
-    if (!this.isOrientationSupported()) {
-      throw createError("Device orientation API is not supported", "NOT_SUPPORTED");
-    }
-    return new Promise((resolve, reject) => {
-      const handleOrientation = (event) => {
-        window.removeEventListener("deviceorientation", handleOrientation);
-        resolve({
-          x: event.alpha ?? 0,
-          y: event.beta ?? 0,
-          z: event.gamma ?? 0,
+    if (!this.isOrientationSupported())
+      throw a("Device orientation API is not supported", "NOT_SUPPORTED");
+    return new Promise((e, t) => {
+      const o = (i) => {
+        window.removeEventListener("deviceorientation", o), e({
+          x: i.alpha ?? 0,
+          y: i.beta ?? 0,
+          z: i.gamma ?? 0,
           timestamp: Date.now()
         });
       };
-      window.addEventListener("deviceorientation", handleOrientation);
-      setTimeout(() => {
-        window.removeEventListener("deviceorientation", handleOrientation);
-        reject(createError("Device orientation timeout", "UNKNOWN_ERROR"));
+      window.addEventListener("deviceorientation", o), setTimeout(() => {
+        window.removeEventListener("deviceorientation", o), t(a("Device orientation timeout", "UNKNOWN_ERROR"));
       }, 5e3);
     });
   }
   /**
    * Watch device orientation changes
    */
-  watchOrientation(callback) {
-    if (!this.isOrientationSupported()) {
-      throw createError("Device orientation API is not supported", "NOT_SUPPORTED");
-    }
-    const handleOrientation = (event) => {
-      callback({
-        x: event.alpha ?? 0,
-        y: event.beta ?? 0,
-        z: event.gamma ?? 0,
+  watchOrientation(e) {
+    if (!this.isOrientationSupported())
+      throw a("Device orientation API is not supported", "NOT_SUPPORTED");
+    const t = (o) => {
+      e({
+        x: o.alpha ?? 0,
+        y: o.beta ?? 0,
+        z: o.gamma ?? 0,
         timestamp: Date.now()
       });
     };
-    window.addEventListener("deviceorientation", handleOrientation);
-    return () => {
-      window.removeEventListener("deviceorientation", handleOrientation);
+    return window.addEventListener("deviceorientation", t), () => {
+      window.removeEventListener("deviceorientation", t);
     };
   }
   /**
    * Get device motion data
    */
   async getMotion() {
-    if (!this.isMotionSupported()) {
-      throw createError("Device motion API is not supported", "NOT_SUPPORTED");
-    }
-    return new Promise((resolve, reject) => {
-      const handleMotion = (event) => {
-        window.removeEventListener("devicemotion", handleMotion);
-        resolve({
-          x: event.acceleration?.x ?? 0,
-          y: event.acceleration?.y ?? 0,
-          z: event.acceleration?.z ?? 0,
+    if (!this.isMotionSupported())
+      throw a("Device motion API is not supported", "NOT_SUPPORTED");
+    return new Promise((e, t) => {
+      const o = (i) => {
+        window.removeEventListener("devicemotion", o), e({
+          x: i.acceleration?.x ?? 0,
+          y: i.acceleration?.y ?? 0,
+          z: i.acceleration?.z ?? 0,
           timestamp: Date.now()
         });
       };
-      window.addEventListener("devicemotion", handleMotion);
-      setTimeout(() => {
-        window.removeEventListener("devicemotion", handleMotion);
-        reject(createError("Device motion timeout", "UNKNOWN_ERROR"));
+      window.addEventListener("devicemotion", o), setTimeout(() => {
+        window.removeEventListener("devicemotion", o), t(a("Device motion timeout", "UNKNOWN_ERROR"));
       }, 5e3);
     });
   }
   /**
    * Watch device motion changes
    */
-  watchMotion(callback) {
-    if (!this.isMotionSupported()) {
-      throw createError("Device motion API is not supported", "NOT_SUPPORTED");
-    }
-    const handleMotion = (event) => {
-      callback({
-        x: event.acceleration?.x ?? 0,
-        y: event.acceleration?.y ?? 0,
-        z: event.acceleration?.z ?? 0,
+  watchMotion(e) {
+    if (!this.isMotionSupported())
+      throw a("Device motion API is not supported", "NOT_SUPPORTED");
+    const t = (o) => {
+      e({
+        x: o.acceleration?.x ?? 0,
+        y: o.acceleration?.y ?? 0,
+        z: o.acceleration?.z ?? 0,
         timestamp: Date.now()
       });
     };
-    window.addEventListener("devicemotion", handleMotion);
-    return () => {
-      window.removeEventListener("devicemotion", handleMotion);
+    return window.addEventListener("devicemotion", t), () => {
+      window.removeEventListener("devicemotion", t);
     };
   }
   /**
    * Request permission for motion sensors (iOS 13+)
    */
   async requestPermission() {
-    if (!this.isMotionSupported()) {
-      return false;
-    }
+    if (!this.isMotionSupported())
+      return !1;
     try {
-      const permission = await navigator.permissions?.query({ name: "accelerometer" });
-      return permission?.state === "granted";
+      return (await navigator.permissions?.query({ name: "accelerometer" }))?.state === "granted";
     } catch {
-      return false;
+      return !1;
     }
   }
 }
-const sensors = new SensorsAPI();
-class FileSystemAPI {
+const R = new E();
+class O {
   /**
    * Check if file system access is supported
    */
@@ -309,39 +278,33 @@ class FileSystemAPI {
    * Check if legacy file input is supported
    */
   isLegacySupported() {
-    return typeof document !== "undefined" && "createElement" in document;
+    return typeof document < "u" && "createElement" in document;
   }
   /**
    * Open file picker (modern API)
    */
-  async openFilePicker(options = {}) {
-    if (!this.isSupported()) {
-      throw createError("File System Access API is not supported", "NOT_SUPPORTED");
-    }
+  async openFilePicker(e = {}) {
+    if (!this.isSupported())
+      throw a("File System Access API is not supported", "NOT_SUPPORTED");
     try {
-      const pickerOptions = {
-        types: options.accept ? [{
+      const t = {
+        types: e.accept ? [{
           description: "Files",
           accept: Object.fromEntries(
-            options.accept.map((type) => [type, [type]])
+            e.accept.map((r) => [r, [r]])
           )
         }] : void 0,
-        multiple: options.multiple ?? false
-      };
-      const fileHandles = await window.showOpenFilePicker(pickerOptions);
-      const files = await Promise.all(
-        fileHandles.map(async (handle) => handle.getFile())
+        multiple: e.multiple ?? !1
+      }, o = await window.showOpenFilePicker(t), i = await Promise.all(
+        o.map(async (r) => r.getFile())
       );
       return {
-        files,
-        paths: files.map((file) => file.name)
+        files: i,
+        paths: i.map((r) => r.name)
       };
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw createError("File picker was cancelled", "PERMISSION_DENIED");
-      }
-      throw createError(
-        `Failed to open file picker: ${error instanceof Error ? error.message : "Unknown error"}`,
+    } catch (t) {
+      throw t instanceof Error && t.name === "AbortError" ? a("File picker was cancelled", "PERMISSION_DENIED") : a(
+        `Failed to open file picker: ${t instanceof Error ? t.message : "Unknown error"}`,
         "PERMISSION_DENIED"
       );
     }
@@ -349,55 +312,38 @@ class FileSystemAPI {
   /**
    * Open file picker (legacy fallback)
    */
-  async openFilePickerLegacy(options = {}) {
-    if (!this.isLegacySupported()) {
-      throw createError("File input is not supported", "NOT_SUPPORTED");
-    }
-    return new Promise((resolve, reject) => {
-      const input = document.createElement("input");
-      input.type = "file";
-      input.multiple = options.multiple ?? false;
-      input.accept = options.accept?.join(",") ?? "";
-      input.onchange = (event) => {
-        const target = event.target;
-        const files = Array.from(target.files || []);
-        resolve({
-          files,
-          paths: files.map((file) => file.name)
+  async openFilePickerLegacy(e = {}) {
+    if (!this.isLegacySupported())
+      throw a("File input is not supported", "NOT_SUPPORTED");
+    return new Promise((t, o) => {
+      const i = document.createElement("input");
+      i.type = "file", i.multiple = e.multiple ?? !1, i.accept = e.accept?.join(",") ?? "", i.onchange = (r) => {
+        const c = r.target, s = Array.from(c.files || []);
+        t({
+          files: s,
+          paths: s.map((d) => d.name)
         });
-      };
-      input.oncancel = () => {
-        reject(createError("File picker was cancelled", "PERMISSION_DENIED"));
-      };
-      input.click();
+      }, i.oncancel = () => {
+        o(a("File picker was cancelled", "PERMISSION_DENIED"));
+      }, i.click();
     });
   }
   /**
    * Open file picker with fallback
    */
-  async openFile(options = {}) {
-    if (this.isSupported()) {
-      return await this.openFilePicker(options);
-    } else {
-      return await this.openFilePickerLegacy(options);
-    }
+  async openFile(e = {}) {
+    return this.isSupported() ? await this.openFilePicker(e) : await this.openFilePickerLegacy(e);
   }
   /**
    * Save file
    */
-  async saveFile(blob, filename) {
+  async saveFile(e, t) {
     try {
-      const url = URL.createObjectURL(blob);
-      const a = document.createElement("a");
-      a.href = url;
-      a.download = filename;
-      document.body.appendChild(a);
-      a.click();
-      document.body.removeChild(a);
-      URL.revokeObjectURL(url);
-    } catch (error) {
-      throw createError(
-        `Failed to save file: ${error instanceof Error ? error.message : "Unknown error"}`,
+      const o = URL.createObjectURL(e), i = document.createElement("a");
+      i.href = o, i.download = t, document.body.appendChild(i), i.click(), document.body.removeChild(i), URL.revokeObjectURL(o);
+    } catch (o) {
+      throw a(
+        `Failed to save file: ${o instanceof Error ? o.message : "Unknown error"}`,
         "UNKNOWN_ERROR"
       );
     }
@@ -405,53 +351,45 @@ class FileSystemAPI {
   /**
    * Read file as text
    */
-  async readAsText(file) {
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => resolve(reader.result);
-      reader.onerror = () => reject(createError("Failed to read file", "UNKNOWN_ERROR"));
-      reader.readAsText(file);
+  async readAsText(e) {
+    return new Promise((t, o) => {
+      const i = new FileReader();
+      i.onload = () => t(i.result), i.onerror = () => o(a("Failed to read file", "UNKNOWN_ERROR")), i.readAsText(e);
     });
   }
   /**
    * Read file as data URL
    */
-  async readAsDataURL(file) {
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => resolve(reader.result);
-      reader.onerror = () => reject(createError("Failed to read file", "UNKNOWN_ERROR"));
-      reader.readAsDataURL(file);
+  async readAsDataURL(e) {
+    return new Promise((t, o) => {
+      const i = new FileReader();
+      i.onload = () => t(i.result), i.onerror = () => o(a("Failed to read file", "UNKNOWN_ERROR")), i.readAsDataURL(e);
     });
   }
 }
-const fileSystem = new FileSystemAPI();
-function vibrate(pattern) {
-  return new Promise((resolve) => {
-    if ("vibrate" in navigator) {
-      navigator.vibrate(pattern);
-      resolve();
-    } else if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.aippyListener) {
-      const data = {
+const S = new O();
+function D(n) {
+  return new Promise((e) => {
+    if ("vibrate" in navigator)
+      navigator.vibrate(n), e();
+    else if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.aippyListener) {
+      const t = {
         command: "navigator.vibrate",
-        parameters: pattern
+        parameters: n
       };
-      window.webkit.messageHandlers.aippyListener.postMessage(data);
-      resolve();
-    } else {
-      console.warn("Vibration not supported in this environment");
-      resolve();
-    }
+      window.webkit.messageHandlers.aippyListener.postMessage(t), e();
+    } else
+      console.warn("Vibration not supported in this environment"), e();
   });
 }
 export {
-  CameraAPI,
-  FileSystemAPI,
-  GeolocationAPI,
-  SensorsAPI,
-  camera,
-  fileSystem,
-  geolocation,
-  sensors,
-  vibrate
+  g as CameraAPI,
+  O as FileSystemAPI,
+  v as GeolocationAPI,
+  E as SensorsAPI,
+  f as camera,
+  S as fileSystem,
+  N as geolocation,
+  R as sensors,
+  D as vibrate
 };