nativescript 8.1.4 → 8.1.5

package/config/test-dependencies.json

@@ -1,13 +1,15 @@
 [
+    {
+        "name": "@jsdevtools/coverage-istanbul-loader"
+    },
     {
         "name": "karma"
     },
     {
-        "name": "karma-nativescript-launcher"
+        "name": "karma-coverage"
     },
     {
-        "name": "karma-webpack",
-        "excludedPeerDependencies": ["webpack"]
+        "name": "karma-nativescript-launcher"
     },
     {
         "name": "mocha",
@@ -48,5 +50,8 @@
         "name": "@types/qunit",
         "framework": "qunit",
         "projectType": ".ts"
+    },
+    {
+        "name": "nyc"
     }
 ]

package/config/test-deps-versions-generated.json

@@ -1 +1 @@
-{"karma":"6.3.4","karma-nativescript-launcher":"0.4.0","karma-webpack":"5.0.0","mocha":"9.1.2","karma-mocha":"2.0.1","karma-chai":"0.1.0","karma-jasmine":"4.0.1","karma-qunit":"4.1.2","@types/karma-chai":"0.1.2","@types/mocha":"9.0.0","@types/jasmine":"3.9.1","@types/qunit":"2.11.2"}
+{"@jsdevtools/coverage-istanbul-loader":"3.0.5","karma":"6.3.9","karma-coverage":"2.0.3","karma-nativescript-launcher":"0.4.0","mocha":"9.1.3","karma-mocha":"2.0.1","karma-chai":"0.1.0","karma-jasmine":"4.0.1","karma-qunit":"4.1.2","@types/karma-chai":"0.1.2","@types/mocha":"9.0.0","@types/jasmine":"3.10.2","@types/qunit":"2.11.2","nyc":"15.1.0"}

package/lib/.d.ts

@@ -217,6 +217,7 @@
 /// <reference path="common/test/unit-tests/project-files-provider-base.ts" />
 /// <reference path="common/test/unit-tests/services/files-hash-service.ts" />
 /// <reference path="common/test/unit-tests/services/help-service.ts" />
+/// <reference path="common/test/unit-tests/services/hook-service.ts" />
 /// <reference path="common/test/unit-tests/services/json-file-settings-service.ts" />
 /// <reference path="common/test/unit-tests/services/net-service.ts" />
 /// <reference path="common/test/unit-tests/services/settings-service.ts" />

package/lib/commands/clean.js

@@ -37,8 +37,13 @@ class CleanCommand {
             }
             catch (err) {
             }
-            yield this.$projectCleanupService.clean(pathsToClean);
-            spinner.succeed("Project successfully cleaned.");
+            const success = yield this.$projectCleanupService.clean(pathsToClean);
+            if (success) {
+                spinner.succeed("Project successfully cleaned.");
+            }
+            else {
+                spinner.fail(`${"Project unsuccessfully cleaned.".red}`);
+            }
         });
     }
 }

package/lib/commands/test-init.js

@@ -91,12 +91,19 @@ class TestInitCommand {
                 }
             }
             yield this.$pluginsService.add("@nativescript/unit-test-runner", this.$projectData);
+            this.$logger.clearScreen();
+            const bufferedLogs = [];
             const testsDir = path.join(this.$projectData.appDirectoryPath, "tests");
             const projectTestsDir = path.relative(this.$projectData.projectDir, testsDir);
             const relativeTestsDir = path.relative(this.$projectData.appDirectoryPath, testsDir);
             let shouldCreateSampleTests = true;
             if (this.$fs.exists(testsDir)) {
-                this.$logger.info(`${projectTestsDir} directory already exists, will not create an example test project.`);
+                const specFilenamePattern = `<filename>.spec${projectFilesExtension}`;
+                bufferedLogs.push([
+                    `Note: The "${projectTestsDir}" directory already exists, will not create example tests in the project.`,
+                    `You may create "${specFilenamePattern}" files anywhere you'd like.`,
+                    "",
+                ].join("\n").yellow);
                 shouldCreateSampleTests = false;
             }
             this.$fs.ensureDirectoryExists(testsDir);
