webtonative 1.0.74 → 1.0.75-beta.2

package/package.json

@@ -1,32 +1,37 @@
 {
-    "name": "webtonative",
-    "version": "1.0.74",
-    "description": "",
-    "main": "index.js",
-    "scripts": {
-        "build": "rimraf build && babel src --presets @babel/preset-env,minify --out-dir build && node buildScript.js && npm run dist",
-        "test": "echo \"Error: no test specified\" && exit 1",
-        "dist": "NODE_ENV=production webpack --config webpack.config.js"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/webtonative/webtonative.git"
-    },
-    "author": "",
-    "license": "ISC",
-    "bugs": {
-        "url": "https://github.com/webtonative/webtonative/issues"
-    },
-    "homepage": "https://github.com/webtonative/webtonative#readme",
-    "dependencies": {},
-    "devDependencies": {
-        "@babel/cli": "^7.14.5",
-        "@babel/core": "^7.14.6",
-        "@babel/preset-env": "^7.14.7",
-        "babel-loader": "^8.2.2",
-        "babel-preset-minify": "^0.5.1",
-        "rimraf": "^3.0.2",
-        "webpack": "^5.40.0",
-        "webpack-cli": "^4.7.2"
-    }
-}
+	"name": "webtonative",
+	"version": "1.0.75-beta.2",
+	"description": "",
+	"main": "build/index.js",
+	"types": "build/index.d.ts",
+	"scripts": {
+		"build": "rimraf build && tsc && ts-node buildScript.ts && npm run dist",
+		"test": "echo \"Error: no test specified\" && exit 1",
+		"dist": "NODE_ENV=production webpack --config webpack.config.js"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/webtonative/webtonative.git"
+	},
+	"author": "",
+	"license": "ISC",
+	"bugs": {
+		"url": "https://github.com/webtonative/webtonative/issues"
+	},
+	"homepage": "https://github.com/webtonative/webtonative#readme",
+	"dependencies": {},
+	"devDependencies": {
+		"@babel/cli": "^7.14.5",
+		"@babel/core": "^7.14.6",
+		"@babel/preset-env": "^7.14.7",
+		"@types/node": "^18.11.18",
+		"babel-loader": "^8.2.2",
+		"babel-preset-minify": "^0.5.1",
+		"rimraf": "^3.0.2",
+		"ts-loader": "^9.4.2",
+		"ts-node": "^10.9.1",
+		"typescript": "^4.9.4",
+		"webpack": "^5.40.0",
+		"webpack-cli": "^4.7.2"
+	}
+}

package/src/ATTConsent/index.ts

@@ -0,0 +1,51 @@
+import { platform, registerCb, webToNativeIos } from "../utills";
+import { ATTConsentOptions, ATTConsentResponse, ATTConsentIosMessage } from "./types";
+
+/**
+ * This function opens ATTConsent
+ * @param options - Options for ATT consent request
+ * @example wtn.ATTConsent.request({
+ *  callback:(value)=>{
+ *    console.log(value);
+ *  }
+ * });
+ */
+export const request = (options: ATTConsentOptions = {}): void => {
+	const { callback } = options;
+	if (["IOS_APP"].includes(platform)) {
+		registerCb((response: ATTConsentResponse) => {
+			const { type } = response;
+			if (type === "requestTrackingConsent") {
+				callback && callback(response);
+			}
+		});
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "requestTrackingAuthorization",
+			} as ATTConsentIosMessage);
+		}
+	}
+};
+
+/**
+ * This function gets the current ATT consent status
+ * @param options - Options for ATT consent status
+ */
+export const status = (options: ATTConsentOptions = {}): void => {
+	const { callback } = options;
+	if (["IOS_APP"].includes(platform)) {
+		registerCb((response: ATTConsentResponse) => {
+			const { type } = response;
+			if (type === "trackingConsentStatus") {
+				callback && callback(response);
+			}
+		});
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "trackingConsentStatus",
+			} as ATTConsentIosMessage);
+		}
+	}
+};

package/src/ATTConsent/types.ts

@@ -0,0 +1,17 @@
+export interface ATTConsentResponse {
+	type: string;
+	status?: string;
+	[key: string]: any;
+}
+
+export interface ATTConsentCallback {
+	(response: ATTConsentResponse): void;
+}
+
+export interface ATTConsentOptions {
+	callback?: ATTConsentCallback;
+}
+
+export interface ATTConsentIosMessage {
+	action: string;
+}

package/src/AdMob/index.ts

