webtonative 1.0.74 → 1.0.75-beta.2

package/src/Biometric/types.ts

@@ -0,0 +1,27 @@
+export interface BiometricResponse {
+	type: string;
+	status?: string;
+	[key: string]: any;
+}
+
+export interface BiometricCallback {
+	(response: BiometricResponse): void;
+}
+
+export interface BiometricOptions {
+	callback?: BiometricCallback;
+	secret?: string;
+	prompt?: string;
+	isAuthenticationOptional?: boolean;
+}
+
+export interface BiometricIosMessage {
+	action: string;
+	secret?: string;
+	prompt?: string;
+}
+
+export interface BiometricAuthOptions {
+	prompt?: string;
+	isAuthenticationOptional?: boolean;
+}

package/src/Bluetooth/index.ts

@@ -0,0 +1,71 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import { 
+	BluetoothScanOptions, 
+	BluetoothPairOptions, 
+	BluetoothUnpairOptions, 
+	BluetoothResponse,
+	BluetoothPairParams,
+	BluetoothUnpairParams
+} from "./types";
+
+/**
+ * Starts scanning for Bluetooth devices (Android only)
+ * @param options - Options for Bluetooth scanning
+ */
+export const startBluetoothScan = (options: BluetoothScanOptions = {}): void => {
+	const { callback } = options;
+	if (["ANDROID_APP"].includes(platform)) {
+		registerCb((response: BluetoothResponse) => {
+			const { type } = response;
+			if (type === "startBluetoothScan") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.startBluetoothScan();
+	}
+};
+
+/**
+ * Pairs with a Bluetooth device (Android only)
+ * @param options - Options for pairing with a Bluetooth device
+ */
+export const pairDevice = (options: BluetoothPairOptions = {}): void => {
+	const { callback, address, timeout = 10 } = options;
+	if (["ANDROID_APP"].includes(platform)) {
+		registerCb((response: BluetoothResponse) => {
+			const { type } = response;
+			if (type === "pairWithDevice") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.pairWithDevice(JSON.stringify({
+				address,
+				timeout
+		} as BluetoothPairParams));
+	}
+};
+
+/**
+ * Unpairs from a Bluetooth device (Android only)
+ * @param options - Options for unpairing from a Bluetooth device
+ */
+export const unpairDevice = (options: BluetoothUnpairOptions = {}): void => {
+	const { callback, address } = options;
+	if (["ANDROID_APP"].includes(platform)) {
+		registerCb((response: BluetoothResponse) => {
+			const { type } = response;
+			if (type === "unpairDevice") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" &&
+        	webToNative.unpairDevice(JSON.stringify({
+				address
+			} as BluetoothUnpairParams));
+	}
+};

package/src/Bluetooth/types.ts

@@ -0,0 +1,40 @@
+export interface BluetoothResponse {
+	type: string;
+	status?: string;
+	devices?: BluetoothDevice[];
+	[key: string]: any;
+}
+
+export interface BluetoothDevice {
+	name?: string;
+	address?: string;
+	[key: string]: any;
+}
+
+export interface BluetoothCallback {
+	(response: BluetoothResponse): void;
+}
+
+export interface BluetoothScanOptions {
+	callback?: BluetoothCallback;
+}
+
+export interface BluetoothPairOptions {
+	callback?: BluetoothCallback;
+	address?: string;
+	timeout?: number;
+}
+
+export interface BluetoothUnpairOptions {
+	callback?: BluetoothCallback;
+	address?: string;
+}
+
+export interface BluetoothPairParams {
+	address?: string;
+	timeout?: number;
+}
+
+export interface BluetoothUnpairParams {
+	address?: string;
+}

package/src/BottomNavigation/index.ts

@@ -0,0 +1,39 @@
+import { platform, webToNative, webToNativeIos } from "../utills";
+import { BottomNavigationShowOptions, BottomNavigationIosMessage } from "./types";
+
+/**
+ * Hides the bottom navigation
+ */
+export const hide = (): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		platform === "ANDROID_APP" &&
+        	webToNative.showHideStickyFooter(false);
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "showHideStickyFooter",
+				show: false,
+			} as BottomNavigationIosMessage);
+		}
+	}
+};
+
+/**
+ * Shows the bottom navigation
+ * @param options - Options for showing bottom navigation
+ */
+export const show = (options: BottomNavigationShowOptions = {}): void => {
+	const { key } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		platform === "ANDROID_APP" &&
+        	webToNative.showHideStickyFooter(true);
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "showHideStickyFooter",
+				show: true,
+				key,
+			} as BottomNavigationIosMessage);
+		}
+	}
+};

