webtonative 1.0.74 → 1.0.75-beta.2

package/src/InAppPurchase/index.ts

@@ -0,0 +1,92 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import {
+	InAppPurchaseOptions,
+	GetAllPurchasesOptions,
+	GetReceiptDataOptions,
+	InAppPurchaseResponse,
+	InAppPurchaseIosMessage,
+	InAppPurchaseAndroidParams
+} from "./types";
+
+/**
+ * This function handles native in app purchase
+ * @param options - Options for in-app purchase
+ * @example wtn.inAppPurchase({
+ *  productId : 'productId'
+ *  callback:(data)=>{
+ *    console.log(data);
+ *  }
+ * });
+ */
+export const inAppPurchase = (options: InAppPurchaseOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { callback, productId, productType, isConsumable = false } = options;
+
+		registerCb((response: InAppPurchaseResponse) => {
+			const { type } = response;
+			if (type === "inAppPurchase") {
+				callback && callback(response);
+			}
+		});
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "inAppPurchase",
+				productId,
+			} as InAppPurchaseIosMessage);
+		}
+
+		platform === "ANDROID_APP" &&
+			webToNative.inAppPurchase(JSON.stringify({
+				action: "inAppPurchase",
+				productId,
+				productType,
+				isConsumable
+			} as InAppPurchaseAndroidParams));
+	}
+};
+
+/**
+ * Gets all purchases (Android only)
+ * @param options - Options for getting all purchases
+ */
+export const getAllPurchases = (options: GetAllPurchasesOptions): void => {
+	if (["ANDROID_APP"].includes(platform)) {
+		const { callback } = options;
+
+		registerCb((response: InAppPurchaseResponse) => {
+			const { type } = response;
+			if (type === "purchaseList") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+			webToNative.getAllPurchases({
+				action: "purchaseList"
+			});
+	}
+};
+
+/**
+ * Gets receipt data (iOS only)
+ * @param options - Options for getting receipt data
+ */
+export const getReceiptData = (options: GetReceiptDataOptions): void => {
+	if (["IOS_APP"].includes(platform)) {
+		const { callback } = options;
+
+		registerCb((response: InAppPurchaseResponse) => {
+			const { type } = response;
+			if (type === "getReceiptData") {
+				callback && callback(response);
+			}
+		});
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "getReceiptData"
+			} as InAppPurchaseIosMessage);
+		}
+	}
+};

package/src/InAppPurchase/types.ts

@@ -0,0 +1,35 @@
+export interface InAppPurchaseResponse {
+	type: string;
+	[key: string]: any;
+}
+
+export interface InAppPurchaseCallback {
+	(response: InAppPurchaseResponse): void;
+}
+
+export interface InAppPurchaseOptions {
+	productId: string;
+	callback?: InAppPurchaseCallback;
+	productType?: string;
+	isConsumable?: boolean;
+}
+
+export interface GetAllPurchasesOptions {
+	callback?: InAppPurchaseCallback;
+}
+
+export interface GetReceiptDataOptions {
+	callback?: InAppPurchaseCallback;
+}
+
+export interface InAppPurchaseIosMessage {
+	action: string;
+	productId?: string;
+}
+
+export interface InAppPurchaseAndroidParams {
+	action: string;
+	productId?: string;
+	productType?: string;
+	isConsumable?: boolean;
+}

package/src/InAppUpdate/index.ts

