fk-platform-sdk 1.0.2 → 1.0.3-7.beta4

package/dist/managers/{modules/NativeModuleManager.d.ts → NativeModuleHelper.d.ts}

@@ -1,13 +1,17 @@
-import { NativeModuleManagerProvider } from "../../interfaces/NativeModuleManagerProvider";
-import { NativeModuleCallbackManager } from "../NativeModuleCallbackManager";
-export interface NativeModuleManager {
-    dummy?: string;
-}
+import { NativeModuleManagerProvider } from "../interfaces/NativeModuleManagerProvider";
+import { NativeModuleCallbackManager } from "./NativeModuleCallbackManager";
 export declare class NativeModuleHelper {
     static getCurrentNativeModuleProvider(): NativeModuleManagerProvider;
 }
+export interface NativeModuleManager {
+    postMessage: (args: any[]) => void;
+    [key: string]: any;
+}
 export declare class NativeModule<T extends NativeModuleManager> {
     protected nativeModuleManager: T;
     protected nativeModuleCallbackManager: NativeModuleCallbackManager;
     constructor(nativeModuleManager: T, nativeModuleCallbackManager: NativeModuleCallbackManager);
+    protected postMessage(dict: {
+        [key: string]: any;
+    }): void;
 }

package/dist/managers/NativeModuleHelper.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var WindowManager_1 = require("./WindowManager");
+var Errors_1 = require("../constants/Errors");
+var FKPlatformError_1 = require("../errors/FKPlatformError");
+var NativeModuleHelper = /** @class */ (function () {
+    function NativeModuleHelper() {
+    }
+    NativeModuleHelper.getCurrentNativeModuleProvider = function () {
+        var windowObj = WindowManager_1.WindowManager.getWindow();
+        if (windowObj) {
+            if (windowObj.nativeModules) {
+                return windowObj.nativeModules;
+            }
+            if (windowObj.webkit) {
+                return windowObj.webkit.messageHandlers;
+            }
+            return windowObj;
+        }
+        throw new FKPlatformError_1.FKPlatformError(Errors_1.Errors.NATIVE_MODULES_MISSING);
+    };
+    return NativeModuleHelper;
+}());
+exports.NativeModuleHelper = NativeModuleHelper;
+var NativeModule = /** @class */ (function () {
+    function NativeModule(nativeModuleManager, nativeModuleCallbackManager) {
+        this.nativeModuleManager = nativeModuleManager;
+        this.nativeModuleCallbackManager = nativeModuleCallbackManager;
+    }
+    NativeModule.prototype.postMessage = function (dict) {
+        var _a;
+        var methodName = dict.methodName;
+        var args = Object.keys(dict).map(function (key) { return dict[key]; });
+        /** All the bridge method calls for modules flows via this method */
+        /**
+         * We first check if the method name exists on the native end. This is done to maintain
+         * backward compatibility.
+         *
+         * If the method exists, invoke that method via the bridge.
+         *
+         * The new implementation will be as follows:
+         * 1. In iOS postMessage will be triggered with dictionary as argument. The first key in dictionary will
+         * contain the method name. Using this method name, appropriate methods will be called in native.
+         * 2. In Android, the same implementation will continue. You need to expose the exact method annotated with
+         * JS Annotation.
+         *
+         */
+        // check if this method name exists in native. This is done for backward compatibility.
+        if (this.nativeModuleManager[methodName]) {
+            // shift is used to remove the first element from the array, ie the method name since we are calling the exact method.
+            args.shift();
+            (_a = this.nativeModuleManager)[methodName].apply(_a, args);
+        }
+        // tslint:disable-next-line:no-string-literal
+        if (this.nativeModuleManager["postMessage"]) {
+            // if the native module does not exist, fire the postMessage
+            // we also pass the first parameter as the method name so that the client can figure out what
+            // method they will have to invoke
+            this.nativeModuleManager.postMessage(args);
+        }
+        return;
+    };
+    return NativeModule;
+}());
+exports.NativeModule = NativeModule;

package/dist/modules/AnalyticsModuleImpl.d.ts