package/src/BottomNavigation/types.ts

@@ -0,0 +1,9 @@
+export interface BottomNavigationShowOptions {
+	key?: string;
+}
+
+export interface BottomNavigationIosMessage {
+	action: string;
+	show: boolean;
+	key?: string;
+}

package/src/Clipboard/index.ts

@@ -0,0 +1,48 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import {
+  ClipboardResponse,
+  GetClipboardOptions,
+  SetClipboardOptions,
+  ClipboardIosMessage
+} from "./types";
+
+/**
+ * Gets content from clipboard
+ * @param options - Options for getting clipboard content
+ */
+export const get = (options: GetClipboardOptions = {}): void => {
+	const { callback } = options;
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		registerCb((response: ClipboardResponse) => {
+			const { type } = response;
+			if (type === "CLIPBOARD_CONTENT") {
+				callback && callback(response);
+			}
+		});
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "getClipBoardData",
+			} as ClipboardIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.getText();
+	}
+};
+
+/**
+ * Sets content to clipboard
+ * @param options - Options for setting clipboard content
+ */
+export const set = (options: SetClipboardOptions = {}): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "setClipBoardData",
+				text: options.data || "",
+			} as ClipboardIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.setText(options.data || "");
+	}
+};

package/src/Clipboard/types.ts

@@ -0,0 +1,30 @@
+// Define types for Clipboard module
+
+// Clipboard response interface
+export interface ClipboardResponse {
+  type: string;
+  content?: string;
+  [key: string]: any;
+}
+
+// Clipboard callback function type
+export type ClipboardCallback = (response: ClipboardResponse) => void;
+
+// Get clipboard options
+export interface GetClipboardOptions {
+  callback?: ClipboardCallback;
+  [key: string]: any;
+}
+
+// Set clipboard options
+export interface SetClipboardOptions {
+  data?: string;
+  [key: string]: any;
+}
+
+// iOS message structure
+export interface ClipboardIosMessage {
+  action: string;
+  text?: string;
+  [key: string]: any;
+}

package/src/Facebook/events.ts

@@ -0,0 +1,45 @@
+import { platform, webToNative, webToNativeIos } from "../utills";
+import { FacebookEventOptions, FacebookPurchaseOptions, FacebookEventIosMessage } from "./types";
+
+/**
+ * Sends a Facebook event
+ * @param options - Options for the Facebook event
+ */
+export const send = (options: FacebookEventOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { event, valueToSum, parameters } = options;
+
+		platform === "ANDROID_APP" && webToNative.addFbEvents(event, parameters);
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "sendFBEvent",
+				eventName: event,
+				valueToSum,
+				parameters,
+			} as FacebookEventIosMessage);
+		}
+	}
+};
+
+/**
+ * Sends a Facebook purchase event
+ * @param options - Options for the Facebook purchase event
+ * @example wtn.facebook.events.sendPurchase({amount: 10.99, currency: "USD", parameters: {item_name: "Product"}});
+ */
+export const sendPurchase = (options: FacebookPurchaseOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { amount, currency, parameters } = options;
+
+		platform === "ANDROID_APP" && webToNative.addFbPurchaseEvent(amount, currency, parameters);
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "sendFBPurchaseEvent",
+				currency,
+				amount,
+				parameters,
+			} as FacebookEventIosMessage);
+		}
+	}
+};

package/src/Facebook/index.ts

@@ -0,0 +1,3 @@
+import * as events from "./events";
+
+export { events };

package/src/Facebook/types.ts

