@tagadapay/plugin-sdk 1.0.2

package/dist/react/utils/deviceInfo.js

@@ -0,0 +1,163 @@
+'use client';
+/**
+ * Get basic browser information from user agent
+ */
+function getBrowserInfo() {
+    const userAgent = navigator.userAgent;
+    // Chrome
+    if (userAgent.includes('Chrome')) {
+        const match = /Chrome\/(\d+)/.exec(userAgent);
+        return { name: 'Chrome', version: match ? match[1] : 'unknown' };
+    }
+    // Firefox
+    if (userAgent.includes('Firefox')) {
+        const match = /Firefox\/(\d+)/.exec(userAgent);
+        return { name: 'Firefox', version: match ? match[1] : 'unknown' };
+    }
+    // Safari
+    if (userAgent.includes('Safari') && !userAgent.includes('Chrome')) {
+        const match = /Version\/(\d+)/.exec(userAgent);
+        return { name: 'Safari', version: match ? match[1] : 'unknown' };
+    }
+    // Edge
+    if (userAgent.includes('Edge')) {
+        const match = /Edge\/(\d+)/.exec(userAgent);
+        return { name: 'Edge', version: match ? match[1] : 'unknown' };
+    }
+    return { name: 'unknown', version: 'unknown' };
+}
+/**
+ * Get basic OS information from user agent
+ */
+function getOSInfo() {
+    const userAgent = navigator.userAgent;
+    // Windows
+    if (userAgent.includes('Windows')) {
+        if (userAgent.includes('Windows NT 10.0'))
+            return { name: 'Windows', version: '10' };
+        if (userAgent.includes('Windows NT 6.3'))
+            return { name: 'Windows', version: '8.1' };
+        if (userAgent.includes('Windows NT 6.2'))
+            return { name: 'Windows', version: '8' };
+        if (userAgent.includes('Windows NT 6.1'))
+            return { name: 'Windows', version: '7' };
+        return { name: 'Windows', version: 'unknown' };
+    }
+    // macOS
+    if (userAgent.includes('Mac OS X')) {
+        const match = /Mac OS X (\d+[._]\d+)/.exec(userAgent);
+        return { name: 'macOS', version: match ? match[1].replace('_', '.') : 'unknown' };
+    }
+    // iOS
+    if (userAgent.includes('iPhone') || userAgent.includes('iPad')) {
+        const match = /OS (\d+[._]\d+)/.exec(userAgent);
+        return { name: 'iOS', version: match ? match[1].replace('_', '.') : 'unknown' };
+    }
+    // Android
+    if (userAgent.includes('Android')) {
+        const match = /Android (\d+[.\d]*)/.exec(userAgent);
+        return { name: 'Android', version: match ? match[1] : 'unknown' };
+    }
+    // Linux
+    if (userAgent.includes('Linux')) {
+        return { name: 'Linux', version: 'unknown' };
+    }
+    return { name: 'unknown', version: 'unknown' };
+}
+/**
+ * Get device information
+ */
+function getDeviceInfo() {
+    const userAgent = navigator.userAgent;
+    // Mobile devices
+    if (userAgent.includes('iPhone')) {
+        return { type: 'mobile', model: 'iPhone' };
+    }
+    if (userAgent.includes('iPad')) {
+        return { type: 'tablet', model: 'iPad' };
+    }
+    if (userAgent.includes('Android')) {
+        if (userAgent.includes('Mobile')) {
+            return { type: 'mobile', model: 'Android' };
+        }
+        else {
+            return { type: 'tablet', model: 'Android' };
+        }
+    }
+    // Desktop (no specific device info)
+    return undefined;
+}
+/**
+ * Get screen resolution
+ */
+function getScreenResolution() {
+    return {
+        width: window.screen.width,
+        height: window.screen.height,
+    };
+}
+/**
+ * Get timezone
+ */
+function getTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    catch (error) {
+        console.error('Failed to get timezone:', error);
+        return 'UTC';
+    }
+}
+/**
+ * Get browser locale
+ */
+export function getBrowserLocale() {
+    try {
+        return navigator.language || 'en-US';
+    }
+    catch (error) {
+        console.error('Failed to get browser locale:', error);
+        return 'en-US';
+    }
+}
+/**
+ * Collect all device information
+ */
+export function collectDeviceInfo() {
+    if (typeof window === 'undefined') {
+        // Server-side fallback
+        return {
+            userAgent: {
+                browser: { name: 'unknown', version: 'unknown' },
+                os: { name: 'unknown', version: 'unknown' },
+            },
+            screenResolution: { width: 0, height: 0 },
+            timeZone: 'UTC',
+        };
+    }
+    return {
+        userAgent: {
+            browser: getBrowserInfo(),
+            os: getOSInfo(),
+            device: getDeviceInfo(),
+        },
+        screenResolution: getScreenResolution(),
+        timeZone: getTimeZone(),
+    };
+}
+/**
+ * Get URL parameters for session initialization
+ */
+export function getUrlParams() {
+    if (typeof window === 'undefined') {
+        return {};
+    }
+    const params = new URLSearchParams(window.location.search);
+    return {
+        locale: params.get('locale') || undefined,
+        currency: params.get('currency') || undefined,
+        utmSource: params.get('utm_source') || undefined,
+        utmMedium: params.get('utm_medium') || undefined,
+        utmCampaign: params.get('utm_campaign') || undefined,
+    };
+}

