webtonative 1.0.74 → 1.0.75-beta.2

package/src/SocialLogin/google.ts

@@ -0,0 +1,64 @@
+import { platform, registerCb, webToNative, webToNativeIos } from "../utills";
+import { SocialLoginOptions, GoogleLoginResponse, GoogleLogoutResponse, GoogleIosMessage } from "./types";
+
+/**
+ * This function handles native Google login
+ * @param options - Options for Google login
+ * @example wtn.socialLogin.google.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: GoogleLoginResponse) => {
+			const { type } = response;
+			if (type === "googleLoginToken") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.signInWithGoogle();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "googleSignIn",
+				scope,
+			} as GoogleIosMessage);
+		}
+	}
+};
+
+/**
+ * This function handles native Google logout
+ * @param options - Options for Google logout
+ * @example wtn.socialLogin.google.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: GoogleLogoutResponse) => {
+			const { type } = response;
+			if (type === "googleLogOut") {
+				callback && callback(response);
+			}
+		});
+
+		platform === "ANDROID_APP" && webToNative.signOutWithGoogle();
+
+		if (platform === "IOS_APP" && webToNativeIos) {
+			webToNativeIos.postMessage({
+				action: "googleSignOut",
+				scope,
+			} as GoogleIosMessage);
+		}
+	}
+};

package/src/SocialLogin/index.ts

@@ -0,0 +1,20 @@
+import { login as loginFacebook, logout as logoutFacebook } from "./facebook";
+import { login as loginApple } from "./apple";
+import { login as loginGoogle, logout as logoutGoogle } from "./google";
+
+/**
+ * Social login module for Facebook, Google, and Apple authentication
+ */
+export const socialLogin = {
+	facebook: {
+		login: loginFacebook,
+		logout: logoutFacebook,
+	},
+	google: {
+		login: loginGoogle,
+		logout: logoutGoogle,
+	},
+	apple: {
+		login: loginApple,
+	},
+};

package/src/SocialLogin/types.ts

@@ -0,0 +1,52 @@
+// Common types for social login
+export interface SocialLoginResponse {
+	type: string;
+	[key: string]: any;
+}
+
+export interface SocialLoginCallback {
+	(response: SocialLoginResponse): void;
+}
+
+export interface SocialLoginOptions {
+	callback?: SocialLoginCallback;
+	scope?: string;
+}
+
+// Facebook types
+export interface FacebookLoginResponse extends SocialLoginResponse {
+	type: 'fbLoginToken';
+}
+
+export interface FacebookLogoutResponse extends SocialLoginResponse {
+	type: 'fbLogOut';
+}
+
+export interface FacebookIosMessage {
+	action: 'fbSignIn' | 'fbSignOut';
+	scope?: string;
+}
+
+// Google types
+export interface GoogleLoginResponse extends SocialLoginResponse {
+	type: 'googleLoginToken';
+}
+
+export interface GoogleLogoutResponse extends SocialLoginResponse {
+	type: 'googleLogOut';
+}
+
+export interface GoogleIosMessage {
+	action: 'googleSignIn' | 'googleSignOut';
+	scope?: string;
+}
+
+// Apple types
+export interface AppleLoginResponse extends SocialLoginResponse {
+	type: 'appleLoginToken';
+}
+
+export interface AppleIosMessage {
+	action: 'appleSignIn';
+	scope?: string;
+}

package/src/Stripe/index.ts

