@akylas/nativescript-cli 8.7.2

package/lib/commands/preview.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreviewCommand = void 0;
+const yok_1 = require("../common/yok");
+const resolve_package_path_1 = require("@rigor789/resolve-package-path");
+const constants_1 = require("../constants");
+const color_1 = require("../color");
+const path = require("path");
+const PREVIEW_CLI_PACKAGE = "@nativescript/preview-cli";
+class PreviewCommand {
+    constructor($logger, $errors, $projectData, $packageManager, $childProcess, $options) {
+        this.$logger = $logger;
+        this.$errors = $errors;
+        this.$projectData = $projectData;
+        this.$packageManager = $packageManager;
+        this.$childProcess = $childProcess;
+        this.$options = $options;
+        this.allowedParameters = [];
+    }
+    getPreviewCLIPath() {
+        return (0, resolve_package_path_1.resolvePackagePath)(PREVIEW_CLI_PACKAGE, {
+            paths: [this.$projectData.projectDir],
+        });
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$options.disableNpmInstall) {
+                yield this.$packageManager.install(`${PREVIEW_CLI_PACKAGE}@latest`, this.$projectData.projectDir, {
+                    "save-dev": true,
+                    "save-exact": true,
+                });
+            }
+            const previewCLIPath = this.getPreviewCLIPath();
+            if (!previewCLIPath) {
+                const packageManagerName = yield this.$packageManager.getPackageManagerName();
+                let installCommand = "";
+                switch (packageManagerName) {
+                    case constants_1.PackageManagers.yarn:
+                    case constants_1.PackageManagers.yarn2:
+                        installCommand = "yarn add -D @nativescript/preview-cli";
+                        break;
+                    case constants_1.PackageManagers.pnpm:
+                        installCommand = "pnpm install --save-dev @nativescript/preview-cli";
+                        break;
+                    case constants_1.PackageManagers.bun:
+                        installCommand = "bun add --dev @nativescript/preview-cli";
+                    case constants_1.PackageManagers.npm:
+                    default:
+                        installCommand = "npm install --save-dev @nativescript/preview-cli";
+                        break;
+                }
+                this.$logger.info([
+                    `Uhh ohh, no Preview CLI found.`,
+                    "",
+                    `This should not happen under regular circumstances, but seems like it did somehow... :(`,
+                    `Good news though, you can install the Preview CLI by running`,
+                    "",
+                    "  " + color_1.color.green(installCommand),
+                    "",
+                    "Once installed, run this command again and everything should work!",
+                    "If it still fails, you can invoke the preview-cli directly as a last resort with",
+                    "",
+                    color_1.color.cyan("  ./node_modules/.bin/preview-cli"),
+                    "",
+                    "And if you are still having issues, try again - or reach out on Discord/open an issue on GitHub.",
+                ].join("\n"));
+                this.$errors.fail("Running preview failed.");
+            }
+            const previewCLIBinPath = path.resolve(previewCLIPath, "./dist/index.js");
+            const commandIndex = process.argv.indexOf("preview");
+            const commandArgs = process.argv.slice(commandIndex + 1);
+            this.$childProcess.spawn(process.execPath, [previewCLIBinPath, ...commandArgs], {
+                stdio: "inherit",
+            });
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.PreviewCommand = PreviewCommand;
+yok_1.injector.registerCommand("preview", PreviewCommand);

package/lib/commands/remove-platform.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemovePlatformCommand = void 0;
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+class RemovePlatformCommand {
+    constructor($errors, $platformCommandHelper, $platformValidationService, $projectData) {
+        this.$errors = $errors;
+        this.$platformCommandHelper = $platformCommandHelper;
+        this.$platformValidationService = $platformValidationService;
+        this.$projectData = $projectData;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return this.$platformCommandHelper.removePlatforms(args, this.$projectData);
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args || args.length === 0) {
+                this.$errors.failWithHelp("No platform specified. Please specify a platform to remove.");
+            }
+            _.each(args, (platform) => {
+                this.$platformValidationService.validatePlatform(platform, this.$projectData);
+            });
+            return true;
+        });
+    }
+}
+exports.RemovePlatformCommand = RemovePlatformCommand;
+yok_1.injector.registerCommand("platform|remove", RemovePlatformCommand);

