@akylas/nativescript-cli 8.7.2 → 8.8.2

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

@@ -1 +1 @@
-{"@jsdevtools/coverage-istanbul-loader":"3.0.5","karma":"6.4.3","karma-coverage":"2.2.1","karma-nativescript-launcher":"0.4.0","mocha":"10.4.0","karma-mocha":"2.0.1","karma-chai":"0.1.0","karma-jasmine":"4.0.2","karma-qunit":"4.2.0","@types/karma-chai":"0.1.6","@types/mocha":"10.0.6","@types/jasmine":"5.1.4","@types/qunit":"2.19.10","nyc":"15.1.0"}
+{"@jsdevtools/coverage-istanbul-loader":"3.0.5","karma":"6.4.4","karma-coverage":"2.2.1","karma-nativescript-launcher":"0.4.0","mocha":"10.7.3","karma-mocha":"2.0.1","karma-chai":"0.1.0","karma-jasmine":"4.0.2","karma-qunit":"4.2.1","@types/karma-chai":"0.1.7","@types/mocha":"10.0.9","@types/jasmine":"5.1.4","@types/qunit":"2.19.10","nyc":"17.1.0"}

package/docs/man_pages/project/configuration/native/native-add-java.md

@@ -0,0 +1,32 @@
+<% if (isJekyll) { %>---
+title: ns native add java
+position: 2
+---<% } %>
+
+# ns native add java
+
+### Description
+
+Adds a newly generated Java file, which includes a class with the specified name, placing it in the appropriate directory.
+
+### Commands
+
+Usage | Synopsis
+------|-------
+Java | `$ ns native add java <Java class name>`
+
+### Arguments
+
+* `<Java class name>` is the fully qualified name of the `Class` to create, e.g. `org.nativescript.SomeClass`
+
+<% if(isHtml) { %>
+
+### Related Commands
+
+Command | Description
+----------|----------
+[native add swift](native-add-swift.html) | Generates and adds a Swift file containing a class of the given name.
+[native add objective-c](native-add-objective-c.html) | Generates and adds Objective-C files containing an interface of the given name.
+[native add java](native-add-java.html) | Generates and adds a Java file containing a class of the given name.
+[native add kotlin](native-add-kotlin.html) | Generates and adds a Kotlin file containing a class of the given name.
+<% } %>

package/docs/man_pages/project/configuration/native/native-add-kotlin.md

@@ -0,0 +1,34 @@
+<% if (isJekyll) { %>---
+title: ns native add kotlin
+position: 3
+---<% } %>
+
+# ns native add kotlin
+
+### Description
+
+Adds a newly generated Kotlin file, which includes a class with the specified name, placing it in the appropriate directory.
+
+Kotlin usage requires that the `useKotlin` property is set in `gradle.properties`, the command will set this to `true`.
+
+### Commands
+
+Usage | Synopsis
+------|-------
+Kotlin | `$ ns native add kotlin <Kotlin class name>`
+
+### Arguments
+
+* `<Kotlin class name>` is the fully qualified name of the `Class` to create, e.g. `org.nativescript.SomeClass`
+
+<% if(isHtml) { %>
+
+### Related Commands
+
+Command | Description
+----------|----------
+[native add swift](native-add-swift.html) | Generates and adds a Swift file containing a class of the given name.
+[native add objective-c](native-add-objective-c.html) | Generates and adds Objective-C files containing an interface of the given name.
+[native add java](native-add-java.html) | Generates and adds a Java file containing a class of the given name.
+[native add kotlin](native-add-kotlin.html) | Generates and adds a Kotlin file containing a class of the given name.
+<% } %>

package/docs/man_pages/project/configuration/native/native-add-objective-c.md