@@ -113,14 +120,48 @@ class TestInitCommand {
             });
             this.$fs.writeFile(path.join(projectDir, "karma.conf.js"), karmaConf);
             const exampleFilePath = this.$resources.resolvePath(`test/example.${frameworkToInstall}${projectFilesExtension}`);
+            const targetExampleTestPath = path.join(testsDir, `example.spec${projectFilesExtension}`);
             if (shouldCreateSampleTests && this.$fs.exists(exampleFilePath)) {
-                this.$fs.copyFile(exampleFilePath, path.join(testsDir, `example${projectFilesExtension}`));
-                this.$logger.info(`\nExample test file created in ${projectTestsDir}`.yellow);
+                this.$fs.copyFile(exampleFilePath, targetExampleTestPath);
+                const targetExampleTestRelativePath = path.relative(projectDir, targetExampleTestPath);
+                bufferedLogs.push(`Added example test: ${targetExampleTestRelativePath.yellow}`);
             }
-            else {
-                this.$logger.info(`\nPlace your test files under ${projectTestsDir}`.yellow);
+            const testMainResourcesPath = this.$resources.resolvePath(`test/test-main${projectFilesExtension}`);
+            const testMainPath = path.join(this.$projectData.appDirectoryPath, `test${projectFilesExtension}`);
+            if (!this.$fs.exists(testMainPath)) {
+                this.$fs.copyFile(testMainResourcesPath, testMainPath);
+                const testMainRelativePath = path.relative(projectDir, testMainPath);
+                bufferedLogs.push(`Main test entrypoint created: ${testMainRelativePath.yellow}`);
             }
-            this.$logger.info('Run your tests using the "$ ns test <platform>" command.'.yellow);
+            const testTsConfigTemplate = this.$resources.readText("test/tsconfig.spec.json");
+            const testTsConfig = _.template(testTsConfigTemplate)({
+                basePath: this.$projectData.getAppDirectoryRelativePath(),
+            });
+            this.$fs.writeFile(path.join(projectDir, "tsconfig.spec.json"), testTsConfig);
+            bufferedLogs.push(`Added/replaced ${"tsconfig.spec.json".yellow}`);
+            const greyDollarSign = "$".grey;
+            this.$logger.info([
+                [
+                    `Tests using`.green,
+                    frameworkToInstall.cyan,
+                    `were successfully initialized.`.green,
+                ].join(" "),
+                "",
+                ...bufferedLogs,
+                "",
+                `Note: @nativescript/unit-test-runner was included in "dependencies" as a convenience to automatically adjust your app's Info.plist on iOS and AndroidManifest.xml on Android to ensure the socket connects properly.`
+                    .yellow,
+                "",
+                `For production you may want to move to "devDependencies" and manage the settings yourself.`
+                    .yellow,
+                "",
+                "",
+                `You can now run your tests:`,
+                "",
+                `  ${greyDollarSign} ${"ns test ios".green}`,
+                `  ${greyDollarSign} ${"ns test android".green}`,
+                "",
+            ].join("\n"));
         });
     }
 }

package/lib/common/dispatchers.js