package/dist/react/utils/jwtDecoder.d.ts

@@ -0,0 +1,14 @@
+import { Session } from '../types';
+/**
+ * Decode a JWT token to extract session information
+ * This is a simple client-side decoder - do not use for security validation
+ */
+export declare function decodeJWTClient(token: string): Session | null;
+/**
+ * Check if a JWT token is expired
+ */
+export declare function isTokenExpired(token: string): boolean;
+/**
+ * Get token expiration time
+ */
+export declare function getTokenExpiration(token: string): Date | null;

package/dist/react/utils/jwtDecoder.js

@@ -0,0 +1,86 @@
+'use client';
+/**
+ * Decode a JWT token to extract session information
+ * This is a simple client-side decoder - do not use for security validation
+ */
+export function decodeJWTClient(token) {
+    try {
+        // Split the token into parts
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            console.error('Invalid JWT token format');
+            return null;
+        }
+        // Decode the payload (second part)
+        const payload = parts[1];
+        // Add padding if needed
+        const paddedPayload = payload + '='.repeat((4 - (payload.length % 4)) % 4);
+        // Decode base64
+        const decoded = atob(paddedPayload);
+        // Parse JSON
+        const parsedPayload = JSON.parse(decoded);
+        // Check if token is expired
+        if (parsedPayload.exp && Date.now() >= parsedPayload.exp * 1000) {
+            console.warn('JWT token is expired');
+            return null;
+        }
+        // Return session data
+        return {
+            sessionId: parsedPayload.sessionId,
+            storeId: parsedPayload.storeId,
+            accountId: parsedPayload.accountId,
+            customerId: parsedPayload.customerId,
+            role: parsedPayload.role,
+            isValid: true,
+            isLoading: false,
+        };
+    }
+    catch (error) {
+        console.error('Failed to decode JWT token:', error);
+        return null;
+    }
+}
+/**
+ * Check if a JWT token is expired
+ */
+export function isTokenExpired(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return true;
+        const payload = parts[1];
+        const paddedPayload = payload + '='.repeat((4 - (payload.length % 4)) % 4);
+        const decoded = atob(paddedPayload);
+        const parsedPayload = JSON.parse(decoded);
+        if (parsedPayload.exp) {
+            return Date.now() >= parsedPayload.exp * 1000;
+        }
+        return false;
+    }
+    catch (error) {
+        console.error('Failed to check token expiration:', error);
+        return true;
+    }
+}
+/**
+ * Get token expiration time
+ */
+export function getTokenExpiration(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return null;
+        const payload = parts[1];
+        const paddedPayload = payload + '='.repeat((4 - (payload.length % 4)) % 4);
+        const decoded = atob(paddedPayload);
+        const parsedPayload = JSON.parse(decoded);
+        if (parsedPayload.exp) {
+            return new Date(parsedPayload.exp * 1000);
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('Failed to get token expiration:', error);
+        return null;
+    }
+}