@aippy/runtime 0.2.0-dev.5 → 0.2.1

package/dist/useAudioContext-D9Y4gIw9.js

@@ -1,358 +0,0 @@
-import { useState, useRef, useEffect } from "react";
-function isIOSDevice() {
-  const userAgent = navigator.userAgent;
-  if (/iPad|iPhone|iPod/.test(userAgent)) {
-    return true;
-  }
-  if (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) {
-    return true;
-  }
-  return false;
-}
-function isMediaStreamAudioSupported() {
-  try {
-    if (!window.AudioContext) {
-      return false;
-    }
-    const tempContext = new AudioContext();
-    const hasMethod = typeof tempContext.createMediaStreamDestination === "function";
-    tempContext.close();
-    return hasMethod;
-  } catch {
-    return false;
-  }
-}
-function createHiddenMediaElement(type = "video", debug = false) {
-  const element = document.createElement(type);
-  element.muted = false;
-  element.autoplay = true;
-  if (type === "video") {
-    element.playsInline = true;
-  }
-  if (debug) {
-    element.style.cssText = "position:fixed;bottom:10px;right:10px;width:200px;background:#ff0000;z-index:9999;";
-  } else {
-    element.style.cssText = "position:fixed;width:1px;height:1px;opacity:0;pointer-events:none;";
-  }
-  return element;
-}
-function createHiddenVideoElement(debug = false) {
-  return createHiddenMediaElement("video", debug);
-}
-class AudioSilenceDetector {
-  constructor(audioContext, mediaElement, options, debug = false) {
-    this.audioContext = audioContext;
-    this.mediaElement = mediaElement;
-    this.silenceThreshold = options.silenceThreshold;
-    this.silenceDuration = options.silenceDuration;
-    this.checkInterval = options.checkInterval;
-    this.debug = debug;
-    this.analyser = audioContext.createAnalyser();
-    this.analyser.fftSize = 512;
-    this.analyser.smoothingTimeConstant = 0.3;
-    this.dataArray = new Uint8Array(this.analyser.frequencyBinCount);
-  }
-  analyser;
-  dataArray;
-  rafId = null;
-  silenceStartTime = 0;
-  isPaused = false;
-  lastCheckTime = 0;
-  silenceThreshold;
-  silenceDuration;
-  checkInterval;
-  debug;
-  /**
-   * Connect the detector to the audio stream
-   */
-  connect(source) {
-    source.connect(this.analyser);
-  }
-  /**
-   * Start monitoring audio levels
-   */
-  start() {
-    if (this.rafId !== null) return;
-    this.lastCheckTime = performance.now();
-    this.check();
-    if (this.debug) {
-      console.log("[AudioSilenceDetector] Started monitoring");
-    }
-  }
-  /**
-   * Stop monitoring
-   */
-  stop() {
-    if (this.rafId !== null) {
-      cancelAnimationFrame(this.rafId);
-      this.rafId = null;
-    }
-    if (this.debug) {
-      console.log("[AudioSilenceDetector] Stopped monitoring");
-    }
-  }
-  /**
-   * Cleanup resources
-   */
-  dispose() {
-    this.stop();
-    this.analyser.disconnect();
-  }
-  /**
-   * Check audio levels and pause/resume as needed
-   */
-  check = () => {
-    const now = performance.now();
-    const elapsed = now - this.lastCheckTime;
-    if (elapsed >= this.checkInterval) {
-      this.lastCheckTime = now;
-      const volume = this.getAudioLevel();
-      if (volume < this.silenceThreshold) {
-        if (this.silenceStartTime === 0) {
-          this.silenceStartTime = now;
-        } else {
-          const silenceDuration = now - this.silenceStartTime;
-          if (silenceDuration >= this.silenceDuration && !this.isPaused) {
-            this.pauseMedia();
-          }
-        }
-      } else {
-        this.silenceStartTime = 0;
-        if (this.isPaused) {
-          this.resumeMedia();
-        }
-      }
-    }
-    this.rafId = requestAnimationFrame(this.check);
-  };
-  /**
-   * Get current audio level (0-1)
-   */
-  getAudioLevel() {
-    this.analyser.getByteTimeDomainData(this.dataArray);
-    let sum = 0;
-    for (let i = 0; i < this.dataArray.length; i++) {
-      const normalized = (this.dataArray[i] - 128) / 128;
-      sum += normalized * normalized;
-    }
-    return Math.sqrt(sum / this.dataArray.length);
-  }
-  /**
-   * Pause media element to stop audio output
-   */
-  pauseMedia() {
-    try {
-      this.mediaElement.pause();
-      this.isPaused = true;
-      if (this.debug) {
-        console.log("[AudioSilenceDetector] Paused media element (silence detected)");
-      }
-    } catch (error) {
-      console.error("[AudioSilenceDetector] Failed to pause:", error);
-    }
-  }
-  /**
-   * Resume media element playback
-   */
-  resumeMedia() {
-    try {
-      if (this.audioContext.state === "running") {
-        this.mediaElement.play().catch((error) => {
-          if (this.debug) {
-            console.warn("[AudioSilenceDetector] Failed to resume:", error);
-          }
-        });
-      }
-      this.isPaused = false;
-      if (this.debug) {
-        console.log("[AudioSilenceDetector] Resumed media element (audio detected)");
-      }
-    } catch (error) {
-      console.error("[AudioSilenceDetector] Failed to resume:", error);
-    }
-  }
-}
-function patchAudioContext(audioContext, options = {}) {
-  const {
-    forceEnable = false,
-    autoCleanup = true,
-    debug = false,
-    mediaElementType = "video",
-    autoPause = {}
-  } = options;
-  const autoPauseOptions = {
-    enabled: autoPause.enabled ?? true,
-    silenceThreshold: autoPause.silenceThreshold ?? 1e-3,
-    silenceDuration: autoPause.silenceDuration ?? 50,
-    checkInterval: autoPause.checkInterval ?? 16
-  };
-  const needsPatch = forceEnable || isIOSDevice();
-  if (!needsPatch) {
-    return Object.assign(audioContext, {
-      unlock: async () => {
-        if (audioContext.state === "suspended") {
-          await audioContext.resume();
-        }
-      },
-      cleanup: () => {
-      },
-      isPatched: false,
-      originalDestination: audioContext.destination
-    });
-  }
-  if (!isMediaStreamAudioSupported()) {
-    console.warn(
-      "[AudioContext] MediaStreamAudioDestinationNode not supported, falling back to native"
-    );
-    return Object.assign(audioContext, {
-      unlock: async () => audioContext.resume(),
-      cleanup: () => {
-      },
-      isPatched: false,
-      originalDestination: audioContext.destination
-    });
-  }
-  const originalDestination = audioContext.destination;
-  const streamDestination = audioContext.createMediaStreamDestination();
-  const gainNode = audioContext.createGain();
-  gainNode.gain.value = 1;
-  gainNode.connect(streamDestination);
-  const mediaElement = createHiddenMediaElement(mediaElementType, debug);
-  mediaElement.srcObject = streamDestination.stream;
-  document.body.appendChild(mediaElement);
-  let silenceDetector = null;
-  if (autoPauseOptions.enabled) {
-    silenceDetector = new AudioSilenceDetector(
-      audioContext,
-      mediaElement,
-      autoPauseOptions,
-      debug
-    );
-    silenceDetector.connect(gainNode);
-  }
-  Object.defineProperty(audioContext, "destination", {
-    get: () => gainNode,
-    enumerable: true,
-    configurable: true
-  });
-  if (!("maxChannelCount" in gainNode)) {
-    Object.defineProperty(gainNode, "maxChannelCount", {
-      get: () => originalDestination.maxChannelCount,
-      enumerable: true
-    });
-  }
-  let isUnlocked = false;
-  const unlock = async () => {
-    if (isUnlocked) {
-      return;
-    }
-    try {
-      await mediaElement.play();
-      if (audioContext.state === "suspended") {
-        await audioContext.resume();
-      }
-      if (silenceDetector) {
-        silenceDetector.start();
-      }
-      isUnlocked = true;
-      if (debug) {
-        console.log("[AudioContext] iOS unlock successful");
-      }
-    } catch (error) {
-      if (error instanceof DOMException && error.name === "NotAllowedError") {
-        if (debug) {
-          console.log("[AudioContext] Unlock requires user interaction");
-        }
-        throw error;
-      }
-      console.error("[AudioContext] Unlock failed:", error);
-      throw error;
-    }
-  };
-  const cleanup = () => {
-    try {
-      if (silenceDetector) {
-        silenceDetector.dispose();
-        silenceDetector = null;
-      }
-      mediaElement.pause();
-      mediaElement.srcObject = null;
-      mediaElement.remove();
-      if (debug) {
-        console.log("[AudioContext] Cleanup completed");
-      }
-    } catch (error) {
-      console.error("[AudioContext] Cleanup error:", error);
-    }
-  };
-  if (autoCleanup) {
-    const originalClose = audioContext.close.bind(audioContext);
-    audioContext.close = async () => {
-      cleanup();
-      return originalClose();
-    };
-  }
-  return Object.assign(audioContext, {
-    unlock,
-    cleanup,
-    isPatched: true,
-    originalDestination
-  });
-}
-function useAudioContext(options = {}) {
-  const { autoUnlock = true, ...patchOptions } = options;
-  const [audioContext, setAudioContext] = useState(null);
-  const [isUnlocked, setIsUnlocked] = useState(false);
-  const unlockFnRef = useRef(null);
-  useEffect(() => {
-    const ctx = new AudioContext();
-    const patchedCtx = patchAudioContext(ctx, patchOptions);
-    setAudioContext(patchedCtx);
-    return () => {
-      patchedCtx.cleanup();
-      patchedCtx.close();
-    };
-  }, []);
-  useEffect(() => {
-    if (!audioContext) return;
-    unlockFnRef.current = async () => {
-      if (isUnlocked) return;
-      try {
-        await audioContext.unlock();
-        setIsUnlocked(true);
-      } catch (error) {
-        if (error instanceof DOMException && error.name === "NotAllowedError") {
-          return;
-        }
-        console.warn("Failed to unlock audio:", error);
-      }
-    };
-  }, [audioContext, isUnlocked]);
-  useEffect(() => {
-    if (!autoUnlock || !audioContext) return;
-    const handleInteraction = async (event) => {
-      if (!event.isTrusted) return;
-      await unlockFnRef.current?.();
-    };
-    document.addEventListener("click", handleInteraction, { once: true, capture: true });
-    document.addEventListener("touchstart", handleInteraction, { once: true, capture: true });
-    return () => {
-      document.removeEventListener("click", handleInteraction, { capture: true });
-      document.removeEventListener("touchstart", handleInteraction, { capture: true });
-    };
-  }, [autoUnlock, audioContext]);
-  return {
-    audioContext,
-    isUnlocked,
-    unlock: unlockFnRef.current || (async () => {
-    })
-  };
-}
-export {
-  createHiddenVideoElement as a,
-  isMediaStreamAudioSupported as b,
-  createHiddenMediaElement as c,
-  isIOSDevice as i,
-  patchAudioContext as p,
-  useAudioContext as u
-};

