@aippy/runtime 0.2.6 → 0.2.7-dev.1

package/dist/user/api.d.ts

@@ -0,0 +1,9 @@
+import { UserProfile } from './types';
+/**
+ * Fetch user profile by ID from API
+ */
+export declare function fetchUserProfile(userId: string): Promise<UserProfile | null>;
+/**
+ * Clear profile cache
+ */
+export declare function clearProfileCache(userId?: string): void;

package/dist/user/bridge.d.ts

@@ -0,0 +1,162 @@
+/**
+ * User SDK Bridge
+ * Handles communication with:
+ * - iOS native layer via window.webkit.aippyListener
+ * - Parent window via postMessage (iframe scenario)
+ */
+/**
+ * User credentials
+ */
+export interface IOSUserCredentials {
+    uid: string;
+    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
+ */
+export declare function isInIframe(): boolean;
+/**
+ * Request user credentials from parent window (iframe scenario)
+ * Parent window should respond with postMessage containing credentials
+ *
+ * @param timeoutMs - Timeout in milliseconds (default: 5000)
+ * @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
+ *
+ * localStorage format:
+ * - token: JWT string
+ * - 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
+ *
+ * @param timeoutMs - Timeout in milliseconds (default: 5000)
+ * @returns Promise resolving to user credentials (empty if unavailable)
+ */
+export declare function requestCredentialsFromiOS(timeoutMs?: number): Promise<IOSUserCredentials>;
+/**
+ * Receive credentials directly from iOS or parent window
+ * 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
+ */
+export declare function initUserBridge(): void;
+/**
+ * Auto-request credentials on SDK load
+ * Tries multiple sources in order:
+ * 1. iOS native bridge (if available)
+ * 2. Parent localStorage (if in iframe, same-origin)
+ * 3. Parent postMessage (if in iframe, cross-origin)
+ */
+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
+ */
+export declare function getAuthTokenAsync(): Promise<string>;
+/**
+ * Get current user ID asynchronously
+ * Waits for credentials if not already available
+ * @returns Promise resolving to user ID string, or "" if unavailable
+ */
+export declare function getCurrentUserIdAsync(): Promise<string>;
+/**
+ * Check if credentials have been received
+ */
+export declare function hasCredentials(): boolean;
+/**
+ * Get cached credentials (synchronous, may be null if not yet received)
+ */
+export declare function getCachedCredentials(): IOSUserCredentials | null;

package/dist/user/config.d.ts

@@ -0,0 +1,21 @@
+import { UserSdkConfig } from './types';
+/**
+ * Initialize user SDK configuration
+ */
+export declare function initUserSdk(config: Partial<UserSdkConfig>): void;
+/**
+ * Get current user SDK configuration
+ */
+export declare function getUserSdkConfig(): UserSdkConfig;
+/**
+ * Update auth token
+ */
+export declare function setAuthToken(token: string): void;
+/**
+ * Update current user ID
+ */
+export declare function setCurrentUserId(userId: string | null): void;
+/**
+ * Get current auth token synchronously
+ */
+export declare function getAuthToken(): string;

package/dist/user/hooks.d.ts

@@ -0,0 +1,74 @@
+import { UserProfileQueryResult, UserProfilesQueryResult, GetUserProfileByIdOptions, GetJoinedUserProfilesOptions } from './types';
+import { getAuthToken } from './config';
+/**
+ * Hook to get current user ID
+ * @returns Current user ID or null
+ */
+export declare function useCurrentUserId(): string | null;
+/**
+ * Hook to get current auth token
+ * @returns Current auth token string
+ */
+export declare function useAuthToken(): string;
+/**
+ * Hook to get current user's profile
+ * @returns Query result with current user profile data
+ */
+export declare function useGetCurrentUserProfileQuery(): UserProfileQueryResult;
+/**
+ * Hook to get user profile by ID
+ * @param options - Options containing user ID to fetch
+ * @returns Query result with user profile data
+ */
+export declare function useGetUserProfileByIdQuery(options: GetUserProfileByIdOptions): UserProfileQueryResult;
+/**
+ * Hook to get all joined user profiles
+ * @param options - Options for filtering users
+ * @returns Query result with user profiles array
+ *
+ * Note: This is a simplified implementation that only fetches the current user.
+ * In production, this would fetch all users from a users list API.
+ */
+export declare function useGetJoinedUserProfilesQuery(options?: GetJoinedUserProfilesOptions): UserProfilesQueryResult;
+/**
+ * Synchronous function to get current user ID
+ * Use this in non-React contexts
+ */
+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

@@ -0,0 +1,12 @@
+/**
+ * User SDK module
+ * Provides user profile fetching and session management
+ */
+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, 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, requestUserInfoFromiOS, getUserInfoAsync, getCachedUserInfo, hasUserInfo, clearCachedUserInfo, requestUserInfoFromParent, tryGetUserInfoFromParentStorage, getUserInfoFromParent, } from './bridge';
+export type { IOSUserCredentials, IOSUserInfo } from './bridge';