package/lib/commands/resources/resources-update.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcesUpdateCommand = void 0;
+const yok_1 = require("../../common/yok");
+class ResourcesUpdateCommand {
+    constructor($projectData, $errors, $androidResourcesMigrationService) {
+        this.$projectData = $projectData;
+        this.$errors = $errors;
+        this.$androidResourcesMigrationService = $androidResourcesMigrationService;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$androidResourcesMigrationService.migrate(this.$projectData.getAppResourcesDirectoryPath());
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args || args.length === 0) {
+                args = ["android"];
+            }
+            for (const platform of args) {
+                if (!this.$androidResourcesMigrationService.canMigrate(platform)) {
+                    this.$errors.fail(`The ${platform} does not need to have its resources updated.`);
+                }
+                if (this.$androidResourcesMigrationService.hasMigrated(this.$projectData.getAppResourcesDirectoryPath())) {
+                    this.$errors.fail("The App_Resources have already been updated for the Android platform.");
+                }
+            }
+            return true;
+        });
+    }
+}
+exports.ResourcesUpdateCommand = ResourcesUpdateCommand;
+yok_1.injector.registerCommand("resources|update", ResourcesUpdateCommand);

package/lib/commands/run.js

@@ -0,0 +1,177 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunVisionOSCommand = exports.RunAndroidCommand = exports.RunIosCommand = exports.RunCommandBase = void 0;
+const constants_1 = require("../common/constants");
+const decorators_1 = require("../common/decorators");
+const helpers_1 = require("../common/helpers");
+const yok_1 = require("../common/yok");
+const constants_2 = require("../constants");
+class RunCommandBase {
+    constructor($devicePlatformsConstants, $errors, $hostInfo, $liveSyncCommandHelper, $migrateController, $options, $projectData, $keyCommandHelper) {
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$errors = $errors;
+        this.$hostInfo = $hostInfo;
+        this.$liveSyncCommandHelper = $liveSyncCommandHelper;
+        this.$migrateController = $migrateController;
+        this.$options = $options;
+        this.$projectData = $projectData;
+        this.$keyCommandHelper = $keyCommandHelper;
+        this.liveSyncCommandHelperAdditionalOptions = {};
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$liveSyncCommandHelper.executeCommandLiveSync(this.platform, this.liveSyncCommandHelperAdditionalOptions);
+            if (process.env.NS_IS_INTERACTIVE) {
+                this.$keyCommandHelper.attachKeyCommands(this.platform, "run");
+            }
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (args.length) {
+                this.$errors.failWithHelp(constants_1.ERROR_NO_VALID_SUBCOMMAND_FORMAT, "run");
+            }
+            this.platform = args[0] || this.platform;
+            if (!this.platform && !this.$hostInfo.isDarwin) {
+                this.platform = this.$devicePlatformsConstants.Android;
+            }
+            this.$projectData.initializeProjectData();
+            const platforms = this.platform
+                ? [this.platform]
+                : [
+                    this.$devicePlatformsConstants.Android,
+                    this.$devicePlatformsConstants.iOS,
+                ];
+            if (!this.$options.force) {
+                yield this.$migrateController.validate({
+                    projectDir: this.$projectData.projectDir,
+                    platforms,
+                });
+            }
+            yield this.$liveSyncCommandHelper.validatePlatform(this.platform);
+            return true;
+        });
+    }
+}
+exports.RunCommandBase = RunCommandBase;
+yok_1.injector.registerCommand("run|*all", RunCommandBase);
+class RunIosCommand {
+    get runCommand() {
+        const runCommand = this.$injector.resolve(RunCommandBase);
+        runCommand.platform = this.platform;
+        return runCommand;
+    }
+    get platform() {
+        return this.$devicePlatformsConstants.iOS;
+    }
+    constructor($devicePlatformsConstants, $errors, $injector, $options, $platformValidationService, $projectDataService) {
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$errors = $errors;
+        this.$injector = $injector;
+        this.$options = $options;
+        this.$platformValidationService = $platformValidationService;
+        this.$projectDataService = $projectDataService;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.runCommand.execute(args);
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectData = this.$projectDataService.getProjectData();
+            if (!this.$platformValidationService.isPlatformSupportedForOS(this.platform, projectData)) {
+                this.$errors.fail(`Applications for platform ${this.platform} can not be built on this OS`);
+            }
+            const result = (yield this.runCommand.canExecute(args)) &&
+                (yield this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, projectData, this.platform.toLowerCase()));
+            return result;
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], RunIosCommand.prototype, "runCommand", null);
+exports.RunIosCommand = RunIosCommand;
+yok_1.injector.registerCommand("run|ios", RunIosCommand);
+class RunAndroidCommand {
+    get runCommand() {
+        const runCommand = this.$injector.resolve(RunCommandBase);
+        runCommand.platform = this.platform;
+        return runCommand;
+    }
+    get platform() {
+        return this.$devicePlatformsConstants.Android;
+    }
+    constructor($devicePlatformsConstants, $errors, $injector, $options, $platformValidationService, $projectData) {
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$errors = $errors;
+        this.$injector = $injector;
+        this.$options = $options;
+        this.$platformValidationService = $platformValidationService;
+        this.$projectData = $projectData;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.runCommand.execute(args);
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.runCommand.canExecute(args);
+            if (!this.$platformValidationService.isPlatformSupportedForOS(this.$devicePlatformsConstants.Android, this.$projectData)) {
+                this.$errors.fail(`Applications for platform ${this.$devicePlatformsConstants.Android} can not be built on this OS`);
+            }
+            if ((this.$options.release || this.$options.aab) &&
+                !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
+                if (this.$options.release) {
+                    this.$errors.failWithHelp(constants_2.ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
+                }
+                else {
+                    this.$errors.failWithHelp(constants_2.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
+                }
+            }
+            return this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, this.$devicePlatformsConstants.Android.toLowerCase());
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], RunAndroidCommand.prototype, "runCommand", null);
+exports.RunAndroidCommand = RunAndroidCommand;
+yok_1.injector.registerCommand("run|android", RunAndroidCommand);
+class RunVisionOSCommand extends RunIosCommand {
+    get platform() {
+        return this.$devicePlatformsConstants.visionOS;
+    }
+    constructor($devicePlatformsConstants, $errors, $injector, $options, $platformValidationService, $projectDataService) {
+        super($devicePlatformsConstants, $errors, $injector, $options, $platformValidationService, $projectDataService);
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$errors = $errors;
+        this.$injector = $injector;
+        this.$options = $options;
+        this.$platformValidationService = $platformValidationService;
+        this.$projectDataService = $projectDataService;
+    }
+}
+exports.RunVisionOSCommand = RunVisionOSCommand;
+yok_1.injector.registerCommand("run|vision", RunVisionOSCommand);
+yok_1.injector.registerCommand("run|visionos", RunVisionOSCommand);

package/lib/commands/setup.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetupCommand = void 0;
+const yok_1 = require("../common/yok");
+class SetupCommand {
+    constructor($doctorService) {
+        this.$doctorService = $doctorService;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return this.$doctorService.runSetupScript();
+    }
+}
+exports.SetupCommand = SetupCommand;
+yok_1.injector.registerCommand("setup|*", SetupCommand);

package/lib/commands/start.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartCommand = void 0;
+const header_1 = require("../common/header");
+const yok_1 = require("../common/yok");
+class StartCommand {
+    constructor($startService) {
+        this.$startService = $startService;
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, header_1.printHeader)();
+            this.$startService.start();
+            return;
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.StartCommand = StartCommand;
+yok_1.injector.registerCommand("start", StartCommand);

package/lib/commands/test-init.js

@@ -0,0 +1,167 @@
+"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 path = require("path");
+const _ = require("lodash");
+const constants_1 = require("../constants");
+const helpers_1 = require("../common/helpers");
+const yok_1 = require("../common/yok");
+const color_1 = require("../color");
+class TestInitCommand {
+    constructor($packageManager, $projectData, $errors, $options, $prompter, $fs, $resources, $pluginsService, $logger, $testInitializationService) {
+        this.$packageManager = $packageManager;
+        this.$projectData = $projectData;
+        this.$errors = $errors;
+        this.$options = $options;
+        this.$prompter = $prompter;
+        this.$fs = $fs;
+        this.$resources = $resources;
+        this.$pluginsService = $pluginsService;
+        this.$logger = $logger;
+        this.$testInitializationService = $testInitializationService;
+        this.allowedParameters = [];
+        this.karmaConfigAdditionalFrameworks = {
+            mocha: ["chai"],
+        };
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectDir = this.$projectData.projectDir;
+            const frameworkToInstall = this.$options.framework ||
+                (yield this.$prompter.promptForChoice("Select testing framework:", constants_1.TESTING_FRAMEWORKS));
+            if (constants_1.TESTING_FRAMEWORKS.indexOf(frameworkToInstall) === -1) {
+                this.$errors.failWithHelp(`Unknown or unsupported unit testing framework: ${frameworkToInstall}.`);
+            }
+            const projectFilesExtension = this.$projectData.projectType === constants_1.ProjectTypes.TsFlavorName ||
+                this.$projectData.projectType === constants_1.ProjectTypes.NgFlavorName
+                ? ".ts"
+                : ".js";
+            let modulesToInstall = [];
+            try {
+                modulesToInstall = this.$testInitializationService.getDependencies(frameworkToInstall);
+            }
+            catch (err) {
+                this.$errors.fail(`Unable to install the unit testing dependencies. Error: '${err.message}'`);
+            }
+            modulesToInstall = modulesToInstall.filter((moduleToInstall) => !moduleToInstall.projectType ||
+                moduleToInstall.projectType === projectFilesExtension);
+            for (const mod of modulesToInstall) {
+                let moduleToInstall = mod.name;
+                moduleToInstall += `@${mod.version}`;
+                yield this.$packageManager.install(moduleToInstall, projectDir, {
+                    "save-dev": true,
+                    "save-exact": true,
+                    optional: false,
+                    disableNpmInstall: this.$options.disableNpmInstall,
+                    frameworkPath: this.$options.frameworkPath,
+                    ignoreScripts: this.$options.ignoreScripts,
+                    path: this.$options.path,
+                });
+                const modulePath = path.join(projectDir, "node_modules", mod.name);
+                const modulePackageJsonPath = path.join(modulePath, "package.json");
+                const modulePackageJsonContent = this.$fs.readJson(modulePackageJsonPath);
+                const modulePeerDependencies = modulePackageJsonContent.peerDependencies || {};
+                for (const peerDependency in modulePeerDependencies) {
+                    const isPeerDependencyExcluded = _.includes(mod.excludedPeerDependencies, peerDependency);
+                    if (isPeerDependencyExcluded) {
+                        continue;
+                    }
+                    const dependencyVersion = modulePeerDependencies[peerDependency] || "*";
+                    try {
+                        yield this.$packageManager.install(`${peerDependency}@${dependencyVersion}`, projectDir, {
+                            "save-dev": true,
+                            "save-exact": true,
+                            disableNpmInstall: false,
+                            frameworkPath: this.$options.frameworkPath,
+                            ignoreScripts: this.$options.ignoreScripts,
+                            path: this.$options.path,
+                        });
+                    }
+                    catch (e) {
+                        this.$logger.error(e.message);
+                    }
+                }
+            }
+            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)) {
+                const specFilenamePattern = `<filename>.spec${projectFilesExtension}`;
+                bufferedLogs.push(color_1.color.yellow([
+                    `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")));
+                shouldCreateSampleTests = false;
+            }
+            this.$fs.ensureDirectoryExists(testsDir);
+            const frameworks = [frameworkToInstall]
+                .concat(this.karmaConfigAdditionalFrameworks[frameworkToInstall] || [])
+                .map((fw) => `'${fw}'`)
+                .join(", ");
+            const testFiles = `'${(0, helpers_1.fromWindowsRelativePathToUnix)(relativeTestsDir)}/**/*${projectFilesExtension}'`;
+            const karmaConfTemplate = this.$resources.readText("test/karma.conf.js");
+            const karmaConf = _.template(karmaConfTemplate)({
+                frameworks,
+                testFiles,
+                basePath: this.$projectData.getAppDirectoryRelativePath(),
+            });
+            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, targetExampleTestPath);
+                const targetExampleTestRelativePath = path.relative(projectDir, targetExampleTestPath);
+                bufferedLogs.push(`Added example test: ${color_1.color.yellow(targetExampleTestRelativePath)}`);
+            }
+            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: ${color_1.color.yellow(testMainRelativePath)}`);
+            }
+            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 ${color_1.color.yellow("tsconfig.spec.json")}`);
+            const greyDollarSign = color_1.color.grey("$");
+            this.$logger.info([
+                [
+                    color_1.color.green(`Tests using`),
+                    color_1.color.cyan(frameworkToInstall),
+                    color_1.color.green(`were successfully initialized.`),
+                ].join(" "),
+                "",
+                ...bufferedLogs,
+                "",
+                color_1.color.yellow(`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.`),
+                "",
+                color_1.color.yellow(`For production you may want to move to "devDependencies" and manage the settings yourself.`),
+                "",
+                "",
+                `You can now run your tests:`,
+                "",
+                `  ${greyDollarSign} ${color_1.color.green("ns test ios")}`,
+                `  ${greyDollarSign} ${color_1.color.green("ns test android")}`,
+                "",
+            ].join("\n"));
+        });
+    }
+}
+yok_1.injector.registerCommand("test|init", TestInitCommand);