@akylas/nativescript-cli 8.7.2

package/lib/services/assets-generation/assets-generation-service.js

@@ -0,0 +1,178 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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.AssetsGenerationService = void 0;
+const Jimp = require("jimp");
+const Color = require("color");
+const decorators_1 = require("../../common/decorators");
+const constants_1 = require("../../constants");
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+const os_1 = require("os");
+class AssetsGenerationService {
+    get propertiesToEnumerate() {
+        return {
+            icon: ["icons"],
+            splash: ["splashBackgrounds", "splashCenterImages", "splashImages"],
+        };
+    }
+    constructor($logger, $projectDataService, $fs) {
+        this.$logger = $logger;
+        this.$projectDataService = $projectDataService;
+        this.$fs = $fs;
+    }
+    generateIcons(resourceGenerationData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.info("Generating icons ...");
+            yield this.generateImagesForDefinitions(resourceGenerationData, this.propertiesToEnumerate.icon);
+            this.$logger.info("Icons generation completed.");
+        });
+    }
+    generateSplashScreens(splashesGenerationData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.info("Generating splash screens ...");
+            yield this.generateImagesForDefinitions(splashesGenerationData, this.propertiesToEnumerate.splash);
+            this.$logger.info("Splash screens generation completed.");
+        });
+    }
+    generateImagesForDefinitions(generationData, propertiesToEnumerate) {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            const background = generationData.background || "white";
+            const assetsStructure = yield this.$projectDataService.getAssetsStructure(generationData);
+            const assetItems = _(assetsStructure)
+                .filter((assetGroup, platform) => !generationData.platform ||
+                platform.toLowerCase() === generationData.platform.toLowerCase())
+                .map((assetGroup) => _.filter(assetGroup, (assetSubGroup, imageTypeKey) => assetSubGroup && propertiesToEnumerate.indexOf(imageTypeKey) !== -1))
+                .flatten()
+                .map((assetSubGroup) => assetSubGroup.images)
+                .flatten()
+                .filter((assetItem) => !!assetItem.filename)
+                .value();
+            for (const assetItem of assetItems) {
+                if (assetItem.operation === "delete") {
+                    if (this.$fs.exists(assetItem.path)) {
+                        this.$fs.deleteFile(assetItem.path);
+                    }
+                    continue;
+                }
+                if (assetItem.operation === "writeXMLColor") {
+                    const colorName = (_a = assetItem.data) === null || _a === void 0 ? void 0 : _a.colorName;
+                    if (!colorName) {
+                        continue;
+                    }
+                    try {
+                        const color = (_e = (_c = generationData[(_b = assetItem.data) === null || _b === void 0 ? void 0 : _b.fromKey]) !== null && _c !== void 0 ? _c : (_d = assetItem.data) === null || _d === void 0 ? void 0 : _d.default) !== null && _e !== void 0 ? _e : "white";
+                        const colorHEX = Jimp.cssColorToHex(color);
+                        const hex = (_f = colorHEX === null || colorHEX === void 0 ? void 0 : colorHEX.toString(16).substring(0, 6)) !== null && _f !== void 0 ? _f : "FFFFFF";
+                        this.$fs.writeFile(assetItem.path, [
+                            `<?xml version="1.0" encoding="utf-8"?>`,
+                            `<resources>`,
+                            `    <color name="${colorName}">#${hex.toUpperCase()}</color>`,
+                            `</resources>`,
+                        ].join(os_1.EOL));
+                    }
+                    catch (err) {
+                        this.$logger.info(`Failed to write provided color to ${assetItem.path} -> ${colorName}. See --log trace for more info.`);
+                        this.$logger.trace(err);
+                    }
+                    continue;
+                }
+                const operation = assetItem.resizeOperation || "resize";
+                let tempScale = null;
+                if (assetItem.scale) {
+                    if (_.isNumber(assetItem.scale)) {
+                        tempScale = assetItem.scale;
+                    }
+                    else {
+                        const splittedElements = `${assetItem.scale}`.split(constants_1.AssetConstants.sizeDelimiter);
+                        tempScale =
+                            splittedElements &&
+                                splittedElements.length &&
+                                splittedElements[0] &&
+                                +splittedElements[0];
+                    }
+                }
+                const scale = tempScale || constants_1.AssetConstants.defaultScale;
+                const outputPath = assetItem.path;
+                const width = assetItem.width * scale;
+                const height = assetItem.height * scale;
+                if (!width || !height) {
+                    this.$logger.warn(`Image ${assetItem.filename} is skipped as its width and height are invalid.`);
+                    continue;
+                }
+                let image;
+                switch (operation) {
+                    case "overlayWith":
+                        const overlayImageScale = assetItem.overlayImageScale ||
+                            constants_1.AssetConstants.defaultOverlayImageScale;
+                        const imageResize = Math.round(Math.min(width, height) * overlayImageScale);
+                        image = yield this.resize(generationData.imagePath, imageResize, imageResize);
+                        image = this.generateImage(background, width, height, outputPath, image);
+                        break;
+                    case "blank":
+                        image = this.generateImage(background, width, height, outputPath);
+                        break;
+                    case "resize":
+                        image = yield this.resize(generationData.imagePath, width, height);
+                        break;
+                    case "outerScale":
+                        image = yield this.resize(generationData.imagePath, assetItem.width, assetItem.height);
+                        image = this.generateImage("#00000000", width, height, outputPath, image);
+                        break;
+                    default:
+                        throw new Error(`Invalid image generation operation: ${operation}`);
+                }
+                if (assetItem.rgba === false) {
+                    image = image.colorType(2);
+                }
+                image.write(outputPath);
+            }
+        });
+    }
+    resize(imagePath, width, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const image = yield Jimp.read(imagePath);
+            return image.scaleToFit(width, height);
+        });
+    }
+    generateImage(background, width, height, outputPath, overlayImage) {
+        const J = Jimp;
+        const backgroundColor = this.getRgbaNumber(background);
+        let image = new J(width, height, backgroundColor);
+        if (overlayImage) {
+            const centeredWidth = (width - overlayImage.bitmap.width) / 2;
+            const centeredHeight = (height - overlayImage.bitmap.height) / 2;
+            image = image.composite(overlayImage, centeredWidth, centeredHeight);
+        }
+        return image;
+    }
+    getRgbaNumber(colorString) {
+        const color = new Color(colorString);
+        const colorRgb = color.rgb();
+        const alpha = Math.round(colorRgb.alpha() * 255);
+        return Jimp.rgbaToInt(colorRgb.red(), colorRgb.green(), colorRgb.blue(), alpha);
+    }
+}
+__decorate([
+    (0, decorators_1.exported)("assetsGenerationService")
+], AssetsGenerationService.prototype, "generateIcons", null);
+__decorate([
+    (0, decorators_1.exported)("assetsGenerationService")
+], AssetsGenerationService.prototype, "generateSplashScreens", null);
+exports.AssetsGenerationService = AssetsGenerationService;
+yok_1.injector.register("assetsGenerationService", AssetsGenerationService);