@@ -0,0 +1,9 @@
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
+import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
+import { AnalyticsEvent } from "../analytics/interfaces/AnalyticsEvent";
+import { AnalyticsModule } from "../analytics/interfaces/AnalyticsModule";
+export declare class AnalyticsModuleImpl extends NativeModule<NativeModuleManager> implements AnalyticsModule {
+    constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
+    pushEvent(event: AnalyticsEvent): void;
+    forceFlushEvents(): void;
+}

package/dist/modules/AnalyticsModuleImpl.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
+var AnalyticsModuleImpl = /** @class */ (function (_super) {
+    __extends(AnalyticsModuleImpl, _super);
+    function AnalyticsModuleImpl(nativeModuleCallbackManager) {
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().AnalyticsModule, nativeModuleCallbackManager) || this;
+    }
+    AnalyticsModuleImpl.prototype.pushEvent = function (event) {
+        var _this = this;
+        this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
+            var type = event.type;
+            delete event.type;
+            var eventValidator = event.getValidator();
+            if (eventValidator.isValid()) {
+                _this.postMessage({
+                    methodName: "pushEvent",
+                    requestId: requestId,
+                    type: type,
+                    event: JSON.stringify(event),
+                });
+            }
+            else {
+                _this.postMessage({
+                    methodName: "onEventValidationError",
+                    requestId: requestId,
+                    type: type,
+                    error: eventValidator.getErrorMessage(),
+                });
+            }
+        });
+    };
+    AnalyticsModuleImpl.prototype.forceFlushEvents = function () {
+        var _this = this;
+        this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
+            _this.postMessage({
+                methodName: "forceFlushEvents",
+                requestId: requestId
+            });
+        });
+    };
+    return AnalyticsModuleImpl;
+}(NativeModuleHelper_1.NativeModule));
+exports.AnalyticsModuleImpl = AnalyticsModuleImpl;

package/dist/modules/AppVersionModuleImpl.d.ts

@@ -0,0 +1,9 @@
+import { NativeModuleResponse } from "../interfaces/NativeModuleResponse";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
+import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
+import { AppVersionModule } from "../interfaces/modules/AppVersionModule";
+import { AppVersionManagerResponse } from "../types/AppVersionManagerResponse";
+export declare class AppVersionModuleImpl extends NativeModule<NativeModuleManager> implements AppVersionModule {
+    constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
+    getApkVersion(): Promise<NativeModuleResponse<AppVersionManagerResponse>>;
+}

package/dist/modules/AppVersionModuleImpl.js

@@ -0,0 +1,30 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
+var AppVersionModuleImpl = /** @class */ (function (_super) {
+    __extends(AppVersionModuleImpl, _super);
+    function AppVersionModuleImpl(nativeModuleCallbackManager) {
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().AppVersionModule, nativeModuleCallbackManager) || this;
+    }
+    AppVersionModuleImpl.prototype.getApkVersion = function () {
+        var _this = this;
+        return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
+            _this.postMessage({
+                methodName: "getApkVersion",
+                requestId: requestId
+            });
+        });
+    };
+    return AppVersionModuleImpl;
+}(NativeModuleHelper_1.NativeModule));
+exports.AppVersionModuleImpl = AppVersionModuleImpl;

package/dist/modules/AuthModuleImpl.d.ts

@@ -1,7 +1,6 @@
-import { AuthModuleManager } from "../managers/modules/AuthModuleManager";
-import { NativeModule } from "../managers/modules/NativeModuleManager";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
 import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
