@aippy/runtime 0.2.0 → 0.2.1

package/dist/errors-CDEBaBxB.js

@@ -0,0 +1,26 @@
+var e = Object.defineProperty;
+var o = (E, R, N) => R in E ? e(E, R, { enumerable: !0, configurable: !0, writable: !0, value: N }) : E[R] = N;
+var O = (E, R, N) => o(E, typeof R != "symbol" ? R + "" : R, N);
+class I extends Error {
+  constructor(N, r = "AIPPY_ERROR", t) {
+    super(N);
+    O(this, "code");
+    O(this, "context");
+    this.name = "AippyRuntimeError", this.code = r, this.context = t;
+  }
+}
+const _ = {
+  NOT_SUPPORTED: "NOT_SUPPORTED",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+function s(E, R = "UNKNOWN_ERROR", N) {
+  return new I(E, _[R], N);
+}
+export {
+  I as A,
+  _ as E,
+  s as c
+};

package/dist/index/index.js

@@ -1,40 +1,40 @@
-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";
-import { c as c3, a as a3, i, b as b3, p as p2, u } from "../useAudioContext-D9Y4gIw9.js";
+import { DEFAULT_CONFIG as o, SDK_NAME as r, VERSION as t, getConfigFromEnv as s, getVersionInfo as i, mergeConfig as m } from "../core/index.js";
+import { A as p, E as c, c as f } from "../errors-CDEBaBxB.js";
+import { CameraAPI as A, FileSystemAPI as E, GeolocationAPI as l, SensorsAPI as S, camera as u, fileSystem as x, geolocation as I, sensors as P, vibrate as C } from "../device/index.js";
+import { c as R, a as y, P as D, b as M, p as O, d as b } from "../pwa-DPd78fwK.js";
+import { a as v, b as w } from "../useTweaks-Bc26i-fJ.js";
+import { c as T, a as V, i as _, b as k, p as G, u as H } from "../useAudioContext-DaLkaQ8P.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,
-  c3 as createHiddenMediaElement,
-  a3 as createHiddenVideoElement,
-  fileSystem,
-  geolocation,
-  getConfigFromEnv,
-  getVersionInfo,
-  i as isIOSDevice,
-  b3 as isMediaStreamAudioSupported,
-  mergeConfig,
-  p2 as patchAudioContext,
-  b as performanceMonitor,
-  p as platform,
-  d as pwa,
-  sensors,
-  u as useAudioContext,
-  vibrate
+  p as AippyRuntimeError,
+  A as CameraAPI,
+  o as DEFAULT_CONFIG,
+  c as ERROR_CODES,
+  E as FileSystemAPI,
+  l as GeolocationAPI,
+  R as PWAUtils,
+  y as PerformanceMonitor,
+  D as PlatformDetector,
+  r as SDK_NAME,
+  S as SensorsAPI,
+  t as VERSION,
+  v as aippyTweaks,
+  w as aippyTweaksRuntime,
+  u as camera,
+  f as createError,
+  T as createHiddenMediaElement,
+  V as createHiddenVideoElement,
+  x as fileSystem,
+  I as geolocation,
+  s as getConfigFromEnv,
+  i as getVersionInfo,
+  _ as isIOSDevice,
+  k as isMediaStreamAudioSupported,
+  m as mergeConfig,
+  G as patchAudioContext,
+  M as performanceMonitor,
+  O as platform,
+  b as pwa,
+  P as sensors,
+  H as useAudioContext,
+  C as vibrate
 };

package/dist/pwa-DPd78fwK.js