@@ -0,0 +1,113 @@
+import {
+	webToNative,
+	isNativeApp,
+	registerForAbMobCb,
+	deRegisterForAbMobCb,
+	platform,
+	webToNativeIos,
+} from "../utills";
+import { Platform } from "../types";
+import {
+	AdMobResponse,
+	AdMobCallback,
+	BannerAdOptions,
+	FullScreenAdOptions,
+	RewardsAdOptions,
+	AdMobIosMessage
+} from "./types";
+
+let adMobCb: AdMobCallback | null = null;
+
+/**
+ * This function shows banner ad
+ * @param options - Banner ad options
+ * @example wtn.bannerAd({
+ *  adId: "ca-app-pub-xxx"
+ * });
+ */
+const bannerAd = (options: BannerAdOptions = {}): any => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "showBannerAd",
+				adId: options.adId || "",
+			} as AdMobIosMessage);
+		}
+		platform === "ANDROID_APP" && webToNative.showBannerAd(JSON.stringify(options));
+		return this;
+	}
+};
+
+/**
+ * This function shows full screen ad
+ * @param options - Full screen ad options
+ * @example wtn.fullScreenAd({
+ *  fullScreenAdCallback:(value)=>{
+ *    console.log(value);
+ *  }
+ * });
+ */
+const fullScreenAd = (options: FullScreenAdOptions = {}): any => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { fullScreenAdCallback } = options;
+		registerForAbMobCb((response: AdMobResponse) => {
+			const { status } = response;
+			adMobCb && adMobCb(response);
+			if (status === "adDismissed") {
+				adMobCb = null;
+			}
+			if (["adDismissed", "adLoadError", "adError"].indexOf(status) > -1) {
+				deRegisterForAbMobCb();
+			}
+		});
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "showFullScreenAd",
+				adId: options.adId || "",
+			} as AdMobIosMessage);
+		}
+		platform === "ANDROID_APP" && webToNative.showFullScreenAd(JSON.stringify(options));
+		if (typeof fullScreenAdCallback === "function") {
+			adMobCb = fullScreenAdCallback;
+		}
+		return this;
+	}
+};
+
+/**
+ * This function shows rewards ad
+ * @param options - Rewards ad options
+ * @example wtn.rewardsAd({
+ *  rewardsAdCallback:(value)=>{
+ *    console.log(value);
+ *  }
+ * });
+ */
+const rewardsAd = (options: RewardsAdOptions = {}): any => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { rewardsAdCallback } = options;
+		registerForAbMobCb((response: AdMobResponse) => {
+			const { status } = response;
+			adMobCb && adMobCb(response);
+			if (status === "adDismissed") {
+				adMobCb = null;
+			}
+			if (["adDismissed", "adLoadError", "adError"].indexOf(status) > -1) {
+				deRegisterForAbMobCb();
+			}
+		});
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "showRewardAd",
+				adId: options.adId || "",
+			} as AdMobIosMessage);
+		}
+		platform === "ANDROID_APP" && webToNative.showRewardsAd(JSON.stringify(options));
+		if (typeof rewardsAdCallback === "function") {
+			adMobCb = rewardsAdCallback;
+		}
+		return this;
+	}
+};
+
+export { bannerAd, fullScreenAd, rewardsAd };

package/src/AdMob/types.ts

@@ -0,0 +1,37 @@
+// Define types for AdMob module
+
+// AdMob response interface
+export interface AdMobResponse {
+  status: 'adDismissed' | 'adLoadError' | 'adError' | string;
+  [key: string]: any;
+}
+
+// AdMob callback function type
+export type AdMobCallback = (response: AdMobResponse) => void;
+
+// Banner ad options
+export interface BannerAdOptions {
+  adId?: string;
+  [key: string]: any;
+}
+
+// Full screen ad options
+export interface FullScreenAdOptions {
+  adId?: string;
+  fullScreenAdCallback?: AdMobCallback;
+  [key: string]: any;
+}
+
+// Rewards ad options
+export interface RewardsAdOptions {
+  adId?: string;
+  rewardsAdCallback?: AdMobCallback;
+  [key: string]: any;
+}
+
+// iOS message structure
+export interface AdMobIosMessage {
+  action: string;
+  adId?: string;
+  [key: string]: any;
+}

package/src/AppReview/index.ts

@@ -0,0 +1,19 @@
+import { platform, registerCb, webToNativeIos, webToNative } from "../utills";
+import { AppReviewOptions, AppReviewIosMessage } from "./types";
+
+/**
+ * Shows the app review/rating prompt
+ * @param options - Options for app review prompt
+ */
+export const prompt = (options: AppReviewOptions = {}): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "showAppRating",
+			} as AppReviewIosMessage);
+		}
+		
+		platform === "ANDROID_APP" &&
+			webToNative.showInAppReview();
+	}
+};