@@ -0,0 +1,24 @@
+export interface FacebookEventParameters {
+	[key: string]: any;
+}
+
+export interface FacebookEventOptions {
+	event: string;
+	valueToSum?: number;
+	parameters?: FacebookEventParameters;
+}
+
+export interface FacebookPurchaseOptions {
+	amount: number;
+	currency: string;
+	parameters?: FacebookEventParameters;
+}
+
+export interface FacebookEventIosMessage {
+	action: string;
+	eventName?: string;
+	valueToSum?: number;
+	parameters?: FacebookEventParameters;
+	currency?: string;
+	amount?: number;
+}

package/src/Firebase/Analytics/index.ts

@@ -0,0 +1,127 @@
+import { platform, webToNative, webToNativeIos } from "../../utills";
+import { 
+	FirebaseAnalyticsCollectionOptions,
+	FirebaseUserIdOptions,
+	FirebaseUserPropertyOptions,
+	FirebaseDefaultParametersOptions,
+	FirebaseEventOptions,
+	FirebaseScreenOptions,
+	FirebaseAnalyticsIosMessage
+} from "../types";
+
+/**
+ * Sets Firebase Analytics collection enabled or disabled
+ * @param options - Options for setting analytics collection
+ */
+export const setCollection = (options: FirebaseAnalyticsCollectionOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { enabled } = options;
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "setFirebaseAnalyticsCollection",
+				enabled,
+			} as FirebaseAnalyticsIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.setFirebaseAnalyticsCollection(enabled);
+	}
+};
+
+/**
+ * Sets Firebase user ID
+ * @param options - Options for setting user ID
+ */
+export const setUserId = (options: FirebaseUserIdOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { userId } = options;
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "setFirebaseUserId",
+				userId,
+			} as FirebaseAnalyticsIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.setFirebaseUserId(userId);
+	}
+};
+
+/**
+ * Sets a Firebase user property
+ * @param options - Options for setting user property
+ */
+export const setUserProperty = (options: FirebaseUserPropertyOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { key, value } = options;
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "setFirebaseUserProp",
+				key,
+				value,
+			} as FirebaseAnalyticsIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.setFirebaseUserProp(key, value);
+	}
+};
+
+/**
+ * Sets default event parameters for Firebase Analytics
+ * @param options - Options for setting default parameters
+ */
+export const setDefaultEventParameters = (options: FirebaseDefaultParametersOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { parameters } = options;
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "setFirebaseDefaultParam",
+				parameters,
+			} as FirebaseAnalyticsIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.setFirebaseDefaultParam(parameters);
+	}
+};
+
+/**
+ * Logs a Firebase Analytics event
+ * @param options - Options for logging an event
+ */
+export const logEvent = (options: FirebaseEventOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { eventName, parameters } = options;
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "logFirebaseEvent",
+				eventName,
+				parameters,
+			} as FirebaseAnalyticsIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.logFirebaseEvent(eventName, parameters);
+	}
+};
+
+/**
+ * Logs a Firebase Analytics screen view
+ * @param options - Options for logging a screen view
+ */
+export const logScreen = (options: FirebaseScreenOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { screenName, screenClass } = options;
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "logFirebaseScreenView",
+				screenName,
+				screenClass,
+			} as FirebaseAnalyticsIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.logFirebaseScreenView(screenName, screenClass);
+	}
+};

package/src/Firebase/Messaging/index.ts