@@ -0,0 +1,54 @@
+import { platform, webToNative, webToNativeIos, registerCb } from "../utills";
+import { StripeOptions, StripePaymentData, StripeIosMessage } from "./types";
+
+export const makeTapToPay = (options: StripeOptions): void => {
+    if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+        const { 
+            callback, 
+            apiUrl = null, 
+            amount, 
+            currency, 
+            isSimulated = false, 
+            captureMethod = "automatic", 
+            connectionToken, 
+            stripeLocationId, 
+            clientSecret = null 
+        } = options;
+        
+        registerCb((response) => {
+            const { type } = response;
+            if (type === "makeTapToPayStripePayment") {
+                callback && callback(response);
+            }
+        });
+
+        let paymentData: StripePaymentData = {
+            secretToken: connectionToken,
+            amount,
+            currency,
+            isSimulated,
+            captureMethod,
+            locationId: stripeLocationId
+        };
+        
+        if (apiUrl) {
+            paymentData.apiUrl = apiUrl;
+        }
+        
+        if (clientSecret) {
+            paymentData.client_secret = clientSecret;
+        }
+        
+        if (platform === "ANDROID_APP") {
+            webToNative.makeTapToPayStripePayment(JSON.stringify(paymentData));
+        }
+
+        if (platform === "IOS_APP" && webToNativeIos) {
+            const iosMessage: StripeIosMessage = {
+                "action": "makeTapToPayStripePayment",
+                ...paymentData
+            };
+            webToNativeIos.postMessage(iosMessage);
+        }
+    }
+};

package/src/Stripe/types.ts

@@ -0,0 +1,37 @@
+import { BaseCallback, BaseResponse } from "../types";
+
+export interface StripeResponse extends BaseResponse {
+  type: "makeTapToPayStripePayment";
+  // Additional response properties can be added here based on actual response structure
+}
+
+export interface StripeCallback extends BaseCallback {
+  (response: StripeResponse): void;
+}
+
+export interface StripePaymentData {
+  secretToken: string;
+  amount: number;
+  currency: string;
+  isSimulated: boolean;
+  captureMethod: string;
+  locationId: string;
+  apiUrl?: string;
+  client_secret?: string;
+}
+
+export interface StripeOptions {
+  callback?: StripeCallback;
+  apiUrl?: string;
+  amount: number;
+  currency: string;
+  isSimulated?: boolean;
+  captureMethod?: string;
+  connectionToken: string;
+  stripeLocationId: string;
+  clientSecret?: string;
+}
+
+export interface StripeIosMessage extends StripePaymentData {
+  action: string;
+}

package/src/VoiceSearch/index.ts

@@ -0,0 +1,37 @@
+import { webToNative, isNativeApp, registerCb } from "../utills";
+import { VoiceSearchOptions, VoiceSearchCallback, VoiceSearchResponse } from "./types";
+
+let voiceSearchCb: VoiceSearchCallback | null = null;
+
+/**
+ * This function opens native voice search
+ * @param options Configuration options for voice search
+ * @example wtn.openVoiceSearch({
+ *  onVoiceSearch:(value)=>{
+ *    console.log(value);
+ *  }
+ * });
+ */
+const openVoiceSearch = (options: VoiceSearchOptions = {}): any => {
+  const { onVoiceSearch } = options;
+  
+  registerCb((response) => {
+    const { type, results } = response as VoiceSearchResponse;
+    if (type === "VOICE_SEARCH_RESULT") {
+      voiceSearchCb && voiceSearchCb(results);
+      voiceSearchCb = null;
+    }
+  });
+  
+  if (isNativeApp) {
+    webToNative.openVoiceSearch();
+  }
+  
+  if (typeof onVoiceSearch === "function") {
+    voiceSearchCb = onVoiceSearch;
+  }
+  
+  return this;
+};
+
+export default openVoiceSearch;

package/src/VoiceSearch/types.ts

@@ -0,0 +1,12 @@
+import { BaseResponse } from "../types";
+
+export interface VoiceSearchResponse extends BaseResponse {
+  type: "VOICE_SEARCH_RESULT";
+  results: string;
+}
+
+export type VoiceSearchCallback = (results: string) => void;
+
+export interface VoiceSearchOptions {
+  onVoiceSearch?: VoiceSearchCallback;
+}

package/src/barcode/barcode-scan.ts

