@ankhorage/expo-runtime 2.6.0 → 2.7.0

package/src/resolveExpoRuntimePlan.ts

@@ -11,6 +11,24 @@ import {
   type PermissionSupport,
 } from '@ankhorage/permissions/expo/manifest';
 
+import {
+  EXPO_CAPABILITY_RUNTIME_REGISTRY,
+  EXPO_RUNTIME_PROVIDER_PACKAGES,
+  type ExpoRuntimeAdapterId,
+  type ExpoRuntimeCapabilityMetadata,
+  type ExpoRuntimeConfigPlugin,
+  type ExpoRuntimeDiagnostic,
+  type ExpoRuntimeProviderId,
+  findCapabilityMetadata,
+  findConfigHintMetadata,
+  GENERATED_RUNTIME_DEPENDENCY_VERSIONS,
+  unknownCapabilityDiagnostic,
+  unknownPermissionDiagnostic,
+  unsupportedPermissionDiagnostic,
+} from './expoRuntimePlanningMetadata';
+
+export type { ExpoRuntimeAdapterId, ExpoRuntimeProviderId };
+
 export interface ExpoRuntimePlanningScreen {
   readonly requires?: {
     readonly capabilities?: readonly ScreenCapabilityRequirement[];
@@ -28,22 +46,6 @@ interface ExpoRuntimeDependency {
   readonly reasons: readonly string[];
 }
 
-interface ExpoRuntimeConfigPlugin {
-  readonly name: string;
-  readonly options?: Readonly<Record<string, boolean | string>>;
-}
-
-export type ExpoRuntimeProviderId = 'permissions';
-export type ExpoRuntimeAdapterId = 'ExpoBarcodeScannerAdapter';
-
-interface ExpoRuntimeDiagnostic {
-  readonly severity: 'error' | 'warning';
-  readonly requirementType: 'capability' | 'configHint' | 'package' | 'permission';
-  readonly requirement: string;
-  readonly message: string;
-  readonly support?: PermissionSupport;
-}
-
 export interface ExpoRuntimePlan {
   readonly permissions: readonly ScreenPermissionRequirement[];
   readonly capabilities: readonly ScreenCapabilityRequirement[];
@@ -61,20 +63,6 @@ export interface ExpoRuntimePlan {
   readonly diagnostics: readonly ExpoRuntimeDiagnostic[];
 }
 
-interface ExpoRuntimeCapabilityMetadata {
-  readonly impliedPermissions?: readonly ScreenPermissionRequirement[];
-  readonly requiredPackages?: readonly string[];
-  readonly providers?: readonly ExpoRuntimeProviderId[];
-  readonly runtimeAdapters?: readonly ExpoRuntimeAdapterId[];
-  readonly androidPermissions?: readonly string[];
-  readonly plugins?: readonly ExpoRuntimeConfigPlugin[];
-}
-
-interface ExpoRuntimeHintMetadata {
-  readonly androidPermissions?: readonly string[];
-  readonly plugin?: ExpoRuntimeConfigPlugin;
-}
-
 interface ResolveExpoRuntimePlanOptions {
   readonly capabilityRegistry?: Readonly<
     Partial<Record<AnkhorageCapabilityName, ExpoRuntimeCapabilityMetadata>>
@@ -83,263 +71,245 @@ interface ResolveExpoRuntimePlanOptions {
   readonly permissionSupport?: Readonly<Record<Permission, ExpoPermissionMetadata>>;
 }
 
-const CAMERA_ANDROID_PERMISSION = 'android.permission.CAMERA';
-const EXPO_RUNTIME_PACKAGE_NAME = '@ankhorage/expo-runtime';
-
-const GENERATED_EXPO_DEPENDENCY_VERSIONS = {
-  '@ankhorage/permissions': '^0.2.0',
-  '@ankhorage/expo-runtime': 'latest',
-  'expo-camera': '~17.0.10',
-} as const satisfies Record<string, string>;
-
-const EXPO_RUNTIME_PROVIDER_PACKAGES = {
-  permissions: '@ankhorage/permissions',
-} as const satisfies Record<ExpoRuntimeProviderId, string>;
+interface PlanningState {
+  readonly permissions: Map<string, ScreenPermissionRequirement>;
+  readonly impliedPermissions: Map<string, ScreenPermissionRequirement>;
+  readonly capabilities: Map<string, ScreenCapabilityRequirement>;
+  readonly diagnostics: ExpoRuntimeDiagnostic[];
+  readonly dependencies: Map<string, ExpoRuntimeDependency>;
+  readonly pluginOptions: Map<string, Record<string, boolean | string>>;
+  readonly configHints: Set<string>;
+  readonly androidPermissions: Set<string>;
+  readonly providers: Set<ExpoRuntimeProviderId>;
+  readonly runtimeAdapters: Set<ExpoRuntimeAdapterId>;
+}
 
-const EXPO_RUNTIME_CONFIG_HINTS = {
-  cameraPermission: {
-    androidPermissions: [CAMERA_ANDROID_PERMISSION],
-    plugin: {
-      name: 'expo-camera',
-      options: {
-        cameraPermission: 'Allow camera access.',
-      },
-    },
-  },
-} as const satisfies Readonly<Record<string, ExpoRuntimeHintMetadata>>;
+interface PlanningContext {
+  readonly state: PlanningState;
+  readonly capabilityRegistry: Readonly<
+    Partial<Record<AnkhorageCapabilityName, ExpoRuntimeCapabilityMetadata>>
+  >;
+  readonly dependencyVersions: Readonly<Record<string, string>>;
+  readonly permissionSupport: Readonly<Record<Permission, ExpoPermissionMetadata>>;
+}
 
-const EXPO_CAPABILITY_RUNTIME_REGISTRY = {
-  barcodeScanner: {
-    impliedPermissions: [{ permission: 'camera' }],
-    requiredPackages: ['expo-camera'],
-    providers: ['permissions'],
-    runtimeAdapters: ['ExpoBarcodeScannerAdapter'],
-    androidPermissions: [CAMERA_ANDROID_PERMISSION],
-    plugins: [
-      {
-        name: 'expo-camera',
-        options: {
-          cameraPermission: 'Allow camera access to scan barcodes.',
-        },
-      },
-    ],
-  },
-} as const satisfies Readonly<
-  Partial<Record<AnkhorageCapabilityName, ExpoRuntimeCapabilityMetadata>>
->;
+const EXPO_RUNTIME_PACKAGE_NAME = '@ankhorage/expo-runtime';
 
 export function resolveExpoRuntimePlan(
   manifest: ExpoRuntimePlanningManifest,
   options: ResolveExpoRuntimePlanOptions = {},
 ): ExpoRuntimePlan {
-  const permissionsByName = new Map<string, ScreenPermissionRequirement>();
-  const impliedPermissionsByName = new Map<string, ScreenPermissionRequirement>();
-  const capabilitiesByName = new Map<string, ScreenCapabilityRequirement>();
-
-  for (const screen of Object.values(manifest.screens)) {
-    screen.requires?.permissions?.forEach((requirement) => {
-      permissionsByName.set(requirement.permission, requirement);
-    });
-    screen.requires?.capabilities?.forEach((requirement) => {
-      capabilitiesByName.set(requirement.capability, requirement);
-    });
-  }
-
-  const capabilityRegistry: Readonly<
-    Partial<Record<AnkhorageCapabilityName, ExpoRuntimeCapabilityMetadata>>
-  > = options.capabilityRegistry ?? EXPO_CAPABILITY_RUNTIME_REGISTRY;
-
-  for (const capabilityRequirement of capabilitiesByName.values()) {
-    capabilityRegistry[capabilityRequirement.capability]?.impliedPermissions?.forEach(
-      (permissionRequirement: ScreenPermissionRequirement) => {
-        if (!permissionsByName.has(permissionRequirement.permission)) {
-          permissionsByName.set(permissionRequirement.permission, permissionRequirement);
-          impliedPermissionsByName.set(permissionRequirement.permission, permissionRequirement);
-        }
-      },
-    );
+  const state = createPlanningState(manifest);
+  const context: PlanningContext = {
+    state,
+    capabilityRegistry: options.capabilityRegistry ?? EXPO_CAPABILITY_RUNTIME_REGISTRY,
+    dependencyVersions: options.dependencyVersions ?? GENERATED_RUNTIME_DEPENDENCY_VERSIONS,
+    permissionSupport: options.permissionSupport ?? EXPO_PERMISSION_SUPPORT,
+  };
+  addImpliedPermissions(context);
+  planPermissions(context);
+  planCapabilities(context);
+  if (state.providers.size > 0 || state.runtimeAdapters.size > 0) {
+    addDependency(context, EXPO_RUNTIME_PACKAGE_NAME, 'runtime:expo');
   }
+  return buildPlan(state);
+}
 
-  const diagnostics: ExpoRuntimeDiagnostic[] = [];
-  const dependencies = new Map<string, ExpoRuntimeDependency>();
-  const pluginOptions = new Map<string, Record<string, boolean | string>>();
-  const configHints = new Set<string>();
-  const androidPermissions = new Set<string>();
-  const providers = new Set<ExpoRuntimeProviderId>();
-  const runtimeAdapters = new Set<ExpoRuntimeAdapterId>();
-  const dependencyVersions: Readonly<Record<string, string>> =
-    options.dependencyVersions ?? GENERATED_EXPO_DEPENDENCY_VERSIONS;
-  const permissionSupport = options.permissionSupport ?? EXPO_PERMISSION_SUPPORT;
-  const configHintRegistry: Readonly<Record<string, ExpoRuntimeHintMetadata>> =
-    EXPO_RUNTIME_CONFIG_HINTS;
-
-  const addDependency = (name: string, reason: string) => {
-    const version = dependencyVersions[name];
-    if (version === undefined) {
-      diagnostics.push({
-        severity: 'warning',
-        requirementType: 'package',
-        requirement: name,
-        message: `No generated-app dependency version is registered for '${name}'.`,
-      });
-      return;
+function createPlanningState(manifest: ExpoRuntimePlanningManifest): PlanningState {
+  const permissions = new Map<string, ScreenPermissionRequirement>();
+  const capabilities = new Map<string, ScreenCapabilityRequirement>();
+  for (const screen of Object.values(manifest.screens)) {
+    for (const requirement of screen.requires?.permissions ?? []) {
+      permissions.set(requirement.permission, requirement);
     }
-
-    const existing = dependencies.get(name);
-    if (existing) {
-      dependencies.set(name, {
-        ...existing,
-        reasons: Array.from(new Set([...existing.reasons, reason])),
-      });
-      return;
+    for (const requirement of screen.requires?.capabilities ?? []) {
+      capabilities.set(requirement.capability, requirement);
     }
-
-    dependencies.set(name, {
-      name,
-      version,
-      reasons: [reason],
-    });
-  };
-
-  const addProvider = (provider: ExpoRuntimeProviderId, reason: string) => {
-    providers.add(provider);
-    addDependency(EXPO_RUNTIME_PROVIDER_PACKAGES[provider], reason);
-  };
-
-  const addPlugin = (plugin: ExpoRuntimeConfigPlugin) => {
-    const existingOptions = pluginOptions.get(plugin.name) ?? {};
-    pluginOptions.set(plugin.name, {
-      ...existingOptions,
-      ...(plugin.options ?? {}),
-    });
+  }
+  return {
+    permissions,
+    capabilities,
+    impliedPermissions: new Map(),
+    diagnostics: [],
+    dependencies: new Map(),
+    pluginOptions: new Map(),
+    configHints: new Set(),
+    androidPermissions: new Set(),
+    providers: new Set(),
+    runtimeAdapters: new Set(),
   };
+}
 
-  for (const permissionRequirement of permissionsByName.values()) {
-    if (!isPermission(permissionRequirement.permission)) {
-      diagnostics.push({
-        severity: 'error',
-        requirementType: 'permission',
-        requirement: permissionRequirement.permission,
-        message: `Unknown permission '${permissionRequirement.permission}' cannot be resolved for Expo runtime generation.`,
-      });
-      continue;
-    }
-
-    const supportMetadata = permissionSupport[permissionRequirement.permission];
-    if (
-      supportMetadata.support === 'unsupported' ||
-      supportMetadata.support === 'notImplemented' ||
-      supportMetadata.support === 'limited'
-    ) {
-      diagnostics.push({
-        severity: supportMetadata.support === 'limited' ? 'warning' : 'error',
-        requirementType: 'permission',
-        requirement: permissionRequirement.permission,
-        message: `Expo runtime support for '${permissionRequirement.permission}' is '${supportMetadata.support}'.`,
-        support: supportMetadata.support,
-      });
-      continue;
-    }
-
-    if (supportMetadata.support === 'notRequired') {
-      continue;
+function addImpliedPermissions(context: PlanningContext): void {
+  const { state } = context;
+  for (const capability of state.capabilities.values()) {
+    const metadata = findCapabilityMetadata(context.capabilityRegistry, capability);
+    for (const permission of metadata?.impliedPermissions ?? []) {
+      if (!state.permissions.has(permission.permission)) {
+        state.permissions.set(permission.permission, permission);
+        state.impliedPermissions.set(permission.permission, permission);
+      }
     }
+  }
+}
 
-    addProvider('permissions', `permission:${permissionRequirement.permission}`);
-    supportMetadata.requiredPackages.forEach((packageName) => {
-      addDependency(packageName, `permission:${permissionRequirement.permission}`);
-    });
-
-    supportMetadata.configHints.forEach((configHint) => {
-      configHints.add(configHint);
-      const configHintMetadata = configHintRegistry[configHint];
-      if (!configHintMetadata) {
-        diagnostics.push({
-          severity: 'warning',
-          requirementType: 'configHint',
-          requirement: configHint,
-          message: `Config hint '${configHint}' is not translated into generated Expo config yet.`,
-        });
-        return;
-      }
+function planPermissions(context: PlanningContext): void {
+  for (const requirement of context.state.permissions.values()) {
+    planPermission(context, requirement);
+  }
+}
 
-      configHintMetadata.androidPermissions?.forEach((permissionName) => {
-        androidPermissions.add(permissionName);
-      });
-      if (configHintMetadata.plugin) {
-        addPlugin(configHintMetadata.plugin);
-      }
-    });
+function planPermission(context: PlanningContext, requirement: ScreenPermissionRequirement): void {
+  if (!isPermission(requirement.permission)) {
+    context.state.diagnostics.push(unknownPermissionDiagnostic(requirement.permission));
+    return;
+  }
+  const metadata = findPermissionSupport(context.permissionSupport, requirement.permission);
+  if (isUnsupported(metadata.support)) {
+    context.state.diagnostics.push(
+      unsupportedPermissionDiagnostic(requirement.permission, metadata.support),
+    );
+    return;
+  }
+  if (metadata.support === 'notRequired') {
+    return;
   }
+  const reason = `permission:${requirement.permission}`;
+  addProvider(context, 'permissions', reason);
+  metadata.requiredPackages.forEach((name) => addDependency(context, name, reason));
+  metadata.configHints.forEach((hint) => applyConfigHint(context.state, hint));
+}
 
-  for (const capabilityRequirement of capabilitiesByName.values()) {
-    const capabilityMetadata = capabilityRegistry[capabilityRequirement.capability];
-    if (!capabilityMetadata) {
-      diagnostics.push({
-        severity: 'warning',
-        requirementType: 'capability',
-        requirement: capabilityRequirement.capability,
-        message: `No Expo runtime metadata is registered for capability '${capabilityRequirement.capability}'.`,
-      });
+function planCapabilities(context: PlanningContext): void {
+  for (const requirement of context.state.capabilities.values()) {
+    const metadata = findCapabilityMetadata(context.capabilityRegistry, requirement);
+    if (metadata === undefined) {
+      context.state.diagnostics.push(unknownCapabilityDiagnostic(requirement.capability));
       continue;
     }
+    const reason = `capability:${requirement.capability}`;
+    metadata.requiredPackages?.forEach((name) => addDependency(context, name, reason));
+    metadata.providers?.forEach((provider) => addProvider(context, provider, reason));
+    metadata.runtimeAdapters?.forEach((adapter) => context.state.runtimeAdapters.add(adapter));
+    metadata.androidPermissions?.forEach((permission) =>
+      context.state.androidPermissions.add(permission),
+    );
+    metadata.plugins?.forEach((plugin) => addPlugin(context.state, plugin));
+  }
+}
 
-    capabilityMetadata.requiredPackages?.forEach((packageName) => {
-      addDependency(packageName, `capability:${capabilityRequirement.capability}`);
-    });
-    capabilityMetadata.providers?.forEach((provider) => {
-      addProvider(provider, `capability:${capabilityRequirement.capability}`);
-    });
-    capabilityMetadata.runtimeAdapters?.forEach((runtimeAdapter) => {
-      runtimeAdapters.add(runtimeAdapter);
+function applyConfigHint(state: PlanningState, configHint: string): void {
+  state.configHints.add(configHint);
+  const metadata = findConfigHintMetadata(configHint);
+  if (metadata === undefined) {
+    state.diagnostics.push({
+      severity: 'warning',
+      requirementType: 'configHint',
+      requirement: configHint,
+      message: `Config hint '${configHint}' is not translated into generated Expo config yet.`,
     });
-    capabilityMetadata.androidPermissions?.forEach((permissionName) => {
-      androidPermissions.add(permissionName);
+    return;
+  }
+  metadata.androidPermissions?.forEach((permission) => state.androidPermissions.add(permission));
+  if (metadata.plugin !== undefined) {
+    addPlugin(state, metadata.plugin);
+  }
+}
+
+function addDependency(context: PlanningContext, name: string, reason: string): void {
+  const version = findDependencyVersion(context.dependencyVersions, name);
+  if (version === undefined) {
+    context.state.diagnostics.push({
+      severity: 'warning',
+      requirementType: 'package',
+      requirement: name,
+      message: `No generated-app dependency version is registered for '${name}'.`,
     });
-    capabilityMetadata.plugins?.forEach(addPlugin);
+    return;
   }
+  const existing = context.state.dependencies.get(name);
+  context.state.dependencies.set(name, {
+    name,
+    version,
+    reasons: existing === undefined ? [reason] : Array.from(new Set([...existing.reasons, reason])),
+  });
+}
 
-  if (providers.size > 0 || runtimeAdapters.size > 0) {
-    addDependency(EXPO_RUNTIME_PACKAGE_NAME, 'runtime:expo');
+function addProvider(
+  context: PlanningContext,
+  provider: ExpoRuntimeProviderId,
+  reason: string,
+): void {
+  context.state.providers.add(provider);
+  const packageName = Object.entries(EXPO_RUNTIME_PROVIDER_PACKAGES).find(
+    ([name]) => name === String(provider),
+  )?.[1];
+  if (packageName === undefined) {
+    throw new Error(`Runtime package metadata is missing for provider '${provider}'.`);
   }
+  addDependency(context, packageName, reason);
+}
 
-  const plugins = Array.from(pluginOptions.entries())
-    .map(([name, pluginOptions]) => ({
-      name,
-      options: Object.keys(pluginOptions).length > 0 ? pluginOptions : undefined,
-    }))
-    .sort((left, right) => left.name.localeCompare(right.name));
+function addPlugin(state: PlanningState, plugin: ExpoRuntimeConfigPlugin): void {
+  const existingOptions = state.pluginOptions.get(plugin.name) ?? {};
+  state.pluginOptions.set(plugin.name, { ...existingOptions, ...(plugin.options ?? {}) });
+}
 
+function buildPlan(state: PlanningState): ExpoRuntimePlan {
+  const plugins = Array.from(state.pluginOptions, ([name, options]) => ({
+    name,
+    options: Object.keys(options).length > 0 ? options : undefined,
+  })).sort((left, right) => left.name.localeCompare(right.name));
   return {
-    permissions: Array.from(permissionsByName.values()).sort(comparePermissionRequirements),
-    capabilities: Array.from(capabilitiesByName.values()).sort(compareCapabilityRequirements),
-    impliedPermissions: Array.from(impliedPermissionsByName.values()).sort(
-      comparePermissionRequirements,
-    ),
-    dependencies: Array.from(dependencies.values()).sort((left, right) =>
+    permissions: Array.from(state.permissions.values()).sort(comparePermissions),
+    capabilities: Array.from(state.capabilities.values()).sort(compareCapabilities),
+    impliedPermissions: Array.from(state.impliedPermissions.values()).sort(comparePermissions),
+    dependencies: Array.from(state.dependencies.values()).sort((left, right) =>
       left.name.localeCompare(right.name),
     ),
     nativeConfig: {
-      androidPermissions: Array.from(androidPermissions).sort(),
-      configHints: Array.from(configHints).sort(),
+      androidPermissions: Array.from(state.androidPermissions).sort(),
+      configHints: Array.from(state.configHints).sort(),
       plugins,
     },
-    providers: Array.from(providers).sort(),
-    runtimeAdapters: Array.from(runtimeAdapters).sort(),
-    usesExpoRuntimeRegistry: runtimeAdapters.size > 0,
-    needsPermissionsProvider: providers.has('permissions'),
-    diagnostics,
+    providers: Array.from(state.providers).sort(),
+    runtimeAdapters: Array.from(state.runtimeAdapters).sort(),
+    usesExpoRuntimeRegistry: state.runtimeAdapters.size > 0,
+    needsPermissionsProvider: state.providers.has('permissions'),
+    diagnostics: state.diagnostics,
   };
 }
 
-function compareCapabilityRequirements(
+function findPermissionSupport(
+  registry: Readonly<Record<Permission, ExpoPermissionMetadata>>,
+  permission: Permission,
+): ExpoPermissionMetadata {
+  const metadata = Object.entries(registry).find(([name]) => name === String(permission))?.[1];
+  if (metadata === undefined) {
+    throw new Error(`Permission metadata is missing for '${permission}'.`);
+  }
+  return metadata;
+}
+
+function findDependencyVersion(
+  versions: Readonly<Record<string, string>>,
+  name: string,
+): string | undefined {
+  return Object.entries(versions).find(([candidate]) => candidate === name)?.[1];
+}
+
+function isUnsupported(support: PermissionSupport): boolean {
+  return support === 'unsupported' || support === 'notImplemented' || support === 'limited';
+}
+
+function compareCapabilities(
   left: ScreenCapabilityRequirement,
   right: ScreenCapabilityRequirement,
 ): number {
   return left.capability.localeCompare(right.capability);
 }
 
-function comparePermissionRequirements(
+function comparePermissions(
   left: ScreenPermissionRequirement,
   right: ScreenPermissionRequirement,
 ): number {