@ankhorage/permissions 0.1.1 → 0.2.0

package/src/expo/permissionResponse.ts

@@ -0,0 +1,84 @@
+import type { Permission } from '../registry/permissions';
+import {
+  createPermissionState,
+  isPermissionStatus,
+  type PermissionState,
+} from '../state/permissionState';
+
+export interface ExpoPermissionResponse {
+  readonly status: string;
+  readonly canAskAgain?: boolean;
+}
+
+export type ExpoPermissionMethod = () => Promise<ExpoPermissionResponse>;
+
+export function createExpoPermissionState(
+  permission: Permission,
+  response: ExpoPermissionResponse,
+): PermissionState {
+  const status = isPermissionStatus(response.status) ? response.status : 'unknown';
+
+  return createPermissionState({
+    permission,
+    status,
+    canAskAgain: response.canAskAgain,
+  });
+}
+
+export function createExpoUnavailableState(
+  permission: Permission,
+  error: unknown,
+): PermissionState {
+  return createPermissionState({
+    permission,
+    status: 'unavailable',
+    reason: getExpoPermissionErrorMessage(error),
+  });
+}
+
+export function findExpoPermissionMethod(
+  source: unknown,
+  methodName: string,
+  containerNames: readonly string[] = [],
+): ExpoPermissionMethod | undefined {
+  if (hasExpoPermissionMethod(source, methodName)) {
+    return source[methodName];
+  }
+
+  if (!isRecord(source)) {
+    return undefined;
+  }
+
+  for (const containerName of containerNames) {
+    const container = source[containerName];
+
+    if (hasExpoPermissionMethod(container, methodName)) {
+      return container[methodName];
+    }
+  }
+
+  return undefined;
+}
+
+function getExpoPermissionErrorMessage(error: unknown): string {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+
+  if (typeof error === 'string' && error.length > 0) {
+    return error;
+  }
+
+  return 'Expo permission operation failed.';
+}
+
+function hasExpoPermissionMethod(
+  value: unknown,
+  methodName: string,
+): value is Record<string, ExpoPermissionMethod> {
+  return isRecord(value) && typeof value[methodName] === 'function';
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}

package/src/manager/createPermissionManager.ts

@@ -3,7 +3,7 @@ import { assertKnownPermission, type Permission } from '../registry/permissions'
 import { normalizePermissionState, type PermissionState } from '../state/permissionState';
 
 /***
- * Public manager returned by `createPermissionManager`.
+ * Public facade for checking and requesting normalized permission state.
  */
 export interface PermissionManager {
   getStatus(permission: Permission): Promise<PermissionState>;
@@ -12,22 +12,11 @@ export interface PermissionManager {
 }
 
 /***
- * Wraps a client with registry validation and normalized results.
+ * Creates a permission manager from a runtime-specific client.
  *
  * @readme
- * Runtime permissions and build-time native configuration are separate concerns.
- * This manager checks or requests permissions through a client, but it does not
- * generate iOS usage descriptions, Android manifest entries, or Expo config
- * plugins.
- *
- * @usage
- * ```ts
- * const permissions = createPermissionManager(client);
- * const camera = await permissions.getStatus(Permission.Camera);
- * const requested = camera.granted
- *   ? camera
- *   : await permissions.request(Permission.Camera);
- * ```
+ * The manager validates permission names and normalizes client results.
+ * Native app configuration remains a separate build-time concern.
  */
 export function createPermissionManager(client: PermissionClient): PermissionManager {
   const manager: PermissionManager = {

package/src/react/index.tsx

@@ -99,20 +99,6 @@ export function usePermissions(): PermissionManager {
 
 /***
  * Tracks a single permission and exposes explicit refresh/request actions.
- *
- * @usage
- * ```tsx
- * const camera = usePermission(Permission.Camera, { refreshOnMount: true });
- *
- * return (
- *   <Button
- *     disabled={camera.granted}
- *     onPress={() => {
- *       void camera.request();
- *     }}
- *   />
- * );
- * ```
  */
 export function usePermission(
   permission: Permission,

package/src/testing/index.ts

@@ -51,14 +51,6 @@ export interface FakePermissionClient extends PermissionClient {
  * @readme
  * Fake clients make permission flows testable without native devices, browser
  * prompts, simulators, or network access.
- *
- * @usage
- * ```ts
- * const client = createFakePermissionClient({
- *   initialStates: [{ permission: Permission.Camera, status: 'denied' }],
- * });
- * await client.request(Permission.Camera);
- * ```
  */
 export function createFakePermissionClient(
   options: FakePermissionClientOptions = {},