nativescript 8.9.0-dev.1 → 8.9.0-dev.2

package/lib/commands/generate-assets.js

@@ -1,4 +1,13 @@
 "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.GenerateSplashScreensCommand = exports.GenerateIconsCommand = exports.GenerateCommandBase = void 0;
 const yok_1 = require("../common/yok");
@@ -14,9 +23,11 @@ class GenerateCommandBase {
         ];
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        const [imagePath] = args;
-        await this.generate(imagePath, this.$options.background);
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [imagePath] = args;
+            yield this.generate(imagePath, this.$options.background);
+        });
     }
 }
 exports.GenerateCommandBase = GenerateCommandBase;
@@ -27,11 +38,13 @@ class GenerateIconsCommand extends GenerateCommandBase {
         this.$projectData = $projectData;
         this.$stringParameterBuilder = $stringParameterBuilder;
     }
-    async generate(imagePath, background) {
-        await this.$assetsGenerationService.generateIcons({
-            imagePath,
-            background,
-            projectDir: this.$projectData.projectDir,
+    generate(imagePath, background) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$assetsGenerationService.generateIcons({
+                imagePath,
+                background,
+                projectDir: this.$projectData.projectDir,
+            });
         });
     }
 }
@@ -44,13 +57,16 @@ class GenerateSplashScreensCommand extends GenerateCommandBase {
         this.$projectData = $projectData;
         this.$stringParameterBuilder = $stringParameterBuilder;
     }
-    async generate(imagePath, background) {
-        await this.$assetsGenerationService.generateSplashScreens({
-            imagePath,
-            background,
-            projectDir: this.$projectData.projectDir,
+    generate(imagePath, background) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$assetsGenerationService.generateSplashScreens({
+                imagePath,
+                background,
+                projectDir: this.$projectData.projectDir,
+            });
         });
     }
 }
 exports.GenerateSplashScreensCommand = GenerateSplashScreensCommand;
 yok_1.injector.registerCommand("resources|generate|splashes", GenerateSplashScreensCommand);
+//# sourceMappingURL=generate-assets.js.map

package/lib/commands/generate-help.js

@@ -1,4 +1,13 @@
 "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.GenerateHelpCommand = void 0;
 const yok_1 = require("../common/yok");
@@ -7,9 +16,12 @@ class GenerateHelpCommand {
         this.$helpService = $helpService;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        return this.$helpService.generateHtmlPages();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$helpService.generateHtmlPages();
+        });
     }
 }
 exports.GenerateHelpCommand = GenerateHelpCommand;
 yok_1.injector.registerCommand("dev-generate-help", GenerateHelpCommand);
+//# sourceMappingURL=generate-help.js.map

package/lib/commands/generate.js

@@ -1,30 +1,88 @@
 "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.GenerateCommand = void 0;
+const schematics_executor_1 = require("@nativescript/schematics-executor");
 const yok_1 = require("../common/yok");
 class GenerateCommand {
-    constructor($logger, $errors) {
+    constructor($logger, $options, $errors) {
         this.$logger = $logger;
+        this.$options = $options;
         this.$errors = $errors;
         this.allowedParameters = [];
     }
-    async execute(_rawArgs) {
-        try {
-            this.$logger.info("If you have ideas for this command, please discuss at https://nativescript.org/discord");
-        }
-        catch (error) {
-            this.$errors.fail(error.message);
-        }
+    execute(_rawArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield (0, schematics_executor_1.run)(this.executionOptions);
+            }
+            catch (error) {
+                this.$errors.fail(error.message);
+            }
+        });
     }
