@tagadapay/plugin-sdk 2.8.8 → 2.8.9

package/dist/react/config/environment.d.ts

@@ -1,22 +1 @@
-import { Environment, ApiConfig, EnvironmentConfig } from '../types';
-/**
- * Environment configurations for different deployment environments
- */
-export declare const ENVIRONMENT_CONFIGS: Record<Environment, ApiConfig>;
-/**
- * Get the environment configuration based on the current environment
- */
-export declare function getEnvironmentConfig(environment?: Environment): EnvironmentConfig;
-/**
- * Build a complete API URL from environment config and endpoint path
- */
-export declare function buildApiUrl(config: EnvironmentConfig, endpointPath: string): string;
-/**
- * Get a specific endpoint URL
- */
-export declare function getEndpointUrl(config: EnvironmentConfig, category: keyof ApiConfig['endpoints'], endpoint: string): string;
-/**
- * Auto-detect environment based on hostname, URL patterns, and deployment context
- * Works with any build tool or deployment system
- */
-export declare function detectEnvironment(): Environment;
+export * from '../../v2/core/config/environment';

package/dist/react/config/environment.js

@@ -1,132 +1 @@
-'use client';
-/**
- * Environment configurations for different deployment environments
- */
-export const ENVIRONMENT_CONFIGS = {
-    production: {
-        baseUrl: 'https://app.tagadapay.com',
-        endpoints: {
-            checkout: {
-                sessionInit: '/api/v1/checkout/session/init',
-                sessionStatus: '/api/v1/checkout/session/status',
-            },
-            customer: {
-                profile: '/api/v1/customer/profile',
-                session: '/api/v1/customer/session',
-            },
-            store: {
-                config: '/api/v1/store/config',
-            },
-        },
-    },
-    development: {
-        baseUrl: 'https://app.tagadapay.dev',
-        endpoints: {
-            checkout: {
-                sessionInit: '/api/v1/checkout/session/init',
-                sessionStatus: '/api/v1/checkout/session/status',
-            },
-            customer: {
-                profile: '/api/v1/customer/profile',
-                session: '/api/v1/customer/session',
-            },
-            store: {
-                config: '/api/v1/store/config',
-            },
-        },
-    },
-    local: {
-        baseUrl: 'http://app.localhost:3000',
-        endpoints: {
-            checkout: {
-                sessionInit: '/api/v1/checkout/session/init',
-                sessionStatus: '/api/v1/checkout/session/status',
-            },
-            customer: {
-                profile: '/api/v1/customer/profile',
-                session: '/api/v1/customer/session',
-            },
-            store: {
-                config: '/api/v1/store/config',
-            },
-        },
-    },
-};
-/**
- * Get the environment configuration based on the current environment
- */
-export function getEnvironmentConfig(environment = 'local') {
-    const apiConfig = ENVIRONMENT_CONFIGS[environment];
-    if (!apiConfig) {
-        console.warn(`Unknown environment: ${environment}. Falling back to local.`);
-        return {
-            environment: 'local',
-            apiConfig: ENVIRONMENT_CONFIGS.local,
-        };
-    }
-    return {
-        environment,
-        apiConfig,
-    };
-}
-/**
- * Build a complete API URL from environment config and endpoint path
- */
-export function buildApiUrl(config, endpointPath) {
-    return `${config.apiConfig.baseUrl}${endpointPath}`;
-}
-/**
- * Get a specific endpoint URL
- */
-export function getEndpointUrl(config, category, endpoint) {
-    const categoryEndpoints = config.apiConfig.endpoints[category];
-    const endpointPath = categoryEndpoints[endpoint];
-    if (!endpointPath) {
-        throw new Error(`Endpoint not found: ${category}.${endpoint}`);
-    }
-    return buildApiUrl(config, endpointPath);
-}
-/**
- * Auto-detect environment based on hostname, URL patterns, and deployment context
- * Works with any build tool or deployment system
- */
-export function detectEnvironment() {
-    // Check if we're in browser
-    if (typeof window === 'undefined') {
-        return 'local'; // SSR fallback
-    }
-    const hostname = window.location.hostname;
-    const href = window.location.href;
-    // Production: deployed to production domains
-    if (hostname === 'app.tagadapay.com' ||
-        hostname.includes('tagadapay.com') ||
-        hostname.includes('yourproductiondomain.com')) {
-        return 'production';
-    }
-    // Development: deployed to staging/dev domains or has dev indicators
-    if (hostname === 'app.tagadapay.dev' ||
-        hostname.includes('tagadapay.dev') || // ✅ app.tagadapay.dev and subdomains
-        hostname.includes('vercel.app') ||
-        hostname.includes('netlify.app') ||
-        hostname.includes('surge.sh') ||
-        hostname.includes('github.io') ||
-        hostname.includes('herokuapp.com') ||
-        hostname.includes('railway.app') ||
-        href.includes('?env=dev') ||
-        href.includes('?dev=true') ||
-        href.includes('#dev')) {
-        return 'development';
-    }
-    // Local: localhost, local IPs, or local domains
-    if (hostname === 'localhost' ||
-        hostname.startsWith('127.') ||
-        hostname.startsWith('192.168.') ||
-        hostname.startsWith('10.') ||
-        hostname.includes('.local') ||
-        hostname === '' ||
-        hostname === '0.0.0.0') {
-        return 'local';
-    }
-    // Default fallback for unknown domains (safer to use development)
-    return 'development';
-}
+export * from '../../v2/core/config/environment';

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