@@ -0,0 +1,59 @@
+import {
+  isNativeApp,
+  platform,
+  webToNative,
+  registerCb,
+  webToNativeIos,
+} from "../utills";
+import Format from "./formats";
+
+// Define interfaces for barcode scanner
+interface BarcodeScanOptions {
+  onBarcodeSearch?: (value: string) => void;
+  format?: number;
+}
+
+interface BarcodeScanResponse {
+  type: string;
+  value: string;
+  [key: string]: any;
+}
+
+/**
+ * This function opens native barcode scanner from Android/Ios app.
+ * @param {object} options
+ * @example wtn.onScanner({
+ *  onBarcodeSearch:(value)=>{
+ *    console.log(value);
+ *  }
+ * });
+ */
+const BarcodeScan = (options: BarcodeScanOptions): void => {
+  if (["ANDROID_APP", "IOS_APP"].includes(platform)) {
+    const { onBarcodeSearch, format } = options;
+
+    registerCb((response: BarcodeScanResponse) => {
+      const { type, value } = response;
+      if (type === "BARCODE_SCAN") {
+        onBarcodeSearch && onBarcodeSearch(value);
+      }
+    });
+    
+    if (platform === "ANDROID_APP" && webToNative.startScanner) {
+      webToNative.startScanner(
+        JSON.stringify({
+          formats: format ? [format] : [],
+        })
+      );
+    }
+    
+    if (platform === "IOS_APP" && webToNativeIos) {
+      webToNativeIos.postMessage({
+        action: "barcodeScan",
+        barcodeFormat: format ? String(format) : String(Format.ALL_FORMATS),
+      });
+    }
+  }
+};
+
+export default BarcodeScan;

package/src/barcode/barcode-types.ts

@@ -0,0 +1,22 @@
+import { BaseResponse } from "../types";
+
+export interface BarcodeScanResponse extends BaseResponse {
+  type: "BARCODE_SCAN";
+  value: string;
+}
+
+export type BarcodeScanCallback = (value: string) => void;
+
+export interface BarcodeScanOptions {
+  onBarcodeSearch?: BarcodeScanCallback;
+  format?: number;
+}
+
+export interface BarcodeScanAndroidParams {
+  formats: number[];
+}
+
+export interface BarcodeScanIosMessage {
+  action: string;
+  barcodeFormat: string;
+}

package/src/barcode/formats.ts

@@ -0,0 +1,19 @@
+// Barcode formats
+export enum BarcodeFormat {
+  ALL_FORMATS = 0,
+  CODE_128 = 1,
+  CODE_39 = 2,
+  CODE_93 = 4,
+  CODABAR = 8,
+  DATA_MATRIX = 16,
+  EAN_13 = 32,
+  EAN_8 = 64,
+  ITF = 128,
+  QR_CODE = 256,
+  UPC_A = 512,
+  UPC_E = 1024,
+  PDF417 = 2048,
+  AZTEC = 4096
+}
+
+export default BarcodeFormat;

package/src/barcode/index.ts

@@ -0,0 +1,5 @@
+import Format from "./formats";
+import Types from "./types";
+import BarcodeScan from "./barcode-scan";
+
+export { Format, Types, BarcodeScan };

package/src/barcode/types.ts

@@ -0,0 +1,18 @@
+// Barcode types
+export enum BarcodeType {
+  QR_CODE = 'QR_CODE',
+  DATA_MATRIX = 'DATA_MATRIX',
+  UPC_E = 'UPC_E',
+  UPC_A = 'UPC_A',
+  EAN_8 = 'EAN_8',
+  EAN_13 = 'EAN_13',
+  CODE_128 = 'CODE_128',
+  CODE_39 = 'CODE_39',
+  CODE_93 = 'CODE_93',
+  CODABAR = 'CODABAR',
+  ITF = 'ITF',
+  AZTEC = 'AZTEC',
+  PDF_417 = 'PDF_417'
+}
+
+export default BarcodeType;

package/src/index.ts