-    async canExecute(rawArgs) {
-        this.setExecutionOptions(rawArgs);
-        this.validateExecutionOptions();
-        return true;
+    canExecute(rawArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setExecutionOptions(rawArgs);
+            this.validateExecutionOptions();
+            return true;
+        });
     }
     validateExecutionOptions() {
+        if (!this.executionOptions.schematic) {
+            this.$errors.failWithHelp(`The generate command requires a schematic name to be specified.`);
+        }
     }
     setExecutionOptions(rawArgs) {
+        const options = this.parseRawArgs(rawArgs);
+        this.executionOptions = Object.assign(Object.assign({}, options), { logger: this.$logger, directory: process.cwd() });
+    }
+    parseRawArgs(rawArgs) {
+        const collection = this.$options.collection;
+        const schematic = rawArgs.shift();
+        const { options, args } = parseSchematicSettings(rawArgs);
+        return {
+            collection,
+            schematic,
+            schematicOptions: options,
+            schematicArgs: args,
+        };
     }
 }
 exports.GenerateCommand = GenerateCommand;
+/**
+ * Converts an array of command line arguments to options for the executed schematic.
+ * @param rawArgs The command line arguments. They should be in the format 'key=value' for strings or 'key' for booleans.
+ */
+function parseSchematicSettings(rawArgs) {
+    const [optionStrings, args] = partition(rawArgs, (item) => item.includes("="));
+    const options = optionStrings
+        .map((o) => o.split("=")) // split to key and value pairs
+        .map(([key, ...value]) => [key, value.join("=")]) // concat the value arrays if there are multiple = signs
+        .reduce((obj, [key, value]) => {
+        return Object.assign(Object.assign({}, obj), { [key]: value });
+    }, {});
+    return { options, args };
+}
+/**
+ * Splits an array into two groups based on a predicate.
+ * @param array The array to split.
+ * @param predicate The condition to be used for splitting.
+ */
+function partition(array, predicate) {
+    return array.reduce(([pass, fail], item) => {
+        return predicate(item)
+            ? [[...pass, item], fail]
+            : [pass, [...fail, item]];
+    }, [[], []]);
+}
 yok_1.injector.registerCommand("generate", GenerateCommand);
+//# sourceMappingURL=generate.js.map

package/lib/commands/info.js

@@ -1,4 +1,13 @@
 "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.InfoCommand = void 0;
 const yok_1 = require("../common/yok");
@@ -7,9 +16,12 @@ class InfoCommand {
         this.$infoService = $infoService;
         this.allowedParameters = [];
     }
-    async execute(args) {
-        return this.$infoService.printComponentsInfo();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$infoService.printComponentsInfo();
+        });
     }
 }
 exports.InfoCommand = InfoCommand;
 yok_1.injector.registerCommand("info", InfoCommand);
+//# sourceMappingURL=info.js.map

package/lib/commands/install.js

@@ -1,4 +1,13 @@
 "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.InstallCommand = void 0;
 const os_1 = require("os");
@@ -20,46 +29,53 @@ class InstallCommand {
         this.allowedParameters = [this.$stringParameter];
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        return args[0]
-            ? this.installModule(args[0])
-            : this.installProjectDependencies();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return args[0]
+                ? this.installModule(args[0])
+                : this.installProjectDependencies();
+        });
     }
