@ankhorage/permissions 0.2.3 → 0.2.5

package/src/expo/client.testSupport.ts

@@ -0,0 +1,188 @@
+import { mock } from 'bun:test';
+
+export interface MockPermissionResponse {
+  readonly status: string;
+  readonly canAskAgain?: boolean;
+  readonly accessPrivileges?: 'all' | 'limited' | 'none';
+  readonly ios?: { readonly status?: number };
+}
+
+type CameraMockMode = 'topLevel' | 'cameraNamespace' | 'missingExports';
+type AudioMockMode = 'topLevel' | 'audioModule' | 'missingExports';
+
+export function permissionResponse(status: string, canAskAgain = true): MockPermissionResponse {
+  return { status, canAskAgain };
+}
+
+export const cameraMock = {
+  mode: 'topLevel' as CameraMockMode,
+  getResponse: permissionResponse('granted'),
+  requestResponse: permissionResponse('granted'),
+  getError: undefined as string | undefined,
+  requestError: undefined as string | undefined,
+};
+export const audioMock = {
+  mode: 'topLevel' as AudioMockMode,
+  getResponse: permissionResponse('granted'),
+  requestResponse: permissionResponse('granted'),
+  getError: undefined as string | undefined,
+  requestError: undefined as string | undefined,
+};
+export const mediaLibraryMock = {
+  getResponse: permissionResponse('granted'),
+  requestResponse: permissionResponse('granted'),
+  getError: undefined as string | undefined,
+  requestError: undefined as string | undefined,
+  getCalls: [] as boolean[],
+  requestCalls: [] as boolean[],
+};
+export const locationMock = {
+  foregroundGetResponse: permissionResponse('granted'),
+  foregroundRequestResponse: permissionResponse('granted'),
+  backgroundGetResponse: permissionResponse('granted'),
+  backgroundRequestResponse: permissionResponse('granted'),
+  getCalls: [] as string[],
+  requestCalls: [] as string[],
+};
+export const notificationsMock = {
+  getResponse: permissionResponse('granted'),
+  requestResponse: permissionResponse('granted'),
+  getError: undefined as string | undefined,
+  requestError: undefined as string | undefined,
+};
+export const linkingMock = { calls: 0, error: undefined as Error | undefined };
+
+void mock.module('expo-camera', () => ({
+  get getCameraPermissionsAsync() {
+    if (cameraMock.mode !== 'topLevel') return undefined;
+    return () => {
+      if (cameraMock.getError !== undefined) throw new Error(cameraMock.getError);
+      return Promise.resolve(cameraMock.getResponse);
+    };
+  },
+  get requestCameraPermissionsAsync() {
+    if (cameraMock.mode !== 'topLevel') return undefined;
+    return () => {
+      if (cameraMock.requestError !== undefined) throw new Error(cameraMock.requestError);
+      return Promise.resolve(cameraMock.requestResponse);
+    };
+  },
+  get Camera() {
+    if (cameraMock.mode !== 'cameraNamespace') return undefined;
+    return {
+      getCameraPermissionsAsync: () => Promise.resolve(cameraMock.getResponse),
+      requestCameraPermissionsAsync: () => Promise.resolve(cameraMock.requestResponse),
+    };
+  },
+}));
+
+void mock.module('expo-audio', () => ({
+  get getRecordingPermissionsAsync() {
+    if (audioMock.mode !== 'topLevel') return undefined;
+    return () => {
+      if (audioMock.getError !== undefined) throw new Error(audioMock.getError);
+      return Promise.resolve(audioMock.getResponse);
+    };
+  },
+  get requestRecordingPermissionsAsync() {
+    if (audioMock.mode !== 'topLevel') return undefined;
+    return () => {
+      if (audioMock.requestError !== undefined) throw new Error(audioMock.requestError);
+      return Promise.resolve(audioMock.requestResponse);
+    };
+  },
+  get AudioModule() {
+    if (audioMock.mode !== 'audioModule') return undefined;
+    return {
+      getRecordingPermissionsAsync: () => Promise.resolve(audioMock.getResponse),
+      requestRecordingPermissionsAsync: () => Promise.resolve(audioMock.requestResponse),
+    };
+  },
+}));
+
+void mock.module('expo-media-library', () => ({
+  getPermissionsAsync: (writeOnly?: boolean) => {
+    mediaLibraryMock.getCalls.push(writeOnly === true);
+    if (mediaLibraryMock.getError !== undefined) throw new Error(mediaLibraryMock.getError);
+    return Promise.resolve(mediaLibraryMock.getResponse);
+  },
+  requestPermissionsAsync: (writeOnly?: boolean) => {
+    mediaLibraryMock.requestCalls.push(writeOnly === true);
+    if (mediaLibraryMock.requestError !== undefined) throw new Error(mediaLibraryMock.requestError);
+    return Promise.resolve(mediaLibraryMock.requestResponse);
+  },
+}));
+
+void mock.module('expo-location', () => ({
+  getForegroundPermissionsAsync: () => {
+    locationMock.getCalls.push('foreground');
+    return Promise.resolve(locationMock.foregroundGetResponse);
+  },
+  requestForegroundPermissionsAsync: () => {
+    locationMock.requestCalls.push('foreground');
+    return Promise.resolve(locationMock.foregroundRequestResponse);
+  },
+  getBackgroundPermissionsAsync: () => {
+    locationMock.getCalls.push('background');
+    return Promise.resolve(locationMock.backgroundGetResponse);
+  },
+  requestBackgroundPermissionsAsync: () => {
+    locationMock.requestCalls.push('background');
+    return Promise.resolve(locationMock.backgroundRequestResponse);
+  },
+}));
+
+void mock.module('expo-notifications', () => ({
+  getPermissionsAsync: () => {
+    if (notificationsMock.getError !== undefined) throw new Error(notificationsMock.getError);
+    return Promise.resolve(notificationsMock.getResponse);
+  },
+  requestPermissionsAsync: () => {
+    if (notificationsMock.requestError !== undefined)
+      throw new Error(notificationsMock.requestError);
+    return Promise.resolve(notificationsMock.requestResponse);
+  },
+}));
+
+void mock.module('expo-linking', () => ({
+  openSettings: () => {
+    linkingMock.calls += 1;
+    if (linkingMock.error !== undefined) throw linkingMock.error;
+    return Promise.resolve();
+  },
+}));
+
+export function resetExpoMocks(): void {
+  cameraMock.mode = 'topLevel';
+  cameraMock.getResponse = permissionResponse('granted');
+  cameraMock.requestResponse = permissionResponse('granted');
+  cameraMock.getError = undefined;
+  cameraMock.requestError = undefined;
+  audioMock.mode = 'topLevel';
+  audioMock.getResponse = permissionResponse('granted');
+  audioMock.requestResponse = permissionResponse('granted');
+  audioMock.getError = undefined;
+  audioMock.requestError = undefined;
+  resetCollectionMocks();
+  notificationsMock.getResponse = permissionResponse('granted');
+  notificationsMock.requestResponse = permissionResponse('granted');
+  notificationsMock.getError = undefined;
+  notificationsMock.requestError = undefined;
+  linkingMock.calls = 0;
+  linkingMock.error = undefined;
+}
+
+function resetCollectionMocks(): void {
+  mediaLibraryMock.getResponse = permissionResponse('granted');
+  mediaLibraryMock.requestResponse = permissionResponse('granted');
+  mediaLibraryMock.getError = undefined;
+  mediaLibraryMock.requestError = undefined;
+  mediaLibraryMock.getCalls.length = 0;
+  mediaLibraryMock.requestCalls.length = 0;
+  locationMock.foregroundGetResponse = permissionResponse('granted');
+  locationMock.foregroundRequestResponse = permissionResponse('granted');
+  locationMock.backgroundGetResponse = permissionResponse('granted');
+  locationMock.backgroundRequestResponse = permissionResponse('granted');
+  locationMock.getCalls.length = 0;
+  locationMock.requestCalls.length = 0;
+}

