@akylas/nativescript-cli 8.7.2 → 8.8.3

package/lib/commands/generate-help.js

@@ -1,13 +1,4 @@
 "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");
@@ -16,10 +7,8 @@ class GenerateHelpCommand {
         this.$helpService = $helpService;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$helpService.generateHtmlPages();
-        });
+    async execute(args) {
+        return this.$helpService.generateHtmlPages();
     }
 }
 exports.GenerateHelpCommand = GenerateHelpCommand;

package/lib/commands/generate.js

@@ -1,13 +1,4 @@
 "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");
@@ -19,22 +10,18 @@ class GenerateCommand {
         this.$errors = $errors;
         this.allowedParameters = [];
     }
-    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 execute(_rawArgs) {
+        try {
+            await (0, schematics_executor_1.run)(this.executionOptions);
+        }
+        catch (error) {
+            this.$errors.fail(error.message);
+        }
     }
-    canExecute(rawArgs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.setExecutionOptions(rawArgs);
-            this.validateExecutionOptions();
-            return true;
-        });
+    async canExecute(rawArgs) {
+        this.setExecutionOptions(rawArgs);
+        this.validateExecutionOptions();
+        return true;
     }
     validateExecutionOptions() {
         if (!this.executionOptions.schematic) {
@@ -43,7 +30,11 @@ class GenerateCommand {
     }
     setExecutionOptions(rawArgs) {
         const options = this.parseRawArgs(rawArgs);
-        this.executionOptions = Object.assign(Object.assign({}, options), { logger: this.$logger, directory: process.cwd() });
+        this.executionOptions = {
+            ...options,
+            logger: this.$logger,
+            directory: process.cwd(),
+        };
     }
     parseRawArgs(rawArgs) {
         const collection = this.$options.collection;
@@ -64,7 +55,7 @@ function parseSchematicSettings(rawArgs) {
         .map((o) => o.split("="))
         .map(([key, ...value]) => [key, value.join("=")])
         .reduce((obj, [key, value]) => {
-        return Object.assign(Object.assign({}, obj), { [key]: value });
+        return { ...obj, [key]: value };
     }, {});
     return { options, args };
 }

package/lib/commands/info.js

@@ -1,13 +1,4 @@
 "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");
@@ -16,10 +7,8 @@ class InfoCommand {
         this.$infoService = $infoService;
         this.allowedParameters = [];
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$infoService.printComponentsInfo();
-        });
+    async execute(args) {
+        return this.$infoService.printComponentsInfo();
     }
 }
 exports.InfoCommand = InfoCommand;

package/lib/commands/install.js

@@ -1,13 +1,4 @@
 "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");
@@ -29,50 +20,44 @@ class InstallCommand {
         this.allowedParameters = [this.$stringParameter];
         this.$projectData.initializeProjectData();
     }
-    execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return args[0]
-                ? this.installModule(args[0])
-                : this.installProjectDependencies();
-        });
+    async execute(args) {
+        return args[0]
+            ? this.installModule(args[0])
+            : this.installProjectDependencies();
     }
-    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}`;
-                    }
+    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}`;
                 }
             }
-            if (error) {
-                this.$logger.error(error);
-            }
-        });
+        }
+        if (error) {
+            this.$logger.error(error);
+        }
     }
-    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,
-            });
+    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,
         });
     }
 }

package/lib/commands/list-platforms.js

@@ -1,13 +1,4 @@
 "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");
@@ -20,25 +11,23 @@ class ListPlatformsCommand {
         this.allowedParameters = [];
         this.$projectData.initializeProjectData();
     }
-    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"));
+    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"));
             }
             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");
+                this.$logger.info("The project is not prepared for any platform");
             }
-        });
+            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;

package/lib/commands/migrate.js

@@ -1,13 +1,4 @@
 "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");
@@ -21,23 +12,21 @@ class MigrateCommand {
         this.allowedParameters = [];
         this.$projectData.initializeProjectData();
     }
-    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);
-        });
+    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);
     }
 }
 exports.MigrateCommand = MigrateCommand;

package/lib/commands/native-add.js