-    async installProjectDependencies() {
-        let error = "";
-        await this.$pluginsService.ensureAllDependenciesAreInstalled(this.$projectData);
-        for (const platform of this.$mobileHelper.platformNames) {
-            const platformData = this.$platformsDataService.getPlatformData(platform, this.$projectData);
-            const frameworkPackageData = this.$projectDataService.getRuntimePackage(this.$projectData.projectDir, platformData.platformNameLowerCase);
-            if (frameworkPackageData && frameworkPackageData.version) {
-                try {
-                    const platformProjectService = platformData.platformProjectService;
-                    await platformProjectService.validate(this.$projectData, this.$options);
-                    await this.$platformCommandHelper.addPlatforms([`${platform}@${frameworkPackageData.version}`], this.$projectData, this.$options.frameworkPath);
-                }
-                catch (err) {
-                    error = `${error}${os_1.EOL}${err}`;
+    installProjectDependencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let error = "";
+            yield this.$pluginsService.ensureAllDependenciesAreInstalled(this.$projectData);
+            for (const platform of this.$mobileHelper.platformNames) {
+                const platformData = this.$platformsDataService.getPlatformData(platform, this.$projectData);
+                const frameworkPackageData = this.$projectDataService.getRuntimePackage(this.$projectData.projectDir, platformData.platformNameLowerCase);
+                if (frameworkPackageData && frameworkPackageData.version) {
+                    try {
+                        const platformProjectService = platformData.platformProjectService;
+                        yield platformProjectService.validate(this.$projectData, this.$options);
+                        yield this.$platformCommandHelper.addPlatforms([`${platform}@${frameworkPackageData.version}`], this.$projectData, this.$options.frameworkPath);
+                    }
+                    catch (err) {
+                        error = `${error}${os_1.EOL}${err}`;
+                    }
                 }
             }
-        }
-        if (error) {
-            this.$logger.error(error);
-        }
+            if (error) {
+                this.$logger.error(error);
+            }
+        });
     }
-    async installModule(moduleName) {
-        const projectDir = this.$projectData.projectDir;
-        const devPrefix = "nativescript-dev-";
-        if (!this.$fs.exists(moduleName) && moduleName.indexOf(devPrefix) !== 0) {
-            moduleName = devPrefix + moduleName;
-        }
-        await this.$packageManager.install(moduleName, projectDir, {
-            "save-dev": true,
-            disableNpmInstall: this.$options.disableNpmInstall,
-            frameworkPath: this.$options.frameworkPath,
-            ignoreScripts: this.$options.ignoreScripts,
-            path: this.$options.path,
+    installModule(moduleName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectDir = this.$projectData.projectDir;
+            const devPrefix = "nativescript-dev-";
+            if (!this.$fs.exists(moduleName) && moduleName.indexOf(devPrefix) !== 0) {
+                moduleName = devPrefix + moduleName;
+            }
+            yield this.$packageManager.install(moduleName, projectDir, {
+                "save-dev": true,
+                disableNpmInstall: this.$options.disableNpmInstall,
+                frameworkPath: this.$options.frameworkPath,
+                ignoreScripts: this.$options.ignoreScripts,
+                path: this.$options.path,
+            });
         });
     }
 }
 exports.InstallCommand = InstallCommand;
 yok_1.injector.registerCommand("install", InstallCommand);
+//# sourceMappingURL=install.js.map

package/lib/commands/list-platforms.js

@@ -1,4 +1,13 @@
 "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.ListPlatformsCommand = void 0;
 const helpers = require("../common/helpers");
@@ -11,24 +20,27 @@ class ListPlatformsCommand {
         this.allowedParameters = [];
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        const installedPlatforms = this.$platformCommandHelper.getInstalledPlatforms(this.$projectData);
-        if (installedPlatforms.length > 0) {
-            const preparedPlatforms = this.$platformCommandHelper.getPreparedPlatforms(this.$projectData);
-            if (preparedPlatforms.length > 0) {
-                this.$logger.info("The project is prepared for: ", helpers.formatListOfNames(preparedPlatforms, "and"));
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const installedPlatforms = this.$platformCommandHelper.getInstalledPlatforms(this.$projectData);
+            if (installedPlatforms.length > 0) {
+                const preparedPlatforms = this.$platformCommandHelper.getPreparedPlatforms(this.$projectData);
+                if (preparedPlatforms.length > 0) {
+                    this.$logger.info("The project is prepared for: ", helpers.formatListOfNames(preparedPlatforms, "and"));
+                }
+                else {
+                    this.$logger.info("The project is not prepared for any platform");
+                }
+                this.$logger.info("Installed platforms: ", helpers.formatListOfNames(installedPlatforms, "and"));
             }
             else {
-                this.$logger.info("The project is not prepared for any platform");
+                const formattedPlatformsList = helpers.formatListOfNames(this.$platformCommandHelper.getAvailablePlatforms(this.$projectData), "and");
+                this.$logger.info("Available platforms for this OS: ", formattedPlatformsList);
+                this.$logger.info("No installed platforms found. Use $ ns platform add");
             }
-            this.$logger.info("Installed platforms: ", helpers.formatListOfNames(installedPlatforms, "and"));
-        }
-        else {
-            const formattedPlatformsList = helpers.formatListOfNames(this.$platformCommandHelper.getAvailablePlatforms(this.$projectData), "and");
-            this.$logger.info("Available platforms for this OS: ", formattedPlatformsList);
-            this.$logger.info("No installed platforms found. Use $ ns platform add");
-        }
+        });
     }
 }
 exports.ListPlatformsCommand = ListPlatformsCommand;
 yok_1.injector.registerCommand("platform|*list", ListPlatformsCommand);