package/src/AppReview/types.ts

@@ -0,0 +1,12 @@
+// Define types for AppReview module
+
+// iOS message structure
+export interface AppReviewIosMessage {
+  action: string;
+  [key: string]: any;
+}
+
+// Options for app review prompt
+export interface AppReviewOptions {
+  [key: string]: any;
+}

package/src/AppsFlyer/index.ts

@@ -0,0 +1,46 @@
+import {
+    platform,
+    webToNative,
+    webToNativeIos,
+  } from "../utills";
+import { AppsFlyerEventValues, AppsFlyerIosMessage } from "./types";
+
+/**
+ * Sets the AppsFlyer customer user ID
+ * @param userId - The user ID to set
+ * @example wtn.appsflyer.setCustomerUserId("1234");
+ */
+export const setCustomerUserId = (userId: string): void => {
+  if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+    platform === "ANDROID_APP" &&
+      webToNative.setAppsFlyerUserId(userId);
+
+    if (platform === "IOS_APP" && webToNativeIos) {
+      webToNativeIos.postMessage({
+        action: "setAppsFlyerUserId",
+        userId
+      } as AppsFlyerIosMessage);
+    }
+  }
+};
+
+/**
+ * Logs an event to AppsFlyer
+ * @param eventName - The name of the event
+ * @param eventValues - The values associated with the event
+ * @example wtn.appsflyer.logEvent("ADD_TO_CART",{name:"Cadburry",quantity:1});
+ */
+export const logEvent = (eventName: string, eventValues: AppsFlyerEventValues): void => {
+  if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+    platform === "ANDROID_APP" &&
+      webToNative.addEventToAppsFlyer(eventName, JSON.stringify(eventValues));
+
+    if (platform === "IOS_APP" && webToNativeIos) {
+      webToNativeIos.postMessage({
+        action: "addEventToAppsFlyer",
+        eventName,
+        eventValues
+      } as AppsFlyerIosMessage);
+    }
+  }
+};

package/src/AppsFlyer/types.ts

@@ -0,0 +1,10 @@
+export interface AppsFlyerEventValues {
+	[key: string]: any;
+}
+
+export interface AppsFlyerIosMessage {
+	action: string;
+	userId?: string;
+	eventName?: string;
+	eventValues?: AppsFlyerEventValues;
+}

package/src/BackgroundLocation/index.ts

@@ -0,0 +1,78 @@
+import { platform, webToNative, webToNativeIos, registerCb, deRegisterCbByKey } from "../utills";
+import { BackgroundLocationOptions, BackgroundLocationIosMessage, LocationUpdateResponse } from "./types";
+
+/**
+ * Starts tracking background location
+ * @param options - Background location tracking options
+ */
+export const start = (options: BackgroundLocationOptions = {}): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const {
+			data,
+			callback,
+			backgroundIndicator = false,
+			pauseAutomatically = true,
+			distanceFilter = 0.0,
+			desiredAccuracy = "best",
+			activityType = "other",
+			apiUrl,
+			timeout,
+		} = options;
+
+		registerCb(
+			(response: LocationUpdateResponse) => {
+				const { type } = response;
+				if (type === "LOCATION_UPDATE") {
+					callback && callback(response);
+				}
+			},
+			{
+				key: "LOCATION_UPDATE",
+				ignoreDelete: true,
+			}
+		);
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "startLocation",
+				data,
+				backgroundIndicator,
+				pauseAutomatically,
+				distanceFilter,
+				desiredAccuracy,
+				activityType,
+				apiUrl,
+				timeout,
+			} as BackgroundLocationIosMessage);
+		}
+
+		platform === "ANDROID_APP" &&
+			webToNative.startTrackingLocation(JSON.stringify({
+				action: "startLocation",
+				data,
+				interval: timeout,
+				callback,
+				apiUrl,
+				displacement: distanceFilter
+			}));
+	}
+};
+
+/**
+ * Stops tracking background location
+ * @param options - Options for stopping location tracking
+ */
+export const stop = (options: Record<string, any> = {}): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		deRegisterCbByKey("LOCATION_UPDATE");
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "stopLocation",
+			} as BackgroundLocationIosMessage);
+		}
+
+		platform === "ANDROID_APP" &&
+			webToNative.stopTrackingLocation();
+	}
+};

package/src/BackgroundLocation/types.ts

