@expo/fingerprint 0.0.10 → 0.2.0

package/e2e/__tests__/managed-test.ts

@@ -8,7 +8,7 @@ import {
   createProjectHashAsync,
   diffFingerprintChangesAsync,
 } from '../../src/Fingerprint';
-import { normalizeOptions } from '../../src/Options';
+import { normalizeOptionsAsync } from '../../src/Options';
 import { getHashSourcesAsync } from '../../src/sourcer/Sourcer';
 
 describe('managed project test', () => {
@@ -65,7 +65,7 @@ describe('managed project test', () => {
 
     const configPath = path.join(projectRoot, 'app.json');
     const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
-    config.jsEngine = 'hermes';
+    config.expo.jsEngine = 'hermes';
     await fs.writeFile(configPath, JSON.stringify(config, null, 2));
 
     const hash2 = await createProjectHashAsync(projectRoot);
@@ -110,18 +110,9 @@ describe('managed project test', () => {
           "type": "dir",
         },
         {
-          "contents": "{"sourceDir":"node_modules/@react-native-community/netinfo/android","packageImportPath":"import com.reactnativecommunity.netinfo.NetInfoPackage;","packageInstance":"new NetInfoPackage()","buildTypes":[],"componentDescriptors":[],"cmakeListsPath":"node_modules/@react-native-community/netinfo/android/build/generated/source/codegen/jni/CMakeLists.txt"}",
-          "hash": "7612d745a76df00c1a8781735858c16030b3cc53",
-          "id": "rncliAutolinkingConfig:@react-native-community/netinfo:android",
-          "reasons": [
-            "bareRncliAutolinking",
-          ],
-          "type": "contents",
-        },
-        {
-          "contents": "{"podspecPath":"node_modules/@react-native-community/netinfo/react-native-netinfo.podspec","configurations":[],"scriptPhases":[]}",
-          "hash": "40eebce5caf94df11096238a5a2ca648ea9f242e",
-          "id": "rncliAutolinkingConfig:@react-native-community/netinfo:ios",
+          "contents": "{"@react-native-community/netinfo":{"root":"node_modules/@react-native-community/netinfo","name":"@react-native-community/netinfo","platforms":{"ios":{"podspecPath":"node_modules/@react-native-community/netinfo/react-native-netinfo.podspec","configurations":[],"scriptPhases":[]},"android":{"sourceDir":"node_modules/@react-native-community/netinfo/android","packageImportPath":"import com.reactnativecommunity.netinfo.NetInfoPackage;","packageInstance":"new NetInfoPackage()","buildTypes":[],"componentDescriptors":[],"cmakeListsPath":"node_modules/@react-native-community/netinfo/android/build/generated/source/codegen/jni/CMakeLists.txt"}}},"expo":{"root":"node_modules/expo","name":"expo","platforms":{"ios":{"podspecPath":"node_modules/expo/Expo.podspec","configurations":[],"scriptPhases":[]},"android":{"sourceDir":"node_modules/expo/android","packageImportPath":"import expo.modules.ExpoModulesPackage;","packageInstance":"new ExpoModulesPackage()","buildTypes":[],"componentDescriptors":[],"cmakeListsPath":"node_modules/expo/android/build/generated/source/codegen/jni/CMakeLists.txt"}}}}",
+          "hash": "ac75722bd87eb0189440be83faa2249079da5839",
+          "id": "rncliAutolinkingConfig",
           "reasons": [
             "bareRncliAutolinking",
           ],
@@ -156,7 +147,10 @@ describe(`getHashSourcesAsync - managed project`, () => {
   });
 
   it('should match snapshot', async () => {
-    const sources = await getHashSourcesAsync(projectRoot, normalizeOptions());
+    const sources = await getHashSourcesAsync(
+      projectRoot,
+      await normalizeOptionsAsync(projectRoot)
+    );
     expect(sources).toMatchSnapshot();
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/fingerprint",
-  "version": "0.0.10",
+  "version": "0.2.0",
   "description": "A library to generate a fingerprint from a React Native project",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -48,5 +48,5 @@
     "glob": "^7.1.7",
     "temp-dir": "^2.0.0"
   },
-  "gitHead": "30c46ba88d14ce545497241993ca53a87d77271c"
+  "gitHead": "431682b5adf82c17d11da7dc9b4648801299f520"
 }

package/src/Fingerprint.ts

@@ -1,6 +1,6 @@
 import { dedupSources } from './Dedup';
 import type { Fingerprint, FingerprintSource, Options } from './Fingerprint.types';
-import { normalizeOptions } from './Options';
+import { normalizeOptionsAsync } from './Options';
 import { sortSources } from './Sort';
 import { createFingerprintFromSourcesAsync } from './hash/Hash';
 import { getHashSourcesAsync } from './sourcer/Sourcer';
@@ -12,7 +12,7 @@ export async function createFingerprintAsync(
   projectRoot: string,
   options?: Options
 ): Promise<Fingerprint> {
-  const opts = normalizeOptions(options);
+  const opts = await normalizeOptionsAsync(projectRoot, options);
   const sources = await getHashSourcesAsync(projectRoot, opts);
   const normalizedSources = sortSources(dedupSources(sources, projectRoot));
   const fingerprint = await createFingerprintFromSourcesAsync(normalizedSources, projectRoot, opts);
@@ -42,10 +42,19 @@ export async function diffFingerprintChangesAsync(
   if (fingerprint.hash === newFingerprint.hash) {
     return [];
   }
-  const result: FingerprintSource[] = newFingerprint.sources.filter((newItem) => {
-    return !fingerprint.sources.find(
+  return diffFingerprints(fingerprint, newFingerprint);
+}
+
+/**
+ * Differentiate two fingerprints
+ */
+export function diffFingerprints(
+  fingerprint1: Fingerprint,
+  fingerprint2: Fingerprint
+): FingerprintSource[] {
+  return fingerprint2.sources.filter((newItem) => {
+    return !fingerprint1.sources.find(
       (item) => item.type === newItem.type && item.hash === newItem.hash
     );
   });
-  return result;
 }

package/src/Fingerprint.types.ts

@@ -39,9 +39,21 @@ export interface Options {
   /**
    * Excludes directories from hashing. This supported pattern is as `glob()`.
    * Default is `['android/build', 'android/app/build', 'android/app/.cxx', 'ios/Pods']`.
+   * @deprecated Use `ignorePaths` instead.
    */
   dirExcludes?: string[];
 
+  /**
+   * Ignore files and directories from hashing. This supported pattern is as `glob()`.
+   *
+   * Please note that the pattern matching is slightly different from gitignore. For example, we don't support partial matching where `build` does not match `android/build`. You should use `'**' + '/build'` instead.
+   * @see [minimatch implementations](https://github.com/isaacs/minimatch#comparisons-to-other-fnmatchglob-implementations) for more reference.
+   *
+   * Besides this `ignorePaths`, fingerprint comes with implicit default ignorePaths defined in `Options.DEFAULT_IGNORE_PATHS`.
+   * If you want to override the default ignorePaths, use `!` prefix.
+   */
+  ignorePaths?: string[];
+
   /**
    * Additional sources for hashing.
    */
@@ -54,7 +66,7 @@ export interface NormalizedOptions extends Options {
   platforms: NonNullable<Options['platforms']>;
   concurrentIoLimit: NonNullable<Options['concurrentIoLimit']>;
   hashAlgorithm: NonNullable<Options['hashAlgorithm']>;
-  dirExcludes: NonNullable<Options['dirExcludes']>;
+  ignorePaths: NonNullable<Options['ignorePaths']>;
 }
 
 export interface HashSourceFile {

package/src/Options.ts

@@ -1,18 +1,56 @@
+import fs from 'fs/promises';
 import os from 'os';
+import path from 'path';
 
 import type { NormalizedOptions, Options } from './Fingerprint.types';
 
-export function normalizeOptions(options?: Options): NormalizedOptions {
+export const FINGERPRINT_IGNORE_FILENAME = '.fingerprintignore';
+
+export const DEFAULT_IGNORE_PATHS = [
+  FINGERPRINT_IGNORE_FILENAME,
+  '**/android/build/**/*',
+  '**/android/app/build/**/*',
+  '**/android/app/.cxx/**/*',
+  '**/ios/Pods/**/*',
+
+  // Ignore all expo configs because we will read expo config in a HashSourceContents already
+  'app.config.ts',
+  'app.config.js',
+  'app.config.json',
+  'app.json',
+];
+
+export async function normalizeOptionsAsync(
+  projectRoot: string,
+  options?: Options
+): Promise<NormalizedOptions> {
   return {
     ...options,
     platforms: options?.platforms ?? ['android', 'ios'],
     concurrentIoLimit: options?.concurrentIoLimit ?? os.cpus().length,
     hashAlgorithm: options?.hashAlgorithm ?? 'sha1',
-    dirExcludes: options?.dirExcludes ?? [
-      '**/android/build',
-      '**/android/app/build',
-      '**/android/app/.cxx',
-      'ios/Pods',
-    ],
+    ignorePaths: await collectIgnorePathsAsync(projectRoot, options),
   };
 }
+
+async function collectIgnorePathsAsync(projectRoot: string, options?: Options): Promise<string[]> {
+  const ignorePaths = [
+    ...DEFAULT_IGNORE_PATHS,
+    ...(options?.ignorePaths ?? []),
+    ...(options?.dirExcludes?.map((dirExclude) => `${dirExclude}/**/*`) ?? []),
+  ];
+
+  const fingerprintIgnorePath = path.join(projectRoot, FINGERPRINT_IGNORE_FILENAME);
+  try {
+    const fingerprintIgnore = await fs.readFile(fingerprintIgnorePath, 'utf8');
+    const fingerprintIgnoreLines = fingerprintIgnore.split('\n');
+    for (const line of fingerprintIgnoreLines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine) {
+        ignorePaths.push(trimmedLine);
+      }
+    }
+  } catch {}
+
+  return ignorePaths;
+}

package/src/__tests__/Fingerprint-test.ts

@@ -2,7 +2,7 @@ import { vol } from 'memfs';
 
 import { createFingerprintAsync, diffFingerprintChangesAsync } from '../Fingerprint';
 import type { Fingerprint } from '../Fingerprint.types';
-import { normalizeOptions } from '../Options';
+import { normalizeOptionsAsync } from '../Options';
 
 jest.mock('fs');
 jest.mock('fs/promises');
@@ -15,8 +15,12 @@ describe(diffFingerprintChangesAsync, () => {
 
   it('should return empty array when fingerprint matched', async () => {
     vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', normalizeOptions());
-    const diff = await diffFingerprintChangesAsync(fingerprint, '/app', normalizeOptions());
+    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
+    const diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff.length).toBe(0);
   });
 
@@ -27,16 +31,21 @@ describe(diffFingerprintChangesAsync, () => {
       hash: '',
     };
 
-    const diff = await diffFingerprintChangesAsync(fingerprint, '/app', normalizeOptions());
+    const diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff).toMatchInlineSnapshot(`
       [
         {
-          "filePath": "app.json",
-          "hash": "1fd2d92d50dc1da96b41795046b9ea4e30dd2b48",
+          "contents": "{"android":{"adaptiveIcon":{"backgroundColor":"#FFFFFF","foregroundImage":"./assets/adaptive-icon.png"}},"assetBundlePatterns":["**/*"],"icon":"./assets/icon.png","ios":{"supportsTablet":true},"name":"sdk47","orientation":"portrait","platforms":["android","ios","web"],"slug":"sdk47","splash":{"backgroundColor":"#ffffff","image":"./assets/splash.png","resizeMode":"contain"},"updates":{"fallbackToCacheTimeout":0},"userInterfaceStyle":"light","version":"1.0.0","web":{"favicon":"./assets/favicon.png"}}",
+          "hash": "33b2b95de3b0b474810630e51527a2c0a6e5de9c",
+          "id": "expoConfig",
           "reasons": [
             "expoConfig",
           ],
-          "type": "file",
+          "type": "contents",
         },
       ]
     `);
@@ -46,19 +55,27 @@ describe(diffFingerprintChangesAsync, () => {
     vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
     const packageJson = JSON.parse(vol.readFileSync('/app/package.json', 'utf8').toString());
     jest.doMock('/app/package.json', () => packageJson, { virtual: true });
-    const fingerprint = await createFingerprintAsync('/app', normalizeOptions());
+    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
 
     // first round for bumping package version which should not cause changes
     packageJson.version = '111.111.111';
     jest.doMock('/app/package.json', () => packageJson, { virtual: true });
-    let diff = await diffFingerprintChangesAsync(fingerprint, '/app', normalizeOptions());
+    let diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff.length).toBe(0);
 
     // second round to update scripts section and it should cause changes
     packageJson.scripts ||= {};
     packageJson.scripts.postinstall = 'echo "hello"';
     jest.doMock('/app/package.json', () => packageJson, { virtual: true });
-    diff = await diffFingerprintChangesAsync(fingerprint, '/app', normalizeOptions());
+    diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     jest.dontMock('/app/package.json');
     expect(diff).toMatchInlineSnapshot(`
       [
@@ -77,20 +94,25 @@ describe(diffFingerprintChangesAsync, () => {
 
   it('should return diff from file changes', async () => {
     vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', normalizeOptions());
+    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
     const config = JSON.parse(vol.readFileSync('/app/app.json', 'utf8').toString());
     config.expo.jsEngine = 'jsc';
     vol.writeFileSync('/app/app.json', JSON.stringify(config, null, 2));
-    const diff = await diffFingerprintChangesAsync(fingerprint, '/app', normalizeOptions());
+    const diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff).toMatchInlineSnapshot(`
       [
         {
-          "filePath": "app.json",
-          "hash": "9ff1b51ca9b9435e8b849bcc82e3900d70f0feee",
+          "contents": "{"android":{"adaptiveIcon":{"backgroundColor":"#FFFFFF","foregroundImage":"./assets/adaptive-icon.png"}},"assetBundlePatterns":["**/*"],"icon":"./assets/icon.png","ios":{"supportsTablet":true},"jsEngine":"jsc","name":"sdk47","orientation":"portrait","platforms":["android","ios","web"],"slug":"sdk47","splash":{"backgroundColor":"#ffffff","image":"./assets/splash.png","resizeMode":"contain"},"updates":{"fallbackToCacheTimeout":0},"userInterfaceStyle":"light","version":"1.0.0","web":{"favicon":"./assets/favicon.png"}}",
+          "hash": "7068a4234e7312c6ac54b776ea4dfad0ac789b2a",
+          "id": "expoConfig",
           "reasons": [
             "expoConfig",
           ],
-          "type": "file",
+          "type": "contents",
         },
       ]
     `);
@@ -98,9 +120,13 @@ describe(diffFingerprintChangesAsync, () => {
 
   it('should return diff from dir changes', async () => {
     vol.fromJSON(require('../sourcer/__tests__/fixtures/BareReactNative70Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', normalizeOptions());
+    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
     vol.writeFileSync('/app/ios/README.md', '# Adding new file in ios dir');
-    const diff = await diffFingerprintChangesAsync(fingerprint, '/app', normalizeOptions());
+    const diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff).toMatchInlineSnapshot(`
       [
         {

package/src/hash/Hash.ts

@@ -82,10 +82,14 @@ export async function createFileHashResultsAsync(
   limiter: pLimit.Limit,
   projectRoot: string,
   options: NormalizedOptions
-): Promise<HashResult> {
+): Promise<HashResult | null> {
   // Backup code for faster hashing
   /*
   return limiter(async () => {
+    if (isIgnoredPath(filePath, options.ignorePaths)) {
+      return null;
+    }
+
     const hasher = createHash(options.hashAlgorithm);
 
     const stat = await fs.stat(filePath);
@@ -102,7 +106,11 @@ export async function createFileHashResultsAsync(
   */
 
   return limiter(() => {
-    return new Promise<HashResult>((resolve, reject) => {
+    return new Promise<HashResult | null>((resolve, reject) => {
+      if (isIgnoredPath(filePath, options.ignorePaths)) {
+        return resolve(null);
+      }
+
       let resolved = false;
       const hasher = createHash(options.hashAlgorithm);
       const stream = createReadStream(path.join(projectRoot, filePath));
@@ -124,15 +132,28 @@ export async function createFileHashResultsAsync(
 }
 
 /**
- * Indicate the given `dirPath` should be excluded by `dirExcludes`
+ * Indicate the given `filePath` should be excluded by `ignorePaths`
  */
-function isExcludedDir(dirPath: string, dirExcludes: string[]): boolean {
-  for (const exclude of dirExcludes) {
-    if (minimatch(dirPath, exclude)) {
-      return true;
+export function isIgnoredPath(
+  filePath: string,
+  ignorePaths: string[],
+  minimatchOptions: minimatch.IOptions = { dot: true }
+): boolean {
+  const minimatchObjs = ignorePaths.map(
+    (ignorePath) => new minimatch.Minimatch(ignorePath, minimatchOptions)
+  );
+
+  let result = false;
+  for (const minimatchObj of minimatchObjs) {
+    const currMatch = minimatchObj.match(filePath);
+    if (minimatchObj.negate && result && !currMatch) {
+      // Special handler for negate (!pattern).
+      // As long as previous match result is true and not matched from the current negate pattern, we should early return.
+      return false;
     }
+    result ||= currMatch;
   }
-  return false;
+  return result;
 }
 
 /**
@@ -146,7 +167,7 @@ export async function createDirHashResultsAsync(
   options: NormalizedOptions,
   depth: number = 0
 ): Promise<HashResult | null> {
-  if (isExcludedDir(dirPath, options.dirExcludes)) {
+  if (isIgnoredPath(dirPath, options.ignorePaths)) {
     return null;
   }
   const dirents = (await fs.readdir(path.join(projectRoot, dirPath), { withFileTypes: true })).sort(
@@ -164,12 +185,15 @@ export async function createDirHashResultsAsync(
   }
 
   const hasher = createHash(options.hashAlgorithm);
-  const results = await Promise.all(promises);
+  const results = (await Promise.all(promises)).filter(
+    (result): result is HashResult => result != null
+  );
+  if (results.length === 0) {
+    return null;
+  }
   for (const result of results) {
-    if (result != null) {
-      hasher.update(result.id);
-      hasher.update(result.hex);
-    }
+    hasher.update(result.id);
+    hasher.update(result.hex);
   }
   const hex = hasher.digest('hex');
 

package/src/hash/__tests__/Hash-test.ts

@@ -4,7 +4,7 @@ import pLimit from 'p-limit';
 import path from 'path';
 
 import { HashSource } from '../../Fingerprint.types';
-import { normalizeOptions } from '../../Options';
+import { normalizeOptionsAsync } from '../../Options';
 import {
   createContentsHashResultsAsync,
   createDirHashResultsAsync,
@@ -12,6 +12,7 @@ import {
   createFingerprintFromSourcesAsync,
   createFingerprintSourceAsync,
   createSourceId,
+  isIgnoredPath,
 } from '../Hash';
 
 jest.mock('fs');
@@ -23,18 +24,21 @@ describe(createFingerprintFromSourcesAsync, () => {
   });
 
   it('snapshot', async () => {
+    const filePath = 'assets/icon.png';
     vol.mkdirSync('/app');
-    vol.writeFileSync(path.join('/app', 'app.json'), '{}');
+    vol.mkdirSync('/app/assets');
+    vol.writeFileSync(path.join('/app', filePath), '{}');
 
     const sources: HashSource[] = [
       { type: 'contents', id: 'foo', contents: 'HelloWorld', reasons: ['foo'] },
-      { type: 'file', filePath: 'app.json', reasons: ['expoConfig'] },
+      { type: 'file', filePath, reasons: ['icon'] },
     ];
 
-    expect(await createFingerprintFromSourcesAsync(sources, '/app', normalizeOptions()))
-      .toMatchInlineSnapshot(`
+    expect(
+      await createFingerprintFromSourcesAsync(sources, '/app', await normalizeOptionsAsync('/app'))
+    ).toMatchInlineSnapshot(`
       {
-        "hash": "ec7d81780f735d5e289b27cdcc04a6c99d2621dc",
+        "hash": "ca7d58cd60289daa5cddcf99fcaa1d339bfc2c1a",
         "sources": [
           {
             "contents": "HelloWorld",
@@ -46,10 +50,10 @@ describe(createFingerprintFromSourcesAsync, () => {
             "type": "contents",
           },
           {
-            "filePath": "app.json",
+            "filePath": "assets/icon.png",
             "hash": "bf21a9e8fbc5a3846fb05b4fa0859e0917b2202f",
             "reasons": [
-              "expoConfig",
+              "icon",
             ],
             "type": "file",
           },
@@ -72,7 +76,12 @@ describe(createFingerprintSourceAsync, () => {
       hash: 'db8ac1c259eb89d4a131b253bacfca5f319d54f2',
     };
     expect(
-      await createFingerprintSourceAsync(source, pLimit(1), '/app', normalizeOptions())
+      await createFingerprintSourceAsync(
+        source,
+        pLimit(1),
+        '/app',
+        await normalizeOptionsAsync('/app')
+      )
     ).toEqual(expectedResult);
   });
 });
@@ -81,7 +90,7 @@ describe(createContentsHashResultsAsync, () => {
   it('should return {id, hex} result', async () => {
     const id = 'foo';
     const contents = '{}';
-    const options = normalizeOptions();
+    const options = await normalizeOptionsAsync('/app');
     const result = await createContentsHashResultsAsync(
       {
         type: 'contents',
@@ -104,18 +113,32 @@ describe(createFileHashResultsAsync, () => {
   });
 
   it('should return {id, hex} result', async () => {
-    const filePath = 'app.json';
+    const filePath = 'assets/icon.png';
     const contents = '{}';
     const limiter = pLimit(1);
-    const options = normalizeOptions();
+    const options = await normalizeOptionsAsync('/app');
     vol.mkdirSync('/app');
+    vol.mkdirSync('/app/assets');
     vol.writeFileSync(path.join('/app', filePath), contents);
 
     const result = await createFileHashResultsAsync(filePath, limiter, '/app', options);
 
     const expectHex = createHash(options.hashAlgorithm).update(contents).digest('hex');
-    expect(result.id).toEqual(filePath);
-    expect(result.hex).toEqual(expectHex);
+    expect(result?.id).toEqual(filePath);
+    expect(result?.hex).toEqual(expectHex);
+  });
+
+  it('should ignore file if it is in options.ignorePaths', async () => {
+    const filePath = 'app.json';
+    const contents = '{}';
+    const limiter = pLimit(1);
+    const options = await normalizeOptionsAsync('/app');
+    options.ignorePaths = ['*.json'];
+    vol.mkdirSync('/app');
+    vol.writeFileSync(path.join('/app', filePath), contents);
+
+    const result = await createFileHashResultsAsync(filePath, limiter, '/app', options);
+    expect(result).toBe(null);
   });
 });
 
@@ -126,7 +149,7 @@ describe(createDirHashResultsAsync, () => {
 
   it('should return {id, hex} result', async () => {
     const limiter = pLimit(3);
-    const options = normalizeOptions();
+    const options = await normalizeOptionsAsync('/app');
     const volJSON = {
       '/app/ios/Podfile': '...',
       '/app/eas.json': '{}',
@@ -140,9 +163,33 @@ describe(createDirHashResultsAsync, () => {
     expect(result?.hex).not.toBe('');
   });
 
+  it('should ignore dir if it is in options.ignorePaths', async () => {
+    const limiter = pLimit(3);
+    const options = await normalizeOptionsAsync('/app');
+    options.ignorePaths = ['ios/**/*', 'android/**/*'];
+    const volJSON = {
+      '/app/ios/Podfile': '...',
+      '/app/eas.json': '{}',
+      '/app/app.json': '{}',
+      '/app/android/build.gradle': '...',
+    };
+    vol.fromJSON(volJSON);
+
+    const fingerprint1 = await createDirHashResultsAsync('.', limiter, '/app', options);
+
+    vol.reset();
+    const volJSONIgnoreNativeProjects = {
+      '/app/eas.json': '{}',
+      '/app/app.json': '{}',
+    };
+    vol.fromJSON(volJSONIgnoreNativeProjects);
+    const fingerprint2 = await createDirHashResultsAsync('.', limiter, '/app', options);
+    expect(fingerprint1).toEqual(fingerprint2);
+  });
+
   it('should return stable result from sorted files', async () => {
     const limiter = pLimit(3);
-    const options = normalizeOptions();
+    const options = await normalizeOptionsAsync('/app');
     const volJSON = {
       '/app/ios/Podfile': '...',
       '/app/eas.json': '{}',
@@ -190,3 +237,38 @@ describe(createSourceId, () => {
     expect(createSourceId(source)).toBe('foo');
   });
 });
+
+describe(isIgnoredPath, () => {
+  it('should support file pattern', () => {
+    expect(isIgnoredPath('app.json', ['app.json'])).toBe(true);
+    expect(isIgnoredPath('app.ts', ['*.{js,ts}'])).toBe(true);
+    expect(isIgnoredPath('/dir/app.json', ['/dir/*.json'])).toBe(true);
+  });
+
+  it('should support directory pattern', () => {
+    expect(isIgnoredPath('/app/ios/Podfile', ['**/ios/**/*'])).toBe(true);
+  });
+
+  it('case sensitive by design', () => {
+    expect(isIgnoredPath('app.json', ['APP.JSON'])).toBe(false);
+  });
+
+  it('should include dot files from wildcard pattern', () => {
+    expect(isIgnoredPath('.bashrc', ['*'])).toBe(true);
+  });
+
+  it('no `matchBase` and `partial` by design', () => {
+    expect(isIgnoredPath('/dir/app.json', ['app.json'])).toBe(false);
+  });
+
+  it('match a file inside a dir should use a globstar', () => {
+    expect(isIgnoredPath('/dir/app.ts', ['*'])).toBe(false);
+    expect(isIgnoredPath('/dir/app.ts', ['**/*'])).toBe(true);
+  });
+
+  it('should use `!` to override default ignorePaths', () => {
+    const ignorePaths = ['**/ios/**/*', '!**/ios/Podfile', '**/android/**/*'];
+    expect(isIgnoredPath('/app/ios/Podfile', ignorePaths)).toBe(false);
+    expect(isIgnoredPath('/app/ios/Podfile.lock', ignorePaths)).toBe(true);
+  });
+});