@amabeth/repeating-wheel-picker 1.1.0 → 1.2.0

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

@@ -0,0 +1,259 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { glob } from 'glob';
+import { createRequire } from 'module';
+import path from 'path';
+
+import { getProjectPackageJsonPathAsync, mergeLinkingOptionsAsync } from './mergeLinkingOptions';
+import { getIsolatedModulesPath } from './utils';
+import { requireAndResolveExpoModuleConfig } from '../ExpoModuleConfig';
+import { PackageRevision, SearchOptions, SearchResults } from '../types';
+
+// Names of the config files. From lowest to highest priority.
+const EXPO_MODULE_CONFIG_FILENAMES = ['unimodule.json', 'expo-module.config.json'];
+
+/**
+ * Searches for modules to link based on given config.
+ */
+export async function findModulesAsync(providedOptions: SearchOptions): Promise<SearchResults> {
+  const options = await mergeLinkingOptionsAsync(providedOptions);
+  const results: Map<string, PackageRevision> = new Map();
+
+  const nativeModuleNames = new Set<string>();
+
+  // custom native modules should be resolved first so that they can override other modules
+  const searchPaths = new Set(
+    options.nativeModulesDir && fs.existsSync(options.nativeModulesDir)
+      ? [options.nativeModulesDir, ...options.searchPaths]
+      : options.searchPaths
+  );
+
+  // `searchPaths` can be mutated to discover all "isolated modules groups", when using isolated modules
+  for (const searchPath of searchPaths) {
+    const isNativeModulesDir = searchPath === options.nativeModulesDir;
+
+    const packageConfigPaths = await findPackagesConfigPathsAsync(searchPath);
+
+    for (const packageConfigPath of packageConfigPaths) {
+      const packagePath = await fs.promises.realpath(
+        path.join(searchPath, path.dirname(packageConfigPath))
+      );
+      const expoModuleConfig = requireAndResolveExpoModuleConfig(
+        path.join(packagePath, path.basename(packageConfigPath))
+      );
+
+      const { name, version } = resolvePackageNameAndVersion(packagePath, {
+        fallbackToDirName: isNativeModulesDir,
+      });
+
+      const maybeIsolatedModulesPath = getIsolatedModulesPath(packagePath, name);
+      if (maybeIsolatedModulesPath) {
+        searchPaths.add(maybeIsolatedModulesPath);
+      }
+
+      if (options.exclude?.includes(name) || !expoModuleConfig.supportsPlatform(options.platform)) {
+        continue;
+      }
+
+      // add the current revision to the results
+      const currentRevision: PackageRevision = {
+        path: packagePath,
+        version,
+        config: expoModuleConfig,
+      };
+      addRevisionToResults(results, name, currentRevision);
+
+      // if the module is a native module, we need to add it to the nativeModuleNames set
+      if (isNativeModulesDir && !nativeModuleNames.has(name)) {
+        nativeModuleNames.add(name);
+      }
+    }
+  }
+
+  const searchResults: SearchResults = Object.fromEntries(results.entries());
+
+  // It doesn't make much sense to strip modules if there is only one search path.
+  // (excluding custom native modules path)
+  // Workspace root usually doesn't specify all its dependencies (see Expo Go),
+  // so in this case we should link everything.
+  if (options.searchPaths.length <= 1 || options.onlyProjectDeps === false) {
+    return searchResults;
+  }
+
+  return await filterToProjectDependenciesAsync(searchResults, {
+    ...providedOptions,
+    // Custom native modules are not filtered out
+    // when they're not specified in package.json dependencies.
+    alwaysIncludedPackagesNames: nativeModuleNames,
+  });
+}
+
+/**
+ * Returns the priority of the config at given path. Higher number means higher priority.
+ */
+function configPriority(fullpath: string): number {
+  return EXPO_MODULE_CONFIG_FILENAMES.indexOf(path.basename(fullpath));
+}
+
+/**
+ * Adds {@link revision} to the {@link results} map
+ * or to package duplicates if it already exists.
+ * @param results [mutable] yet resolved packages map
+ * @param name resolved package name
+ * @param revision resolved package revision
+ */
+function addRevisionToResults(
+  results: Map<string, PackageRevision>,
+  name: string,
+  revision: PackageRevision
+): void {
+  if (!results.has(name)) {
+    // The revision that was found first will be the main one.
+    // An array of duplicates and the config are needed only here.
+    results.set(name, {
+      ...revision,
+      duplicates: [],
+    });
+  } else if (
+    results.get(name)?.path !== revision.path &&
+    results.get(name)?.duplicates?.every(({ path }) => path !== revision.path)
+  ) {
+    const { config, duplicates, ...duplicateEntry } = revision;
+    results.get(name)?.duplicates?.push(duplicateEntry);
+  }
+}
+
+/**
+ * Returns paths to the highest priority config files, relative to the {@link searchPath}.
+ * @example
+ * ```
+ * // Given the following file exists: /foo/myapp/modules/mymodule/expo-module.config.json
+ * await findPackagesConfigPathsAsync('/foo/myapp/modules');
+ * // returns ['mymodule/expo-module.config.json']
+ *
+ * await findPackagesConfigPathsAsync('/foo/myapp/modules/mymodule');
+ * // returns ['expo-module.config.json']
+ * ```
+ */
+async function findPackagesConfigPathsAsync(searchPath: string): Promise<string[]> {
+  const bracedFilenames = '{' + EXPO_MODULE_CONFIG_FILENAMES.join(',') + '}';
+  const paths = await glob(
+    [`*/${bracedFilenames}`, `@*/*/${bracedFilenames}`, `./${bracedFilenames}`],
+    {
+      cwd: searchPath,
+    }
+  );
+
+  // If the package has multiple configs (e.g. `unimodule.json` and `expo-module.config.json` during the transition time)
+  // then we want to give `expo-module.config.json` the priority.
+  return Object.values(
+    paths.reduce<Record<string, string>>((acc, configPath) => {
+      const dirname = path.dirname(configPath);
+
+      if (!acc[dirname] || configPriority(configPath) > configPriority(acc[dirname])) {
+        acc[dirname] = configPath;
+      }
+      return acc;
+    }, {})
+  );
+}
+
+/**
+ * Resolves package name and version for the given {@link packagePath} from its `package.json`.
+ * if {@link fallbackToDirName} is true, it returns the dir name when `package.json` doesn't exist.
+ * @returns object with `name` and `version` properties. `version` falls back to `UNVERSIONED` if cannot be resolved.
+ */
+function resolvePackageNameAndVersion(
+  packagePath: string,
+  { fallbackToDirName }: { fallbackToDirName?: boolean } = {}
+): { name: string; version: string } {
+  try {
+    const { name, version } = require(path.join(packagePath, 'package.json'));
+    return { name, version: version || 'UNVERSIONED' };
+  } catch (e) {
+    if (fallbackToDirName) {
+      // we don't have the package.json name, so we'll use the directory name
+      return {
+        name: path.basename(packagePath),
+        version: 'UNVERSIONED',
+      };
+    } else {
+      throw e;
+    }
+  }
+}
+
+/**
+ * Filters out packages that are not the dependencies of the project.
+ */
+async function filterToProjectDependenciesAsync(
+  results: SearchResults,
+  options: Pick<SearchOptions, 'projectRoot' | 'silent'> & {
+    alwaysIncludedPackagesNames?: Set<string>;
+  }
+): Promise<SearchResults> {
+  const filteredResults: SearchResults = {};
+  const visitedPackages = new Set<string>();
+
+  // iterate through always included package names and add them to the visited packages
+  // if the results contains them
+  for (const name of options.alwaysIncludedPackagesNames ?? []) {
+    if (results[name] && !visitedPackages.has(name)) {
+      filteredResults[name] = results[name];
+      visitedPackages.add(name);
+    }
+  }
+
+  // Helper for traversing the dependency hierarchy.
+  function visitPackage(packageJsonPath: string) {
+    const packageJson = require(packageJsonPath);
+
+    // Prevent getting into the recursive loop.
+    if (visitedPackages.has(packageJson.name)) {
+      return;
+    }
+    visitedPackages.add(packageJson.name);
+
+    // Iterate over the dependencies to find transitive modules.
+    for (const dependencyName in packageJson.dependencies) {
+      const dependencyResult = results[dependencyName];
+
+      if (!filteredResults[dependencyName]) {
+        let dependencyPackageJsonPath: string;
+
+        if (dependencyResult) {
+          filteredResults[dependencyName] = dependencyResult;
+          dependencyPackageJsonPath = path.join(dependencyResult.path, 'package.json');
+        } else {
+          try {
+            /**
+             * Custom `require` that resolves from the current working dir instead of this script path.
+             * **Requires Node v12.2.0**
+             */
+            const projectRequire = createRequire(packageJsonPath);
+            dependencyPackageJsonPath = projectRequire.resolve(`${dependencyName}/package.json`);
+          } catch (error: any) {
+            // Some packages don't include package.json in its `exports` field,
+            // but none of our packages do that, so it seems fine to just ignore that type of error.
+            // Related issue: https://github.com/react-native-community/cli/issues/1168
+            if (!options.silent && error.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+              console.warn(
+                chalk.yellow(`⚠️  Cannot resolve the path to "${dependencyName}" package.`)
+              );
+            }
+            continue;
+          }
+        }
+
+        // Visit the dependency package.
+        visitPackage(dependencyPackageJsonPath);
+      }
+    }
+  }
+
+  // Visit project's package.
+  const projectPackageJsonPath = await getProjectPackageJsonPathAsync(options.projectRoot);
+  visitPackage(projectPackageJsonPath);
+
+  return filteredResults;
+}

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

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+
+import { getLinkingImplementationForPlatform } from './utils';
+import { GenerateModulesProviderOptions, GenerateOptions, ModuleDescriptor } from '../types';
+
+/**
+ * Generates a source file listing all packages to link.
+ * Right know it works only for Android platform.
+ */
+export async function generatePackageListAsync(
+  modules: ModuleDescriptor[],
+  options: GenerateOptions
+) {
+  try {
+    const platformLinking = getLinkingImplementationForPlatform(options.platform);
+    await platformLinking.generatePackageListAsync(modules, options.target, options.namespace);
+  } catch (e) {
+    console.error(
+      chalk.red(`Generating package list is not available for platform: ${options.platform}`)
+    );
+    throw e;
+  }
+}
+
+/**
+ * Generates ExpoModulesProvider file listing all packages to link.
+ * Right know it works only for Apple platforms.
+ */
+export async function generateModulesProviderAsync(
+  modules: ModuleDescriptor[],
+  options: GenerateModulesProviderOptions
+) {
+  try {
+    const platformLinking = getLinkingImplementationForPlatform(options.platform);
+    await platformLinking.generateModulesProviderAsync(
+      modules,
+      options.target,
+      options.entitlement
+    );
+  } catch (e) {
+    console.error(
+      chalk.red(`Generating modules provider is not available for platform: ${options.platform}`)
+    );
+    throw e;
+  }
+}

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

