nativescript 8.9.0-alpha.3 → 8.9.0-dev.0

package/lib/services/webpack/webpack-compiler-service.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebpackCompilerService = void 0;
 const path = require("path");
@@ -41,199 +32,192 @@ class WebpackCompilerService extends events_1.EventEmitter {
         this.webpackProcesses = {};
         this.expectedHashes = {};
     }
-    compileWithWatch(platformData, projectData, prepareData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                if (this.webpackProcesses[platformData.platformNameLowerCase]) {
-                    resolve(void 0);
-                    return;
-                }
-                let isFirstWebpackWatchCompilation = true;
-                prepareData.watch = true;
-                try {
-                    const childProcess = yield this.startWebpackProcess(platformData, projectData, prepareData);
-                    childProcess.stdout.on("data", function (data) {
-                        process.stdout.write(data);
-                    });
-                    childProcess.stderr.on("data", function (data) {
-                        process.stderr.write(data);
-                    });
-                    childProcess.on("message", (message) => {
-                        this.$logger.trace("Message from webpack", message);
-                        if (typeof message === "object" &&
-                            "version" in message &&
-                            "type" in message) {
-                            if (isFirstWebpackWatchCompilation) {
-                                isFirstWebpackWatchCompilation = false;
-                                resolve(childProcess);
-                                return;
-                            }
-                            return this.handleHMRMessage(message, platformData, projectData, prepareData);
-                        }
-                        if (message === "Webpack compilation complete.") {
-                            this.$logger.info("Webpack build done!");
+    async compileWithWatch(platformData, projectData, prepareData) {
+        return new Promise(async (resolve, reject) => {
+            if (this.webpackProcesses[platformData.platformNameLowerCase]) {
+                resolve(void 0);
+                return;
+            }
+            let isFirstWebpackWatchCompilation = true;
+            prepareData.watch = true;
+            try {
+                const childProcess = await this.startWebpackProcess(platformData, projectData, prepareData);
+                childProcess.stdout.on("data", function (data) {
+                    process.stdout.write(data);
+                });
+                childProcess.stderr.on("data", function (data) {
+                    process.stderr.write(data);
+                });
+                childProcess.on("message", (message) => {
+                    this.$logger.trace("Message from webpack", message);
+                    if (typeof message === "object" &&
+                        "version" in message &&
+                        "type" in message) {
+                        if (isFirstWebpackWatchCompilation) {
+                            isFirstWebpackWatchCompilation = false;
                             resolve(childProcess);
+                            return;
                         }
-                        message = message;
-                        if (message.emittedFiles) {
-                            if (isFirstWebpackWatchCompilation) {
-                                isFirstWebpackWatchCompilation = false;
-                                this.expectedHashes[platformData.platformNameLowerCase] =
-                                    prepareData.hmr ? message.hash : "";
-                                return;
-                            }
-                            const previousHash = this.expectedHashes[platformData.platformNameLowerCase];
-                            let result;
-                            if (prepareData.hmr) {
-                                result = this.getUpdatedEmittedFiles(message.emittedFiles, message.chunkFiles, message.hash, platformData.platformNameLowerCase);
-                            }
-                            else {
-                                result = {
-                                    emittedFiles: message.emittedFiles,
-                                    fallbackFiles: [],
-                                    hash: "",
-                                };
-                            }
-                            const files = result.emittedFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
-                            const fallbackFiles = result.fallbackFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
-                            const data = {
-                                files,
-                                hasOnlyHotUpdateFiles: files.every((f) => f.indexOf("hot-update") > -1),
-                                hmrData: {
-                                    hash: result.hash,
-                                    fallbackFiles,
-                                },
-                                platform: platformData.platformNameLowerCase,
-                            };
-                            this.$logger.trace("Generated data from webpack message:", data);
-                            if (data.hasOnlyHotUpdateFiles && previousHash === message.hash) {
-                                return;
-                            }
-                            if (data.files.length) {
-                                this.emit(constants_1.WEBPACK_COMPILATION_COMPLETE, data);
-                            }
+                        return this.handleHMRMessage(message, platformData, projectData, prepareData);
+                    }
+                    if (message === "Webpack compilation complete.") {
+                        this.$logger.info("Webpack build done!");
+                        resolve(childProcess);
+                    }
+                    message = message;
+                    if (message.emittedFiles) {
+                        if (isFirstWebpackWatchCompilation) {
+                            isFirstWebpackWatchCompilation = false;
+                            this.expectedHashes[platformData.platformNameLowerCase] =
+                                prepareData.hmr ? message.hash : "";
+                            return;
                         }
-                    });
-                    childProcess.on("error", (err) => {
-                        this.$logger.trace(`Unable to start webpack process in watch mode. Error is: ${err}`);
-                        delete this.webpackProcesses[platformData.platformNameLowerCase];
-                        reject(err);
-                    });
-                    childProcess.on("close", (arg) => __awaiter(this, void 0, void 0, function* () {
-                        yield this.$cleanupService.removeKillProcess(childProcess.pid.toString());
-                        const exitCode = typeof arg === "number" ? arg : arg && arg.code;
-                        this.$logger.trace(`Webpack process exited with code ${exitCode} when we expected it to be long living with watch.`);
-                        const error = new Error(`Executing webpack failed with exit code ${exitCode}.`);
-                        error.code = exitCode;
-                        delete this.webpackProcesses[platformData.platformNameLowerCase];
-                        reject(error);
-                    }));
-                }
-                catch (err) {
-                    reject(err);
-                }
-            }));
-        });
-    }
-    compileWithoutWatch(platformData, projectData, prepareData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                if (this.webpackProcesses[platformData.platformNameLowerCase]) {
-                    resolve();
-                    return;
-                }
-                try {
-                    const childProcess = yield this.startWebpackProcess(platformData, projectData, prepareData);
-                    childProcess.on("error", (err) => {
-                        this.$logger.trace(`Unable to start webpack process in non-watch mode. Error is: ${err}`);
-                        delete this.webpackProcesses[platformData.platformNameLowerCase];
-                        reject(err);
-                    });
-                    childProcess.on("close", (arg) => __awaiter(this, void 0, void 0, function* () {
-                        yield this.$cleanupService.removeKillProcess(childProcess.pid.toString());
-                        delete this.webpackProcesses[platformData.platformNameLowerCase];
-                        const exitCode = typeof arg === "number" ? arg : arg && arg.code;
-                        if (exitCode === 0) {
-                            resolve();
+                        const previousHash = this.expectedHashes[platformData.platformNameLowerCase];
+                        let result;
+                        if (prepareData.hmr) {
+                            result = this.getUpdatedEmittedFiles(message.emittedFiles, message.chunkFiles, message.hash, platformData.platformNameLowerCase);
                         }
                         else {
-                            const error = new Error(`Executing webpack failed with exit code ${exitCode}.`);
-                            error.code = exitCode;
-                            reject(error);
+                            result = {
+                                emittedFiles: message.emittedFiles,
+                                fallbackFiles: [],
+                                hash: "",
+                            };
                         }
-                    }));
-                }
-                catch (err) {
+                        const files = result.emittedFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
+                        const fallbackFiles = result.fallbackFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
+                        const data = {
+                            files,
+                            hasOnlyHotUpdateFiles: files.every((f) => f.indexOf("hot-update") > -1),
+                            hmrData: {
+                                hash: result.hash,
+                                fallbackFiles,
+                            },
+                            platform: platformData.platformNameLowerCase,
+                        };
+                        this.$logger.trace("Generated data from webpack message:", data);
+                        if (data.hasOnlyHotUpdateFiles && previousHash === message.hash) {
+                            return;
+                        }
+                        if (data.files.length) {
+                            this.emit(constants_1.WEBPACK_COMPILATION_COMPLETE, data);
+                        }
+                    }
+                });
+                childProcess.on("error", (err) => {
+                    this.$logger.trace(`Unable to start webpack process in watch mode. Error is: ${err}`);
+                    delete this.webpackProcesses[platformData.platformNameLowerCase];
                     reject(err);
-                }
-            }));
-        });
-    }
-    stopWebpackCompiler(platform) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (platform) {
-                yield this.stopWebpackForPlatform(platform);
+                });
+                childProcess.on("close", async (arg) => {
+                    await this.$cleanupService.removeKillProcess(childProcess.pid.toString());
+                    const exitCode = typeof arg === "number" ? arg : arg && arg.code;
+                    this.$logger.trace(`Webpack process exited with code ${exitCode} when we expected it to be long living with watch.`);
+                    const error = new Error(`Executing webpack failed with exit code ${exitCode}.`);
+                    error.code = exitCode;
+                    delete this.webpackProcesses[platformData.platformNameLowerCase];
+                    reject(error);
+                });
             }