@@ -0,0 +1,105 @@
+/**
+ * Repository for webtonative javascript sdk. Build your android/ios app from https://webtonative.com.
+ * This is in beta phase.
+ * @example npm install webtonative
+ * import webtonative from "webtonative";
+ * const wtn = webtonative();
+ */
+import { isNativeApp, webToNative, platform, webToNativeIos, registerCb } from "./utills";
+import { StatusBarOptions, DownloadBlobFileOptions, CustomFileDownloadOptions } from "./types";
+
+export const isAndroidApp: boolean = platform === "ANDROID_APP";
+export const isIosApp: boolean = platform === "IOS_APP";
+
+/**
+ * This function hides splash screen
+ * @example wtn.hideSplashScreen()
+ */
+export const hideSplashScreen = (): void => {
+	isNativeApp && webToNative.hideSplashScreen && webToNative.hideSplashScreen();
+};
+
+export const statusBar = (options: StatusBarOptions): void => {
+	if (isNativeApp) {
+		if (isAndroidApp) {
+			webToNative.statusBar && webToNative.statusBar(JSON.stringify(options));
+		} else if (isIosApp) {
+			webToNativeIos && webToNativeIos.postMessage({
+				action: "statusBar",
+				color: options.color,
+				style: options.style,
+			});
+		}
+	}
+};
+
+export const downloadFile = (downloadUrl: string): void => {
+	if (isNativeApp) {
+		if (isAndroidApp) {
+			// Android implementation
+		} else if (isIosApp) {
+			webToNativeIos && webToNativeIos.postMessage({
+				action: "downloadFile",
+				downloadUrl,
+			});
+		}
+	}
+};
+
+export const downloadBlobFile = ({fileName, downloadUrl}: DownloadBlobFileOptions): void => {
+	if (["IOS_APP"].includes(platform)) {
+		isIosApp && webToNativeIos && webToNativeIos.postMessage({
+			action: "downloadBlobFile",
+			fileName,
+			url: downloadUrl,
+		});
+	}
+};
+
+export const customFileDownload = ({downloadUrl, fileName, isBlob, mimeType, cookies, userAgent, openFileAfterDownload}: CustomFileDownloadOptions): void => {
+	if (["ANDROID_APP"].includes(platform)) {
+		platform === "ANDROID_APP" && webToNative.downloadFile && webToNative.downloadFile(JSON.stringify({
+			url: downloadUrl,
+			fileName,
+			isBlob,
+			mimeType,
+			cookies,
+			userAgent,
+			openFileAfterDownload
+		}))
+	}
+}
+
+export const deviceInfo = (): Promise<any> => {
+	return new Promise((resolve, reject) => {
+		registerCb(
+			(results) => {
+				if (results) {
+					resolve(results);
+				} else {
+					reject({
+						err: "Error getting device info",
+					});
+				}
+			},
+			{
+				key: "deviceInfo",
+			}
+		);
+		if (platform === "ANDROID_APP") {
+			webToNative.getDeviceInfo && webToNative.getDeviceInfo();
+		} else if (platform === "IOS_APP") {
+			webToNativeIos && webToNativeIos.postMessage({
+				action: "deviceInfo",
+			});
+		} else {
+			reject("This function will work in Native App Powered By WebToNative");
+		}
+	});
+};
+
+export const showInAppReview = (): void => {
+	isNativeApp && webToNative.showInAppReview && webToNative.showInAppReview();
+};
+
+// Export all other functions from the original file

package/src/types/index.ts

@@ -0,0 +1,71 @@
+// Define common types used throughout the package
+
+// Platform types
+export type Platform = 'ANDROID_APP' | 'IOS_APP' | 'WEBSITE';
+
+// Base response interface for all native responses
+export interface BaseResponse {
+  type: string;
+  [key: string]: any;
+}
+
+// Base callback interface for all native callbacks
+export interface BaseCallback {
+  (response: BaseResponse): void;
+}
+
+// Callback function types
+export type CallbackFunction = (response: any) => void;
+
+// Register callback options
+export interface RegisterCallbackOptions {
+  key?: string;
+  ignoreDelete?: boolean;
+}
+
+// Status bar options
+export interface StatusBarOptions {
+  color?: string;
+  style?: 'light' | 'dark';
+}
+
+// Download file options
+export interface DownloadBlobFileOptions {
+  fileName: string;
+  downloadUrl: string;
+}
+
+// Custom file download options
+export interface CustomFileDownloadOptions {
+  downloadUrl: string;
+  fileName: string;
+  isBlob?: boolean;
+  mimeType?: string;
+  cookies?: string;
+  userAgent?: string;
+  openFileAfterDownload?: boolean;
+}
+
+// Device info response
+export interface DeviceInfoResponse {
+  [key: string]: any;
+}
+
+// Native interface
+export interface WebToNativeInterface {
+  getAndroidVersion?: () => string;
+  hideSplashScreen?: () => void;
+  statusBar?: (options: string) => void;
+  downloadFile?: (options: string) => void;
+  getDeviceInfo?: () => void;
+  showInAppReview?: () => void;
+  startScanner?: (options: string) => void;
+  androidCBHook?: (results: string) => void;
+  androidAdMobCBHook?: (results: string) => void;
+  [key: string]: any;
+}
+
+// iOS interface
+export interface WebToNativeIosInterface {
+  postMessage: (message: any) => void;
+}