-export declare class AuthModuleImpl extends NativeModule<AuthModuleManager> {
+export declare class AuthModuleImpl extends NativeModule<NativeModuleManager> {
     constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
     init(clientId: string): void;
 }

package/dist/modules/AuthModuleImpl.js

@@ -10,15 +10,18 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-var NativeModuleManager_1 = require("../managers/modules/NativeModuleManager");
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
 var AuthModuleImpl = /** @class */ (function (_super) {
     __extends(AuthModuleImpl, _super);
     function AuthModuleImpl(nativeModuleCallbackManager) {
-        return _super.call(this, NativeModuleManager_1.NativeModuleHelper.getCurrentNativeModuleProvider().AuthModule, nativeModuleCallbackManager) || this;
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().AuthModule, nativeModuleCallbackManager) || this;
     }
     AuthModuleImpl.prototype.init = function (clientId) {
-        this.nativeModuleManager.init(clientId);
+        this.postMessage({
+            methodName: "init",
+            clientId: clientId,
+        });
     };
     return AuthModuleImpl;
-}(NativeModuleManager_1.NativeModule));
+}(NativeModuleHelper_1.NativeModule));
 exports.AuthModuleImpl = AuthModuleImpl;

package/dist/modules/ContactsModuleImpl.d.ts

@@ -1,9 +1,8 @@
-import { NativeModule } from "../managers/modules/NativeModuleManager";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
 import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
-import { ContactsModuleManager, Contact } from "../managers/modules/ContactsModuleManager";
-import { ContactsModule } from "../interfaces/ContactsModule";
+import { ContactsModule, Contact } from "../interfaces/modules/ContactsModule";
 import { NativeModuleResponse } from "../interfaces/NativeModuleResponse";
-export declare class ContactsModuleImpl extends NativeModule<ContactsModuleManager> implements ContactsModule {
+export declare class ContactsModuleImpl extends NativeModule<NativeModuleManager> implements ContactsModule {
     constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
     pickPhoneNumber(): Promise<NativeModuleResponse<Contact>>;
     getContactInfo(phoneNumbers: string[]): Promise<NativeModuleResponse<{

package/dist/modules/ContactsModuleImpl.js

@@ -10,24 +10,31 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-var NativeModuleManager_1 = require("../managers/modules/NativeModuleManager");
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
 var ContactsModuleImpl = /** @class */ (function (_super) {
     __extends(ContactsModuleImpl, _super);
     function ContactsModuleImpl(nativeModuleCallbackManager) {
-        return _super.call(this, NativeModuleManager_1.NativeModuleHelper.getCurrentNativeModuleProvider().ContactsModule, nativeModuleCallbackManager) || this;
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().ContactsModule, nativeModuleCallbackManager) || this;
     }
     ContactsModuleImpl.prototype.pickPhoneNumber = function () {
         var _this = this;
         return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
-            _this.nativeModuleManager.pickPhoneNumber(requestId);
+            _this.postMessage({
+                methodName: "pickPhoneNumber",
+                requestId: requestId,
+            });
         });
     };
     ContactsModuleImpl.prototype.getContactInfo = function (phoneNumbers) {
         var _this = this;
         return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
-            _this.nativeModuleManager.getContactInfo(requestId, JSON.stringify(phoneNumbers));
+            _this.postMessage({
+                methodName: "getContactInfo",
+                requestId: requestId,
+                numbers: JSON.stringify(phoneNumbers),
+            });
         });
     };
     return ContactsModuleImpl;
-}(NativeModuleManager_1.NativeModule));
+}(NativeModuleHelper_1.NativeModule));
 exports.ContactsModuleImpl = ContactsModuleImpl;

package/dist/modules/DownloaderModuleImpl.d.ts

@@ -0,0 +1,9 @@
+import { NativeModuleResponse } from "../interfaces/NativeModuleResponse";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
+import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
+import { DownloaderModule } from "../interfaces/modules/DownloaderModule";
+import { DownloadManagerResponse } from "../types/DownloadManagerResponse";
+export declare class DownloaderModuleImpl extends NativeModule<NativeModuleManager> implements DownloaderModule {
+    constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
+    fileDownload(url: string, mimeType: string): Promise<NativeModuleResponse<DownloadManagerResponse>>;
+}

package/dist/modules/DownloaderModuleImpl.js

