nativescript 8.6.0-vision.4 → 8.6.0-vision.6

package/lib/common/yok.js

@@ -41,6 +41,7 @@ class Yok {
     constructor() {
         this.overrideAlreadyRequiredModule = false;
         this.COMMANDS_NAMESPACE = "commands";
+        this.KEY_COMMANDS_NAMESPACE = "keyCommands";
         this.modules = {};
         this.resolutionProgress = {};
         this.hierarchicalCommands = {};
@@ -78,6 +79,9 @@ class Yok {
     require(names, file) {
         forEachName(names, (name) => this.requireOne(name, file));
     }
+    requireKeyCommand(name, file) {
+        this.requireOne(this.createKeyCommandName(name), file);
+    }
     requirePublic(names, file) {
         forEachName(names, (name) => {
             this.requireOne(name, file);
@@ -136,6 +140,9 @@ class Yok {
             }
         });
     }
+    registerKeyCommand(name, resolver) {
+        this.register(this.createKeyCommandName(name), resolver);
+    }
     getDefaultCommand(name, commandArguments) {
         const subCommands = this.hierarchicalCommands[name];
         const defaultCommand = _.find(subCommands, (command) => _.some(command.split("|"), (c) => _.startsWith(c, "*")));
@@ -270,6 +277,15 @@ class Yok {
         command = this.resolve(commandModuleName);
         return command;
     }
+    resolveKeyCommand(name) {
+        let command;
+        const commandModuleName = this.createKeyCommandName(name);
+        if (!this.modules[commandModuleName]) {
+            return null;
+        }
+        command = this.resolve(commandModuleName);
+        return command;
+    }
     resolve(param, ctorArguments) {
         if (_.isFunction(param)) {
             return this.resolveConstructor(param, ctorArguments);
@@ -372,12 +388,21 @@ class Yok {
         }
         return commands;
     }
+    getRegisteredKeyCommandsNames() {
+        const modulesNames = _.keys(this.modules);
+        const commandsNames = _.filter(modulesNames, (moduleName) => _.startsWith(moduleName, `${this.KEY_COMMANDS_NAMESPACE}.`));
+        let commands = _.map(commandsNames, (commandName) => commandName.substr(this.KEY_COMMANDS_NAMESPACE.length + 1));
+        return commands;
+    }
     getChildrenCommandsNames(commandName) {
         return this.hierarchicalCommands[commandName];
     }
     createCommandName(name) {
         return `${this.COMMANDS_NAMESPACE}.${name}`;
     }
+    createKeyCommandName(name) {
+        return `${this.KEY_COMMANDS_NAMESPACE}.${name}`;
+    }
     dispose() {
         Object.keys(this.modules).forEach((moduleName) => {
             const instances = this.modules[moduleName].instances;

package/lib/config.js

@@ -51,6 +51,7 @@ class StaticConfig {
         this.ANALYTICS_INSTALLATION_ID_SETTING_NAME = "AnalyticsInstallationID";
         this.RESOURCE_DIR_PATH = path.join(__dirname, "..", "resources");
         this.version = require("../package.json").version;
+        this.cliBinPath = path.resolve(__dirname, "..", "bin", "nativescript.js");
         this._adbFilePath = null;
         this._userAgent = null;
     }

package/lib/controllers/migrate-controller.js

@@ -112,7 +112,7 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
             {
                 packageName: "@nativescript/angular",
                 minVersion: "10.0.0",
-                desiredVersion: "~15.2.0",
+                desiredVersion: "^16.0.0",
                 shouldMigrateAction(dependency, projectData, loose) {
                     return __awaiter(this, void 0, void 0, function* () {
                         if (!this.hasDependency(dependency, projectData)) {
@@ -451,7 +451,7 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
                 constants.NODE_MODULES_FOLDER_NAME,
                 constants.PACKAGE_LOCK_JSON_FILE_NAME,
             ]);
-            const { dependencies, devDependencies, } = yield this.$pluginsService.getDependenciesFromPackageJson(projectData.projectDir);
+            const { dependencies, devDependencies } = yield this.$pluginsService.getDependenciesFromPackageJson(projectData.projectDir);
             const hasSchematics = [...dependencies, ...devDependencies].find((p) => p.name === "@nativescript/schematics");
             if (!hasSchematics) {
                 yield this.$projectCleanupService.clean([
@@ -781,7 +781,7 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
     migrateNativeScriptAngular() {
         return __awaiter(this, void 0, void 0, function* () {
             const minVersion = "10.0.0";
-            const desiredVersion = "~15.2.0";
+            const desiredVersion = "~16.2.0";
             const dependencies = [
                 {
                     packageName: "@angular/animations",
@@ -834,13 +834,13 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
                 {
                     packageName: "rxjs",
                     minVersion: "6.6.0",
-                    desiredVersion: "~7.6.0",
+                    desiredVersion: "~7.8.0",
                     shouldAddIfMissing: true,
                 },
                 {
                     packageName: "zone.js",
                     minVersion: "0.11.1",
-                    desiredVersion: "~0.13.0",
+                    desiredVersion: "~0.14.0",
                     shouldAddIfMissing: true,
                 },
                 {

package/lib/controllers/prepare-controller.js

@@ -17,13 +17,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrepareController = void 0;
 const choki = require("chokidar");
-const helpers_1 = require("../common/helpers");
-const decorators_1 = require("../common/decorators");
 const events_1 = require("events");
+const _ = require("lodash");
 const path = require("path");
-const constants_1 = require("../constants");
+const decorators_1 = require("../common/decorators");
+const helpers_1 = require("../common/helpers");
 const yok_1 = require("../common/yok");
-const _ = require("lodash");
+const constants_1 = require("../constants");
 class PrepareController extends events_1.EventEmitter {
     constructor($platformController, $hooksService, $fs, $logger, $mobileHelper, $nodeModulesDependenciesBuilder, $platformsDataService, $pluginsService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $webpackCompilerService, $watchIgnoreListService, $analyticsService, $markingModeService, $projectConfigService, $projectService) {
         super();
@@ -48,6 +48,7 @@ class PrepareController extends events_1.EventEmitter {
         this.isInitialPrepareReady = false;
         this.persistedData = [];
         this.webpackCompilerHandler = null;
+        this.pausedFileWatch = false;
     }
     prepare(prepareData) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -123,6 +124,11 @@ class PrepareController extends events_1.EventEmitter {
                 this.watchersData[projectData.projectDir][platformData.platformNameLowerCase] = {
                     nativeFilesWatcher: null,
                     hasWebpackCompilerProcess: false,
+                    prepareArguments: {
+                        platformData,
+                        projectData,
+                        prepareData,
+                    },
                 };
             }
             yield this.startJSWatcherWithPrepare(platformData, projectData, prepareData);
@@ -154,6 +160,8 @@ class PrepareController extends events_1.EventEmitter {
             if (!this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].hasWebpackCompilerProcess) {
                 const handler = (data) => {
                     if (data.platform.toLowerCase() === platformData.platformNameLowerCase) {
+                        if (this.isFileWatcherPaused())
+                            return;
                         this.emitPrepareEvent(Object.assign(Object.assign({}, data), { hasNativeChanges: false }));
                     }
                 };
@@ -196,6 +204,8 @@ class PrepareController extends events_1.EventEmitter {
             const watcher = choki
                 .watch(patterns, watcherOptions)
                 .on("all", (event, filePath) => __awaiter(this, void 0, void 0, function* () {
+                if (this.isFileWatcherPaused())
+                    return;
                 filePath = path.join(projectData.projectDir, filePath);
                 if (this.$watchIgnoreListService.isFileInIgnoreList(filePath)) {
                     this.$watchIgnoreListService.removeFileFromIgnoreList(filePath);
@@ -297,6 +307,33 @@ class PrepareController extends events_1.EventEmitter {
             });
         });
     }
+    isFileWatcherPaused() {
+        return this.pausedFileWatch;
+    }
+    toggleFileWatcher() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pausedFileWatch = !this.pausedFileWatch;
+            const watchers = Object.values(this.watchersData);
+            if (this.pausedFileWatch) {
+                for (const watcher of watchers) {
+                    for (const platform in watcher) {
+                        yield this.$webpackCompilerService.stopWebpackCompiler(platform);
+                        watcher[platform].hasWebpackCompilerProcess = false;
+                    }
+                }
+            }
+            else {
+                for (const watcher of watchers) {
+                    for (const platform in watcher) {
+                        const args = watcher[platform].prepareArguments;
+                        watcher[platform].hasWebpackCompilerProcess = true;
+                        yield this.$webpackCompilerService.compileWithWatch(args.platformData, args.projectData, args.prepareData);
+                    }
+                }
+            }
+            return this.pausedFileWatch;
+        });
+    }
 }
 __decorate([
     (0, decorators_1.performanceLog)(),

package/lib/controllers/run-controller.js

@@ -136,8 +136,12 @@ class RunController extends events_1.EventEmitter {
                     this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceStopped, {
                         projectDir,
                         deviceIdentifier,
+                        keepProcessAlive: stopOptions === null || stopOptions === void 0 ? void 0 : stopOptions.keepProcessAlive,
                     });
                 });
+                if (stopOptions === null || stopOptions === void 0 ? void 0 : stopOptions.keepProcessAlive) {
+                    this.removeAllListeners(constants_2.RunOnDeviceEvents.runOnDeviceStopped);
+                }
             }
         });
     }
@@ -298,6 +302,7 @@ class RunController extends events_1.EventEmitter {
                     }
                     else {
                         const shouldBuild = prepareResultData.hasNativeChanges ||
+                            buildData.nativePrepare.forceRebuildNativeApp ||
                             (yield this.$buildController.shouldBuild(buildData));
                         if (shouldBuild) {
                             packageFilePath = yield deviceDescriptor.buildAction();

package/lib/definitions/livesync.d.ts

@@ -141,6 +141,7 @@ declare global {
 		error?: Error;
 		notification?: string;
 		isFullSync?: boolean;
+		keepProcessAlive?: boolean;
 	}
 
 	interface IIsEmulator {
@@ -577,6 +578,8 @@ declare global {
 		): Promise<ILiveSyncDeviceDescriptor[]>;
 		getDeviceInstances(platform?: string): Promise<Mobile.IDevice[]>;
 		getLiveSyncData(projectDir: string): ILiveSyncInfo;
+
+		stop(): Promise<void>;
 	}
 
 	interface ILiveSyncServiceResolver {

package/lib/definitions/prepare.d.ts

@@ -10,6 +10,7 @@ declare global {
 		env: any;
 		watch?: boolean;
 		watchNative: boolean;
+		watchNodeModules?: boolean;
 	}
 
 	interface IiOSCodeSigningData {
@@ -31,6 +32,8 @@ declare global {
 	interface IPrepareController extends EventEmitter {
 		prepare(prepareData: IPrepareData): Promise<IPrepareResultData>;
 		stopWatchers(projectDir: string, platform: string): Promise<void>;
+		toggleFileWatcher: () => Promise<boolean>;
+		// toggleWatchNodeModules: () => Promise<boolean>;
 	}
 
 	interface IPrepareResultData {

package/lib/definitions/project.d.ts

@@ -550,6 +550,8 @@ interface IiCloudContainerEnvironment {
 
 interface INativePrepare {
 	skipNativePrepare: boolean;
+	forceRebuildNativeApp?: boolean;
+	restartLiveSync?: boolean;
 }
 
 interface IBuildConfig

package/lib/definitions/run.d.ts

@@ -14,7 +14,10 @@ declare global {
 	interface IStopRunData {
 		projectDir: string;
 		deviceIdentifiers?: string[];
-		stopOptions?: { shouldAwaitAllActions: boolean };
+		stopOptions?: {
+			shouldAwaitAllActions: boolean;
+			keepProcessAlive?: boolean;
+		};
 	}
 
 	interface IRunController extends EventEmitter {

package/lib/definitions/start-service.d.ts

@@ -0,0 +1,13 @@
+import { ChildProcess } from "child_process";
+
+export interface IStartService {
+	ios: ChildProcess;
+	android: ChildProcess;
+	start(): void;
+	toggleVerbose(): void;
+
+	runIOS(): Promise<void>;
+	runAndroid(): Promise<void>;
+	stopIOS(): Promise<void>;
+	stopAndroid(): Promise<void>;
+}

package/lib/helpers/key-command-helper.js

@@ -0,0 +1,119 @@
+"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 });
+const color_1 = require("../color");
+const yok_1 = require("../common/yok");
+class KeyCommandHelper {
+    constructor() {
+        this.platform = "all";
+        this.overrides = {};
+        this.onKeyPressed = (data) => __awaiter(this, void 0, void 0, function* () {
+            const key = data.toString();
+            if (this.keyCommandExecutionBlocked && key !== "\u0003")
+                return;
+            try {
+                const exists = yok_1.injector.getRegisteredKeyCommandsNames().includes(key);
+                if (exists) {
+                    const keyCommand = yok_1.injector.resolveKeyCommand(key);
+                    if (keyCommand.platform === "all" ||
+                        keyCommand.platform === this.platform ||
+                        this.platform === "all") {
+                        if (keyCommand.canExecute &&
+                            !keyCommand.canExecute(this.processType)) {
+                            console.log("blocked execution");
+                            return;
+                        }
+                        if (keyCommand.willBlockKeyCommandExecution)
+                            this.keyCommandExecutionBlocked = true;
+                        if (this.overrides[key]) {
+                            if (!(yield this.overrides[key]())) {
+                                this.keyCommandExecutionBlocked = false;
+                                process.stdin.resume();
+                                return;
+                            }
+                        }
+                        if (keyCommand.key !== "\u0003") {
+                            const line = ` ${color_1.color.dim("→")} ${color_1.color.bold(keyCommand.key)} — ${keyCommand.description}`;
+                            const lineLength = (0, color_1.stripColors)(line).length - 1;
+                            console.log(color_1.color.dim(` ┌${"─".repeat(lineLength)}┐`));
+                            console.log(line + color_1.color.dim(" │"));
+                            console.log(color_1.color.dim(` └${"─".repeat(lineLength)}┘`));
+                            console.log("");
+                        }
+                        const result = yield keyCommand.execute(this.platform);
+                        this.keyCommandExecutionBlocked = false;
+                        if (process.stdin.setRawMode) {
+                            process.stdin.resume();
+                        }
+                        return result;
+                    }
+                }
+                process.stdout.write(key);
+            }
+            catch (e) {
+                const $logger = yok_1.injector.resolve("logger");
+                $logger.error(e.message);
+            }
+        });
+    }
+    addOverride(key, execute) {
+        this.overrides[key] = execute;
+    }
+    removeOverride(key) {
+        this.overrides[key] = undefined;
+    }
+    printCommands(platform) {
+        const commands = yok_1.injector.getRegisteredKeyCommandsNames();
+        const commandHelp = commands.reduce((arr, key) => {
+            const command = yok_1.injector.resolveKeyCommand(key);
+            if (!command.description ||
+                (command.platform !== "all" &&
+                    command.platform !== platform &&
+                    platform !== "all") ||
+                (command.canExecute && !command.canExecute(this.processType))) {
+                return arr;
+            }
+            else {
+                arr.push(`   ${color_1.color.bold(command.key)} — ${command.description}`);
+                return arr;
+            }
+        }, []);
+        console.info([
+            "",
+            `  The CLI is ${color_1.color.underline(`interactive`)}, you can press the following keys any time (make sure the terminal has focus).`,
+            "",
+            ...commandHelp,
+            "",
+        ].join("\n"));
+    }
+    attachKeyCommands(platform, processType) {
+        this.processType = processType;
+        this.platform = platform;
+        const stdin = process.stdin;
+        if (!stdin.setRawMode) {
+            process.on("message", (key) => {
+                this.onKeyPressed(Buffer.from(key));
+            });
+        }
+        else {
+            stdin.setRawMode(false);
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.on("data", this.onKeyPressed);
+        }
+    }
+    detachKeyCommands() {
+        process.stdin.off("data", this.onKeyPressed);
+        process.stdin.setRawMode(false);
+    }
+}
+exports.default = KeyCommandHelper;
+yok_1.injector.register("keyCommandHelper", KeyCommandHelper);

package/lib/helpers/livesync-command-helper.js

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveSyncCommandHelper = void 0;
-const constants_1 = require("../constants");
-const yok_1 = require("../common/yok");
 const _ = require("lodash");
+const yok_1 = require("../common/yok");
+const constants_1 = require("../constants");
 class LiveSyncCommandHelper {
     constructor($androidBundleValidatorHelper, $buildDataService, $projectData, $options, $deployController, $iosDeviceOperations, $mobileHelper, $devicesService, $injector, $buildController, $analyticsService, $errors, $iOSSimulatorLogProvider, $cleanupService, $runController) {
         this.$androidBundleValidatorHelper = $androidBundleValidatorHelper;
@@ -66,25 +66,27 @@ class LiveSyncCommandHelper {
     }
     createDeviceDescriptors(devices, platform, additionalOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const deviceDescriptors = devices.map((device) => {
+            const deviceDescriptors = devices.map((d) => {
                 const outputPath = additionalOptions &&
                     additionalOptions.getOutputDirectory &&
                     additionalOptions.getOutputDirectory({
-                        platform: device.deviceInfo.platform,
-                        emulator: device.isEmulator,
+                        platform: d.deviceInfo.platform,
+                        emulator: d.isEmulator,
                         projectDir: this.$projectData.projectDir,
                     });
-                const buildData = this.$buildDataService.getBuildData(this.$projectData.projectDir, device.deviceInfo.platform, Object.assign(Object.assign({}, this.$options.argv), { outputPath, buildForDevice: !device.isEmulator, watch: !this.$options.release && this.$options.watch, _device: device }));
-                this.$androidBundleValidatorHelper.validateDeviceApiLevel(device, buildData);
+                const buildData = this.$buildDataService.getBuildData(this.$projectData.projectDir, d.deviceInfo.platform, Object.assign(Object.assign({}, this.$options.argv), { outputPath, buildForDevice: !d.isEmulator, watch: !this.$options.release && this.$options.watch, nativePrepare: {
+                        forceRebuildNativeApp: additionalOptions.forceRebuildNativeApp,
+                    } }));
+                this.$androidBundleValidatorHelper.validateDeviceApiLevel(d, buildData);
                 const buildAction = additionalOptions && additionalOptions.buildPlatform
-                    ? additionalOptions.buildPlatform.bind(additionalOptions.buildPlatform, device.deviceInfo.platform, buildData, this.$projectData)
+                    ? additionalOptions.buildPlatform.bind(additionalOptions.buildPlatform, d.deviceInfo.platform, buildData, this.$projectData)
                     : this.$buildController.build.bind(this.$buildController, buildData);
                 const info = {
-                    identifier: device.deviceInfo.identifier,
+                    identifier: d.deviceInfo.identifier,
                     buildAction,
                     debuggingEnabled: additionalOptions &&
                         additionalOptions.deviceDebugMap &&
-                        additionalOptions.deviceDebugMap[device.deviceInfo.identifier],
+                        additionalOptions.deviceDebugMap[d.deviceInfo.identifier],
                     debugOptions: this.$options,
                     skipNativePrepare: additionalOptions && additionalOptions.skipNativePrepare,
                     buildData,
@@ -113,17 +115,33 @@ class LiveSyncCommandHelper {
                 yield this.runInRelease(platform, deviceDescriptors);
                 return;
             }
-            yield this.$runController.run({
-                liveSyncInfo,
-                deviceDescriptors,
-            });
-            const remainingDevicesToSync = devices.map((d) => d.deviceInfo.identifier);
-            this.$runController.on(constants_1.RunOnDeviceEvents.runOnDeviceStopped, (data) => {
+            if (additionalOptions.restartLiveSync) {
+                yield this.$runController.stop({
+                    projectDir: this.$projectData.projectDir,
+                    deviceIdentifiers: deviceDescriptors.map((device) => device.identifier),
+                    stopOptions: {
+                        shouldAwaitAllActions: true,
+                        keepProcessAlive: true,
+                    },
+                });
+                const devices = yield this.getDeviceInstances(platform);
+                yield this.executeLiveSyncOperation(devices, platform, Object.assign(Object.assign({}, additionalOptions), { restartLiveSync: false }));
+                return;
+            }
+            else {
+                yield this.$runController.run({
+                    liveSyncInfo,
+                    deviceDescriptors,
+                });
+            }
+            this.$runController.on(constants_1.RunOnDeviceEvents.runOnDeviceStopped, (data) => __awaiter(this, void 0, void 0, function* () {
+                const devices = yield this.getDeviceInstances(platform);
+                const remainingDevicesToSync = devices.map((d) => d.deviceInfo.identifier);
                 _.remove(remainingDevicesToSync, (d) => d === data.deviceIdentifier);
-                if (remainingDevicesToSync.length === 0) {
+                if (remainingDevicesToSync.length === 0 && !data.keepProcessAlive) {
                     process.exit(134);
                 }
-            });
+            }));
         });
     }
     validatePlatform(platform) {
@@ -184,6 +202,19 @@ class LiveSyncCommandHelper {
             }
         });
     }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.getDeviceInstances();
+            return this.$runController.stop({
+                projectDir: this.$projectData.projectDir,
+                deviceIdentifiers: devices.map((d) => d.deviceInfo.identifier),
+                stopOptions: {
+                    shouldAwaitAllActions: true,
+                    keepProcessAlive: true,
+                },
+            });
+        });
+    }
 }
 exports.LiveSyncCommandHelper = LiveSyncCommandHelper;
 yok_1.injector.register("liveSyncCommandHelper", LiveSyncCommandHelper);

package/lib/key-commands/bootstrap.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const yok_1 = require("../common/yok");
+const path = "./key-commands/index";
+yok_1.injector.requireKeyCommand("a", path);
+yok_1.injector.requireKeyCommand("i", path);
+yok_1.injector.requireKeyCommand("A", path);
+yok_1.injector.requireKeyCommand("I", path);
+yok_1.injector.requireKeyCommand("r", path);
+yok_1.injector.requireKeyCommand("R", path);
+yok_1.injector.requireKeyCommand("w", path);
+yok_1.injector.requireKeyCommand("c", path);
+yok_1.injector.requireKeyCommand("n", path);
+yok_1.injector.requireKeyCommand("?", path);
+yok_1.injector.requireKeyCommand("\u0003", path);