nativescript 8.5.1 → 8.5.2

package/lib/base-package-manager.js

@@ -88,7 +88,9 @@ class BasePackageManager {
     getFlagsString(config, asArray) {
         const array = [];
         for (const flag in config) {
-            if (flag === "global" && this.packageManager !== "yarn" && this.packageManager !== "yarn2") {
+            if (flag === "global" &&
+                this.packageManager !== "yarn" &&
+                this.packageManager !== "yarn2") {
                 array.push(`--${flag}`);
                 array.push(`${config[flag]}`);
             }

package/lib/commands/clean.js

@@ -12,16 +12,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CleanCommand = void 0;
 const yok_1 = require("../common/yok");
 const constants = require("../constants");
+const os = require("os");
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const helpers_1 = require("../common/helpers");
+const CLIPath = (0, path_1.resolve)(__dirname, "..", "..", "bin", "nativescript.js");
+function bytesToHumanReadable(bytes) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let unit = 0;
+    while (bytes >= 1024) {
+        bytes /= 1024;
+        unit++;
+    }
+    return `${bytes.toFixed(2)} ${units[unit]}`;
+}
+function promiseMap(values, mapper, concurrency = 10) {
+    let index = 0;
+    let pending = 0;
+    let done = false;
+    return new Promise((resolve, reject) => {
+        const next = () => {
+            done = index === values.length;
+            if (done && pending === 0) {
+                return resolve();
+            }
+            while (pending < concurrency && index < values.length) {
+                const value = values[index++];
+                pending++;
+                mapper(value)
+                    .then(() => {
+                    pending--;
+                    next();
+                })
+                    .catch();
+            }
+        };
+        next();
+    });
+}
 class CleanCommand {
-    constructor($projectCleanupService, $projectConfigService, $terminalSpinnerService) {
+    constructor($projectCleanupService, $projectConfigService, $terminalSpinnerService, $projectService, $prompter, $logger, $options, $childProcess) {
         this.$projectCleanupService = $projectCleanupService;
         this.$projectConfigService = $projectConfigService;
         this.$terminalSpinnerService = $terminalSpinnerService;
+        this.$projectService = $projectService;
+        this.$prompter = $prompter;
+        this.$logger = $logger;
+        this.$options = $options;
+        this.$childProcess = $childProcess;
         this.allowedParameters = [];
     }
     execute(args) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const spinner = this.$terminalSpinnerService.createSpinner();
+            const isDryRun = (_a = this.$options.dryRun) !== null && _a !== void 0 ? _a : false;
+            const isJSON = (_b = this.$options.json) !== null && _b !== void 0 ? _b : false;
+            const spinner = this.$terminalSpinnerService.createSpinner({
+                isSilent: isJSON,
+            });
+            if (!this.$projectService.isValidNativeScriptProject()) {
+                return this.cleanMultipleProjects(spinner);
+            }
             spinner.start("Cleaning project...\n");
             let pathsToClean = [
                 constants.HOOKS_DIR_NAME,
@@ -41,8 +92,20 @@ class CleanCommand {
             }
             catch (err) {
             }
-            const success = yield this.$projectCleanupService.clean(pathsToClean);
-            if (success) {
+            const res = yield this.$projectCleanupService.clean(pathsToClean, {
+                dryRun: isDryRun,
+                silent: isJSON,
+                stats: isJSON,
+            });
+            if (res.stats && isJSON) {
+                console.log(JSON.stringify({
+                    ok: res.ok,
+                    dryRun: isDryRun,
+                    stats: Object.fromEntries(res.stats.entries()),
+                }, null, 2));
+                return;
+            }
+            if (res.ok) {
                 spinner.succeed("Project successfully cleaned.");
             }
             else {
@@ -50,6 +113,139 @@ class CleanCommand {
             }
         });
     }
+    cleanMultipleProjects(spinner) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(0, helpers_1.isInteractive)() || this.$options.json) {
+                this.$logger.warn("No project found in the current directory.");
+                return;
+            }
+            const shouldScan = yield this.$prompter.confirm("No project found in the current directory. Would you like to scan for all projects in sub-directories instead?");
+            if (!shouldScan) {
+                return;
+            }
+            spinner.start("Scanning for projects... Please wait.");
+            const paths = yield this.getNSProjectPathsInDirectory();
+            spinner.succeed(`Found ${paths.length} projects.`);
+            let computed = 0;
+            const updateProgress = () => {
+                const current = `${computed}/${paths.length}`.grey;
+                spinner.start(`Gathering cleanable sizes. This may take a while... ${current}`);
+            };
+            updateProgress();
+            const projects = new Map();
+            yield promiseMap(paths, (p) => {
+                return this.$childProcess
+                    .exec(`node ${CLIPath} clean --dry-run --json --disable-analytics`, {
+                    cwd: p,
+                })
+                    .then((res) => {
+                    const paths = JSON.parse(res).stats;
+                    return Object.values(paths).reduce((a, b) => a + b, 0);
+                })
+                    .catch((err) => {
+                    this.$logger.trace("Failed to get project size for %s, Error is:", p, err);
+                    return -1;
+                })
+                    .then((size) => {
+                    if (size > 0 || size === -1) {
+                        projects.set(p, size);
+                    }
+                    computed++;
+                    updateProgress();
+                });
+            }, os.cpus().length);
+            spinner.clear();
+            spinner.stop();
+            this.$logger.clearScreen();
+            const totalSize = Array.from(projects.values())
+                .filter((s) => s > 0)
+                .reduce((a, b) => a + b, 0);
+            const pathsToClean = yield this.$prompter.promptForChoice(`Found ${projects.size} cleanable project(s) with a total size of: ${bytesToHumanReadable(totalSize).green}. Select projects to clean`, Array.from(projects.keys()).map((p) => {
+                const size = projects.get(p);
+                let description;
+                if (size === -1) {
+                    description = " - could not get size";
+                }
+                else {
+                    description = ` - ${bytesToHumanReadable(size)}`;
+                }
+                return {
+                    title: `${p}${description.grey}`,
+                    value: p,
+                };
+            }), true, {
+                optionsPerPage: process.stdout.rows - 6,
+            });
+            this.$logger.clearScreen();
+            spinner.warn(`This will run "${`ns clean`.yellow}" in all the selected projects and ${"delete files from your system".red.bold}!`);
+            spinner.warn(`This action cannot be undone!`);
+            let confirmed = yield this.$prompter.confirm("Are you sure you want to clean the selected projects?");
+            if (!confirmed) {
+                return;
+            }
+            spinner.info("Cleaning... This might take a while...");
+            let totalSizeCleaned = 0;
+            for (let i = 0; i < pathsToClean.length; i++) {
+                const currentPath = pathsToClean[i];
+                spinner.start(`Cleaning ${currentPath.cyan}... ${i + 1}/${pathsToClean.length}`);
+                const ok = yield this.$childProcess
+                    .exec(`node ${CLIPath} clean ${this.$options.dryRun ? "--dry-run" : ""} --json --disable-analytics`, {
+                    cwd: currentPath,
+                })
+                    .then((res) => {
+                    const cleanupRes = JSON.parse(res);
+                    return cleanupRes.ok;
+                })
+                    .catch((err) => {
+                    this.$logger.trace('Failed to clean project "%s"', currentPath, err);
+                    return false;
+                });
+                if (ok) {
+                    const cleanedSize = projects.get(currentPath);
+                    const cleanedSizeStr = `- ${bytesToHumanReadable(cleanedSize)}`.grey;
+                    spinner.succeed(`Cleaned ${currentPath.cyan} ${cleanedSizeStr}`);
+                    totalSizeCleaned += cleanedSize;
+                }
+                else {
+                    spinner.fail(`Failed to clean ${currentPath.cyan} - skipped`);
+                }
+            }
+            spinner.clear();
+            spinner.stop();
+            spinner.succeed(`Done! We've just freed up ${bytesToHumanReadable(totalSizeCleaned).green}! Woohoo! 🎉`);
+            if (this.$options.dryRun) {
+                spinner.info('Note: the "--dry-run" flag was used, so no files were actually deleted.');
+            }
+        });
+    }
+    getNSProjectPathsInDirectory(dir = process.cwd()) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let nsDirs = [];
+            const getFiles = (dir) => __awaiter(this, void 0, void 0, function* () {
+                if (dir.includes("node_modules")) {
+                    return;
+                }
+                const dirents = yield (0, promises_1.readdir)(dir, { withFileTypes: true }).catch((err) => {
+                    this.$logger.trace('Failed to read directory "%s". Error is:', dir, err);
+                    return [];
+                });
+                const hasNSConfig = dirents.some((ent) => ent.name.includes("nativescript.config.ts") ||
+                    ent.name.includes("nativescript.config.js"));
+                if (hasNSConfig) {
+                    nsDirs.push(dir);
+                    return;
+                }
+                yield Promise.all(dirents.map((dirent) => {
+                    const res = (0, path_1.resolve)(dir, dirent.name);
+                    if (dirent.isDirectory()) {
+                        return getFiles(res);
+                    }
+                }));
+            });
+            yield getFiles(dir);
+            return nsDirs;
+        });
+    }
 }
 exports.CleanCommand = CleanCommand;
 yok_1.injector.registerCommand("clean", CleanCommand);