@@ -0,0 +1,40 @@
+import { platform, registerCb, webToNative } from "../utills";
+import { CheckUpdateOptions, UpdateApplicationOptions, InAppUpdateResponse } from "./types";
+
+/**
+ * Checks if an app update is available (Android only)
+ * @param options - Options for checking app update
+ */
+export const checkIfAppUpdateAvailable = (options: CheckUpdateOptions): void => {
+	if (["ANDROID_APP"].includes(platform)) {
+		const { callback } = options;
+
+		registerCb((response: InAppUpdateResponse) => {
+			const { type } = response;
+			if (type === "checkIfAppUpdateAvailable") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.checkIfAppUpdateAvailable();
+	}
+};
+
+/**
+ * Updates the application (Android only)
+ * @param options - Options for updating the application
+ */
+export const updateApplication = (options: UpdateApplicationOptions): void => {
+	if (["ANDROID_APP"].includes(platform)) {
+		const { updateType = "immediate", callback } = options;
+
+		registerCb((response: InAppUpdateResponse) => {
+			const { type } = response;
+			if (type === "updateApplication") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.updateApplication(updateType);
+	}
+};

package/src/InAppUpdate/types.ts

@@ -0,0 +1,17 @@
+export interface InAppUpdateResponse {
+	type: string;
+	[key: string]: any;
+}
+
+export interface InAppUpdateCallback {
+	(response: InAppUpdateResponse): void;
+}
+
+export interface CheckUpdateOptions {
+	callback?: InAppUpdateCallback;
+}
+
+export interface UpdateApplicationOptions {
+	updateType?: 'immediate' | 'flexible';
+	callback?: InAppUpdateCallback;
+}

package/src/MediaPlayer/index.ts

@@ -0,0 +1,56 @@
+import { platform, webToNative, webToNativeIos } from "../utills";
+import { MediaPlayerOptions, MediaPlayerIosMessage, MediaPlayerAndroidParams } from "./types";
+
+/**
+ * Plays media content
+ * @param options - Options for playing media
+ */
+export const playMedia = (options: MediaPlayerOptions = {}): void => {
+	const { url, imageUrl = "https://images.freeimages.com/images/large-previews/3b2/prague-conference-center-1056491.jpg" } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		
+		platform === "ANDROID_APP" && webToNative.playMedia(JSON.stringify({url, imageUrl} as MediaPlayerAndroidParams));
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				"action": "playMedia",
+				url,
+				image: imageUrl
+			} as MediaPlayerIosMessage);
+		}
+	}
+};
+
+/**
+ * Pauses currently playing media
+ * @param options - Options for pausing media
+ */
+export const pauseMedia = (options: MediaPlayerOptions = {}): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		
+		platform === "ANDROID_APP" && webToNative.pausePlaying();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				"action": "pauseMedia"
+			} as MediaPlayerIosMessage);
+		}
+	}
+};
+
+/**
+ * Stops currently playing media
+ * @param options - Options for stopping media
+ */
+export const stopMedia = (options: MediaPlayerOptions = {}): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		
+		platform === "ANDROID_APP" && webToNative.stopPlaying();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				"action": "stopMedia"
+			} as MediaPlayerIosMessage);
+		}
+	}
+};

package/src/MediaPlayer/types.ts

@@ -0,0 +1,15 @@
+export interface MediaPlayerOptions {
+	url?: string;
+	imageUrl?: string;
+}
+
+export interface MediaPlayerIosMessage {
+	action: string;
+	url?: string;
+	image?: string;
+}
+
+export interface MediaPlayerAndroidParams {
+	url?: string;
+	imageUrl?: string;
+}

package/src/NativeContacts/index.ts

@@ -0,0 +1,50 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import { ContactsOptions, ContactsResponse, ContactsIosMessage } from "./types";
+
+/**
+ * Gets the permission status for contacts access
+ * @param options - Options for getting permission status
+ */
+export const getPermissionStatus = (options: ContactsOptions = {}): void => {
+	const { callback } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: ContactsResponse) => {
+			const { type } = response;
+			if (type === "contactPermissionStatus") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.getPermissionStatus();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "askUserForContactPermission",
+			} as ContactsIosMessage);
+		}
+	}
+};
+
+/**
+ * Gets all contacts from the device
+ * @param options - Options for getting all contacts
+ */
+export const getAll = (options: ContactsOptions = {}): void => {
+	const { callback } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: ContactsResponse) => {
+			const { type } = response;
+			if (type === "contactDetails") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.getAll();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "getUserContactDetails",
+			} as ContactsIosMessage);
+		}
+	}
+};

package/src/NativeContacts/types.ts

@@ -0,0 +1,16 @@
+export interface ContactsResponse {
+	type: string;
+	[key: string]: any;
+}
+
+export interface ContactsCallback {
+	(response: ContactsResponse): void;
+}
+
+export interface ContactsOptions {
+	callback?: ContactsCallback;
+}
+
+export interface ContactsIosMessage {
+	action: string;
+}

package/src/Notification/index.ts

