@oxyhq/services 19.2.0 → 20.0.1

package/src/ui/hooks/useLanguageManagement.ts

@@ -1,11 +1,15 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import type { ApiError, User } from '@oxyhq/core';
+import type { ApiError, User, SupportedLanguage } from '@oxyhq/core';
 import {
+  FALLBACK_LOCALE,
+  SUPPORTED_LANGUAGES,
+  getBaseLanguage,
   getLanguageMetadata,
   getLanguageName,
   getNativeLanguageName,
-  normalizeLanguageCode,
-  type LanguageMetadata,
+  getPrimaryLanguage,
+  getUserLanguages,
+  normalizeLocale,
 } from '@oxyhq/core';
 import type { StorageInterface } from '../utils/storageHelpers';
 import { extractErrorMessage } from '../utils/errorHandlers';
@@ -13,34 +17,143 @@ import { extractErrorMessage } from '../utils/errorHandlers';
 export interface UseLanguageManagementOptions {
   storage: StorageInterface | null;
   languageKey: string;
+  /**
+   * The active account, when signed in. When present, the account's primary
+   * locale (`languages[0]`) is authoritative for the app's UI locale; when
+   * `null` the device locale (or a locally-chosen guest override) is used.
+   */
+  user: User | null;
   onError?: (error: ApiError) => void;
   logger?: (message: string, error?: unknown) => void;
 }
 
 export interface UseLanguageManagementResult {
+  /**
+   * The active UI locale (a canonical `language-REGION` tag). Derived, never
+   * stored: the account's primary locale when signed in, otherwise the
+   * locally-chosen guest override, otherwise the device locale.
+   */
   currentLanguage: string;
-  metadata: LanguageMetadata | null;
+  /**
+   * The ordered account locales (primary first) when signed in, or the single
+   * guest override when signed out. Empty only before the guest override loads
+   * and no device locale resolves.
+   */
+  languages: string[];
+  metadata: SupportedLanguage | null;
   languageName: string;
   nativeLanguageName: string;
-  setLanguage: (languageId: string) => Promise<void>;
-  applyLanguagePreference: (user: User | null) => Promise<void>;
+  /**
+   * Persist a single locally-owned locale (guest / device override) and mark it
+   * primary. For signed-in accounts, locale changes are written to the account
+   * (`updateProfile({ languages })`) instead — the derived `currentLanguage`
+   * then follows the refreshed `user`.
+   */
+  setLanguage: (locale: string) => Promise<void>;
   hydrateLanguage: () => Promise<void>;
 }
 
