@oxy.so/services 11.2.0-oxy-one.2 → 11.2.0-oxy-one.4

package/src/ui/hooks/useFollow.ts

@@ -23,7 +23,10 @@ import { patchCachedUserRelationship } from './queries/userCacheRelationship';
 export const useFollow = (userId?: string | string[]) => {
   const queryClient = useQueryClient();
   const { oxyServices, canUsePrivateApi } = useOxy();
-  const userIds = useMemo(() => (Array.isArray(userId) ? userId : userId ? [userId] : []), [userId]);
+  const userIds = useMemo(
+    () => (Array.isArray(userId) ? userId : userId ? [userId] : []),
+    [userId],
+  );
   const isSingleUser = typeof userId === 'string';
   // Narrowed single-user id for use in closures (callbacks/queryFn) where TS
   // can't carry the `isSingleUser` boolean back to a `string` narrowing.
@@ -31,22 +34,40 @@ export const useFollow = (userId?: string | string[]) => {
 
   // Granular Zustand selectors — only re-render when THIS user's data changes
   const isFollowing = useFollowStore(
-    useCallback((s) => (isSingleUser && userId ? s.followingUsers[userId] ?? false : false), [isSingleUser, userId])
+    useCallback(
+      (s) => (isSingleUser && userId ? (s.followingUsers[userId] ?? false) : false),
+      [isSingleUser, userId],
+    ),
   );
   const isLoading = useFollowStore(
-    useCallback((s) => (isSingleUser && userId ? s.loadingUsers[userId] ?? false : false), [isSingleUser, userId])
+    useCallback(
+      (s) => (isSingleUser && userId ? (s.loadingUsers[userId] ?? false) : false),
+      [isSingleUser, userId],
+    ),
   );
   const error = useFollowStore(
-    useCallback((s) => (isSingleUser && userId ? s.errors[userId] ?? null : null), [isSingleUser, userId])
+    useCallback(
+      (s) => (isSingleUser && userId ? (s.errors[userId] ?? null) : null),
+      [isSingleUser, userId],
+    ),
   );
   const followerCount = useFollowStore(
-    useCallback((s) => (isSingleUser && userId ? s.followerCounts[userId] ?? null : null), [isSingleUser, userId])
+    useCallback(
+      (s) => (isSingleUser && userId ? (s.followerCounts[userId] ?? null) : null),
+      [isSingleUser, userId],
+    ),
   );
   const followingCount = useFollowStore(
-    useCallback((s) => (isSingleUser && userId ? s.followingCounts[userId] ?? null : null), [isSingleUser, userId])
+    useCallback(
+      (s) => (isSingleUser && userId ? (s.followingCounts[userId] ?? null) : null),
+      [isSingleUser, userId],
+    ),
   );
   const isLoadingCounts = useFollowStore(
-    useCallback((s) => (isSingleUser && userId ? s.loadingCounts[userId] ?? false : false), [isSingleUser, userId])
+    useCallback(
+      (s) => (isSingleUser && userId ? (s.loadingCounts[userId] ?? false) : false),
+      [isSingleUser, userId],
+    ),
   );
 
   // For multi-user mode, subscribe to a FLAT snapshot of the per-user fields.
@@ -66,11 +87,12 @@ export const useFollow = (userId?: string | string[]) => {
         flat[`${uid}:error`] = s.errors[uid] ?? null;
       }
       return flat;
-    })
+    }),
   );
 
   const followData = useMemo(() => {
-    const data: Record<string, { isFollowing: boolean; isLoading: boolean; error: string | null }> = {};
+    const data: Record<string, { isFollowing: boolean; isLoading: boolean; error: string | null }> =
+      {};
     if (isSingleUser) return data;
     for (const uid of userIds) {
       data[uid] = {
@@ -85,56 +107,80 @@ export const useFollow = (userId?: string | string[]) => {
   // Multi-user aggregate selectors
   const multiUserLoadingState = useFollowStore(
     useShallow((s) => {
-      if (isSingleUser) return { isAnyLoading: false, hasAnyError: false, allFollowing: true, allNotFollowing: true };
+      if (isSingleUser)
+        return {
+          isAnyLoading: false,
+          hasAnyError: false,
+          allFollowing: true,
+          allNotFollowing: true,
+        };
       return {
-        isAnyLoading: userIds.some(uid => s.loadingUsers[uid]),
-        hasAnyError: userIds.some(uid => !!s.errors[uid]),
-        allFollowing: userIds.every(uid => s.followingUsers[uid]),
-        allNotFollowing: userIds.every(uid => !s.followingUsers[uid]),
+        isAnyLoading: userIds.some((uid) => s.loadingUsers[uid]),
+        hasAnyError: userIds.some((uid) => !!s.errors[uid]),
+        allFollowing: userIds.every((uid) => s.followingUsers[uid]),
+        allNotFollowing: userIds.every((uid) => !s.followingUsers[uid]),
       };
-    })
+    }),
   );
 
   // Stable callbacks that depend on primitives, not object references.
   // Store actions are accessed via getState() to avoid subscribing to them.
   const toggleFollow = useCallback(async () => {
-    if (!isSingleUser || !userId) throw new Error('toggleFollow is only available for single user mode');
+    if (!isSingleUser || !userId)
+      throw new Error('toggleFollow is only available for single user mode');
     if (!canUsePrivateApi) throw new Error('Authentication is required to follow users');
     const currentlyFollowing = useFollowStore.getState().followingUsers[userId] ?? false;
-    const accepted = await useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
+    const accepted = await useFollowStore
+      .getState()
+      .toggleFollowUser(userId, oxyServices, currentlyFollowing);
     if (accepted) patchCachedUserRelationship(queryClient, userId, !currentlyFollowing);
   }, [isSingleUser, userId, canUsePrivateApi, oxyServices, queryClient]);
 
-  const setFollowStatus = useCallback((following: boolean) => {
-    if (!isSingleUser || !userId) throw new Error('setFollowStatus is only available for single user mode');
-    useFollowStore.getState().setFollowingStatus(userId, following);
-  }, [isSingleUser, userId]);
+  const setFollowStatus = useCallback(
+    (following: boolean) => {
+      if (!isSingleUser || !userId)
+        throw new Error('setFollowStatus is only available for single user mode');
+      useFollowStore.getState().setFollowingStatus(userId, following);
+    },
+    [isSingleUser, userId],
+  );
 
   const fetchStatus = useCallback(async () => {
-    if (!isSingleUser || !userId) throw new Error('fetchStatus is only available for single user mode');
+    if (!isSingleUser || !userId)
+      throw new Error('fetchStatus is only available for single user mode');
     if (!canUsePrivateApi) return;
     useFollowStore.getState().resolveFollowStatuses([userId], oxyServices);
   }, [isSingleUser, userId, canUsePrivateApi, oxyServices]);
 
   const clearError = useCallback(() => {
-    if (!isSingleUser || !userId) throw new Error('clearError is only available for single user mode');
+    if (!isSingleUser || !userId)
+      throw new Error('clearError is only available for single user mode');
     useFollowStore.getState().clearFollowError(userId);
   }, [isSingleUser, userId]);
 
   const fetchUserCounts = useCallback(async () => {
-    if (!isSingleUser || !userId) throw new Error('fetchUserCounts is only available for single user mode');
+    if (!isSingleUser || !userId)
+      throw new Error('fetchUserCounts is only available for single user mode');
     await useFollowStore.getState().fetchUserCounts(userId, oxyServices);
   }, [isSingleUser, userId, oxyServices]);
 
-  const setFollowerCount = useCallback((count: number) => {
-    if (!isSingleUser || !userId) throw new Error('setFollowerCount is only available for single user mode');
-    useFollowStore.getState().setFollowerCount(userId, count);
-  }, [isSingleUser, userId]);
+  const setFollowerCount = useCallback(
+    (count: number) => {
+      if (!isSingleUser || !userId)
+        throw new Error('setFollowerCount is only available for single user mode');
+      useFollowStore.getState().setFollowerCount(userId, count);
+    },
+    [isSingleUser, userId],
+  );
 
-  const setFollowingCount = useCallback((count: number) => {
-    if (!isSingleUser || !userId) throw new Error('setFollowingCount is only available for single user mode');
-    useFollowStore.getState().setFollowingCount(userId, count);
-  }, [isSingleUser, userId]);
+  const setFollowingCount = useCallback(
+    (count: number) => {
+      if (!isSingleUser || !userId)
+        throw new Error('setFollowingCount is only available for single user mode');
+      useFollowStore.getState().setFollowingCount(userId, count);
+    },
+    [isSingleUser, userId],
+  );
 
   // Auto-fetch counts for single-user mode via React Query instead of a manual
   // useEffect. The Zustand store remains the canonical home for count values
@@ -161,21 +207,29 @@ export const useFollow = (userId?: string | string[]) => {
   });
 
   // Multi-user callbacks
-  const toggleFollowForUser = useCallback(async (targetUserId: string) => {
-    if (!canUsePrivateApi) throw new Error('Authentication is required to follow users');
-    const currentState = useFollowStore.getState().followingUsers[targetUserId] ?? false;
-    const accepted = await useFollowStore.getState().toggleFollowUser(targetUserId, oxyServices, currentState);
-    if (accepted) patchCachedUserRelationship(queryClient, targetUserId, !currentState);
-  }, [canUsePrivateApi, oxyServices, queryClient]);
+  const toggleFollowForUser = useCallback(
+    async (targetUserId: string) => {
+      if (!canUsePrivateApi) throw new Error('Authentication is required to follow users');
+      const currentState = useFollowStore.getState().followingUsers[targetUserId] ?? false;
+      const accepted = await useFollowStore
+        .getState()
+        .toggleFollowUser(targetUserId, oxyServices, currentState);
+      if (accepted) patchCachedUserRelationship(queryClient, targetUserId, !currentState);
+    },
+    [canUsePrivateApi, oxyServices, queryClient],
+  );
 
   const setFollowStatusForUser = useCallback((targetUserId: string, following: boolean) => {
     useFollowStore.getState().setFollowingStatus(targetUserId, following);
   }, []);
 
-  const fetchStatusForUser = useCallback(async (targetUserId: string) => {
-    if (!canUsePrivateApi) return;
-    useFollowStore.getState().resolveFollowStatuses([targetUserId], oxyServices);
-  }, [canUsePrivateApi, oxyServices]);
+  const fetchStatusForUser = useCallback(
+    async (targetUserId: string) => {
+      if (!canUsePrivateApi) return;
+      useFollowStore.getState().resolveFollowStatuses([targetUserId], oxyServices);
+    },
+    [canUsePrivateApi, oxyServices],
+  );
 
   // Resolve EVERY member's status in ONE micro-batched bulk call (never N
   // single requests). Ids already known/seeded are skipped by the resolver.
@@ -200,10 +254,19 @@ export const useFollow = (userId?: string | string[]) => {
     useFollowStore.getState().clearFollowError(targetUserId);
   }, []);
 
-  const updateCountsFromFollowAction = useCallback((targetUserId: string, action: 'follow' | 'unfollow', counts: { followers: number; following: number }) => {
-    const currentUserId = oxyServices.session.userId || undefined;
-    useFollowStore.getState().updateCountsFromFollowAction(targetUserId, action, counts, currentUserId);
-  }, [oxyServices]);
+  const updateCountsFromFollowAction = useCallback(
+    (
+      targetUserId: string,
+      action: 'follow' | 'unfollow',
+      counts: { followers: number; following: number },
+    ) => {
+      const currentUserId = oxyServices.session.userId || undefined;
+      useFollowStore
+        .getState()
+        .updateCountsFromFollowAction(targetUserId, action, counts, currentUserId);
+    },
+    [oxyServices],
+  );
 
   if (isSingleUser && userId) {
     return {
@@ -247,7 +310,11 @@ export const useFollow = (userId?: string | string[]) => {
  * - Only subscribes to the specific user's follow and loading state
  * - Returns only what FollowButton needs (no counts, no multi-user)
  */
-export const useFollowForButton = (userId: string, oxyServices: OxyServices, initiallyFollowing?: boolean) => {
+export const useFollowForButton = (
+  userId: string,
+  oxyServices: OxyServices,
+  initiallyFollowing?: boolean,
+) => {
   // Seed the store synchronously on the FIRST render (before paint) when the
   // caller provided a definite `initiallyFollowing` and the store has no entry
   // yet. This makes the first paint show the correct label (no post-mount
@@ -266,19 +333,15 @@ export const useFollowForButton = (userId: string, oxyServices: OxyServices, ini
   });
 
   const isFollowing = useFollowStore(
-    useCallback((s) => s.followingUsers[userId] ?? false, [userId])
+    useCallback((s) => s.followingUsers[userId] ?? false, [userId]),
   );
   // Tri-state: a present key (seeded or fetched) is a DEFINITE status; a missing
   // key is UNKNOWN. The button renders a neutral/disabled state while unknown.
   const isKnown = useFollowStore(
-    useCallback((s) => Object.prototype.hasOwnProperty.call(s.followingUsers, userId), [userId])
-  );
-  const isLoading = useFollowStore(
-    useCallback((s) => s.loadingUsers[userId] ?? false, [userId])
-  );
-  const error = useFollowStore(
-    useCallback((s) => s.errors[userId] ?? null, [userId])
+    useCallback((s) => Object.prototype.hasOwnProperty.call(s.followingUsers, userId), [userId]),
   );
+  const isLoading = useFollowStore(useCallback((s) => s.loadingUsers[userId] ?? false, [userId]));
+  const error = useFollowStore(useCallback((s) => s.errors[userId] ?? null, [userId]));
 
   const toggleFollow = useCallback(async (): Promise<boolean> => {
     const currentlyFollowing = useFollowStore.getState().followingUsers[userId] ?? false;
@@ -293,9 +356,12 @@ export const useFollowForButton = (userId: string, oxyServices: OxyServices, ini
     useFollowStore.getState().resolveFollowStatuses([userId], oxyServices);
   }, [userId, oxyServices]);
 
-  const setFollowStatus = useCallback((following: boolean) => {
-    useFollowStore.getState().setFollowingStatus(userId, following);
-  }, [userId]);
+  const setFollowStatus = useCallback(
+    (following: boolean) => {
+      useFollowStore.getState().setFollowingStatus(userId, following);
+    },
+    [userId],
+  );
 
   const clearError = useCallback(() => {
     useFollowStore.getState().clearFollowError(userId);
@@ -332,26 +398,32 @@ export const useFollowerCounts = (userId: string) => {
   const { oxyServices } = useOxy();
 
   const followerCount = useFollowStore(
-    useCallback((s) => s.followerCounts[userId] ?? null, [userId])
+    useCallback((s) => s.followerCounts[userId] ?? null, [userId]),
   );
   const followingCount = useFollowStore(
-    useCallback((s) => s.followingCounts[userId] ?? null, [userId])
+    useCallback((s) => s.followingCounts[userId] ?? null, [userId]),
   );
   const isLoadingCounts = useFollowStore(
-    useCallback((s) => s.loadingCounts[userId] ?? false, [userId])
+    useCallback((s) => s.loadingCounts[userId] ?? false, [userId]),
   );
 
   const fetchUserCounts = useCallback(async () => {
     await useFollowStore.getState().fetchUserCounts(userId, oxyServices);
   }, [userId, oxyServices]);
 
-  const setFollowerCount = useCallback((count: number) => {
-    useFollowStore.getState().setFollowerCount(userId, count);
-  }, [userId]);
+  const setFollowerCount = useCallback(
+    (count: number) => {
+      useFollowStore.getState().setFollowerCount(userId, count);
+    },
+    [userId],
+  );
 
-  const setFollowingCount = useCallback((count: number) => {
-    useFollowStore.getState().setFollowingCount(userId, count);
-  }, [userId]);
+  const setFollowingCount = useCallback(
+    (count: number) => {
+      useFollowStore.getState().setFollowingCount(userId, count);
+    },
+    [userId],
+  );
 
   return {
     followerCount,

package/src/ui/hooks/useFollowTarget.ts

@@ -56,18 +56,18 @@ export interface UseFollowTargetResult {
 
 export function useFollowTarget(
   targetId: string | undefined,
-  options?: { initialStatus?: FollowStatus }
+  options?: { initialStatus?: FollowStatus },
 ): UseFollowTargetResult {
   const { oxyServices, canUsePrivateApi } = useOxy();
 
   const status = useFollowTargetStore(
-    useCallback((s) => (targetId ? s.statuses[targetId] : undefined), [targetId])
+    useCallback((s) => (targetId ? s.statuses[targetId] : undefined), [targetId]),
   );
   const isPending = useFollowTargetStore(
-    useCallback((s) => (targetId ? (s.pending[targetId] ?? false) : false), [targetId])
+    useCallback((s) => (targetId ? (s.pending[targetId] ?? false) : false), [targetId]),
   );
   const error = useFollowTargetStore(
-    useCallback((s) => (targetId ? s.errors[targetId] : undefined), [targetId])
+    useCallback((s) => (targetId ? s.errors[targetId] : undefined), [targetId]),
   );
 
   const initialStatus = options?.initialStatus;
@@ -119,7 +119,7 @@ export function useFollowTarget(
     async (
       optimistic: FollowStatus,
       run: () => Promise<FollowStatus | undefined>,
-      failureMessage: string
+      failureMessage: string,
     ): Promise<boolean> => {
       if (!targetId) return false;
       const store = useFollowTargetStore.getState();
@@ -142,7 +142,7 @@ export function useFollowTarget(
         useFollowTargetStore.getState().setPending(targetId, false);
       }
     },
-    [targetId]
+    [targetId],
   );
 
   const current = status ?? UNKNOWN_FOLLOW_STATUS;
@@ -161,10 +161,10 @@ export function useFollowTarget(
         // than reconstructing one: `effectiveState`'s derivation lives there,
         // and a client recomputing it is a second implementation of one rule.
         async () => (await oxyServices.follows.followTarget(targetId, opts)).status,
-        'Could not follow'
+        'Could not follow',
       );
     },
-    [targetId, current, mutate, oxyServices]
+    [targetId, current, mutate, oxyServices],
   );
 
   const unfollow = useCallback(async () => {
@@ -176,7 +176,7 @@ export function useFollowTarget(
         await oxyServices.follows.unfollowTarget(relationshipId);
         return { ...UNKNOWN_FOLLOW_STATUS };
       },
-      'Could not unfollow'
+      'Could not unfollow',
     );
   }, [targetId, current.relationshipId, mutate, oxyServices]);
 
@@ -190,7 +190,7 @@ export function useFollowTarget(
         await oxyServices.follows.setApplicationMode(relationshipId, 'disabled');
         return optimistic;
       },
-      'Could not change this app’s setting for this follow'
+      'Could not change this app’s setting for this follow',
     );
   }, [targetId, current, mutate, oxyServices]);
 
@@ -204,7 +204,7 @@ export function useFollowTarget(
         await oxyServices.follows.restoreInheritance(relationshipId);
         return optimistic;
       },
-      'Could not change this app’s setting for this follow'
+      'Could not change this app’s setting for this follow',
     );
   }, [targetId, current, mutate, oxyServices]);
 

package/src/ui/hooks/useI18n.ts

@@ -26,10 +26,15 @@ export function useI18n() {
   const oxy = useOptionalOxy();
   const currentLanguage = oxy?.currentLanguage ?? FALLBACK_LOCALE;
   // Core's non-English dictionaries load on demand; re-translate when one lands.
-  const localesVersion = useSyncExternalStore(subscribeLocales, getLocalesVersion, getLocalesVersion);
+  const localesVersion = useSyncExternalStore(
+    subscribeLocales,
+    getLocalesVersion,
+    getLocalesVersion,
+  );
   // biome-ignore lint/correctness/useExhaustiveDependencies: `localesVersion` is the re-translate signal — a new `t` makes consumers re-render once a dictionary lands.
   const t = useMemo(() => {
-    return (key: string, vars?: Record<string, string | number>) => translate(currentLanguage, key, vars);
+    return (key: string, vars?: Record<string, string | number>) =>
+      translate(currentLanguage, key, vars);
   }, [currentLanguage, localesVersion]);
   return { t, locale: currentLanguage };
 }