@ankhorage/permissions 0.2.3 → 0.2.5

package/src/testing/index.ts

@@ -45,6 +45,12 @@ export interface FakePermissionClient extends PermissionClient {
   getSnapshot(): readonly PermissionState[];
 }
 
+interface FakePermissionContext {
+  readonly now: () => Date;
+  readonly requestStates: Map<Permission, PermissionState>;
+  readonly states: Map<Permission, PermissionState>;
+}
+
 /***
  * Creates a deterministic in-memory client for tests and examples.
  *
@@ -55,12 +61,21 @@ export interface FakePermissionClient extends PermissionClient {
 export function createFakePermissionClient(
   options: FakePermissionClientOptions = {},
 ): FakePermissionClient {
-  const now = options.now ?? (() => new Date());
-  const states = new Map<Permission, PermissionState>();
-  const requestStates = new Map<Permission, PermissionState>();
+  const context = createFakePermissionContext(options);
+  const client = createFakePermissionOperations(context, options.openSettings);
+  if (options.openSettings === undefined) delete client.openSettings;
+  return client;
+}
+
+function createFakePermissionContext(options: FakePermissionClientOptions): FakePermissionContext {
+  const context: FakePermissionContext = {
+    now: options.now ?? (() => new Date()),
+    states: new Map<Permission, PermissionState>(),
+    requestStates: new Map<Permission, PermissionState>(),
+  };
 
   for (const permission of PERMISSIONS) {
-    states.set(
+    context.states.set(
       permission,
       createPermissionState({
         permission,
@@ -71,45 +86,47 @@ export function createFakePermissionClient(
   }
 
   for (const state of options.initialStates ?? []) {
-    states.set(state.permission, normalizeSeed(state));
+    context.states.set(state.permission, normalizeSeed(state));
   }
 
   for (const state of options.requestStates ?? []) {
-    requestStates.set(state.permission, normalizeSeed(state));
+    context.requestStates.set(state.permission, normalizeSeed(state));
   }
+  return context;
+}
 
+function createFakePermissionOperations(
+  context: FakePermissionContext,
+  openSettings: (() => Promise<void>) | undefined,
+): FakePermissionClient {
   const client: FakePermissionClient = {
     getStatus(permission) {
-      return Promise.resolve(getStoredState(states, assertKnownPermission(permission)));
+      return Promise.resolve(getStoredState(context.states, assertKnownPermission(permission)));
     },
-
     request(permission) {
       const knownPermission = assertKnownPermission(permission);
       const requestState =
-        requestStates.get(knownPermission) ?? getStoredState(states, knownPermission);
+        context.requestStates.get(knownPermission) ??
+        getStoredState(context.states, knownPermission);
       const nextState = createPermissionState({
         permission: knownPermission,
         status: requestState.status,
         canAskAgain: requestState.canAskAgain,
-        requestedAt: now(),
+        requestedAt: context.now(),
         reason: requestState.reason,
       });
 
-      states.set(knownPermission, nextState);
-
+      context.states.set(knownPermission, nextState);
       return Promise.resolve(nextState);
     },
-
-    openSettings: options.openSettings,
-
+    openSettings,
     setState(state) {
       const normalizedState = normalizeSeed(state);
-      states.set(normalizedState.permission, normalizedState);
+      context.states.set(normalizedState.permission, normalizedState);
     },
-
     setStatus(permission, status, statusOptions = {}) {
       const knownPermission = assertKnownPermission(permission);
-      states.set(
+      context.states.set(
         knownPermission,
         createPermissionState({
           permission: knownPermission,
@@ -119,16 +136,10 @@ export function createFakePermissionClient(
         }),
       );
     },
-
     getSnapshot() {
-      return PERMISSIONS.map((permission) => getStoredState(states, permission));
+      return PERMISSIONS.map((permission) => getStoredState(context.states, permission));
     },
   };
-
-  if (options.openSettings === undefined) {
-    delete client.openSettings;
-  }
-
   return client;
 }
 

package/src/web/index.test.ts

@@ -1,205 +1,203 @@
-import { describe, expect, test } from 'bun:test';
+import { expect, test } from 'bun:test';
 
 import { Permission } from '../registry/permissions';
 import { createWebPermissionClient, type WebPermissionClientOptions } from './index';
 
-describe('createWebPermissionClient', () => {
-  test('returns unavailable for unsupported web permissions', async () => {
-    const client = createWebPermissionClient({ global: {} });
+test('returns unavailable for unsupported web permissions', async () => {
+  const client = createWebPermissionClient({ global: {} });
 
-    const state = await client.getStatus(Permission.MediaLibrary);
+  const state = await client.getStatus(Permission.MediaLibrary);
 
-    expect(state).toMatchObject({
-      status: 'unavailable',
-      canAskAgain: false,
-    });
+  expect(state).toMatchObject({
+    status: 'unavailable',
+    canAskAgain: false,
   });
+});
 
-  test('reads notification permission structurally', async () => {
-    const client = createWebPermissionClient({
-      global: {
-        Notification: {
-          permission: 'granted',
-          requestPermission: () => 'granted',
-        },
+test('reads notification permission structurally', async () => {
+  const client = createWebPermissionClient({
+    global: {
+      Notification: {
+        permission: 'granted',
+        requestPermission: () => 'granted',
       },
-    });
+    },
+  });
 
-    const state = await client.getStatus(Permission.Notifications);
+  const state = await client.getStatus(Permission.Notifications);
 
-    expect(state).toMatchObject({
-      status: 'granted',
-      granted: true,
-    });
+  expect(state).toMatchObject({
+    status: 'granted',
+    granted: true,
   });
+});
 
-  test('requests notifications without throwing on denial', async () => {
-    const client = createWebPermissionClient({
-      global: {
-        Notification: {
-          permission: 'default',
-          requestPermission: () => Promise.resolve('denied'),
-        },
+test('requests notifications without throwing on denial', async () => {
+  const client = createWebPermissionClient({
+    global: {
+      Notification: {
+        permission: 'default',
+        requestPermission: () => Promise.resolve('denied'),
       },
-    });
+    },
+  });
 
-    const state = await client.request(Permission.Notifications);
+  const state = await client.request(Permission.Notifications);
 
-    expect(state).toMatchObject({
-      status: 'denied',
-      granted: false,
-    });
+  expect(state).toMatchObject({
+    status: 'denied',
+    granted: false,
   });
+});
 
-  test('returns unavailable when notification request throws', async () => {
-    const client = createWebPermissionClient({
-      global: {
-        Notification: {
-          permission: 'default',
-          requestPermission: () => {
-            throw Object.assign(new Error('blocked'), { name: 'SecurityError' });
-          },
+test('returns unavailable when notification request throws', async () => {
+  const client = createWebPermissionClient({
+    global: {
+      Notification: {
+        permission: 'default',
+        requestPermission: () => {
+          throw Object.assign(new Error('blocked'), { name: 'SecurityError' });
         },
       },
-    });
+    },
+  });
 
-    const state = await client.request(Permission.Notifications);
+  const state = await client.request(Permission.Notifications);
 
-    expect(state).toMatchObject({
-      status: 'unavailable',
-      granted: false,
-      reason: 'Notification permission request failed: SecurityError.',
-    });
+  expect(state).toMatchObject({
+    status: 'unavailable',
+    granted: false,
+    reason: 'Notification permission request failed: SecurityError.',
   });
+});
 
-  test('uses Permissions API for location status when available', async () => {
-    const client = createWebPermissionClient({
-      global: {
-        navigator: {
-          permissions: {
-            query: () => Promise.resolve({ state: 'prompt' }),
-          },
+test('uses Permissions API for location status when available', async () => {
+  const client = createWebPermissionClient({
+    global: {
+      navigator: {
+        permissions: {
+          query: () => Promise.resolve({ state: 'prompt' }),
         },
       },
-    });
+    },
+  });
 
-    const state = await client.getStatus(Permission.LocationForeground);
+  const state = await client.getStatus(Permission.LocationForeground);
 
-    expect(state).toMatchObject({
-      status: 'unknown',
-      canAskAgain: true,
-    });
+  expect(state).toMatchObject({
+    status: 'unknown',
+    canAskAgain: true,
   });
+});
 
-  test('returns blocked for media in insecure contexts', async () => {
-    const client = createWebPermissionClient({
-      global: {
-        isSecureContext: false,
-      },
-    });
-
-    const state = await client.getStatus(Permission.Camera);
-
-    expect(state).toMatchObject({
-      status: 'blocked',
-      canAskAgain: false,
-    });
-  });
-
-  test('requests geolocation without a 1ms timeout', async () => {
-    let requestedOptions:
-      | {
-          readonly maximumAge?: number;
-          readonly timeout?: number;
-        }
-      | undefined;
-    const client = createWebPermissionClient({
-      global: {
-        navigator: {
-          geolocation: {
-            getCurrentPosition: (success, _error, options) => {
-              requestedOptions = options;
-              success();
-            },
+test('returns blocked for media in insecure contexts', async () => {
+  const client = createWebPermissionClient({
+    global: {
+      isSecureContext: false,
+    },
+  });
+
+  const state = await client.getStatus(Permission.Camera);
+
+  expect(state).toMatchObject({
+    status: 'blocked',
+    canAskAgain: false,
+  });
+});
+
+test('requests geolocation without a 1ms timeout', async () => {
+  let requestedOptions:
+    | {
+        readonly maximumAge?: number;
+        readonly timeout?: number;
+      }
+    | undefined;
+  const client = createWebPermissionClient({
+    global: {
+      navigator: {
+        geolocation: {
+          getCurrentPosition: (success, _error, options) => {
+            requestedOptions = options;
+            success();
           },
         },
       },
-    });
+    },
+  });
 
-    const state = await client.request(Permission.LocationForeground);
+  const state = await client.request(Permission.LocationForeground);
 
-    expect(state.status).toBe('granted');
-    expect(requestedOptions).toEqual({ maximumAge: 0 });
-  });
+  expect(state.status).toBe('granted');
+  expect(requestedOptions).toEqual({ maximumAge: 0 });
+});
 
-  test('requests media with getUserMedia and stops tracks', async () => {
-    let stopped = false;
-    const global: WebPermissionClientOptions['global'] = {
-      navigator: {
-        mediaDevices: {
-          getUserMedia: () =>
-            Promise.resolve({
-              getTracks: () => [
-                {
-                  stop: () => {
-                    stopped = true;
-                  },
+test('requests media with getUserMedia and stops tracks', async () => {
+  let stopped = false;
+  const global: WebPermissionClientOptions['global'] = {
+    navigator: {
+      mediaDevices: {
+        getUserMedia: () =>
+          Promise.resolve({
+            getTracks: () => [
+              {
+                stop: () => {
+                  stopped = true;
                 },
-              ],
-            }),
-        },
+              },
+            ],
+          }),
       },
-    };
-    const client = createWebPermissionClient({ global });
+    },
+  };
+  const client = createWebPermissionClient({ global });
 
-    const state = await client.request(Permission.Microphone);
+  const state = await client.request(Permission.Microphone);
 
-    expect(state).toMatchObject({
-      status: 'granted',
-      granted: true,
-    });
-    expect(stopped).toBe(true);
+  expect(state).toMatchObject({
+    status: 'granted',
+    granted: true,
   });
+  expect(stopped).toBe(true);
+});
 
-  test('maps missing media devices to unavailable', async () => {
-    const client = createWebPermissionClient({
-      global: {
-        navigator: {
-          mediaDevices: {
-            getUserMedia: () =>
-              Promise.reject(Object.assign(new Error('missing'), { name: 'NotFoundError' })),
-          },
+test('maps missing media devices to unavailable', async () => {
+  const client = createWebPermissionClient({
+    global: {
+      navigator: {
+        mediaDevices: {
+          getUserMedia: () =>
+            Promise.reject(Object.assign(new Error('missing'), { name: 'NotFoundError' })),
         },
       },
-    });
+    },
+  });
 
-    const state = await client.request(Permission.Camera);
+  const state = await client.request(Permission.Camera);
 
-    expect(state).toMatchObject({
-      status: 'unavailable',
-      granted: false,
-      reason: 'Media permission request failed: NotFoundError.',
-    });
+  expect(state).toMatchObject({
+    status: 'unavailable',
+    granted: false,
+    reason: 'Media permission request failed: NotFoundError.',
   });
+});
 
-  test('maps user media denial to denied', async () => {
-    const client = createWebPermissionClient({
-      global: {
-        navigator: {
-          mediaDevices: {
-            getUserMedia: () =>
-              Promise.reject(Object.assign(new Error('denied'), { name: 'NotAllowedError' })),
-          },
+test('maps user media denial to denied', async () => {
+  const client = createWebPermissionClient({
+    global: {
+      navigator: {
+        mediaDevices: {
+          getUserMedia: () =>
+            Promise.reject(Object.assign(new Error('denied'), { name: 'NotAllowedError' })),
         },
       },
-    });
+    },
+  });
 
-    const state = await client.request(Permission.Camera);
+  const state = await client.request(Permission.Camera);
 
-    expect(state).toMatchObject({
-      status: 'denied',
-      granted: false,
-      reason: 'Media permission request was denied: NotAllowedError.',
-    });
+  expect(state).toMatchObject({
+    status: 'denied',
+    granted: false,
+    reason: 'Media permission request was denied: NotAllowedError.',
   });
 });

package/src/web/index.ts

@@ -1,15 +1,17 @@
 import type { PermissionClient } from '../client/types';
 import { assertKnownPermission, Permission } from '../registry/permissions';
+import { createPermissionState, type PermissionState } from '../state/permissionState';
 import {
-  createPermissionState,
-  type PermissionState,
-  type PermissionStatus,
-} from '../state/permissionState';
+  type BrowserPermissionState,
+  formatErrorName,
+  type NotificationPermissionState,
+  stateFromBrowserPermission,
+  stateFromMediaError,
+  stateFromNotificationPermission,
+  unavailable,
+} from './permissionStates';
 
 type BrowserPermissionName = 'camera' | 'microphone' | 'geolocation' | 'notifications';
-type BrowserPermissionState = 'granted' | 'denied' | 'prompt';
-type NotificationPermissionState = 'default' | 'denied' | 'granted';
-
 interface BrowserPermissionStatus {
   readonly state: BrowserPermissionState;
 }
@@ -293,98 +295,3 @@ async function requestMedia(
     return stateFromMediaError(permission, error);
   }
 }
-
-function stateFromMediaError(permission: Permission, error: unknown): PermissionState {
-  const errorName = getErrorName(error);
-  const unavailableErrorNames = new Set([
-    'AbortError',
-    'NotFoundError',
-    'NotReadableError',
-    'OverconstrainedError',
-    'SecurityError',
-  ]);
-
-  if (errorName !== undefined && unavailableErrorNames.has(errorName)) {
-    return createPermissionState({
-      permission,
-      status: 'unavailable',
-      canAskAgain: false,
-      requestedAt: new Date(),
-      reason: `Media permission request failed: ${errorName}.`,
-    });
-  }
-
-  return createPermissionState({
-    permission,
-    status: 'denied',
-    canAskAgain: false,
-    requestedAt: new Date(),
-    reason:
-      errorName === undefined
-        ? 'Media permission request was denied.'
-        : `Media permission request was denied: ${errorName}.`,
-  });
-}
-
-function stateFromNotificationPermission(
-  permission: Permission,
-  status: NotificationPermissionState,
-): PermissionState {
-  if (status === 'granted') {
-    return createPermissionState({
-      permission,
-      status: 'granted',
-      canAskAgain: true,
-    });
-  }
-
-  if (status === 'denied') {
-    return createPermissionState({
-      permission,
-      status: 'denied',
-      canAskAgain: false,
-    });
-  }
-
-  return createPermissionState({
-    permission,
-    status: 'unknown',
-    canAskAgain: true,
-  });
-}
-
-function stateFromBrowserPermission(
-  permission: Permission,
-  status: BrowserPermissionState,
-): PermissionState {
-  const normalizedStatus: PermissionStatus = status === 'prompt' ? 'unknown' : status;
-
-  return createPermissionState({
-    permission,
-    status: normalizedStatus,
-    canAskAgain: status === 'prompt' || status === 'granted',
-  });
-}
-
-function unavailable(permission: Permission, reason: string): PermissionState {
-  return createPermissionState({
-    permission,
-    status: 'unavailable',
-    canAskAgain: false,
-    reason,
-  });
-}
-
-function formatErrorName(error: unknown): string {
-  const errorName = getErrorName(error);
-
-  return errorName === undefined ? '' : `: ${errorName}`;
-}
-
-function getErrorName(error: unknown): string | undefined {
-  if (typeof error !== 'object' || error === null || !('name' in error)) {
-    return undefined;
-  }
-
-  return typeof error.name === 'string' && error.name.length > 0 ? error.name : undefined;
-}

package/src/web/permissionStates.ts

@@ -0,0 +1,83 @@
+import type { Permission } from '../registry/permissions';
+import {
+  createPermissionState,
+  type PermissionState,
+  type PermissionStatus,
+} from '../state/permissionState';
+
+export type BrowserPermissionState = 'granted' | 'denied' | 'prompt';
+export type NotificationPermissionState = 'default' | 'denied' | 'granted';
+
+export function stateFromMediaError(permission: Permission, error: unknown): PermissionState {
+  const errorName = getErrorName(error);
+  const unavailableErrorNames = new Set([
+    'AbortError',
+    'NotFoundError',
+    'NotReadableError',
+    'OverconstrainedError',
+    'SecurityError',
+  ]);
+  if (errorName !== undefined && unavailableErrorNames.has(errorName)) {
+    return createPermissionState({
+      permission,
+      status: 'unavailable',
+      canAskAgain: false,
+      requestedAt: new Date(),
+      reason: `Media permission request failed: ${errorName}.`,
+    });
+  }
+  return createPermissionState({
+    permission,
+    status: 'denied',
+    canAskAgain: false,
+    requestedAt: new Date(),
+    reason:
+      errorName === undefined
+        ? 'Media permission request was denied.'
+        : `Media permission request was denied: ${errorName}.`,
+  });
+}
+
+export function stateFromNotificationPermission(
+  permission: Permission,
+  status: NotificationPermissionState,
+): PermissionState {
+  if (status === 'granted') {
+    return createPermissionState({ permission, status: 'granted', canAskAgain: true });
+  }
+  if (status === 'denied') {
+    return createPermissionState({ permission, status: 'denied', canAskAgain: false });
+  }
+  return createPermissionState({ permission, status: 'unknown', canAskAgain: true });
+}
+
+export function stateFromBrowserPermission(
+  permission: Permission,
+  status: BrowserPermissionState,
+): PermissionState {
+  const normalizedStatus: PermissionStatus = status === 'prompt' ? 'unknown' : status;
+  return createPermissionState({
+    permission,
+    status: normalizedStatus,
+    canAskAgain: status === 'prompt' || status === 'granted',
+  });
+}
+
+export function unavailable(permission: Permission, reason: string): PermissionState {
+  return createPermissionState({
+    permission,
+    status: 'unavailable',
+    canAskAgain: false,
+    reason,
+  });
+}
+
+export function formatErrorName(error: unknown): string {
+  const errorName = getErrorName(error);
+  return errorName === undefined ? '' : `: ${errorName}`;
+}
+
+function getErrorName(error: unknown): string | undefined {
+  if (typeof error !== 'object' || error === null || !('name' in error)) return undefined;
+  return typeof error.name === 'string' && error.name.length > 0 ? error.name : undefined;
+}