@@ -0,0 +1,7 @@
+import type { ResolveOptions } from '../types';
+import { getLinkingImplementationForPlatform } from './utils';
+
+export function getConfiguration(options: ResolveOptions) {
+  const platformLinking = getLinkingImplementationForPlatform(options.platform);
+  return platformLinking.getConfiguration?.(options);
+}

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

@@ -0,0 +1,45 @@
+import path from 'path';
+
+import { findModulesAsync } from './findModules';
+import {
+  getProjectPackageJsonPathAsync,
+  getProjectPackageJsonPathSync,
+  mergeLinkingOptionsAsync,
+  resolveSearchPathsAsync,
+} from './mergeLinkingOptions';
+import { resolveExtraBuildDependenciesAsync, resolveModulesAsync } from './resolveModules';
+import type { ModuleDescriptor, SearchOptions } from '../types';
+import { getConfiguration } from './getConfiguration';
+
+export {
+  findModulesAsync,
+  getProjectPackageJsonPathAsync,
+  mergeLinkingOptionsAsync,
+  resolveExtraBuildDependenciesAsync,
+  resolveModulesAsync,
+  resolveSearchPathsAsync,
+  getConfiguration,
+};
+export { generateModulesProviderAsync, generatePackageListAsync } from './generatePackageList';
+export { verifySearchResults } from './verifySearchResults';
+export * from '../types';
+
+/**
+ * Programmatic API to query autolinked modules for a project.
+ */
+export async function queryAutolinkingModulesFromProjectAsync(
+  projectRoot: string,
+  options: Pick<SearchOptions, 'platform' | 'exclude' | 'onlyProjectDeps'>
+): Promise<ModuleDescriptor[]> {
+  const searchPaths = await resolveSearchPathsAsync(null, projectRoot);
+  const linkOptions = await mergeLinkingOptionsAsync({ ...options, projectRoot, searchPaths });
+  const searchResults = await findModulesAsync(linkOptions);
+  return await resolveModulesAsync(searchResults, linkOptions);
+}
+
+/**
+ * Get the project root directory from the current working directory.
+ */
+export function findProjectRootSync(cwd: string = process.cwd()): string {
+  return path.dirname(getProjectPackageJsonPathSync(cwd));
+}

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

