@aippy/runtime 0.2.7-dev.5 → 0.2.7-dev.7

package/dist/pwa-C5nXU0DN.js

@@ -0,0 +1,250 @@
+import { c as n, a as i } from "./errors-B3bDbQbD.js";
+class d {
+  /**
+   * Get Core Web Vitals metrics
+   */
+  async getCoreWebVitals() {
+    const e = {};
+    try {
+      const t = performance.getEntriesByName("first-contentful-paint")[0];
+      t && (e.fcp = t.startTime);
+      const r = performance.getEntriesByType("largest-contentful-paint");
+      if (r.length > 0) {
+        const o = r[r.length - 1];
+        e.lcp = o.startTime;
+      }
+      const a = performance.getEntriesByType("first-input");
+      if (a.length > 0) {
+        const o = a[0];
+        e.fid = o.processingStart - o.startTime;
+      }
+      const s = performance.getEntriesByType("layout-shift");
+      if (s.length > 0) {
+        let o = 0;
+        for (const p of s) {
+          const l = p;
+          l.hadRecentInput || (o += l.value);
+        }
+        e.cls = o;
+      }
+      const c = this.calculateTTI();
+      c && (e.tti = c);
+    } catch (t) {
+      console.warn("Failed to get Core Web Vitals:", t);
+    }
+    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((t) => ({
+      name: t.name,
+      duration: t.duration,
+      size: t.transferSize,
+      type: this.getResourceType(t.name)
+    }));
+  }
+  /**
+   * Measure function execution time
+   */
+  measureFunction(e, t) {
+    const r = e();
+    return t && (performance.mark(`${t}-start`), performance.mark(`${t}-end`), performance.measure(t, `${t}-start`, `${t}-end`)), r;
+  }
+  /**
+   * Measure async function execution time
+   */
+  async measureAsyncFunction(e, t) {
+    const r = await e();
+    return t && (performance.mark(`${t}-start`), performance.mark(`${t}-end`), performance.measure(t, `${t}-start`, `${t}-end`)), r;
+  }
+  /**
+   * 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 m = new d();
+class u {
+  /**
+   * 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 {
+      return await navigator.serviceWorker.register(e);
+    } catch (t) {
+      return console.error("Service Worker registration failed:", t), null;
+    }
+  }
+  /**
+   * Unregister service worker
+   */
+  async unregisterServiceWorker() {
+    if (!("serviceWorker" in navigator))
+      return !1;
+    try {
+      const e = await navigator.serviceWorker.getRegistrations();
+      for (const t of e)
+        await t.unregister();
+      return !0;
+    } catch (e) {
+      return console.error("Service Worker unregistration failed:", e), !1;
+    }
+  }
+  /**
+   * Request notification permission
+   */
+  async requestNotificationPermission() {
+    if (!("Notification" in window))
+      throw n("Notifications not supported", i.NOT_SUPPORTED);
+    return Notification.permission === "granted" ? "granted" : Notification.permission === "denied" ? "denied" : await Notification.requestPermission();
+  }
+  /**
+   * Send notification
+   */
+  async sendNotification(e, t) {
+    if (!("Notification" in window))
+      throw n("Notifications not supported", i.NOT_SUPPORTED);
+    if (Notification.permission !== "granted")
+      throw n("Notification permission not granted", i.PERMISSION_DENIED);
+    const r = new Notification(e, t);
+    setTimeout(() => {
+      r.close();
+    }, 5e3);
+  }
+  /**
+   * Share content using Web Share API
+   */
+  async share(e) {
+    if (!("share" in navigator))
+      throw n("Web Share API not supported", i.NOT_SUPPORTED);
+    try {
+      await navigator.share(e);
+    } catch (t) {
+      if (t instanceof Error && t.name !== "AbortError")
+        throw n(`Share failed: ${t.message}`, i.OPERATION_FAILED);
+    }
+  }
+  /**
+   * Copy text to clipboard
+   */
+  async copyToClipboard(e) {
+    if (!("clipboard" in navigator))
+      throw n("Clipboard API not supported", i.NOT_SUPPORTED);
+    try {
+      await navigator.clipboard.writeText(e);
+    } catch (t) {
+      throw n(`Copy to clipboard failed: ${t instanceof Error ? t.message : "Unknown error"}`, i.OPERATION_FAILED);
+    }
+  }
+  /**
+   * Read text from clipboard
+   */
+  async readFromClipboard() {
+    if (!("clipboard" in navigator))
+      throw n("Clipboard API not supported", i.NOT_SUPPORTED);
+    try {
+      return await navigator.clipboard.readText();
+    } catch (e) {
+      throw n(`Read from clipboard failed: ${e instanceof Error ? e.message : "Unknown error"}`, i.OPERATION_FAILED);
+    }
+  }
+  /**
+   * Get install prompt event
+   */
+  getInstallPromptEvent() {
+    return new Promise((e) => {
+      const t = (r) => {
+        r.preventDefault(), e(r), window.removeEventListener("beforeinstallprompt", t);
+      };
+      window.addEventListener("beforeinstallprompt", t);
+    });
+  }
+}
+const y = new u();
+export {
+  d as P,
+  u as a,
+  y as b,
+  m as p
+};