@@ -0,0 +1,342 @@
+var u = Object.defineProperty;
+var f = (o, e, r) => e in o ? u(o, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : o[e] = r;
+var l = (o, e, r) => f(o, typeof e != "symbol" ? e + "" : e, r);
+import { UAParser as m } from "ua-parser-js";
+class p {
+  constructor() {
+    l(this, "parser");
+    this.parser = new m();
+  }
+  /**
+   * Get platform information
+   */
+  getPlatformInfo() {
+    const e = this.parser.getResult(), r = this.normalizePlatformName(e.os.name), t = this.normalizeBrowserName(e.browser.name), n = this.isMobileDevice(), i = !n;
+    return {
+      name: r,
+      version: e.os.version,
+      browser: t,
+      browserVersion: e.browser.version,
+      isMobile: n,
+      isDesktop: i
+    };
+  }
+  /**
+   * Get platform capabilities
+   */
+  getCapabilities() {
+    return {
+      serviceWorker: "serviceWorker" in navigator,
+      pushNotifications: "PushManager" in window,
+      webShare: "share" in navigator,
+      clipboard: "clipboard" in navigator,
+      webRTC: !!(window.RTCPeerConnection || window.webkitRTCPeerConnection),
+      webGL: !!this.getWebGLContext(),
+      webAssembly: "WebAssembly" in window
+    };
+  }
+  /**
+   * Check if device is mobile
+   */
+  isMobileDevice() {
+    const e = navigator.userAgent;
+    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(e) || this.isTouchDevice();
+  }
+  /**
+   * Check if device supports touch
+   */
+  isTouchDevice() {
+    return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+  }
+  /**
+   * Check if running in standalone mode (PWA)
+   */
+  isStandalone() {
+    return window.matchMedia("(display-mode: standalone)").matches || window.navigator.standalone === !0;
+  }
+  /**
+   * Check if running in iOS Safari
+   */
+  isIOSSafari() {
+    const e = this.getPlatformInfo();
+    return e.name === "ios" && e.browser === "safari";
+  }
+  /**
+   * Check if running in Android Chrome
+   */
+  isAndroidChrome() {
+    const e = this.getPlatformInfo();
+    return e.name === "android" && e.browser === "chrome";
+  }
+  normalizePlatformName(e) {
+    if (!e) return "unknown";
+    const r = e.toLowerCase();
+    return r.includes("ios") ? "ios" : r.includes("android") ? "android" : r.includes("windows") ? "windows" : r.includes("mac") ? "macos" : r.includes("linux") ? "linux" : "unknown";
+  }
+  normalizeBrowserName(e) {
+    if (!e) return "unknown";
+    const r = e.toLowerCase();
+    return r.includes("chrome") ? "chrome" : r.includes("firefox") ? "firefox" : r.includes("safari") ? "safari" : r.includes("edge") ? "edge" : "unknown";
+  }
+  getWebGLContext() {
+    try {
+      const e = document.createElement("canvas");
+      return e.getContext("webgl") || e.getContext("experimental-webgl");
+    } catch {
+      return null;
+    }
+  }
+}
+const y = new p();
+class w {
+  /**
+   * Get Core Web Vitals metrics
+   */
+  async getCoreWebVitals() {
+    const e = {};
+    try {
+      const r = performance.getEntriesByName("first-contentful-paint")[0];
+      r && (e.fcp = r.startTime);
+      const t = performance.getEntriesByType("largest-contentful-paint");
+      if (t.length > 0) {
+        const s = t[t.length - 1];
+        e.lcp = s.startTime;
+      }
+      const n = performance.getEntriesByType("first-input");
+      if (n.length > 0) {
+        const s = n[0];
+        e.fid = s.processingStart - s.startTime;
+      }
+      const i = performance.getEntriesByType("layout-shift");
+      if (i.length > 0) {
+        let s = 0;
+        for (const d of i) {
+          const c = d;
+          c.hadRecentInput || (s += c.value);
+        }
+        e.cls = s;
+      }
+      const a = this.calculateTTI();
+      a && (e.tti = a);
+    } catch (r) {
+      console.warn("Failed to get Core Web Vitals:", r);
+    }
+    return e;
+  }
+  /**
+   * Get navigation timing metrics
+   */
+  getNavigationTiming() {
+    const e = performance.getEntriesByType("navigation")[0];
+    return e ? {
+      // DNS lookup time
+      dns: e.domainLookupEnd - e.domainLookupStart,
+      // TCP connection time
+      tcp: e.connectEnd - e.connectStart,
+      // Request time
+      request: e.responseStart - e.requestStart,
+      // Response time
+      response: e.responseEnd - e.responseStart,
+      // DOM processing time
+      domProcessing: e.domComplete - e.domInteractive,
+      // Total page load time
+      total: e.loadEventEnd - e.fetchStart
+    } : null;
+  }
+  /**
+   * Get resource timing metrics
+   */
+  getResourceTiming() {
+    return performance.getEntriesByType("resource").map((r) => ({
+      name: r.name,
+      duration: r.duration,
+      size: r.transferSize,
+      type: this.getResourceType(r.name)
+    }));
+  }
+  /**
+   * Measure function execution time
+   */
+  measureFunction(e, r) {
+    const t = performance.now(), n = e(), i = performance.now();
+    return r && (performance.mark(`${r}-start`), performance.mark(`${r}-end`), performance.measure(r, `${r}-start`, `${r}-end`)), console.log(`Function ${r || "anonymous"} took ${i - t} milliseconds`), n;
+  }
+  /**
+   * Measure async function execution time
+   */
+  async measureAsyncFunction(e, r) {
+    const t = performance.now(), n = await e(), i = performance.now();
+    return r && (performance.mark(`${r}-start`), performance.mark(`${r}-end`), performance.measure(r, `${r}-start`, `${r}-end`)), console.log(`Async function ${r || "anonymous"} took ${i - t} milliseconds`), n;
+  }
+  /**
+   * Get memory usage (if available)
+   */
+  getMemoryUsage() {
+    if ("memory" in performance) {
+      const e = performance.memory;
+      return {
+        used: e.usedJSHeapSize,
+        total: e.totalJSHeapSize,
+        limit: e.jsHeapSizeLimit
+      };
+    }
+    return null;
+  }
+  calculateTTI() {
+    const e = performance.getEntriesByType("navigation")[0];
+    return e ? e.domContentLoadedEventEnd - e.fetchStart : null;
+  }
+  getResourceType(e) {
+    return e.includes(".js") ? "script" : e.includes(".css") ? "stylesheet" : e.includes(".png") || e.includes(".jpg") || e.includes(".gif") ? "image" : e.includes(".woff") || e.includes(".ttf") ? "font" : "other";
+  }
+}
+const b = new w();
+class g {
+  /**
+   * Get PWA information
+   */
+  getPWAInfo() {
+    return {
+      isInstalled: this.isInstalled(),
+      isInstallable: this.isInstallable(),
+      canInstall: this.canInstall(),
+      isStandalone: this.isStandalone()
+    };
+  }
+  /**
+   * Check if PWA is installed
+   */
+  isInstalled() {
+    return this.isStandalone() || this.isInApp();
+  }
+  /**
+   * Check if PWA is installable
+   */
+  isInstallable() {
+    return "serviceWorker" in navigator && "PushManager" in window;
+  }
+  /**
+   * Check if install prompt is available
+   */
+  canInstall() {
+    return this.isInstallable() && !this.isInstalled();
+  }
+  /**
+   * Check if running in standalone mode
+   */
+  isStandalone() {
+    return window.matchMedia("(display-mode: standalone)").matches || window.navigator.standalone === !0;
+  }
+  /**
+   * Check if running in app (iOS)
+   */
+  isInApp() {
+    return window.navigator.standalone === !0;
+  }
+  /**
+   * Register service worker
+   */
+  async registerServiceWorker(e) {
+    if (!("serviceWorker" in navigator))
+      return console.warn("Service Worker not supported"), null;
+    try {
+      const r = await navigator.serviceWorker.register(e);
+      return console.log("Service Worker registered:", r), r;
+    } catch (r) {
+      return console.error("Service Worker registration failed:", r), null;
+    }
+  }
+  /**
+   * Unregister service worker
+   */
+  async unregisterServiceWorker() {
+    if (!("serviceWorker" in navigator))
+      return !1;
+    try {
+      const e = await navigator.serviceWorker.getRegistrations();
+      for (const r of e)
+        await r.unregister();
+      return !0;
+    } catch (e) {
+      return console.error("Service Worker unregistration failed:", e), !1;
+    }
+  }
+  /**
+   * Request notification permission
+   */
+  async requestNotificationPermission() {
+    if (!("Notification" in window))
+      throw new Error("Notifications not supported");
+    return Notification.permission === "granted" ? "granted" : Notification.permission === "denied" ? "denied" : await Notification.requestPermission();
+  }
+  /**
+   * Send notification
+   */
+  async sendNotification(e, r) {
+    if (!("Notification" in window))
+      throw new Error("Notifications not supported");
+    if (Notification.permission !== "granted")
+      throw new Error("Notification permission not granted");
+    const t = new Notification(e, r);
+    setTimeout(() => {
+      t.close();
+    }, 5e3);
+  }
+  /**
+   * Share content using Web Share API
+   */
+  async share(e) {
+    if (!("share" in navigator))
+      throw new Error("Web Share API not supported");
+    try {
+      await navigator.share(e);
+    } catch (r) {
+      if (r instanceof Error && r.name !== "AbortError")
+        throw new Error(`Share failed: ${r.message}`);
+    }
+  }
+  /**
+   * Copy text to clipboard
+   */
+  async copyToClipboard(e) {
+    if (!("clipboard" in navigator))
+      throw new Error("Clipboard API not supported");
+    try {
+      await navigator.clipboard.writeText(e);
+    } catch (r) {
+      throw new Error(`Copy to clipboard failed: ${r instanceof Error ? r.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Read text from clipboard
+   */
+  async readFromClipboard() {
+    if (!("clipboard" in navigator))
+      throw new Error("Clipboard API not supported");
+    try {
+      return await navigator.clipboard.readText();
+    } catch (e) {
+      throw new Error(`Read from clipboard failed: ${e instanceof Error ? e.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get install prompt event
+   */
+  getInstallPromptEvent() {
+    return new Promise((e) => {
+      const r = (t) => {
+        t.preventDefault(), e(t), window.removeEventListener("beforeinstallprompt", r);
+      };
+      window.addEventListener("beforeinstallprompt", r);
+    });
+  }
+}
+const E = new g();
+export {
+  p as P,
+  w as a,
+  b,
+  g as c,
+  E as d,
+  y as p
+};

package/dist/tweaks/index.js

@@ -1,5 +1,5 @@
-import { a, b } from "../useTweaks-mK5PAWOs.js";
+import { a as e, b as s } from "../useTweaks-Bc26i-fJ.js";
 export {
-  a as aippyTweaks,
-  b as aippyTweaksRuntime
+  e as aippyTweaks,
+  s as aippyTweaksRuntime
 };

package/dist/useAudioContext-DaLkaQ8P.js

@@ -0,0 +1,223 @@
+var v = Object.defineProperty;
+var S = (e, t, n) => t in e ? v(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var s = (e, t, n) => S(e, typeof t != "symbol" ? t + "" : t, n);
+import { useState as k, useRef as w, useEffect as p } from "react";
+function T() {
+  const e = navigator.userAgent;
+  return !!(/iPad|iPhone|iPod/.test(e) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1);
+}
+function P() {
+  try {
+    if (!window.AudioContext)
+      return !1;
+    const e = new AudioContext(), t = typeof e.createMediaStreamDestination == "function";
+    return e.close(), t;
+  } catch {
+    return !1;
+  }
+}
+function D(e = "video", t = !1) {
+  const n = document.createElement(e);
+  return n.muted = !1, n.autoplay = !0, e === "video" && (n.playsInline = !0), t ? n.style.cssText = "position:fixed;bottom:10px;right:10px;width:200px;background:#ff0000;z-index:9999;" : n.style.cssText = "position:fixed;width:1px;height:1px;opacity:0;pointer-events:none;", n;
+}
+function M(e = !1) {
+  return D("video", e);
+}
+class E {
+  constructor(t, n, i, a = !1) {
+    s(this, "analyser");
+    s(this, "dataArray");
+    s(this, "rafId", null);
+    s(this, "silenceStartTime", 0);
+    s(this, "isPaused", !1);
+    s(this, "lastCheckTime", 0);
+    s(this, "silenceThreshold");
+    s(this, "silenceDuration");
+    s(this, "checkInterval");
+    s(this, "debug");
+    /**
+     * Check audio levels and pause/resume as needed
+     */
+    s(this, "check", () => {
+      const t = performance.now();
+      t - this.lastCheckTime >= this.checkInterval && (this.lastCheckTime = t, this.getAudioLevel() < this.silenceThreshold ? this.silenceStartTime === 0 ? this.silenceStartTime = t : t - this.silenceStartTime >= this.silenceDuration && !this.isPaused && this.pauseMedia() : (this.silenceStartTime = 0, this.isPaused && this.resumeMedia())), this.rafId = requestAnimationFrame(this.check);
+    });
+    this.audioContext = t, this.mediaElement = n, this.silenceThreshold = i.silenceThreshold, this.silenceDuration = i.silenceDuration, this.checkInterval = i.checkInterval, this.debug = a, this.analyser = t.createAnalyser(), this.analyser.fftSize = 512, this.analyser.smoothingTimeConstant = 0.3, this.dataArray = new Uint8Array(this.analyser.frequencyBinCount);
+  }
+  /**
+   * Connect the detector to the audio stream
+   */
+  connect(t) {
+    t.connect(this.analyser);
+  }
+  /**
+   * Start monitoring audio levels
+   */
+  start() {
+    this.rafId === null && (this.lastCheckTime = performance.now(), this.check(), this.debug && console.log("[AudioSilenceDetector] Started monitoring"));
+  }
+  /**
+   * Stop monitoring
+   */
+  stop() {
+    this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null), this.debug && console.log("[AudioSilenceDetector] Stopped monitoring");
+  }
+  /**
+   * Cleanup resources
+   */
+  dispose() {
+    this.stop(), this.analyser.disconnect();
+  }
+  /**
+   * Get current audio level (0-1)
+   */
+  getAudioLevel() {
+    this.analyser.getByteTimeDomainData(this.dataArray);
+    let t = 0;
+    for (let n = 0; n < this.dataArray.length; n++) {
+      const i = (this.dataArray[n] - 128) / 128;
+      t += i * i;
+    }
+    return Math.sqrt(t / this.dataArray.length);
+  }
+  /**
+   * Pause media element to stop audio output
+   */
+  pauseMedia() {
+    try {
+      this.mediaElement.pause(), this.isPaused = !0, this.debug && console.log("[AudioSilenceDetector] Paused media element (silence detected)");
+    } catch (t) {
+      console.error("[AudioSilenceDetector] Failed to pause:", t);
+    }
+  }
+  /**
+   * Resume media element playback
+   */
+  resumeMedia() {
+    try {
+      this.audioContext.state === "running" && this.mediaElement.play().catch((t) => {
+        this.debug && console.warn("[AudioSilenceDetector] Failed to resume:", t);
+      }), this.isPaused = !1, this.debug && console.log("[AudioSilenceDetector] Resumed media element (audio detected)");
+    } catch (t) {
+      console.error("[AudioSilenceDetector] Failed to resume:", t);
+    }
+  }
+}
+function x(e, t = {}) {
+  const {
+    forceEnable: n = !1,
+    autoCleanup: i = !0,
+    debug: a = !1,
+    mediaElementType: m = "video",
+    autoPause: d = {}
+  } = t, h = {
+    enabled: d.enabled ?? !0,
+    silenceThreshold: d.silenceThreshold ?? 1e-3,
+    silenceDuration: d.silenceDuration ?? 50,
+    checkInterval: d.checkInterval ?? 16
+  };
+  if (!(n || T()))
+    return Object.assign(e, {
+      unlock: async () => {
+        e.state === "suspended" && await e.resume();
+      },
+      cleanup: () => {
+      },
+      isPatched: !1,
+      originalDestination: e.destination
+    });
+  if (!P())
+    return console.warn(
+      "[AudioContext] MediaStreamAudioDestinationNode not supported, falling back to native"
+    ), Object.assign(e, {
+      unlock: async () => e.resume(),
+      cleanup: () => {
+      },
+      isPatched: !1,
+      originalDestination: e.destination
+    });
+  const c = e.destination, g = e.createMediaStreamDestination(), f = e.createGain();
+  f.gain.value = 1, f.connect(g);
+  const l = D(m, a);
+  l.srcObject = g.stream, document.body.appendChild(l);
+  let u = null;
+  h.enabled && (u = new E(
+    e,
+    l,
+    h,
+    a
+  ), u.connect(f)), Object.defineProperty(e, "destination", {
+    get: () => f,
+    enumerable: !0,
+    configurable: !0
+  }), "maxChannelCount" in f || Object.defineProperty(f, "maxChannelCount", {
+    get: () => c.maxChannelCount,
+    enumerable: !0
+  });
+  let y = !1;
+  const b = async () => {
+    if (!y)
+      try {
+        await l.play(), e.state === "suspended" && await e.resume(), u && u.start(), y = !0, a && console.log("[AudioContext] iOS unlock successful");
+      } catch (o) {
+        throw o instanceof DOMException && o.name === "NotAllowedError" ? (a && console.log("[AudioContext] Unlock requires user interaction"), o) : (console.error("[AudioContext] Unlock failed:", o), o);
+      }
+  }, A = () => {
+    try {
+      u && (u.dispose(), u = null), l.pause(), l.srcObject = null, l.remove(), a && console.log("[AudioContext] Cleanup completed");
+    } catch (o) {
+      console.error("[AudioContext] Cleanup error:", o);
+    }
+  };
+  if (i) {
+    const o = e.close.bind(e);
+    e.close = async () => (A(), o());
+  }
+  return Object.assign(e, {
+    unlock: b,
+    cleanup: A,
+    isPatched: !0,
+    originalDestination: c
+  });
+}
+function O(e = {}) {
+  const { autoUnlock: t = !0, ...n } = e, [i, a] = k(null), [m, d] = k(!1), h = w(null);
+  return p(() => {
+    const r = new AudioContext(), c = x(r, n);
+    return a(c), () => {
+      c.cleanup(), c.close();
+    };
+  }, []), p(() => {
+    i && (h.current = async () => {
+      if (!m)
+        try {
+          await i.unlock(), d(!0);
+        } catch (r) {
+          if (r instanceof DOMException && r.name === "NotAllowedError")
+            return;
+          console.warn("Failed to unlock audio:", r);
+        }
+    });
+  }, [i, m]), p(() => {
+    if (!t || !i) return;
+    const r = async (c) => {
+      c.isTrusted && await h.current?.();
+    };
+    return document.addEventListener("click", r, { once: !0, capture: !0 }), document.addEventListener("touchstart", r, { once: !0, capture: !0 }), () => {
+      document.removeEventListener("click", r, { capture: !0 }), document.removeEventListener("touchstart", r, { capture: !0 });
+    };
+  }, [t, i]), {
+    audioContext: i,
+    isUnlocked: m,
+    unlock: h.current || (async () => {
+    })
+  };
+}
+export {
+  M as a,
+  P as b,
+  D as c,
+  T as i,
+  x as p,
+  O as u
+};