@@ -0,0 +1,127 @@
+import findUp from 'find-up';
+import fs from 'fs';
+import path from 'path';
+
+import type { PlatformAutolinkingOptions, SearchOptions, SupportedPlatform } from '../types';
+
+/**
+ * Find the path to the `package.json` of the closest project in the given project root.
+ */
+export async function getProjectPackageJsonPathAsync(projectRoot: string): Promise<string> {
+  const result = await findUp('package.json', { cwd: projectRoot });
+  if (!result) {
+    throw new Error(`Couldn't find "package.json" up from path "${projectRoot}"`);
+  }
+  return result;
+}
+
+/**
+ * Synchronous version of {@link getProjectPackageJsonPathAsync}.
+ */
+export function getProjectPackageJsonPathSync(projectRoot: string): string {
+  const result = findUp.sync('package.json', { cwd: projectRoot });
+  if (!result) {
+    throw new Error(`Couldn't find "package.json" up from path "${projectRoot}"`);
+  }
+  return result;
+}
+
+/**
+ * Merges autolinking options from different sources (the later the higher priority)
+ * - options defined in package.json's `expo.autolinking` field
+ * - platform-specific options from the above (e.g. `expo.autolinking.apple`)
+ * - options provided to the CLI command
+ */
+export async function mergeLinkingOptionsAsync<OptionsType extends SearchOptions>(
+  providedOptions: OptionsType
+): Promise<OptionsType> {
+  const packageJson = require(await getProjectPackageJsonPathAsync(providedOptions.projectRoot));
+  const baseOptions = packageJson.expo?.autolinking as PlatformAutolinkingOptions;
+  const platformOptions = getPlatformOptions(providedOptions.platform, baseOptions);
+  const finalOptions = Object.assign(
+    {},
+    baseOptions,
+    platformOptions,
+    providedOptions
+  ) as OptionsType;
+
+  // Makes provided paths absolute or falls back to default paths if none was provided.
+  finalOptions.searchPaths = await resolveSearchPathsAsync(
+    finalOptions.searchPaths,
+    providedOptions.projectRoot
+  );
+
+  finalOptions.nativeModulesDir = await resolveNativeModulesDirAsync(
+    finalOptions.nativeModulesDir,
+    providedOptions.projectRoot
+  );
+
+  return finalOptions;
+}
+
+/**
+ * Resolves autolinking search paths. If none is provided, it accumulates all node_modules when
+ * going up through the path components. This makes workspaces work out-of-the-box without any configs.
+ */
+export async function resolveSearchPathsAsync(
+  searchPaths: string[] | null,
+  cwd: string
+): Promise<string[]> {
+  return searchPaths && searchPaths.length > 0
+    ? searchPaths.map((searchPath) => path.resolve(cwd, searchPath))
+    : await findDefaultPathsAsync(cwd);
+}
+
+/**
+ * Looks up for workspace's `node_modules` paths.
+ */
+async function findDefaultPathsAsync(cwd: string): Promise<string[]> {
+  const paths = [];
+  let dir = cwd;
+  let pkgJsonPath: string | undefined;
+
+  while ((pkgJsonPath = await findUp('package.json', { cwd: dir }))) {
+    dir = path.dirname(path.dirname(pkgJsonPath));
+    paths.push(path.join(pkgJsonPath, '..', 'node_modules'));
+
+    // This stops the infinite loop when the package.json is placed at the root dir.
+    if (path.dirname(dir) === dir) {
+      break;
+    }
+  }
+  return paths;
+}
+
+/**
+ * Finds the real path to custom native modules directory.
+ * - When {@link cwd} is inside the project directory, the path is searched relatively
+ * to the project root (directory with the `package.json` file).
+ * - When {@link cwd} is outside project directory (no `package.json` found), it is relative to
+ * the current working directory (the {@link cwd} param).
+ *
+ * @param nativeModulesDir path to custom native modules directory. Defaults to `"./modules"` if null.
+ * @param cwd current working directory
+ * @returns resolved native modules directory or `null` if it is not found or doesn't exist.
+ */
+async function resolveNativeModulesDirAsync(
+  nativeModulesDir: string | null | undefined,
+  cwd: string
+): Promise<string | null> {
+  const packageJsonPath = await findUp('package.json', { cwd });
+  const projectRoot = packageJsonPath != null ? path.join(packageJsonPath, '..') : cwd;
+  const resolvedPath = path.resolve(projectRoot, nativeModulesDir || 'modules');
+  return fs.existsSync(resolvedPath) ? resolvedPath : null;
+}
+
+/**
+ * Gets the platform-specific autolinking options from the base options.
+ */
+function getPlatformOptions(
+  platform: SupportedPlatform,
+  options?: PlatformAutolinkingOptions
+): PlatformAutolinkingOptions {
+  if (platform === 'apple') {
+    return options?.apple ?? options?.ios ?? {};
+  }
+  return options?.[platform] ?? {};
+}

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