package/lib/services/build-artifacts-service.js

@@ -0,0 +1,113 @@
+"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.BuildArtifactsService = void 0;
+const path = require("path");
+const yok_1 = require("../common/yok");
+const _ = require("lodash");
+class BuildArtifactsService {
+    constructor($errors, $fs, $logger) {
+        this.$errors = $errors;
+        this.$fs = $fs;
+        this.$logger = $logger;
+    }
+    getLatestAppPackagePath(platformData, buildOutputOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const outputPath = buildOutputOptions.outputPath ||
+                platformData.getBuildOutputPath(buildOutputOptions);
+            const applicationPackage = this.getLatestApplicationPackage(outputPath, platformData.getValidBuildOutputData(buildOutputOptions));
+            const packageFile = applicationPackage.packageName;
+            if (!packageFile || !this.$fs.exists(packageFile)) {
+                this.$errors.fail(`Unable to find built application. Try 'ns build ${platformData.platformNameLowerCase}'.`);
+            }
+            return packageFile;
+        });
+    }
+    getAllAppPackages(buildOutputPath, validBuildOutputData) {
+        const rootFiles = this.$fs
+            .readDirectory(buildOutputPath)
+            .map((filename) => path.join(buildOutputPath, filename));
+        let result = this.getApplicationPackagesCore(rootFiles, validBuildOutputData.packageNames);
+        if (result) {
+            return result;
+        }
+        const candidates = this.$fs.enumerateFilesInDirectorySync(buildOutputPath);
+        result = this.getApplicationPackagesCore(candidates, validBuildOutputData.packageNames);
+        if (result) {
+            return result;
+        }
+        if (validBuildOutputData.regexes && validBuildOutputData.regexes.length) {
+            const packages = candidates.filter((filepath) => _.some(validBuildOutputData.regexes, (regex) => regex.test(path.basename(filepath))));
+            return this.createApplicationPackages(packages);
+        }
+        return [];
+    }
+    copyAppPackages(targetPath, platformData, buildOutputOptions) {
+        targetPath = path.resolve(targetPath);
+        const outputPath = buildOutputOptions.outputPath ||
+            platformData.getBuildOutputPath(buildOutputOptions);
+        const applicationPackages = this.getAllAppPackages(outputPath, platformData.getValidBuildOutputData(buildOutputOptions));
+        this.$fs.ensureDirectoryExists(path.dirname(targetPath));
+        let filterRegex;
+        let targetIsDirectory = false;
+        if (this.$fs.exists(targetPath) &&
+            this.$fs.getFsStats(targetPath).isDirectory()) {
+            targetIsDirectory = true;
+        }
+        else if (targetPath.match(/\.(ipa|aab|apk)/)) {
+            if (applicationPackages.length > 1) {
+                filterRegex = new RegExp("universal");
+                this.$logger.trace(`Multiple packages were built but only the universal one will be copied if existing'.`);
+            }
+        }
+        else {
+            targetIsDirectory = true;
+        }
+        applicationPackages.forEach((pack) => {
+            const targetFilePath = targetIsDirectory
+                ? path.join(targetPath, path.basename(pack.packageName))
+                : targetPath;
+            if (!filterRegex || filterRegex.test(pack.packageName)) {
+                this.$fs.copyFile(pack.packageName, targetFilePath);
+                this.$logger.info(`Copied file '${pack.packageName}' to '${targetFilePath}'.`);
+            }
+        });
+    }
+    getLatestApplicationPackage(buildOutputPath, validBuildOutputData, abis) {
+        let packages = this.getAllAppPackages(buildOutputPath, validBuildOutputData);
+        const packageExtName = path.extname(validBuildOutputData.packageNames[0]);
+        if (packages.length === 0) {
+            this.$errors.fail(`No ${packageExtName} found in ${buildOutputPath} directory.`);
+        }
+        if (packages.length > 1) {
+            this.$logger.warn(`More than one ${packageExtName} found in ${buildOutputPath} directory. Using the last one produced from build.`);
+        }
+        packages = _.sortBy(packages, (pkg) => pkg.time).reverse();
+        return packages[0];
+    }
+    getApplicationPackagesCore(candidates, validPackageNames) {
+        const packages = candidates.filter((filePath) => _.includes(validPackageNames, path.basename(filePath)));
+        if (packages.length > 0) {
+            return this.createApplicationPackages(packages);
+        }
+        return null;
+    }
+    createApplicationPackages(packages) {
+        return packages.map((packageName) => {
+            return {
+                packageName,
+                time: this.$fs.getFsStats(packageName).mtime,
+            };
+        });
+    }
+}
+exports.BuildArtifactsService = BuildArtifactsService;
+yok_1.injector.register("buildArtifactsService", BuildArtifactsService);

