@akylas/nativescript-cli 8.7.2

package/lib/commands/create-project.js

@@ -0,0 +1,431 @@
+"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.CreateProjectCommand = void 0;
+const constants = require("../constants");
+const path = require("path");
+const helpers_1 = require("../common/helpers");
+const yok_1 = require("../common/yok");
+const color_1 = require("../color");
+class CreateProjectCommand {
+    constructor($projectService, $logger, $errors, $options, $prompter, $stringParameter) {
+        this.$projectService = $projectService;
+        this.$logger = $logger;
+        this.$errors = $errors;
+        this.$options = $options;
+        this.$prompter = $prompter;
+        this.$stringParameter = $stringParameter;
+        this.enableHooks = false;
+        this.allowedParameters = [this.$stringParameter];
+        this.isInteractionIntroShown = false;
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const interactiveAdverbs = ["First", "Next", "Finally"];
+            const getNextInteractiveAdverb = () => {
+                return interactiveAdverbs.shift() || "Next";
+            };
+            if ((this.$options.tsc ||
+                this.$options.ng ||
+                this.$options.vue ||
+                this.$options.react ||
+                this.$options.solid ||
+                this.$options.svelte ||
+                this.$options.js) &&
+                this.$options.template) {
+                this.$errors.failWithHelp("You cannot use a flavor option like --ng, --vue, --react, --solid, --svelte, --tsc and --js together with --template.");
+            }
+            let projectName = args[0];
+            let selectedTemplate;
+            if (this.$options["vision-ng"] ||
+                (this.$options.vision && this.$options.ng)) {
+                selectedTemplate = constants.RESERVED_TEMPLATE_NAMES["vision-ng"];
+            }
+            else if (this.$options["vision-react"] ||
+                (this.$options.vision && this.$options.react)) {
+                selectedTemplate = constants.RESERVED_TEMPLATE_NAMES["vision-react"];
+            }
+            else if (this.$options["vision-solid"] ||
+                (this.$options.vision && this.$options.solid)) {
+                selectedTemplate = constants.RESERVED_TEMPLATE_NAMES["vision-solid"];
+            }
+            else if (this.$options["vision-svelte"] ||
+                (this.$options.vision && this.$options.svelte)) {
+                selectedTemplate = constants.RESERVED_TEMPLATE_NAMES["vision-svelte"];
+            }
+            else if (this.$options["vision-vue"] ||
+                (this.$options.vision && (this.$options.vue || this.$options.vuejs))) {
+                selectedTemplate = constants.RESERVED_TEMPLATE_NAMES["vision-vue"];
+            }
+            else if ((this.$options.vue || this.$options.vuejs) &&
+                this.$options.tsc) {
+                selectedTemplate = "@nativescript/template-blank-vue-ts";
+            }
+            else if (this.$options.vision) {
+                selectedTemplate = constants.RESERVED_TEMPLATE_NAMES["vision"];
+            }
+            else if (this.$options.js) {
+                selectedTemplate = constants.JAVASCRIPT_NAME;
+            }
+            else if (this.$options.tsc) {
+                selectedTemplate = constants.TYPESCRIPT_NAME;
+            }
+            else if (this.$options.ng) {
+                selectedTemplate = constants.ANGULAR_NAME;
+            }
+            else if (this.$options.vue || this.$options.vuejs) {
+                selectedTemplate = constants.VUE_NAME;
+            }
+            else if (this.$options.solid) {
+                selectedTemplate = constants.SOLID_NAME;
+            }
+            else if (this.$options.react) {
+                selectedTemplate = constants.REACT_NAME;
+            }
+            else if (this.$options.svelte) {
+                selectedTemplate = constants.SVELTE_NAME;
+            }
+            else {
+                selectedTemplate = this.$options.template;
+            }
+            if (!projectName && (0, helpers_1.isInteractive)()) {
+                this.printInteractiveCreationIntroIfNeeded();
+                projectName = yield this.$prompter.getString(`${getNextInteractiveAdverb()}, what will be the name of your app?`, { allowEmpty: false });
+                this.$logger.info();
+            }
+            projectName = yield this.$projectService.validateProjectName({
+                projectName: projectName,
+                force: this.$options.force,
+                pathToProject: this.$options.path,
+            });
+            if (!selectedTemplate && (0, helpers_1.isInteractive)()) {
+                this.printInteractiveCreationIntroIfNeeded();
+                selectedTemplate = yield this.interactiveFlavorAndTemplateSelection(getNextInteractiveAdverb(), getNextInteractiveAdverb());
+            }
+            this.createdProjectData = yield this.$projectService.createProject({
+                projectName: projectName,
+                template: selectedTemplate,
+                appId: this.$options.appid,
+                pathToProject: this.$options.path,
+                force: true,
+                ignoreScripts: this.$options.ignoreScripts,
+            });
+        });
+    }
+    interactiveFlavorAndTemplateSelection(flavorAdverb, templateAdverb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selectedFlavor = yield this.interactiveFlavorSelection(flavorAdverb);
+            const selectedTemplate = yield this.interactiveTemplateSelection(selectedFlavor, templateAdverb);
+            return selectedTemplate;
+        });
+    }
+    interactiveFlavorSelection(adverb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const flavorSelection = yield this.$prompter.promptForDetailedChoice(`${adverb}, which style of NativeScript project would you like to use:`, [
+                {
+                    key: constants.NgFlavorName,
+                    description: "Learn more at https://nativescript.org/angular",
+                },
+                {
+                    key: constants.ReactFlavorName,
+                    description: "Learn more at https://github.com/shirakaba/react-nativescript",
+                },
+                {
+                    key: constants.VueFlavorName,
+                    description: "Learn more at https://nativescript.org/vue",
+                },
+                {
+                    key: constants.SolidFlavorName,
+                    description: "Learn more at https://www.solidjs.com",
+                },
+                {
+                    key: constants.SvelteFlavorName,
+                    description: "Learn more at https://svelte-native.technology",
+                },
+                {
+                    key: constants.TsFlavorName,
+                    description: "Learn more at https://nativescript.org/typescript",
+                },
+                {
+                    key: constants.JsFlavorName,
+                    description: "Use NativeScript without any framework",
+                },
+            ]);
+            return flavorSelection;
+        });
+    }
+    printInteractiveCreationIntroIfNeeded() {
+        if (!this.isInteractionIntroShown) {
+            this.isInteractionIntroShown = true;
+            this.$logger.info();
+            this.$logger.printMarkdown(`# Let’s create a NativeScript app!`);
+            this.$logger.printMarkdown(`
+Answer the following questions to help us build the right app for you. (Note: you
+can skip this prompt next time using the --template option, or the --ng, --react, --vue, --svelte, --ts, or --js flags.)
+`);
+        }
+    }
+    interactiveTemplateSelection(flavorSelection, adverb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selectedFlavorTemplates = [];
+            let selectedTemplate;
+            switch (flavorSelection) {
+                case constants.NgFlavorName: {
+                    selectedFlavorTemplates.push(...this.getNgTemplates());
+                    break;
+                }
+                case constants.ReactFlavorName: {
+                    selectedFlavorTemplates.push(...this.getReactTemplates());
+                    break;
+                }
+                case constants.VueFlavorName: {
+                    selectedFlavorTemplates.push(...this.getVueTemplates());
+                    break;
+                }
+                case constants.SolidFlavorName: {
+                    selectedFlavorTemplates.push(...this.getSolidTemplates());
+                    break;
+                }
+                case constants.SvelteFlavorName: {
+                    selectedFlavorTemplates.push(...this.getSvelteTemplates());
+                    break;
+                }
+                case constants.TsFlavorName: {
+                    selectedFlavorTemplates.push(...this.getTsTemplates());
+                    break;
+                }
+                case constants.JsFlavorName: {
+                    selectedFlavorTemplates.push(...this.getJsTemplates());
+                    break;
+                }
+            }
+            if (selectedFlavorTemplates.length > 1) {
+                this.$logger.info();
+                const templateChoices = selectedFlavorTemplates.map((template) => {
+                    return { key: template.key, description: template.description };
+                });
+                const selectedTemplateKey = yield this.$prompter.promptForDetailedChoice(`${adverb}, which template would you like to start from:`, templateChoices);
+                selectedTemplate = selectedFlavorTemplates.find((t) => t.key === selectedTemplateKey).value;
+            }
+            else {
+                selectedTemplate = selectedFlavorTemplates[0].value;
+            }
+            return selectedTemplate;
+        });
+    }
+    getJsTemplates() {
+        const templates = [
+            {
+                key: CreateProjectCommand.HelloWorldTemplateKey,
+                value: constants.RESERVED_TEMPLATE_NAMES.javascript,
+                description: CreateProjectCommand.HelloWorldTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.DrawerTemplateKey,
+                value: "@nativescript/template-drawer-navigation",
+                description: CreateProjectCommand.DrawerTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.TabsTemplateKey,
+                value: "@nativescript/template-tab-navigation",
+                description: CreateProjectCommand.TabsTemplateDescription,
+            },
+        ];
+        return templates;
+    }
+    getTsTemplates() {
+        const templates = [
+            {
+                key: CreateProjectCommand.HelloWorldTemplateKey,
+                value: constants.RESERVED_TEMPLATE_NAMES.typescript,
+                description: CreateProjectCommand.HelloWorldTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.DrawerTemplateKey,
+                value: "@nativescript/template-drawer-navigation-ts",
+                description: CreateProjectCommand.DrawerTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.TabsTemplateKey,
+                value: "@nativescript/template-tab-navigation-ts",
+                description: CreateProjectCommand.TabsTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.BlankVisionTemplateKey,
+                value: "@nativescript/template-hello-world-ts-vision",
+                description: CreateProjectCommand.BlankVisionTemplateDescription,
+            },
+        ];
+        return templates;
+    }
+    getNgTemplates() {
+        const templates = [
+            {
+                key: CreateProjectCommand.HelloWorldTemplateKey,
+                value: constants.RESERVED_TEMPLATE_NAMES.angular,
+                description: CreateProjectCommand.HelloWorldTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.DrawerTemplateKey,
+                value: "@nativescript/template-drawer-navigation-ng",
+                description: CreateProjectCommand.DrawerTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.TabsTemplateKey,
+                value: "@nativescript/template-tab-navigation-ng",
+                description: CreateProjectCommand.TabsTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.BlankVisionTemplateKey,
+                value: "@nativescript/template-hello-world-ng-vision",
+                description: CreateProjectCommand.BlankVisionTemplateDescription,
+            },
+        ];
+        return templates;
+    }
+    getReactTemplates() {
+        const templates = [
+            {
+                key: CreateProjectCommand.HelloWorldTemplateKey,
+                value: constants.RESERVED_TEMPLATE_NAMES.react,
+                description: CreateProjectCommand.HelloWorldTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.BlankVisionTemplateKey,
+                value: "@nativescript/template-blank-react-vision",
+                description: CreateProjectCommand.BlankVisionTemplateDescription,
+            },
+        ];
+        return templates;
+    }
+    getSolidTemplates() {
+        const templates = [
+            {
+                key: CreateProjectCommand.HelloWorldTemplateKey,
+                value: constants.RESERVED_TEMPLATE_NAMES.solid,
+                description: CreateProjectCommand.HelloWorldTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.BlankVisionTemplateKey,
+                value: "@nativescript/template-blank-solid-vision",
+                description: CreateProjectCommand.BlankVisionTemplateDescription,
+            },
+        ];
+        return templates;
+    }
+    getSvelteTemplates() {
+        const templates = [
+            {
+                key: CreateProjectCommand.HelloWorldTemplateKey,
+                value: constants.RESERVED_TEMPLATE_NAMES.svelte,
+                description: CreateProjectCommand.HelloWorldTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.BlankVisionTemplateKey,
+                value: "@nativescript/template-blank-svelte-vision",
+                description: CreateProjectCommand.BlankVisionTemplateDescription,
+            },
+        ];
+        return templates;
+    }
+    getVueTemplates() {
+        const templates = [
+            {
+                key: CreateProjectCommand.BlankTemplateKey,
+                value: "@nativescript/template-blank-vue",
+                description: CreateProjectCommand.BlankTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.BlankTsTemplateKey,
+                value: "@nativescript/template-blank-vue-ts",
+                description: CreateProjectCommand.BlankTsTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.DrawerTemplateKey,
+                value: "@nativescript/template-drawer-navigation-vue",
+                description: CreateProjectCommand.DrawerTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.TabsTemplateKey,
+                value: "@nativescript/template-tab-navigation-vue",
+                description: CreateProjectCommand.TabsTemplateDescription,
+            },
+            {
+                key: CreateProjectCommand.BlankVisionTemplateKey,
+                value: "@nativescript/template-blank-vue-vision",
+                description: CreateProjectCommand.BlankVisionTemplateDescription,
+            },
+        ];
+        return templates;
+    }
+    postCommandAction(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { projectDir, projectName } = this.createdProjectData;
+            const relativePath = path.relative(process.cwd(), projectDir);
+            const greyDollarSign = color_1.color.grey("$");
+            this.$logger.clearScreen();
+            let runDebugNotes = [];
+            if (this.$options.vision ||
+                this.$options["vision-ng"] ||
+                this.$options["vision-react"] ||
+                this.$options["vision-solid"] ||
+                this.$options["vision-svelte"] ||
+                this.$options["vision-vue"]) {
+                runDebugNotes = [
+                    `Run the project on Vision Pro with:`,
+                    "",
+                    `  ${greyDollarSign} ${color_1.color.green("ns run visionos --no-hmr")}`,
+                ];
+            }
+            else {
+                runDebugNotes = [
+                    `Run the project on multiple devices:`,
+                    "",
+                    `  ${greyDollarSign} ${color_1.color.green("ns run ios")}`,
+                    `  ${greyDollarSign} ${color_1.color.green("ns run android")}`,
+                    "",
+                    "Debug the project with Chrome DevTools:",
+                    "",
+                    `  ${greyDollarSign} ${color_1.color.green("ns debug ios")}`,
+                    `  ${greyDollarSign} ${color_1.color.green("ns debug android")}`,
+                ];
+            }
+            this.$logger.info([
+                [
+                    color_1.color.green(`Project`),
+                    color_1.color.cyan(projectName),
+                    color_1.color.green(`was successfully created.`),
+                ].join(" "),
+                "",
+                `Now you can navigate to your project with ${color_1.color.cyan(`cd ${relativePath}`)} and then:`,
+                "",
+                ...runDebugNotes,
+                ``,
+                `For more options consult the docs or run ${color_1.color.green("ns --help")}`,
+                "",
+            ].join("\n"));
+        });
+    }
+}
+CreateProjectCommand.BlankTemplateKey = "Blank";
+CreateProjectCommand.BlankTemplateDescription = "A blank app";
+CreateProjectCommand.BlankTsTemplateKey = "Blank Typescript";
+CreateProjectCommand.BlankTsTemplateDescription = "A blank typescript app";
+CreateProjectCommand.BlankVisionTemplateKey = "visionOS";
+CreateProjectCommand.BlankVisionTemplateDescription = "A visionOS app";
+CreateProjectCommand.HelloWorldTemplateKey = "Hello World";
+CreateProjectCommand.HelloWorldTemplateDescription = "A Hello World app";
+CreateProjectCommand.DrawerTemplateKey = "SideDrawer";
+CreateProjectCommand.DrawerTemplateDescription = "An app with pre-built pages that uses a drawer for navigation";
+CreateProjectCommand.TabsTemplateKey = "Tabs";
+CreateProjectCommand.TabsTemplateDescription = "An app with pre-built pages that uses tabs for navigation";
+exports.CreateProjectCommand = CreateProjectCommand;
+yok_1.injector.registerCommand("create", CreateProjectCommand);

