@aippy/runtime 0.2.7-dev.0 → 0.2.7-dev.2

package/dist/pwa-CilSlaik.js

@@ -0,0 +1,249 @@
+class f {
+  /**
+   * Get Core Web Vitals metrics
+   */
+  async getCoreWebVitals() {
+    const r = {};
+    try {
+      const e = performance.getEntriesByName("first-contentful-paint")[0];
+      e && (r.fcp = e.startTime);
+      const t = performance.getEntriesByType("largest-contentful-paint");
+      if (t.length > 0) {
+        const n = t[t.length - 1];
+        r.lcp = n.startTime;
+      }
+      const i = performance.getEntriesByType("first-input");
+      if (i.length > 0) {
+        const n = i[0];
+        r.fid = n.processingStart - n.startTime;
+      }
+      const o = performance.getEntriesByType("layout-shift");
+      if (o.length > 0) {
+        let n = 0;
+        for (const l of o) {
+          const s = l;
+          s.hadRecentInput || (n += s.value);
+        }
+        r.cls = n;
+      }
+      const a = this.calculateTTI();
+      a && (r.tti = a);
+    } catch (e) {
+      console.warn("Failed to get Core Web Vitals:", e);
+    }
+    return r;
+  }
+  /**
+   * Get navigation timing metrics
+   */
+  getNavigationTiming() {
+    const r = performance.getEntriesByType("navigation")[0];
+    return r ? {
+      // DNS lookup time
+      dns: r.domainLookupEnd - r.domainLookupStart,
+      // TCP connection time
+      tcp: r.connectEnd - r.connectStart,
+      // Request time
+      request: r.responseStart - r.requestStart,
+      // Response time
+      response: r.responseEnd - r.responseStart,
+      // DOM processing time
+      domProcessing: r.domComplete - r.domInteractive,
+      // Total page load time
+      total: r.loadEventEnd - r.fetchStart
+    } : null;
+  }
+  /**
+   * Get resource timing metrics
+   */
+  getResourceTiming() {
+    return performance.getEntriesByType("resource").map((e) => ({
+      name: e.name,
+      duration: e.duration,
+      size: e.transferSize,
+      type: this.getResourceType(e.name)
+    }));
+  }
+  /**
+   * Measure function execution time
+   */
+  measureFunction(r, e) {
+    const t = r();
+    return e && (performance.mark(`${e}-start`), performance.mark(`${e}-end`), performance.measure(e, `${e}-start`, `${e}-end`)), t;
+  }
+  /**
+   * Measure async function execution time
+   */
+  async measureAsyncFunction(r, e) {
+    const t = await r();
+    return e && (performance.mark(`${e}-start`), performance.mark(`${e}-end`), performance.measure(e, `${e}-start`, `${e}-end`)), t;
+  }
+  /**
+   * Get memory usage (if available)
+   */
+  getMemoryUsage() {
+    if ("memory" in performance) {
+      const r = performance.memory;
+      return {
+        used: r.usedJSHeapSize,
+        total: r.totalJSHeapSize,
+        limit: r.jsHeapSizeLimit
+      };
+    }
+    return null;
+  }
+  calculateTTI() {
+    const r = performance.getEntriesByType("navigation")[0];
+    return r ? r.domContentLoadedEventEnd - r.fetchStart : null;
+  }
+  getResourceType(r) {
+    return r.includes(".js") ? "script" : r.includes(".css") ? "stylesheet" : r.includes(".png") || r.includes(".jpg") || r.includes(".gif") ? "image" : r.includes(".woff") || r.includes(".ttf") ? "font" : "other";
+  }
+}
+const p = new f();
+class d {
+  /**
+   * 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(r) {
+    if (!("serviceWorker" in navigator))
+      return console.warn("Service Worker not supported"), null;
+    try {
+      return await navigator.serviceWorker.register(r);
+    } catch (e) {
+      return console.error("Service Worker registration failed:", e), null;
+    }
+  }
+  /**
+   * Unregister service worker
+   */
+  async unregisterServiceWorker() {
+    if (!("serviceWorker" in navigator))
+      return !1;
+    try {
+      const r = await navigator.serviceWorker.getRegistrations();
+      for (const e of r)
+        await e.unregister();
+      return !0;
+    } catch (r) {
+      return console.error("Service Worker unregistration failed:", r), !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(r, e) {
+    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(r, e);
+    setTimeout(() => {
+      t.close();
+    }, 5e3);
+  }
+  /**
+   * Share content using Web Share API
+   */
+  async share(r) {
+    if (!("share" in navigator))
+      throw new Error("Web Share API not supported");
+    try {
+      await navigator.share(r);
+    } catch (e) {
+      if (e instanceof Error && e.name !== "AbortError")
+        throw new Error(`Share failed: ${e.message}`);
+    }
+  }
+  /**
+   * Copy text to clipboard
+   */
+  async copyToClipboard(r) {
+    if (!("clipboard" in navigator))
+      throw new Error("Clipboard API not supported");
+    try {
+      await navigator.clipboard.writeText(r);
+    } catch (e) {
+      throw new Error(`Copy to clipboard failed: ${e instanceof Error ? e.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 (r) {
+      throw new Error(`Read from clipboard failed: ${r instanceof Error ? r.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get install prompt event
+   */
+  getInstallPromptEvent() {
+    return new Promise((r) => {
+      const e = (t) => {
+        t.preventDefault(), r(t), window.removeEventListener("beforeinstallprompt", e);
+      };
+      window.addEventListener("beforeinstallprompt", e);
+    });
+  }
+}
+const u = new d();
+export {
+  f as P,
+  d as a,
+  u as b,
+  p
+};

package/dist/ui-D6IZ1jrR.js

@@ -0,0 +1,119 @@
+var a = Object.defineProperty;
+var c = (o, e, n) => e in o ? a(o, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : o[e] = n;
+var s = (o, e, n) => c(o, typeof e != "symbol" ? e + "" : e, n);
+import { UAParser as d } from "ua-parser-js";
+class l {
+  constructor() {
+    s(this, "parser");
+    this.parser = new d();
+  }
+  /**
+   * Get platform information
+   */
+  getPlatformInfo() {
+    const e = this.parser.getResult(), n = this.normalizePlatformName(e.os.name), t = this.normalizeBrowserName(e.browser.name), r = this.isMobileDevice(), i = !r;
+    return {
+      name: n,
+      version: e.os.version,
+      browser: t,
+      browserVersion: e.browser.version,
+      isMobile: r,
+      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";
+  }
+  /**
+   * 解析 User-Agent 中的 Aippy App 信息
+   */
+  parseAippyInfo() {
+    const e = navigator.userAgent, n = /Aippy\/([^\/]+)\/[^\/]+\/(iOS|Android)/i, t = e.match(n);
+    if (t) {
+      const r = t[1];
+      return {
+        platform: t[2],
+        version: r
+      };
+    }
+    return null;
+  }
+  normalizePlatformName(e) {
+    if (!e) return "unknown";
+    const n = e.toLowerCase();
+    return n.includes("ios") ? "ios" : n.includes("android") ? "android" : n.includes("windows") ? "windows" : n.includes("mac") ? "macos" : n.includes("linux") ? "linux" : "unknown";
+  }
+  normalizeBrowserName(e) {
+    if (!e) return "unknown";
+    const n = e.toLowerCase();
+    return n.includes("chrome") ? "chrome" : n.includes("firefox") ? "firefox" : n.includes("safari") ? "safari" : n.includes("edge") ? "edge" : "unknown";
+  }
+  getWebGLContext() {
+    try {
+      const e = document.createElement("canvas");
+      return e.getContext("webgl") || e.getContext("experimental-webgl");
+    } catch {
+      return null;
+    }
+  }
+}
+const f = new l();
+function p(o) {
+  const e = document.createElement("div");
+  e.style.cssText = "position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,0.5);display:flex;align-items:center;justify-content:center;z-index:999999";
+  const n = document.createElement("div");
+  n.style.cssText = "background:#fff;border-radius:12px;padding:24px 32px;max-width:80%;text-align:center;box-shadow:0 4px 20px rgba(0,0,0,0.15)";
+  const t = document.createElement("p");
+  t.style.cssText = "margin:0 0 20px;font-size:16px;color:#333;line-height:1.5", t.textContent = o;
+  const r = document.createElement("button");
+  r.style.cssText = "background:#007AFF;color:#fff;border:none;border-radius:8px;padding:10px 32px;font-size:15px;cursor:pointer", r.textContent = "OK", r.onclick = () => e.remove(), n.appendChild(t), n.appendChild(r), e.appendChild(n), document.body.appendChild(e);
+}
+export {
+  l as P,
+  f as p,
+  p as s
+};

package/dist/user/bridge.d.ts

@@ -12,6 +12,22 @@ export interface IOSUserCredentials {
     token: string;
     apiBaseUrl?: string;
 }
+/**
+ * User information (extended profile data)
+ */
+export interface IOSUserInfo {
+    uid: string;
+    displayName?: string;
+    nickname?: string;
+    username?: string;
+    photoUrl?: string;
+    avatar?: string;
+    email?: string;
+    phone?: string;
+    bio?: string;
+    online?: boolean;
+    [key: string]: unknown;
+}
 /**
  * Check if running inside an iframe
  */
@@ -24,6 +40,15 @@ export declare function isInIframe(): boolean;
  * @returns Promise resolving to user credentials
  */
 export declare function requestCredentialsFromParent(timeoutMs?: number): Promise<IOSUserCredentials>;
+/**
+ * Request user info from parent window (iframe scenario)
+ * Parent window should respond with postMessage containing user info
+ * IMPORTANT: This method does NOT cache - it always requests fresh data
+ *
+ * @param timeoutMs - Timeout in milliseconds (default: 5000)
+ * @returns Promise resolving to user info (null if unavailable)
+ */
+export declare function requestUserInfoFromParent(timeoutMs?: number): Promise<IOSUserInfo | null>;
 /**
  * Try to get credentials from parent localStorage directly
  * This works when same-origin, otherwise falls back to postMessage
@@ -33,6 +58,17 @@ export declare function requestCredentialsFromParent(timeoutMs?: number): Promis
  * - user: JSON string with { uid, nickName, ... }
  */
 export declare function tryGetCredentialsFromParentStorage(): IOSUserCredentials | null;
+/**
+ * Try to get user info from parent localStorage directly
+ * This works when same-origin, otherwise falls back to postMessage
+ * IMPORTANT: This method does NOT cache - it always reads fresh data from parent
+ *
+ * localStorage format:
+ * - user: JSON string with { uid, nickName, username, avatar, ... }
+ *
+ * @returns User info or null if unavailable
+ */
+export declare function tryGetUserInfoFromParentStorage(): IOSUserInfo | null;
 /**
  * Request user credentials from iOS native layer
  * Uses aippyRuntime's message passing mechanism
@@ -46,6 +82,52 @@ export declare function requestCredentialsFromiOS(timeoutMs?: number): Promise<I
  * Called via: window.processUserCredentials(data)
  */
 export declare function processUserCredentials(data: unknown): void;
+/**
+ * Receive user info directly from iOS or parent window
+ * Called via: window.processUserInfo(data)
+ */
+export declare function processUserInfo(data: unknown): void;
+/**
+ * Request user info from iOS native layer
+ * This method caches the result and won't request again unless forced
+ *
+ * @param forceRefresh - Force refresh even if cached (default: false)
+ * @param timeoutMs - Timeout in milliseconds (default: 5000)
+ * @returns Promise resolving to user info (null if unavailable)
+ */
+export declare function requestUserInfoFromiOS(forceRefresh?: boolean, timeoutMs?: number): Promise<IOSUserInfo | null>;
+/**
+ * Get user info asynchronously
+ * Returns cached user info if available, otherwise requests from iOS
+ *
+ * @param forceRefresh - Force refresh even if cached (default: false)
+ * @returns Promise resolving to user info, or null if unavailable
+ */
+export declare function getUserInfoAsync(forceRefresh?: boolean): Promise<IOSUserInfo | null>;
+/**
+ * Get user info from parent window (iframe scenario)
+ * IMPORTANT: This method ALWAYS fetches fresh data, NO caching
+ *
+ * Strategy:
+ * 1. Try to get from parent localStorage (same-origin, faster)
+ * 2. If cross-origin, use postMessage (slower but works cross-origin)
+ *
+ * @param timeoutMs - Timeout for postMessage request (default: 5000)
+ * @returns Promise resolving to fresh user info, or null if unavailable
+ */
+export declare function getUserInfoFromParent(timeoutMs?: number): Promise<IOSUserInfo | null>;
+/**
+ * Get cached user info (synchronous, may be null if not yet received)
+ */
+export declare function getCachedUserInfo(): IOSUserInfo | null;
+/**
+ * Check if user info has been received
+ */
+export declare function hasUserInfo(): boolean;
+/**
+ * Clear cached user info (useful for logout)
+ */
+export declare function clearCachedUserInfo(): void;
 /**
  * Initialize bridge and expose to window
  */
@@ -59,9 +141,7 @@ export declare function initUserBridge(): void;
  */
 export declare function autoRequestCredentials(): Promise<void>;
 /**
- * Get auth token asynchronously
- * Waits for credentials if not already available
- * @returns Promise resolving to token string, or "" if unavailable
+ * 异步获取 Auth Token
  */
 export declare function getAuthTokenAsync(): Promise<string>;
 /**

package/dist/user/hooks.d.ts

@@ -36,3 +36,39 @@ export declare function useGetJoinedUserProfilesQuery(options?: GetJoinedUserPro
  */
 export declare function getCurrentUserId(): string | null;
 export { getAuthToken };
+/**
+ * Hook to get user info from iOS or parent window (no backend API)
+ * Automatically detects environment (iOS App or iframe) and uses appropriate method
+ *
+ * Uses module-level cache to avoid duplicate requests when used in multiple components
+ *
+ * @returns User info with avatar, nickName, username, uid
+ *
+ * @example
+ * ```typescript
+ * const { avatar, nickName, username, uid } = useUserInfo();
+ *
+ * <Avatar>
+ *   <AvatarImage src={avatar} />
+ *   <AvatarFallback>{nickName[0]}</AvatarFallback>
+ * </Avatar>
+ * <span>{nickName}</span>
+ * ```
+ */
+export declare function useUserInfo(): {
+    avatar: string;
+    nickName: string;
+    username: string;
+    uid: string;
+};
+/**
+ * Clear the cached user info
+ * Useful when user logs out or switches account
+ *
+ * @example
+ * ```typescript
+ * // When user logs out
+ * clearUserInfoCache();
+ * ```
+ */
+export declare function clearUserInfoCache(): void;

package/dist/user/index.d.ts

@@ -4,8 +4,9 @@
  */
 export type { UserProfile, UserProfileQueryResult, UserProfilesQueryResult, GetUserProfileByIdOptions, GetJoinedUserProfilesOptions, FormatDateOptions, UserSessionInfoInterface, UserSdkConfig, } from './types';
 export { initUserSdk, getUserSdkConfig, setAuthToken, setCurrentUserId, } from './config';
-export { useCurrentUserId, useAuthToken, useGetCurrentUserProfileQuery, useGetUserProfileByIdQuery, useGetJoinedUserProfilesQuery, getCurrentUserId, getAuthToken, } from './hooks';
+export { useCurrentUserId, useAuthToken, useGetCurrentUserProfileQuery, useGetUserProfileByIdQuery, useGetJoinedUserProfilesQuery, getCurrentUserId, getAuthToken, useUserInfo, // Simple hook for iOS/iframe user info
+clearUserInfoCache, } from './hooks';
 export { fetchUserProfile, clearProfileCache } from './api';
 export { userSessionInfo } from './userSessionInfo';
-export { isInIframe, requestCredentialsFromiOS, requestCredentialsFromParent, tryGetCredentialsFromParentStorage, initUserBridge, autoRequestCredentials, getAuthTokenAsync, getCurrentUserIdAsync, hasCredentials, getCachedCredentials, } from './bridge';
-export type { IOSUserCredentials } from './bridge';
+export { isInIframe, requestCredentialsFromiOS, requestCredentialsFromParent, tryGetCredentialsFromParentStorage, initUserBridge, autoRequestCredentials, getAuthTokenAsync, getCurrentUserIdAsync, hasCredentials, getCachedCredentials, requestUserInfoFromiOS, getUserInfoAsync, getCachedUserInfo, hasUserInfo, clearCachedUserInfo, requestUserInfoFromParent, tryGetUserInfoFromParentStorage, getUserInfoFromParent, } from './bridge';
+export type { IOSUserCredentials, IOSUserInfo } from './bridge';

package/dist/user/index.js

@@ -1,28 +1,38 @@
-import { f as r, b as a, h as t, l as n, j as u, g as i, k as o, e as d, i as C, c as f, d as l, r as g, s as U, a as h, t as c } from "../bridge-DdAH4txB.js";
-import { e as k, f as y, g as P, a as m, u as A, b as S, d as G, c as T, h as q } from "../userSessionInfo-CBk9ywXi.js";
+import { f as r, q as a, b as t, h as n, l as o, o as u, j as i, n as f, w as U, g as d, k as I, p as C, e as g, i as l, c, d as h, r as m, u as P, m as y, s as k, a as A, t as F, v as S } from "../bridge-N9ELFpfV.js";
+import { i as G, f as T, h as p, g as Q, a as b, u as j, b as x, d as B, c as O, e as v, j as w } from "../userSessionInfo-DFvsuELU.js";
 export {
   r as autoRequestCredentials,
-  k as clearProfileCache,
-  y as fetchUserProfile,
-  a as getAuthToken,
-  t as getAuthTokenAsync,
-  n as getCachedCredentials,
-  P as getCurrentUserId,
-  u as getCurrentUserIdAsync,
-  i as getUserSdkConfig,
-  o as hasCredentials,
-  d as initUserBridge,
-  C as initUserSdk,
-  f as isInIframe,
-  l as requestCredentialsFromParent,
-  g as requestCredentialsFromiOS,
-  U as setAuthToken,
-  h as setCurrentUserId,
-  c as tryGetCredentialsFromParentStorage,
-  m as useAuthToken,
-  A as useCurrentUserId,
-  S as useGetCurrentUserProfileQuery,
-  G as useGetJoinedUserProfilesQuery,
-  T as useGetUserProfileByIdQuery,
-  q as userSessionInfo
+  a as clearCachedUserInfo,
+  G as clearProfileCache,
+  T as clearUserInfoCache,
+  p as fetchUserProfile,
+  t as getAuthToken,
+  n as getAuthTokenAsync,
+  o as getCachedCredentials,
+  u as getCachedUserInfo,
+  Q as getCurrentUserId,
+  i as getCurrentUserIdAsync,
+  f as getUserInfoAsync,
+  U as getUserInfoFromParent,
+  d as getUserSdkConfig,
+  I as hasCredentials,
+  C as hasUserInfo,
+  g as initUserBridge,
+  l as initUserSdk,
+  c as isInIframe,
+  h as requestCredentialsFromParent,
+  m as requestCredentialsFromiOS,
+  P as requestUserInfoFromParent,
+  y as requestUserInfoFromiOS,
+  k as setAuthToken,
+  A as setCurrentUserId,
+  F as tryGetCredentialsFromParentStorage,
+  S as tryGetUserInfoFromParentStorage,
+  b as useAuthToken,
+  j as useCurrentUserId,
+  x as useGetCurrentUserProfileQuery,
+  B as useGetJoinedUserProfilesQuery,
+  O as useGetUserProfileByIdQuery,
+  v as useUserInfo,
+  w as userSessionInfo
 };

package/dist/user/types.d.ts

@@ -9,6 +9,8 @@ declare global {
     interface Window {
         /** User credentials callback from iOS */
         processUserCredentials?: (data: unknown) => void;
+        /** User info callback from iOS */
+        processUserInfo?: (data: unknown) => void;
     }
 }
 /**