@@ -0,0 +1,46 @@
+import { getLinkingImplementationForPlatform } from './utils';
+import type { ExtraDependencies, ModuleDescriptor, ResolveOptions, SearchResults } from '../types';
+
+/**
+ * Resolves search results to a list of platform-specific configuration.
+ */
+export async function resolveModulesAsync(
+  searchResults: SearchResults,
+  options: ResolveOptions
+): Promise<ModuleDescriptor[]> {
+  const platformLinking = getLinkingImplementationForPlatform(options.platform);
+
+  return (
+    await Promise.all(
+      Object.entries(searchResults).map(async ([packageName, revision]) => {
+        const resolvedModule = await platformLinking.resolveModuleAsync(
+          packageName,
+          revision,
+          options
+        );
+        return resolvedModule
+          ? {
+              packageName,
+              packageVersion: revision.version,
+              ...resolvedModule,
+            }
+          : null;
+      })
+    )
+  )
+    .filter(Boolean)
+    .sort((a, b) => a.packageName.localeCompare(b.packageName));
+}
+
+/**
+ * Resolves the extra build dependencies for the project, such as additional Maven repositories or CocoaPods pods.
+ */
+export async function resolveExtraBuildDependenciesAsync(
+  options: ResolveOptions
+): Promise<ExtraDependencies> {
+  const platformLinking = getLinkingImplementationForPlatform(options.platform);
+  const extraDependencies = await platformLinking.resolveExtraBuildDependenciesAsync(
+    options.projectRoot
+  );
+  return extraDependencies ?? [];
+}

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