package/lib/commands/debug.js

@@ -0,0 +1,191 @@
+"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.DebugAndroidCommand = exports.DebugIOSCommand = exports.DebugPlatformCommand = void 0;
+const decorators_1 = require("../common/decorators");
+const command_base_1 = require("./command-base");
+const helpers_1 = require("../common/helpers");
+const constants_1 = require("../constants");
+const yok_1 = require("../common/yok");
+const _ = require("lodash");
+class DebugPlatformCommand extends command_base_1.ValidatePlatformCommandBase {
+    constructor(platform, $devicesService, $platformValidationService, $projectData, $options, $platformsDataService, $cleanupService, $logger, $errors, $debugDataService, $debugController, $liveSyncCommandHelper, $migrateController) {
+        super($options, $platformsDataService, $platformValidationService, $projectData);
+        this.platform = platform;
+        this.$devicesService = $devicesService;
+        this.$logger = $logger;
+        this.$errors = $errors;
+        this.$debugDataService = $debugDataService;
+        this.$debugController = $debugController;
+        this.$liveSyncCommandHelper = $liveSyncCommandHelper;
+        this.$migrateController = $migrateController;
+        this.allowedParameters = [];
+        $cleanupService.setShouldDispose(false);
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                platform: this.platform,
+                deviceId: this.$options.device,
+                emulator: this.$options.emulator,
+                skipDeviceDetectionInterval: true,
+            });
+            const selectedDeviceForDebug = yield this.$devicesService.pickSingleDevice({
+                onlyEmulators: this.$options.emulator,
+                onlyDevices: this.$options.forDevice,
+                deviceId: this.$options.device,
+            });
+            if (this.$options.start) {
+                const debugOptions = _.cloneDeep(this.$options.argv);
+                const debugData = this.$debugDataService.getDebugData(selectedDeviceForDebug.deviceInfo.identifier, this.$projectData, debugOptions);
+                yield this.$debugController.printDebugInformation(yield this.$debugController.startDebug(debugData));
+                return;
+            }
+            yield this.$liveSyncCommandHelper.executeLiveSyncOperation([selectedDeviceForDebug], this.platform, {
+                deviceDebugMap: {
+                    [selectedDeviceForDebug.deviceInfo.identifier]: true,
+                },
+                buildPlatform: undefined,
+                skipNativePrepare: false,
+            });
+        });
+    }
+    canExecute(args) {
+        const _super = Object.create(null, {
+            canExecuteCommandBase: { get: () => super.canExecuteCommandBase }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$options.force) {
+                yield this.$migrateController.validate({
+                    projectDir: this.$projectData.projectDir,
+                    platforms: [this.platform],
+                });
+            }
+            if (!this.$platformValidationService.isPlatformSupportedForOS(this.platform, this.$projectData)) {
+                this.$errors.fail(`Applications for platform ${this.platform} can not be built on this OS`);
+            }
+            if (this.$options.release) {
+                this.$errors.failWithHelp("--release flag is not applicable to this command.");
+            }
+            const result = yield _super.canExecuteCommandBase.call(this, this.platform, {
+                validateOptions: true,
+            });
+            return result;
+        });
+    }
+}
+exports.DebugPlatformCommand = DebugPlatformCommand;
+class DebugIOSCommand {
+    get debugPlatformCommand() {
+        return this.$injector.resolve(DebugPlatformCommand, {
+            platform: this.platform,
+        });
+    }
+    constructor($errors, $devicePlatformsConstants, $platformValidationService, $options, $injector, $sysInfo, $projectData, $iosDeviceOperations, $iOSSimulatorLogProvider) {
+        this.$errors = $errors;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$platformValidationService = $platformValidationService;
+        this.$options = $options;
+        this.$injector = $injector;
+        this.$sysInfo = $sysInfo;
+        this.$projectData = $projectData;
+        this.allowedParameters = [];
+        this.platform = this.$devicePlatformsConstants.iOS;
+        this.$projectData.initializeProjectData();
+        $iosDeviceOperations.setShouldDispose(false);
+        $iOSSimulatorLogProvider.setShouldDispose(false);
+    }
+    execute(args) {
+        return this.debugPlatformCommand.execute(args);
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$platformValidationService.isPlatformSupportedForOS(this.$devicePlatformsConstants.iOS, this.$projectData)) {
+                this.$errors.fail(`Applications for platform ${this.$devicePlatformsConstants.iOS} can not be built on this OS`);
+            }
+            const isValidTimeoutOption = this.isValidTimeoutOption();
+            if (!isValidTimeoutOption) {
+                this.$errors.fail(`Timeout option specifies the seconds NativeScript CLI will wait to find the inspector socket port from device's logs. Must be a number.`);
+            }
+            if (this.$options.inspector) {
+                const macOSWarning = yield this.$sysInfo.getMacOSWarningMessage();
+                if (macOSWarning &&
+                    macOSWarning.severity === "high") {
+                    this.$errors.fail(`You cannot use NativeScript Inspector on this OS. To use it, please update your OS.`);
+                }
+            }
+            const result = yield this.debugPlatformCommand.canExecute(args);
+            return result;
+        });
+    }
+    isValidTimeoutOption() {
+        if (!this.$options.timeout) {
+            return true;
+        }
+        const timeout = parseInt(this.$options.timeout, 10);
+        if (timeout === 0) {
+            return true;
+        }
+        if (!timeout) {
+            return false;
+        }
+        return true;
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], DebugIOSCommand.prototype, "debugPlatformCommand", null);
+exports.DebugIOSCommand = DebugIOSCommand;
+yok_1.injector.registerCommand("debug|ios", DebugIOSCommand);
+class DebugAndroidCommand {
+    get debugPlatformCommand() {
+        return this.$injector.resolve(DebugPlatformCommand, {
+            platform: this.platform,
+        });
+    }
+    constructor($errors, $devicePlatformsConstants, $injector, $projectData, $options) {
+        this.$errors = $errors;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$injector = $injector;
+        this.$projectData = $projectData;
+        this.$options = $options;
+        this.allowedParameters = [];
+        this.platform = this.$devicePlatformsConstants.Android;
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.debugPlatformCommand.execute(args);
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const canExecuteBase = yield this.debugPlatformCommand.canExecute(args);
+            if (canExecuteBase) {
+                if (this.$options.aab && !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
+                    this.$errors.failWithHelp(constants_1.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
+                }
+            }
+            return canExecuteBase;
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], DebugAndroidCommand.prototype, "debugPlatformCommand", null);
+exports.DebugAndroidCommand = DebugAndroidCommand;
+yok_1.injector.registerCommand("debug|android", DebugAndroidCommand);