@@ -0,0 +1,277 @@
+"use strict";
+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");
+const path = require("path");
+const yok_1 = require("../common/yok");
+const utils_1 = require("../common/utils");
+const os_1 = require("os");
+class NativeAddCommand {
+    constructor($projectData, $logger, $errors) {
+        this.$projectData = $projectData;
+        this.$logger = $logger;
+        this.$errors = $errors;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    async execute(args) {
+        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;
+    }
+    getIosSourcePathBase() {
+        const resources = this.$projectData.getAppResourcesDirectoryPath();
+        return path.join(resources, "iOS", "src");
+    }
+    getAndroidSourcePathBase() {
+        const resources = this.$projectData.getAppResourcesDirectoryPath();
+        return path.join(resources, "Android", "src", "main", "java");
+    }
+}
+exports.NativeAddCommand = NativeAddCommand;
+class NativeAddSingleCommand extends NativeAddCommand {
+    constructor($projectData, $logger, $errors) {
+        super($projectData, $logger, $errors);
+    }
+    async canExecute(args) {
+        if (!args || args.length !== 1) {
+            this.failWithUsage();
+        }
+        return true;
+    }
+}
+exports.NativeAddSingleCommand = NativeAddSingleCommand;
+class NativeAddAndroidCommand extends NativeAddSingleCommand {
+    constructor($projectData, $logger, $errors) {
+        super($projectData, $logger, $errors);
+    }
+    getPackageName(className) {
+        const lastDotIndex = className.lastIndexOf(".");
+        if (lastDotIndex !== -1) {
+            return className.substring(0, lastDotIndex);
+        }
+        return "";
+    }
+    getClassSimpleName(className) {
+        const lastDotIndex = className.lastIndexOf(".");
+        if (lastDotIndex !== -1) {
+            return className.substring(lastDotIndex + 1);
+        }
+        return className;
+    }
+    generateJavaClassContent(packageName, classSimpleName) {
+        return ((packageName.length > 0 ? `package ${packageName};` : "") +
+            `
+import android.util.Log;
+
+public class ${classSimpleName} {
+    public void logMessage() {
+        Log.d("JS", "Hello from ${classSimpleName}!");
+    }
+}
+`);
+    }
+    generateKotlinClassContent(packageName, classSimpleName) {
+        return ((packageName.length > 0 ? `package ${packageName};` : "") +
+            `
+
+import android.util.Log
+
+class ${classSimpleName} {
+    fun logMessage() {
+        Log.d("JS", "Hello from ${classSimpleName}!")
+    }
+}
+`);
+    }
+    doJavaKotlin(className, extension) {
+        const fileExt = extension == "java" ? extension : "kt";
+        const packageName = this.getPackageName(className);
+        const classSimpleName = this.getClassSimpleName(className);
+        const packagePath = path.join(this.getAndroidSourcePathBase(), ...packageName.split("."));
+        const filePath = path.join(packagePath, `${classSimpleName}.${fileExt}`);
+        if (fs.existsSync(filePath)) {
+            this.$errors.failWithHelp(`${extension} file '${filePath}' already exists.`);
+            return;
+        }
+        if (extension == "kotlin" && !this.checkAndUpdateGradleProperties()) {
+            return;
+        }
+        const fileContent = extension == "java"
+            ? this.generateJavaClassContent(packageName, classSimpleName)
+            : this.generateKotlinClassContent(packageName, classSimpleName);
+        fs.mkdirSync(packagePath, { recursive: true });
+        fs.writeFileSync(filePath, fileContent);
+        this.$logger.info(`${(0, utils_1.capitalizeFirstLetter)(extension)} file '${filePath}' generated successfully.`);
+    }
+    checkAndUpdateGradleProperties() {
+        const resources = this.$projectData.getAppResourcesDirectoryPath();
+        const filePath = path.join(resources, "Android", "gradle.properties");
+        if (fs.existsSync(filePath)) {
+            const fileContent = fs.readFileSync(filePath, "utf8");
+            const propertyRegex = /^useKotlin\s*=\s*(true|false)$/m;
+            const match = propertyRegex.exec(fileContent);
+            if (match) {
+                const useKotlin = match[1];
+                if (useKotlin === "false") {
+                    this.$errors.failWithHelp("The useKotlin property is set to false. Stopping processing. Kotlin must be enabled in gradle.properties to use.");
+                    return false;
+                }
+                if (useKotlin === "true") {
+                    return true;
+                }
+            }
+            else {
+                fs.appendFileSync(filePath, `${os_1.EOL}useKotlin=true${os_1.EOL}`);
+                this.$logger.info('Added "useKotlin=true" property to gradle.properties.');
+            }
+        }
+        else {
+            fs.writeFileSync(filePath, `useKotlin=true${os_1.EOL}`);
+            this.$logger.info('Created gradle.properties with "useKotlin=true" property.');
+        }
+        return true;
+    }
+}
+exports.NativeAddAndroidCommand = NativeAddAndroidCommand;
+class NativeAddJavaCommand extends NativeAddAndroidCommand {
+    constructor($projectData, $logger, $errors) {
+        super($projectData, $logger, $errors);
+    }
+    async execute(args) {
+        this.doJavaKotlin(args[0], "java");
+        return Promise.resolve();
+    }
+}
+exports.NativeAddJavaCommand = NativeAddJavaCommand;
+class NativeAddKotlinCommand extends NativeAddAndroidCommand {
+    constructor($projectData, $logger, $errors) {
+        super($projectData, $logger, $errors);
+    }
+    async execute(args) {
+        this.doJavaKotlin(args[0], "kotlin");
+        return Promise.resolve();
+    }
+}
+exports.NativeAddKotlinCommand = NativeAddKotlinCommand;
+class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
+    constructor($projectData, $logger, $errors) {
+        super($projectData, $logger, $errors);
+    }
+    async execute(args) {
+        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)) {
+            this.generateOrUpdateModuleMap(`${className}.h`, path.join(iosSourceBase, "module.modulemap"));
+        }
+    }
+    generateOrUpdateModuleMap(headerFileName, moduleMapPath) {
+        const moduleName = "LocalModule";
+        const headerPath = headerFileName;
+        let moduleMapContent = "";
+        if (fs.existsSync(moduleMapPath)) {
+            moduleMapContent = fs.readFileSync(moduleMapPath, "utf8");
+        }
+        const headerDeclaration = `header "${headerPath}"`;
+        if (moduleMapContent.includes(`module ${moduleName}`)) {
+            if (moduleMapContent.includes(headerDeclaration)) {
+                this.$logger.warn(`Header '${headerFileName}' is already added to the module map.`);
+                return;
+            }
+            const updatedModuleMapContent = moduleMapContent.replace(new RegExp(`module ${moduleName} {\\s*([^}]*)\\s*}`, "s"), `module ${moduleName} {${os_1.EOL}    $1${os_1.EOL}    ${headerDeclaration}${os_1.EOL}}`);
+            fs.writeFileSync(moduleMapPath, updatedModuleMapContent);
+        }
+        else {
+            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);
+        }
+        this.$logger.info(`Module map '${moduleMapPath}' has been updated with the header '${headerFileName}'.`);
+    }
+    generateObjectiveCFiles(className, classFilePath, interfaceFilePath) {
+        if (fs.existsSync(classFilePath)) {
+            this.$errors.failWithHelp(`Error: File '${classFilePath}' already exists.`);
+            return false;
+        }
+        if (fs.existsSync(interfaceFilePath)) {
+            this.$errors.failWithHelp(`Error: File '${interfaceFilePath}' already exists.`);
+            return false;
+        }
+        const interfaceContent = `#import <Foundation/Foundation.h>
+
+@interface ${className} : NSObject
+
+- (void)logMessage;
+
+@end
+`;
+        const classContent = `#import "${className}.h"
+
+@implementation ${className}
+
+- (void)logMessage {
+    NSLog(@"Hello from ${className} class!");
+}
+
+@end
+`;
+        fs.writeFileSync(classFilePath, classContent);
+        this.$logger.trace(`Objective-C class file '${classFilePath}' generated successfully.`);
+        fs.writeFileSync(interfaceFilePath, interfaceContent);
+        this.$logger.trace(`Objective-C interface file '${interfaceFilePath}' generated successfully.`);
+        return true;
+    }
+}
+exports.NativeAddObjectiveCCommand = NativeAddObjectiveCCommand;
+class NativeAddSwiftCommand extends NativeAddSingleCommand {
+    constructor($projectData, $logger, $errors) {
+        super($projectData, $logger, $errors);
+    }
+    async execute(args) {
+        this.doSwift(args[0]);
+        return Promise.resolve();
+    }
+    doSwift(className) {
+        const iosSourceBase = this.getIosSourcePathBase();
+        const swiftFilePath = path.join(iosSourceBase, `${className}.swift`);
+        this.generateSwiftFile(className, swiftFilePath);
+    }
+    generateSwiftFile(className, filePath) {
+        const directory = path.dirname(filePath);
+        if (!fs.existsSync(directory)) {
+            fs.mkdirSync(directory, { recursive: true });
+            this.$logger.trace(`Created directory: '${directory}'.`);
+        }
+        if (fs.existsSync(filePath)) {
+            this.$errors.failWithHelp(`Error: File '${filePath}' already exists.`);
+            return;
+        }
+        const content = `import Foundation;
+import os;		
+
+@objc class ${className}: NSObject {
+	@objc func logMessage() {
+		os_log("Hello from ${className} class!")
+	}
+}`;
+        fs.writeFileSync(filePath, content);
+        this.$logger.info(`Swift file '${filePath}' generated successfully.`);
+    }
+}
+exports.NativeAddSwiftCommand = NativeAddSwiftCommand;
+yok_1.injector.registerCommand(["native|add"], NativeAddCommand);
+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);