@aippy/runtime 0.1.0

package/dist/pwa-BkviTQoN.js

@@ -0,0 +1,408 @@
+import { UAParser } from "ua-parser-js";
+class PlatformDetector {
+  parser;
+  constructor() {
+    this.parser = new UAParser();
+  }
+  /**
+   * Get platform information
+   */
+  getPlatformInfo() {
+    const result = this.parser.getResult();
+    const platformName = this.normalizePlatformName(result.os.name);
+    const browserName = this.normalizeBrowserName(result.browser.name);
+    const isMobile = this.isMobileDevice();
+    const isDesktop = !isMobile;
+    return {
+      name: platformName,
+      version: result.os.version,
+      browser: browserName,
+      browserVersion: result.browser.version,
+      isMobile,
+      isDesktop
+    };
+  }
+  /**
+   * 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 userAgent = navigator.userAgent;
+    const mobileRegex = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
+    return mobileRegex.test(userAgent) || 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 === true;
+  }
+  /**
+   * Check if running in iOS Safari
+   */
+  isIOSSafari() {
+    const info = this.getPlatformInfo();
+    return info.name === "ios" && info.browser === "safari";
+  }
+  /**
+   * Check if running in Android Chrome
+   */
+  isAndroidChrome() {
+    const info = this.getPlatformInfo();
+    return info.name === "android" && info.browser === "chrome";
+  }
+  normalizePlatformName(name) {
+    if (!name) return "unknown";
+    const normalized = name.toLowerCase();
+    if (normalized.includes("ios")) return "ios";
+    if (normalized.includes("android")) return "android";
+    if (normalized.includes("windows")) return "windows";
+    if (normalized.includes("mac")) return "macos";
+    if (normalized.includes("linux")) return "linux";
+    return "unknown";
+  }
+  normalizeBrowserName(name) {
+    if (!name) return "unknown";
+    const normalized = name.toLowerCase();
+    if (normalized.includes("chrome")) return "chrome";
+    if (normalized.includes("firefox")) return "firefox";
+    if (normalized.includes("safari")) return "safari";
+    if (normalized.includes("edge")) return "edge";
+    return "unknown";
+  }
+  getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    } catch {
+      return null;
+    }
+  }
+}
+const platform = new PlatformDetector();
+class PerformanceMonitor {
+  /**
+   * Get Core Web Vitals metrics
+   */
+  async getCoreWebVitals() {
+    const metrics = {};
+    try {
+      const fcpEntry = performance.getEntriesByName("first-contentful-paint")[0];
+      if (fcpEntry) {
+        metrics.fcp = fcpEntry.startTime;
+      }
+      const lcpEntries = performance.getEntriesByType("largest-contentful-paint");
+      if (lcpEntries.length > 0) {
+        const lcpEntry = lcpEntries[lcpEntries.length - 1];
+        metrics.lcp = lcpEntry.startTime;
+      }
+      const fidEntries = performance.getEntriesByType("first-input");
+      if (fidEntries.length > 0) {
+        const fidEntry = fidEntries[0];
+        metrics.fid = fidEntry.processingStart - fidEntry.startTime;
+      }
+      const clsEntries = performance.getEntriesByType("layout-shift");
+      if (clsEntries.length > 0) {
+        let clsValue = 0;
+        for (const entry of clsEntries) {
+          const clsEntry = entry;
+          if (!clsEntry.hadRecentInput) {
+            clsValue += clsEntry.value;
+          }
+        }
+        metrics.cls = clsValue;
+      }
+      const tti = this.calculateTTI();
+      if (tti) {
+        metrics.tti = tti;
+      }
+    } catch (error) {
+      console.warn("Failed to get Core Web Vitals:", error);
+    }
+    return metrics;
+  }
+  /**
+   * Get navigation timing metrics
+   */
+  getNavigationTiming() {
+    const navigation = performance.getEntriesByType("navigation")[0];
+    if (!navigation) {
+      return null;
+    }
+    return {
+      // DNS lookup time
+      dns: navigation.domainLookupEnd - navigation.domainLookupStart,
+      // TCP connection time
+      tcp: navigation.connectEnd - navigation.connectStart,
+      // Request time
+      request: navigation.responseStart - navigation.requestStart,
+      // Response time
+      response: navigation.responseEnd - navigation.responseStart,
+      // DOM processing time
+      domProcessing: navigation.domComplete - navigation.domInteractive,
+      // Total page load time
+      total: navigation.loadEventEnd - navigation.fetchStart
+    };
+  }
+  /**
+   * Get resource timing metrics
+   */
+  getResourceTiming() {
+    const resources = performance.getEntriesByType("resource");
+    return resources.map((resource) => ({
+      name: resource.name,
+      duration: resource.duration,
+      size: resource.transferSize,
+      type: this.getResourceType(resource.name)
+    }));
+  }
+  /**
+   * Measure function execution time
+   */
+  measureFunction(fn, name) {
+    const start = performance.now();
+    const result = fn();
+    const end = performance.now();
+    if (name) {
+      performance.mark(`${name}-start`);
+      performance.mark(`${name}-end`);
+      performance.measure(name, `${name}-start`, `${name}-end`);
+    }
+    console.log(`Function ${name || "anonymous"} took ${end - start} milliseconds`);
+    return result;
+  }
+  /**
+   * Measure async function execution time
+   */
+  async measureAsyncFunction(fn, name) {
+    const start = performance.now();
+    const result = await fn();
+    const end = performance.now();
+    if (name) {
+      performance.mark(`${name}-start`);
+      performance.mark(`${name}-end`);
+      performance.measure(name, `${name}-start`, `${name}-end`);
+    }
+    console.log(`Async function ${name || "anonymous"} took ${end - start} milliseconds`);
+    return result;
+  }
+  /**
+   * Get memory usage (if available)
+   */
+  getMemoryUsage() {
+    if ("memory" in performance) {
+      const memory = performance.memory;
+      return {
+        used: memory.usedJSHeapSize,
+        total: memory.totalJSHeapSize,
+        limit: memory.jsHeapSizeLimit
+      };
+    }
+    return null;
+  }
+  calculateTTI() {
+    const navigation = performance.getEntriesByType("navigation")[0];
+    if (navigation) {
+      return navigation.domContentLoadedEventEnd - navigation.fetchStart;
+    }
+    return null;
+  }
+  getResourceType(url) {
+    if (url.includes(".js")) return "script";
+    if (url.includes(".css")) return "stylesheet";
+    if (url.includes(".png") || url.includes(".jpg") || url.includes(".gif")) return "image";
+    if (url.includes(".woff") || url.includes(".ttf")) return "font";
+    return "other";
+  }
+}
+const performanceMonitor = new PerformanceMonitor();
+class PWAUtils {
+  /**
+   * 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 === true;
+  }
+  /**
+   * Check if running in app (iOS)
+   */
+  isInApp() {
+    return window.navigator.standalone === true;
+  }
+  /**
+   * Register service worker
+   */
+  async registerServiceWorker(swPath) {
+    if (!("serviceWorker" in navigator)) {
+      console.warn("Service Worker not supported");
+      return null;
+    }
+    try {
+      const registration = await navigator.serviceWorker.register(swPath);
+      console.log("Service Worker registered:", registration);
+      return registration;
+    } catch (error) {
+      console.error("Service Worker registration failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Unregister service worker
+   */
+  async unregisterServiceWorker() {
+    if (!("serviceWorker" in navigator)) {
+      return false;
+    }
+    try {
+      const registrations = await navigator.serviceWorker.getRegistrations();
+      for (const registration of registrations) {
+        await registration.unregister();
+      }
+      return true;
+    } catch (error) {
+      console.error("Service Worker unregistration failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Request notification permission
+   */
+  async requestNotificationPermission() {
+    if (!("Notification" in window)) {
+      throw new Error("Notifications not supported");
+    }
+    if (Notification.permission === "granted") {
+      return "granted";
+    }
+    if (Notification.permission === "denied") {
+      return "denied";
+    }
+    return await Notification.requestPermission();
+  }
+  /**
+   * Send notification
+   */
+  async sendNotification(title, options) {
+    if (!("Notification" in window)) {
+      throw new Error("Notifications not supported");
+    }
+    if (Notification.permission !== "granted") {
+      throw new Error("Notification permission not granted");
+    }
+    const notification = new Notification(title, options);
+    setTimeout(() => {
+      notification.close();
+    }, 5e3);
+  }
+  /**
+   * Share content using Web Share API
+   */
+  async share(data) {
+    if (!("share" in navigator)) {
+      throw new Error("Web Share API not supported");
+    }
+    try {
+      await navigator.share(data);
+    } catch (error) {
+      if (error instanceof Error && error.name !== "AbortError") {
+        throw new Error(`Share failed: ${error.message}`);
+      }
+    }
+  }
+  /**
+   * Copy text to clipboard
+   */
+  async copyToClipboard(text) {
+    if (!("clipboard" in navigator)) {
+      throw new Error("Clipboard API not supported");
+    }
+    try {
+      await navigator.clipboard.writeText(text);
+    } catch (error) {
+      throw new Error(`Copy to clipboard failed: ${error instanceof Error ? error.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 (error) {
+      throw new Error(`Read from clipboard failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get install prompt event
+   */
+  getInstallPromptEvent() {
+    return new Promise((resolve) => {
+      const handleBeforeInstallPrompt = (e) => {
+        e.preventDefault();
+        resolve(e);
+        window.removeEventListener("beforeinstallprompt", handleBeforeInstallPrompt);
+      };
+      window.addEventListener("beforeinstallprompt", handleBeforeInstallPrompt);
+    });
+  }
+}
+const pwa = new PWAUtils();
+export {
+  PlatformDetector as P,
+  PerformanceMonitor as a,
+  performanceMonitor as b,
+  PWAUtils as c,
+  pwa as d,
+  platform as p
+};

package/dist/tweaks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useTweaks';
+export type * from './types';

package/dist/tweaks/index.js

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

package/dist/tweaks/useTweaks.d.ts

@@ -0,0 +1,10 @@
+import { TweaksConfig } from './types';
+declare const aippyTweaksRuntime: {
+    tweaks: (config: TweaksConfig) => Record<string, {
+        useState: () => any;
+    }>;
+};
+export declare const aippyTweaks: (config: TweaksConfig) => Record<string, {
+    useState: () => any;
+}>;
+export { aippyTweaksRuntime };

package/dist/tweaks.d.ts

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

package/dist/useTweaks-mK5PAWOs.js

@@ -0,0 +1,258 @@
+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
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './platform';
+export * from './performance';
+export * from './pwa';
+export * from './types';

package/dist/utils/index.js

@@ -0,0 +1,9 @@
+import { c, a, P, b, p, d } from "../pwa-BkviTQoN.js";
+export {
+  c as PWAUtils,
+  a as PerformanceMonitor,
+  P as PlatformDetector,
+  b as performanceMonitor,
+  p as platform,
+  d as pwa
+};