package/lib/services/build-data-service.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildDataService = void 0;
+const build_data_1 = require("../data/build-data");
+const yok_1 = require("../common/yok");
+class BuildDataService {
+    constructor($mobileHelper) {
+        this.$mobileHelper = $mobileHelper;
+    }
+    getBuildData(projectDir, platform, data) {
+        if (this.$mobileHelper.isApplePlatform(platform)) {
+            return new build_data_1.IOSBuildData(projectDir, platform, data);
+        }
+        else if (this.$mobileHelper.isAndroidPlatform(platform)) {
+            return new build_data_1.AndroidBuildData(projectDir, platform, data);
+        }
+    }
+}
+exports.BuildDataService = BuildDataService;
+yok_1.injector.register("buildDataService", BuildDataService);

package/lib/services/build-info-file-service.js

@@ -0,0 +1,79 @@
+"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.BuildInfoFileService = void 0;
+const path = require("path");
+const helpers = require("../common/helpers");
+const yok_1 = require("../common/yok");
+const buildInfoFileName = ".nsbuildinfo";
+class BuildInfoFileService {
+    constructor($devicePathProvider, $fs, $mobileHelper, $projectChangesService) {
+        this.$devicePathProvider = $devicePathProvider;
+        this.$fs = $fs;
+        this.$mobileHelper = $mobileHelper;
+        this.$projectChangesService = $projectChangesService;
+    }
+    getLocalBuildInfo(platformData, buildData) {
+        const outputPath = buildData.outputPath || platformData.getBuildOutputPath(buildData);
+        const buildInfoFile = path.join(outputPath, buildInfoFileName);
+        if (this.$fs.exists(buildInfoFile)) {
+            try {
+                const buildInfo = this.$fs.readJson(buildInfoFile);
+                return buildInfo;
+            }
+            catch (e) {
+                return null;
+            }
+        }
+        return null;
+    }
+    getDeviceBuildInfo(device, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceFilePath = yield this.getDeviceBuildInfoFilePath(device, projectData);
+            try {
+                const deviceFileContent = yield this.$mobileHelper.getDeviceFileContent(device, deviceFilePath, projectData);
+                return JSON.parse(deviceFileContent);
+            }
+            catch (e) {
+                return null;
+            }
+        });
+    }
+    saveLocalBuildInfo(platformData, buildInfoFileDirname) {
+        const buildInfoFile = path.join(buildInfoFileDirname, buildInfoFileName);
+        const prepareInfo = this.$projectChangesService.getPrepareInfo(platformData);
+        const buildInfo = {
+            prepareTime: prepareInfo.changesRequireBuildTime,
+            buildTime: new Date().toString(),
+        };
+        this.$fs.writeJson(buildInfoFile, buildInfo);
+    }
+    saveDeviceBuildInfo(device, projectData, outputFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceFilePath = yield this.getDeviceBuildInfoFilePath(device, projectData);
+            const appIdentifier = projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
+            yield device.fileSystem.putFile(path.join(outputFilePath, buildInfoFileName), deviceFilePath, appIdentifier);
+        });
+    }
+    getDeviceBuildInfoFilePath(device, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = device.deviceInfo.platform.toLowerCase();
+            const deviceRootPath = yield this.$devicePathProvider.getDeviceProjectRootPath(device, {
+                appIdentifier: projectData.projectIdentifiers[platform],
+                getDirname: true,
+            });
+            const result = helpers.fromWindowsRelativePathToUnix(path.join(deviceRootPath, buildInfoFileName));
+            return result;
+        });
+    }
+}
+exports.BuildInfoFileService = BuildInfoFileService;
+yok_1.injector.register("buildInfoFileService", BuildInfoFileService);

