@oxy.so/services 4.0.5 → 4.0.7

package/src/ui/components/followButtonAccessibility.ts

@@ -0,0 +1,83 @@
+/**
+ * What a screen reader hears for a follow button.
+ *
+ * Bloom's `FollowButton` names itself "Follow" in both states and carries the
+ * state in its pressed flag. Android TalkBack reads that flag as "selected",
+ * so a button that SHOWS "Following" was announced as "Follow, selected", and a
+ * TalkBack user could not tell they already follow the account
+ * (OxyHQ/oxy#1375 item 22). The name now says the state, and who it is for
+ * when the caller knows the handle.
+ *
+ * Pure, and kept apart from the components, so every state is pinned by a
+ * table test rather than by a render that can only see one state at a time.
+ */
+
+export interface FollowButtonAccessibility {
+  accessibilityLabel: string;
+  accessibilityHint?: string;
+}
+
+/** `@nate` from `nate` or `@nate`; `undefined` when there is no handle. */
+export function formatHandle(username: string | undefined): string | undefined {
+  const bare = username?.trim().replace(/^@+/, '');
+  return bare ? `@${bare}` : undefined;
+}
+
+/**
+ * The single-user button.
+ *
+ * - `isKnown: false`: the status is still being fetched and the button is
+ *   inert, so it says so rather than offering a "Follow" it would ignore.
+ * - `isPending`: a follow or unfollow is in flight. The name keeps the state
+ *   the button still shows; the busy flag says the rest, and there is no hint
+ *   because a press does nothing until the write settles.
+ * - Following: "Following @nate", hinted "Unfollows @nate", because pressing
+ *   it unfollows, which the visible "Following" does not say.
+ */
+export function describeFollowButton(input: {
+  isKnown: boolean;
+  isFollowing: boolean;
+  isPending: boolean;
+  username?: string;
+}): FollowButtonAccessibility {
+  const handle = formatHandle(input.username);
+
+  if (!input.isKnown) {
+    return {
+      accessibilityLabel: handle
+        ? `Checking whether you follow ${handle}`
+        : 'Checking follow status',
+    };
+  }
+
+  const accessibilityLabel = input.isFollowing
+    ? handle ? `Following ${handle}` : 'Following'
+    : handle ? `Follow ${handle}` : 'Follow';
+
+  if (input.isPending || !input.isFollowing) return { accessibilityLabel };
+
+  return {
+    accessibilityLabel,
+    accessibilityHint: handle ? `Unfollows ${handle}` : 'Unfollows this account',
+  };
+}
+
+/**
+ * The "Follow all" button. The labels are the caller's, since a starter pack
+ * and a feed's member list word it differently; the hint carries the count.
+ */
+export function describeFollowAllButton(input: {
+  allFollowing: boolean;
+  isPending: boolean;
+  count: number;
+  followAllLabel: string;
+  followedAllLabel: string;
+}): FollowButtonAccessibility {
+  const accessibilityLabel = input.allFollowing ? input.followedAllLabel : input.followAllLabel;
+  if (input.isPending) return { accessibilityLabel };
+  const accounts = input.count === 1 ? '1 account' : `${input.count} accounts`;
+  return {
+    accessibilityLabel,
+    accessibilityHint: input.allFollowing ? `Unfollows all ${accounts}` : `Follows all ${accounts}`,
+  };
+}

package/src/ui/components/modals/DeleteAccountModal.tsx

@@ -4,6 +4,7 @@ import { View, TextInput } from 'react-native';
 import { Text } from '@oxy.so/bloom/typography';
 import Ionicons from '../../icons/Ionicons';
 import { Button } from '@oxy.so/bloom/button';
+import { Admonition } from '@oxy.so/bloom/admonition';
 import { useTheme } from '@oxy.so/bloom/theme';
 import { surfaces, type SurfaceControls } from '@oxy.so/bloom/surfaces';
 
