eas-cli 0.32.0 → 0.34.1

package/build/vcs/clients/git.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitCaseSensitiveAsync = void 0;
+const tslib_1 = require("tslib");
+const spawn_async_1 = (0, tslib_1.__importDefault)(require("@expo/spawn-async"));
+const log_1 = (0, tslib_1.__importStar)(require("../../log"));
+const prompts_1 = require("../../prompts");
+const git_1 = require("../git");
+const vcs_1 = require("../vcs");
+class GitClient extends vcs_1.Client {
+    async ensureRepoExistsAsync() {
+        if (!(await (0, git_1.isGitInstalledAsync)())) {
+            throw new Error('git command not found, install it before proceeding');
+        }
+        if (await (0, git_1.doesGitRepoExistAsync)()) {
+            return;
+        }
+        log_1.default.warn("It looks like you haven't initialized the git repository yet.");
+        log_1.default.warn('EAS Build requires you to use a git repository for your project.');
+        const confirmInit = await (0, prompts_1.confirmAsync)({
+            message: `Would you like us to run 'git init' in the current directory for you?`,
+        });
+        if (!confirmInit) {
+            throw new Error('A git repository is required for building your project. Initialize it and run this command again.');
+        }
+        await (0, spawn_async_1.default)('git', ['init']);
+        log_1.default.log("We're going to make an initial commit for your repository.");
+        const { message } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'message',
+            message: 'Commit message:',
+            initial: 'Initial commit',
+            validate: (input) => input !== '',
+        });
+        await this.commitAsync({ commitAllFiles: true, commitMessage: message });
+    }
+    async commitAsync({ commitMessage, commitAllFiles, }) {
+        if (commitAllFiles) {
+            await (0, spawn_async_1.default)('git', ['add', '-A']);
+        }
+        await (0, spawn_async_1.default)('git', ['add', '-u']);
+        await (0, spawn_async_1.default)('git', ['commit', '-m', commitMessage]);
+    }
+    async isCommitRequiredAsync() {
+        return await this.hasUncommittedChangesAsync();
+    }
+    async hasUncommittedChangesAsync() {
+        const changes = await (0, git_1.gitStatusAsync)({ showUntracked: true });
+        return changes.length > 0;
+    }
+    async getRootPathAsync() {
+        return (await (0, spawn_async_1.default)('git', ['rev-parse', '--show-toplevel'])).stdout.trim();
+    }
+    async makeShallowCopyAsync(destinationPath) {
+        if (await this.hasUncommittedChangesAsync()) {
+            // it should already be checked before this function is called, but in case it wasn't
+            // we want to ensure that any changes were introduced by call to `setGitCaseSensitivityAsync`
+            throw new Error('You have some uncommitted changes in your repository.');
+        }
+        let gitRepoUri;
+        if (process.platform === 'win32') {
+            // getRootDirectoryAsync() will return C:/path/to/repo on Windows and path
+            // prefix should be file:///
+            gitRepoUri = `file:///${await this.getRootPathAsync()}`;
+        }
+        else {
+            // getRootDirectoryAsync() will /path/to/repo, and path prefix should be
+            // file:/// so only file:// needs to be prepended
+            gitRepoUri = `file://${await this.getRootPathAsync()}`;
+        }
+        const isCaseSensitive = await isGitCaseSensitiveAsync();
+        await setGitCaseSensitivityAsync(true);
+        try {
+            if (await this.hasUncommittedChangesAsync()) {
+                log_1.default.error('Detected inconsistent filename casing between your local filesystem and git.');
+                log_1.default.error('This will likely cause your build to fail. Impacted files:');
+                await (0, spawn_async_1.default)('git', ['status', '--short'], { stdio: 'inherit' });
+                log_1.default.newLine();
+                log_1.default.error(`Error: Resolve filename casing inconsistencies before proceeding. ${(0, log_1.learnMore)('https://expo.fyi/macos-ignorecase')}`);
+                throw new Error('You have some uncommitted changes in your repository.');
+            }
+            await (0, spawn_async_1.default)('git', [
+                'clone',
+                '--no-hardlinks',
+                '--depth',
+                '1',
+                gitRepoUri,
+                destinationPath,
+            ]);
+        }
+        finally {
+            await setGitCaseSensitivityAsync(isCaseSensitive);
+        }
+    }
+    async getCommitHashAsync() {
+        try {
+            return (await (0, spawn_async_1.default)('git', ['rev-parse', 'HEAD'])).stdout.trim();
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    async trackFileAsync(file) {
+        await (0, spawn_async_1.default)('git', ['add', '--intent-to-add', file]);
+    }
+    async getBranchNameAsync() {
+        try {
+            return (await (0, spawn_async_1.default)('git', ['rev-parse', '--abbrev-ref', 'HEAD'])).stdout.trim();
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    async getLastCommitMessageAsync() {
+        try {
+            return (await (0, spawn_async_1.default)('git', ['--no-pager', 'log', '-1', '--pretty=%B'])).stdout.trim();
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    async showDiffAsync() {
+        const outputTooLarge = (await (0, git_1.getGitDiffOutputAsync)()).split(/\r\n|\r|\n/).length > 100;
+        await (0, git_1.gitDiffAsync)({ withPager: outputTooLarge });
+    }
+    async isFileUntrackedAsync(path) {
+        const withUntrackedFiles = await (0, git_1.gitStatusAsync)({ showUntracked: true });
+        const trackedFiles = await (0, git_1.gitStatusAsync)({ showUntracked: false });
+        const pathWithoutLeadingDot = path.replace(/^\.\//, ''); // remove leading './' from path
+        return (withUntrackedFiles.includes(pathWithoutLeadingDot) &&
+            !trackedFiles.includes(pathWithoutLeadingDot));
+    }
+    async isFileIgnoredAsync(filePath) {
+        try {
+            await (0, spawn_async_1.default)('git', ['check-ignore', '-q', filePath]);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.default = GitClient;
+/**
+ * Checks if git is configured to be case sensitive
+ * @returns {boolean | undefined}
+ *    - boolean - is git case sensitive
+ *    - undefined - case sensitivity is not configured and git is using default behavior
+ */
+async function isGitCaseSensitiveAsync() {
+    if (process.platform !== 'darwin') {
+        return undefined;
+    }
+    try {
+        const result = await (0, spawn_async_1.default)('git', ['config', '--get', 'core.ignorecase']);
+        const isIgnoreCaseEnabled = result.stdout.trim();
+        if (isIgnoreCaseEnabled === '') {
+            return undefined;
+        }
+        else if (isIgnoreCaseEnabled === 'true') {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+exports.isGitCaseSensitiveAsync = isGitCaseSensitiveAsync;
+async function setGitCaseSensitivityAsync(enable) {
+    // we are assuming that if someone sets that on non-macos device then
+    // they know what they are doing
+    if (process.platform !== 'darwin') {
+        return;
+    }
+    if (enable === undefined) {
+        await (0, spawn_async_1.default)('git', ['config', '--unset', 'core.ignorecase']);
+    }
+    else {
+        await (0, spawn_async_1.default)('git', ['config', 'core.ignorecase', String(!enable)]);
+    }
+}

package/build/vcs/clients/gitNoCommit.d.ts

@@ -0,0 +1,7 @@
+import GitClient from './git';
+export default class GitNoCommitClient extends GitClient {
+    isCommitRequiredAsync(): Promise<boolean>;
+    getRootPathAsync(): Promise<string>;
+    makeShallowCopyAsync(destinationPath: string): Promise<void>;
+    isFileIgnoredAsync(filePath: string): Promise<boolean>;
+}

package/build/vcs/clients/gitNoCommit.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const spawn_async_1 = (0, tslib_1.__importDefault)(require("@expo/spawn-async"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const local_1 = require("../local");
+const git_1 = (0, tslib_1.__importDefault)(require("./git"));
+class GitNoCommitClient extends git_1.default {
+    async isCommitRequiredAsync() {
+        return false;
+    }
+    async getRootPathAsync() {
+        return (await (0, spawn_async_1.default)('git', ['rev-parse', '--show-toplevel'])).stdout.trim();
+    }
+    async makeShallowCopyAsync(destinationPath) {
+        // normalize converts C:/some/path to C:\some\path on windows
+        const srcPath = path_1.default.normalize(await this.getRootPathAsync());
+        await (0, local_1.makeShallowCopyAsync)(srcPath, destinationPath);
+    }
+    async isFileIgnoredAsync(filePath) {
+        // normalize converts C:/some/path to C:\some\path on windows
+        const ignore = new local_1.Ignore(await this.getRootPathAsync());
+        await ignore.initIgnoreAsync();
+        return ignore.ignores(filePath);
+    }
+}
+exports.default = GitNoCommitClient;

package/build/vcs/clients/noVcs.d.ts

@@ -0,0 +1,6 @@
+import { Client } from '../vcs';
+export default class NoVcsClient extends Client {
+    getRootPathAsync(): Promise<string>;
+    makeShallowCopyAsync(destinationPath: string): Promise<void>;
+    isFileIgnoredAsync(filePath: string): Promise<boolean>;
+}

package/build/vcs/clients/noVcs.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const local_1 = require("../local");
+const vcs_1 = require("../vcs");
+class NoVcsClient extends vcs_1.Client {
+    async getRootPathAsync() {
+        return (0, local_1.getRootPath)();
+    }
+    async makeShallowCopyAsync(destinationPath) {
+        const srcPath = (0, local_1.getRootPath)();
+        await (0, local_1.makeShallowCopyAsync)(srcPath, destinationPath);
+    }
+    async isFileIgnoredAsync(filePath) {
+        const ignore = new local_1.Ignore((0, local_1.getRootPath)());
+        await ignore.initIgnoreAsync();
+        return ignore.ignores(filePath);
+    }
+}
+exports.default = NoVcsClient;

package/build/vcs/git.d.ts

@@ -1,18 +1,11 @@
-import { Client } from './vcs';
-export default class GitClient extends Client {
-    ensureRepoExistsAsync(): Promise<void>;
-    commitAsync({ commitMessage, commitAllFiles, }: {
-        commitMessage: string;
-        commitAllFiles?: boolean;
-    }): Promise<void>;
-    hasUncommittedChangesAsync(): Promise<boolean>;
-    getRootPathAsync(): Promise<string>;
-    makeShallowCopyAsync(destinationPath: string): Promise<void>;
-    getCommitHashAsync(): Promise<string | undefined>;
-    trackFileAsync(file: string): Promise<void>;
-    getBranchNameAsync(): Promise<string | null>;
-    getLastCommitMessageAsync(): Promise<string | null>;
-    showDiffAsync(): Promise<void>;
-    isFileUntrackedAsync(path: string): Promise<boolean>;
-    isFileIgnoredAsync(filePath: string): Promise<boolean>;
+export declare function isGitInstalledAsync(): Promise<boolean>;
+export declare function doesGitRepoExistAsync(): Promise<boolean>;
+interface GitStatusOptions {
+    showUntracked?: boolean;
 }
+export declare function gitStatusAsync({ showUntracked }?: GitStatusOptions): Promise<string>;
+export declare function getGitDiffOutputAsync(): Promise<string>;
+export declare function gitDiffAsync({ withPager, }?: {
+    withPager?: boolean;
+}): Promise<void>;
+export {};

package/build/vcs/git.js

@@ -1,141 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitDiffAsync = exports.getGitDiffOutputAsync = exports.gitStatusAsync = exports.doesGitRepoExistAsync = exports.isGitInstalledAsync = void 0;
 const tslib_1 = require("tslib");
 const spawn_async_1 = (0, tslib_1.__importDefault)(require("@expo/spawn-async"));
-const log_1 = (0, tslib_1.__importStar)(require("../log"));
-const prompts_1 = require("../prompts");
-const vcs_1 = require("./vcs");
-class GitClient extends vcs_1.Client {
-    async ensureRepoExistsAsync() {
-        if (!(await isGitInstalledAsync())) {
-            throw new Error('git command not found, install it before proceeding');
-        }
-        if (await doesGitRepoExistAsync()) {
-            return;
-        }
-        log_1.default.warn("It looks like you haven't initialized the git repository yet.");
-        log_1.default.warn('EAS Build requires you to use a git repository for your project.');
-        const confirmInit = await (0, prompts_1.confirmAsync)({
-            message: `Would you like to run 'git init' in the current directory?`,
-        });
-        if (!confirmInit) {
-            throw new Error('A git repository is required for building your project. Initialize it and run this command again.');
-        }
-        await (0, spawn_async_1.default)('git', ['init']);
-        log_1.default.log("We're going to make an initial commit for you repository.");
-        const { message } = await (0, prompts_1.promptAsync)({
-            type: 'text',
-            name: 'message',
-            message: 'Commit message:',
-            initial: 'Initial commit',
-            validate: (input) => input !== '',
-        });
-        await this.commitAsync({ commitAllFiles: true, commitMessage: message });
-    }
-    async commitAsync({ commitMessage, commitAllFiles, }) {
-        if (commitAllFiles) {
-            await (0, spawn_async_1.default)('git', ['add', '-A']);
-        }
-        await (0, spawn_async_1.default)('git', ['add', '-u']);
-        await (0, spawn_async_1.default)('git', ['commit', '-m', commitMessage]);
-    }
-    async hasUncommittedChangesAsync() {
-        const changes = await gitStatusAsync({ showUntracked: true });
-        return changes.length > 0;
-    }
-    async getRootPathAsync() {
-        return (await (0, spawn_async_1.default)('git', ['rev-parse', '--show-toplevel'])).stdout.trim();
-    }
-    async makeShallowCopyAsync(destinationPath) {
-        if (await this.hasUncommittedChangesAsync()) {
-            // it should not happen, we need that to make sure that check before clone
-            // is always caused by case sensitivity
-            throw new Error('You have some uncommitted changes in your repository.');
-        }
-        let gitRepoUri;
-        if (process.platform === 'win32') {
-            // getRootDirectoryAsync() will return C:/path/to/repo on Windows and path
-            // prefix should be file:///
-            gitRepoUri = `file:///${await this.getRootPathAsync()}`;
-        }
-        else {
-            // getRootDirectoryAsync() will /path/to/repo, and path prefix should be
-            // file:/// so only file:// needs to be prepended
-            gitRepoUri = `file://${await this.getRootPathAsync()}`;
-        }
-        const isCaseSensitive = await isGitCaseSensitiveAsync();
-        await setGitCaseSensitivityAsync(true);
-        try {
-            if (await this.hasUncommittedChangesAsync()) {
-                log_1.default.error('Detected inconsistent filename casing between your local filesystem and git.');
-                log_1.default.error('This will likely cause your build to fail. Impacted files:');
-                await (0, spawn_async_1.default)('git', ['status', '--short'], { stdio: 'inherit' });
-                log_1.default.newLine();
-                log_1.default.error(`Error: Resolve filename casing inconsistencies before proceeding. ${(0, log_1.learnMore)('https://expo.fyi/macos-ignorecase')}`);
-                throw new Error('You have some uncommitted changes in your repository.');
-            }
-            await (0, spawn_async_1.default)('git', [
-                'clone',
-                '--no-hardlinks',
-                '--depth',
-                '1',
-                gitRepoUri,
-                destinationPath,
-            ]);
-        }
-        finally {
-            await setGitCaseSensitivityAsync(isCaseSensitive);
-        }
-    }
-    async getCommitHashAsync() {
-        try {
-            return (await (0, spawn_async_1.default)('git', ['rev-parse', 'HEAD'])).stdout.trim();
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async trackFileAsync(file) {
-        await (0, spawn_async_1.default)('git', ['add', '--intent-to-add', file]);
-    }
-    async getBranchNameAsync() {
-        try {
-            return (await (0, spawn_async_1.default)('git', ['rev-parse', '--abbrev-ref', 'HEAD'])).stdout.trim();
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    async getLastCommitMessageAsync() {
-        try {
-            return (await (0, spawn_async_1.default)('git', ['--no-pager', 'log', '-1', '--pretty=%B'])).stdout.trim();
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    async showDiffAsync() {
-        const outputTooLarge = (await getGitDiffOutputAsync()).split(/\r\n|\r|\n/).length > 100;
-        await gitDiffAsync({ withPager: outputTooLarge });
-    }
-    async isFileUntrackedAsync(path) {
-        const withUntrackedFiles = await gitStatusAsync({ showUntracked: true });
-        const trackedFiles = await gitStatusAsync({ showUntracked: false });
-        const pathWithoutLeadingDot = path.replace(/^\.\//, ''); // remove leading './' from path
-        return (withUntrackedFiles.includes(pathWithoutLeadingDot) &&
-            !trackedFiles.includes(pathWithoutLeadingDot));
-    }
-    async isFileIgnoredAsync(filePath) {
-        try {
-            await (0, spawn_async_1.default)('git', ['check-ignore', '-q', filePath]);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-}
-exports.default = GitClient;
 async function isGitInstalledAsync() {
     try {
         await (0, spawn_async_1.default)('git', ['--help']);
@@ -148,6 +15,7 @@ async function isGitInstalledAsync() {
     }
     return true;
 }
+exports.isGitInstalledAsync = isGitInstalledAsync;
 async function doesGitRepoExistAsync() {
     try {
         await (0, spawn_async_1.default)('git', ['rev-parse', '--git-dir']);
@@ -157,53 +25,17 @@ async function doesGitRepoExistAsync() {
         return false;
     }
 }
+exports.doesGitRepoExistAsync = doesGitRepoExistAsync;
 async function gitStatusAsync({ showUntracked } = {}) {
     return (await (0, spawn_async_1.default)('git', ['status', '-s', showUntracked ? '-uall' : '-uno'])).stdout;
 }
+exports.gitStatusAsync = gitStatusAsync;
 async function getGitDiffOutputAsync() {
     return (await (0, spawn_async_1.default)('git', ['--no-pager', 'diff'])).stdout;
 }
-async function gitDiffAsync({ withPager = false } = {}) {
+exports.getGitDiffOutputAsync = getGitDiffOutputAsync;
+async function gitDiffAsync({ withPager = false, } = {}) {
     const options = withPager ? [] : ['--no-pager'];
     await (0, spawn_async_1.default)('git', [...options, 'diff'], { stdio: ['ignore', 'inherit', 'inherit'] });
 }
-/**
- * Checks if git is configured to be case sensitive
- * @returns {boolean | undefined}
- *    - boolean - is git case senstive
- *    - undefined - case sensitivity is not configured and git is using default behavior
- */
-async function isGitCaseSensitiveAsync() {
-    if (process.platform !== 'darwin') {
-        return undefined;
-    }
-    try {
-        const result = await (0, spawn_async_1.default)('git', ['config', '--get', 'core.ignorecase']);
-        const isIgnoreCaseEnabled = result.stdout.trim();
-        if (isIgnoreCaseEnabled === '') {
-            return undefined;
-        }
-        else if (isIgnoreCaseEnabled === 'true') {
-            return false;
-        }
-        else {
-            return true;
-        }
-    }
-    catch (e) {
-        return undefined;
-    }
-}
-async function setGitCaseSensitivityAsync(enable) {
-    // we are assuming that if someone sets that on non-macos device then
-    // they know what they are doing
-    if (process.platform !== 'darwin') {
-        return;
-    }
-    if (enable === undefined) {
-        await (0, spawn_async_1.default)('git', ['config', '--unset', 'core.ignorecase']);
-    }
-    else {
-        await (0, spawn_async_1.default)('git', ['config', 'core.ignorecase', String(!enable)]);
-    }
-}
+exports.gitDiffAsync = gitDiffAsync;

package/build/vcs/index.d.ts

@@ -1,3 +1,3 @@
 import { Client } from './vcs';
-declare const _default: Client;
-export default _default;
+export declare function setVcsClient(client: Client): void;
+export declare function getVcsClient(): Client;

package/build/vcs/index.js

@@ -1,17 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVcsClient = exports.setVcsClient = void 0;
 const tslib_1 = require("tslib");
 const log_1 = (0, tslib_1.__importDefault)(require("../log"));
-const git_1 = (0, tslib_1.__importDefault)(require("./git"));
-const local_1 = (0, tslib_1.__importDefault)(require("./local"));
+const gitNoCommit_1 = (0, tslib_1.__importDefault)(require("./clients/gitNoCommit"));
+const noVcs_1 = (0, tslib_1.__importDefault)(require("./clients/noVcs"));
 const NO_VCS_WARNING = `Using EAS CLI without version control system is not recommended, use this mode only if you know what you are doing.`;
-function resolveVcsClient() {
+let vcsClient = resolveDefaultVcsClient();
+function resolveDefaultVcsClient() {
     if (process.env.EAS_NO_VCS) {
         if (process.env.NODE_ENV !== 'test') {
             log_1.default.warn(NO_VCS_WARNING);
         }
-        return new local_1.default();
+        return new noVcs_1.default();
     }
-    return new git_1.default();
+    return new gitNoCommit_1.default();
 }
-exports.default = resolveVcsClient();
+function setVcsClient(client) {
+    vcsClient = client;
+}
+exports.setVcsClient = setVcsClient;
+function getVcsClient() {
+    return vcsClient;
+}
+exports.getVcsClient = getVcsClient;

package/build/vcs/local.d.ts

@@ -1,6 +1,19 @@
-import { Client } from './vcs';
-export default class LocalClient extends Client {
-    getRootPathAsync(): Promise<string>;
-    makeShallowCopyAsync(destinationPath: string): Promise<void>;
-    isFileIgnoredAsync(filePath: string): Promise<boolean>;
+export declare function getRootPath(): string;
+/**
+ * Ignore wraps the 'ignore' package to support multiple .gitignore files
+ * in subdirectories.
+ *
+ * Inconsistencies with git behavior:
+ * - if parent .gitignore has ignore rule and child has exception to that rule,
+ *   file will still be ignored,
+ * - node_modules is always ignored,
+ * - if .easignore exists, .gitignore files are not used.
+ */
+export declare class Ignore {
+    private rootDir;
+    private ignoreMapping;
+    constructor(rootDir: string);
+    initIgnoreAsync(): Promise<void>;
+    ignores(relativePath: string): boolean;
 }
+export declare function makeShallowCopyAsync(src: string, dst: string): Promise<void>;

package/build/vcs/local.js

@@ -1,34 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShallowCopyAsync = exports.Ignore = exports.getRootPath = void 0;
 const tslib_1 = require("tslib");
+const fast_glob_1 = (0, tslib_1.__importDefault)(require("fast-glob"));
 const fs_extra_1 = (0, tslib_1.__importDefault)(require("fs-extra"));
 const ignore_1 = (0, tslib_1.__importDefault)(require("ignore"));
 const path_1 = (0, tslib_1.__importDefault)(require("path"));
-const vcs_1 = require("./vcs");
+const EASIGNORE_FILENAME = '.easignore';
+const GITIGNORE_FILENAME = '.gitignore';
 const DEFAULT_IGNORE = `
+.git
 node_modules
 `;
-class LocalClient extends vcs_1.Client {
-    async getRootPathAsync() {
-        return getRootPath();
-    }
-    async makeShallowCopyAsync(destinationPath) {
-        const srcPath = getRootPath();
-        const ignore = await initIgnoreAsync();
-        await fs_extra_1.default.copy(srcPath, destinationPath, {
-            filter: (srcFilePath) => {
-                if (srcFilePath === srcPath) {
-                    return true;
-                }
-                return !ignore.ignores(path_1.default.relative(srcPath, srcFilePath));
-            },
-        });
-    }
-    async isFileIgnoredAsync(filePath) {
-        return (await initIgnoreAsync()).ignores(filePath);
-    }
-}
-exports.default = LocalClient;
 function getRootPath() {
     var _a;
     const rootPath = (_a = process.env.EAS_PROJECT_ROOT) !== null && _a !== void 0 ? _a : process.cwd();
@@ -37,16 +20,62 @@ function getRootPath() {
     }
     return rootPath;
 }
-async function initIgnoreAsync() {
-    const srcPath = getRootPath();
-    const easIgnorePath = path_1.default.join(srcPath, '.easignore');
-    const gitIgnorePath = path_1.default.join(srcPath, '.gitignore');
-    let ignoreFile = DEFAULT_IGNORE;
-    if (await fs_extra_1.default.pathExists(easIgnorePath)) {
-        ignoreFile = await fs_extra_1.default.readFile(easIgnorePath, 'utf8');
+exports.getRootPath = getRootPath;
+/**
+ * Ignore wraps the 'ignore' package to support multiple .gitignore files
+ * in subdirectories.
+ *
+ * Inconsistencies with git behavior:
+ * - if parent .gitignore has ignore rule and child has exception to that rule,
+ *   file will still be ignored,
+ * - node_modules is always ignored,
+ * - if .easignore exists, .gitignore files are not used.
+ */
+class Ignore {
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+        this.ignoreMapping = [];
+    }
+    async initIgnoreAsync() {
+        const easIgnorePath = path_1.default.join(this.rootDir, EASIGNORE_FILENAME);
+        if (await fs_extra_1.default.pathExists(easIgnorePath)) {
+            this.ignoreMapping = [
+                ['', (0, ignore_1.default)().add(DEFAULT_IGNORE)],
+                ['', (0, ignore_1.default)().add(await fs_extra_1.default.readFile(easIgnorePath, 'utf8'))],
+            ];
+            return;
+        }
+        const ignoreFilePaths = (await (0, fast_glob_1.default)(`**/${GITIGNORE_FILENAME}`, { cwd: this.rootDir, ignore: ['node_modules'] }))
+            // ensure that parent dir is before child directories
+            .sort((a, b) => a.length - b.length && a.localeCompare(b));
+        const ignoreMapping = await Promise.all(ignoreFilePaths.map(async (filePath) => {
+            return [
+                filePath.slice(0, filePath.length - GITIGNORE_FILENAME.length),
+                (0, ignore_1.default)().add(await fs_extra_1.default.readFile(path_1.default.join(this.rootDir, filePath), 'utf8')),
+            ];
+        }));
+        this.ignoreMapping = [['', (0, ignore_1.default)().add(DEFAULT_IGNORE)], ...ignoreMapping];
     }
-    else if (await fs_extra_1.default.pathExists(gitIgnorePath)) {
-        ignoreFile = await fs_extra_1.default.readFile(gitIgnorePath, 'utf8');
+    ignores(relativePath) {
+        for (const [prefix, ignore] of this.ignoreMapping) {
+            if (relativePath.startsWith(prefix) && ignore.ignores(relativePath.slice(prefix.length))) {
+                return true;
+            }
+        }
+        return false;
     }
-    return (0, ignore_1.default)().add(ignoreFile);
 }
+exports.Ignore = Ignore;
+async function makeShallowCopyAsync(src, dst) {
+    const ignore = new Ignore(src);
+    await ignore.initIgnoreAsync();
+    await fs_extra_1.default.copy(src, dst, {
+        filter: (srcFilePath) => {
+            if (srcFilePath === src) {
+                return true;
+            }
+            return !ignore.ignores(path_1.default.relative(src, srcFilePath));
+        },
+    });
+}
+exports.makeShallowCopyAsync = makeShallowCopyAsync;