package/lib/services/cleanup-service.js

@@ -0,0 +1,194 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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.CleanupService = void 0;
+const path = require("path");
+const decorators_1 = require("../common/decorators");
+const yok_1 = require("../common/yok");
+class CleanupService {
+    constructor($options, $staticConfig, $childProcess) {
+        this.$staticConfig = $staticConfig;
+        this.$childProcess = $childProcess;
+        this.shouldDispose = true;
+        this.pathToCleanupLogFile = $options.cleanupLogFile;
+    }
+    addCleanupCommand(commandInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanupProcess = yield this.getCleanupProcess();
+            cleanupProcess.send({
+                messageType: "AddCleanCommand",
+                commandInfo,
+            });
+        });
+    }
+    removeCleanupCommand(commandInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanupProcess = yield this.getCleanupProcess();
+            cleanupProcess.send({
+                messageType: "RemoveCleanCommand",
+                commandInfo,
+            });
+        });
+    }
+    addRequest(requestInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanupProcess = yield this.getCleanupProcess();
+            cleanupProcess.send({
+                messageType: "AddRequest",
+                requestInfo,
+            });
+        });
+    }
+    removeRequest(requestInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanupProcess = yield this.getCleanupProcess();
+            cleanupProcess.send({
+                messageType: "RemoveRequest",
+                requestInfo,
+            });
+        });
+    }
+    addCleanupDeleteAction(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanupProcess = yield this.getCleanupProcess();
+            cleanupProcess.send({
+                messageType: "AddDeleteFileAction",
+                filePath,
+            });
+        });
+    }
+    removeCleanupDeleteAction(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanupProcess = yield this.getCleanupProcess();
+            cleanupProcess.send({
+                messageType: "RemoveDeleteFileAction",
+                filePath,
+            });
+        });
+    }
+    addCleanupJS(jsCommand) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanupProcess = yield this.getCleanupProcess();
+            cleanupProcess.send({
+                messageType: "AddJSFileToRequire",
+                jsCommand,
+            });
+        });
+    }
+    removeCleanupJS(jsCommand) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleanupProcess = yield this.getCleanupProcess();
+            cleanupProcess.send({
+                messageType: "RemoveJSFileToRequire",
+                jsCommand,
+            });
+        });
+    }
+    addKillProcess(pid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const killSpawnCommandInfo = this.getKillProcesSpawnInfo(pid);
+            yield this.addCleanupCommand(killSpawnCommandInfo);
+        });
+    }
+    removeKillProcess(pid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const killSpawnCommandInfo = this.getKillProcesSpawnInfo(pid);
+            yield this.removeCleanupCommand(killSpawnCommandInfo);
+        });
+    }
+    setCleanupLogFile(filePath) {
+        this.pathToCleanupLogFile = filePath;
+    }
+    dispose() {
+        if (this.cleanupProcess && this.shouldDispose) {
+            this.cleanupProcess.disconnect();
+        }
+    }
+    setShouldDispose(shouldDispose) {
+        this.shouldDispose = shouldDispose;
+    }
+    getCleanupProcess() {
+        return new Promise((resolve, reject) => {
+            const cleanupProcessArgs = this.getCleanupProcessArgs();
+            const cleanupProcess = this.$childProcess.spawn(process.execPath, cleanupProcessArgs, {
+                stdio: ["ignore", "ignore", "ignore", "ipc"],
+                detached: true,
+            });
+            cleanupProcess.unref();
+            let isSettled = false;
+            const timeoutId = setTimeout(() => {
+                if (!isSettled) {
+                    reject(new Error("Unable to start Cleanup process."));
+                }
+            }, CleanupService.CLEANUP_PROCESS_START_TIMEOUT);
+            cleanupProcess.on("error", (err) => {
+                clearTimeout(timeoutId);
+                if (!isSettled) {
+                    isSettled = true;
+                    reject(err);
+                }
+            });
+            cleanupProcess.on("message", (data) => {
+                if (data === "ProcessReadyToReceive") {
+                    clearTimeout(timeoutId);
+                    if (!isSettled) {
+                        isSettled = true;
+                        this.cleanupProcess = cleanupProcess;
+                        resolve(cleanupProcess);
+                    }
+                }
+            });
+        });
+    }
+    getCleanupProcessArgs() {
+        const cleanupProcessArgs = [
+            path.join(__dirname, "..", "detached-processes", "cleanup-process.js"),
+            this.$staticConfig.PATH_TO_BOOTSTRAP,
+        ];
+        if (this.pathToCleanupLogFile) {
+            cleanupProcessArgs.push(path.resolve(this.pathToCleanupLogFile));
+        }
+        return cleanupProcessArgs;
+    }
+    getKillProcesSpawnInfo(pid) {
+        let command;
+        let args;
+        switch (process.platform) {
+            case "win32":
+                command = "taskkill";
+                args = ["/pid", pid, "/T", "/F"];
+                break;
+            default:
+                command = path.join(__dirname, "../bash-scripts/terminateProcess.sh");
+                args = [pid];
+                break;
+        }
+        return {
+            command,
+            args,
+        };
+    }
+}
+CleanupService.CLEANUP_PROCESS_START_TIMEOUT = 10 * 1000;
+__decorate([
+    (0, decorators_1.exported)("cleanupService")
+], CleanupService.prototype, "setCleanupLogFile", null);
+__decorate([
+    (0, decorators_1.cache)()
+], CleanupService.prototype, "getCleanupProcess", null);
+exports.CleanupService = CleanupService;
+yok_1.injector.register("cleanupService", CleanupService);