@@ -0,0 +1,41 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import { NotificationOptions, NotificationResponse, NotificationIosMessage } from "./types";
+
+/**
+ * Checks notification permission status
+ * @param options - Options for checking notification permission
+ */
+export const checkNotificationPermission = (options: NotificationOptions = {}): void => {
+	const { callback } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: NotificationResponse) => {
+			const { type } = response;
+			if (type === "checkNotificationPermission") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.checkNotificationPermission();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "checkNotificationPermission",
+			} as NotificationIosMessage);
+		}
+	}
+};
+
+/**
+ * Opens the app notification settings page
+ */
+export const openAppNotificationPage = (): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		platform === "ANDROID_APP" && webToNative.openAppNotificationPage();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "openAppNotificationPage",
+			} as NotificationIosMessage);
+		}
+	}
+};

package/src/Notification/types.ts

@@ -0,0 +1,16 @@
+export interface NotificationResponse {
+	type: string;
+	[key: string]: any;
+}
+
+export interface NotificationCallback {
+	(response: NotificationResponse): void;
+}
+
+export interface NotificationOptions {
+	callback?: NotificationCallback;
+}
+
+export interface NotificationIosMessage {
+	action: string;
+}

package/src/OneSignal/index.ts

@@ -0,0 +1,54 @@
+import { isNativeApp, platform, webToNative, registerCb, webToNativeIos } from "../utills";
+import { Platform, RegisterCallbackOptions } from "../types";
+import { PlayerIdResponse, OneSignalIosMessage } from "./types";
+
+export const getPlayerId = (): Promise<string> => {
+	return new Promise<string>((resolve, reject) => {
+		registerCb(
+			(results: PlayerIdResponse) => {
+				if (results.isSuccess) {
+					resolve(results.playerId as string);
+				} else {
+					reject(results);
+				}
+			},
+			{
+				key: "getPlayerId",
+			} as RegisterCallbackOptions
+		);
+		if (platform === "ANDROID_APP") {
+			webToNative.getOneSignalId();
+		} else if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "getPlayerId",
+			} as OneSignalIosMessage);
+		} else {
+			reject("This function will work in Native App Powered By WebToNative");
+		}
+	});
+};
+
+export const setExternalUserId = (userId: string): boolean | void => {
+	if (userId) {
+		if (platform === "ANDROID_APP") {
+			return isNativeApp && webToNative.setExternalUserId(userId);
+		} else if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "setExternalUserId",
+				userId: userId,
+			} as OneSignalIosMessage);
+		}
+	} else {
+		throw "userId is required";
+	}
+};
+
+export const removeExternalUserId = (): boolean | void => {
+	if (platform === "ANDROID_APP") {
+		return isNativeApp && webToNative.removeExternalUserId();
+	} else if (platform === "IOS_APP" && webToNativeIos) {
+		webToNativeIos.postMessage({
+			action: "removeExternalUserId",
+		} as OneSignalIosMessage);
+	}
+};

package/src/OneSignal/types.ts

@@ -0,0 +1,15 @@
+// Define types for OneSignal module
+
+// Response from getPlayerId
+export interface PlayerIdResponse {
+  isSuccess: boolean;
+  playerId?: string;
+  [key: string]: any;
+}
+
+// Message structure for iOS
+export interface OneSignalIosMessage {
+  action: string;
+  userId?: string;
+  [key: string]: any;
+}

package/src/Printing/index.ts

@@ -0,0 +1,17 @@
+import { platform, webToNative } from "../utills";
+import { PrintingOptions, PrintingAndroidParams } from "./types";
+
+/**
+ * Sets the print size for Android printing
+ * @param options - Options for setting print size
+ */
+export const setPrintSize = (options: PrintingOptions): void => {
+	if (["ANDROID_APP"].includes(platform)) {
+		let { printSize = "ISO_A4", label = "" } = options;
+		platform === "ANDROID_APP" && 
+		webToNative.setPrintSize(JSON.stringify({
+			printSize,
+			label
+		} as PrintingAndroidParams));
+	}
+};

package/src/Printing/types.ts

@@ -0,0 +1,9 @@
+export interface PrintingOptions {
+	printSize?: string;
+	label?: string;
+}
+
+export interface PrintingAndroidParams {
+	printSize: string;
+	label: string;
+}