package/src/utills.ts

@@ -0,0 +1,110 @@
+import { Platform, WebToNativeInterface, WebToNativeIosInterface, CallbackFunction, RegisterCallbackOptions } from './types';
+
+const isClient: boolean = typeof window !== "undefined";
+const webToNative: WebToNativeInterface = (isClient && (window as any).WebToNativeInterface) || {};
+const webToNativeIos: WebToNativeIosInterface | false =
+	isClient &&
+	(window as any).webkit &&
+	(window as any).webkit.messageHandlers &&
+	(window as any).webkit.messageHandlers.webToNativeInterface;
+const platform: Platform = webToNative.getAndroidVersion
+	? "ANDROID_APP"
+	: webToNativeIos
+	? "IOS_APP"
+	: "WEBSITE";
+const isNativeApp: boolean = isClient && platform !== "WEBSITE";
+const cbObj: Record<string | number, { cb: CallbackFunction; ignoreDelete?: boolean }> = {};
+let counter: number = 1;
+let abMobCb: CallbackFunction | null = null;
+if (isNativeApp) {
+	webToNative.androidCBHook = (results: string) => {
+		var response: any = results;
+		try {
+			response = JSON.parse(results);
+		} catch (e) {
+			console.log(e);
+		}
+		const { type } = response;
+		for (var key in cbObj) {
+			const { cb, ignoreDelete = false } = cbObj[key];
+			if (response && response.reqType) {
+				if (key == response["reqType"]) {
+					cb(response);
+					if (!ignoreDelete) {
+						delete cbObj[key];
+					}
+				}
+			} else {
+				cb(response);
+				if (!ignoreDelete) {
+					delete cbObj[key];
+				}
+			}
+		}
+	};
+	(window as any).iOSAdMobCBHook = webToNative.androidAdMobCBHook = (results: string) => {
+		const responseObj = JSON.parse(results);
+		abMobCb && abMobCb(responseObj);
+	};
+	(window as any).iosCBHook = (results: string) => {
+		var response: any = results;
+		try {
+			response = JSON.parse(results);
+		} catch (e) {
+			console.log(e);
+		}
+		for (var key in cbObj) {
+			const { cb, ignoreDelete = false } = cbObj[key];
+			if (response && response.reqType) {
+				if (key == response["reqType"]) {
+					cb(response);
+					if (!ignoreDelete) {
+						delete cbObj[key];
+					}
+				}
+			} else {
+				cb(response);
+				if (!ignoreDelete) {
+					delete cbObj[key];
+				}
+			}
+		}
+	};
+}
+
+const registerCb = (cb: CallbackFunction, obj?: RegisterCallbackOptions) => {
+	if (typeof cb === "function") {
+		if (obj && obj.key) {
+			cbObj[obj["key"]] = { cb, ignoreDelete: obj.ignoreDelete ? true : false };
+		} else {
+			cbObj[counter] = { cb, ignoreDelete: obj && obj.ignoreDelete ? true : false };
+			counter += 1;
+		}
+	}
+};
+const registerForAbMobCb = (cb: CallbackFunction) => {
+	if (typeof cb === "function") {
+		abMobCb = cb;
+	}
+};
+const deRegisterForAbMobCb = () => {
+	if (abMobCb) {
+		abMobCb = null;
+	}
+};
+
+const deRegisterCbByKey = (key: string | number) => {
+	delete cbObj[key];
+};
+
+export {
+	webToNative,
+	isClient,
+	webToNativeIos,
+	platform,
+	isNativeApp,
+	registerCb,
+	registerForAbMobCb,
+	deRegisterForAbMobCb,
+	deRegisterCbByKey,
+};