@@ -0,0 +1,34 @@
+export interface LocationUpdateResponse {
+	type: string;
+	latitude?: number;
+	longitude?: number;
+	[key: string]: any;
+}
+
+export interface LocationCallback {
+	(response: LocationUpdateResponse): void;
+}
+
+export interface BackgroundLocationOptions {
+	data?: any;
+	callback?: LocationCallback;
+	backgroundIndicator?: boolean;
+	pauseAutomatically?: boolean;
+	distanceFilter?: number;
+	desiredAccuracy?: 'best' | 'bestForNavigation' | 'nearestTenMeters' | 'hundredMeters' | 'kilometer' | 'threeKilometers';
+	activityType?: 'other' | 'automotiveNavigation' | 'fitness' | 'otherNavigation';
+	apiUrl?: string;
+	timeout?: number;
+}
+
+export interface BackgroundLocationIosMessage {
+	action: string;
+	data?: any;
+	backgroundIndicator?: boolean;
+	pauseAutomatically?: boolean;
+	distanceFilter?: number;
+	desiredAccuracy?: string;
+	activityType?: string;
+	apiUrl?: string;
+	timeout?: number;
+}

package/src/Beacon/index.ts

@@ -0,0 +1,28 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import { BeaconOptions, BeaconResponse, BeaconIosMessage } from "./types";
+
+/**
+ * Initializes beacon data
+ * @param options - Options for initializing beacon data
+ */
+export const initBeaconData = (options: BeaconOptions = {}): void => {
+	const { callback, beaconData } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: BeaconResponse) => {
+			const { type } = response;
+			if (type === "initBeaconData") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.initBeaconData(JSON.stringify(beaconData));
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "initBeaconData",
+				data: beaconData
+			} as BeaconIosMessage);
+		}
+	}
+};

package/src/Beacon/types.ts

@@ -0,0 +1,22 @@
+export interface BeaconResponse {
+	type: string;
+	[key: string]: any;
+}
+
+export interface BeaconCallback {
+	(response: BeaconResponse): void;
+}
+
+export interface BeaconData {
+	[key: string]: any;
+}
+
+export interface BeaconOptions {
+	callback?: BeaconCallback;
+	beaconData?: BeaconData;
+}
+
+export interface BeaconIosMessage {
+	action: string;
+	data?: BeaconData;
+}

package/src/Biometric/index.ts

@@ -0,0 +1,126 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import { BiometricOptions, BiometricResponse, BiometricIosMessage, BiometricAuthOptions } from "./types";
+
+/**
+ * Checks the status of biometric authentication
+ * @param options - Options for checking biometric status
+ */
+export const checkStatus = (options: BiometricOptions = {}): void => {
+	const { callback } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: BiometricResponse) => {
+			const { type } = response;
+			if (type === "checkBiometricStatus") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.checkBiometricStatus();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "checkBiometricStatus",
+			} as BiometricIosMessage);
+		}
+	}
+};
+
+/**
+ * Saves a secret using biometric authentication
+ * @param options - Options for saving biometric secret
+ */
+export const saveSecret = (options: BiometricOptions = {}): void => {
+	const { callback, secret } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: BiometricResponse) => {
+			const { type } = response;
+			if (type === "saveBiometricSecret") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.saveSecret(secret);
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "saveBiometricSecret",
+				secret
+			} as BiometricIosMessage);
+		}
+	}
+};
+
+/**
+ * Deletes a saved biometric secret
+ * @param options - Options for deleting biometric secret
+ */
+export const deleteSecret = (options: BiometricOptions = {}): void => {
+	const { callback } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: BiometricResponse) => {
+			const { type } = response;
+			if (type === "deleteBiometricSecret") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.deleteSecret();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "deleteBiometricSecret",
+			} as BiometricIosMessage);
+		}
+	}
+};
+
+/**
+ * Shows biometric authentication prompt
+ * @param options - Options for showing biometric prompt
+ */
+export const show = (options: BiometricOptions = {}): void => {
+	const { callback, prompt } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: BiometricResponse) => {
+			const { type } = response;
+			if (type === "showBiometric") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.callBiometric(prompt || "Authenticate to continue!");
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "showBiometric",
+				prompt: prompt || '',
+			} as BiometricIosMessage);
+		}
+	}
+};
+
+/**
+ * Shows biometric authentication with dismiss on cancel (Android only)
+ * @param options - Options for biometric authentication with dismiss on cancel
+ */
+export const biometricAuthWithDismissOnCancel = (options: BiometricOptions = {}): void => {
+	const { callback, prompt, isAuthenticationOptional = false } = options;
+	if (["ANDROID_APP"].includes(platform)) {
+		registerCb((response: BiometricResponse) => {
+			const { type } = response;
+			if (type === "biometricAuthWithDismissOnCancel") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.biometricAuthWithDismissOnCancel(JSON.stringify({
+				prompt: prompt || "Authenticate to continue!",
+				isAuthenticationOptional
+			} as BiometricAuthOptions));
+	}
+};