react-native-permission-handler 0.1.0 → 0.2.1

package/src/engines/use-engine.ts

@@ -0,0 +1,10 @@
+import type { PermissionEngine } from "../types";
+import { getDefaultEngine } from "./resolve";
+import { getRNPFallbackEngine } from "./rnp-fallback";
+
+export function resolveEngine(configEngine?: PermissionEngine): PermissionEngine {
+  if (configEngine) return configEngine;
+  const global = getDefaultEngine();
+  if (global) return global;
+  return getRNPFallbackEngine();
+}

package/src/hooks/use-multiple-permissions.test.ts

@@ -1,7 +1,11 @@
 import { createElement } from "react";
 import { type ReactTestRenderer, act, create } from "react-test-renderer";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { MultiplePermissionsConfig, MultiplePermissionsResult } from "../types";
+import type {
+  MultiplePermissionsConfig,
+  MultiplePermissionsResult,
+  PermissionEngine,
+} from "../types";
 
 vi.mock("react-native", () => ({
   AppState: {
@@ -10,17 +14,24 @@ vi.mock("react-native", () => ({
   },
 }));
 
-vi.mock("react-native-permissions", () => ({
-  check: vi.fn(),
-  request: vi.fn(),
-  openSettings: vi.fn(),
-  checkNotifications: vi.fn(),
-  requestNotifications: vi.fn(),
+// Mock the RNP fallback so hooks don't try to require react-native-permissions
+vi.mock("../engines/rnp-fallback", () => ({
+  getRNPFallbackEngine: vi.fn(() => {
+    throw new Error("No engine configured");
+  }),
 }));
 
-import { check, request } from "react-native-permissions";
 import { useMultiplePermissions } from "./use-multiple-permissions";
 
+function createMockEngine(overrides?: Partial<PermissionEngine>): PermissionEngine {
+  return {
+    check: vi.fn().mockResolvedValue("granted"),
+    request: vi.fn().mockResolvedValue("granted"),
+    openSettings: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
 function renderHook(hookFn: () => MultiplePermissionsResult) {
   const results: { current: MultiplePermissionsResult } = {} as {
     current: MultiplePermissionsResult;
@@ -39,41 +50,58 @@ function renderHook(hookFn: () => MultiplePermissionsResult) {
   };
 }
 
-const baseConfig: MultiplePermissionsConfig = {
-  permissions: [
-    {
-      permission:
-        "ios.permission.CAMERA" as MultiplePermissionsConfig["permissions"][0]["permission"],
-      prePrompt: { title: "Camera", message: "Need camera" },
-      blockedPrompt: { title: "Blocked", message: "Camera blocked" },
-    },
-    {
-      permission:
-        "ios.permission.MICROPHONE" as MultiplePermissionsConfig["permissions"][0]["permission"],
-      prePrompt: { title: "Mic", message: "Need mic" },
-      blockedPrompt: { title: "Blocked", message: "Mic blocked" },
-    },
-  ],
-  strategy: "sequential",
-};
-
 describe("useMultiplePermissions", () => {
+  let engine: PermissionEngine;
+
+  const baseConfig = (
+    overrides?: Partial<MultiplePermissionsConfig>,
+  ): MultiplePermissionsConfig => ({
+    permissions: [
+      {
+        permission: "camera",
+        prePrompt: { title: "Camera", message: "Need camera" },
+        blockedPrompt: { title: "Blocked", message: "Camera blocked" },
+      },
+      {
+        permission: "microphone",
+        prePrompt: { title: "Mic", message: "Need mic" },
+        blockedPrompt: { title: "Blocked", message: "Mic blocked" },
+      },
+    ],
+    strategy: "sequential",
+    engine,
+    ...overrides,
+  });
+
   beforeEach(() => {
     vi.clearAllMocks();
+    engine = createMockEngine();
   });
 
-  it("initializes all permissions as idle", () => {
-    const { result } = renderHook(() => useMultiplePermissions(baseConfig));
+  it("initializes all permissions as idle when autoCheck is false", () => {
+    const { result } = renderHook(() => useMultiplePermissions(baseConfig({ autoCheck: false })));
 
     expect(result.current.allGranted).toBe(false);
     expect(Object.values(result.current.statuses)).toEqual(["idle", "idle"]);
   });
 
+  it("auto-checks all permissions on mount", async () => {
+    vi.mocked(engine.check).mockResolvedValueOnce("granted").mockResolvedValueOnce("denied");
+
+    const { result } = renderHook(() => useMultiplePermissions(baseConfig()));
+
+    await act(async () => {});
+
+    expect(engine.check).toHaveBeenCalledTimes(2);
+    expect(result.current.statuses.camera).toBe("granted");
+    expect(result.current.statuses.microphone).toBe("prePrompt");
+  });
+
   it("grants all permissions sequentially when already granted", async () => {
-    vi.mocked(check).mockResolvedValue("granted");
+    vi.mocked(engine.check).mockResolvedValue("granted");
     const onAllGranted = vi.fn();
 
-    const { result } = renderHook(() => useMultiplePermissions({ ...baseConfig, onAllGranted }));
+    const { result } = renderHook(() => useMultiplePermissions(baseConfig({ onAllGranted })));
 
     await act(async () => {
       await result.current.request();
@@ -84,52 +112,65 @@ describe("useMultiplePermissions", () => {
   });
 
   it("requests denied permissions sequentially", async () => {
-    // Initial checks return denied, final re-checks return granted
-    vi.mocked(check)
-      .mockResolvedValueOnce("denied") // camera initial check
-      .mockResolvedValueOnce("denied") // mic initial check
+    // Auto-check on mount returns denied for both, then requestAll flow
+    // checks again (denied), requests (granted), and final re-checks (granted)
+    vi.mocked(engine.check)
+      .mockResolvedValueOnce("denied") // auto-check: camera
+      .mockResolvedValueOnce("denied") // auto-check: mic
+      .mockResolvedValueOnce("denied") // requestAll: camera check
+      .mockResolvedValueOnce("denied") // requestAll: mic check
       .mockResolvedValue("granted"); // final re-checks
-    vi.mocked(request).mockResolvedValue("granted");
+    vi.mocked(engine.request).mockResolvedValue("granted");
     const onAllGranted = vi.fn();
 
-    const { result } = renderHook(() => useMultiplePermissions({ ...baseConfig, onAllGranted }));
+    const { result } = renderHook(() => useMultiplePermissions(baseConfig({ onAllGranted })));
 
+    await act(async () => {});
     await act(async () => {
       await result.current.request();
     });
 
     expect(result.current.allGranted).toBe(true);
-    expect(request).toHaveBeenCalledTimes(2);
+    expect(engine.request).toHaveBeenCalledTimes(2);
     expect(onAllGranted).toHaveBeenCalledOnce();
   });
 
   it("stops sequential flow when permission is denied", async () => {
-    vi.mocked(check).mockResolvedValue("denied");
-    vi.mocked(request).mockResolvedValueOnce("denied");
+    vi.mocked(engine.check).mockResolvedValue("denied");
+    vi.mocked(engine.request).mockResolvedValueOnce("denied");
 
-    const { result } = renderHook(() => useMultiplePermissions(baseConfig));
+    const { result } = renderHook(() => useMultiplePermissions(baseConfig()));
 
     await act(async () => {
       await result.current.request();
     });
 
     expect(result.current.allGranted).toBe(false);
-    expect(request).toHaveBeenCalledTimes(1);
+    expect(engine.request).toHaveBeenCalledTimes(1);
   });
 
   it("fires per-permission callbacks", async () => {
-    vi.mocked(check).mockResolvedValue("denied");
-    vi.mocked(request).mockResolvedValueOnce("granted").mockResolvedValueOnce("denied");
+    vi.mocked(engine.check).mockResolvedValue("denied");
+    vi.mocked(engine.request).mockResolvedValueOnce("granted").mockResolvedValueOnce("denied");
     const onGrant = vi.fn();
     const onDeny = vi.fn();
 
-    const config: MultiplePermissionsConfig = {
-      ...baseConfig,
+    const config = baseConfig({
       permissions: [
-        { ...baseConfig.permissions[0], onGrant },
-        { ...baseConfig.permissions[1], onDeny },
+        {
+          permission: "camera",
+          prePrompt: { title: "Camera", message: "Need camera" },
+          blockedPrompt: { title: "Blocked", message: "Camera blocked" },
+          onGrant,
+        },
+        {
+          permission: "microphone",
+          prePrompt: { title: "Mic", message: "Need mic" },
+          blockedPrompt: { title: "Blocked", message: "Mic blocked" },
+          onDeny,
+        },
       ],
-    };
+    });
 
     const { result } = renderHook(() => useMultiplePermissions(config));
 
@@ -142,18 +183,17 @@ describe("useMultiplePermissions", () => {
   });
 
   it("handles parallel strategy — checks all, then requests denied", async () => {
-    vi.mocked(check)
+    vi.mocked(engine.check)
       .mockResolvedValueOnce("granted") // camera already granted
       .mockResolvedValueOnce("denied") // mic needs request
       .mockResolvedValue("granted"); // final re-checks
-    vi.mocked(request).mockResolvedValue("granted");
+    vi.mocked(engine.request).mockResolvedValue("granted");
     const onAllGranted = vi.fn();
 
-    const config: MultiplePermissionsConfig = {
-      ...baseConfig,
+    const config = baseConfig({
       strategy: "parallel",
       onAllGranted,
-    };
+    });
 
     const { result } = renderHook(() => useMultiplePermissions(config));
 
@@ -161,7 +201,7 @@ describe("useMultiplePermissions", () => {
       await result.current.request();
     });
 
-    expect(request).toHaveBeenCalledTimes(1); // only mic was requested
+    expect(engine.request).toHaveBeenCalledTimes(1); // only mic was requested
     expect(onAllGranted).toHaveBeenCalledOnce();
   });
 });

package/src/hooks/use-multiple-permissions.ts

@@ -1,40 +1,14 @@
-import { useCallback, useRef, useState } from "react";
-import {
-  type PermissionStatus,
-  check,
-  checkNotifications,
-  request,
-  requestNotifications,
-} from "react-native-permissions";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { resolveEngine } from "../engines/use-engine";
 import type {
   MultiPermissionEntry,
   MultiplePermissionsConfig,
   MultiplePermissionsResult,
+  PermissionEngine,
   PermissionFlowState,
+  PermissionStatus,
 } from "../types";
 
-function isNotifications(
-  permission: MultiPermissionEntry["permission"],
-): permission is "notifications" {
-  return permission === "notifications";
-}
-
-async function checkOne(entry: MultiPermissionEntry): Promise<PermissionStatus> {
-  if (isNotifications(entry.permission)) {
-    const result = await checkNotifications();
-    return result.status;
-  }
-  return check(entry.permission);
-}
-
-async function requestOne(entry: MultiPermissionEntry): Promise<PermissionStatus> {
-  if (isNotifications(entry.permission)) {
-    const result = await requestNotifications(["alert", "badge", "sound"]);
-    return result.status;
-  }
-  return request(entry.permission);
-}
-
 function permissionKey(entry: MultiPermissionEntry): string {
   return String(entry.permission);
 }
@@ -43,10 +17,27 @@ function isGrantedStatus(status: PermissionStatus): boolean {
   return status === "granted" || status === "limited";
 }
 
+function statusToFlowState(status: PermissionStatus): PermissionFlowState {
+  switch (status) {
+    case "granted":
+    case "limited":
+      return "granted";
+    case "blocked":
+      return "blockedPrompt";
+    case "unavailable":
+      return "unavailable";
+    case "denied":
+      return "prePrompt";
+    default:
+      return "idle";
+  }
+}
+
 export function useMultiplePermissions(
   config: MultiplePermissionsConfig,
 ): MultiplePermissionsResult {
-  const { permissions, strategy, onAllGranted } = config;
+  const engine = resolveEngine(config.engine);
+  const { permissions, strategy, autoCheck = true, onAllGranted } = config;
   const [statuses, setStatuses] = useState<Record<string, PermissionFlowState>>(() => {
     const initial: Record<string, PermissionFlowState> = {};
     for (const entry of permissions) {
@@ -68,15 +59,15 @@ export function useMultiplePermissions(
 
     try {
       if (strategy === "sequential") {
-        await runSequential(permissions, update);
+        await runSequential(permissions, engine, update);
       } else {
-        await runParallel(permissions, update);
+        await runParallel(permissions, engine, update);
       }
 
       // Final check: are all granted?
       let allDone = true;
       for (const entry of permissions) {
-        const finalStatus = await checkOne(entry);
+        const finalStatus = await engine.check(entry.permission);
         if (!isGrantedStatus(finalStatus)) {
           allDone = false;
           break;
@@ -88,7 +79,27 @@ export function useMultiplePermissions(
     } finally {
       isRunning.current = false;
     }
-  }, [permissions, strategy, onAllGranted]);
+  }, [permissions, strategy, engine, onAllGranted]);
+
+  // Auto-check on mount
+  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional mount-only effect
+  useEffect(() => {
+    if (!autoCheck) return;
+
+    let cancelled = false;
+    async function checkAll() {
+      for (const entry of permissions) {
+        const key = permissionKey(entry);
+        const status = await engine.check(entry.permission);
+        if (cancelled) return;
+        setStatuses((prev) => ({ ...prev, [key]: statusToFlowState(status) }));
+      }
+    }
+    checkAll();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
 
   return {
     statuses,
@@ -99,13 +110,14 @@ export function useMultiplePermissions(
 
 async function runSequential(
   permissions: MultiPermissionEntry[],
+  engine: PermissionEngine,
   updateStatus: (key: string, state: PermissionFlowState) => void,
 ): Promise<void> {
   for (const entry of permissions) {
     const key = permissionKey(entry);
 
     updateStatus(key, "checking");
-    const checkStatus = await checkOne(entry);
+    const checkStatus = await engine.check(entry.permission);
 
     if (isGrantedStatus(checkStatus)) {
       updateStatus(key, "granted");
@@ -126,7 +138,7 @@ async function runSequential(
 
     // Denied — request it
     updateStatus(key, "requesting");
-    const requestStatus = await requestOne(entry);
+    const requestStatus = await engine.request(entry.permission);
 
     if (isGrantedStatus(requestStatus)) {
       updateStatus(key, "granted");
@@ -145,6 +157,7 @@ async function runSequential(
 
 async function runParallel(
   permissions: MultiPermissionEntry[],
+  engine: PermissionEngine,
   updateStatus: (key: string, state: PermissionFlowState) => void,
 ): Promise<void> {
   // Check all in parallel
@@ -152,7 +165,7 @@ async function runParallel(
     permissions.map(async (entry) => {
       const key = permissionKey(entry);
       updateStatus(key, "checking");
-      const status = await checkOne(entry);
+      const status = await engine.check(entry.permission);
       return { entry, key, status };
     }),
   );
@@ -180,7 +193,7 @@ async function runParallel(
     }
 
     updateStatus(key, "requesting");
-    const requestStatus = await requestOne(entry);
+    const requestStatus = await engine.request(entry.permission);
 
     if (isGrantedStatus(requestStatus)) {
       updateStatus(key, "granted");

package/src/hooks/use-permission-handler.test.ts

@@ -1,9 +1,9 @@
 import { createElement } from "react";
 import { type ReactTestRenderer, act, create } from "react-test-renderer";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { PermissionHandlerConfig, PermissionHandlerResult } from "../types";
+import type { PermissionEngine, PermissionHandlerConfig, PermissionHandlerResult } from "../types";
 
-// Mocks must be before imports that use them
+// Mock react-native AppState
 vi.mock("react-native", () => ({
   AppState: {
     currentState: "active",
@@ -11,17 +11,24 @@ vi.mock("react-native", () => ({
   },
 }));
 
-vi.mock("react-native-permissions", () => ({
-  check: vi.fn(),
-  request: vi.fn(),
-  openSettings: vi.fn(),
-  checkNotifications: vi.fn(),
-  requestNotifications: vi.fn(),
+// Mock the RNP fallback so hooks don't try to require react-native-permissions
+vi.mock("../engines/rnp-fallback", () => ({
+  getRNPFallbackEngine: vi.fn(() => {
+    throw new Error("No engine configured");
+  }),
 }));
 
-import { check, checkNotifications, request, requestNotifications } from "react-native-permissions";
 import { usePermissionHandler } from "./use-permission-handler";
 
+function createMockEngine(overrides?: Partial<PermissionEngine>): PermissionEngine {
+  return {
+    check: vi.fn().mockResolvedValue("granted"),
+    request: vi.fn().mockResolvedValue("granted"),
+    openSettings: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
 // Minimal renderHook using react-test-renderer
 function renderHook(hookFn: () => PermissionHandlerResult) {
   const results: { current: PermissionHandlerResult } = {} as {
@@ -41,32 +48,36 @@ function renderHook(hookFn: () => PermissionHandlerResult) {
   };
 }
 
-const baseConfig: PermissionHandlerConfig = {
-  permission: "ios.permission.CAMERA" as PermissionHandlerConfig["permission"],
-  prePrompt: { title: "Camera", message: "We need camera access" },
-  blockedPrompt: { title: "Blocked", message: "Camera is blocked" },
-};
-
 describe("usePermissionHandler", () => {
+  let engine: PermissionEngine;
+
+  const baseConfig = (overrides?: Partial<PermissionHandlerConfig>): PermissionHandlerConfig => ({
+    permission: "camera",
+    engine,
+    prePrompt: { title: "Camera", message: "We need camera access" },
+    blockedPrompt: { title: "Blocked", message: "Camera is blocked" },
+    ...overrides,
+  });
+
   beforeEach(() => {
     vi.clearAllMocks();
+    engine = createMockEngine();
   });
 
   it("auto-checks on mount and transitions to granted", async () => {
-    vi.mocked(check).mockResolvedValue("granted");
-    const { result } = renderHook(() => usePermissionHandler(baseConfig));
+    vi.mocked(engine.check).mockResolvedValue("granted");
+    const { result } = renderHook(() => usePermissionHandler(baseConfig()));
 
-    // After mount, should be checking
     await act(async () => {});
 
     expect(result.current.isGranted).toBe(true);
     expect(result.current.state).toBe("granted");
-    expect(check).toHaveBeenCalledWith(baseConfig.permission);
+    expect(engine.check).toHaveBeenCalledWith("camera");
   });
 
   it("transitions to prePrompt when permission is denied", async () => {
-    vi.mocked(check).mockResolvedValue("denied");
-    const { result } = renderHook(() => usePermissionHandler(baseConfig));
+    vi.mocked(engine.check).mockResolvedValue("denied");
+    const { result } = renderHook(() => usePermissionHandler(baseConfig()));
 
     await act(async () => {});
 
@@ -74,8 +85,8 @@ describe("usePermissionHandler", () => {
   });
 
   it("transitions to blockedPrompt when permission is blocked", async () => {
-    vi.mocked(check).mockResolvedValue("blocked");
-    const { result } = renderHook(() => usePermissionHandler(baseConfig));
+    vi.mocked(engine.check).mockResolvedValue("blocked");
+    const { result } = renderHook(() => usePermissionHandler(baseConfig()));
 
     await act(async () => {});
 
@@ -84,8 +95,8 @@ describe("usePermissionHandler", () => {
   });
 
   it("transitions to unavailable", async () => {
-    vi.mocked(check).mockResolvedValue("unavailable");
-    const { result } = renderHook(() => usePermissionHandler(baseConfig));
+    vi.mocked(engine.check).mockResolvedValue("unavailable");
+    const { result } = renderHook(() => usePermissionHandler(baseConfig()));
 
     await act(async () => {});
 
@@ -94,20 +105,20 @@ describe("usePermissionHandler", () => {
   });
 
   it("skips auto-check when autoCheck is false", async () => {
-    const { result } = renderHook(() => usePermissionHandler({ ...baseConfig, autoCheck: false }));
+    const { result } = renderHook(() => usePermissionHandler(baseConfig({ autoCheck: false })));
 
     await act(async () => {});
 
     expect(result.current.state).toBe("idle");
-    expect(check).not.toHaveBeenCalled();
+    expect(engine.check).not.toHaveBeenCalled();
   });
 
   it("requests permission and fires onGrant", async () => {
-    vi.mocked(check).mockResolvedValue("denied");
-    vi.mocked(request).mockResolvedValue("granted");
+    vi.mocked(engine.check).mockResolvedValue("denied");
+    vi.mocked(engine.request).mockResolvedValue("granted");
     const onGrant = vi.fn();
 
-    const { result } = renderHook(() => usePermissionHandler({ ...baseConfig, onGrant }));
+    const { result } = renderHook(() => usePermissionHandler(baseConfig({ onGrant })));
 
     await act(async () => {});
     expect(result.current.state).toBe("prePrompt");
@@ -121,11 +132,11 @@ describe("usePermissionHandler", () => {
   });
 
   it("fires onDeny when request is denied", async () => {
-    vi.mocked(check).mockResolvedValue("denied");
-    vi.mocked(request).mockResolvedValue("denied");
+    vi.mocked(engine.check).mockResolvedValue("denied");
+    vi.mocked(engine.request).mockResolvedValue("denied");
     const onDeny = vi.fn();
 
-    const { result } = renderHook(() => usePermissionHandler({ ...baseConfig, onDeny }));
+    const { result } = renderHook(() => usePermissionHandler(baseConfig({ onDeny })));
 
     await act(async () => {});
     await act(async () => {
@@ -137,11 +148,11 @@ describe("usePermissionHandler", () => {
   });
 
   it("fires onBlock when request results in blocked", async () => {
-    vi.mocked(check).mockResolvedValue("denied");
-    vi.mocked(request).mockResolvedValue("blocked");
+    vi.mocked(engine.check).mockResolvedValue("denied");
+    vi.mocked(engine.request).mockResolvedValue("blocked");
     const onBlock = vi.fn();
 
-    const { result } = renderHook(() => usePermissionHandler({ ...baseConfig, onBlock }));
+    const { result } = renderHook(() => usePermissionHandler(baseConfig({ onBlock })));
 
     await act(async () => {});
     await act(async () => {
@@ -152,33 +163,32 @@ describe("usePermissionHandler", () => {
     expect(onBlock).toHaveBeenCalled();
   });
 
-  it("uses notification API when permission is 'notifications'", async () => {
-    vi.mocked(checkNotifications).mockResolvedValue({ status: "denied", settings: {} });
-    vi.mocked(requestNotifications).mockResolvedValue({ status: "granted", settings: {} });
+  it("passes permission string to engine (notification routing is engine's job)", async () => {
+    vi.mocked(engine.check).mockResolvedValue("denied");
+    vi.mocked(engine.request).mockResolvedValue("granted");
 
     const { result } = renderHook(() =>
-      usePermissionHandler({ ...baseConfig, permission: "notifications" }),
+      usePermissionHandler(baseConfig({ permission: "notifications" })),
     );
 
     await act(async () => {});
-    expect(checkNotifications).toHaveBeenCalled();
-    expect(check).not.toHaveBeenCalled();
+    expect(engine.check).toHaveBeenCalledWith("notifications");
 
     await act(async () => {
       result.current.request();
     });
 
-    expect(requestNotifications).toHaveBeenCalledWith(["alert", "badge", "sound"]);
+    expect(engine.request).toHaveBeenCalledWith("notifications");
     expect(result.current.isGranted).toBe(true);
   });
 
   it("guards against double-tap race condition", async () => {
-    vi.mocked(check).mockResolvedValue("denied");
-    vi.mocked(request).mockImplementation(
+    vi.mocked(engine.check).mockResolvedValue("denied");
+    vi.mocked(engine.request).mockImplementation(
       () => new Promise((resolve) => setTimeout(() => resolve("granted"), 50)),
     );
 
-    const { result } = renderHook(() => usePermissionHandler(baseConfig));
+    const { result } = renderHook(() => usePermissionHandler(baseConfig()));
 
     await act(async () => {});
     expect(result.current.state).toBe("prePrompt");
@@ -188,14 +198,14 @@ describe("usePermissionHandler", () => {
       result.current.request(); // double-tap
     });
 
-    expect(request).toHaveBeenCalledTimes(1);
+    expect(engine.request).toHaveBeenCalledTimes(1);
   });
 
   it("dismiss fires onDeny and transitions to denied", async () => {
-    vi.mocked(check).mockResolvedValue("denied");
+    vi.mocked(engine.check).mockResolvedValue("denied");
     const onDeny = vi.fn();
 
-    const { result } = renderHook(() => usePermissionHandler({ ...baseConfig, onDeny }));
+    const { result } = renderHook(() => usePermissionHandler(baseConfig({ onDeny })));
 
     await act(async () => {});
     expect(result.current.state).toBe("prePrompt");