package/dist/user/index.js

@@ -0,0 +1,38 @@
+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-D2d8hnO_.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-SbuNZ7JR.js";
+export {
+  r as autoRequestCredentials,
+  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

@@ -0,0 +1,113 @@
+/**
+ * User SDK types and interfaces
+ */
+/**
+ * Global type declarations for User SDK iOS bridge
+ * Note: webkit.messageHandlers.aippyListener is already declared in tweaks/types.ts
+ */
+declare global {
+    interface Window {
+        /** User credentials callback from iOS */
+        processUserCredentials?: (data: unknown) => void;
+        /** User info callback from iOS */
+        processUserInfo?: (data: unknown) => void;
+    }
+}
+/**
+ * User profile data structure
+ */
+export interface UserProfile {
+    /** User unique identifier */
+    id: string;
+    /** Display name */
+    displayName: string;
+    /** Username (for @mentions) */
+    username: string;
+    /** Avatar URL */
+    photoUrl?: string;
+    /** Online status */
+    online?: boolean;
+    /** User bio */
+    bio?: string;
+    /** Cover image URL */
+    coverImageUrl?: string;
+    /** Additional metadata */
+    [key: string]: unknown;
+}
+/**
+ * Query result for user profile
+ */
+export interface UserProfileQueryResult {
+    /** User profile data */
+    data: UserProfile | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    isError: boolean;
+    /** Error object */
+    error: Error | null;
+    /** Refetch function */
+    refetch: () => Promise<void>;
+}
+/**
+ * Options for getting user profile by ID
+ */
+export interface GetUserProfileByIdOptions {
+    /** User ID to fetch */
+    id: string;
+}
+/**
+ * Options for getting joined user profiles
+ */
+export interface GetJoinedUserProfilesOptions {
+    /** Whether to include current user */
+    includeSelf?: boolean;
+}
+/**
+ * Query result for multiple user profiles
+ */
+export interface UserProfilesQueryResult {
+    /** User profiles array */
+    data: UserProfile[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    isError: boolean;
+    /** Error object */
+    error: Error | null;
+    /** Refetch function */
+    refetch: () => Promise<void>;
+}
+/**
+ * Date format options
+ */
+export interface FormatDateOptions {
+    /** Timestamp in milliseconds */
+    timestampMs: number;
+    /** Format string (e.g., 'MMM d, h:mm a') */
+    formatString: string;
+}
+/**
+ * User session info interface
+ */
+export interface UserSessionInfoInterface {
+    /** Get current user ID synchronously */
+    getCurrentUserId: () => string | null;
+    /** Get current timestamp in milliseconds */
+    getTimestampInMs: () => number;
+    /** Format date with given format string */
+    formatDate: (options: FormatDateOptions) => string;
+}
+/**
+ * User SDK configuration
+ */
+export interface UserSdkConfig {
+    /** API base URL */
+    apiBaseUrl: string;
+    /** Auth token */
+    authToken: string;
+    /** Current user ID */
+    currentUserId: string | null;
+    /** Cache time in milliseconds */
+    cacheTime?: number;
+}

package/dist/user/userSessionInfo.d.ts

@@ -0,0 +1,6 @@
+import { UserSessionInfoInterface } from './types';
+/**
+ * User session info object
+ * Provides synchronous access to current user data and utilities
+ */
+export declare const userSessionInfo: UserSessionInfoInterface;

package/dist/user.d.ts

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

package/dist/userSessionInfo-SbuNZ7JR.js

@@ -0,0 +1,229 @@
+import { useState as o, useEffect as y, useCallback as U } from "react";
+import { g as I, b as k } from "./bridge-D2d8hnO_.js";
+const w = /* @__PURE__ */ new Map();
+async function S(e) {
+  const t = I(), n = w.get(e);
+  if (n && Date.now() - n.timestamp < (t.cacheTime || 3e5))
+    return n.data;
+  try {
+    const r = await fetch(
+      `${t.apiBaseUrl}/user/profile?targetUid=${e}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${t.authToken}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (!r.ok)
+      throw new Error(`Failed to fetch user profile: ${r.status}`);
+    const a = await r.json(), i = C(a, e);
+    return w.set(e, { data: i, timestamp: Date.now() }), i;
+  } catch (r) {
+    return console.error("[UserSDK] Failed to fetch user profile:", r), null;
+  }
+}
+function C(e, t) {
+  const n = typeof e == "object" && e !== null ? e : {}, r = n.data || n.user || n;
+  return {
+    id: r.id || r.uid || t,
+    displayName: r.displayName || r.nickname || r.name || "Unknown User",
+    username: r.username || r.id || t,
+    photoUrl: r.photoUrl || r.avatar || r.avatarUrl,
+    online: r.online ?? !1,
+    bio: r.bio,
+    coverImageUrl: r.coverImageUrl,
+    ...r
+  };
+}
+function D(e) {
+  e ? w.delete(e) : w.clear();
+}
+function M() {
+  const [e, t] = o(
+    I().currentUserId
+  );
+  return y(() => {
+    t(I().currentUserId);
+  }, []), e;
+}
+function N() {
+  const [e, t] = o(k());
+  return y(() => {
+    t(k());
+  }, []), e;
+}
+function T() {
+  const e = M(), [t, n] = o(null), [r, a] = o(!0), [i, u] = o(!1), [h, s] = o(null), l = U(async () => {
+    if (!e) {
+      n(null), a(!1);
+      return;
+    }
+    a(!0), u(!1), s(null);
+    try {
+      const c = await S(e);
+      n(c);
+    } catch (c) {
+      u(!0), s(c instanceof Error ? c : new Error(String(c)));
+    } finally {
+      a(!1);
+    }
+  }, [e]);
+  y(() => {
+    l();
+  }, [l]);
+  const f = U(async () => {
+    e && D(e), await l();
+  }, [e, l]);
+  return { data: t, isLoading: r, isError: i, error: h, refetch: f };
+}
+function b(e) {
+  const { id: t } = e, [n, r] = o(null), [a, i] = o(!0), [u, h] = o(!1), [s, l] = o(null), f = U(async () => {
+    if (!t) {
+      r(null), i(!1);
+      return;
+    }
+    i(!0), h(!1), l(null);
+    try {
+      const d = await S(t);
+      r(d);
+    } catch (d) {
+      h(!0), l(d instanceof Error ? d : new Error(String(d)));
+    } finally {
+      i(!1);
+    }
+  }, [t]);
+  y(() => {
+    f();
+  }, [f]);
+  const c = U(async () => {
+    D(t), await f();
+  }, [t, f]);
+  return { data: n, isLoading: a, isError: u, error: s, refetch: c };
+}
+function A(e = {}) {
+  const { includeSelf: t = !0 } = e, n = M(), [r, a] = o([]), [i, u] = o(!0), [h, s] = o(!1), [l, f] = o(null), c = U(async () => {
+    u(!0), s(!1), f(null);
+    try {
+      const m = [];
+      if (t && n) {
+        const E = await S(n);
+        E && m.push(E);
+      }
+      a(m);
+    } catch (m) {
+      s(!0), f(m instanceof Error ? m : new Error(String(m)));
+    } finally {
+      u(!1);
+    }
+  }, [t, n]);
+  y(() => {
+    c();
+  }, [c]);
+  const d = U(async () => {
+    D(), await c();
+  }, [c]);
+  return { data: r, isLoading: i, isError: h, error: l, refetch: d };
+}
+function L() {
+  return I().currentUserId;
+}
+let g = null, p = null;
+function j() {
+  const [e, t] = o(g || {
+    avatar: "",
+    nickName: "用户",
+    username: "",
+    uid: ""
+  });
+  return y(() => {
+    let n = !0;
+    return (async () => {
+      try {
+        if (g) {
+          console.log("[useUserInfo] Using cached user info"), n && t(g);
+          return;
+        }
+        if (p) {
+          console.log("[useUserInfo] Waiting for existing request"), await p, n && g && t(g);
+          return;
+        }
+        console.log("[useUserInfo] Fetching user info"), p = (async () => {
+          const { getUserInfoAsync: a, getUserInfoFromParent: i, isInIframe: u } = await import("./bridge-D2d8hnO_.js").then((l) => l.x), { hasNativeBridge: h } = await import("./native-bridge-BnvipFJc.js");
+          let s = null;
+          h() ? s = await a() : u() ? s = await i() : s = await a(), s && (g = {
+            avatar: String(s.avatar || s.photoUrl || ""),
+            nickName: String(s.nickName || s.displayName || "用户"),
+            username: String(s.username || ""),
+            uid: String(s.uid || "")
+          });
+        })(), await p, p = null, n && g && t(g);
+      } catch (a) {
+        console.error("[useUserInfo] Failed to fetch user info:", a), p = null;
+      }
+    })(), () => {
+      n = !1;
+    };
+  }, []), e;
+}
+function B() {
+  g = null, p = null, console.log("[useUserInfo] Cache cleared");
+}
+function P(e, t) {
+  const n = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ], r = e.getHours(), a = r % 12 || 12, i = r >= 12 ? "PM" : "AM";
+  return t.replace("MMM", n[e.getMonth()]).replace("dd", String(e.getDate()).padStart(2, "0")).replace("d", String(e.getDate())).replace("hh", String(a).padStart(2, "0")).replace("h", String(a)).replace("mm", String(e.getMinutes()).padStart(2, "0")).replace("a", i).replace("yyyy", String(e.getFullYear())).replace("yy", String(e.getFullYear()).slice(-2));
+}
+const G = {
+  /**
+   * Get current user ID synchronously
+   */
+  getCurrentUserId() {
+    return I().currentUserId;
+  },
+  /**
+   * Get current timestamp in milliseconds
+   */
+  getTimestampInMs() {
+    return Date.now();
+  },
+  /**
+   * Format date with given format string
+   * @param options - Format options with timestamp and format string
+   * @returns Formatted date string
+   *
+   * @example
+   * userSessionInfo.formatDate({ timestampMs: Date.now(), formatString: 'MMM d, h:mm a' })
+   * // Returns: "Jan 7, 10:30 PM"
+   */
+  formatDate(e) {
+    const { timestampMs: t, formatString: n } = e, r = new Date(t);
+    return P(r, n);
+  }
+};
+export {
+  N as a,
+  T as b,
+  b as c,
+  A as d,
+  j as e,
+  B as f,
+  L as g,
+  S as h,
+  D as i,
+  G as j,
+  M as u
+};