package/src/Screen/index.ts

@@ -0,0 +1,34 @@
+import { platform, webToNative, webToNativeIos } from "../utills";
+import { ScreenIosMessage } from "./types";
+
+/**
+ * Keeps the screen on (prevents screen from turning off)
+ */
+export const keepScreenOn = (): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "keepScreenOn",
+				flag: true,
+			} as ScreenIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.keepScreenOn();
+	}
+};
+
+/**
+ * Returns screen to normal behavior (allows screen to turn off)
+ */
+export const keepScreenNormal = (): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "keepScreenOn",
+				flag: false,
+			} as ScreenIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.keepScreenNormal();
+	}
+};

package/src/Screen/types.ts

@@ -0,0 +1,8 @@
+// Define types for Screen module
+
+// iOS message structure
+export interface ScreenIosMessage {
+  action: string;
+  flag?: boolean;
+  [key: string]: any;
+}

package/src/Siri/index.ts

@@ -0,0 +1,23 @@
+import { platform, webToNativeIos } from "../utills";
+import { SiriOptions, SiriIosMessage } from "./types";
+
+/**
+ * Adds an action to Siri (iOS only)
+ * @param options - Options for adding to Siri
+ */
+export const addToSiri = (options: SiriOptions = {}): void => {
+	const { actionUrl, suggestedPhrase, title } = options;
+	if (["IOS_APP"].includes(platform)) {
+		
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				"action": "addToSiri",
+				"data": {
+					actionUrl,
+					suggestedPhrase,
+					title
+				}
+			} as SiriIosMessage);
+		}
+	}
+};

package/src/Siri/types.ts

@@ -0,0 +1,14 @@
+export interface SiriOptions {
+	actionUrl?: string;
+	suggestedPhrase?: string;
+	title?: string;
+}
+
+export interface SiriIosMessage {
+	action: string;
+	data?: {
+		actionUrl?: string;
+		suggestedPhrase?: string;
+		title?: string;
+	};
+}

package/src/SocialLogin/apple.ts

@@ -0,0 +1,31 @@
+import { platform, registerCb, webToNativeIos } from "../utills";
+import { SocialLoginOptions, AppleLoginResponse, AppleIosMessage } from "./types";
+
+/**
+ * This function handles native Apple login
+ * @param options - Options for Apple login
+ * @example wtn.socialLogin.apple.login({
+ *  callback:(data)=>{
+ *    console.log(data);
+ *  }
+ * });
+ */
+export const login = (options: SocialLoginOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { callback, scope } = options;
+
+		registerCb((response: AppleLoginResponse) => {
+			const { type } = response;
+			if (type === "appleLoginToken") {
+				callback && callback(response);
+			}
+		});
+		
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "appleSignIn",
+				scope,
+			} as AppleIosMessage);
+		}
+	}
+};

package/src/SocialLogin/facebook.ts

@@ -0,0 +1,64 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import { SocialLoginOptions, FacebookLoginResponse, FacebookLogoutResponse, FacebookIosMessage } from "./types";
+
+/**
+ * This function handles native facebook login
+ * @param options - Options for Facebook login
+ * @example wtn.socialLogin.facebook.login({
+ *  callback:(data)=>{
+ *    console.log(data);
+ *  }
+ * });
+ */
+export const login = (options: SocialLoginOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { callback, scope } = options;
+
+		registerCb((response: FacebookLoginResponse) => {
+			const { type } = response;
+			if (type === "fbLoginToken") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.loginWithFacebook();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "fbSignIn",
+				scope,
+			} as FacebookIosMessage);
+		}
+	}
+};
+
+/**
+ * This function handles native facebook logout
+ * @param options - Options for Facebook logout
+ * @example wtn.socialLogin.facebook.logout({
+ *  callback:(data)=>{
+ *    console.log(data);
+ *  }
+ * });
+ */
+export const logout = (options: SocialLoginOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { callback, scope } = options;
+
+		registerCb((response: FacebookLogoutResponse) => {
+			const { type } = response;
+			if (type === "fbLogOut") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.logoutWithFacebook();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "fbSignOut",
+				scope,
+			} as FacebookIosMessage);
+		}
+	}
+};