package/dist/tweaks/index.js

@@ -1,4 +1,4 @@
-import { a as e, b as s } from "../useTweaks-QxMRmg7i.js";
+import { a as e, b as s } from "../useTweaks-B7Muzo78.js";
 export {
   e as aippyTweaks,
   s as aippyTweaksRuntime

package/dist/url-c26cuIpu.js

@@ -0,0 +1,7 @@
+function o(n, t) {
+  const e = n.endsWith("/") ? n : `${n}/`, i = t.startsWith("/") ? t.slice(1) : t;
+  return new URL(i, e).href;
+}
+export {
+  o as j
+};

package/dist/{useTweaks-QxMRmg7i.js → useTweaks-B7Muzo78.js}

@@ -2,7 +2,8 @@ var b = Object.defineProperty;
 var g = (n, e, t) => e in n ? b(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
 var r = (n, e, t) => g(n, typeof e != "symbol" ? e + "" : e, t);
 import { useReducer as v, useEffect as m } from "react";
-class T {
+import { b as T, a as C } from "./errors-B3bDbQbD.js";
+class I {
   constructor(e) {
     r(this, "cancelled", !1);
     this.cancelFn = e;
@@ -22,13 +23,13 @@ class k {
     this.listeners.forEach((t) => t(e));
   }
   subscribe(e) {
-    return this.listeners.push(e), new T(() => {
+    return this.listeners.push(e), new I(() => {
       const t = this.listeners.indexOf(e);
       t > -1 && this.listeners.splice(t, 1);
     });
   }
 }
-class C {
+class O {
   constructor(e, t) {
     r(this, "values", {});
     r(this, "subject", new k());
@@ -51,7 +52,7 @@ class C {
   getValue(e) {
     const t = this.values[e];
     if (t === void 0)
-      throw new Error(`Tweak key not found in values: ${e}`);
+      throw T(`Tweak key not found in values: ${e}`, C.INVALID_CONFIG);
     return t;
   }
   // React Hook integration
@@ -67,7 +68,7 @@ class C {
     }, [e]), t;
   }
 }
-class I {
+class R {
   constructor() {
     r(this, "tweaksInstance", null);
     r(this, "tweaksDidWarn", !1);
@@ -80,7 +81,7 @@ class I {
     if (this.tweaksInstance)
       return this.tweaksDidWarn || (this.tweaksDidWarn = !0, console.warn("⚠️ [Aippy Tweaks] tweaks() is expected to only be called once, returning previous value")), this.tweaksInstance;
     this.originalConfig = { ...e };
-    const t = new k(), i = new C(t, e), a = {};
+    const t = new k(), i = new O(t, e), a = {};
     for (const s of Object.keys(e))
       a[s] = {
         useState: () => i.useState(s)
@@ -172,11 +173,11 @@ class I {
     }
   }
 }
-const w = new I(), y = {
+const w = new R(), y = {
   tweaks: (n) => w.tweaks(n)
-}, N = y.tweaks;
+}, S = y.tweaks;
 typeof window < "u" && (window.aippyTweaksRuntime = y, window.processNativeData = w.processNativeData.bind(w));
 export {
-  N as a,
+  S as a,
   y as b
 };

package/dist/user/hooks.d.ts

@@ -1,12 +1,16 @@
 /**
  * User SDK Hooks
  */
-/** Hook to get user info (avatar, nickName, username, uid) */
-export declare function useUserInfo(): {
+export interface UserInfo {
     avatar: string;
     nickName: string;
     username: string;
     uid: string;
+}
+/** Hook to get user info (avatar, nickName, username, uid) with loading state */
+export declare function useUserInfo(): UserInfo & {
+    isLoading: boolean;
+    refetch: () => Promise<void>;
 };
 /** Clear cached user info */
 export declare function clearUserInfoCache(): void;

package/dist/user/index.d.ts

@@ -2,5 +2,6 @@
  * User SDK
  */
 export { useUserInfo, clearUserInfoCache } from './hooks';
+export type { UserInfo } from './hooks';
 export { getAuthTokenAsync, isInIframe } from './bridge';
 export type { IOSUserCredentials, IOSUserInfo } from './bridge';

package/dist/user/index.js

@@ -1,6 +1,6 @@
-import { c as o, u as s } from "../hooks-CE9cjXHP.js";
-import { getAuthTokenAsync as f } from "../bridge-Ca3H2iN1.js";
-import { i as t } from "../ui-y5N62DqC.js";
+import { c as o, u as s } from "../hooks-C7VP176R.js";
+import { getAuthTokenAsync as f } from "../bridge-BQQ3PfSO.js";
+import { i as t } from "../app-version-checker-B1UXEcy9.js";
 export {
   o as clearUserInfoCache,
   f as getAuthTokenAsync,

package/dist/utils/app-version-checker.d.ts

@@ -0,0 +1,62 @@
+import { AppVersionConfig, AppEnvironmentCheckResult } from './platform';
+import { default as versionRequirements } from './app-version-requirements.json';
+/**
+ * Feature support check result
+ */
+export interface FeatureSupportResult {
+    /** Whether the feature is supported in current environment */
+    supported: boolean;
+    /** Environment check result from platform detector */
+    envCheck: AppEnvironmentCheckResult;
+    /** Current app version (if in app) */
+    currentVersion?: string;
+    /** Minimum required version for this feature */
+    requiredVersion?: string;
+    /** Error message if not supported */
+    message?: string;
+}
+/**
+ * Available feature names for version checking
+ */
+export type FeatureName = keyof typeof versionRequirements;
+/**
+ * Get version requirements for a feature
+ */
+export declare function getFeatureVersionRequirements(featureName: FeatureName): AppVersionConfig;
+/**
+ * Check if app version supports a specific feature
+ *
+ * @param featureName - The feature to check (e.g., 'userCredentials', 'userInfo')
+ * @returns FeatureSupportResult with support status and details
+ *
+ * @example
+ * ```ts
+ * const result = checkFeatureSupport('userCredentials');
+ * if (!result.supported) {
+ *   console.log('Feature not supported:', result.message);
+ * }
+ * ```
+ */
+export declare function checkFeatureSupport(featureName: FeatureName): FeatureSupportResult;
+/**
+ * Check feature support and handle old version automatically
+ *
+ * This is a convenience function that:
+ * 1. Checks if the feature is supported
+ * 2. If not supported due to old app version, shows an alert and throws an error
+ *
+ * @param featureName - The feature to check
+ * @returns FeatureSupportResult (only returns if supported or web/iframe environment)
+ * @throws Error if app version is too old
+ *
+ * @example
+ * ```ts
+ * const result = requireFeatureSupport('userCredentials');
+ * // Code here only runs if feature is supported
+ * ```
+ */
+export declare function requireFeatureSupport(featureName: FeatureName): FeatureSupportResult;
+/**
+ * Get all available feature names
+ */
+export declare function getAvailableFeatures(): FeatureName[];

package/dist/utils/app-version-requirements.json.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+  "userCredentials": {
+    "iOS": "1.6.7",
+    "Android": "1.1.8"
+  },
+  "userInfo": {
+    "iOS": "1.6.7",
+    "Android": "1.1.8"
+  }
+}
+;
+
+export default _default;

package/dist/utils/index.d.ts

@@ -3,3 +3,5 @@ export * from './performance';
 export * from './pwa';
 export * from './types';
 export * from './ui';
+export * from './url';
+export * from './app-version-checker';

package/dist/utils/index.js

@@ -1,13 +1,19 @@
-import { P as o, c as s, i as e, p as t, s as m } from "../ui-y5N62DqC.js";
-import { a as f, P as i, p as n, b as c } from "../pwa-CilSlaik.js";
+import { P as a, a as s, c as o, b as t, g as p, i, p as m, r as n, s as f } from "../app-version-checker-B1UXEcy9.js";
+import { a as c, P as l, p as P, b as F } from "../pwa-C5nXU0DN.js";
+import { j as g } from "../url-c26cuIpu.js";
 export {
-  f as PWAUtils,
-  i as PerformanceMonitor,
-  o as PlatformDetector,
-  s as compareVersions,
-  e as isInIframe,
-  n as performanceMonitor,
-  t as platform,
-  c as pwa,
-  m as showAlert
+  c as PWAUtils,
+  l as PerformanceMonitor,
+  a as PlatformDetector,
+  s as checkFeatureSupport,
+  o as compareVersions,
+  t as getAvailableFeatures,
+  p as getFeatureVersionRequirements,
+  i as isInIframe,
+  g as joinUrl,
+  P as performanceMonitor,
+  m as platform,
+  F as pwa,
+  n as requireFeatureSupport,
+  f as showAlert
 };

package/dist/utils/ui.d.ts

@@ -2,10 +2,12 @@
  * UI Utilities
  * Common UI components for SDK modules
  */
+export type AlertType = 'update' | 'signin';
 /**
  * 自定义弹窗
  * 用于在各 SDK 模块中显示提示信息
  *
  * @param message - 要显示的消息
+ * @param type - 弹窗类型：'update' 发送消息给原生 App，'signin' 发送消息给父窗口
  */
-export declare function showAlert(message: string): void;
+export declare function showAlert(message: string, type?: AlertType): Promise<void>;

package/dist/utils/url.d.ts

@@ -0,0 +1,7 @@
+/**
+ * URL utilities for Aippy Runtime SDK.
+ */
+/**
+ * Joins a base URL with a path segment.
+ */
+export declare function joinUrl(baseUrl: string, path: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aippy/runtime",
-  "version": "0.2.7-dev.5",
+  "version": "0.2.7-dev.7",
   "description": "Aippy Runtime SDK - Runtime SDK for Aippy projects",
   "private": false,
   "type": "module",