package/lib/common/declarations.d.ts

@@ -338,6 +338,13 @@ interface IFileSystem {
 	 */
 	getFileSize(path: string): number;
 
+	/**
+	 * Returns the size of specified path (recurses into all sub-directories if the path is a directory).
+	 * @param {string} path Path to file or directory.
+	 * @returns {number} File size in bytes.
+	 */
+	getSize(path: string): number;
+
 	/**
 	 * Change file timestamps of the file referenced by the supplied path.
 	 * @param {string} path  File path

package/lib/common/dispatchers.js

@@ -40,7 +40,7 @@ class CommandDispatcher {
             if (this.$options.version) {
                 return this.printVersion();
             }
-            if (this.$logger.getLevel() === "TRACE") {
+            if (this.$logger.getLevel() === "TRACE" && !this.$options.json) {
                 this.$logger.trace("Collecting system information...");
                 const sysInfo = yield this.$sysInfo.getSysInfo({
                     pathToNativeScriptCliPackageJson: path.join(__dirname, "..", "..", "package.json"),

package/lib/common/file-system.js

@@ -147,6 +147,31 @@ let FileSystem = FileSystem_1 = class FileSystem {
         const stat = this.getFsStats(path);
         return stat.size;
     }
+    getSize(path) {
+        const dirSize = (dir, paths = new Map(), root = true) => {
+            const files = fs.readdirSync(dir, { withFileTypes: true });
+            files.map((file) => {
+                const path = (0, path_1.join)(dir, file.name);
+                if (file.isDirectory()) {
+                    dirSize(path, paths, false);
+                    return;
+                }
+                if (file.isFile()) {
+                    const { size } = fs.statSync(path);
+                    paths.set(path, size);
+                }
+            });
+            if (root) {
+                return Array.from(paths.values()).reduce((sum, current) => sum + current, 0);
+            }
+        };
+        try {
+            return dirSize(path);
+        }
+        catch (err) {
+            return 0;
+        }
+    }
     futureFromEvent(eventEmitter, event) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {

package/lib/common/prompter.js

@@ -84,16 +84,24 @@ class Prompter {
             return result.inputString;
         });
     }
-    promptForChoice(promptMessage, choices) {
+    promptForChoice(promptMessage, choices, multiple = false, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const schema = {
-                message: promptMessage,
-                type: "select",
-                name: "userAnswer",
-                choices,
-            };
+            const schema = Object.assign({ message: promptMessage, type: multiple ? "multiselect" : "select", name: "userAnswer", choices }, options);
             const result = yield this.get([schema]);
-            return choices[result.userAnswer];
+            const extractValue = (choice) => {
+                if (typeof choice === "object") {
+                    return choice.value || choice;
+                }
+                if (typeof choice === "string") {
+                    return choice;
+                }
+                if (typeof choice === "number") {
+                    return choices[choice];
+                }
+            };
+            return multiple
+                ? result.userAnswer.map(extractValue)
+                : extractValue(result.userAnswer);
         });
     }
     promptForDetailedChoice(promptMessage, choices) {

package/lib/common/services/commands-service.js

@@ -53,7 +53,9 @@ class CommandsService {
             this.commands.push({ commandName, commandArguments });
             const command = this.$injector.resolveCommand(commandName);
             if (command) {
-                if (!this.$staticConfig.disableAnalytics && !command.disableAnalytics) {
+                if (!this.$staticConfig.disableAnalytics &&
+                    !command.disableAnalytics &&
+                    !this.$options.disableAnalytics) {
                     const analyticsService = this.$injector.resolve("analyticsService");
                     yield analyticsService.checkConsent();
                     const beautifiedCommandName = this.beautifyCommandName(commandName).replace(/\|/g, " ");

package/lib/common/services/hooks-service.js

@@ -1,4 +1,10 @@
 "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) {
@@ -16,6 +22,7 @@ const _ = require("lodash");
 const helpers_1 = require("../helpers");
 const constants_1 = require("../../constants");
 const yok_1 = require("../yok");
+const decorators_1 = require("../decorators");
 class Hook {
     constructor(name, fullPath) {
         this.name = name;
@@ -298,6 +305,9 @@ class HooksService {
         return invalidArguments;
     }
 }
-exports.HooksService = HooksService;
 HooksService.HOOKS_DIRECTORY_NAME = "hooks";
+__decorate([
+    (0, decorators_1.cache)()
+], HooksService.prototype, "initialize", null);
+exports.HooksService = HooksService;
 yok_1.injector.register("hooksService", HooksService);

package/lib/declarations.d.ts

@@ -642,6 +642,8 @@ interface IOptions
 	skipRefresh: boolean;
 	file: string;
 	analyticsClient: string;
+	analyticsLogFile: string;
+	disableAnalytics: boolean;
 	force: boolean;
 	sdk: string;
 	template: string;
@@ -684,13 +686,13 @@ interface IOptions
 	background: string;
 	hmr: boolean;
 	link: boolean;
-	analyticsLogFile: string;
 	performance: Object;
 	cleanupLogFile: string;
 	appleApplicationSpecificPassword: string;
 	appleSessionBase64: string;
 	markingMode: boolean;
 	git: boolean;
+	dryRun: boolean;
 }
 
 interface IEnvOptions {

package/lib/definitions/project.d.ts

@@ -315,13 +315,50 @@ interface IProjectCleanupService {
 	 * Clean multiple paths
 	 * @param {string[]} pathsToClean
 	 */
-	clean(pathsToClean: string[]): Promise<boolean>;
+	clean(
+		pathsToClean: string[],
+		options?: IProjectCleanupOptions
+	): Promise<IProjectCleanupResult>;
 
 	/**
 	 * Clean a single path
 	 * @param {string} pathToClean
 	 */
-	cleanPath(pathToClean: string): Promise<boolean>;
+	cleanPath(
+		pathToClean: string,
+		options?: IProjectCleanupOptions
+	): Promise<IProjectCleanupResult>;
+}
+
+interface IProjectCleanupOptions {
+	/**
+	 * When set, the cleanup service will calculate the size of the cleaned up files.
+	 */
+	stats?: boolean;
+	/**
+	 * When set, the cleanup service will not delete any files.
+	 */
+	dryRun?: boolean;
+	/**
+	 * When set, the cleanup service will not print any messages to the console.
+	 */
+	silent?: boolean;
+}
+
+interface IProjectCleanupResult {
+	ok: boolean;
+	/**
+	 * When stats is set to true, this will contain a map of the cleaned up paths and their size.
+	 */
+	stats?: Map<string, number>;
+}
+
+interface IProjectPathCleanupResult {
+	ok: boolean;
+	/**
+	 * When stats is set to true, this will contain the size of the cleaned path in bytes.
+	 */
+	size?: number;
 }
 
 interface IBackup {

package/lib/definitions/prompter.d.ts

@@ -10,7 +10,14 @@ declare global {
 		get(schemas: IPrompterQuestion[]): Promise<any>;
 		getPassword(prompt: string, options?: IAllowEmpty): Promise<string>;
 		getString(prompt: string, options?: IPrompterOptions): Promise<string>;
-		promptForChoice(promptMessage: string, choices: string[]): Promise<string>;
+		promptForChoice(
+			promptMessage: string,
+			choices:
+				| string[]
+				| { title: string; description?: string; value?: string }[],
+			multiple: boolean = false,
+			options: any = {}
+		): Promise<string>;
 		promptForDetailedChoice(
 			promptMessage: string,
 			choices: { key: string; description: string }[]

package/lib/definitions/terminal-spinner-service.d.ts

@@ -1,3 +1,8 @@
+import type { Options, Ora } from "ora";
+
+type ITerminalSpinnerOptions = Options;
+type ITerminalSpinner = Ora;
+
 interface ITerminalSpinnerService {
 	createSpinner(spinnerOptions?: ITerminalSpinnerOptions): ITerminalSpinner;
 	execute<T>(
@@ -5,105 +10,3 @@ interface ITerminalSpinnerService {
 		action: () => Promise<T>
 	): Promise<T>;
 }
-
-type SpinnerName =
-	| "dots"
-	| "dots2"
-	| "dots3"
-	| "dots4"
-	| "dots5"
-	| "dots6"
-	| "dots7"
-	| "dots8"
-	| "dots9"
-	| "dots10"
-	| "dots11"
-	| "dots12"
-	| "line"
-	| "line2"
-	| "pipe"
-	| "simpleDots"
-	| "simpleDotsScrolling"
-	| "star"
-	| "star2"
-	| "flip"
-	| "hamburger"
-	| "growVertical"
-	| "growHorizontal"
-	| "balloon"
-	| "balloon2"
-	| "noise"
-	| "bounce"
-	| "boxBounce"
-	| "boxBounce2"
-	| "triangle"
-	| "arc"
-	| "circle"
-	| "squareCorners"
-	| "circleQuarters"
-	| "circleHalves"
-	| "squish"
-	| "toggle"
-	| "toggle2"
-	| "toggle3"
-	| "toggle4"
-	| "toggle5"
-	| "toggle6"
-	| "toggle7"
-	| "toggle8"
-	| "toggle9"
-	| "toggle10"
-	| "toggle11"
-	| "toggle12"
-	| "toggle13"
-	| "arrow"
-	| "arrow2"
-	| "arrow3"
-	| "bouncingBar"
-	| "bouncingBall"
-	| "smiley"
-	| "monkey"
-	| "hearts"
-	| "clock"
-	| "earth"
-	| "moon"
-	| "runner"
-	| "pong"
-	| "shark"
-	| "dqpb";
-
-interface Spinner {
-	interval?: number;
-	frames: string[];
-}
-
-interface ITerminalSpinner {
-	text: string;
-	start(text?: string): ITerminalSpinner;
-	stop(): ITerminalSpinner;
-	succeed(text?: string): ITerminalSpinner;
-	fail(text?: string): ITerminalSpinner;
-	warn(text?: string): ITerminalSpinner;
-	info(text?: string): ITerminalSpinner;
-	clear(): ITerminalSpinner;
-	render(): ITerminalSpinner;
-	frame(): ITerminalSpinner;
-}
-
-interface ITerminalSpinnerOptions {
-	text?: string;
-	spinner?: SpinnerName | Spinner;
-	color?:
-		| "black"
-		| "red"
-		| "green"
-		| "yellow"
-		| "blue"
-		| "magenta"
-		| "cyan"
-		| "white"
-		| "gray";
-	interval?: number;
-	stream?: NodeJS.WritableStream;
-	enabled?: boolean;
-}

package/lib/options.js

@@ -177,6 +177,7 @@ class Options {
             default: { type: "boolean", hasSensitiveValue: false },
             count: { type: "number", hasSensitiveValue: false },
             analyticsLogFile: { type: "string", hasSensitiveValue: true },
+            disableAnalytics: { type: "boolean", hasSensitiveValue: false },
             cleanupLogFile: { type: "string", hasSensitiveValue: true },
             hooks: {
                 type: "boolean",
@@ -205,6 +206,7 @@ class Options {
                 hasSensitiveValue: false,
                 default: true,
             },
+            dryRun: { type: "boolean", hasSensitiveValue: false },
         };
     }
     get optionNames() {

package/lib/services/initialize-service.js

@@ -22,11 +22,11 @@ class InitializeService {
         return __awaiter(this, void 0, void 0, function* () {
             initOpts = initOpts || {};
             const $logger = this.$injector.resolve("logger");
+            const $options = this.$injector.resolve("options");
             if (initOpts.loggerOptions) {
                 $logger.initialize(initOpts.loggerOptions);
             }
             else {
-                const $options = this.$injector.resolve("options");
                 const loggerLevel = $options.log &&
                     constants_1.LoggerLevel[$options.log.toUpperCase()];
                 $logger.initializeCliLogger({ level: loggerLevel });
@@ -42,7 +42,12 @@ class InitializeService {
                         initOpts.extensibilityOptions.pathToExtensions;
                 }
             }
-            yield this.showWarnings($logger);
+            if ($options.json) {
+                $logger.trace("Skipping system warnings for --json commands");
+            }
+            else {
+                yield this.showWarnings($logger);
+            }
         });
     }
     showWarnings($logger) {

package/lib/services/project-cleanup-service.js

@@ -19,58 +19,81 @@ class ProjectCleanupService {
         this.$projectHelper = $projectHelper;
         this.$terminalSpinnerService = $terminalSpinnerService;
     }
-    clean(pathsToClean) {
+    clean(pathsToClean, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.spinner = this.$terminalSpinnerService.createSpinner();
+            this.spinner = this.$terminalSpinnerService.createSpinner({
+                isSilent: options.silent,
+            });
+            let stats = options.stats ? new Map() : false;
             let success = true;
             for (const pathToClean of pathsToClean) {
-                const isCleaned = yield this.cleanPath(pathToClean).catch((error) => {
+                const cleanRes = yield this.cleanPath(pathToClean, options).catch((error) => {
                     this.$logger.trace(`Encountered error while cleaning. Error is: ${error.message}.`, error);
-                    return false;
+                    return { ok: false };
                 });
-                success = success && isCleaned;
+                if (stats && "size" in cleanRes) {
+                    stats.set(pathToClean, cleanRes.size);
+                }
+                success = success && cleanRes.ok;
+            }
+            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+                console.log();
             }
-            console.log();
-            return success;
+            if (stats) {
+                return { ok: success, stats };
+            }
+            return { ok: success };
         });
     }
-    cleanPath(pathToClean) {
+    cleanPath(pathToClean, options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const dryRun = (_a = options === null || options === void 0 ? void 0 : options.dryRun) !== null && _a !== void 0 ? _a : false;
+            const logPrefix = dryRun ? "(dry run) ".grey : "";
             this.spinner.clear();
-            let success = true;
             let fileType;
             if (!pathToClean || pathToClean.trim().length === 0) {
-                this.$logger.trace("cleanPath called with no pathToClean.");
-                return success;
+                this.$logger.trace(`${logPrefix}cleanPath called with no pathToClean.`);
+                return { ok: true };
             }
             const filePath = path.resolve(this.$projectHelper.projectDir, pathToClean);
             const displayPath = `${path.relative(this.$projectHelper.projectDir, filePath)}`.yellow;
-            this.$logger.trace(`Trying to clean '${filePath}'`);
+            this.$logger.trace(`${logPrefix}Trying to clean '${filePath}'`);
             if (this.$fs.exists(filePath)) {
                 const stat = this.$fs.getFsStats(filePath);
+                let size = 0;
+                if (options === null || options === void 0 ? void 0 : options.stats) {
+                    size = this.$fs.getSize(filePath);
+                }
                 if (stat.isDirectory()) {
-                    this.$logger.trace(`Path '${filePath}' is a directory, deleting.`);
-                    this.$fs.deleteDirectorySafe(filePath);
+                    this.$logger.trace(`${logPrefix}Path '${filePath}' is a directory, deleting.`);
+                    !dryRun && this.$fs.deleteDirectorySafe(filePath);
                     fileType = "directory";
                 }
                 else {
-                    this.$logger.trace(`Path '${filePath}' is a file, deleting.`);
-                    this.$fs.deleteFile(filePath);
+                    this.$logger.trace(`${logPrefix}Path '${filePath}' is a file, deleting.`);
+                    !dryRun && this.$fs.deleteFile(filePath);
                     fileType = "file";
                 }
-                success = !this.$fs.exists(filePath);
+                const success = dryRun || !this.$fs.exists(filePath);
                 if (success) {
-                    this.spinner.succeed(`Cleaned ${fileType} ${displayPath}`);
+                    this.spinner.succeed(`${logPrefix}Cleaned ${fileType} ${displayPath}`);
                 }
                 else {
                     const message = `Failed to Clean ${fileType}`.red;
-                    this.spinner.fail(`${message} ${displayPath}`);
+                    this.spinner.fail(`${logPrefix}${message} ${displayPath}`);
+                }
+                if (options === null || options === void 0 ? void 0 : options.stats) {
+                    return { ok: success, size };
                 }
-                return success;
+                return { ok: success };
+            }
+            this.$logger.trace(`${logPrefix}Path '${filePath}' not found, skipping.`);
+            this.spinner.info(`${logPrefix}Skipping ${displayPath} because it doesn't exist.`);
+            if (options === null || options === void 0 ? void 0 : options.stats) {
+                return { ok: true, size: 0 };
             }
-            this.$logger.trace(`Path '${filePath}' not found, skipping.`);
-            this.spinner.info(`Skipping ${displayPath} because it doesn't exist.`);
-            return success;
+            return { ok: true };
         });
     }
 }

package/lib/services/terminal-spinner-service.js

@@ -15,7 +15,7 @@ const yok_1 = require("../common/yok");
 class TerminalSpinnerService {
     createSpinner(spinnerOptions = {}) {
         spinnerOptions.stream = spinnerOptions.stream || process.stdout;
-        return new ora(spinnerOptions);
+        return ora(spinnerOptions);
     }
     execute(spinnerOptions, action) {
         return __awaiter(this, void 0, void 0, function* () {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nativescript",
   "preferGlobal": true,
-  "version": "8.5.1",
+  "version": "8.5.2",
   "author": "NativeScript <support@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {
@@ -65,7 +65,7 @@
     "byline": "5.0.0",
     "chalk": "4.1.0",
     "chokidar": "3.5.1",
-    "cli-table": "https://github.com/telerik/cli-table/tarball/v0.3.1.2",
+    "cli-table": "https://github.com/telerik-boneyard/cli-table/tarball/v0.3.1.2",
     "color": "3.1.2",
     "colors": "1.4.0",
     "convert-source-map": "1.7.0",
@@ -90,7 +90,7 @@
     "nativescript-dev-xcode": "0.2.1",
     "nativescript-preview-sdk": "0.4.2",
     "open": "7.1.0",
-    "ora": "5.0.0",
+    "ora": "5.4.1",
     "osenv": "0.1.5",
     "pacote": "11.1.11",
     "pako": "1.0.11",
@@ -98,7 +98,7 @@
     "plist": "3.0.1",
     "plist-merge-patch": "0.1.1",
     "prettier": "2.1.1",
-    "prompts": "2.4.0",
+    "prompts": "2.4.2",
     "proper-lockfile": "4.1.1",
     "proxy-lib": "0.4.0",
     "qr-image": "3.2.0",
@@ -137,10 +137,9 @@
     "@types/lodash": "4.14.158",
     "@types/minimatch": "^3.0.3",
     "@types/node": "14.0.27",
-    "@types/ora": "3.2.0",
     "@types/pacote": "^11.1.0",
     "@types/prettier": "2.1.0",
-    "@types/prompts": "2.0.9",
+    "@types/prompts": "2.4.2",
     "@types/proper-lockfile": "4.1.1",
     "@types/qr-image": "3.2.3",
     "@types/retry": "0.12.0",