@@ -0,0 +1,34 @@
+<% if (isJekyll) { %>---
+title: ns native add objective-c
+position: 4
+---<% } %>
+
+# ns native add objective-c
+
+### Description
+
+Adds newly generated Objective-C files, which include an interface with the specified name, placing them in the appropriate directory.
+
+Objective-C usage requires that the `module.modulemap` is modified to include the header file, the command will set this entry.
+
+### Commands
+
+Usage | Synopsis
+------|-------
+Objective-C | `$ ns native add objective-c <Objective-C interface name>`
+
+### Arguments
+
+* `<Objective-C interface name>` is the name of the `interface` to create, e.g. `SomeInterface`
+
+<% if(isHtml) { %>
+
+### Related Commands
+
+Command | Description
+----------|----------
+[native add swift](native-add-swift.html) | Generates and adds a Swift file containing a class of the given name.
+[native add objective-c](native-add-objective-c.html) | Generates and adds Objective-C files containing an interface of the given name.
+[native add java](native-add-java.html) | Generates and adds a Java file containing a class of the given name.
+[native add kotlin](native-add-kotlin.html) | Generates and adds a Kotlin file containing a class of the given name.
+<% } %>

package/docs/man_pages/project/configuration/native/native-add-swift.md

@@ -0,0 +1,32 @@
+<% if (isJekyll) { %>---
+title: ns native add swift
+position: 5
+---<% } %>
+
+# ns native add swift
+
+### Description
+
+Adds a newly generated Swift file, which includes a class with the specified name, placing it in the appropriate directory.
+
+### Commands
+
+Usage | Synopsis
+------|-------
+Swift | `$ ns native add swift <Swift class name>`
+
+### Arguments
+
+* `<Swift class name>` is the name of the `Class` to create, e.g. `SomeClass`
+
+<% if(isHtml) { %>
+
+### Related Commands
+
+Command | Description
+----------|----------
+[native add swift](native-add-swift.html) | Generates and adds a Swift file containing a class of the given name.
+[native add objective-c](native-add-objective-c.html) | Generates and adds Objective-C files containing an interface of the given name.
+[native add java](native-add-java.html) | Generates and adds a Java file containing a class of the given name.
+[native add kotlin](native-add-kotlin.html) | Generates and adds a Kotlin file containing a class of the given name.
+<% } %>

package/docs/man_pages/project/configuration/native/native-add.md

@@ -0,0 +1,31 @@
+<% if (isJekyll) { %>---
+title: ns native add
+position: 1
+---<% } %>
+
+# ns native add
+
+### Description
+
+Commands to add native files to the application placing them in the correct directory.
+
+### Commands
+
+Usage | Synopsis
+------|-------
+Swift | `$ ns native add swift <Swift class name>`
+Objective-C | `$ ns native add objective-c <Objective-C interface name>`
+Java | `$ ns native add java <Java class name>`
+Kotlin | `$ ns native add kotlin <Kotlin class name>`
+
+<% if(isHtml) { %>
+
+### Related Commands
+
+Command | Description
+----------|----------
+[native add swift](native-add-swift.html) | Generates and adds a Swift file containing a class of the given name.
+[native add objective-c](native-add-objective-c.html) | Generates and adds Objective-C files containing an interface of the given name.
+[native add java](native-add-java.html) | Generates and adds a Java file containing a class of the given name.
+[native add kotlin](native-add-kotlin.html) | Generates and adds a Kotlin file containing a class of the given name.
+<% } %>

package/docs/man_pages/project/configuration/native/native.md

@@ -0,0 +1,31 @@
+<% if (isJekyll) { %>---
+title: ns native
+position: 1
+---<% } %>
+
+# ns native
+
+### Description
+
+Commands to add native files to the application placing them in the correct directory.
+
+### Commands
+
+Usage | Synopsis
+------|-------
+Swift | `$ ns native add swift <Swift class name>`
+Objective-C | `$ ns native add objective-c <Objective-C interface name>`
+Java | `$ ns native add java <Java class name>`
+Kotlin | `$ ns native add kotlin <Kotlin class name>`
+
+<% if(isHtml) { %>
+
+### Related Commands
+
+Command | Description
+----------|----------
+[native add swift](native-add-swift.html) | Generates and adds a Swift file containing a class of the given name.
+[native add objective-c](native-add-objective-c.html) | Generates and adds Objective-C files containing an interface of the given name.
+[native add java](native-add-java.html) | Generates and adds a Java file containing a class of the given name.
+[native add kotlin](native-add-kotlin.html) | Generates and adds a Kotlin file containing a class of the given name.
+<% } %>