package/dist/useTweaks-mK5PAWOs.js

@@ -1,258 +0,0 @@
-import { useReducer, useEffect } from "react";
-class Cancellable {
-  constructor(cancelFn) {
-    this.cancelFn = cancelFn;
-  }
-  cancelled = false;
-  cancel() {
-    if (!this.cancelled) {
-      this.cancelled = true;
-      this.cancelFn?.();
-    }
-  }
-  get isCancelled() {
-    return this.cancelled;
-  }
-}
-class PassthroughSubject {
-  listeners = [];
-  send(data) {
-    this.listeners.forEach((listener) => listener(data));
-  }
-  subscribe(callback) {
-    this.listeners.push(callback);
-    return new Cancellable(() => {
-      const index = this.listeners.indexOf(callback);
-      if (index > -1) {
-        this.listeners.splice(index, 1);
-      }
-    });
-  }
-}
-class TweaksManager {
-  values = {};
-  subject = new PassthroughSubject();
-  observable;
-  constructor(observable, config) {
-    this.observable = observable;
-    for (const [key, item] of Object.entries(config)) {
-      this.values[key] = item.value;
-    }
-    this.observable.subscribe((data) => {
-      if (data && data.values) {
-        console.log("🔄 [Aippy Tweaks] Processing external update:", data.values);
-        const changedKeys = [];
-        for (const [key, newValue] of Object.entries(data.values)) {
-          let convertedValue = newValue;
-          if (this.values[key] !== void 0) {
-            const originalType = typeof this.values[key];
-            if (originalType === "number" && typeof newValue === "string") {
-              convertedValue = parseFloat(newValue);
-            } else if (originalType === "boolean" && typeof newValue !== "boolean") {
-              convertedValue = newValue === "true" || newValue === true;
-            }
-          }
-          if (this.values[key] !== convertedValue) {
-            const oldValue = this.values[key];
-            this.values[key] = convertedValue;
-            this.subject.send(key);
-            changedKeys.push(key);
-            console.log(`📝 [Aippy Tweaks] Updated ${key}: ${oldValue} → ${convertedValue} (type: ${typeof convertedValue})`);
-          }
-        }
-        if (changedKeys.length > 0) {
-          console.log(`✨ [Aippy Tweaks] Successfully updated ${changedKeys.length} tweak(s):`, changedKeys);
-        } else {
-          console.log("💡 [Aippy Tweaks] No values changed in this update");
-        }
-      }
-    });
-  }
-  getValue(key) {
-    const value = this.values[key];
-    if (value === void 0) {
-      throw new Error(`Tweak key not found in values: ${key}`);
-    }
-    return value;
-  }
-  // React Hook integration
-  useState(key) {
-    const [value, forceUpdate] = useReducer(() => this.getValue(key), this.getValue(key));
-    useEffect(() => {
-      const subscription = this.subject.subscribe((changedKey) => {
-        if (changedKey === key) {
-          forceUpdate();
-        }
-      });
-      return () => {
-        subscription.cancel();
-      };
-    }, [key]);
-    return value;
-  }
-}
-class TweaksRuntime {
-  tweaksInstance = null;
-  tweaksDidWarn = false;
-  updateCallback;
-  // Store update callback function
-  originalConfig;
-  // Store original config for merging
-  tweaks(config) {
-    if (this.tweaksInstance) {
-      if (!this.tweaksDidWarn) {
-        this.tweaksDidWarn = true;
-        console.warn("⚠️ [Aippy Tweaks] tweaks() is expected to only be called once, returning previous value");
-      }
-      return this.tweaksInstance;
-    }
-    console.log("🚀 [Aippy Tweaks] Creating new tweaks runtime instance");
-    this.originalConfig = { ...config };
-    const subject = new PassthroughSubject();
-    const manager = new TweaksManager(subject, config);
-    const instance = {};
-    for (const key of Object.keys(config)) {
-      instance[key] = {
-        useState: () => manager.useState(key)
-      };
-    }
-    this.tweaksInstance = instance;
-    console.log("📋 [Aippy Tweaks] Created tweaks instance with keys:", Object.keys(config));
-    if (typeof window !== "undefined" && window.aippyTweaksRuntime) {
-      window.aippyTweaksRuntime.tweaksInstance = instance;
-      console.log("🌐 [Aippy Tweaks] Exposed tweaksInstance to window.aippyTweaksRuntime.tweaksInstance");
-    }
-    this.initializeExternalCommunication(config, (data) => {
-      subject.send(data);
-    });
-    return instance;
-  }
-  initializeExternalCommunication(config, callback) {
-    this.updateCallback = callback;
-    console.log("🎛️ [Aippy Tweaks] Initializing tweaks with config:", config);
-    console.log("🎛️ [Aippy Tweaks] Total tweaks count:", Object.keys(config).length);
-    const aippyListener = window.webkit?.messageHandlers?.aippyListener;
-    if (aippyListener) {
-      try {
-        const data = {
-          command: "tweaks.initialize",
-          parameters: JSON.stringify(config)
-        };
-        aippyListener.postMessage(data);
-        console.log("✅ [Aippy Tweaks] Successfully sent tweaks config to iOS app via aippyListener");
-        console.log("📤 [Aippy Tweaks] Sent data:", data);
-      } catch (error) {
-        console.warn("❌ [Aippy Tweaks] Failed to send tweaks config to iOS app:", error);
-      }
-    } else {
-      console.warn("⚠️ [Aippy Tweaks] webkit.messageHandlers.aippyListener not available");
-      console.log(
-        "🔍 [Aippy Tweaks] Available webkit handlers:",
-        window.webkit?.messageHandlers ? Object.keys(window.webkit.messageHandlers) : "none"
-      );
-    }
-    if (window.parent && window.parent !== window) {
-      try {
-        const message = {
-          type: "tweaks-initialize",
-          config: JSON.stringify(config)
-        };
-        window.parent.postMessage(message, "*");
-        console.log("📡 [Aippy Tweaks] Sent tweaks config to parent window:", message);
-        const runtimeMessage = {
-          type: "aippy-tweaks-ready",
-          aippyTweaksRuntime: {
-            tweaks: window.aippyTweaksRuntime?.tweaks,
-            tweaksInstance: window.aippyTweaksRuntime?.tweaksInstance
-          }
-        };
-        window.parent.postMessage(runtimeMessage, "*");
-        console.log("📡 [Aippy Tweaks] Sent aippyTweaksRuntime to parent window:", runtimeMessage);
-      } catch (error) {
-        console.warn("❌ [Aippy Tweaks] Failed to send to parent window:", error);
-      }
-    }
-    const messageHandler = (event) => {
-      if (event.data && event.data.type === "tweaks-update") {
-        console.log("📥 [Aippy Tweaks] Received tweaks update:", event.data);
-        callback(event.data);
-      }
-    };
-    window.addEventListener("message", messageHandler);
-    console.log("👂 [Aippy Tweaks] Listening for tweaks updates via window.postMessage");
-  }
-  // Process native data updates - Public method for external calls
-  processNativeData(data) {
-    if (!this.tweaksInstance) {
-      console.warn("⚠️ [Aippy Tweaks] processNativeData called but no tweaks instance exists");
-      return;
-    }
-    if (!this.updateCallback) {
-      console.warn("⚠️ [Aippy Tweaks] processNativeData called but no update callback available");
-      return;
-    }
-    try {
-      if (!data || typeof data !== "object") {
-        console.warn("⚠️ [Aippy Tweaks] Invalid data type received from native:", typeof data);
-        return;
-      }
-      if (!this.originalConfig) {
-        console.warn("⚠️ [Aippy Tweaks] No original config available for merging");
-        return;
-      }
-      const values = {};
-      const mergedConfig = {};
-      let processedCount = 0;
-      console.log("📱 [DEBUG] Starting to process iOS data and merge with original config...");
-      for (const [key, iosConfigItem] of Object.entries(data)) {
-        console.log(`📱 [DEBUG] Processing key: ${key}`, iosConfigItem);
-        if (iosConfigItem && typeof iosConfigItem === "object" && "value" in iosConfigItem) {
-          const iosItem = iosConfigItem;
-          const originalItem = this.originalConfig[key];
-          if (!originalItem) {
-            console.warn(`⚠️ [Aippy Tweaks] Key "${key}" not found in original config, skipping`);
-            continue;
-          }
-          const iosSpecificFields = /* @__PURE__ */ new Set(["tweakKey", "valueBefore", "tweaksType", "editType"]);
-          const mergedItem = { ...originalItem };
-          for (const [fieldName, fieldValue] of Object.entries(iosItem)) {
-            if (iosSpecificFields.has(fieldName)) {
-              continue;
-            }
-            if (fieldValue !== void 0 && fieldValue !== null) {
-              mergedItem[fieldName] = fieldValue;
-            }
-          }
-          mergedConfig[key] = mergedItem;
-          values[key] = iosItem.value;
-          processedCount++;
-        }
-      }
-      if (processedCount === 0) {
-        console.warn("⚠️ [Aippy Tweaks] No valid values found in iOS data:", data);
-        return;
-      }
-      const updateMessage = {
-        type: "tweaks-update",
-        values
-      };
-      this.updateCallback(updateMessage);
-    } catch (error) {
-      console.error("❌ [Aippy Tweaks] Error processing native data:", error);
-    }
-  }
-}
-const globalTweaksRuntime = new TweaksRuntime();
-const aippyTweaksRuntime = {
-  tweaks: (config) => globalTweaksRuntime.tweaks(config)
-};
-const aippyTweaks = aippyTweaksRuntime.tweaks;
-if (typeof window !== "undefined") {
-  window.aippyTweaksRuntime = aippyTweaksRuntime;
-  window.processNativeData = globalTweaksRuntime.processNativeData.bind(globalTweaksRuntime);
-  console.log("🌐 [Aippy Tweaks] Exposed processNativeData to window.processNativeData");
-}
-export {
-  aippyTweaks as a,
-  aippyTweaksRuntime as b
-};