@aippy/runtime 0.1.0

package/dist/device/index.js

@@ -0,0 +1,457 @@
+import { c as createError } from "../errors-DAz5_jDJ.js";
+class CameraAPI {
+  stream = null;
+  /**
+   * Check if camera is supported
+   */
+  isSupported() {
+    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
+  }
+  /**
+   * Get camera stream
+   */
+  async getStream(options = {}) {
+    if (!this.isSupported()) {
+      throw createError("Camera API is not supported", "NOT_SUPPORTED");
+    }
+    try {
+      const constraints = {
+        video: {
+          width: options.width,
+          height: options.height,
+          facingMode: options.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"}`,
+        "PERMISSION_DENIED"
+      );
+    }
+  }
+  /**
+   * Capture photo from stream
+   */
+  async capturePhoto(options = {}) {
+    if (!this.stream) {
+      throw createError("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);
+      return {
+        blob,
+        dataUrl,
+        width: canvas.width,
+        height: canvas.height
+      };
+    } catch (error) {
+      throw createError(
+        `Failed to capture photo: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "UNKNOWN_ERROR"
+      );
+    }
+  }
+  /**
+   * Stop camera stream
+   */
+  stopStream() {
+    if (this.stream) {
+      this.stream.getTracks().forEach((track) => track.stop());
+      this.stream = null;
+    }
+  }
+}
+const camera = new CameraAPI();
+class GeolocationAPI {
+  /**
+   * Check if geolocation is supported
+   */
+  isSupported() {
+    return "geolocation" in navigator;
+  }
+  /**
+   * 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
+      };
+      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
+          };
+          resolve(result);
+        },
+        (error) => {
+          let errorCode = "UNKNOWN_ERROR";
+          let errorMessage = "Unknown geolocation error";
+          switch (error.code) {
+            case error.PERMISSION_DENIED:
+              errorCode = "PERMISSION_DENIED";
+              errorMessage = "Geolocation permission denied";
+              break;
+            case error.POSITION_UNAVAILABLE:
+              errorMessage = "Position unavailable";
+              break;
+            case error.TIMEOUT:
+              errorMessage = "Geolocation timeout";
+              break;
+          }
+          reject(createError(errorMessage, errorCode));
+        },
+        geoOptions
+      );
+    });
+  }
+  /**
+   * 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
+    };
+    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
+        };
+        callback(result);
+      },
+      (error) => {
+        console.error("Geolocation watch error:", error);
+      },
+      geoOptions
+    );
+  }
+  /**
+   * Clear position watch
+   */
+  clearWatch(watchId) {
+    navigator.geolocation.clearWatch(watchId);
+  }
+}
+const geolocation = new GeolocationAPI();
+class SensorsAPI {
+  /**
+   * Check if device orientation is supported
+   */
+  isOrientationSupported() {
+    return "DeviceOrientationEvent" in window;
+  }
+  /**
+   * Check if device motion is supported
+   */
+  isMotionSupported() {
+    return "DeviceMotionEvent" in window;
+  }
+  /**
+   * 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,
+          timestamp: Date.now()
+        });
+      };
+      window.addEventListener("deviceorientation", handleOrientation);
+      setTimeout(() => {
+        window.removeEventListener("deviceorientation", handleOrientation);
+        reject(createError("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,
+        timestamp: Date.now()
+      });
+    };
+    window.addEventListener("deviceorientation", handleOrientation);
+    return () => {
+      window.removeEventListener("deviceorientation", handleOrientation);
+    };
+  }
+  /**
+   * 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,
+          timestamp: Date.now()
+        });
+      };
+      window.addEventListener("devicemotion", handleMotion);
+      setTimeout(() => {
+        window.removeEventListener("devicemotion", handleMotion);
+        reject(createError("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,
+        timestamp: Date.now()
+      });
+    };
+    window.addEventListener("devicemotion", handleMotion);
+    return () => {
+      window.removeEventListener("devicemotion", handleMotion);
+    };
+  }
+  /**
+   * Request permission for motion sensors (iOS 13+)
+   */
+  async requestPermission() {
+    if (!this.isMotionSupported()) {
+      return false;
+    }
+    try {
+      const permission = await navigator.permissions?.query({ name: "accelerometer" });
+      return permission?.state === "granted";
+    } catch {
+      return false;
+    }
+  }
+}
+const sensors = new SensorsAPI();
+class FileSystemAPI {
+  /**
+   * Check if file system access is supported
+   */
+  isSupported() {
+    return "showOpenFilePicker" in window;
+  }
+  /**
+   * Check if legacy file input is supported
+   */
+  isLegacySupported() {
+    return typeof document !== "undefined" && "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");
+    }
+    try {
+      const pickerOptions = {
+        types: options.accept ? [{
+          description: "Files",
+          accept: Object.fromEntries(
+            options.accept.map((type) => [type, [type]])
+          )
+        }] : void 0,
+        multiple: options.multiple ?? false
+      };
+      const fileHandles = await window.showOpenFilePicker(pickerOptions);
+      const files = await Promise.all(
+        fileHandles.map(async (handle) => handle.getFile())
+      );
+      return {
+        files,
+        paths: files.map((file) => file.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"}`,
+        "PERMISSION_DENIED"
+      );
+    }
+  }
+  /**
+   * 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)
+        });
+      };
+      input.oncancel = () => {
+        reject(createError("File picker was cancelled", "PERMISSION_DENIED"));
+      };
+      input.click();
+    });
+  }
+  /**
+   * Open file picker with fallback
+   */
+  async openFile(options = {}) {
+    if (this.isSupported()) {
+      return await this.openFilePicker(options);
+    } else {
+      return await this.openFilePickerLegacy(options);
+    }
+  }
+  /**
+   * Save file
+   */
+  async saveFile(blob, filename) {
+    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"}`,
+        "UNKNOWN_ERROR"
+      );
+    }
+  }
+  /**
+   * 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);
+    });
+  }
+  /**
+   * 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);
+    });
+  }
+}
+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 = {
+        command: "navigator.vibrate",
+        parameters: pattern
+      };
+      window.webkit.messageHandlers.aippyListener.postMessage(data);
+      resolve();
+    } else {
+      console.warn("Vibration not supported in this environment");
+      resolve();
+    }
+  });
+}
+export {
+  CameraAPI,
+  FileSystemAPI,
+  GeolocationAPI,
+  SensorsAPI,
+  camera,
+  fileSystem,
+  geolocation,
+  sensors,
+  vibrate
+};

package/dist/device/sensors.d.ts

@@ -0,0 +1,38 @@
+import { SensorData } from './types';
+/**
+ * Device sensors functionality wrapper
+ */
+export declare class SensorsAPI {
+    /**
+     * Check if device orientation is supported
+     */
+    isOrientationSupported(): boolean;
+    /**
+     * Check if device motion is supported
+     */
+    isMotionSupported(): boolean;
+    /**
+     * Get device orientation data
+     */
+    getOrientation(): Promise<SensorData>;
+    /**
+     * Watch device orientation changes
+     */
+    watchOrientation(callback: (data: SensorData) => void): () => void;
+    /**
+     * Get device motion data
+     */
+    getMotion(): Promise<SensorData>;
+    /**
+     * Watch device motion changes
+     */
+    watchMotion(callback: (data: SensorData) => void): () => void;
+    /**
+     * Request permission for motion sensors (iOS 13+)
+     */
+    requestPermission(): Promise<boolean>;
+}
+/**
+ * Sensors API instance
+ */
+export declare const sensors: SensorsAPI;

package/dist/device/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Device-related types and interfaces
+ */
+export interface CameraOptions {
+    /** Video quality */
+    quality?: 'low' | 'medium' | 'high';
+    /** Video format */
+    format?: 'jpeg' | 'png' | 'webp';
+    /** Video width */
+    width?: number;
+    /** Video height */
+    height?: number;
+    /** Front camera preference */
+    facingMode?: 'user' | 'environment';
+}
+export interface CameraResult {
+    /** Captured image as blob */
+    blob: Blob;
+    /** Image data URL */
+    dataUrl: string;
+    /** Image dimensions */
+    width: number;
+    height: number;
+}
+export interface GeolocationOptions {
+    /** Enable high accuracy */
+    enableHighAccuracy?: boolean;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Maximum age of cached position */
+    maximumAge?: number;
+}
+export interface GeolocationResult {
+    /** Latitude */
+    latitude: number;
+    /** Longitude */
+    longitude: number;
+    /** Accuracy in meters */
+    accuracy: number;
+    /** Altitude in meters */
+    altitude?: number;
+    /** Altitude accuracy in meters */
+    altitudeAccuracy?: number;
+    /** Heading in degrees */
+    heading?: number;
+    /** Speed in meters per second */
+    speed?: number;
+    /** Timestamp */
+    timestamp: number;
+}
+export interface SensorData {
+    /** X-axis value */
+    x: number;
+    /** Y-axis value */
+    y: number;
+    /** Z-axis value */
+    z: number;
+    /** Timestamp */
+    timestamp: number;
+}
+export interface FileSystemOptions {
+    /** File types to accept */
+    accept?: string[];
+    /** Multiple file selection */
+    multiple?: boolean;
+    /** Directory selection */
+    directory?: boolean;
+}
+export interface FileSystemResult {
+    /** Selected files */
+    files: File[];
+    /** File paths */
+    paths: string[];
+}

package/dist/device.d.ts

@@ -0,0 +1,2 @@
+export * from './device/index'
+export {}

package/dist/errors-DAz5_jDJ.js

@@ -0,0 +1,25 @@
+class AippyRuntimeError extends Error {
+  code;
+  context;
+  constructor(message, code = "AIPPY_ERROR", context) {
+    super(message);
+    this.name = "AippyRuntimeError";
+    this.code = code;
+    this.context = context;
+  }
+}
+const ERROR_CODES = {
+  NOT_SUPPORTED: "NOT_SUPPORTED",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+function createError(message, code = "UNKNOWN_ERROR", context) {
+  return new AippyRuntimeError(message, ERROR_CODES[code], context);
+}
+export {
+  AippyRuntimeError as A,
+  ERROR_CODES as E,
+  createError as c
+};

package/dist/index/index.js

@@ -0,0 +1,33 @@
+import { DEFAULT_CONFIG, SDK_NAME, VERSION, getConfigFromEnv, getVersionInfo, mergeConfig } from "../core/index.js";
+import { A, E, c } from "../errors-DAz5_jDJ.js";
+import { CameraAPI, FileSystemAPI, GeolocationAPI, SensorsAPI, camera, fileSystem, geolocation, sensors, vibrate } from "../device/index.js";
+import { c as c2, a, P, b, p, d } from "../pwa-BkviTQoN.js";
+import { a as a2, b as b2 } from "../useTweaks-mK5PAWOs.js";
+export {
+  A as AippyRuntimeError,
+  CameraAPI,
+  DEFAULT_CONFIG,
+  E as ERROR_CODES,
+  FileSystemAPI,
+  GeolocationAPI,
+  c2 as PWAUtils,
+  a as PerformanceMonitor,
+  P as PlatformDetector,
+  SDK_NAME,
+  SensorsAPI,
+  VERSION,
+  a2 as aippyTweaks,
+  b2 as aippyTweaksRuntime,
+  camera,
+  c as createError,
+  fileSystem,
+  geolocation,
+  getConfigFromEnv,
+  getVersionInfo,
+  mergeConfig,
+  b as performanceMonitor,
+  p as platform,
+  d as pwa,
+  sensors,
+  vibrate
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './device';
+export * from './utils';
+export * from './tweaks';