@@ -1,39 +1 @@
-export interface DeviceInfo {
-    userAgent: {
-        browser: {
-            name: string;
-            version: string;
-        };
-        os: {
-            name: string;
-            version: string;
-        };
-        device?: {
-            type: string;
-            model: string;
-        };
-    };
-    screenResolution: {
-        width: number;
-        height: number;
-    };
-    timeZone: string;
-}
-/**
- * Get browser locale
- */
-export declare function getBrowserLocale(): string;
-/**
- * Collect all device information
- */
-export declare function collectDeviceInfo(): DeviceInfo;
-/**
- * Get URL parameters for session initialization
- */
-export declare function getUrlParams(): {
-    locale?: string;
-    currency?: string;
-    utmSource?: string;
-    utmMedium?: string;
-    utmCampaign?: string;
-};
+export * from '../../v2/core/utils/deviceInfo';

package/dist/react/utils/deviceInfo.js

@@ -1,163 +1 @@
-'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,
-    };
-}
+export * from '../../v2/core/utils/deviceInfo';

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

@@ -1,14 +1 @@
-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;
+export * from '../../v2/core/utils/jwtDecoder';

package/dist/react/utils/jwtDecoder.js

@@ -1,86 +1 @@
-'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;
-    }
-}
+export * from '../../v2/core/utils/jwtDecoder';

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

@@ -1,16 +1 @@
-/**
- * Set the CMS token in localStorage
- */
-export declare function setClientToken(token: string): void;
-/**
- * Get the CMS token from localStorage
- */
-export declare function getClientToken(): string | null;
-/**
- * Clear the CMS token from localStorage
- */
-export declare function clearClientToken(): void;
-/**
- * Check if a token exists in localStorage
- */
-export declare function hasClientToken(): boolean;
+export * from '../../v2/core/utils/tokenStorage';

package/dist/react/utils/tokenStorage.js

@@ -1,53 +1 @@
-'use client';
-/**
- * Client-side token storage utilities
- */
-const TOKEN_KEY = 'cms_token';
-/**
- * Set the CMS token in localStorage
- */
-export function setClientToken(token) {
-    if (typeof window !== 'undefined') {
-        try {
-            localStorage.setItem(TOKEN_KEY, token);
-            window.dispatchEvent(new Event('storage'));
-        }
-        catch (error) {
-            console.error('Failed to save token to localStorage:', error);
-        }
-    }
-}
-/**
- * Get the CMS token from localStorage
- */
-export function getClientToken() {
-    if (typeof window !== 'undefined') {
-        try {
-            return localStorage.getItem(TOKEN_KEY);
-        }
-        catch (error) {
-            console.error('Failed to get token from localStorage:', error);
-            return null;
-        }
-    }
-    return null;
-}
-/**
- * Clear the CMS token from localStorage
- */
-export function clearClientToken() {
-    if (typeof window !== 'undefined') {
-        try {
-            localStorage.removeItem(TOKEN_KEY);
-        }
-        catch (error) {
-            console.error('Failed to clear token from localStorage:', error);
-        }
-    }
-}
-/**
- * Check if a token exists in localStorage
- */
-export function hasClientToken() {
-    return !!getClientToken();
-}
+export * from '../../v2/core/utils/tokenStorage';

package/dist/v2/core/client.d.ts

@@ -0,0 +1,92 @@
+import { ApiClient } from './resources/apiClient';
+import { PluginConfig, RawPluginConfig } from './utils/pluginConfig';
+import { Environment, EnvironmentConfig, Session, AuthState, Customer, Store, Locale, Currency } from './types';
+export interface TagadaClientConfig {
+    environment?: Environment;
+    debugMode?: boolean;
+    localConfig?: string;
+    rawPluginConfig?: RawPluginConfig;
+    blockUntilSessionReady?: boolean;
+}
+export interface TagadaState {
+    auth: AuthState;
+    session: Session | null;
+    customer: Customer | null;
+    locale: Locale;
+    currency: Currency;
+    store: Store | null;
+    environment: EnvironmentConfig;
+    isLoading: boolean;
+    isInitialized: boolean;
+    isSessionInitialized: boolean;
+    pluginConfig: PluginConfig;
+    pluginConfigLoading: boolean;
+    debugMode: boolean;
+    token: string | null;
+}
+export declare class TagadaClient {
+    apiClient: ApiClient;
+    state: TagadaState;
+    private eventDispatcher;
+    private tokenPromise;
+    private tokenResolver;
+    private boundHandleStorageChange;
+    private readonly config;
+    private instanceId;
+    constructor(config?: TagadaClientConfig);
+    /**
+     * Cleanup client resources
+     */
+    destroy(): void;
+    /**
+     * Handle storage changes (e.g. token update in another tab)
+     */
+    private handleStorageChange;
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener: (state: TagadaState) => void): () => void;
+    /**
+     * Get current state
+     */
+    getState(): TagadaState;
+    /**
+     * Update state and notify listeners
+     */
+    private updateState;
+    /**
+     * Resolve environment
+     */
+    private resolveEnvironment;
+    /**
+     * Main initialization flow
+     */
+    private initialize;
+    /**
+     * Load plugin configuration
+     */
+    private initializePluginConfig;
+    /**
+     * Initialize token and session
+     */
+    private initializeToken;
+    /**
+     * Set token and resolve waiting requests
+     */
+    private setToken;
+    /**
+     * Wait for token to be available
+     */
+    private waitForToken;
+    /**
+     * Create anonymous token
+     */
+    createAnonymousToken(storeId: string): Promise<void>;
+    /**
+     * Initialize session
+     */
+    initializeSession(sessionData: Session): Promise<void>;
+    private updateSessionState;
+    private getCurrencySymbol;
+    private getCurrencyName;
+}