@@ -91,6 +91,9 @@ class CommandDispatcher {
     printVersion() {
         return __awaiter(this, void 0, void 0, function* () {
             this.$logger.info(this.$staticConfig.version);
+            if (this.$options.json) {
+                return;
+            }
             const spinner = this.$terminalSpinnerService.createSpinner();
             spinner.start("Checking for updates...");
             const nativescriptCliVersion = yield this.$versionsService.getNativescriptCliVersion();

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

@@ -23,7 +23,7 @@ class Hook {
     }
 }
 class HooksService {
-    constructor($childProcess, $fs, $logger, $errors, $config, $staticConfig, $injector, $projectHelper, $options, $performanceService) {
+    constructor($childProcess, $fs, $logger, $errors, $config, $staticConfig, $injector, $projectHelper, $options, $performanceService, $projectConfigService) {
         this.$childProcess = $childProcess;
         this.$fs = $fs;
         this.$logger = $logger;
@@ -34,6 +34,7 @@ class HooksService {
         this.$projectHelper = $projectHelper;
         this.$options = $options;
         this.$performanceService = $performanceService;
+        this.$projectConfigService = $projectConfigService;
     }
     get hookArgsName() {
         return "hookArgs";
@@ -46,6 +47,10 @@ class HooksService {
             this.hooksDirectories.push(path.join(projectDir, HooksService.HOOKS_DIRECTORY_NAME));
         }
         this.$logger.trace("Hooks directories: " + util.inspect(this.hooksDirectories));
+        const customHooks = this.$projectConfigService.getValue("hooks", []);
+        if (customHooks.length) {
+            this.$logger.trace("Custom hooks: " + util.inspect(customHooks));
+        }
     }
     static formatHookName(commandName) {
         return commandName.replace(/\|[\s\S]*$/, "");
@@ -79,6 +84,10 @@ class HooksService {
                 for (const hooksDirectory of this.hooksDirectories) {
                     results.push(yield this.executeHooksInDirectory(hooksDirectory, hookName, hookArguments));
                 }
+                const customHooks = this.getCustomHooksByName(hookName);
+                for (const hook of customHooks) {
+                    results.push(yield this.executeHook(this.$projectHelper.projectDir, hookName, hook, hookArguments));
+                }
             }
             catch (err) {
                 this.$logger.trace(`Failed during hook execution ${hookName}.`);
@@ -87,75 +96,102 @@ class HooksService {
             return _.flatten(results);
         });
     }
-    executeHooksInDirectory(directoryPath, hookName, hookArguments) {
+    executeHook(directoryPath, hookName, hook, hookArguments) {
         return __awaiter(this, void 0, void 0, function* () {
             hookArguments = hookArguments || {};
-            const results = [];
-            const hooks = this.getHooksByName(directoryPath, hookName);
-            for (let i = 0; i < hooks.length; ++i) {
-                const hook = hooks[i];
-                const relativePath = path.relative(directoryPath, hook.fullPath);
-                const trackId = relativePath.replace(new RegExp("\\" + path.sep, "g"), constants_1.AnalyticsEventLabelDelimiter);
-                let command = this.getSheBangInterpreter(hook);
-                let inProc = false;
-                if (!command) {
-                    command = hook.fullPath;
-                    if (path.extname(hook.fullPath).toLowerCase() === ".js") {
-                        command = process.argv[0];
-                        inProc = this.shouldExecuteInProcess(this.$fs.readText(hook.fullPath));
-                    }
+            let result;
+            const relativePath = path.relative(directoryPath, hook.fullPath);
+            const trackId = relativePath.replace(new RegExp("\\" + path.sep, "g"), constants_1.AnalyticsEventLabelDelimiter);
+            let command = this.getSheBangInterpreter(hook);
+            let inProc = false;
+            if (!command) {
+                command = hook.fullPath;
+                if (path.extname(hook.fullPath).toLowerCase() === ".js") {
+                    command = process.argv[0];
+                    inProc = this.shouldExecuteInProcess(this.$fs.readText(hook.fullPath));
                 }
-                const startTime = this.$performanceService.now();
-                if (inProc) {
-                    this.$logger.trace("Executing %s hook at location %s in-process", hookName, hook.fullPath);
-                    const hookEntryPoint = require(hook.fullPath);
-                    this.$logger.trace(`Validating ${hookName} arguments.`);
-                    const invalidArguments = this.validateHookArguments(hookEntryPoint, hook.fullPath);
-                    if (invalidArguments.length) {
-                        this.$logger.warn(`${hook.fullPath} will NOT be executed because it has invalid arguments - ${invalidArguments.join(", ").grey}.`);
-                        continue;
-                    }
-                    const projectDataHookArg = hookArguments["hookArgs"] && hookArguments["hookArgs"]["projectData"];
-                    if (projectDataHookArg) {
-                        hookArguments["projectData"] = hookArguments["$projectData"] = projectDataHookArg;
+            }
+            const startTime = this.$performanceService.now();
+            if (inProc) {
+                this.$logger.trace("Executing %s hook at location %s in-process", hookName, hook.fullPath);
+                const hookEntryPoint = require(hook.fullPath);
+                this.$logger.trace(`Validating ${hookName} arguments.`);
+                const invalidArguments = this.validateHookArguments(hookEntryPoint, hook.fullPath);
+                if (invalidArguments.length) {
+                    this.$logger.warn(`${hook.fullPath} will NOT be executed because it has invalid arguments - ${invalidArguments.join(", ").grey}.`);
+                    return;
+                }
+                const projectDataHookArg = hookArguments["hookArgs"] && hookArguments["hookArgs"]["projectData"];
+                if (projectDataHookArg) {
+                    hookArguments["projectData"] = hookArguments["$projectData"] = projectDataHookArg;
+                }
+                const maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
+                if (maybePromise) {
+                    this.$logger.trace("Hook promises to signal completion");
+                    try {
+                        result = yield maybePromise;
                     }
-                    const maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
-                    if (maybePromise) {
-                        this.$logger.trace("Hook promises to signal completion");
-                        try {
-                            const result = yield maybePromise;
-                            results.push(result);
+                    catch (err) {
+                        if (err &&
+                            _.isBoolean(err.stopExecution) &&
+                            err.errorAsWarning === true) {
+                            this.$logger.warn(err.message || err);
                         }
-                        catch (err) {
-                            if (err &&
-                                _.isBoolean(err.stopExecution) &&
-                                err.errorAsWarning === true) {
-                                this.$logger.warn(err.message || err);
-                            }
-                            else {
-                                this.$logger.error(err);
-                                throw (err || new Error(`Failed to execute hook: ${hook.fullPath}.`));
-                            }
+                        else {
+                            this.$logger.error(err);
+                            throw err || new Error(`Failed to execute hook: ${hook.fullPath}.`);
                         }
-                        this.$logger.trace("Hook completed");
                     }
+                    this.$logger.trace("Hook completed");
                 }
-                else {
-                    const environment = this.prepareEnvironment(hook.fullPath);
-                    this.$logger.trace("Executing %s hook at location %s with environment ", hookName, hook.fullPath, environment);
-                    const output = yield this.$childProcess.spawnFromEvent(command, [hook.fullPath], "close", environment, { throwError: false });
-                    results.push(output);
-                    if (output.exitCode !== 0) {
-                        throw new Error(output.stdout + output.stderr);
-                    }
-                    this.$logger.trace("Finished executing %s hook at location %s with environment ", hookName, hook.fullPath, environment);
+            }
+            else {
+                const environment = this.prepareEnvironment(hook.fullPath);
+                this.$logger.trace("Executing %s hook at location %s with environment ", hookName, hook.fullPath, environment);
+                const output = yield this.$childProcess.spawnFromEvent(command, [hook.fullPath], "close", environment, { throwError: false });
+                result = output;
+                if (output.exitCode !== 0) {
+                    throw new Error(output.stdout + output.stderr);
+                }
+                this.$logger.trace("Finished executing %s hook at location %s with environment ", hookName, hook.fullPath, environment);
+            }
+            const endTime = this.$performanceService.now();
+            this.$performanceService.processExecutionData(trackId, startTime, endTime, [
+                hookArguments,
+            ]);
+            return result;
+        });
+    }
+    executeHooksInDirectory(directoryPath, hookName, hookArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            hookArguments = hookArguments || {};
+            const results = [];
+            const hooks = this.getHooksByName(directoryPath, hookName);
+            for (let i = 0; i < hooks.length; ++i) {
+                const hook = hooks[i];
+                const result = yield this.executeHook(directoryPath, hookName, hook, hookArguments);
+                if (result) {
+                    results.push(result);
                 }
-                const endTime = this.$performanceService.now();
-                this.$performanceService.processExecutionData(trackId, startTime, endTime, [hookArguments]);
             }
             return results;
         });
     }
+    getCustomHooksByName(hookName) {
+        const hooks = [];
+        const customHooks = this.$projectConfigService.getValue("hooks", []);
+        for (const cHook of customHooks) {
+            if (cHook.type === hookName) {
+                const fullPath = path.join(this.$projectHelper.projectDir, cHook.script);
+                const isFile = this.$fs.getFsStats(fullPath).isFile();
+                if (isFile) {
+                    const fileNameParts = cHook.script.split("/");
+                    hooks.push(new Hook(this.getBaseFilename(fileNameParts[fileNameParts.length - 1]), fullPath));
+                }
+            }
+        }
+        return hooks;
+    }
     getHooksByName(directoryPath, hookName) {
         const allBaseHooks = this.getHooksInDirectory(directoryPath);
         const baseHooks = _.filter(allBaseHooks, (hook) => hook.name.toLowerCase() === hookName.toLowerCase());

package/lib/controllers/migrate-controller.js

@@ -19,6 +19,7 @@ const simple_git_1 = require("simple-git");
 const update_controller_base_1 = require("./update-controller-base");
 const helpers_1 = require("../common/helpers");
 const yok_1 = require("../common/yok");
+const temp = require("temp");
 class MigrateController extends update_controller_base_1.UpdateControllerBase {
     constructor($fs, $platformCommandHelper, $platformsDataService, $packageInstallationManager, $packageManager, $pacoteService, $logger, $errors, $pluginsService, $projectDataService, $projectConfigService, $options, $resources, $injector, $settingsService, $staticConfig, $terminalSpinnerService, $projectCleanupService, $projectBackupService, $childProcess) {
         super($fs, $platformCommandHelper, $platformsDataService, $packageInstallationManager, $packageManager, $pacoteService);
@@ -150,7 +151,7 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
             {
                 packageName: "@nativescript/unit-test-runner",
                 minVersion: "1.0.0",
-                desiredVersion: "~2.0.5",
+                desiredVersion: "~3.0.0",
                 shouldMigrateAction(dependency, projectData, loose) {
                     return __awaiter(this, void 0, void 0, function* () {
                         if (!this.hasDependency(dependency, projectData)) {
@@ -289,10 +290,21 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
             this.spinner.info("Updating project dependencies");
             yield this.migrateDependencies(projectData, platforms, loose);
             this.spinner.succeed("Project dependencies have been updated");
+            const isAngular = this.hasDependency({
+                packageName: "@nativescript/angular",
+            }, projectData);
+            let polyfillsPath;
+            if (isAngular) {
+                polyfillsPath = yield this.checkOrCreatePolyfillsTS(projectData);
+            }
             const tsConfigPath = path.resolve(projectDir, "tsconfig.json");
             if (this.$fs.exists(tsConfigPath)) {
                 this.spinner.info(`Updating ${"tsconfig.json".yellow}`);
-                yield this.migrateTSConfig(tsConfigPath);
+                yield this.migrateTSConfig({
+                    tsConfigPath,
+                    isAngular,
+                    polyfillsPath,
+                });
                 this.spinner.succeed(`Updated ${"tsconfig.json".yellow}`);
             }
             yield this.migrateWebpack5(projectDir, projectData);
@@ -673,10 +685,7 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
             const dependencies = [
                 {
                     packageName: "karma-webpack",
-                    minVersion: "3.0.5",
-                    desiredVersion: "~5.0.0",
-                    isDev: true,
-                    shouldAddIfMissing: true,
+                    shouldRemove: true,
                 },
                 {
                     packageName: "karma-jasmine",
@@ -712,7 +721,7 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
             return dependencies;
         });
     }
-    migrateTSConfig(tsConfigPath) {
+    migrateTSConfig({ tsConfigPath, isAngular, polyfillsPath, }) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const configContents = this.$fs.readJson(tsConfigPath);
@@ -725,6 +734,16 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
                 configContents.compilerOptions.lib = [
                     ...new Set([...(configContents.compilerOptions.lib || []), "es2017"]),
                 ];
+                if (isAngular) {
+                    if (configContents.files) {
+                        configContents.files = [
+                            ...new Set([
+                                ...(configContents.files || []),
+                                polyfillsPath !== null && polyfillsPath !== void 0 ? polyfillsPath : "./src/polyfills.ts",
+                            ]),
+                        ];
+                    }
+                }
                 this.$fs.writeJson(tsConfigPath, configContents);
                 return true;
             }
@@ -734,6 +753,30 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
             }
         });
     }
+    checkOrCreatePolyfillsTS(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { projectDir, appDirectoryPath } = projectData;
+            const possiblePaths = [
+                `${appDirectoryPath}/polyfills.ts`,
+                `./src/polyfills.ts`,
+                `./app/polyfills.ts`,
+            ].map((possiblePath) => path.resolve(projectDir, possiblePath));
+            let polyfillsPath = possiblePaths.find((possiblePath) => {
+                return this.$fs.exists(possiblePath);
+            });
+            if (polyfillsPath) {
+                return "./" + path.relative(projectDir, polyfillsPath);
+            }
+            const tempDir = temp.mkdirSync({
+                prefix: "migrate-angular-polyfills",
+            });
+            yield this.$pacoteService.extractPackage(constants.RESERVED_TEMPLATE_NAMES["angular"], tempDir);
+            this.$fs.copyFile(path.resolve(tempDir, "src/polyfills.ts"), possiblePaths[0]);
+            this.$fs.deleteDirectory(tempDir);
+            this.spinner.succeed(`Created fresh ${"polyfills.ts".cyan}`);
+            return "./" + path.relative(projectDir, possiblePaths[0]);
+        });
+    }
     migrateNativeScriptAngular() {
         return __awaiter(this, void 0, void 0, function* () {
             const minVersion = "10.0.0";
@@ -799,6 +842,12 @@ class MigrateController extends update_controller_base_1.UpdateControllerBase {
                     desiredVersion: "~0.11.4",
                     shouldAddIfMissing: true,
                 },
+                {
+                    packageName: "@angular/cli",
+                    minVersion,
+                    desiredVersion,
+                    isDev: true,
+                },
                 {
                     packageName: "@angular/compiler-cli",
                     minVersion,

package/lib/definitions/project.d.ts

@@ -134,6 +134,11 @@ interface INsConfigAndroid extends INsConfigPlaform {
 	enableMultithreadedJavascript?: boolean;
 }
 
+interface INsConfigHooks {
+	type?: string;
+	script: string;
+}
+
 interface INsConfig {
 	id?: string;
 	main?: string;
@@ -146,6 +151,7 @@ interface INsConfig {
 	ios?: INsConfigIOS;
 	android?: INsConfigAndroid;
 	ignoredNativeDependencies?: string[];
+	hooks?: INsConfigHooks[];
 }
 
 interface IProjectData extends ICreateProjectData {
@@ -302,13 +308,13 @@ interface IProjectCleanupService {
 	 * Clean multiple paths
 	 * @param {string[]} pathsToClean
 	 */
-	clean(pathsToClean: string[]): Promise<void>;
+	clean(pathsToClean: string[]): Promise<boolean>;
 
 	/**
 	 * Clean a single path
 	 * @param {string} pathToClean
 	 */
-	cleanPath(pathToClean: string): Promise<void>;
+	cleanPath(pathToClean: string): Promise<boolean>;
 }
 
 interface IBackup {
@@ -346,7 +352,7 @@ interface IProjectConfigService {
 	 * Get value for a given config key path
 	 * @param key the property key path
 	 */
-	getValue(key: string): any;
+	getValue(key: string, defaultValue?: any): any;
 	/**
 	 * Set value for a given config key path
 	 * @param key the property key path

package/lib/package-manager.js

@@ -21,7 +21,7 @@ const decorators_2 = require("./common/decorators");
 const constants_1 = require("./constants");
 const yok_1 = require("./common/yok");
 class PackageManager {
-    constructor($errors, $npm, $options, $yarn, $pnpm, $logger, $userSettingsService) {
+    constructor($errors, $npm, $options, $yarn, $pnpm, $logger, $userSettingsService, $projectConfigService) {
         this.$errors = $errors;
         this.$npm = $npm;
         this.$options = $options;
@@ -29,6 +29,7 @@ class PackageManager {
         this.$pnpm = $pnpm;
         this.$logger = $logger;
         this.$userSettingsService = $userSettingsService;
+        this.$projectConfigService = $projectConfigService;
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -103,6 +104,16 @@ class PackageManager {
             catch (err) {
                 this.$errors.fail(`Unable to read package manager config from user settings ${err}`);
             }
+            try {
+                const configPm = this.$projectConfigService.getValue("cli.packageManager");
+                if (configPm) {
+                    this.$logger.trace(`Determined packageManager to use from user config is: ${configPm}`);
+                    pm = configPm;
+                }
+            }
+            catch (err) {
+                this.$logger.trace("Tried to read cli.packageManager from project config and failed. Error is: ", err);
+            }
             if (pm === constants_1.PackageManagers.yarn || this.$options.yarn) {
                 this._packageManagerName = constants_1.PackageManagers.yarn;
                 return this.$yarn;

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

@@ -22,19 +22,25 @@ class ProjectCleanupService {
     }
     clean(pathsToClean) {
         return __awaiter(this, void 0, void 0, function* () {
+            let success = true;
             for (const pathToClean of pathsToClean) {
-                yield this.cleanPath(pathToClean).catch((error) => {
+                const isCleaned = yield this.cleanPath(pathToClean).catch((error) => {
                     this.$logger.trace(`Encountered error while cleaning. Error is: ${error.message}.`, error);
+                    return false;
                 });
+                success = success && isCleaned;
             }
+            return success;
         });
     }
     cleanPath(pathToClean) {
         return __awaiter(this, void 0, void 0, function* () {
             this.spinner.clear();
+            let success = true;
+            let fileType;
             if (!pathToClean || pathToClean.trim().length === 0) {
                 this.$logger.trace("cleanPath called with no pathToClean.");
-                return;
+                return success;
             }
             const filePath = path.resolve(this.$projectHelper.projectDir, pathToClean);
             const displayPath = `${path.relative(this.$projectHelper.projectDir, filePath)}`.yellow;
@@ -44,16 +50,25 @@ class ProjectCleanupService {
                 if (stat.isDirectory()) {
                     this.$logger.trace(`Path '${filePath}' is a directory, deleting.`);
                     this.$fs.deleteDirectorySafe(filePath);
-                    this.spinner.succeed(`Cleaned directory ${displayPath}`);
+                    fileType = "directory";
                 }
                 else {
                     this.$logger.trace(`Path '${filePath}' is a file, deleting.`);
                     this.$fs.deleteFile(filePath);
-                    this.spinner.succeed(`Cleaned file ${displayPath}`);
+                    fileType = "file";
                 }
-                return;
+                success = !this.$fs.exists(filePath);
+                if (success) {
+                    this.spinner.succeed(`Cleaned ${fileType} ${displayPath}`);
+                }
+                else {
+                    const message = `Failed to Clean ${fileType}`.red;
+                    this.spinner.fail(`${message} ${displayPath}`);
+                }
+                return success;
             }
             this.$logger.trace(`Path '${filePath}' not found, skipping.`);
+            return success;
         });
     }
 }

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

@@ -92,7 +92,11 @@ export default {
             .filter(Boolean)
             .map((c) => {
             if (this.$fs.isRelativePath(c)) {
-                return path.join(projectDir || this.projectHelper.projectDir, c);
+                const dir = projectDir || this.projectHelper.projectDir;
+                if (!dir) {
+                    return c;
+                }
+                return path.join(dir, c);
             }
             return c;
         });

package/lib/services/test-execution-service.js

@@ -120,6 +120,7 @@ class TestExecutionService {
                 path: this.$options.path,
                 tns: process.argv[1],
                 node: process.execPath,
+                env: this.$options.env,
                 options: {
                     debugTransport: this.$options.debugTransport,
                     debugBrk: this.$options.debugBrk,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nativescript",
   "preferGlobal": true,
-  "version": "8.1.4",
+  "version": "8.1.5",
   "author": "NativeScript <support@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {

package/resources/test/karma.conf.js

@@ -1,4 +1,3 @@
-const filePatterns = [${ testFiles }];
 module.exports = function (config) {
   const options = {
 
@@ -11,8 +10,8 @@ module.exports = function (config) {
     frameworks: [${ frameworks }],
 
 
-    // list of files / patterns to load in the browser
-    files: filePatterns,
+    // list of files / patterns to load in the browser. Leave empty for webpack projects
+    // files: [],
 
 
     // list of files to exclude
@@ -31,6 +30,16 @@ module.exports = function (config) {
     // available reporters: https://npmjs.org/browse/keyword/karma-reporter
     reporters: ['progress'],
 
+    // configure optional coverage, enable via --env.codeCoverage
+    coverageReporter: {
+      dir: require('path').join(__dirname, './coverage'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+
 
     // web server port
     port: 9876,
@@ -74,41 +83,9 @@ module.exports = function (config) {
     singleRun: false
   };
 
-  setWebpackPreprocessor(config, options);
-  setWebpack(config, options);
-
-  config.set(options);
-}
-module.exports.filePatterns = filePatterns;
-// You can also use RegEx if you'd like:
-// module.exports.filesRegex = /\.\/tests\/.*\.ts$/;
-
-function setWebpackPreprocessor(config, options) {
-  if (config && config.bundle) {
-    if (!options.preprocessors) {
-      options.preprocessors = {};
-    }
-
-    options.files.forEach(file => {
-      if (!options.preprocessors[file]) {
-        options.preprocessors[file] = [];
-      }
-      options.preprocessors[file].push('webpack');
-    });
+  if(config._NS && config._NS.env && config._NS.env.codeCoverage) {
+    options.reporters = (options.reporters || []).concat(['coverage']);
   }
-}
 
-function setWebpack(config, options) {
-  if (config && config.bundle) {
-    const env = {};
-    env[config.platform] = true;
-    env.sourceMap = config.debugBrk;
-    env.appPath = config.appPath;
-    env.karmaWebpack = true;
-    options.webpack = require('./webpack.config')(env);
-    delete options.webpack.entry;
-    delete options.webpack.output.libraryTarget;
-    const invalidPluginsForUnitTesting = ["GenerateBundleStarterPlugin", "GenerateNativeScriptEntryPointsPlugin"];
-    options.webpack.plugins = options.webpack.plugins.filter(p => !invalidPluginsForUnitTesting.includes(p.constructor.name));
-  }
+  config.set(options);
 }

package/resources/test/test-main.js

@@ -0,0 +1,9 @@
+import { runTestApp } from "@nativescript/unit-test-runner";
+// import other polyfills here
+
+runTestApp({
+	runTests: () => {
+		const tests = require.context("./", true, /\.spec\.js$/);
+		tests.keys().map(tests);
+	},
+});

package/resources/test/test-main.ts

@@ -0,0 +1,11 @@
+import { runTestApp } from "@nativescript/unit-test-runner";
+// import other polyfills here
+
+declare let require: any;
+
+runTestApp({
+	runTests: () => {
+		const tests = require.context("./", true, /\.spec\.ts$/);
+		tests.keys().map(tests);
+	},
+});

package/resources/test/tsconfig.spec.json

@@ -0,0 +1,9 @@
+{
+	"extends": "./tsconfig.json",
+    "compilerOptions": {
+        "sourceMap": true
+    },
+	"files": ["${ basePath }/test.ts"],
+	"include": ["${ basePath }/**/*.spec.ts", "${ basePath }/**/*.d.ts"],
+	"exclude": ["node_modules", "platforms", "e2e"]
+}

package/lib/common/.vscode/settings.json

@@ -1,9 +0,0 @@
-// Place your settings in this file to overwrite default and user settings.
-{
-	"files.exclude": {
-		"**/.git": true,
-		"**/.DS_Store": true,
-		"**/*.js": { "when": "$(basename).ts"},
-		"**/*.js.map": true
-	}
-}