@tagadapay/plugin-sdk 2.8.7 → 2.8.9

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

@@ -0,0 +1,271 @@
+/**
+ * Types for the Tagada Pay SDK Core
+ */
+export type Environment = 'production' | 'development' | 'local';
+export interface ApiConfig {
+    baseUrl: string;
+    endpoints: {
+        checkout: {
+            sessionInit: string;
+            sessionStatus: string;
+        };
+        customer: {
+            profile: string;
+            session: string;
+        };
+        store: {
+            config: string;
+        };
+    };
+}
+export interface EnvironmentConfig {
+    environment: Environment;
+    apiConfig: ApiConfig;
+}
+export interface Customer {
+    id: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    isAuthenticated: boolean;
+    role: 'authenticated' | 'anonymous';
+}
+export type SessionRole = 'authenticated' | 'anonymous';
+export interface Session {
+    sessionId: string;
+    storeId: string;
+    accountId: string;
+    customerId: string;
+    role: SessionRole;
+    isValid: boolean;
+    isLoading: boolean;
+}
+export interface AuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    customer: Customer | null;
+    session: Session | null;
+}
+export interface Locale {
+    locale: string;
+    language: string;
+    region: string;
+    messages?: Record<string, string>;
+}
+export interface Currency {
+    code: string;
+    symbol: string;
+    name: string;
+}
+export interface Store {
+    id: string;
+    name: string;
+    domain: string;
+    currency: string;
+    locale: string;
+    presentmentCurrencies: string[];
+    chargeCurrencies: string[];
+}
+export interface PickupPoint {
+    id: string;
+    name: string;
+    country: string;
+    postal_code: string;
+    city: string;
+    address: string;
+    address2?: string;
+    house_number?: string;
+    phone?: string;
+    email?: string;
+    latitude?: number;
+    longitude?: number;
+    opening_hours?: string;
+    extra_info?: string;
+}
+export interface OrderItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    quantity: number;
+    unitAmount: number;
+    amount: number;
+    adjustedAmount: number;
+    currency: string;
+    recurring?: boolean;
+    interval?: 'day' | 'week' | 'month' | 'year' | null;
+    intervalCount?: number | null;
+    orderLineItemProduct?: {
+        name: string;
+    };
+    orderLineItemVariant?: {
+        name: string;
+        imageUrl: string | null;
+    };
+    subscriptionSettings?: {
+        trial?: boolean;
+    };
+}
+export interface OrderSummary {
+    currency: string;
+    totalPromotionAmount: number;
+    totalTaxAmount: number;
+    shippingCost: number;
+    shippingCostIsFree: boolean;
+    subtotalAmount: number;
+    subtotalAdjustedAmount: number;
+    totalAdjustedAmount: number;
+    adjustments?: {
+        type: string;
+        amount: number;
+        description: string;
+    }[];
+}
+export interface OrderAddress {
+    firstName: string;
+    lastName: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    state: string;
+    postal: string;
+    country: string;
+    phone?: string;
+}
+export interface Order {
+    id: string;
+    currency: string;
+    paidAmount: number;
+    status: string;
+    createdAt: string;
+    metadata?: Record<string, any>;
+    items: OrderItem[];
+    summaries?: OrderSummary[];
+    shippingAddress?: OrderAddress;
+    billingAddress?: OrderAddress;
+    pickupAddress?: PickupPoint;
+    checkoutSession?: {
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    relatedOrders?: Order[];
+}
+export interface PaymentSummary {
+    id: string;
+    status: string;
+    amount: number;
+    currency: string;
+    createdAt: string;
+    updatedAt?: string;
+    provider?: string;
+    metadata?: Record<string, any>;
+}
+export interface PromotionSummary {
+    id: string;
+    code?: string | null;
+    type?: string;
+    amount?: number;
+    description?: string | null;
+}
+export interface OrderAdjustmentSummary {
+    type: string;
+    amount: number;
+    description: string;
+}
+export interface OrderWithRelations extends Order {
+    customer?: Customer;
+    store?: Store;
+    account?: {
+        id: string;
+        name?: string;
+    } | undefined;
+    items: OrderItem[];
+    payments?: PaymentSummary[];
+    summaries: OrderSummary[];
+    checkoutSession?: {
+        id?: string;
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    promotions?: PromotionSummary[];
+    subscriptions?: any[];
+    adjustments: OrderAdjustmentSummary[];
+}
+export interface CustomerAddress {
+    company?: string;
+    firstName: string;
+    lastName: string;
+    address1: string;
+    city: string;
+    country: string;
+    state: string;
+    postal: string;
+    phone?: string;
+    email?: string;
+}
+export interface CustomerOrderSummary {
+    id: string;
+    storeId: string;
+    accountId: string;
+    createdAt: string;
+    updatedAt: string;
+    status: string;
+    cancelledAt: string | null;
+    cancelledReason: string | null;
+    paidAt: string | null;
+    paidAmount: number | null;
+    openAt: string | null;
+    abandonedAt: string | null;
+    currency: string;
+    externalCustomerType: string | null;
+    externalCustomerId: string | null;
+    externalOrderId: string | null;
+    billingAddress: CustomerAddress;
+    shippingAddress: Omit<CustomerAddress, 'email'>;
+    pickupAddress: any | null;
+    taxesIncluded: boolean;
+    draft: boolean;
+    checkoutSessionId: string | null;
+    sessionHash: string | null;
+    customerId: string;
+    createdFrom: string | null;
+    paymentInstrumentId: string | null;
+    refundedAt: string | null;
+    refundedAmount: number | null;
+    metadata?: Record<string, any>;
+}
+export interface CustomerInfos {
+    customer: {
+        id: string;
+        email: string | null;
+        firstName: string | null;
+        lastName: string | null;
+        externalCustomerId: string | null;
+        lastOrderId: string | null;
+        accountId: string;
+        storeId: string;
+        billingAddress: CustomerAddress | null;
+        shippingAddress: Omit<CustomerAddress, 'email'> | null;
+        currency: string | null;
+        locale: string | null;
+        draft: boolean;
+        acceptsMarketing: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, any>;
+        device: any | null;
+        orders: CustomerOrderSummary[];
+        subscriptions: any[];
+    };
+    promotionCodes: any[];
+}
+export interface SessionInitResponse {
+    store: Store;
+    locale: string;
+    messages?: Record<string, string>;
+    customer?: Customer;
+    session?: Session;
+}
+export interface AnonymousTokenResponse {
+    token: string;
+}

package/dist/v2/core/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the Tagada Pay SDK Core
+ */
+export {};

package/dist/v2/core/utils/deviceInfo.d.ts

@@ -0,0 +1,39 @@
+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;
+};

package/dist/v2/core/utils/deviceInfo.js

@@ -0,0 +1,162 @@
+/**
+ * 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/v2/core/utils/eventDispatcher.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Simple event dispatcher for handling state changes in the SDK
+ */
+export type Listener<T> = (data: T) => void;
+export declare class EventDispatcher<T> {
+    private listeners;
+    subscribe(listener: Listener<T>): () => void;
+    notify(data: T): void;
+    clear(): void;
+}

package/dist/v2/core/utils/eventDispatcher.js

@@ -0,0 +1,24 @@
+export class EventDispatcher {
+    constructor() {
+        this.listeners = new Set();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    notify(data) {
+        this.listeners.forEach((listener) => {
+            try {
+                listener(data);
+            }
+            catch (error) {
+                console.error('Error in event listener:', error);
+            }
+        });
+    }
+    clear() {
+        this.listeners.clear();
+    }
+}

package/dist/v2/core/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/v2/core/utils/jwtDecoder.js

@@ -0,0 +1,85 @@
+/**
+ * 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;
+    }
+}

package/dist/v2/core/utils/pluginConfig.js

@@ -8,6 +8,12 @@ import { resolveEnvValue } from './env';
  */
 const loadLocalDevConfig = async (configVariant = 'default') => {
     try {
+        // Check for explicit environment override
+        const env = resolveEnvValue('TAGADA_ENV') || resolveEnvValue('TAGADA_ENVIRONMENT');
+        if (env === 'production') {
+            // Skip local config loading if explicitly in production mode
+            return null;
+        }
         // Only try to load local config in development
         // Use hostname-based detection for better Vite compatibility
         const isLocalDev = typeof window !== 'undefined' &&

package/dist/v2/core/utils/tokenStorage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Client-side token storage utilities
+ */
+/**
+ * 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;

package/dist/v2/core/utils/tokenStorage.js

@@ -0,0 +1,52 @@
+/**
+ * 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();
+}