@clarityops/preferences 0.1.1

package/dist/index.js

@@ -0,0 +1,625 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AVATAR_CACHE_TTL: () => AVATAR_CACHE_TTL,
+  PreferencesProvider: () => PreferencesProvider,
+  PreferencesService: () => PreferencesService,
+  clearAvatarCache: () => clearAvatarCache,
+  getCachedAvatar: () => getCachedAvatar,
+  hasCachedAvatar: () => hasCachedAvatar,
+  setCachedAvatar: () => setCachedAvatar,
+  useAvatar: () => useAvatar,
+  usePreferences: () => usePreferences,
+  usePreferencesSafe: () => usePreferencesSafe
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/PreferencesContext.tsx
+var import_react = require("react");
+
+// src/PreferencesService.ts
+function isValidJwtFormat(token) {
+  if (!token || typeof token !== "string") return false;
+  if (token === "null" || token === "undefined" || token.trim() === "") return false;
+  const segments = token.split(".");
+  return segments.length === 3;
+}
+function isTokenExpired(token) {
+  try {
+    const payload = JSON.parse(atob(token.split(".")[1]));
+    const currentTime = Math.floor(Date.now() / 1e3);
+    return payload.exp < currentTime;
+  } catch {
+    return true;
+  }
+}
+var refreshInProgress = null;
+var lastRefreshTime = 0;
+var REFRESH_DEBOUNCE_MS = 5e3;
+var PreferencesService = class {
+  constructor(config) {
+    this.baseUrl = config.apiBaseUrl;
+    this.brandingUrl = config.brandingUrl;
+    this.getToken = config.getToken;
+    this.onTokenInvalid = config.onTokenInvalid;
+  }
+  /**
+   * Update the config (e.g., when token changes)
+   */
+  updateConfig(config) {
+    if (config.getToken) {
+      this.getToken = config.getToken;
+    }
+    if (config.onTokenInvalid !== void 0) {
+      this.onTokenInvalid = config.onTokenInvalid;
+    }
+    if (config.apiBaseUrl) {
+      this.baseUrl = config.apiBaseUrl;
+    }
+    if (config.brandingUrl) {
+      this.brandingUrl = config.brandingUrl;
+    }
+  }
+  /**
+   * Refresh token with debounce to prevent multiple simultaneous refresh attempts
+   */
+  async refreshWithDebounce() {
+    const now = Date.now();
+    if (refreshInProgress) {
+      console.log("[PreferencesService] \u23F3 Waiting for existing refresh to complete...");
+      return refreshInProgress;
+    }
+    if (now - lastRefreshTime < REFRESH_DEBOUNCE_MS) {
+      console.log("[PreferencesService] \u23F3 Recent refresh detected, using current token");
+      return this.getToken();
+    }
+    if (this.onTokenInvalid) {
+      console.log("[PreferencesService] \u{1F504} Starting token refresh...");
+      lastRefreshTime = now;
+      refreshInProgress = this.onTokenInvalid().finally(() => {
+        refreshInProgress = null;
+      });
+      return refreshInProgress;
+    }
+    return null;
+  }
+  /**
+   * Get a valid token, refreshing if necessary with debounce protection
+   */
+  async getValidToken() {
+    let token = this.getToken();
+    if (!isValidJwtFormat(token)) {
+      console.warn("[PreferencesService] Token is missing or malformed, attempting refresh...");
+      token = await this.refreshWithDebounce();
+      if (!isValidJwtFormat(token)) {
+        throw new Error("Authentication required - no valid token available");
+      }
+    }
+    if (isTokenExpired(token)) {
+      console.warn("[PreferencesService] Token is expired, attempting refresh...");
+      token = await this.refreshWithDebounce();
+      if (!token || isTokenExpired(token)) {
+        throw new Error("Session expired - please log in again");
+      }
+    }
+    return token;
+  }
+  async request(endpoint, options = {}) {
+    const token = await this.getValidToken();
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      if (response.status === 401 && this.onTokenInvalid) {
+        console.warn("[PreferencesService] Got 401, attempting token refresh and retry...");
+        const newToken = await this.onTokenInvalid();
+        if (newToken && isValidJwtFormat(newToken)) {
+          const retryResponse = await fetch(`${this.baseUrl}${endpoint}`, {
+            ...options,
+            headers: {
+              "Authorization": `Bearer ${newToken}`,
+              "Content-Type": "application/json",
+              ...options.headers
+            }
+          });
+          if (retryResponse.ok) {
+            return retryResponse.json();
+          }
+        }
+      }
+      throw new Error(error.error || error.message || "Request failed");
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Get user preferences
+   */
+  async getPreferences() {
+    return this.request("/forge/users/me/preferences");
+  }
+  /**
+   * Update preferences (merge update)
+   */
+  async updatePreferences(preferences) {
+    return this.request("/forge/users/me/preferences", {
+      method: "PATCH",
+      body: JSON.stringify(preferences)
+    });
+  }
+  /**
+   * Replace all preferences
+   */
+  async replacePreferences(preferences) {
+    return this.request("/forge/users/me/preferences", {
+      method: "PUT",
+      body: JSON.stringify(preferences)
+    });
+  }
+  /**
+   * Step 1: Prepare avatar upload - get signed URL for GCS
+   */
+  async prepareAvatarUpload(filename, mimeType) {
+    const token = await this.getValidToken();
+    const response = await fetch(`${this.brandingUrl}/branding/prepare-avatar-upload`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        filename,
+        mime_type: mimeType
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to prepare upload" }));
+      if (response.status === 401 && this.onTokenInvalid) {
+        console.warn("[PreferencesService] Got 401 on prepareAvatarUpload, attempting refresh...");
+        const newToken = await this.onTokenInvalid();
+        if (newToken && isValidJwtFormat(newToken)) {
+          const retryResponse = await fetch(`${this.brandingUrl}/branding/prepare-avatar-upload`, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${newToken}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              filename,
+              mime_type: mimeType
+            })
+          });
+          if (retryResponse.ok) {
+            const data2 = await retryResponse.json();
+            if (data2.success) return data2.data;
+          }
+        }
+      }
+      throw new Error(error.error || error.message || "Failed to prepare avatar upload");
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new Error(data.error || "Failed to prepare avatar upload");
+    }
+    return data.data;
+  }
+  /**
+   * Step 2: Upload file directly to GCS
+   */
+  async uploadToGCS(uploadUrl, file) {
+    const response = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": file.type
+      },
+      body: file
+    });
+    if (!response.ok) {
+      throw new Error("Failed to upload file to storage");
+    }
+  }
+  /**
+   * Step 3: Confirm avatar upload
+   */
+  async confirmAvatarUpload(storagePath) {
+    const token = await this.getValidToken();
+    const response = await fetch(`${this.brandingUrl}/branding/confirm-avatar-upload`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        storage_path: storagePath
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to confirm upload" }));
+      if (response.status === 401 && this.onTokenInvalid) {
+        console.warn("[PreferencesService] Got 401 on confirmAvatarUpload, attempting refresh...");
+        const newToken = await this.onTokenInvalid();
+        if (newToken && isValidJwtFormat(newToken)) {
+          const retryResponse = await fetch(`${this.brandingUrl}/branding/confirm-avatar-upload`, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${newToken}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              storage_path: storagePath
+            })
+          });
+          if (retryResponse.ok) {
+            const data2 = await retryResponse.json();
+            if (data2.success) return data2.data;
+          }
+        }
+      }
+      throw new Error(error.error || error.message || "Failed to confirm avatar upload");
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new Error(data.error || "Failed to confirm avatar upload");
+    }
+    return data.data;
+  }
+  /**
+   * Get current user's avatar
+   */
+  async getMyAvatar() {
+    const token = await this.getValidToken();
+    const response = await fetch(`${this.brandingUrl}/branding/my-avatar`, {
+      headers: {
+        "Authorization": `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to fetch avatar" }));
+      if (response.status === 401 && this.onTokenInvalid) {
+        console.warn("[PreferencesService] Got 401 on getMyAvatar, attempting refresh...");
+        const newToken = await this.onTokenInvalid();
+        if (newToken && isValidJwtFormat(newToken)) {
+          const retryResponse = await fetch(`${this.brandingUrl}/branding/my-avatar`, {
+            headers: {
+              "Authorization": `Bearer ${newToken}`
+            }
+          });
+          if (retryResponse.ok) {
+            const data2 = await retryResponse.json();
+            if (data2.success) return data2.data;
+          }
+        }
+      }
+      throw new Error(error.error || error.message || "Failed to fetch avatar");
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new Error(data.error || "Failed to fetch avatar");
+    }
+    return data.data;
+  }
+  /**
+   * Get any user's avatar
+   */
+  async getUserAvatar(userId) {
+    const token = await this.getValidToken();
+    const response = await fetch(`${this.brandingUrl}/branding/users/${userId}/avatar`, {
+      headers: {
+        "Authorization": `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to fetch avatar" }));
+      if (response.status === 401 && this.onTokenInvalid) {
+        console.warn("[PreferencesService] Got 401 on getUserAvatar, attempting refresh...");
+        const newToken = await this.onTokenInvalid();
+        if (newToken && isValidJwtFormat(newToken)) {
+          const retryResponse = await fetch(`${this.brandingUrl}/branding/users/${userId}/avatar`, {
+            headers: {
+              "Authorization": `Bearer ${newToken}`
+            }
+          });
+          if (retryResponse.ok) {
+            const data2 = await retryResponse.json();
+            if (data2.success) return data2.data;
+          }
+        }
+      }
+      throw new Error(error.error || error.message || "Failed to fetch avatar");
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new Error(data.error || "Failed to fetch avatar");
+    }
+    return data.data;
+  }
+  /**
+   * Complete avatar upload flow (3-step process)
+   */
+  async uploadAvatar(file) {
+    const validTypes = ["image/png", "image/jpeg", "image/jpg", "image/webp"];
+    if (!validTypes.includes(file.type)) {
+      throw new Error("Please select a PNG, JPEG, or WebP image");
+    }
+    const maxSize = 5 * 1024 * 1024;
+    if (file.size > maxSize) {
+      throw new Error("Image must be less than 5MB");
+    }
+    const prepareData = await this.prepareAvatarUpload(file.name, file.type);
+    await this.uploadToGCS(prepareData.upload_url, file);
+    const confirmData = await this.confirmAvatarUpload(prepareData.storage_path);
+    return confirmData.avatar_url;
+  }
+};
+
+// src/avatar-cache.ts
+var AVATAR_CACHE_TTL = 24 * 60 * 60 * 1e3;
+var avatarCache = /* @__PURE__ */ new Map();
+function getCachedAvatar(userId) {
+  const cached = avatarCache.get(userId);
+  if (cached && Date.now() - cached.cachedAt < AVATAR_CACHE_TTL) {
+    return cached.url;
+  }
+  return null;
+}
+function setCachedAvatar(userId, url) {
+  avatarCache.set(userId, {
+    url,
+    cachedAt: Date.now()
+  });
+}
+function clearAvatarCache(userId) {
+  if (userId) {
+    avatarCache.delete(userId);
+  } else {
+    avatarCache.clear();
+  }
+}
+function hasCachedAvatar(userId) {
+  const cached = avatarCache.get(userId);
+  return cached !== void 0 && Date.now() - cached.cachedAt < AVATAR_CACHE_TTL;
+}
+
+// src/PreferencesContext.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var PreferencesContext = (0, import_react.createContext)(null);
+function PreferencesProvider({
+  children,
+  config,
+  initialPreferences
+}) {
+  const [preferences, setPreferences] = (0, import_react.useState)(initialPreferences || {});
+  const [loading, setLoading] = (0, import_react.useState)(!initialPreferences);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [avatarUrl, setAvatarUrl] = (0, import_react.useState)(null);
+  const [hasAvatar, setHasAvatar] = (0, import_react.useState)(false);
+  const [avatarLoading, setAvatarLoading] = (0, import_react.useState)(true);
+  const [avatarError, setAvatarError] = (0, import_react.useState)(null);
+  const refreshAttemptRef = (0, import_react.useRef)(0);
+  const configRef = (0, import_react.useRef)(config);
+  configRef.current = config;
+  const serviceRef = (0, import_react.useRef)(null);
+  if (!serviceRef.current) {
+    serviceRef.current = new PreferencesService(config);
+  }
+  (0, import_react.useEffect)(() => {
+    if (serviceRef.current) {
+      serviceRef.current.updateConfig({
+        getToken: config.getToken,
+        onTokenInvalid: config.onTokenInvalid
+      });
+    }
+  }, [config.getToken, config.onTokenInvalid]);
+  const refreshPreferences = (0, import_react.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const service = serviceRef.current;
+      if (!service) throw new Error("Service not initialized");
+      const response = await service.getPreferences();
+      setPreferences(response.data.preferences);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to load preferences";
+      setError(msg);
+      console.error("Preferences fetch error:", err);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const fetchAvatar = (0, import_react.useCallback)(async (skipCache = false) => {
+    const cacheKey = "me";
+    if (!skipCache) {
+      const cached = getCachedAvatar(cacheKey);
+      if (cached) {
+        setAvatarUrl(cached);
+        setHasAvatar(true);
+        setAvatarLoading(false);
+        return;
+      }
+    }
+    setAvatarLoading(true);
+    setAvatarError(null);
+    try {
+      const service = serviceRef.current;
+      if (!service) throw new Error("Service not initialized");
+      const data = await service.getMyAvatar();
+      if (data.has_avatar && data.avatar_url) {
+        setAvatarUrl(data.avatar_url);
+        setHasAvatar(true);
+        setCachedAvatar(cacheKey, data.avatar_url);
+        refreshAttemptRef.current = 0;
+      } else {
+        setAvatarUrl(null);
+        setHasAvatar(false);
+        clearAvatarCache(cacheKey);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to load avatar";
+      setAvatarError(msg);
+      setAvatarUrl(null);
+      setHasAvatar(false);
+      if (!msg.includes("404") && !msg.includes("not found")) {
+        console.error("Avatar fetch error:", err);
+      }
+    } finally {
+      setAvatarLoading(false);
+    }
+  }, []);
+  const refreshAvatar = (0, import_react.useCallback)(async () => {
+    await fetchAvatar(true);
+  }, [fetchAvatar]);
+  const handleImageError = (0, import_react.useCallback)(() => {
+    if (refreshAttemptRef.current >= 2) {
+      console.warn("Avatar refresh limit reached");
+      setAvatarUrl(null);
+      setHasAvatar(false);
+      return;
+    }
+    refreshAttemptRef.current += 1;
+    console.log("Avatar image failed, refreshing (attempt", refreshAttemptRef.current, ")");
+    clearAvatarCache("me");
+    fetchAvatar(true);
+  }, [fetchAvatar]);
+  const updatePreferences = (0, import_react.useCallback)(async (prefs) => {
+    try {
+      const service = serviceRef.current;
+      if (!service) throw new Error("Service not initialized");
+      const response = await service.updatePreferences(prefs);
+      setPreferences(response.data.preferences);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to update preferences";
+      setError(msg);
+      throw err;
+    }
+  }, []);
+  const uploadAvatar = (0, import_react.useCallback)(async (file) => {
+    const service = serviceRef.current;
+    if (!service) throw new Error("Service not initialized");
+    const url = await service.uploadAvatar(file);
+    clearAvatarCache("me");
+    await fetchAvatar(true);
+    return url;
+  }, [fetchAvatar]);
+  const clearAvatarCache2 = (0, import_react.useCallback)((userId) => {
+    clearAvatarCache(userId || "me");
+  }, []);
+  const applyTheme = (0, import_react.useCallback)((theme) => {
+    const root = document.documentElement;
+    if (theme === "dark") {
+      root.classList.add("dark");
+    } else if (theme === "light") {
+      root.classList.remove("dark");
+    } else {
+      const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+      if (prefersDark) {
+        root.classList.add("dark");
+      } else {
+        root.classList.remove("dark");
+      }
+    }
+  }, []);
+  const syncOnLogin = (0, import_react.useCallback)(async () => {
+    try {
+      const service = serviceRef.current;
+      if (!service) return;
+      const response = await service.getPreferences();
+      const prefs = response.data.preferences;
+      setPreferences(prefs);
+      applyTheme(prefs.theme);
+      await fetchAvatar(true);
+    } catch (err) {
+      console.error("Failed to sync preferences on login:", err);
+    }
+  }, [applyTheme, fetchAvatar]);
+  (0, import_react.useEffect)(() => {
+    const hasToken = !!configRef.current.getToken();
+    if (!hasToken) {
+      setLoading(false);
+      setAvatarLoading(false);
+      return;
+    }
+    if (!initialPreferences) {
+      refreshPreferences();
+    }
+    fetchAvatar();
+  }, []);
+  (0, import_react.useEffect)(() => {
+    const hasToken = !!configRef.current.getToken();
+    if (hasToken && preferences.theme) {
+      applyTheme(preferences.theme);
+    }
+  }, [preferences.theme, applyTheme]);
+  const avatar = {
+    avatarUrl,
+    hasAvatar,
+    loading: avatarLoading,
+    error: avatarError,
+    refresh: refreshAvatar,
+    handleImageError
+  };
+  const value = {
+    preferences,
+    loading,
+    error,
+    avatar,
+    updatePreferences,
+    refreshPreferences,
+    uploadAvatar,
+    clearAvatarCache: clearAvatarCache2,
+    syncOnLogin
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PreferencesContext.Provider, { value, children });
+}
+function usePreferences() {
+  const context = (0, import_react.useContext)(PreferencesContext);
+  if (!context) {
+    throw new Error("usePreferences must be used within a PreferencesProvider");
+  }
+  return context;
+}
+function usePreferencesSafe() {
+  return (0, import_react.useContext)(PreferencesContext);
+}
+function useAvatar() {
+  const { avatar } = usePreferences();
+  return avatar;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AVATAR_CACHE_TTL,
+  PreferencesProvider,
+  PreferencesService,
+  clearAvatarCache,
+  getCachedAvatar,
+  hasCachedAvatar,
+  setCachedAvatar,
+  useAvatar,
+  usePreferences,
+  usePreferencesSafe
+});
+//# sourceMappingURL=index.js.map