@@ -0,0 +1,32 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
+var DownloaderModuleImpl = /** @class */ (function (_super) {
+    __extends(DownloaderModuleImpl, _super);
+    function DownloaderModuleImpl(nativeModuleCallbackManager) {
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().DownloaderModule, nativeModuleCallbackManager) || this;
+    }
+    DownloaderModuleImpl.prototype.fileDownload = function (url, mimeType) {
+        var _this = this;
+        return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
+            _this.postMessage({
+                methodName: "fileDownload",
+                requestId: requestId,
+                url: url,
+                mimeType: mimeType
+            });
+        });
+    };
+    return DownloaderModuleImpl;
+}(NativeModuleHelper_1.NativeModule));
+exports.DownloaderModuleImpl = DownloaderModuleImpl;

package/dist/modules/FontModuleImpl.d.ts

@@ -0,0 +1,9 @@
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
+import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
+import { NativeModuleResponse } from "../interfaces/NativeModuleResponse";
+import { FontsManagerResponse } from "../types/FontsManagerResponse";
+import { FontModule } from "../interfaces/modules/FontModule";
+export declare class FontModuleImpl extends NativeModule<NativeModuleManager> implements FontModule {
+    constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
+    downloadFont(fontFamily: string, url: string): Promise<NativeModuleResponse<FontsManagerResponse>>;
+}

package/dist/modules/FontModuleImpl.js

@@ -0,0 +1,32 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
+var FontModuleImpl = /** @class */ (function (_super) {
+    __extends(FontModuleImpl, _super);
+    function FontModuleImpl(nativeModuleCallbackManager) {
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().FontModule, nativeModuleCallbackManager) || this;
+    }
+    FontModuleImpl.prototype.downloadFont = function (fontFamily, url) {
+        var _this = this;
+        return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
+            _this.postMessage({
+                methodName: "downloadFont",
+                requestId: requestId,
+                fontFamily: fontFamily,
+                url: url
+            });
+        });
+    };
+    return FontModuleImpl;
+}(NativeModuleHelper_1.NativeModule));
+exports.FontModuleImpl = FontModuleImpl;

package/dist/modules/LocationModuleImpl.d.ts

@@ -0,0 +1,11 @@
+import { NativeModuleResponse } from "../interfaces/NativeModuleResponse";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
+import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
+import { LocationModule } from "../interfaces/modules/LocationModule";
+import { LocationManagerResponse } from "../types/LocationManagerResponse";
+import { DeviceInfoResponse } from "../types/DeviceInfoResponse";
+export declare class LocationModuleImpl extends NativeModule<NativeModuleManager> implements LocationModule {
+    constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
+    getUserPinCode(clientID: string): Promise<NativeModuleResponse<LocationManagerResponse>>;
+    getUserDeviceId(): Promise<NativeModuleResponse<DeviceInfoResponse>>;
+}

package/dist/modules/LocationModuleImpl.js

@@ -0,0 +1,40 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
+var LocationModuleImpl = /** @class */ (function (_super) {
+    __extends(LocationModuleImpl, _super);
+    function LocationModuleImpl(nativeModuleCallbackManager) {
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().LocationModule, nativeModuleCallbackManager) || this;
+    }
+    LocationModuleImpl.prototype.getUserPinCode = function (clientID) {
+        var _this = this;
+        return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
+            _this.postMessage({
+                methodName: "getUserPinCode",
+                requestId: requestId,
+                clientID: clientID
+            });
+        });
+    };
+    LocationModuleImpl.prototype.getUserDeviceId = function () {
+        var _this = this;
+        return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
+            _this.postMessage({
+                methodName: "getUserDeviceID",
+                requestId: requestId
+            });
+        });
+    };
+    return LocationModuleImpl;
+}(NativeModuleHelper_1.NativeModule));
+exports.LocationModuleImpl = LocationModuleImpl;

package/dist/modules/NavigationModuleImpl.d.ts

@@ -1,8 +1,7 @@
-import { NavigationModule } from "../interfaces/NavigationModule";
-import { NativeModule } from "../managers/modules/NativeModuleManager";
-import { NavigationModuleManager } from "../managers/modules/NavigationModuleManager";
+import { NavigationModule } from "../interfaces/modules/NavigationModule";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
 import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