@@ -0,0 +1,73 @@
+import { platform, webToNative, webToNativeIos, registerCb } from "../../utills";
+import { 
+	FirebaseTopicSubscriptionOptions,
+	FirebaseTopicUnsubscriptionOptions,
+	FirebaseFCMTokenOptions,
+	FirebaseFCMTokenResponse,
+	FirebaseMessagingIosMessage
+} from "../types";
+
+/**
+ * Subscribes to a Firebase Cloud Messaging topic
+ * @param options - Options for topic subscription
+ */
+export const subscribe = (options: FirebaseTopicSubscriptionOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { toTopic } = options;
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "firebaseSubscribeToTopic",
+				topic: toTopic,
+			} as FirebaseMessagingIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.subscribeToTopic(toTopic);
+	}
+};
+
+/**
+ * Unsubscribes from a Firebase Cloud Messaging topic
+ * @param options - Options for topic unsubscription
+ */
+export const unsubscribe = (options: FirebaseTopicUnsubscriptionOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { fromTopic } = options;
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "firebaseUnsubscribeFromTopic",
+				topic: fromTopic,
+			} as FirebaseMessagingIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.unsubscribeFromTopic(fromTopic);
+	}
+};
+
+/**
+ * Gets the Firebase Cloud Messaging token
+ * @param options - Options for getting FCM token
+ */
+export const getFCMToken = (options: FirebaseFCMTokenOptions): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		const { callback } = options;
+		registerCb((response: FirebaseFCMTokenResponse) => {
+			const { type } = response;
+			if (type === "getFCMToken") {
+				if (platform === "ANDROID_APP") {
+					response.token = response.fcm_registration_token;
+				}
+				callback && callback(response);
+			}
+		});
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "getFCMToken",
+			} as FirebaseMessagingIosMessage);
+		}
+
+		platform === "ANDROID_APP" && webToNative.getRegistrationToken();
+	}
+};

package/src/Firebase/index.ts

@@ -0,0 +1,4 @@
+import * as Analytics from "./Analytics";
+import * as Messaging from "./Messaging";
+
+export { Analytics, Messaging };

package/src/Firebase/types.ts

@@ -0,0 +1,74 @@
+// Common Firebase types
+
+export interface FirebaseAnalyticsCollectionOptions {
+	enabled: boolean;
+}
+
+export interface FirebaseUserIdOptions {
+	userId: string;
+}
+
+export interface FirebaseUserPropertyOptions {
+	key: string;
+	value: string;
+}
+
+export interface FirebaseEventParameters {
+	[key: string]: any;
+}
+
+export interface FirebaseDefaultParametersOptions {
+	parameters: FirebaseEventParameters;
+}
+
+export interface FirebaseEventOptions {
+	eventName: string;
+	parameters?: FirebaseEventParameters;
+}
+
+export interface FirebaseScreenOptions {
+	screenName: string;
+	screenClass?: string;
+}
+
+export interface FirebaseAnalyticsIosMessage {
+	action: string;
+	enabled?: boolean;
+	userId?: string;
+	key?: string;
+	value?: string;
+	parameters?: FirebaseEventParameters;
+	eventName?: string;
+	screenName?: string;
+	screenClass?: string;
+}
+
+// Firebase Messaging types
+
+export interface FirebaseTopicSubscriptionOptions {
+	toTopic: string;
+}
+
+export interface FirebaseTopicUnsubscriptionOptions {
+	fromTopic: string;
+}
+
+export interface FirebaseFCMTokenResponse {
+	type: string;
+	token?: string;
+	fcm_registration_token?: string;
+	[key: string]: any;
+}
+
+export interface FirebaseFCMTokenCallback {
+	(response: FirebaseFCMTokenResponse): void;
+}
+
+export interface FirebaseFCMTokenOptions {
+	callback?: FirebaseFCMTokenCallback;
+}
+
+export interface FirebaseMessagingIosMessage {
+	action: string;
+	topic?: string;
+}

package/src/FirebaseAnalytics/index.ts

@@ -0,0 +1,3 @@
+import * as FirebaseAnalyticsEvents from "../Firebase/Analytics";
+
+export { FirebaseAnalyticsEvents as events };

package/src/Haptics/index.ts

@@ -0,0 +1,17 @@
+import { platform, webToNativeIos } from "../utills";
+import { HapticsOptions, HapticsIosMessage } from "./types";
+
+/**
+ * Triggers a haptic feedback effect
+ * @param options - Options for the haptic effect
+ */
+export const trigger = (options: HapticsOptions = {}): void => {
+	if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "haptikEffect",
+				effect: options.effect,
+			} as HapticsIosMessage);
+		}
+	}
+};

package/src/Haptics/types.ts

@@ -0,0 +1,8 @@
+export interface HapticsOptions {
+	effect?: string;
+}
+
+export interface HapticsIosMessage {
+	action: string;
+	effect?: string;
+}