-const DEFAULT_LANGUAGE = 'en-US';
+/**
+ * Append `locale` to an ordered locale list if not already present. Canonical
+ * order is preserved; the new locale lands last (non-primary).
+ */
+export function addLocale(languages: readonly string[], locale: string): string[] {
+  const canonical = normalizeLocale(locale);
+  if (!canonical) return [...languages];
+  if (languages.includes(canonical)) return [...languages];
+  return [...languages, canonical];
+}
+
+/**
+ * Remove `locale` from an ordered locale list. The list's new first element
+ * becomes the primary locale.
+ */
+export function removeLocale(languages: readonly string[], locale: string): string[] {
+  const canonical = normalizeLocale(locale);
+  if (!canonical) return [...languages];
+  return languages.filter((entry) => entry !== canonical);
+}
+
+/**
+ * Move `locale` to the front of an ordered locale list, making it primary.
+ * Adds it if it was not already present.
+ */
+export function setPrimaryLocale(languages: readonly string[], locale: string): string[] {
+  const canonical = normalizeLocale(locale);
+  if (!canonical) return [...languages];
+  return [canonical, ...languages.filter((entry) => entry !== canonical)];
+}
+
+/**
+ * Resolve the device/browser locale, mapped to a supported catalog locale.
+ *
+ * Reads the platform's ordered locale preferences (`navigator.languages` /
+ * `navigator.language` on web, `Intl.DateTimeFormat().resolvedOptions().locale`
+ * on Hermes) and returns the first that resolves to a supported locale —
+ * either exactly or by base-language match (`fr-BE` → `fr-FR`). Falls back to
+ * {@link FALLBACK_LOCALE} when nothing resolves. Pure and side-effect free.
+ */
+function resolveDeviceLocale(): string {
+  const candidates: string[] = [];
+
+  if (typeof navigator !== 'undefined') {
+    const nav = navigator as Navigator & { languages?: readonly string[] };
+    if (Array.isArray(nav.languages)) {
+      candidates.push(...nav.languages);
+    }
+    if (typeof nav.language === 'string') {
+      candidates.push(nav.language);
+    }
+  }
+
+  try {
+    const intlLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (intlLocale) {
+      candidates.push(intlLocale);
+    }
+  } catch {
+    // Intl is unavailable or incomplete on this runtime — fall through to the
+    // navigator-provided candidates (or the fallback locale below).
+  }
+
+  for (const candidate of candidates) {
+    const exact = normalizeLocale(candidate);
+    if (exact) return exact;
+    const base = getBaseLanguage(candidate);
+    const byBase = SUPPORTED_LANGUAGES.find((entry) => entry.language === base);
+    if (byBase) return byBase.code;
+  }
+
+  return FALLBACK_LOCALE;
+}
 
 /**
- * Manage UI language state, persistence, and metadata derivation.
+ * Resolve and manage the app's active UI locale.
+ *
+ * The active locale is DERIVED, not stored:
+ *  - Signed in  → the account's primary locale (`getPrimaryLanguage(user)`),
+ *    falling back to {@link FALLBACK_LOCALE}. This is what makes every Oxy app
+ *    follow the account's language automatically.
+ *  - Signed out → a locally-chosen guest override if one exists, otherwise the
+ *    device locale.
  *
- * @param options - Configuration for storage access and error reporting
+ * The only external system this hook synchronizes with is local storage (the
+ * guest override), which is loaded once on mount.
  */
 export const useLanguageManagement = ({
   storage,
   languageKey,
+  user,
   onError,
   logger,
 }: UseLanguageManagementOptions): UseLanguageManagementResult => {
-  const [currentLanguage, setCurrentLanguage] = useState<string>(DEFAULT_LANGUAGE);
+  // The device locale is fixed for the lifetime of the runtime.
+  const deviceLanguage = useMemo(resolveDeviceLocale, []);
+
+  // The locally-owned guest override (a single locale). `null` until loaded
+  // from storage or explicitly set; the derived locale falls back to the device
+  // locale while it is `null`.
+  const [guestLanguage, setGuestLanguage] = useState<string | null>(null);
 
   const loadLanguageFromStorage = useCallback(async (): Promise<void> => {
     if (!storage) {
@@ -49,9 +162,9 @@ export const useLanguageManagement = ({
 
     try {
       const savedLanguageRaw = await storage.getItem(languageKey);
-      const normalized = normalizeLanguageCode(savedLanguageRaw) || savedLanguageRaw;
+      const normalized = savedLanguageRaw ? normalizeLocale(savedLanguageRaw) : undefined;
       if (normalized) {
-        setCurrentLanguage(normalized);
+        setGuestLanguage(normalized);
       }
     } catch (error) {
       const message = extractErrorMessage(error, 'Failed to load language preference');
@@ -77,16 +190,19 @@ export const useLanguageManagement = ({
   }, [loadLanguageFromStorage, logger]);
 
   const setLanguage = useCallback(
-    async (languageId: string): Promise<void> => {
+    async (locale: string): Promise<void> => {
       if (!storage) {
         throw new Error('Storage not initialized');
       }
 
-      const normalized = normalizeLanguageCode(languageId) || languageId;
+      const normalized = normalizeLocale(locale);
+      if (!normalized) {
+        throw new Error(`Unsupported locale: ${locale}`);
+      }
 
       try {
         await storage.setItem(languageKey, normalized);
-        setCurrentLanguage(normalized);
+        setGuestLanguage(normalized);
       } catch (error) {
         const message = extractErrorMessage(error, 'Failed to save language preference');
         onError?.({
@@ -105,31 +221,19 @@ export const useLanguageManagement = ({
     [languageKey, logger, onError, storage],
   );
 
-  const applyLanguagePreference = useCallback(
-    async (user: User | null): Promise<void> => {
-      if (!storage || !user) {
-        return;
-      }
-
-      const userLanguage = (user as Record<string, unknown>)?.language as string | undefined;
-      if (!userLanguage) {
-        return;
-      }
+  const languages = useMemo<string[]>(() => {
+    if (user) {
+      return getUserLanguages(user);
+    }
+    return guestLanguage ? [guestLanguage] : [];
+  }, [user, guestLanguage]);
 
-      try {
-        const normalized = normalizeLanguageCode(userLanguage) || userLanguage;
-        await storage.setItem(languageKey, normalized);
-        setCurrentLanguage(normalized);
-      } catch (error) {
-        if (logger) {
-          logger('Failed to apply server language preference', error);
-        } else if (__DEV__) {
-          console.warn('Failed to apply server language preference', error);
-        }
-      }
-    },
-    [languageKey, logger, storage],
-  );
+  const currentLanguage = useMemo<string>(() => {
+    if (user) {
+      return getPrimaryLanguage(user) ?? FALLBACK_LOCALE;
+    }
+    return guestLanguage ?? deviceLanguage;
+  }, [user, guestLanguage, deviceLanguage]);
 
   const metadata = useMemo(() => getLanguageMetadata(currentLanguage), [currentLanguage]);
   const languageName = useMemo(() => getLanguageName(currentLanguage), [currentLanguage]);
@@ -140,13 +244,11 @@ export const useLanguageManagement = ({
 
   return {
     currentLanguage,
+    languages,
     metadata,
     languageName,
     nativeLanguageName,
     setLanguage,
-    applyLanguagePreference,
     hydrateLanguage: loadLanguageFromStorage,
   };
 };
-
-

package/src/ui/hooks/useSessionManagement.ts

@@ -17,7 +17,6 @@ export interface UseSessionManagementOptions {
   storageKeyPrefix?: string;
   loginSuccess: (user: User) => void;
   logoutStore: () => void;
-  applyLanguagePreference: (user: User) => Promise<void>;
   onAuthStateChange?: (user: User | null) => void;
   onError?: (error: ApiError) => void;
   setAuthError?: (message: string | null) => void;
@@ -54,7 +53,6 @@ export const useSessionManagement = ({
   storageKeyPrefix,
   loginSuccess,
   logoutStore,
-  applyLanguagePreference,
   onAuthStateChange,
   onError,
   setAuthError,
@@ -207,10 +205,9 @@ export const useSessionManagement = ({
       setActiveSessionId(sessionId);
       loginSuccess(user);
       await saveActiveSessionId(sessionId);
-      await applyLanguagePreference(user);
       onAuthStateChange?.(user);
     },
-    [applyLanguagePreference, loginSuccess, onAuthStateChange, saveActiveSessionId, setTokenReady],
+    [loginSuccess, onAuthStateChange, saveActiveSessionId, setTokenReady],
   );
 
   const removalTimerIdsRef = useRef<Set<ReturnType<typeof setTimeout>>>(new Set());

package/src/ui/screens/FeedbackScreen.tsx

@@ -12,7 +12,7 @@ import type { BaseScreenProps } from '../types/navigation';
 import { normalizeTheme } from '@oxyhq/core';
 import { packageInfo } from '@oxyhq/core';
 import { useTheme } from '@oxyhq/bloom/theme';
-import { Ionicons, MaterialCommunityIcons } from '@expo/vector-icons';
+import { Ionicons, type MaterialCommunityIcons } from '@expo/vector-icons';
 import { toast } from '@oxyhq/bloom';
 import { H2, Text } from '@oxyhq/bloom/typography';
 import { Button } from '@oxyhq/bloom/button';