-            else {
-                const webpackedPlatforms = Object.keys(this.webpackProcesses);
-                for (let i = 0; i < webpackedPlatforms.length; i++) {
-                    yield this.stopWebpackForPlatform(webpackedPlatforms[i]);
-                }
+            catch (err) {
+                reject(err);
             }
         });
     }
-    shouldUsePreserveSymlinksOption() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentPackageManager = yield this.$packageManager.getPackageManagerName();
-            const res = currentPackageManager !== constants_1.PackageManagers.pnpm;
-            return res;
-        });
-    }
-    startWebpackProcess(platformData, projectData, prepareData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$fs.exists(projectData.webpackConfigPath)) {
-                this.$errors.fail(`The webpack configuration file ${projectData.webpackConfigPath} does not exist. Ensure the file exists, or update the path in ${constants_1.CONFIG_FILE_NAME_DISPLAY}.`);
-            }
-            const envData = this.buildEnvData(platformData.platformNameLowerCase, projectData, prepareData);
-            const envParams = yield this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
-            const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
-            if (yield this.shouldUsePreserveSymlinksOption()) {
-                additionalNodeArgs.push("--preserve-symlinks");
+    async compileWithoutWatch(platformData, projectData, prepareData) {
+        return new Promise(async (resolve, reject) => {
+            if (this.webpackProcesses[platformData.platformNameLowerCase]) {
+                resolve();
+                return;
             }
-            if (process.arch === "x64") {
-                additionalNodeArgs.unshift("--max_old_space_size=4096");
-            }
-            const args = [
-                ...additionalNodeArgs,
-                this.getWebpackExecutablePath(projectData),
-                this.isWebpack5(projectData) ? `build` : null,
-                `--config=${projectData.webpackConfigPath}`,
-                ...envParams,
-            ].filter(Boolean);
-            if (prepareData.watch) {
-                args.push("--watch");
-            }
-            const stdio = prepareData.watch ? ["ipc"] : "inherit";
-            const options = {
-                cwd: projectData.projectDir,
-                stdio,
-            };
-            options.env = {
-                NATIVESCRIPT_WEBPACK_ENV: JSON.stringify(envData)
-            };
-            if (this.$options.hostProjectPath) {
-                Object.assign(options.env, {
-                    USER_PROJECT_PLATFORMS_ANDROID: this.$options.hostProjectPath,
-                    USER_PROJECT_PLATFORMS_ANDROID_MODULE: this.$options.hostProjectModuleName,
-                    USER_PROJECT_PLATFORMS_IOS: this.$options.hostProjectPath,
+            try {
+                const childProcess = await this.startWebpackProcess(platformData, projectData, prepareData);
+                childProcess.on("error", (err) => {
+                    this.$logger.trace(`Unable to start webpack process in non-watch mode. Error is: ${err}`);
+                    delete this.webpackProcesses[platformData.platformNameLowerCase];
+                    reject(err);
+                });
+                childProcess.on("close", async (arg) => {
+                    await this.$cleanupService.removeKillProcess(childProcess.pid.toString());
+                    delete this.webpackProcesses[platformData.platformNameLowerCase];
+                    const exitCode = typeof arg === "number" ? arg : arg && arg.code;
+                    if (exitCode === 0) {
+                        resolve();
+                    }
+                    else {
+                        const error = new Error(`Executing webpack failed with exit code ${exitCode}.`);
+                        error.code = exitCode;
+                        reject(error);
+                    }
                 });
             }
-            const childProcess = this.$childProcess.spawn(process.execPath, args, options);
-            this.webpackProcesses[platformData.platformNameLowerCase] = childProcess;
-            yield this.$cleanupService.addKillProcess(childProcess.pid.toString());
-            return childProcess;
+            catch (err) {
+                reject(err);
+            }
         });
     }
+    async stopWebpackCompiler(platform) {
+        if (platform) {
+            await this.stopWebpackForPlatform(platform);
+        }
+        else {
+            const webpackedPlatforms = Object.keys(this.webpackProcesses);
+            for (let i = 0; i < webpackedPlatforms.length; i++) {
+                await this.stopWebpackForPlatform(webpackedPlatforms[i]);
+            }
+        }
+    }
+    async shouldUsePreserveSymlinksOption() {
+        const currentPackageManager = await this.$packageManager.getPackageManagerName();
+        const res = currentPackageManager !== constants_1.PackageManagers.pnpm;
+        return res;
+    }
+    async startWebpackProcess(platformData, projectData, prepareData) {
+        if (!this.$fs.exists(projectData.webpackConfigPath)) {
+            this.$errors.fail(`The webpack configuration file ${projectData.webpackConfigPath} does not exist. Ensure the file exists, or update the path in ${constants_1.CONFIG_FILE_NAME_DISPLAY}.`);
+        }
+        const envData = this.buildEnvData(platformData.platformNameLowerCase, projectData, prepareData);
+        const envParams = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
+        const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
+        if (await this.shouldUsePreserveSymlinksOption()) {
+            additionalNodeArgs.push("--preserve-symlinks");
+        }
+        if (process.arch === "x64") {
+            additionalNodeArgs.unshift("--max_old_space_size=4096");
+        }
+        const args = [
+            ...additionalNodeArgs,
+            this.getWebpackExecutablePath(projectData),
+            this.isWebpack5(projectData) ? `build` : null,
+            `--config=${projectData.webpackConfigPath}`,
+            ...envParams,
+        ].filter(Boolean);
+        if (prepareData.watch) {
+            args.push("--watch");
+        }
+        const stdio = prepareData.watch ? ["ipc"] : "inherit";
+        const options = {
+            cwd: projectData.projectDir,
+            stdio,
+        };
+        options.env = {
+            NATIVESCRIPT_WEBPACK_ENV: JSON.stringify(envData),
+        };
+        if (this.$hostInfo.isWindows) {
+            Object.assign(options.env, { APPDATA: process.env.appData });
+        }
+        if (this.$options.hostProjectPath) {
+            Object.assign(options.env, {
+                USER_PROJECT_PLATFORMS_ANDROID: this.$options.hostProjectPath,
+                USER_PROJECT_PLATFORMS_ANDROID_MODULE: this.$options.hostProjectModuleName,
+                USER_PROJECT_PLATFORMS_IOS: this.$options.hostProjectPath,
+            });
+        }
+        const childProcess = this.$childProcess.spawn(process.execPath, args, options);
+        this.webpackProcesses[platformData.platformNameLowerCase] = childProcess;
+        await this.$cleanupService.addKillProcess(childProcess.pid.toString());
+        return childProcess;
+    }
     buildEnvData(platform, projectData, prepareData) {
         var _a, _b, _c;
         const { env } = prepareData;
@@ -264,48 +248,46 @@ class WebpackCompilerService extends events_1.EventEmitter {
         }
         return envData;
     }
-    buildEnvCommandLineParams(envData, platformData, projectData, prepareData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const envFlagNames = Object.keys(envData);
-            const canSnapshot = prepareData.release &&
-                this.$mobileHelper.isAndroidPlatform(platformData.normalizedPlatformName);
-            if (envData && envData.snapshot) {
-                if (!canSnapshot) {
-                    this.$logger.warn("Stripping the snapshot flag. " +
-                        "Bear in mind that snapshot is only available in Android release builds.");
-                    envFlagNames.splice(envFlagNames.indexOf("snapshot"), 1);
-                }
-                else if (this.$hostInfo.isWindows) {
-                    const minWebpackPluginWithWinSnapshotsVersion = "1.3.0";
-                    const installedWebpackPluginVersion = yield this.$packageInstallationManager.getInstalledDependencyVersion(constants_1.WEBPACK_PLUGIN_NAME, projectData.projectDir);
-                    const hasWebpackPluginWithWinSnapshotsSupport = !!installedWebpackPluginVersion
-                        ? semver.gte(semver.coerce(installedWebpackPluginVersion), minWebpackPluginWithWinSnapshotsVersion)
-                        : true;
-                    if (!hasWebpackPluginWithWinSnapshotsSupport) {
-                        this.$errors.fail(`In order to generate Snapshots on Windows, please upgrade your Webpack plugin version (npm i ${constants_1.WEBPACK_PLUGIN_NAME}@latest).`);
-                    }
-                }
+    async buildEnvCommandLineParams(envData, platformData, projectData, prepareData) {
+        const envFlagNames = Object.keys(envData);
+        const canSnapshot = prepareData.release &&
+            this.$mobileHelper.isAndroidPlatform(platformData.normalizedPlatformName);
+        if (envData && envData.snapshot) {
+            if (!canSnapshot) {
+                this.$logger.warn("Stripping the snapshot flag. " +
+                    "Bear in mind that snapshot is only available in Android release builds.");
+                envFlagNames.splice(envFlagNames.indexOf("snapshot"), 1);
             }
-            const args = [];
-            envFlagNames.map((item) => {
-                let envValue = envData[item];
-                if (typeof envValue === "undefined") {
-                    return;
+            else if (this.$hostInfo.isWindows) {
+                const minWebpackPluginWithWinSnapshotsVersion = "1.3.0";
+                const installedWebpackPluginVersion = await this.$packageInstallationManager.getInstalledDependencyVersion(constants_1.WEBPACK_PLUGIN_NAME, projectData.projectDir);
+                const hasWebpackPluginWithWinSnapshotsSupport = !!installedWebpackPluginVersion
+                    ? semver.gte(semver.coerce(installedWebpackPluginVersion), minWebpackPluginWithWinSnapshotsVersion)
+                    : true;
+                if (!hasWebpackPluginWithWinSnapshotsSupport) {
+                    this.$errors.fail(`In order to generate Snapshots on Windows, please upgrade your Webpack plugin version (npm i ${constants_1.WEBPACK_PLUGIN_NAME}@latest).`);
                 }
-                if (typeof envValue === "boolean") {
-                    if (envValue) {
-                        args.push(`--env.${item}`);
-                    }
+            }
+        }
+        const args = [];
+        envFlagNames.map((item) => {
+            let envValue = envData[item];
+            if (typeof envValue === "undefined") {
+                return;
+            }
+            if (typeof envValue === "boolean") {
+                if (envValue) {
+                    args.push(`--env.${item}`);
                 }
-                else {
-                    if (!Array.isArray(envValue)) {
-                        envValue = [envValue];
-                    }
-                    envValue.map((value) => args.push(`--env.${item}=${value}`));
+            }
+            else {
+                if (!Array.isArray(envValue)) {
+                    envValue = [envValue];
                 }
-            });
-            return args;
+                envValue.map((value) => args.push(`--env.${item}=${value}`));
+            }
         });
+        return args;
     }
     getUpdatedEmittedFiles(allEmittedFiles, chunkFiles, nextHash, platform) {
         const currentHash = this.getCurrentHotUpdateHash(allEmittedFiles);
@@ -334,16 +316,14 @@ class WebpackCompilerService extends events_1.EventEmitter {
         }
         return hotHash || "";
     }
-    stopWebpackForPlatform(platform) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.trace(`Stopping webpack watch for platform ${platform}.`);
-            const webpackProcess = this.webpackProcesses[platform];
-            yield this.$cleanupService.removeKillProcess(webpackProcess.pid.toString());
-            if (webpackProcess) {
-                webpackProcess.kill("SIGINT");
-                delete this.webpackProcesses[platform];
-            }
-        });
+    async stopWebpackForPlatform(platform) {
+        this.$logger.trace(`Stopping webpack watch for platform ${platform}.`);
+        const webpackProcess = this.webpackProcesses[platform];
+        await this.$cleanupService.removeKillProcess(webpackProcess.pid.toString());
+        if (webpackProcess) {
+            webpackProcess.kill("SIGINT");
+            delete this.webpackProcesses[platform];
+        }
     }
     handleHMRMessage(message, platformData, projectData, prepareData) {
         this.$logger.trace("Received message from webpack process:", message);
@@ -409,8 +389,8 @@ class WebpackCompilerService extends events_1.EventEmitter {
         return false;
     }
 }
+exports.WebpackCompilerService = WebpackCompilerService;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], WebpackCompilerService.prototype, "startWebpackProcess", null);
-exports.WebpackCompilerService = WebpackCompilerService;
 yok_1.injector.register("webpackCompilerService", WebpackCompilerService);

package/lib/services/xcconfig-service.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XcconfigService = void 0;
 const path = require("path");
@@ -30,22 +21,20 @@ class XcconfigService {
     getPluginsReleaseXcconfigFilePath(projectRoot) {
         return path.join(projectRoot, "plugins-release.xcconfig");
     }
-    mergeFiles(sourceFile, destinationFile) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$fs.exists(destinationFile)) {
-                this.$fs.writeFile(destinationFile, "");
-            }
-            const escapedDestinationFile = destinationFile.replace(/'/g, "\\'");
-            const escapedSourceFile = sourceFile.replace(/'/g, "\\'");
-            const mergeScript = `require 'xcodeproj';
+    async mergeFiles(sourceFile, destinationFile) {
+        if (!this.$fs.exists(destinationFile)) {
+            this.$fs.writeFile(destinationFile, "");
+        }
+        const escapedDestinationFile = destinationFile.replace(/'/g, "\\'");
+        const escapedSourceFile = sourceFile.replace(/'/g, "\\'");
+        const mergeScript = `require 'xcodeproj';
 		userConfig = Xcodeproj::Config.new('${escapedDestinationFile}')
 		existingConfig = Xcodeproj::Config.new('${escapedSourceFile}')
 		userConfig.attributes.each do |key,|
   			existingConfig.attributes.delete(key) if (userConfig.attributes.key?(key) && existingConfig.attributes.key?(key))
 		end
 		userConfig.merge(existingConfig).save_as(Pathname.new('${escapedDestinationFile}'))`;
-            yield this.$childProcess.exec(`ruby -e "${mergeScript}"`);
-        });
+        await this.$childProcess.exec(`ruby -e "${mergeScript}"`);
     }
     readPropertyValue(xcconfigFilePath, propertyName) {
         if (this.$fs.exists(xcconfigFilePath)) {