-export declare class NavigationModuleImpl extends NativeModule<NavigationModuleManager> implements NavigationModule {
+export declare class NavigationModuleImpl extends NativeModule<NativeModuleManager> implements NavigationModule {
     constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
     exitSession(): void;
     exitToHomePage(): void;

package/dist/modules/NavigationModuleImpl.js

@@ -10,32 +10,46 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-var NativeModuleManager_1 = require("../managers/modules/NativeModuleManager");
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
 var NavigationModuleImpl = /** @class */ (function (_super) {
     __extends(NavigationModuleImpl, _super);
     function NavigationModuleImpl(nativeModuleCallbackManager) {
-        return _super.call(this, NativeModuleManager_1.NativeModuleHelper.getCurrentNativeModuleProvider().NavigationModule, nativeModuleCallbackManager) || this;
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().NavigationModule, nativeModuleCallbackManager) || this;
     }
     NavigationModuleImpl.prototype.exitSession = function () {
-        this.nativeModuleManager.exitSession();
+        this.postMessage({
+            methodName: "exitSession",
+        });
     };
     NavigationModuleImpl.prototype.exitToHomePage = function () {
-        this.nativeModuleManager.exitToHomePage();
+        this.postMessage({
+            methodName: "exitToHomePage",
+        });
     };
     NavigationModuleImpl.prototype.clearHistory = function () {
-        if (this.nativeModuleManager.clearHistory) {
-            this.nativeModuleManager.clearHistory();
-        }
+        this.postMessage({
+            methodName: "clearHistory",
+        });
     };
     NavigationModuleImpl.prototype.startPayment = function (paymentToken) {
-        this.nativeModuleManager.startPayment(paymentToken);
+        this.postMessage({
+            methodName: "startPayment",
+            paymentToken: paymentToken,
+        });
     };
     NavigationModuleImpl.prototype.notifyPageLocationChange = function (currentUri, isBackNavigation) {
-        this.nativeModuleManager.notifyPageLocationChange(currentUri, isBackNavigation);
+        this.postMessage({
+            methodName: "notifyPageLocationChange",
+            currentUri: currentUri,
+            isBackNavigation: isBackNavigation,
+        });
     };
     NavigationModuleImpl.prototype.navigateToFlipkart = function (uri) {
-        this.nativeModuleManager.navigateToFlipkart(uri);
+        this.postMessage({
+            methodName: "navigateToFlipkart",
+            uri: uri,
+        });
     };
     return NavigationModuleImpl;
-}(NativeModuleManager_1.NativeModule));
+}(NativeModuleHelper_1.NativeModule));
 exports.NavigationModuleImpl = NavigationModuleImpl;

package/dist/modules/PermissionsModuleImpl.d.ts

@@ -1,10 +1,9 @@
 import { NativeModuleResponse } from "../interfaces/NativeModuleResponse";
-import { NativeModule } from "../managers/modules/NativeModuleManager";
-import { PermissionsModuleManager, ScopeAccessRequest, Scope } from "../managers/modules/PermissionsModuleManager";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
 import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
 import { PermissionsManagerResponse } from "../types/PermissionsManagerResponse";