@@ -69,16 +70,11 @@ const DeleteAccountModal: React.FC<DeleteAccountModalProps> = ({
                 {t('deleteAccount.warning') || 'This action cannot be undone. Your account and all associated data will be permanently deleted.'}
             </Text>
 
-            {error && (
-                <View
-                    className="p-3 rounded-lg mb-4"
-                    style={{ backgroundColor: `${theme.colors.error}20` }}
-                >
-                    <Text className="text-text text-sm text-center" style={{ color: theme.colors.error }}>
-                        {error}
-                    </Text>
+            {error ? (
+                <View className="mb-4">
+                    <Admonition type="error">{error}</Admonition>
                 </View>
-            )}
+            ) : null}
 
             <View className="mb-4">
                 <Text className="text-text-secondary text-[13px] mb-2">

package/src/ui/screens/ManageAccountScreen.tsx

@@ -26,6 +26,7 @@ import type { BaseScreenProps } from '../types/navigation';
 import ProfileSummaryCard from '../components/ProfileSummaryCard';
 import { SettingsIcon } from '../components/SettingsIcon';
 import { presentDeleteAccount } from '../components/modals/DeleteAccountModal';
+import { runAccountDeletionHandoff } from '../utils/accountDeletionHandoff';
 import { presentActionSheet } from '../components/surfaces/ActionSheetSurface';
 import { useOxy } from '../context/OxyContext';
 import { useI18n } from '../hooks/useI18n';
@@ -95,6 +96,7 @@ const ManageAccountScreen: React.FC<BaseScreenProps> = ({
         openAvatarPicker,
         accounts,
         openAccountDialog,
+        hasIdentity,
     } = useOxy();
 
     const { data: userFromQuery, isLoading: userLoading } = useCurrentUser({
@@ -330,6 +332,19 @@ const ManageAccountScreen: React.FC<BaseScreenProps> = ({
             });
             return;
         }
+        // Native: the deletion is signed with the identity key. When this app
+        // does not hold it (Commons keeps it on this device, or it lives on
+        // another device), hand off to where it can be signed instead of
+        // failing inside the confirmation surface.
+        const route = await runAccountDeletionHandoff({
+            hasIdentity,
+            canOpenURL: (url) => Linking.canOpenURL(url),
+            openURL: (url) => Linking.openURL(url),
+            t,
+        });
+        if (route !== 'local') {
+            return;
+        }
         const deleted = await presentDeleteAccount({
             username: user.username || '',
             onDelete: handleConfirmDelete,
@@ -339,7 +354,7 @@ const ManageAccountScreen: React.FC<BaseScreenProps> = ({
             await logout();
             onClose?.();
         }
-    }, [user, t, handleConfirmDelete, logout, onClose]);
+    }, [user, t, handleConfirmDelete, hasIdentity, logout, onClose]);
 
     if (!isAuthenticated) {
         return (

package/src/ui/utils/accountDeletionHandoff.ts

@@ -0,0 +1,115 @@
+import { surfaces } from '@oxy.so/bloom/surfaces';
+import { toast } from '@oxy.so/bloom/toast';
+import { IDENTITY_WEB_ORIGIN, logger } from '@oxy.so/core';
+
+/**
+ * Commons' own delete-account screen (`app/(tabs)/(settings)/delete-account.tsx`
+ * in packages/commons). Expo Router drops the route groups, so the scheme path
+ * `delete-account` resolves to it; `oxycommons://` is the scheme the account
+ * dialog already probes and hands sign-in approvals to.
+ */
+export const COMMONS_DELETE_ACCOUNT_URL = 'oxycommons://delete-account';
+
+/** The scheme root `Linking.canOpenURL` probes to tell whether Commons is installed. */
+export const COMMONS_APP_SCHEME = 'oxycommons://';
+
+type Translate = (key: string, vars?: Record<string, string | number>) => string | undefined;
+
+export interface AccountDeletionHandoffDeps {
+  /** Whether THIS app can read an identity key it could sign the deletion with. */
+  hasIdentity: () => Promise<boolean>;
+  canOpenURL: (url: string) => Promise<boolean>;
+  openURL: (url: string) => Promise<unknown>;
+  t: Translate;
+}
+
+/**
+ * `'local'`: this app holds the identity key, so the caller runs its own
+ * delete-account surface. `'handled'`: it does not, and the user has been sent
+ * to where the deletion can actually be signed (or told why not).
+ */
+export type AccountDeletionHandoffResult = 'local' | 'handled';
+
+/**
+ * Decide where a native account deletion can happen, before anything is deleted.
+ *
+ * Deleting an account is signed with the identity private key. When the key
+ * lives in Oxy Commons rather than in this app, the API call cannot be made from
+ * here, so the deletion is delegated to Commons' own screen when Commons is
+ * installed, and explained otherwise. Nothing on the delegated paths calls the
+ * deletion API.
+ */
+export async function runAccountDeletionHandoff(
+  deps: AccountDeletionHandoffDeps,
+): Promise<AccountDeletionHandoffResult> {
+  const { hasIdentity, canOpenURL, openURL, t } = deps;
+  const text = (key: string, fallback: string, vars?: Record<string, string>): string => {
+    // An older `@oxy.so/core` echoes a key it has no string for; show English then.
+    const value = t(key, vars);
+    return value && value !== key ? value : fallback;
+  };
+
+  let holdsIdentity: boolean;
+  try {
+    holdsIdentity = await hasIdentity();
+  } catch (error) {
+    // A locked or unreadable keystore is not proof the identity is elsewhere.
+    logger.warn('Identity read failed before account deletion', { component: 'accountDeletionHandoff' }, error);
+    toast.error(
+      text(
+        'deleteAccount.handoff.identityUnreadable',
+        "Couldn't read this device's identity storage. Unlock your device and try again.",
+      ),
+    );
+    return 'handled';
+  }
+  if (holdsIdentity) {
+    return 'local';
+  }
+
+  let commonsInstalled = false;
+  try {
+    commonsInstalled = await canOpenURL(COMMONS_APP_SCHEME);
+  } catch {
+    commonsInstalled = false;
+  }
+
+  if (commonsInstalled) {
+    const open = await surfaces.confirm({
+      title: text('deleteAccount.handoff.commonsTitle', 'Delete your account in Oxy Commons'),
+      description: text(
+        'deleteAccount.handoff.commonsMessage',
+        'Your identity key is kept by Oxy Commons on this device, and deleting your account needs it. Commons will open on Settings > Delete account to finish.',
+      ),
+      confirmLabel: text('deleteAccount.handoff.openCommons', 'Open Oxy Commons'),
+      cancelLabel: text('common.cancel', 'Cancel'),
+    });
+    if (open) {
+      try {
+        await openURL(COMMONS_DELETE_ACCOUNT_URL);
+      } catch (error) {
+        logger.warn('Opening Commons delete-account failed', { component: 'accountDeletionHandoff' }, error);
+        toast.error(
+          text(
+            'deleteAccount.handoff.commonsOpenFailed',
+            "Couldn't open Oxy Commons. Open it yourself and go to Settings > Delete account.",
+          ),
+        );
+      }
+    }
+    return 'handled';
+  }
+
+  const site = IDENTITY_WEB_ORIGIN.replace(/^https?:\/\//, '');
+  await surfaces.confirm({
+    title: text('deleteAccount.handoff.elsewhereTitle', 'Delete your account where your identity is'),
+    description: text(
+      'deleteAccount.handoff.elsewhereMessage',
+      `Deleting your account needs your identity key, and it isn't on this device. Open Oxy Commons on the device that holds your identity and go to Settings > Delete account, or open ${site} in a browser that holds it.`,
+      { site },
+    ),
+    confirmLabel: text('deleteAccount.handoff.gotIt', 'Got it'),
+    hideCancel: true,
+  });
+  return 'handled';
+}