@@ -0,0 +1,37 @@
+import path from 'path';
+
+import { SupportedPlatform } from '../types';
+
+export function getLinkingImplementationForPlatform(platform: SupportedPlatform) {
+  switch (platform) {
+    case 'ios':
+    case 'macos':
+    case 'tvos':
+    case 'apple':
+      return require('../platforms/apple');
+    case 'android':
+      return require('../platforms/android');
+    case 'devtools':
+      return require('../platforms/devtools');
+  }
+}
+
+/**
+ * Get the possible path to the pnpm isolated modules folder.
+ */
+export function getIsolatedModulesPath(packagePath: string, packageName: string): string | null {
+  // Check if the project is using isolated modules, by checking
+  // if the parent dir of `packagePath` is a `node_modules` folder.
+  // Isolated modules installs dependencies in small groups such as:
+  //   - /.pnpm/expo@50.x.x(...)/node_modules/@expo/cli
+  //   - /.pnpm/expo@50.x.x(...)/node_modules/expo
+  //   - /.pnpm/expo@50.x.x(...)/node_modules/expo-application
+  // When isolated modules are detected, expand the `searchPaths`
+  // to include possible nested dependencies.
+  const maybeIsolatedModulesPath = path.join(
+    packagePath,
+    packageName.startsWith('@') && packageName.includes('/') ? '../..' : '..' // scoped packages are nested deeper
+  );
+  const isIsolatedModulesPath = path.basename(maybeIsolatedModulesPath) === 'node_modules';
+  return isIsolatedModulesPath ? maybeIsolatedModulesPath : null;
+}

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

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import path from 'path';
+
+import { PackageRevision, SearchOptions, SearchResults } from '../types';
+
+/**
+ * Verifies the search results by checking whether there are no duplicates.
+ */
+export function verifySearchResults(searchResults: SearchResults, options: SearchOptions): number {
+  const relativePath: (pkg: PackageRevision) => string = (pkg) =>
+    path.relative(options.projectRoot, pkg.path);
+  let counter = 0;
+
+  for (const moduleName in searchResults) {
+    const revision = searchResults[moduleName];
+
+    if (revision.duplicates?.length) {
+      console.warn(`⚠️  Found multiple versions of ${chalk.green(moduleName)}`);
+      console.log(` - ${chalk.magenta(relativePath(revision))} (${chalk.cyan(revision.version)})`);
+
+      for (const duplicate of revision.duplicates) {
+        console.log(` - ${chalk.gray(relativePath(duplicate))} (${chalk.gray(duplicate.version)})`);
+      }
+      counter++;
+    }
+  }
+  if (counter > 0) {
+    console.warn(
+      '⚠️  Multiple versions of the same module may introduce some side effects or compatibility issues. Remove the duplicate versions.'
+    );
+  }
+  return counter;
+}

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

