@umituz/react-native-firebase 2.0.3 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.0.3",
+  "version": "2.1.1",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/account-deletion/index.ts

@@ -26,3 +26,9 @@ export {
   reauthenticateWithApple,
   getAppleReauthCredential,
 } from './infrastructure/services/reauthentication.service';
+
+export { PasswordPromptModal } from './presentation/components/PasswordPromptModal';
+export type { PasswordPromptModalProps } from './presentation/components/PasswordPromptModal';
+
+export { usePasswordPrompt } from './presentation/hooks/usePasswordPrompt';
+export type { UsePasswordPromptOptions, UsePasswordPromptReturn } from './presentation/hooks/usePasswordPrompt';

package/src/domains/account-deletion/infrastructure/services/account-deletion.service.ts

@@ -74,23 +74,47 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
   if (provider === "apple.com") {
     res = await reauthenticateWithApple(user);
   } else if (provider === "google.com") {
-    if (!options.googleIdToken) {
+    let googleToken = options.googleIdToken;
+    if (!googleToken && options.onGoogleReauthRequired) {
+      const token = await options.onGoogleReauthRequired();
+      if (!token) {
+        return {
+          success: false,
+          error: { code: "auth/google-reauth-cancelled", message: "Google reauth cancelled" },
+          requiresReauth: true
+        };
+      }
+      googleToken = token;
+    }
+    if (!googleToken) {
       return {
         success: false,
         error: { code: "auth/google-reauth", message: "Google reauth required" },
         requiresReauth: true
       };
     }
-    res = await reauthenticateWithGoogle(user, options.googleIdToken);
+    res = await reauthenticateWithGoogle(user, googleToken);
   } else if (provider === "password") {
-    if (!options.password) {
+    let password = options.password;
+    if (!password && options.onPasswordRequired) {
+      const pwd = await options.onPasswordRequired();
+      if (!pwd) {
+        return {
+          success: false,
+          error: { code: "auth/password-reauth-cancelled", message: "Password reauth cancelled" },
+          requiresReauth: true
+        };
+      }
+      password = pwd;
+    }
+    if (!password) {
       return {
         success: false,
         error: { code: "auth/password-reauth", message: "Password required" },
         requiresReauth: true
       };
     }
-    res = await reauthenticateWithPassword(user, options.password);
+    res = await reauthenticateWithPassword(user, password);
   } else {
     return null;
   }

package/src/domains/account-deletion/presentation/components/PasswordPromptModal.tsx

@@ -0,0 +1,106 @@
+/**
+ * Password Prompt Modal
+ * Modal for password input during account deletion reauthentication
+ */
+
+import React, { useState } from 'react';
+import { View, StyleSheet } from 'react-native';
+import {
+  BaseModal,
+  AtomicInput,
+  AtomicButton,
+  useAppDesignTokens
+} from '@umituz/react-native-design-system';
+
+export interface PasswordPromptModalProps {
+  visible: boolean;
+  onConfirm: (password: string) => void;
+  onCancel: () => void;
+  title?: string;
+  message?: string;
+  confirmText?: string;
+  cancelText?: string;
+}
+
+export const PasswordPromptModal: React.FC<PasswordPromptModalProps> = ({
+  visible,
+  onConfirm,
+  onCancel,
+  title = 'Password Required',
+  message = 'Enter your password to continue',
+  confirmText = 'Confirm',
+  cancelText = 'Cancel',
+}) => {
+  const tokens = useAppDesignTokens();
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState('');
+
+  const handleConfirm = () => {
+    if (!password.trim()) {
+      setError('Password is required');
+      return;
+    }
+    onConfirm(password);
+    setPassword('');
+    setError('');
+  };
+
+  const handleCancel = () => {
+    setPassword('');
+    setError('');
+    onCancel();
+  };
+
+  return (
+    <BaseModal
+      visible={visible}
+      onClose={handleCancel}
+      title={title}
+      subtitle={message}
+      dismissOnBackdrop={false}
+    >
+      <View style={[styles.container, { padding: tokens.spacing.md }]}>
+        <AtomicInput
+          value={password}
+          onChangeText={(text: string) => {
+            setPassword(text);
+            setError('');
+          }}
+          placeholder="Password"
+          secureTextEntry
+          autoFocus
+          state={error ? 'error' : 'default'}
+          helperText={error}
+          style={{ marginBottom: tokens.spacing.md }}
+        />
+
+        <View style={[styles.buttons, { gap: tokens.spacing.sm }]}>
+          <AtomicButton
+            title={cancelText}
+            onPress={handleCancel}
+            variant="secondary"
+            style={styles.button}
+          />
+          <AtomicButton
+            title={confirmText}
+            onPress={handleConfirm}
+            variant="primary"
+            style={styles.button}
+          />
+        </View>
+      </View>
+    </BaseModal>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    width: '100%',
+  },
+  buttons: {
+    flexDirection: 'row',
+  },
+  button: {
+    flex: 1,
+  },
+});

package/src/domains/account-deletion/presentation/hooks/usePasswordPrompt.tsx

@@ -0,0 +1,64 @@
+/**
+ * Password Prompt Hook
+ * Manages password prompt modal state and logic
+ */
+
+import React, { useState, useCallback, useMemo } from 'react';
+import { PasswordPromptModal } from '../components/PasswordPromptModal';
+
+export interface UsePasswordPromptOptions {
+  title?: string;
+  message?: string;
+  confirmText?: string;
+  cancelText?: string;
+}
+
+export interface UsePasswordPromptReturn {
+  showPasswordPrompt: () => Promise<string | null>;
+  PasswordPromptComponent: React.ReactNode;
+}
+
+export const usePasswordPrompt = (options: UsePasswordPromptOptions = {}): UsePasswordPromptReturn => {
+  const [isVisible, setIsVisible] = useState(false);
+  const [resolvePromise, setResolvePromise] = useState<((value: string | null) => void) | null>(null);
+
+  const showPasswordPrompt = useCallback((): Promise<string | null> => {
+    return new Promise((resolve) => {
+      setResolvePromise(() => resolve);
+      setIsVisible(true);
+    });
+  }, []);
+
+  const handleConfirm = useCallback((password: string) => {
+    if (resolvePromise) {
+      resolvePromise(password);
+    }
+    setIsVisible(false);
+    setResolvePromise(null);
+  }, [resolvePromise]);
+
+  const handleCancel = useCallback(() => {
+    if (resolvePromise) {
+      resolvePromise(null);
+    }
+    setIsVisible(false);
+    setResolvePromise(null);
+  }, [resolvePromise]);
+
+  const PasswordPromptComponent = useMemo(() => (
+    <PasswordPromptModal
+      visible={isVisible}
+      onConfirm={handleConfirm}
+      onCancel={handleCancel}
+      title={options.title}
+      message={options.message}
+      confirmText={options.confirmText}
+      cancelText={options.cancelText}
+    />
+  ), [isVisible, handleConfirm, handleCancel, options.title, options.message, options.confirmText, options.cancelText]);
+
+  return {
+    showPasswordPrompt,
+    PasswordPromptComponent,
+  };
+};