@amabeth/repeating-wheel-picker 1.0.0 → 1.2.0

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

@@ -0,0 +1,262 @@
+import commander from 'commander';
+import path from 'path';
+
+import {
+  findModulesAsync,
+  generateModulesProviderAsync,
+  generatePackageListAsync,
+  getConfiguration,
+  getProjectPackageJsonPathAsync,
+  mergeLinkingOptionsAsync,
+  resolveExtraBuildDependenciesAsync,
+  resolveModulesAsync,
+  verifySearchResults,
+} from './autolinking';
+import { type RNConfigCommandOptions, createReactNativeConfigAsync } from './reactNativeConfig';
+import type {
+  ModuleDescriptor,
+  CommonNativeModuleDescriptor,
+  GenerateModulesProviderOptions,
+  GenerateOptions,
+  ResolveOptions,
+  SearchOptions,
+  SearchResults,
+  ModuleDescriptorAndroid,
+  ModuleDescriptorIos,
+} from './types';
+
+function hasCoreFeatures(
+  module: ModuleDescriptor
+): module is ModuleDescriptorAndroid | ModuleDescriptorIos {
+  return (module as CommonNativeModuleDescriptor).coreFeatures !== undefined;
+}
+
+/**
+ * Registers a command that only searches for available expo modules.
+ */
+function registerSearchCommand<OptionsType extends SearchOptions>(
+  commandName: string,
+  fn: (search: SearchResults, options: OptionsType) => any
+) {
+  return commander
+    .command(`${commandName} [paths...]`)
+    .option<string[] | null>(
+      '-i, --ignore-paths <ignorePaths...>',
+      'Paths to ignore when looking up for modules.',
+      (value, previous) => (previous ?? []).concat(value)
+    )
+    .option<string[] | null>(
+      '-e, --exclude <exclude...>',
+      'Package names to exclude when looking up for modules.',
+      (value, previous) => (previous ?? []).concat(value)
+    )
+    .option(
+      '-p, --platform [platform]',
+      'The platform that the resulting modules must support. Available options: "apple", "android"',
+      'apple'
+    )
+    .option('--silent', 'Silence resolution warnings')
+    .addOption(
+      new commander.Option(
+        '--project-root <projectRoot>',
+        'The path to the root of the project'
+      ).default(process.cwd(), 'process.cwd()')
+    )
+    .option(
+      '--only-project-deps',
+      'For a monorepo, include only modules that are the project dependencies.',
+      true
+    )
+    .option('--no-only-project-deps', 'Opposite of --only-project-deps', false)
+    .action(async (searchPaths, providedOptions) => {
+      const options = await mergeLinkingOptionsAsync<OptionsType>(
+        searchPaths.length > 0
+          ? {
+              ...providedOptions,
+              searchPaths,
+            }
+          : providedOptions
+      );
+      const searchResults = await findModulesAsync(options);
+      return await fn(searchResults, options);
+    });
+}
+
+/**
+ * Registers a command that searches for modules and then resolves them for specific platform.
+ */
+function registerResolveCommand<OptionsType extends ResolveOptions>(
+  commandName: string,
+  fn: (search: SearchResults, options: OptionsType) => any
+) {
+  return registerSearchCommand<OptionsType>(commandName, fn);
+}
+
+/**
+ * Registry the `react-native-config` command.
+ */
+function registerReactNativeConfigCommand() {
+  return commander
+    .command('react-native-config [paths...]')
+    .option(
+      '-p, --platform [platform]',
+      'The platform that the resulting modules must support. Available options: "android", "ios"',
+      'ios'
+    )
+    .option(
+      '--transitive-linking-dependencies <transitiveLinkingDependencies...>',
+      'The transitive dependencies to include in autolinking. Internally used by fingerprint and only supported react-native-edge-to-edge.'
+    )
+    .addOption(
+      new commander.Option(
+        '--project-root <projectRoot>',
+        'The path to the root of the project'
+      ).default(process.cwd(), 'process.cwd()')
+    )
+    .option<boolean>('-j, --json', 'Output results in the plain JSON format.', () => true, false)
+    .action(async (searchPaths, providedOptions) => {
+      if (!['android', 'ios'].includes(providedOptions.platform)) {
+        throw new Error(`Unsupported platform: ${providedOptions.platform}`);
+      }
+      const projectRoot = path.dirname(
+        await getProjectPackageJsonPathAsync(providedOptions.projectRoot)
+      );
+      const linkingOptions = await mergeLinkingOptionsAsync<SearchOptions>(
+        searchPaths.length > 0
+          ? {
+              ...providedOptions,
+              projectRoot,
+              searchPaths,
+            }
+          : {
+              ...providedOptions,
+              projectRoot,
+            }
+      );
+      const transitiveLinkingDependencies = providedOptions.transitiveLinkingDependencies ?? [];
+      const options: RNConfigCommandOptions = {
+        platform: linkingOptions.platform,
+        projectRoot,
+        searchPaths: linkingOptions.searchPaths,
+        transitiveLinkingDependencies,
+      };
+      const results = await createReactNativeConfigAsync(options);
+      if (providedOptions.json) {
+        console.log(JSON.stringify(results));
+      } else {
+        console.log(require('util').inspect(results, false, null, true));
+      }
+    });
+}
+
+module.exports = async function (args: string[]) {
+  // Searches for available expo modules.
+  registerSearchCommand<SearchOptions & { json?: boolean }>('search', async (results, options) => {
+    if (options.json) {
+      console.log(JSON.stringify(results));
+    } else {
+      console.log(require('util').inspect(results, false, null, true));
+    }
+  }).option<boolean>('-j, --json', 'Output results in the plain JSON format.', () => true, false);
+
+  // Checks whether there are no resolving issues in the current setup.
+  registerSearchCommand('verify', (results, options) => {
+    const numberOfDuplicates = verifySearchResults(results, options);
+    if (!numberOfDuplicates) {
+      console.log('✅ Everything is fine!');
+    }
+  });
+
+  // Searches for available expo modules and resolves the results for given platform.
+  registerResolveCommand('resolve', async (results, options) => {
+    const modules = await resolveModulesAsync(results, options);
+    const extraDependencies = await resolveExtraBuildDependenciesAsync(options);
+    const configuration = getConfiguration(options);
+
+    const coreFeatures = [
+      ...modules.reduce<Set<string>>((acc, module) => {
+        if (hasCoreFeatures(module)) {
+          const features = module.coreFeatures ?? [];
+          for (const feature of features) {
+            acc.add(feature);
+          }
+          return acc;
+        }
+
+        return acc;
+      }, new Set()),
+    ];
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          extraDependencies,
+          coreFeatures,
+          modules,
+          ...(configuration ? { configuration } : {}),
+        })
+      );
+    } else {
+      console.log(
+        require('util').inspect(
+          {
+            extraDependencies,
+            coreFeatures,
+            modules,
+            ...(configuration ? { configuration } : {}),
+          },
+          false,
+          null,
+          true
+        )
+      );
+    }
+  }).option<boolean>('-j, --json', 'Output results in the plain JSON format.', () => true, false);
+
+  // Generates a source file listing all packages to link.
+  // It's deprecated for apple platforms, use `generate-modules-provider` instead.
+  registerResolveCommand<GenerateOptions>('generate-package-list', async (results, options) => {
+    const modules = options.empty ? [] : await resolveModulesAsync(results, options);
+    generatePackageListAsync(modules, options);
+  })
+    .option(
+      '-t, --target <path>',
+      'Path to the target file, where the package list should be written to.'
+    )
+    .option(
+      '-n, --namespace <namespace>',
+      'Java package name under which the package list should be placed.'
+    )
+    .option(
+      '--empty',
+      'Whether to only generate an empty list. Might be used when the user opts-out of autolinking.',
+      false
+    );
+
+  // Generates a source file listing all packages to link in the runtime.
+  registerResolveCommand<GenerateModulesProviderOptions>(
+    'generate-modules-provider',
+    async (results, options) => {
+      const packages = options.packages ?? [];
+      const modules = await resolveModulesAsync(results, options);
+      const filteredModules = modules.filter((module) => packages.includes(module.packageName));
+
+      generateModulesProviderAsync(filteredModules, options);
+    }
+  )
+    .option(
+      '-t, --target <path>',
+      'Path to the target file, where the package list should be written to.'
+    )
+    .option('--entitlement <path>', 'Path to the Apple code signing entitlements file.')
+    .option(
+      '-p, --packages <packages...>',
+      'Names of the packages to include in the generated modules provider.'
+    );
+
+  registerReactNativeConfigCommand();
+
+  await commander
+    .version(require('expo-modules-autolinking/package.json').version)
+    .description('CLI command that searches for Expo modules to autolink them.')
+    .parseAsync(args, { from: 'user' });
+};

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