+//# sourceMappingURL=list-platforms.js.map

package/lib/commands/migrate.js

@@ -1,4 +1,13 @@
 "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.MigrateCommand = void 0;
 const yok_1 = require("../common/yok");
@@ -12,22 +21,25 @@ class MigrateCommand {
         this.allowedParameters = [];
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        const migrationData = {
-            projectDir: this.$projectData.projectDir,
-            platforms: [
-                this.$devicePlatformsConstants.Android,
-                this.$devicePlatformsConstants.iOS,
-            ],
-        };
-        const shouldMigrateResult = await this.$migrateController.shouldMigrate(migrationData);
-        if (!shouldMigrateResult) {
-            const cliVersion = this.$staticConfig.version;
-            this.$logger.printMarkdown(`__Project is compatible with NativeScript \`v${cliVersion}\`__`);
-            return;
-        }
-        await this.$migrateController.migrate(migrationData);
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const migrationData = {
+                projectDir: this.$projectData.projectDir,
+                platforms: [
+                    this.$devicePlatformsConstants.Android,
+                    this.$devicePlatformsConstants.iOS,
+                ],
+            };
+            const shouldMigrateResult = yield this.$migrateController.shouldMigrate(migrationData);
+            if (!shouldMigrateResult) {
+                const cliVersion = this.$staticConfig.version;
+                this.$logger.printMarkdown(`__Project is compatible with NativeScript \`v${cliVersion}\`__`);
+                return;
+            }
+            yield this.$migrateController.migrate(migrationData);
+        });
     }
 }
 exports.MigrateCommand = MigrateCommand;
 yok_1.injector.registerCommand("migrate", MigrateCommand);
+//# sourceMappingURL=migrate.js.map

package/lib/commands/native-add.js

@@ -1,4 +1,13 @@
 "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.NativeAddSwiftCommand = exports.NativeAddObjectiveCCommand = exports.NativeAddKotlinCommand = exports.NativeAddJavaCommand = exports.NativeAddAndroidCommand = exports.NativeAddSingleCommand = exports.NativeAddCommand = void 0;
 const fs = require("fs");
@@ -14,16 +23,20 @@ class NativeAddCommand {
         this.allowedParameters = [];
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        this.failWithUsage();
-        return Promise.resolve();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.failWithUsage();
+            return Promise.resolve();
+        });
     }
     failWithUsage() {
         this.$errors.failWithHelp("Usage: ns native add [swift|objective-c|java|kotlin] [class name]");
     }
-    async canExecute(args) {
-        this.failWithUsage();
-        return false;
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.failWithUsage();
+            return false;
+        });
     }
     getIosSourcePathBase() {
         const resources = this.$projectData.getAppResourcesDirectoryPath();
@@ -39,11 +52,13 @@ class NativeAddSingleCommand extends NativeAddCommand {
     constructor($projectData, $logger, $errors) {
         super($projectData, $logger, $errors);
     }
-    async canExecute(args) {
-        if (!args || args.length !== 1) {
-            this.failWithUsage();
-        }
-        return true;
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args || args.length !== 1) {
+                this.failWithUsage();
+            }
+            return true;
+        });
     }
 }
 exports.NativeAddSingleCommand = NativeAddSingleCommand;
