Merge upstream develop

Author: github-actions[bot]

.vscode/settings.json

@@ -8,7 +8,7 @@
   "editor.formatOnSave": true,
   "editor.codeActionsOnSave": {
     "source.fixAll": "explicit",
-    "source.organizeImports": "explicit",
-    "source.sortMembers": "explicit"
+    "source.organizeImports": "never",
+    "source.sortMembers": "never"
   }
 }

apps/polycentric/package.json

@@ -27,6 +27,8 @@
     "@react-navigation/elements": "^2.8.0",
     "@react-navigation/native": "^7.1.32",
     "@rn-primitives/dropdown-menu": "^1.4.0",
+    "@rn-primitives/hover-card": "^1.4.0",
+    "@rn-primitives/popover": "^1.4.0",
     "@rn-primitives/portal": "^1.4.0",
     "@shopify/flash-list": "^2.3.1",
     "@types/react-native-web": "^0.19.2",

apps/polycentric/src/common/components/DropdownMenu.tsx

@@ -62,7 +62,7 @@ function DropdownMenuItem({
   );
 }
 
-function DropdownMenu({ children }: { children: ReactNode }) {
+function DropdownMenu({ children }: DropdownMenuPrimitive.RootProps) {
   return <DropdownMenuPrimitive.Root>{children}</DropdownMenuPrimitive.Root>;
 }
 DropdownMenu.Trigger = DropdownMenuPrimitive.Trigger;

apps/polycentric/src/common/components/HoverCard.tsx

@@ -0,0 +1,45 @@
+import * as HoverCardPrimitive from '@rn-primitives/hover-card';
+import { StyleSheet, View } from 'react-native';
+import Animated, { BounceIn, FadeOut } from 'react-native-reanimated';
+import { isWeb } from '../util/platform';
+
+export function HoverCardContent({
+  children,
+  ...props
+}: HoverCardPrimitive.ContentProps) {
+  const content = (
+    <HoverCardPrimitive.Content {...props}>
+      <Animated.View
+        entering={BounceIn.duration(450)}
+        exiting={FadeOut.duration(100)}
+      >
+        {children}
+      </Animated.View>
+    </HoverCardPrimitive.Content>
+  );
+
+  return (
+    <HoverCardPrimitive.Portal>
+      {isWeb ? (
+        content
+      ) : (
+        <HoverCardPrimitive.Overlay style={StyleSheet.absoluteFill}>
+          {content}
+        </HoverCardPrimitive.Overlay>
+      )}
+    </HoverCardPrimitive.Portal>
+  );
+}
+
+function HoverCard({ children, ...props }: HoverCardPrimitive.RootProps) {
+  return (
+    <HoverCardPrimitive.Root {...props}>{children}</HoverCardPrimitive.Root>
+  );
+}
+
+HoverCard.Trigger = HoverCardPrimitive.Trigger;
+HoverCard.Content = HoverCardContent;
+
+export type { TriggerRef } from '@rn-primitives/hover-card';
+
+export default HoverCard;

apps/polycentric/src/common/components/Popover.tsx

@@ -0,0 +1,19 @@
+import * as PopoverPrimitive from '@rn-primitives/popover';
+import { ReactNode } from 'react';
+
+export function PopoverContent({ children }: { children: ReactNode }) {
+  return (
+    <PopoverPrimitive.Portal>
+      <PopoverPrimitive.Content>{children}</PopoverPrimitive.Content>
+    </PopoverPrimitive.Portal>
+  );
+}
+
+function Popover({ children }: { children: ReactNode }) {
+  return <PopoverPrimitive.Root>{children}</PopoverPrimitive.Root>;
+}
+
+Popover.Trigger = PopoverPrimitive.Trigger;
+Popover.Content = PopoverContent;
+
+export default Popover;

apps/polycentric/src/common/lib/polycentric-hooks/PolycentricProvider.tsx

@@ -1,5 +1,6 @@
 import { DEFAULT_IDENTITY_NAME } from '@/src/common/constants';
 import useFollows from '@/src/features/follow/hooks/useFollows';
+import useReposts from '@/src/features/post/hooks/useReposts';
 import {
   PolycentricClient,
   createPolycentricClient,
@@ -23,6 +24,7 @@ import {
   useStore,
   type PolycentricStoreApi,
 } from './store';
+import useReactions from '@/src/features/reaction/useReactions';
 
 export interface PolycentricContextValue {
   client: PolycentricClient;
@@ -169,13 +171,21 @@ export function PolycentricProvider({
           // Read follows from the local store immediately — don't gate
           // the UI on the network sync. The sync runs in parallel and
           // re-refreshes once new events have been pulled in.
-          await useFollows.getState().refresh(c);
-          void c
-            .sync()
-            .then(() => useFollows.getState().refresh(c))
-            .catch((syncError) => {
-              console.warn('Initial Polycentric sync failed:', syncError);
-            });
+          useFollows.getState().refresh(c);
+          useReposts.getState().refresh(c);
+          (useReactions.getState().refresh(c),
+            void c
+              .sync()
+              .then(() =>
+                Promise.all([
+                  useFollows.getState().refresh(c),
+                  useReposts.getState().refresh(c),
+                  useReactions.getState().refresh(c),
+                ]),
+              )
+              .catch((syncError) => {
+                console.warn('Initial Polycentric sync failed:', syncError);
+              }));
         }
 
         setIsLoading(false);
@@ -184,14 +194,17 @@ export function PolycentricProvider({
           if (cancelled) return;
           setCurrentIdentity(await resolveIdentity(c));
           await s.getState().refreshIdentities();
-          await useFollows.getState().refresh(c);
+          // TODO: Cleanup this up
+          useFollows.getState().refresh(c);
+          useReposts.getState().refresh(c);
+          useReactions.getState().refresh(c);
         });
 
-        // Identity onboarding (create / claim) publishes an Identity event,
-        // which flows through onContentCreated. Re-resolve so the gate
-        // flips from onboarding → app once the user completes signup.
-        c.events.onContentCreated(async () => {
+        // Identity onboarding (create / claim) publishes an Identity event.
+        // Set to current identity
+        c.events.onContentCreated(async ({ content }) => {
           if (cancelled) return;
+          if (content?.contentBody.oneofKind !== 'identity') return;
           setCurrentIdentity(await resolveIdentity(c));
         });
       } catch (err) {
@@ -223,7 +236,6 @@ export function PolycentricProvider({
   }, [client]);
 
   const value = useMemo<PolycentricContextValue | null>(() => {
-    if (!client || !store) return null;
     return {
       client,
       store,

apps/polycentric/src/common/lib/polycentric-hooks/helpers.ts

@@ -57,23 +57,76 @@ export function getKeyFingerprint(key?: v2.PublicKey): string | undefined {
   return bytesToHex(key.key).substring(0, 16);
 }
 
+/** Every `Content.contentBody` variant that carries a payload — i.e. each
+ *  `oneofKind` except the empty `undefined` case. */
+export type ContentKind = Exclude<
+  v2.Content['contentBody']['oneofKind'],
+  undefined
+>;
+
+/** The payload a given content kind carries. `ContentBodyOf<'follow'>` is
+ *  `v2.Follow`, `ContentBodyOf<'post'>` is `v2.Post`, and so on. Inferred
+ *  via a mapped type rather than `[K]` indexing, which TS rejects for a
+ *  generic key over a discriminated union. */
+export type ContentBodyOf<K extends ContentKind> =
+  Extract<v2.Content['contentBody'], { oneofKind: K }> extends {
+    [P in K]: infer T;
+  }
+    ? T
+    : never;
+
+/** A bundle decoded against a specific content kind: the parsed event, the
+ *  content narrowed to that kind's payload type, and the bundle's raw
+ *  signed event (validated to be present). */
+export type DecodedBundle<K extends ContentKind> = {
+  event: v2.Event;
+  content: ContentBodyOf<K>;
+  signedEvent: v2.SignedEvent;
+};
+
+/**
+ * Decode an `EventBundle` as a specific content kind, replacing the
+ * per-kind `decodeReaction` / `decodeFollow` / `decodePost` helpers.
+ *
+ * Returns `null` when the bundle is malformed or carries a different kind.
+ * The `kind` argument both filters and types the result: the returned
+ * `content` is narrowed to that kind's payload, so `decodeBundle(b, 'follow')`
+ * yields a `v2.Follow` and `decodeBundle(b, 'post')` a `v2.Post`.
+ */
+export function decodeBundle<K extends ContentKind>(
+  bundle: v2.EventBundle,
+  kind: K,
+): DecodedBundle<K> | null {
+  if (!bundle.signedEvent || !bundle.serializedContent?.contentBytes) {
+    return null;
+  }
+  let parsed: v2.Content;
+  let event: v2.Event;
+  try {
+    parsed = v2.Content.fromBinary(bundle.serializedContent.contentBytes);
+    event = v2.Event.fromBinary(bundle.signedEvent.eventBytes);
+  } catch {
+    return null;
+  }
+  if (parsed.contentBody.oneofKind !== kind) return null;
+  // Safe: the oneofKind check above guarantees `kind` is the live payload
+  // key. TS can't index a discriminated union by a generic key, so cast.
+  const content = (
+    parsed.contentBody as unknown as Record<K, ContentBodyOf<K>>
+  )[kind];
+  return { event, content, signedEvent: bundle.signedEvent };
+}
+
 /** Decode a v2 EventBundle into PostData, or null if not a post. */
 export function decodePostBundle(bundle: v2.EventBundle): PostData | null {
+  const decoded = decodeBundle(bundle, 'post');
+  if (!decoded) return null;
   try {
-    if (!bundle.signedEvent) return null;
-    const event = v2.Event.fromBinary(bundle.signedEvent.eventBytes);
+    const { event, content: post, signedEvent } = decoded;
     const key = event.key;
     if (!key?.signedBy?.key) return null;
 
-    if (!bundle.serializedContent?.contentBytes) return null;
-    const content = v2.Content.fromBinary(
-      bundle.serializedContent.contentBytes,
-    );
-    if (content.contentBody.oneofKind !== 'post') return null;
-
     const id = bytesToHex(v2.EventKey.toBinary(key));
-
-    const post = content.contentBody.post;
     const reply = post.reply
       ? {
           rootId: post.reply.root
@@ -99,8 +152,8 @@ export function decodePostBundle(bundle: v2.EventBundle): PostData | null {
       reply,
       quoteId,
       signedEvent: v2.SignedEvent.create({
-        eventBytes: bundle.signedEvent.eventBytes,
-        signature: bundle.signedEvent.signature,
+        eventBytes: signedEvent.eventBytes,
+        signature: signedEvent.signature,
       }),
     };
   } catch (e) {
@@ -116,17 +169,12 @@ function decodeRepostBundle(bundle: v2.EventBundle): {
   targetId: string;
   repostId: string;
 } | null {
+  const decoded = decodeBundle(bundle, 'repost');
+  if (!decoded) return null;
   try {
-    if (!bundle.signedEvent) return null;
-    const event = v2.Event.fromBinary(bundle.signedEvent.eventBytes);
-    const key = event.key;
+    const key = decoded.event.key;
     if (!key?.signedBy?.key) return null;
-    if (!bundle.serializedContent?.contentBytes) return null;
-    const content = v2.Content.fromBinary(
-      bundle.serializedContent.contentBytes,
-    );
-    if (content.contentBody.oneofKind !== 'repost') return null;
-    const target = content.contentBody.repost.post;
+    const target = decoded.content.post;
     if (!target) return null;
     return {
       repostedBy: key.identity,

apps/polycentric/src/common/lib/polycentric-hooks/index.ts

@@ -26,6 +26,7 @@ export {
 
 // Helpers
 export {
+  decodeBundle,
   decodePostBundle as decodeV2PostBundle,
   decodeFeedItems,
   pubkeyStr,
@@ -48,4 +49,9 @@ export {
   toBase64,
   fromBase64,
 } from './helpers';
-export type { PostData } from './helpers';
+export type {
+  PostData,
+  ContentKind,
+  ContentBodyOf,
+  DecodedBundle,
+} from './helpers';

apps/polycentric/src/features/follow/hooks/useFollows.ts

@@ -3,6 +3,10 @@ import {
   v2,
   type PolycentricClient,
 } from '@polycentric/react-native';
+import {
+  decodeBundle,
+  type DecodedBundle,
+} from '@/src/common/lib/polycentric-hooks/helpers';
 import { create } from 'zustand';
 
 type FollowsState = {
@@ -13,27 +17,6 @@ type FollowsState = {
   refresh: (client: PolycentricClient) => Promise<void>;
 };
 
-/**
- * Decode a `Follow` content out of an EventBundle. Returns `null` if the
- * bundle doesn't carry a Follow.
- */
-function decodeFollow(
-  bundle: v2.EventBundle,
-): { event: v2.Event; identity: string } | null {
-  if (!bundle.signedEvent || !bundle.serializedContent?.contentBytes) {
-    return null;
-  }
-  let content: v2.Content;
-  try {
-    content = v2.Content.fromBinary(bundle.serializedContent.contentBytes);
-  } catch {
-    return null;
-  }
-  if (content.contentBody.oneofKind !== 'follow') return null;
-  const event = v2.Event.fromBinary(bundle.signedEvent.eventBytes);
-  return { event, identity: content.contentBody.follow.identity };
-}
-
 const useFollows = create<FollowsState>((set, get) => ({
   follows: new Map(),
   isFollowing(identity) {
@@ -83,10 +66,10 @@ const useFollows = create<FollowsState>((set, get) => ({
     // `identity`. A single identity may have multiple follow events across
     // signing keys — delete them all.
     const targets = bundles
-      .map(decodeFollow)
+      .map((bundle) => decodeBundle(bundle, 'follow'))
       .filter(
-        (entry): entry is { event: v2.Event; identity: string } =>
-          entry !== null && entry.identity === identity,
+        (entry): entry is DecodedBundle<'follow'> =>
+          entry !== null && entry.content.identity === identity,
       );
 
     // Optimistically upate the state
@@ -132,8 +115,8 @@ const useFollows = create<FollowsState>((set, get) => ({
 
     const follows = new Map<string, boolean>();
     for (const bundle of bundles) {
-      const entry = decodeFollow(bundle);
-      if (entry) follows.set(entry.identity, true);
+      const entry = decodeBundle(bundle, 'follow');
+      if (entry) follows.set(entry.content.identity, true);
     }
 
     set({ follows });