package/lib/.d.ts

@@ -15,6 +15,7 @@
 /// <reference path="commands/create-project.ts" />
 /// <reference path="commands/debug.ts" />
 /// <reference path="commands/deploy.ts" />
+/// <reference path="commands/embedding/embed.ts" />
 /// <reference path="commands/extensibility/install-extension.ts" />
 /// <reference path="commands/extensibility/list-extensions.ts" />
 /// <reference path="commands/extensibility/uninstall-extension.ts" />
@@ -26,6 +27,7 @@
 /// <reference path="commands/install.ts" />
 /// <reference path="commands/list-platforms.ts" />
 /// <reference path="commands/migrate.ts" />
+/// <reference path="commands/native-add.ts" />
 /// <reference path="commands/platform-clean.ts" />
 /// <reference path="commands/plugin/add-plugin.ts" />
 /// <reference path="commands/plugin/build-plugin.ts" />

package/lib/bootstrap.js

@@ -93,6 +93,7 @@ yok_1.injector.requireCommand("build|android", "./commands/build");
 yok_1.injector.requireCommand("build|vision", "./commands/build");
 yok_1.injector.requireCommand("build|visionos", "./commands/build");
 yok_1.injector.requireCommand("deploy", "./commands/deploy");
+yok_1.injector.requireCommand("embed", "./commands/embedding/embed");
 yok_1.injector.require("testExecutionService", "./services/test-execution-service");
 yok_1.injector.requireCommand("dev-test|android", "./commands/test");
 yok_1.injector.requireCommand("dev-test|ios", "./commands/test");
@@ -200,4 +201,11 @@ yok_1.injector.require("sharedEventBus", "./shared-event-bus");
 yok_1.injector.require("keyCommandHelper", "./helpers/key-command-helper");
 yok_1.injector.requireCommand("start", "./commands/start");
 yok_1.injector.require("startService", "./services/start-service");
+yok_1.injector.requireCommand([
+    "native|add",
+    "native|add|java",
+    "native|add|kotlin",
+    "native|add|swift",
+    "native|add|objective-c",
+], "./commands/native-add");
 require("./key-commands/bootstrap");

package/lib/commands/embedding/embed.js