@@ -0,0 +1,64 @@
+import fs from 'fs/promises';
+import { glob, GlobOptions } from 'glob';
+import path from 'path';
+
+/**
+ * A matching function that takes a file path and its contents and returns a string if it matches, or null otherwise.
+ */
+type MatchFunctor = (filePath: string, contents: Buffer) => string | null;
+
+/**
+ * Check if the file exists.
+ */
+export async function fileExistsAsync(file: string): Promise<boolean> {
+  return (await fs.stat(file).catch(() => null))?.isFile() ?? false;
+}
+
+/**
+ * Search files that match the glob pattern and return all matches from the matchFunctor.
+ */
+export async function globMatchFunctorAllAsync(
+  globPattern: string,
+  matchFunctor: MatchFunctor,
+  options?: GlobOptions
+): Promise<string[]> {
+  const globStream = glob.stream(globPattern, { ...options, withFileTypes: false });
+  const cwd = options?.cwd !== undefined ? `${options.cwd}` : process.cwd();
+  const results: string[] = [];
+  for await (const file of globStream) {
+    let filePath = file.toString();
+    if (!path.isAbsolute(filePath)) {
+      filePath = path.resolve(cwd, filePath);
+    }
+    const contents = await fs.readFile(filePath);
+    const matched = matchFunctor(filePath, contents);
+    if (matched != null) {
+      results.push(matched);
+    }
+  }
+  return results;
+}
+
+/**
+ * Search files that match the glob pattern and return the first match from the matchFunctor.
+ */
+export async function globMatchFunctorFirstAsync(
+  globPattern: string,
+  matchFunctor: MatchFunctor,
+  options?: GlobOptions
+): Promise<string | null> {
+  const globStream = glob.stream(globPattern, { ...options, withFileTypes: false });
+  const cwd = options?.cwd !== undefined ? `${options.cwd}` : process.cwd();
+  for await (const file of globStream) {
+    let filePath = file.toString();
+    if (!path.isAbsolute(filePath)) {
+      filePath = path.resolve(cwd, filePath);
+    }
+    const contents = await fs.readFile(filePath);
+    const matched = matchFunctor(filePath, contents);
+    if (matched != null) {
+      return matched;
+    }
+  }
+  return null;
+}