eas-cli 0.33.0 → 0.35.0

package/build/utils/profiles.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProfilesAsync = void 0;
 const tslib_1 = require("tslib");
+const eas_json_1 = require("@expo/eas-json");
 const log_1 = (0, tslib_1.__importDefault)(require("../log"));
 async function getProfilesAsync({ platforms, profileName: profileNameArg, 
 // eslint-disable-next-line async-protect/async-suffix
@@ -14,13 +15,19 @@ readProfileAsync, }) {
                 profile = await readProfileAsync(platform, 'production');
                 profileName = 'production';
             }
-            catch (error) {
+            catch (errorOuter) {
+                if (errorOuter instanceof eas_json_1.errors.InvalidEasJsonError) {
+                    throw errorOuter;
+                }
                 try {
                     profile = await readProfileAsync(platform, 'release');
                     profileName = 'release';
                     log_1.default.warn('The default profile changed from "release" to "production". We detected that you still have a "release" build profile, so we are using it. Update eas.json to have a profile named "production" under the `build` key, or specify which profile you\'d like to use with the --profile flag. This fallback behavior will be removed in the next major version of EAS CLI.');
                 }
-                catch (error) {
+                catch (errorInner) {
+                    if (errorInner instanceof eas_json_1.errors.InvalidEasJsonError) {
+                        throw errorInner;
+                    }
                     throw new Error('There is no profile named "production" in eas.json');
                 }
             }

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

@@ -0,0 +1,26 @@
+import { Client } from '../vcs';
+export default class GitClient extends Client {
+    ensureRepoExistsAsync(): Promise<void>;
+    commitAsync({ commitMessage, commitAllFiles, }: {
+        commitMessage: string;
+        commitAllFiles?: boolean;
+    }): Promise<void>;
+    isCommitRequiredAsync(): Promise<boolean>;
+    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>;
+}
+/**
+ * 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
+ */
+export declare function isGitCaseSensitiveAsync(): Promise<boolean | undefined>;

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>;