package/src/expo/client.ts

@@ -15,15 +15,15 @@ export interface ExpoPermissionAdapter {
   request(permission: Permission): Promise<PermissionState>;
 }
 
-const adapters: Partial<Record<Permission, ExpoPermissionAdapter>> = {
-  [Permission.Camera]: cameraAdapter,
-  [Permission.MediaLibrary]: mediaLibraryAdapter,
-  [Permission.MediaLibraryWrite]: mediaLibraryAdapter,
-  [Permission.Microphone]: microphoneAdapter,
-  [Permission.LocationForeground]: locationAdapter,
-  [Permission.LocationBackground]: locationAdapter,
-  [Permission.Notifications]: notificationsAdapter,
-};
+const adapters = new Map<Permission, ExpoPermissionAdapter>([
+  [Permission.Camera, cameraAdapter],
+  [Permission.MediaLibrary, mediaLibraryAdapter],
+  [Permission.MediaLibraryWrite, mediaLibraryAdapter],
+  [Permission.Microphone, microphoneAdapter],
+  [Permission.LocationForeground, locationAdapter],
+  [Permission.LocationBackground, locationAdapter],
+  [Permission.Notifications, notificationsAdapter],
+]);
 
 /***
  * Creates a permission client backed by Expo SDK modules.
@@ -42,7 +42,7 @@ const adapters: Partial<Record<Permission, ExpoPermissionAdapter>> = {
 export function createPermissionClient(): PermissionClient {
   return {
     async getStatus(permission: Permission): Promise<PermissionState> {
-      const metadata = EXPO_PERMISSION_SUPPORT[permission];
+      const metadata = getPermissionSupport(permission);
       if (metadata.support === 'unsupported' || metadata.support === 'notImplemented') {
         return createUnavailableSupportState(permission);
       }
@@ -51,7 +51,7 @@ export function createPermissionClient(): PermissionClient {
         return createNotRequiredState(permission);
       }
 
-      const adapter = adapters[permission];
+      const adapter = adapters.get(permission);
       if (!adapter) {
         throw new Error(`No adapter registered for permission: ${permission}`);
       }
@@ -60,7 +60,7 @@ export function createPermissionClient(): PermissionClient {
     },
 
     async request(permission: Permission): Promise<PermissionState> {
-      const metadata = EXPO_PERMISSION_SUPPORT[permission];
+      const metadata = getPermissionSupport(permission);
       if (metadata.support === 'unsupported' || metadata.support === 'notImplemented') {
         return createUnavailableSupportState(permission);
       }
@@ -69,7 +69,7 @@ export function createPermissionClient(): PermissionClient {
         return createNotRequiredState(permission);
       }
 
-      const adapter = adapters[permission];
+      const adapter = adapters.get(permission);
       if (!adapter) {
         throw new Error(`No adapter registered for permission: ${permission}`);
       }
@@ -91,6 +91,10 @@ export function createPermissionClient(): PermissionClient {
   };
 }
 
+function getPermissionSupport(permission: Permission) {
+  return Reflect.get(EXPO_PERMISSION_SUPPORT, permission);
+}
+
 function createUnavailableSupportState(permission: Permission): PermissionState {
   return createPermissionState({
     permission,

package/src/expo/manifest.test.ts

@@ -1,69 +1,67 @@
 import { readFileSync } from 'node:fs';
 
-import { describe, expect, test } from 'bun:test';
+import { expect, test } from 'bun:test';
 
 import { Permission, PERMISSIONS } from '../registry/permissions';
 import { EXPO_PERMISSION_CLIENT_REQUIRED_PACKAGES, EXPO_PERMISSION_SUPPORT } from './manifest';
 
-describe('EXPO_PERMISSION_SUPPORT', () => {
-  test('defines metadata for every known permission', () => {
-    expect(Object.keys(EXPO_PERMISSION_SUPPORT).sort()).toEqual([...PERMISSIONS].sort());
-  });
-
-  test('stays metadata-only and does not import Expo runtime modules', () => {
-    const source = readFileSync(new URL('./manifest.ts', import.meta.url), 'utf8');
+test('defines metadata for every known permission', () => {
+  expect(Object.keys(EXPO_PERMISSION_SUPPORT).sort()).toEqual([...PERMISSIONS].sort());
+});
 
-    expect(source).not.toContain("from 'expo-");
-    expect(source).not.toContain('await import(');
-  });
+test('stays metadata-only and does not import Expo runtime modules', () => {
+  const source = readFileSync(new URL('./manifest.ts', import.meta.url), 'utf8');
 
-  test('projects client-level settings recovery dependencies', () => {
-    expect(EXPO_PERMISSION_CLIENT_REQUIRED_PACKAGES).toEqual(['expo-linking']);
-  });
+  expect(source).not.toContain("from 'expo-");
+  expect(source).not.toContain('await import(');
+});
 
-  test('includes package and config hints for camera, microphone, and location permissions', () => {
-    expect(EXPO_PERMISSION_SUPPORT[Permission.Camera]).toEqual({
-      support: 'supported',
-      requiredPackages: ['expo-camera'],
-      configHints: ['cameraPermission'],
-    });
+test('projects client-level settings recovery dependencies', () => {
+  expect(EXPO_PERMISSION_CLIENT_REQUIRED_PACKAGES).toEqual(['expo-linking']);
+});
 
-    expect(EXPO_PERMISSION_SUPPORT[Permission.Microphone]).toEqual({
-      support: 'supported',
-      requiredPackages: ['expo-audio'],
-      configHints: ['microphonePermission', 'recordAudioAndroid'],
-    });
+test('includes package and config hints for camera, microphone, and location permissions', () => {
+  expect(EXPO_PERMISSION_SUPPORT[Permission.Camera]).toEqual({
+    support: 'supported',
+    requiredPackages: ['expo-camera'],
+    configHints: ['cameraPermission'],
+  });
 
-    expect(EXPO_PERMISSION_SUPPORT[Permission.LocationForeground]).toEqual({
-      support: 'supported',
-      requiredPackages: ['expo-location'],
-      configHints: ['locationWhenInUsePermission'],
-    });
+  expect(EXPO_PERMISSION_SUPPORT[Permission.Microphone]).toEqual({
+    support: 'supported',
+    requiredPackages: ['expo-audio'],
+    configHints: ['microphonePermission', 'recordAudioAndroid'],
+  });
 
-    expect(EXPO_PERMISSION_SUPPORT[Permission.LocationBackground]).toEqual({
-      support: 'supported',
-      requiredPackages: ['expo-location'],
-      configHints: ['locationAlwaysAndWhenInUsePermission'],
-    });
+  expect(EXPO_PERMISSION_SUPPORT[Permission.LocationForeground]).toEqual({
+    support: 'supported',
+    requiredPackages: ['expo-location'],
+    configHints: ['locationWhenInUsePermission'],
   });
 
-  test('treats clipboard as a not-required permission without runtime package requirements', () => {
-    expect(EXPO_PERMISSION_SUPPORT[Permission.Clipboard]).toEqual({
-      support: 'notRequired',
-      requiredPackages: [],
-      configHints: [],
-    });
+  expect(EXPO_PERMISSION_SUPPORT[Permission.LocationBackground]).toEqual({
+    support: 'supported',
+    requiredPackages: ['expo-location'],
+    configHints: ['locationAlwaysAndWhenInUsePermission'],
   });
+});
 
-  test('keeps MediaLibraryWrite aligned with MediaLibrary metadata', () => {
-    expect(EXPO_PERMISSION_SUPPORT[Permission.MediaLibraryWrite]).toEqual({
-      support: 'supported',
-      requiredPackages: ['expo-media-library'],
-      configHints: ['mediaLibraryPermission'],
-    });
+test('treats clipboard as a not-required permission without runtime package requirements', () => {
+  expect(EXPO_PERMISSION_SUPPORT[Permission.Clipboard]).toEqual({
+    support: 'notRequired',
+    requiredPackages: [],
+    configHints: [],
+  });
+});
 
-    expect(EXPO_PERMISSION_SUPPORT[Permission.MediaLibraryWrite]).toEqual(
-      EXPO_PERMISSION_SUPPORT[Permission.MediaLibrary],
-    );
+test('keeps MediaLibraryWrite aligned with MediaLibrary metadata', () => {
+  expect(EXPO_PERMISSION_SUPPORT[Permission.MediaLibraryWrite]).toEqual({
+    support: 'supported',
+    requiredPackages: ['expo-media-library'],
+    configHints: ['mediaLibraryPermission'],
   });
+
+  expect(EXPO_PERMISSION_SUPPORT[Permission.MediaLibraryWrite]).toEqual(
+    EXPO_PERMISSION_SUPPORT[Permission.MediaLibrary],
+  );
 });

package/src/expo/manifest.ts

@@ -1,11 +1,7 @@
 import { Permission } from '../registry/permissions';
 
 export type PermissionSupport =
-  | 'supported'
-  | 'notRequired'
-  | 'limited'
-  | 'notImplemented'
-  | 'unsupported';
+  'supported' | 'notRequired' | 'limited' | 'notImplemented' | 'unsupported';
 
 export interface ExpoPermissionMetadata {
   readonly support: PermissionSupport;

package/src/expo/permissionResponse.ts

@@ -39,7 +39,7 @@ export function findExpoPermissionMethod(
   containerNames: readonly string[] = [],
 ): ExpoPermissionMethod | undefined {
   if (hasExpoPermissionMethod(source, methodName)) {
-    return source[methodName];
+    return Reflect.get(source, methodName);
   }
 
   if (!isRecord(source)) {
@@ -47,10 +47,10 @@ export function findExpoPermissionMethod(
   }
 
   for (const containerName of containerNames) {
-    const container = source[containerName];
+    const container = Reflect.get(source, containerName);
 
     if (hasExpoPermissionMethod(container, methodName)) {
-      return container[methodName];
+      return Reflect.get(container, methodName);
     }
   }
 
@@ -93,7 +93,7 @@ function hasExpoPermissionMethod(
   value: unknown,
   methodName: string,
 ): value is Record<string, ExpoPermissionMethod> {
-  return isRecord(value) && typeof value[methodName] === 'function';
+  return isRecord(value) && typeof Reflect.get(value, methodName) === 'function';
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

package/src/manager/createPermissionManager.test.ts

@@ -1,67 +1,65 @@
-import { describe, expect, test } from 'bun:test';
+import { expect, test } from 'bun:test';
 
 import { Permission } from '../registry/permissions';
 import { createFakePermissionClient } from '../testing/index';
 import { createPermissionManager } from './createPermissionManager';
 
-describe('createPermissionManager', () => {
-  test('normalizes getStatus results', async () => {
-    const manager = createPermissionManager(
-      createFakePermissionClient({
-        initialStates: [
-          {
-            permission: Permission.Camera,
-            status: 'granted',
-          },
-        ],
-      }),
-    );
+test('normalizes getStatus results', async () => {
+  const manager = createPermissionManager(
+    createFakePermissionClient({
+      initialStates: [
+        {
+          permission: Permission.Camera,
+          status: 'granted',
+        },
+      ],
+    }),
+  );
 
-    const state = await manager.getStatus(Permission.Camera);
+  const state = await manager.getStatus(Permission.Camera);
 
-    expect(state).toMatchObject({
-      permission: Permission.Camera,
-      status: 'granted',
-      granted: true,
-    });
+  expect(state).toMatchObject({
+    permission: Permission.Camera,
+    status: 'granted',
+    granted: true,
   });
+});
 
-  test('does not throw for normal denial', async () => {
-    const manager = createPermissionManager(
-      createFakePermissionClient({
-        requestStates: [
-          {
-            permission: Permission.Notifications,
-            status: 'denied',
-            canAskAgain: false,
-          },
-        ],
-      }),
-    );
+test('does not throw for normal denial', async () => {
+  const manager = createPermissionManager(
+    createFakePermissionClient({
+      requestStates: [
+        {
+          permission: Permission.Notifications,
+          status: 'denied',
+          canAskAgain: false,
+        },
+      ],
+    }),
+  );
 
-    const state = await manager.request(Permission.Notifications);
+  const state = await manager.request(Permission.Notifications);
 
-    expect(state).toMatchObject({
-      status: 'denied',
-      granted: false,
-      canAskAgain: false,
-    });
+  expect(state).toMatchObject({
+    status: 'denied',
+    granted: false,
+    canAskAgain: false,
   });
+});
 
-  test('exposes openSettings only when the client supports it', async () => {
-    let opened = false;
-    const manager = createPermissionManager(
-      createFakePermissionClient({
-        openSettings: () => {
-          opened = true;
+test('exposes openSettings only when the client supports it', async () => {
+  let opened = false;
+  const manager = createPermissionManager(
+    createFakePermissionClient({
+      openSettings: () => {
+        opened = true;
 
-          return Promise.resolve();
-        },
-      }),
-    );
+        return Promise.resolve();
+      },
+    }),
+  );
 
-    await manager.openSettings?.();
+  await manager.openSettings?.();
 
-    expect(opened).toBe(true);
-  });
+  expect(opened).toBe(true);
 });

package/src/react/index.tsx

@@ -105,15 +105,8 @@ export function usePermission(
   options: UsePermissionOptions = {},
 ): PermissionHookResult {
   const manager = usePermissions();
-  const [state, setState] = useState<PermissionState>(
-    () =>
-      (options.initialState === undefined
-        ? undefined
-        : normalizePermissionState(permission, options.initialState)) ??
-      createPermissionState({
-        permission,
-        status: 'unknown',
-      }),
+  const [state, setState] = useState<PermissionState>(() =>
+    createInitialPermissionState(permission, options.initialState),
   );
 
   const refresh = useCallback(async () => {
@@ -131,10 +124,15 @@ export function usePermission(
   }, [manager, permission]);
 
   useEffect(() => {
-    if (options.refreshOnMount === true) {
-      void refresh();
-    }
-  }, [options.refreshOnMount, refresh]);
+    if (options.refreshOnMount !== true) return;
+    let active = true;
+    void manager.getStatus(permission).then((nextState) => {
+      if (active) setState(nextState);
+    });
+    return () => {
+      active = false;
+    };
+  }, [manager, options.refreshOnMount, permission]);
 
   const openSettings =
     manager.openSettings === undefined
@@ -154,3 +152,13 @@ export function usePermission(
     openSettings,
   };
 }
+
+function createInitialPermissionState(
+  permission: Permission,
+  initialState: PermissionState | undefined,
+): PermissionState {
+  return (
+    (initialState === undefined ? undefined : normalizePermissionState(permission, initialState)) ??
+    createPermissionState({ permission, status: 'unknown' })
+  );
+}

package/src/registry/permissions.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'bun:test';
 
+import packageJson from '../../package.json';
 import {
   getPermissionDefinition,
   isPermission,
@@ -24,12 +25,23 @@ describe('permission registry', () => {
 
   test('exposes metadata for every permission', () => {
     for (const permission of PERMISSIONS) {
-      expect(PERMISSION_REGISTRY[permission].permission).toBe(permission);
-      expect(PERMISSION_REGISTRY[permission].label.length).toBeGreaterThan(0);
-      expect(getPermissionDefinition(permission)).toEqual(PERMISSION_REGISTRY[permission]);
+      const definition = Reflect.get(PERMISSION_REGISTRY, permission);
+      expect(definition.permission).toBe(permission);
+      expect(definition.label.length).toBeGreaterThan(0);
+      expect(getPermissionDefinition(permission)).toEqual(definition);
     }
   });
 
+  test('publishes the registry as a dedicated headless subpath', () => {
+    expect(packageJson.exports['./registry']).toEqual({
+      'react-native': './dist/registry/permissions.js',
+      browser: './dist/registry/permissions.js',
+      types: './dist/registry/permissions.d.ts',
+      import: './dist/registry/permissions.js',
+      default: './dist/registry/permissions.js',
+    });
+  });
+
   test('validates permission strings', () => {
     expect(isPermission('camera')).toBe(true);
     expect(isPermission('not-a-permission')).toBe(false);

package/src/state/permissionState.ts

@@ -7,12 +7,7 @@ import type { Permission } from '../registry/permissions';
  * but user denial should be represented as a permission state.
  */
 export type PermissionStatus =
-  | 'unknown'
-  | 'granted'
-  | 'denied'
-  | 'blocked'
-  | 'limited'
-  | 'unavailable';
+  'unknown' | 'granted' | 'denied' | 'blocked' | 'limited' | 'unavailable';
 
 /***
  * Stable ordered list of normalized statuses.