@@ -0,0 +1,303 @@
+import fs from 'fs';
+import { glob } from 'glob';
+import path from 'path';
+
+import type {
+  ExtraDependencies,
+  ModuleDescriptorAndroid,
+  PackageRevision,
+  ResolveOptions,
+} from '../types';
+
+const ANDROID_PROPERTIES_FILE = 'gradle.properties';
+const ANDROID_EXTRA_BUILD_DEPS_KEY = 'android.extraMavenRepos';
+
+export function getConfiguration(options: ResolveOptions): Record<string, any> | undefined {
+  const buildFromSource = options.android?.buildFromSource;
+  if (buildFromSource) {
+    return { buildFromSource };
+  }
+  return undefined;
+}
+
+/**
+ * Generates Java file that contains all autolinked packages.
+ */
+export async function generatePackageListAsync(
+  modules: ModuleDescriptorAndroid[],
+  targetPath: string,
+  namespace: string
+): Promise<void> {
+  const generatedFileContent = await generatePackageListFileContentAsync(modules, namespace);
+  const parentPath = path.dirname(targetPath);
+  if (!fs.existsSync(parentPath)) {
+    await fs.promises.mkdir(parentPath, { recursive: true });
+  }
+  await fs.promises.writeFile(targetPath, generatedFileContent, 'utf8');
+}
+
+export function isAndroidProject(projectRoot: string): boolean {
+  return (
+    fs.existsSync(path.join(projectRoot, 'build.gradle')) ||
+    fs.existsSync(path.join(projectRoot, 'build.gradle.kts'))
+  );
+}
+
+export async function resolveModuleAsync(
+  packageName: string,
+  revision: PackageRevision
+): Promise<ModuleDescriptorAndroid | null> {
+  // TODO: Relative source dir should be configurable through the module config.
+
+  // Don't link itself... :D
+  if (packageName === '@unimodules/react-native-adapter') {
+    return null;
+  }
+
+  const plugins = (revision.config?.androidGradlePlugins() ?? []).map(
+    ({ id, group, sourceDir, applyToRootProject }) => ({
+      id,
+      group,
+      sourceDir: path.join(revision.path, sourceDir),
+      applyToRootProject: applyToRootProject ?? true,
+    })
+  );
+
+  const defaultProjectName = convertPackageToProjectName(packageName);
+
+  const androidProjects = revision.config
+    ?.androidProjects(defaultProjectName)
+    ?.filter((project) => {
+      return !project.isDefault || isAndroidProject(path.join(revision.path, project.path));
+    });
+
+  // Just in case where the module doesn't have its own `build.gradle`/`settings.gradle`.
+  if (!androidProjects?.length) {
+    if (!plugins.length) {
+      return null;
+    }
+
+    return {
+      packageName,
+      plugins,
+    };
+  }
+
+  const projects = androidProjects.map((project) => {
+    const projectPath = path.join(revision.path, project.path);
+
+    const aarProjects = (project.gradleAarProjects ?? [])?.map((aarProject) => {
+      const projectName = `${defaultProjectName}$${aarProject.name}`;
+      const projectDir = path.join(projectPath, 'build', projectName);
+      return {
+        name: projectName,
+        aarFilePath: path.join(revision.path, aarProject.aarFilePath),
+        projectDir,
+      };
+    });
+
+    const { publication } = project;
+    const shouldUsePublicationScriptPath = project.shouldUsePublicationScriptPath
+      ? path.join(revision.path, project.shouldUsePublicationScriptPath)
+      : undefined;
+
+    return {
+      name: project.name,
+      sourceDir: projectPath,
+      modules: project.modules ?? [],
+      ...(shouldUsePublicationScriptPath ? { shouldUsePublicationScriptPath } : {}),
+      ...(publication ? { publication } : {}),
+      ...(aarProjects?.length > 0 ? { aarProjects } : {}),
+    };
+  });
+
+  const coreFeatures = revision.config?.coreFeatures() ?? [];
+
+  return {
+    packageName,
+    projects,
+    ...(plugins?.length > 0 ? { plugins } : {}),
+    ...(coreFeatures.length > 0 ? { coreFeatures } : {}),
+  };
+}
+
+export async function resolveExtraBuildDependenciesAsync(
+  projectNativeRoot: string
+): Promise<ExtraDependencies | null> {
+  const extraMavenReposString = await resolveGradlePropertyAsync(
+    projectNativeRoot,
+    ANDROID_EXTRA_BUILD_DEPS_KEY
+  );
+  if (extraMavenReposString) {
+    try {
+      return JSON.parse(extraMavenReposString);
+    } catch {}
+  }
+  return null;
+}
+
+export async function resolveGradlePropertyAsync(
+  projectNativeRoot: string,
+  propertyKey: string
+): Promise<string | null> {
+  const propsFile = path.join(projectNativeRoot, ANDROID_PROPERTIES_FILE);
+  try {
+    const contents = await fs.promises.readFile(propsFile, 'utf8');
+    const propertyValue = searchGradlePropertyFirst(contents, propertyKey);
+    if (propertyValue) {
+      return propertyValue;
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Generates the string to put into the generated package list.
+ */
+async function generatePackageListFileContentAsync(
+  modules: ModuleDescriptorAndroid[],
+  namespace: string
+): Promise<string> {
+  // TODO: Instead of ignoring `expo` here, make the package class paths configurable from `expo-module.config.json`.
+  const packagesClasses = await findAndroidPackagesAsync(
+    modules.filter((module) => module.packageName !== 'expo')
+  );
+
+  const modulesClasses = await findAndroidModules(modules);
+
+  return `package ${namespace};
+
+import java.util.Arrays;
+import java.util.List;
+import expo.modules.core.interfaces.Package;
+import expo.modules.kotlin.modules.Module;
+import expo.modules.kotlin.ModulesProvider;
+
+public class ExpoModulesPackageList implements ModulesProvider {
+  private static class LazyHolder {
+    static final List<Package> packagesList = Arrays.<Package>asList(
+${packagesClasses.map((packageClass) => `      new ${packageClass}()`).join(',\n')}
+    );
+
+    static final List<Class<? extends Module>> modulesList = Arrays.<Class<? extends Module>>asList(
+      ${modulesClasses.map((moduleClass) => `      ${moduleClass}.class`).join(',\n')}
+    );
+  }
+
+  public static List<Package> getPackageList() {
+    return LazyHolder.packagesList;
+  }
+
+  @Override
+  public List<Class<? extends Module>> getModulesList() {
+    return LazyHolder.modulesList;
+  }
+}
+`;
+}
+
+function findAndroidModules(modules: ModuleDescriptorAndroid[]): string[] {
+  const projects = modules.flatMap((module) => module.projects ?? []);
+
+  const modulesToProvide = projects.filter((project) => project.modules?.length > 0);
+  const classNames = ([] as string[]).concat(...modulesToProvide.map((module) => module.modules));
+  return classNames;
+}
+
+async function findAndroidPackagesAsync(modules: ModuleDescriptorAndroid[]): Promise<string[]> {
+  const classes: string[] = [];
+
+  const flattenedSourceDirList: string[] = [];
+  for (const module of modules) {
+    for (const project of module.projects ?? []) {
+      flattenedSourceDirList.push(project.sourceDir);
+    }
+  }
+
+  await Promise.all(
+    flattenedSourceDirList.map(async (sourceDir) => {
+      const files = await glob('**/*Package.{java,kt}', {
+        cwd: sourceDir,
+      });
+
+      for (const file of files) {
+        const fileContent = await fs.promises.readFile(path.join(sourceDir, file), 'utf8');
+
+        const packageRegex = (() => {
+          if (process.env.EXPO_SHOULD_USE_LEGACY_PACKAGE_INTERFACE) {
+            return /\bimport\s+org\.unimodules\.core\.(interfaces\.Package|BasePackage)\b/;
+          } else {
+            return /\bimport\s+expo\.modules\.core\.(interfaces\.Package|BasePackage)\b/;
+          }
+        })();
+
+        // Very naive check to skip non-expo packages
+        if (!packageRegex.test(fileContent)) {
+          continue;
+        }
+
+        const classPathMatches = fileContent.match(/^package ([\w.]+)\b/m);
+
+        if (classPathMatches) {
+          const basename = path.basename(file, path.extname(file));
+          classes.push(`${classPathMatches[1]}.${basename}`);
+        }
+      }
+    })
+  );
+  return classes.sort();
+}
+
+/**
+ * Converts the package name to Android's project name.
+ *   `/` path will transform as `-`
+ *
+ * Example: `@expo/example` + `android/build.gradle` → `expo-example`
+ */
+export function convertPackageToProjectName(packageName: string): string {
+  return packageName.replace(/^@/g, '').replace(/\W+/g, '-');
+}
+
+/**
+ * Converts the package name and gradle file path to Android's project name.
+ *   `$` to indicate subprojects
+ *   `/` path will transform as `-`
+ *
+ * Example: `@expo/example` + `android/build.gradle` → `expo-example`
+ *
+ * Example: multiple projects
+ *   - `expo-test` + `android/build.gradle` → `react-native-third-party`
+ *   - `expo-test` + `subproject/build.gradle` → `react-native-third-party$subproject`
+ */
+export function convertPackageWithGradleToProjectName(
+  packageName: string,
+  buildGradleFile: string
+): string {
+  const name = convertPackageToProjectName(packageName);
+  const baseDir = path.dirname(buildGradleFile).replace(/\//g, '-');
+  return baseDir === 'android' ? name : `${name}$${baseDir}`;
+}
+
+/**
+ * Given the contents of a `gradle.properties` file,
+ * searches for a property with the given name.
+ *
+ * This function will return the first property found with the given name.
+ * The implementation follows config-plugins and
+ * tries to align the behavior with the `withGradleProperties` plugin.
+ */
+export function searchGradlePropertyFirst(contents: string, propertyName: string): string | null {
+  const lines = contents.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line && !line.startsWith('#')) {
+      const eok = line.indexOf('=');
+      const key = line.slice(0, eok);
+      if (key === propertyName) {
+        const value = line.slice(eok + 1, line.length);
+        return value;
+      }
+    }
+  }
+  return null;
+}