@@ -144,9 +159,11 @@ class NativeAddJavaCommand extends NativeAddAndroidCommand {
     constructor($projectData, $logger, $errors) {
         super($projectData, $logger, $errors);
     }
-    async execute(args) {
-        this.doJavaKotlin(args[0], "java");
-        return Promise.resolve();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.doJavaKotlin(args[0], "java");
+            return Promise.resolve();
+        });
     }
 }
 exports.NativeAddJavaCommand = NativeAddJavaCommand;
@@ -154,9 +171,11 @@ class NativeAddKotlinCommand extends NativeAddAndroidCommand {
     constructor($projectData, $logger, $errors) {
         super($projectData, $logger, $errors);
     }
-    async execute(args) {
-        this.doJavaKotlin(args[0], "kotlin");
-        return Promise.resolve();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.doJavaKotlin(args[0], "kotlin");
+            return Promise.resolve();
+        });
     }
 }
 exports.NativeAddKotlinCommand = NativeAddKotlinCommand;
@@ -164,15 +183,18 @@ class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
     constructor($projectData, $logger, $errors) {
         super($projectData, $logger, $errors);
     }
-    async execute(args) {
-        this.doObjectiveC(args[0]);
-        return Promise.resolve();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.doObjectiveC(args[0]);
+            return Promise.resolve();
+        });
     }
     doObjectiveC(className) {
         const iosSourceBase = this.getIosSourcePathBase();
         const classFilePath = path.join(iosSourceBase, `${className}.m`);
         const headerFilePath = path.join(iosSourceBase, `${className}.h`);
         if (this.generateObjectiveCFiles(className, classFilePath, headerFilePath)) {
+            // Modify/Generate moduleMap
             this.generateOrUpdateModuleMap(`${className}.h`, path.join(iosSourceBase, "module.modulemap"));
         }
     }
@@ -185,7 +207,9 @@ class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
         }
         const headerDeclaration = `header "${headerPath}"`;
         if (moduleMapContent.includes(`module ${moduleName}`)) {
+            // Module declaration already exists in the module map
             if (moduleMapContent.includes(headerDeclaration)) {
+                // Header is already present in the module map
                 this.$logger.warn(`Header '${headerFileName}' is already added to the module map.`);
                 return;
             }
@@ -193,6 +217,7 @@ class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
             fs.writeFileSync(moduleMapPath, updatedModuleMapContent);
         }
         else {
+            // Module declaration does not exist in the module map
             const moduleDeclaration = `module ${moduleName} {${os_1.EOL}    ${headerDeclaration}${os_1.EOL}    export *${os_1.EOL}}`;
             moduleMapContent += `${os_1.EOL}${os_1.EOL}${moduleDeclaration}`;
             fs.writeFileSync(moduleMapPath, moduleMapContent);
@@ -238,9 +263,11 @@ class NativeAddSwiftCommand extends NativeAddSingleCommand {
     constructor($projectData, $logger, $errors) {
         super($projectData, $logger, $errors);
     }
-    async execute(args) {
-        this.doSwift(args[0]);
-        return Promise.resolve();
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.doSwift(args[0]);
+            return Promise.resolve();
+        });
     }
     doSwift(className) {
         const iosSourceBase = this.getIosSourcePathBase();
@@ -275,3 +302,4 @@ yok_1.injector.registerCommand(["native|add|java"], NativeAddJavaCommand);
 yok_1.injector.registerCommand(["native|add|kotlin"], NativeAddKotlinCommand);
 yok_1.injector.registerCommand(["native|add|swift"], NativeAddSwiftCommand);
 yok_1.injector.registerCommand(["native|add|objective-c"], NativeAddObjectiveCCommand);
+//# sourceMappingURL=native-add.js.map