-import { PermissionsModule } from "../interfaces/PermissionsModule";
-export declare class PermissionsModuleImpl extends NativeModule<PermissionsModuleManager> implements PermissionsModule {
+import { PermissionsModule, Scope, ScopeAccessRequest } from "../interfaces/modules/PermissionsModule";
+export declare class PermissionsModuleImpl extends NativeModule<NativeModuleManager> implements PermissionsModule {
     private allScopes;
     constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
     getToken(scopes: ScopeAccessRequest[]): Promise<NativeModuleResponse<PermissionsManagerResponse>>;

package/dist/modules/PermissionsModuleImpl.js

@@ -10,28 +10,32 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-var NativeModuleManager_1 = require("../managers/modules/NativeModuleManager");
-var PermissionsModuleManager_1 = require("../managers/modules/PermissionsModuleManager");
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
+var PermissionsModule_1 = require("../interfaces/modules/PermissionsModule");
 var PermissionsModuleImpl = /** @class */ (function (_super) {
     __extends(PermissionsModuleImpl, _super);
     function PermissionsModuleImpl(nativeModuleCallbackManager) {
-        var _this = _super.call(this, NativeModuleManager_1.NativeModuleHelper.getCurrentNativeModuleProvider().PermissionsModule, nativeModuleCallbackManager) || this;
+        var _this = _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().PermissionsModule, nativeModuleCallbackManager) || this;
         _this.allScopes = Object.freeze({
-            USER_NAME: PermissionsModuleManager_1.Scope.USER_NAME,
-            USER_EMAIL: PermissionsModuleManager_1.Scope.USER_EMAIL,
-            USER_MOBILE: PermissionsModuleManager_1.Scope.USER_MOBILE,
+            USER_NAME: PermissionsModule_1.Scope.USER_NAME,
+            USER_EMAIL: PermissionsModule_1.Scope.USER_EMAIL,
+            USER_MOBILE: PermissionsModule_1.Scope.USER_MOBILE,
         });
         return _this;
     }
     PermissionsModuleImpl.prototype.getToken = function (scopes) {
         var _this = this;
         return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
-            _this.nativeModuleManager.getToken(requestId, JSON.stringify(scopes));
+            _this.postMessage({
+                methodName: "getToken",
+                requestId: requestId,
+                scopes: JSON.stringify(scopes),
+            });
         });
     };
     PermissionsModuleImpl.prototype.getScopes = function () {
         return this.allScopes;
     };
     return PermissionsModuleImpl;
-}(NativeModuleManager_1.NativeModule));
+}(NativeModuleHelper_1.NativeModule));
 exports.PermissionsModuleImpl = PermissionsModuleImpl;

package/dist/modules/SMSModuleImpl.d.ts

@@ -0,0 +1,9 @@
+import { NativeModuleResponse } from "../interfaces/NativeModuleResponse";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
+import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
+import { SMSManagerResponse } from "../types/SMSManagerResponse";
+import { SMSModule } from "../interfaces/modules/SMSModule";
+export declare class SMSModuleImpl extends NativeModule<NativeModuleManager> implements SMSModule {
+    constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
+    captureMessage(): Promise<NativeModuleResponse<SMSManagerResponse>>;
+}

package/dist/modules/SMSModuleImpl.js

@@ -0,0 +1,30 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var NativeModuleHelper_1 = require("../managers/NativeModuleHelper");
+var SMSModuleImpl = /** @class */ (function (_super) {
+    __extends(SMSModuleImpl, _super);
+    function SMSModuleImpl(nativeModuleCallbackManager) {
+        return _super.call(this, NativeModuleHelper_1.NativeModuleHelper.getCurrentNativeModuleProvider().SMSModule, nativeModuleCallbackManager) || this;
+    }
+    SMSModuleImpl.prototype.captureMessage = function () {
+        var _this = this;
+        return this.nativeModuleCallbackManager.executeOnBridge(function (requestId) {
+            _this.postMessage({
+                methodName: "captureMessage",
+                requestId: requestId,
+            });
+        });
+    };
+    return SMSModuleImpl;
+}(NativeModuleHelper_1.NativeModule));
+exports.SMSModuleImpl = SMSModuleImpl;

package/dist/modules/ShareModuleImpl.d.ts

@@ -0,0 +1,9 @@
+import { NativeModuleResponse } from "../interfaces/NativeModuleResponse";
+import { NativeModule, NativeModuleManager } from "../managers/NativeModuleHelper";
+import { NativeModuleCallbackManager } from "../managers/NativeModuleCallbackManager";
+import { GenericUltraShareModule } from "../interfaces/modules/GenericUltraShareModule";
+import { GenericShareManagerResponse } from "../types/GenericShareManagerResponse";
+export declare class ShareModuleImpl extends NativeModule<NativeModuleManager> implements GenericUltraShareModule {
+    constructor(nativeModuleCallbackManager: NativeModuleCallbackManager);
+    share(title: string, text: string, url: string): Promise<NativeModuleResponse<GenericShareManagerResponse>>;
+}