@@ -0,0 +1,91 @@
+"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.EmbedCommand = void 0;
+const yok_1 = require("../../common/yok");
+const prepare_1 = require("../prepare");
+const path_1 = require("path");
+const color_1 = require("../../color");
+class EmbedCommand extends prepare_1.PrepareCommand {
+    constructor($options, $prepareController, $platformValidationService, $projectData, $platformCommandParameter, $platformsDataService, $prepareDataService, $migrateController, $logger, $fs, $projectConfigService) {
+        super($options, $prepareController, $platformValidationService, $projectData, $platformCommandParameter, $platformsDataService, $prepareDataService, $migrateController);
+        this.$options = $options;
+        this.$prepareController = $prepareController;
+        this.$platformValidationService = $platformValidationService;
+        this.$projectData = $projectData;
+        this.$platformCommandParameter = $platformCommandParameter;
+        this.$platformsDataService = $platformsDataService;
+        this.$prepareDataService = $prepareDataService;
+        this.$migrateController = $migrateController;
+        this.$logger = $logger;
+        this.$fs = $fs;
+        this.$projectConfigService = $projectConfigService;
+    }
+    resolveHostProjectPath(hostProjectPath) {
+        if (hostProjectPath.charAt(0) === ".") {
+            const projectDir = this.$projectData.projectDir;
+            return (0, path_1.resolve)(projectDir, hostProjectPath);
+        }
+        return (0, path_1.resolve)(hostProjectPath);
+    }
+    execute(args) {
+        const _super = Object.create(null, {
+            execute: { get: () => super.execute }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const hostProjectPath = args[1];
+            const resolvedHostProjectPath = this.resolveHostProjectPath(hostProjectPath);
+            if (!this.$fs.exists(resolvedHostProjectPath)) {
+                this.$logger.error(`The host project path ${color_1.color.yellow(hostProjectPath)} (resolved to: ${color_1.color.yellow.dim(resolvedHostProjectPath)}) does not exist.`);
+                return;
+            }
+            this.$options["hostProjectPath"] = resolvedHostProjectPath;
+            if (args.length > 2) {
+                this.$options["hostProjectModuleName"] = args[2];
+            }
+            return _super.execute.call(this, args);
+        });
+    }
+    canExecute(args) {
+        const _super = Object.create(null, {
+            canExecute: { get: () => super.canExecute }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const canSuperExecute = yield _super.canExecute.call(this, args);
+            if (!canSuperExecute) {
+                return false;
+            }
+            const platform = args[0].toLowerCase();
+            if (!args[1]) {
+                const hostProjectPath = this.getEmbedConfigForKey("hostProjectPath", platform);
+                if (hostProjectPath) {
+                    args[1] = hostProjectPath;
+                }
+            }
+            if (!args[2]) {
+                const hostProjectModuleName = this.getEmbedConfigForKey("hostProjectModuleName", platform);
+                if (hostProjectModuleName) {
+                    args[2] = hostProjectModuleName;
+                }
+            }
+            console.log(args);
+            if (args.length < 2) {
+                return false;
+            }
+            return true;
+        });
+    }
+    getEmbedConfigForKey(key, platform) {
+        return this.$projectConfigService.getValue(`embed.${platform}.${key}`, this.$projectConfigService.getValue(`embed.${key}`));
+    }
+}
+exports.EmbedCommand = EmbedCommand;
+yok_1.injector.registerCommand("embed", EmbedCommand);

package/lib/commands/native-add.js

@@ -0,0 +1,300 @@
+"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");
+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();
+    }
+    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]");
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.doJavaKotlin(args[0], "java");
+            return Promise.resolve();
+        });
+    }
+}
+exports.NativeAddJavaCommand = NativeAddJavaCommand;
+class NativeAddKotlinCommand extends NativeAddAndroidCommand {
+    constructor($projectData, $logger, $errors) {
+        super($projectData, $logger, $errors);
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.doJavaKotlin(args[0], "kotlin");
+            return Promise.resolve();
+        });
+    }
+}
+exports.NativeAddKotlinCommand = NativeAddKotlinCommand;
+class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
+    constructor($projectData, $logger, $errors) {
+        super($projectData, $logger, $errors);
+    }
+    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)) {
+            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);
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);

package/lib/commands/plugin/build-plugin.js

@@ -38,15 +38,9 @@ class BuildPluginCommand {
                 }
             }
             const tempAndroidProject = yield this.$tempService.mkdirSync("android-project");
-            const gradleArgs = (this.$projectData.nsConfig.android.gradleArgs || [].concat(this.$options.gradleArgs || []));
-            const options = {
-                gradlePath: this.$options.gradlePath,
-                gradleArgs,
-                aarOutputDir: platformsAndroidPath,
-                platformsAndroidDirPath: platformsAndroidPath,
-                pluginName: pluginName,
-                tempPluginDirPath: tempAndroidProject,
-            };
+            const gradleArgs = (this.$projectData.nsConfig.android.gradleArgs || []).concat(this.$options.gradleArgs || []);
+            const pluginOptions = (this.$projectData.nsConfig.android.plugins || {})[pluginName] || {};
+            const options = Object.assign({ gradlePath: this.$options.gradlePath, gradleArgs, aarOutputDir: platformsAndroidPath, platformsAndroidDirPath: platformsAndroidPath, pluginName: pluginName, tempPluginDirPath: tempAndroidProject }, pluginOptions);
             const androidPluginBuildResult = yield this.$androidPluginBuildService.buildAar(options);
             if (androidPluginBuildResult) {
                 this.$logger.info(`${pluginName} successfully built aar at ${platformsAndroidPath}.${os_1.EOL}Temporary Android project can be found at ${tempAndroidProject}.`);