@amabeth/repeating-wheel-picker 1.0.0 → 1.2.0

package/example/node_modules/expo-modules-autolinking/src/platforms/apple.ts

@@ -0,0 +1,292 @@
+import spawnAsync from '@expo/spawn-async';
+import fs from 'fs';
+import { glob } from 'glob';
+import path from 'path';
+
+import { fileExistsAsync } from '../fileUtils';
+import type {
+  AppleCodeSignEntitlements,
+  ExtraDependencies,
+  ModuleDescriptorIos,
+  ModuleIosPodspecInfo,
+  PackageRevision,
+  SearchOptions,
+} from '../types';
+
+const APPLE_PROPERTIES_FILE = 'Podfile.properties.json';
+const APPLE_EXTRA_BUILD_DEPS_KEY = 'apple.extraPods';
+
+const indent = '  ';
+
+async function findPodspecFiles(revision: PackageRevision): Promise<string[]> {
+  const configPodspecPaths = revision.config?.applePodspecPaths();
+  if (configPodspecPaths && configPodspecPaths.length) {
+    return configPodspecPaths;
+  }
+
+  const podspecFiles = await glob('*/*.podspec', {
+    cwd: revision.path,
+    ignore: ['**/node_modules/**'],
+  });
+
+  return podspecFiles;
+}
+
+export function getSwiftModuleNames(
+  pods: ModuleIosPodspecInfo[],
+  swiftModuleNames: string[] | undefined
+): string[] {
+  if (swiftModuleNames && swiftModuleNames.length) {
+    return swiftModuleNames;
+  }
+  // by default, non-alphanumeric characters in the pod name are replaced by _ in the module name
+  return pods.map((pod) => pod.podName.replace(/[^a-zA-Z0-9]/g, '_'));
+}
+
+/**
+ * Resolves module search result with additional details required for iOS platform.
+ */
+export async function resolveModuleAsync(
+  packageName: string,
+  revision: PackageRevision,
+  options: SearchOptions
+): Promise<ModuleDescriptorIos | null> {
+  const podspecFiles = await findPodspecFiles(revision);
+  if (!podspecFiles.length) {
+    return null;
+  }
+
+  const pods = podspecFiles.map((podspecFile) => ({
+    podName: path.basename(podspecFile, path.extname(podspecFile)),
+    podspecDir: path.dirname(path.join(revision.path, podspecFile)),
+  }));
+
+  const swiftModuleNames = getSwiftModuleNames(pods, revision.config?.appleSwiftModuleNames());
+  const coreFeatures = revision.config?.coreFeatures() ?? [];
+
+  return {
+    packageName,
+    pods,
+    swiftModuleNames,
+    flags: options.flags,
+    modules: revision.config?.appleModules() ?? [],
+    appDelegateSubscribers: revision.config?.appleAppDelegateSubscribers() ?? [],
+    reactDelegateHandlers: revision.config?.appleReactDelegateHandlers() ?? [],
+    debugOnly: revision.config?.appleDebugOnly() ?? false,
+    ...(coreFeatures.length > 0 ? { coreFeatures } : {}),
+  };
+}
+
+export async function resolveExtraBuildDependenciesAsync(
+  projectNativeRoot: string
+): Promise<ExtraDependencies | null> {
+  const propsFile = path.join(projectNativeRoot, APPLE_PROPERTIES_FILE);
+  try {
+    const contents = await fs.promises.readFile(propsFile, 'utf8');
+    const podfileJson = JSON.parse(contents);
+    if (podfileJson[APPLE_EXTRA_BUILD_DEPS_KEY]) {
+      // expo-build-properties would serialize the extraPods as JSON string, we should parse it again.
+      const extraPods = JSON.parse(podfileJson[APPLE_EXTRA_BUILD_DEPS_KEY]);
+      return extraPods;
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Generates Swift file that contains all autolinked Swift packages.
+ */
+export async function generateModulesProviderAsync(
+  modules: ModuleDescriptorIos[],
+  targetPath: string,
+  entitlementPath: string
+): Promise<void> {
+  const className = path.basename(targetPath, path.extname(targetPath));
+  const entitlements = await parseEntitlementsAsync(entitlementPath);
+  const generatedFileContent = await generatePackageListFileContentAsync(
+    modules,
+    className,
+    entitlements
+  );
+  const parentPath = path.dirname(targetPath);
+  await fs.promises.mkdir(parentPath, { recursive: true });
+  await fs.promises.writeFile(targetPath, generatedFileContent, 'utf8');
+}
+
+/**
+ * Generates the string to put into the generated package list.
+ */
+async function generatePackageListFileContentAsync(
+  modules: ModuleDescriptorIos[],
+  className: string,
+  entitlements: AppleCodeSignEntitlements
+): Promise<string> {
+  const iosModules = modules.filter(
+    (module) =>
+      module.modules.length ||
+      module.appDelegateSubscribers.length ||
+      module.reactDelegateHandlers.length
+  );
+
+  const modulesToImport = iosModules.filter((module) => !module.debugOnly);
+  const debugOnlyModules = iosModules.filter((module) => module.debugOnly);
+
+  const swiftModules = ([] as string[])
+    .concat(...modulesToImport.map((module) => module.swiftModuleNames))
+    .filter(Boolean);
+
+  const debugOnlySwiftModules = ([] as string[])
+    .concat(...debugOnlyModules.map((module) => module.swiftModuleNames))
+    .filter(Boolean);
+
+  const modulesClassNames = ([] as string[])
+    .concat(...modulesToImport.map((module) => module.modules))
+    .filter(Boolean);
+
+  const debugOnlyModulesClassNames = ([] as string[])
+    .concat(...debugOnlyModules.map((module) => module.modules))
+    .filter(Boolean);
+
+  const appDelegateSubscribers = ([] as string[]).concat(
+    ...modulesToImport.map((module) => module.appDelegateSubscribers)
+  );
+
+  const debugOnlyAppDelegateSubscribers = ([] as string[]).concat(
+    ...debugOnlyModules.map((module) => module.appDelegateSubscribers)
+  );
+
+  const reactDelegateHandlerModules = modulesToImport.filter(
+    (module) => !!module.reactDelegateHandlers.length
+  );
+
+  const debugOnlyReactDelegateHandlerModules = debugOnlyModules.filter(
+    (module) => !!module.reactDelegateHandlers.length
+  );
+
+  return `/**
+ * Automatically generated by expo-modules-autolinking.
+ *
+ * This autogenerated class provides a list of classes of native Expo modules,
+ * but only these that are written in Swift and use the new API for creating Expo modules.
+ */
+
+import ExpoModulesCore
+${generateCommonImportList(swiftModules)}
+${generateDebugOnlyImportList(debugOnlySwiftModules)}
+@objc(${className})
+public class ${className}: ModulesProvider {
+  public override func getModuleClasses() -> [AnyModule.Type] {
+${generateModuleClasses(modulesClassNames, debugOnlyModulesClassNames)}
+  }
+
+  public override func getAppDelegateSubscribers() -> [ExpoAppDelegateSubscriber.Type] {
+${generateModuleClasses(appDelegateSubscribers, debugOnlyAppDelegateSubscribers)}
+  }
+
+  public override func getReactDelegateHandlers() -> [ExpoReactDelegateHandlerTupleType] {
+${generateReactDelegateHandlers(reactDelegateHandlerModules, debugOnlyReactDelegateHandlerModules)}
+  }
+
+  public override func getAppCodeSignEntitlements() -> AppCodeSignEntitlements {
+    return AppCodeSignEntitlements.from(json: #"${JSON.stringify(entitlements)}"#)
+  }
+}
+`;
+}
+
+function generateCommonImportList(swiftModules: string[]): string {
+  return swiftModules.map((moduleName) => `import ${moduleName}`).join('\n');
+}
+
+function generateDebugOnlyImportList(swiftModules: string[]): string {
+  if (!swiftModules.length) {
+    return '';
+  }
+
+  return (
+    wrapInDebugConfigurationCheck(
+      0,
+      swiftModules.map((moduleName) => `import ${moduleName}`).join('\n')
+    ) + '\n'
+  );
+}
+
+function generateModuleClasses(classNames: string[], debugOnlyClassName: string[]): string {
+  const commonClassNames = formatArrayOfClassNames(classNames);
+  if (debugOnlyClassName.length > 0) {
+    return wrapInDebugConfigurationCheck(
+      2,
+      `return ${formatArrayOfClassNames(classNames.concat(debugOnlyClassName))}`,
+      `return ${commonClassNames}`
+    );
+  } else {
+    return `${indent.repeat(2)}return ${commonClassNames}`;
+  }
+}
+
+/**
+ * Formats an array of class names to Swift's array containing these classes.
+ */
+function formatArrayOfClassNames(classNames: string[]): string {
+  return `[${classNames.map((className) => `\n${indent.repeat(3)}${className}.self`).join(',')}
+${indent.repeat(2)}]`;
+}
+
+function generateReactDelegateHandlers(
+  module: ModuleDescriptorIos[],
+  debugOnlyModules: ModuleDescriptorIos[]
+): string {
+  const commonModules = formatArrayOfReactDelegateHandler(module);
+  if (debugOnlyModules.length > 0) {
+    return wrapInDebugConfigurationCheck(
+      2,
+      `return ${formatArrayOfReactDelegateHandler(module.concat(debugOnlyModules))}`,
+      `return ${commonModules}`
+    );
+  } else {
+    return `${indent.repeat(2)}return ${commonModules}`;
+  }
+}
+
+/**
+ * Formats an array of modules to Swift's array containing ReactDelegateHandlers
+ */
+export function formatArrayOfReactDelegateHandler(modules: ModuleDescriptorIos[]): string {
+  const values: string[] = [];
+  for (const module of modules) {
+    for (const handler of module.reactDelegateHandlers) {
+      values.push(`(packageName: "${module.packageName}", handler: ${handler}.self)`);
+    }
+  }
+  return `[${values.map((value) => `\n${indent.repeat(3)}${value}`).join(',')}
+${indent.repeat(2)}]`;
+}
+
+function wrapInDebugConfigurationCheck(
+  indentationLevel: number,
+  debugBlock: string,
+  releaseBlock: string | null = null
+) {
+  if (releaseBlock) {
+    return `${indent.repeat(indentationLevel)}#if EXPO_CONFIGURATION_DEBUG\n${indent.repeat(
+      indentationLevel
+    )}${debugBlock}\n${indent.repeat(indentationLevel)}#else\n${indent.repeat(
+      indentationLevel
+    )}${releaseBlock}\n${indent.repeat(indentationLevel)}#endif`;
+  }
+
+  return `${indent.repeat(indentationLevel)}#if EXPO_CONFIGURATION_DEBUG\n${indent.repeat(
+    indentationLevel
+  )}${debugBlock}\n${indent.repeat(indentationLevel)}#endif`;
+}
+
+async function parseEntitlementsAsync(entitlementPath: string): Promise<AppleCodeSignEntitlements> {
+  if (!(await fileExistsAsync(entitlementPath))) {
+    return {};
+  }
+  const { stdout } = await spawnAsync('plutil', ['-convert', 'json', '-o', '-', entitlementPath]);
+  const entitlementsJson = JSON.parse(stdout);
+  return {
+    appGroups: entitlementsJson['com.apple.security.application-groups'] || undefined,
+  };
+}

package/example/node_modules/expo-modules-autolinking/src/platforms/devtools.ts

@@ -0,0 +1,25 @@
+import path from 'path';
+
+import type { ExtraDependencies, ModuleDescriptorDevTools, PackageRevision } from '../types';
+
+export async function resolveModuleAsync(
+  packageName: string,
+  revision: PackageRevision
+): Promise<ModuleDescriptorDevTools | null> {
+  const devtoolsConfig = revision.config?.toJSON().devtools;
+  if (devtoolsConfig == null) {
+    return null;
+  }
+
+  return {
+    packageName,
+    packageRoot: revision.path,
+    webpageRoot: path.join(revision.path, devtoolsConfig.webpageRoot),
+  };
+}
+
+export async function resolveExtraBuildDependenciesAsync(
+  _projectNativeRoot: string
+): Promise<ExtraDependencies | null> {
+  return null;
+}

package/example/node_modules/expo-modules-autolinking/src/reactNativeConfig/androidResolver.ts

@@ -0,0 +1,264 @@
+import fs from 'fs/promises';
+import { glob } from 'glob';
+import path from 'path';
+
+import type {
+  RNConfigDependencyAndroid,
+  RNConfigReactNativePlatformsConfigAndroid,
+} from './reactNativeConfig.types';
+import {
+  fileExistsAsync,
+  globMatchFunctorAllAsync,
+  globMatchFunctorFirstAsync,
+} from '../fileUtils';
+
+export async function resolveDependencyConfigImplAndroidAsync(
+  packageRoot: string,
+  reactNativeConfig: RNConfigReactNativePlatformsConfigAndroid | null | undefined
+): Promise<RNConfigDependencyAndroid | null> {
+  if (reactNativeConfig === null) {
+    // Skip autolinking for this package.
+    return null;
+  }
+  const sourceDir = reactNativeConfig?.sourceDir || 'android';
+  const androidDir = path.join(packageRoot, sourceDir);
+  const { gradle, manifest } = await findGradleAndManifestAsync({ androidDir, isLibrary: true });
+  if (!manifest && !gradle) {
+    return null;
+  }
+
+  const packageName =
+    reactNativeConfig?.packageName || (await parsePackageNameAsync(androidDir, manifest, gradle));
+  if (!packageName) {
+    return null;
+  }
+  const nativePackageClassName = await parseNativePackageClassNameAsync(packageRoot, androidDir);
+  if (!nativePackageClassName) {
+    return null;
+  }
+
+  const packageJson = JSON.parse(await fs.readFile(path.join(packageRoot, 'package.json'), 'utf8'));
+  const packageImportPath =
+    reactNativeConfig?.packageImportPath || `import ${packageName}.${nativePackageClassName};`;
+  const packageInstance = reactNativeConfig?.packageInstance || `new ${nativePackageClassName}()`;
+  const buildTypes = reactNativeConfig?.buildTypes || [];
+  const dependencyConfiguration = reactNativeConfig?.dependencyConfiguration;
+  const libraryName =
+    reactNativeConfig?.libraryName || (await parseLibraryNameAsync(androidDir, packageJson));
+  const componentDescriptors =
+    reactNativeConfig?.componentDescriptors ||
+    (await parseComponentDescriptorsAsync(packageRoot, packageJson));
+  let cmakeListsPath = reactNativeConfig?.cmakeListsPath
+    ? path.join(androidDir, reactNativeConfig?.cmakeListsPath)
+    : path.join(androidDir, 'build/generated/source/codegen/jni/CMakeLists.txt');
+  const cxxModuleCMakeListsModuleName = reactNativeConfig?.cxxModuleCMakeListsModuleName || null;
+  const cxxModuleHeaderName = reactNativeConfig?.cxxModuleHeaderName || null;
+  let cxxModuleCMakeListsPath = reactNativeConfig?.cxxModuleCMakeListsPath
+    ? path.join(androidDir, reactNativeConfig?.cxxModuleCMakeListsPath)
+    : null;
+  if (process.platform === 'win32') {
+    cmakeListsPath = cmakeListsPath.replace(/\\/g, '/');
+    if (cxxModuleCMakeListsPath) {
+      cxxModuleCMakeListsPath = cxxModuleCMakeListsPath.replace(/\\/g, '/');
+    }
+  }
+
+  const result: RNConfigDependencyAndroid = {
+    sourceDir: androidDir,
+    packageImportPath,
+    packageInstance,
+    dependencyConfiguration,
+    buildTypes,
+    libraryName,
+    componentDescriptors,
+    cmakeListsPath,
+    cxxModuleCMakeListsModuleName,
+    cxxModuleCMakeListsPath,
+    cxxModuleHeaderName,
+  };
+  if (!result.libraryName) {
+    delete result.libraryName;
+  }
+  if (!result.dependencyConfiguration) {
+    delete result.dependencyConfiguration;
+  }
+  return result;
+}
+
+/**
+ * Parse the `RNConfigDependencyAndroid.packageName`
+ */
+export async function parsePackageNameAsync(
+  androidDir: string,
+  manifestPath: string | null,
+  gradlePath: string | null
+): Promise<string | null> {
+  if (gradlePath) {
+    const gradleContents = await fs.readFile(path.join(androidDir, gradlePath), 'utf8');
+    const match = gradleContents.match(/namespace\s*[=]*\s*["'](.+?)["']/);
+    if (match) {
+      return match[1];
+    }
+  }
+  if (manifestPath) {
+    const manifestContents = await fs.readFile(path.join(androidDir, manifestPath), 'utf8');
+    const match = manifestContents.match(/package="(.+?)"/);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+
+/**
+ * Parse the Java or Kotlin class name to for `ReactPackage` or `(Base|Turbo)ReactPackage`.
+ */
+export async function parseNativePackageClassNameAsync(
+  packageRoot: string,
+  androidDir: string
+): Promise<string | null> {
+  const matched = await globMatchFunctorFirstAsync(
+    '**/*Package.{java,kt}',
+    matchNativePackageClassName,
+    { cwd: androidDir }
+  );
+  if (matched) {
+    return matched;
+  }
+
+  // Early return if the module is an Expo module
+  if (await fileExistsAsync(path.join(packageRoot, 'expo-module.config.json'))) {
+    return null;
+  }
+
+  return await globMatchFunctorFirstAsync('**/*.{java,kt}', matchNativePackageClassName, {
+    cwd: androidDir,
+  });
+}
+
+let lazyReactPackageRegex: RegExp | null = null;
+let lazyTurboReactPackageRegex: RegExp | null = null;
+export function matchNativePackageClassName(_filePath: string, contents: Buffer): string | null {
+  const fileContents = contents.toString();
+
+  // [0] Match ReactPackage
+  if (!lazyReactPackageRegex) {
+    lazyReactPackageRegex =
+      /class\s+(\w+[^(\s]*)[\s\w():]*(\s+implements\s+|:)[\s\w():,]*[^{]*ReactPackage/;
+  }
+  const matchReactPackage = fileContents.match(lazyReactPackageRegex);
+  if (matchReactPackage) {
+    return matchReactPackage[1];
+  }
+
+  // [1] Match (Base|Turbo)ReactPackage
+  if (!lazyTurboReactPackageRegex) {
+    lazyTurboReactPackageRegex =
+      /class\s+(\w+[^(\s]*)[\s\w():]*(\s+extends\s+|:)[\s\w():,]*[^{]*(Base|Turbo)ReactPackage/;
+  }
+  const matchTurboReactPackage = fileContents.match(lazyTurboReactPackageRegex);
+  if (matchTurboReactPackage) {
+    return matchTurboReactPackage[1];
+  }
+
+  return null;
+}
+
+export async function parseLibraryNameAsync(
+  androidDir: string,
+  packageJson: any
+): Promise<string | null> {
+  // [0] `codegenConfig.name` from package.json
+  if (packageJson.codegenConfig?.name) {
+    return packageJson.codegenConfig.name;
+  }
+
+  const libraryNameRegExp = /libraryName = ["'](.+)["']/;
+  const gradlePath = path.join(androidDir, 'build.gradle');
+  // [1] `libraryName` from build.gradle
+  if (await fileExistsAsync(gradlePath)) {
+    const buildGradleContents = await fs.readFile(gradlePath, 'utf8');
+    const match = buildGradleContents.match(libraryNameRegExp);
+    if (match) {
+      return match[1];
+    }
+  }
+
+  // [2] `libraryName` from build.gradle.kts
+  const gradleKtsPath = path.join(androidDir, 'build.gradle.kts');
+  if (await fileExistsAsync(gradleKtsPath)) {
+    const buildGradleContents = await fs.readFile(gradleKtsPath, 'utf8');
+    const match = buildGradleContents.match(libraryNameRegExp);
+    if (match) {
+      return match[1];
+    }
+  }
+
+  return null;
+}
+
+export async function parseComponentDescriptorsAsync(
+  packageRoot: string,
+  packageJson: any
+): Promise<string[]> {
+  const jsRoot = packageJson?.codegenConfig?.jsSrcsDir
+    ? path.join(packageRoot, packageJson.codegenConfig.jsSrcsDir)
+    : packageRoot;
+  const results = await globMatchFunctorAllAsync(
+    '**/*.{js,jsx,ts,tsx}',
+    matchComponentDescriptors,
+    {
+      cwd: jsRoot,
+      ignore: ['**/node_modules/**'],
+    }
+  );
+
+  // Filter out duplicates as it happens that libraries contain multiple outputs due to package publishing.
+  // TODO: consider using "codegenConfig" to avoid this.
+  return Array.from(new Set(results));
+}
+
+let lazyCodegenComponentRegex: RegExp | null = null;
+function matchComponentDescriptors(filePath: string, contents: Buffer): string | null {
+  const fileContents = contents.toString();
+
+  if (!lazyCodegenComponentRegex) {
+    lazyCodegenComponentRegex =
+      /codegenNativeComponent(<.*>)?\s*\(\s*["'`](\w+)["'`](,?[\s\S]+interfaceOnly:\s*(\w+))?/m;
+  }
+  const match = fileContents.match(lazyCodegenComponentRegex);
+  if (!(match?.[4] === 'true') && match?.[2]) {
+    return `${match[2]}ComponentDescriptor`;
+  }
+  return null;
+}
+
+export async function findGradleAndManifestAsync({
+  androidDir,
+  isLibrary,
+}: {
+  androidDir: string;
+  isLibrary: boolean;
+}): Promise<{ gradle: string | null; manifest: string | null }> {
+  const globExcludes = [
+    'node_modules/**',
+    '**/build/**',
+    '**/debug/**',
+    'Examples/**',
+    'examples/**',
+    '**/Pods/**',
+    '**/sdks/hermes/android/**',
+    '**/src/androidTest/**',
+    '**/src/test/**',
+  ];
+  const gradlePattern = isLibrary ? 'build.gradle{,.kts}' : 'app/build.gradle{,.kts}';
+  const [manifests, gradles] = await Promise.all([
+    glob('**/AndroidManifest.xml', { cwd: androidDir, ignore: globExcludes }),
+    glob(gradlePattern, { cwd: androidDir, ignore: globExcludes }),
+  ]);
+  const manifest =
+    manifests.find((manifest) => manifest.includes('src/main/')) ??
+    manifests.sort((a, b) => a.localeCompare(b))[0];
+  const gradle = gradles.sort((a, b) => a.localeCompare(b))[0];
+  return { gradle: gradle || null, manifest: manifest || null };
+}

package/example/node_modules/expo-modules-autolinking/src/reactNativeConfig/config.ts

@@ -0,0 +1,67 @@
+import fs from 'fs/promises';
+import path from 'path';
+import requireFromString from 'require-from-string';
+import resolveFrom from 'resolve-from';
+
+import type { RNConfigReactNativeConfig } from './reactNativeConfig.types';
+import { fileExistsAsync } from '../fileUtils';
+
+let tsMain: typeof import('typescript') | null | undefined = undefined;
+
+const mockedNativeModules = path.join(__dirname, '..', '..', 'node_modules_mock');
+
+/**
+ * Load the `react-native.config.js` or `react-native.config.ts` from the package.
+ */
+export async function loadConfigAsync<T extends RNConfigReactNativeConfig>(
+  packageRoot: string
+): Promise<T | null> {
+  const configJsPath = path.join(packageRoot, 'react-native.config.js');
+  if (await fileExistsAsync(configJsPath)) {
+    return requireConfig(configJsPath, await fs.readFile(configJsPath, 'utf8'));
+  }
+
+  const configTsPath = path.join(packageRoot, 'react-native.config.ts');
+  if (await fileExistsAsync(configTsPath)) {
+    if (tsMain === undefined) {
+      const tsPath = resolveFrom.silent(packageRoot, 'typescript');
+      if (tsPath) {
+        tsMain = require(tsPath);
+      }
+    } else if (tsMain == null) {
+      return null;
+    }
+
+    const configContents = await fs.readFile(configTsPath, 'utf8');
+    const transpiledContents = tsMain?.transpileModule(configContents, {
+      compilerOptions: {
+        module: tsMain.ModuleKind.NodeNext,
+        moduleResolution: tsMain.ModuleResolutionKind.NodeNext,
+        target: tsMain.ScriptTarget.ESNext,
+      },
+    });
+    const outputText = transpiledContents?.outputText;
+
+    if (outputText) {
+      return requireConfig(configTsPath, outputText);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Temporarily, we need to mock the community CLI, because
+ * some packages are checking the version of the CLI in the `react-native.config.js` file.
+ * We can remove this once we remove this check from packages.
+ */
+function requireConfig(filepath: string, configContents: string) {
+  try {
+    const config = requireFromString(configContents, filepath, {
+      prependPaths: [mockedNativeModules],
+    });
+    return config.default ?? config ?? null;
+  } catch {
+    return null;
+  }
+}

package/example/node_modules/expo-modules-autolinking/src/reactNativeConfig/index.ts

@@ -0,0 +1,2 @@
+export * from './reactNativeConfig';
+export * from './reactNativeConfig.types';

package/example/node_modules/expo-modules-autolinking/src/reactNativeConfig/iosResolver.ts

@@ -0,0 +1,37 @@
+import fs from 'fs/promises';
+import { glob } from 'glob';
+import path from 'path';
+
+import type {
+  RNConfigDependencyIos,
+  RNConfigReactNativePlatformsConfigIos,
+} from './reactNativeConfig.types';
+
+export async function resolveDependencyConfigImplIosAsync(
+  packageRoot: string,
+  reactNativeConfig: RNConfigReactNativePlatformsConfigIos | null | undefined
+): Promise<RNConfigDependencyIos | null> {
+  if (reactNativeConfig === null) {
+    // Skip autolinking for this package.
+    return null;
+  }
+
+  const podspecs = await glob('*.podspec', { cwd: packageRoot });
+  if (!podspecs?.length) {
+    return null;
+  }
+  const mainPackagePodspec = path.basename(packageRoot) + '.podspec';
+  const podspecFile = podspecs.includes(mainPackagePodspec)
+    ? mainPackagePodspec
+    : podspecs.sort((a, b) => a.localeCompare(b))[0];
+  const podspecPath = path.join(packageRoot, podspecFile);
+
+  const packageJson = JSON.parse(await fs.readFile(path.join(packageRoot, 'package.json'), 'utf8'));
+
+  return {
+    podspecPath,
+    version: packageJson.version,
+    configurations: reactNativeConfig?.configurations || [],
+    scriptPhases: reactNativeConfig?.scriptPhases || [],
+  };
+}