@tagadapay/plugin-sdk 1.0.2

package/dist/react/utils/urlUtils.js

@@ -0,0 +1,449 @@
+'use client';
+/**
+ * Checkout token format: 32 character hexadecimal string
+ * Example: 0cb592d75aae75e337b7b784f6624dbf
+ */
+const CHECKOUT_TOKEN_REGEX = /[a-f0-9]{32}/i;
+/**
+ * Extract checkout token from a URL path
+ *
+ * @param url - The URL to extract the token from
+ * @returns The checkout token if found, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // These will all return "0cb592d75aae75e337b7b784f6624dbf"
+ * extractCheckoutToken("https://example.com/checkout/0cb592d75aae75e337b7b784f6624dbf")
+ * extractCheckoutToken("/checkout/0cb592d75aae75e337b7b784f6624dbf")
+ * extractCheckoutToken("/some/path/0cb592d75aae75e337b7b784f6624dbf/other/path")
+ * extractCheckoutToken("0cb592d75aae75e337b7b784f6624dbf")
+ *
+ * // These will return null
+ * extractCheckoutToken("https://example.com/checkout")
+ * extractCheckoutToken("invalid-token")
+ * ```
+ */
+export function extractCheckoutToken(url) {
+    if (!url || typeof url !== 'string') {
+        return null;
+    }
+    // Try to match the checkout token pattern
+    const match = CHECKOUT_TOKEN_REGEX.exec(url);
+    if (match) {
+        return match[0].toLowerCase(); // Normalize to lowercase
+    }
+    return null;
+}
+/**
+ * Extract checkout token from current browser URL
+ *
+ * @returns The checkout token if found in current URL, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // If current URL is "https://example.com/checkout/0cb592d75aae75e337b7b784f6624dbf"
+ * const token = extractCheckoutTokenFromCurrentUrl();
+ * // Returns: "0cb592d75aae75e337b7b784f6624dbf"
+ * ```
+ */
+export function extractCheckoutTokenFromCurrentUrl() {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    return extractCheckoutToken(window.location.href);
+}
+/**
+ * Extract checkout token from URL pathname only
+ *
+ * @param pathname - The pathname to extract the token from
+ * @returns The checkout token if found, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // These will all return "0cb592d75aae75e337b7b784f6624dbf"
+ * extractCheckoutTokenFromPath("/checkout/0cb592d75aae75e337b7b784f6624dbf")
+ * extractCheckoutTokenFromPath("/some/path/0cb592d75aae75e337b7b784f6624dbf/other/path")
+ * extractCheckoutTokenFromPath("0cb592d75aae75e337b7b784f6624dbf")
+ * ```
+ */
+export function extractCheckoutTokenFromPath(pathname) {
+    if (!pathname || typeof pathname !== 'string') {
+        return null;
+    }
+    return extractCheckoutToken(pathname);
+}
+/**
+ * Validate if a string is a valid checkout token format
+ *
+ * @param token - The token to validate
+ * @returns True if the token is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidCheckoutToken("0cb592d75aae75e337b7b784f6624dbf") // true
+ * isValidCheckoutToken("invalid-token") // false
+ * isValidCheckoutToken("1234567890abcdef1234567890abcdef") // true
+ * isValidCheckoutToken("") // false
+ * ```
+ */
+export function isValidCheckoutToken(token) {
+    if (!token || typeof token !== 'string') {
+        return false;
+    }
+    return CHECKOUT_TOKEN_REGEX.test(token);
+}
+/**
+ * Extract checkout token from various URL formats and validate it
+ *
+ * @param url - The URL to extract and validate the token from
+ * @returns The validated checkout token if found and valid, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // These will all return "0cb592d75aae75e337b7b784f6624dbf"
+ * extractAndValidateCheckoutToken("https://example.com/checkout/0cb592d75aae75e337b7b784f6624dbf")
+ * extractAndValidateCheckoutToken("/checkout/0cb592d75aae75e337b7b784f6624dbf")
+ *
+ * // These will return null
+ * extractAndValidateCheckoutToken("https://example.com/checkout/invalid-token")
+ * extractAndValidateCheckoutToken("https://example.com/checkout")
+ * ```
+ */
+export function extractAndValidateCheckoutToken(url) {
+    const token = extractCheckoutToken(url);
+    if (token && isValidCheckoutToken(token)) {
+        return token;
+    }
+    return null;
+}
+/**
+ * Extract checkout token from URL query parameters
+ *
+ * @param searchParams - URLSearchParams object or search string
+ * @returns The checkout token if found in query params, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // From URLSearchParams
+ * const params = new URLSearchParams('?token=0cb592d75aae75e337b7b784f6624dbf');
+ * const token = extractCheckoutTokenFromQuery(params);
+ *
+ * // From search string
+ * const token = extractCheckoutTokenFromQuery('?checkoutToken=0cb592d75aae75e337b7b784f6624dbf');
+ * ```
+ */
+export function extractCheckoutTokenFromQuery(searchParams) {
+    try {
+        let params;
+        if (typeof searchParams === 'string') {
+            params = new URLSearchParams(searchParams);
+        }
+        else {
+            params = searchParams;
+        }
+        // Check for 'token' parameter first
+        const token = params.get('token');
+        if (token && isValidCheckoutToken(token)) {
+            return token.toLowerCase();
+        }
+        // Check for 'checkoutToken' parameter
+        const checkoutToken = params.get('checkoutToken');
+        if (checkoutToken && isValidCheckoutToken(checkoutToken)) {
+            return checkoutToken.toLowerCase();
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('Failed to extract checkout token from query params:', error);
+        return null;
+    }
+}
+/**
+ * Extract checkout token from current browser URL query parameters
+ *
+ * @returns The checkout token if found in current URL query params, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // If current URL is "https://example.com/checkout?token=0cb592d75aae75e337b7b784f6624dbf"
+ * const token = extractCheckoutTokenFromCurrentUrlQuery();
+ * // Returns: "0cb592d75aae75e337b7b784f6624dbf"
+ * ```
+ */
+export function extractCheckoutTokenFromCurrentUrlQuery() {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    return extractCheckoutTokenFromQuery(window.location.search);
+}
+/**
+ * Get checkout token from multiple possible sources
+ *
+ * @param options - Options for token extraction
+ * @returns The checkout token if found, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // Try to get token from current URL (both query params and path), then from a specific URL, then from a fallback
+ * const token = getCheckoutToken({
+ *   currentUrl: true,
+ *   specificUrl: "https://example.com/checkout/0cb592d75aae75e337b7b784f6624dbf",
+ *   fallbackToken: "0cb592d75aae75e337b7b784f6624dbf"
+ * });
+ *
+ * // Works with both query parameters and path parameters:
+ * // /checkout?token=0cb592d75aae75e337b7b784f6624dbf
+ * // /checkout?checkoutToken=0cb592d75aae75e337b7b784f6624dbf
+ * // /checkout/0cb592d75aae75e337b7b784f6624dbf
+ * ```
+ */
+export function getCheckoutToken(options = {}) {
+    const { currentUrl = true, specificUrl, fallbackToken } = options;
+    // Try current URL first (both path and query params)
+    if (currentUrl) {
+        // Try query parameters first (more common for SPA)
+        const currentQueryToken = extractCheckoutTokenFromCurrentUrlQuery();
+        if (currentQueryToken) {
+            return currentQueryToken;
+        }
+        // Then try path-based token
+        const currentPathToken = extractCheckoutTokenFromCurrentUrl();
+        if (currentPathToken) {
+            return currentPathToken;
+        }
+    }
+    // Try specific URL (both path and query params)
+    if (specificUrl) {
+        // Try query parameters first
+        try {
+            const url = new URL(specificUrl, window?.location?.origin || 'https://example.com');
+            const queryToken = extractCheckoutTokenFromQuery(url.search);
+            if (queryToken) {
+                return queryToken;
+            }
+        }
+        catch (error) {
+            // If URL parsing fails, continue to path extraction
+        }
+        // Then try path-based token
+        const specificToken = extractCheckoutToken(specificUrl);
+        if (specificToken) {
+            return specificToken;
+        }
+    }
+    // Try fallback token
+    if (fallbackToken && isValidCheckoutToken(fallbackToken)) {
+        return fallbackToken;
+    }
+    return null;
+}
+/**
+ * Build a checkout URL with a token
+ *
+ * @param baseUrl - The base URL for the checkout
+ * @param token - The checkout token
+ * @returns The complete checkout URL
+ *
+ * @example
+ * ```typescript
+ * buildCheckoutUrl("https://example.com/checkout", "0cb592d75aae75e337b7b784f6624dbf")
+ * // Returns: "https://example.com/checkout/0cb592d75aae75e337b7b784f6624dbf"
+ * ```
+ */
+export function buildCheckoutUrl(baseUrl, token) {
+    if (!baseUrl || !token || !isValidCheckoutToken(token)) {
+        throw new Error('Invalid base URL or checkout token');
+    }
+    // Remove trailing slash from base URL if present
+    const cleanBaseUrl = baseUrl.replace(/\/$/, '');
+    return `${cleanBaseUrl}/${token}`;
+}
+/**
+ * Check if a URL contains a checkout token (in path or query parameters)
+ *
+ * @param url - The URL to check
+ * @returns True if the URL contains a valid checkout token, false otherwise
+ *
+ * @example
+ * ```typescript
+ * hasCheckoutToken("https://example.com/checkout/0cb592d75aae75e337b7b784f6624dbf") // true
+ * hasCheckoutToken("https://example.com/checkout?token=0cb592d75aae75e337b7b784f6624dbf") // true
+ * hasCheckoutToken("https://example.com/checkout?checkoutToken=0cb592d75aae75e337b7b784f6624dbf") // true
+ * hasCheckoutToken("https://example.com/checkout") // false
+ * hasCheckoutToken("https://example.com/checkout/invalid-token") // false
+ * ```
+ */
+export function hasCheckoutToken(url) {
+    // Check path first
+    if (extractCheckoutToken(url) !== null) {
+        return true;
+    }
+    // Check query parameters
+    try {
+        const urlObj = new URL(url, window?.location?.origin || 'https://example.com');
+        return extractCheckoutTokenFromQuery(urlObj.search) !== null;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Extract checkout initialization data from URL search parameters
+ *
+ * @param searchParams - URLSearchParams object or search string
+ * @returns Checkout initialization data if found, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // From URLSearchParams
+ * const params = new URLSearchParams('?items=[{"id":"1","quantity":2}]&cartToken=abc&storeId=123');
+ * const data = extractCheckoutInitData(params);
+ *
+ * // From search string
+ * const data = extractCheckoutInitData('?items=[{"id":"1","quantity":2}]&cartToken=abc&storeId=123');
+ *
+ * // From base64 encoded data
+ * const data = extractCheckoutInitData('?data=eyJpdGVtcyI6W3siaWQiOiIxIiwicXVhbnRpdHkiOjJ9XX0=');
+ * ```
+ */
+export function extractCheckoutInitData(searchParams) {
+    try {
+        let params;
+        if (typeof searchParams === 'string') {
+            params = new URLSearchParams(searchParams);
+        }
+        else {
+            params = searchParams;
+        }
+        console.log('[extractCheckoutInitData] Processing search params:', Object.fromEntries(params.entries()));
+        // Try to get base64 encoded data first
+        const encodedData = params.get('data');
+        if (encodedData) {
+            console.log('[extractCheckoutInitData] Found base64 encoded data');
+            const decodedData = atob(encodedData);
+            const parsedData = JSON.parse(decodedData);
+            // Validate required fields
+            if (!parsedData.lineItems || !Array.isArray(parsedData.lineItems)) {
+                console.log('[extractCheckoutInitData] Invalid base64 data structure');
+                return null;
+            }
+            return {
+                cartToken: parsedData.cartToken,
+                lineItems: parsedData.lineItems,
+                customer: parsedData.customer,
+                returnUrl: parsedData.returnUrl,
+                storeId: parsedData.storeId,
+            };
+        }
+        // Try to extract lineItems from array format (lineItems[0][variantId], etc.)
+        const lineItems = [];
+        let index = 0;
+        while (true) {
+            const variantId = params.get(`lineItems[${index}][variantId]`);
+            const quantity = params.get(`lineItems[${index}][quantity]`);
+            if (!variantId || !quantity) {
+                break;
+            }
+            lineItems.push({
+                id: variantId,
+                quantity: parseInt(quantity, 10),
+            });
+            index++;
+        }
+        if (lineItems.length > 0) {
+            console.log('[extractCheckoutInitData] Found lineItems in array format:', lineItems);
+            return {
+                cartToken: params.get('cartToken') || undefined,
+                lineItems,
+                customer: {
+                    currency: params.get('currency') || undefined,
+                    locale: params.get('locale') || undefined,
+                },
+                returnUrl: params.get('returnUrl') || undefined,
+                storeId: params.get('storeId') || undefined,
+            };
+        }
+        // Fall back to individual query parameters
+        const items = params.get('items');
+        if (items) {
+            console.log('[extractCheckoutInitData] Found items parameter:', items);
+            const parsedItems = JSON.parse(items);
+            if (!Array.isArray(parsedItems)) {
+                console.log('[extractCheckoutInitData] Invalid items structure');
+                return null;
+            }
+            // Preserve original field names from the URL
+            const lineItems = parsedItems.map((item) => ({
+                ...item, // Keep all original fields (variantId, quantity, etc.)
+            }));
+            console.log('[extractCheckoutInitData] Converted lineItems:', lineItems);
+            return {
+                cartToken: params.get('cartToken') || undefined,
+                lineItems,
+                customer: {
+                    currency: params.get('currency') || undefined,
+                    locale: params.get('locale') || undefined,
+                },
+                returnUrl: params.get('returnUrl') || undefined,
+                storeId: params.get('storeId') || undefined,
+            };
+        }
+        console.log('[extractCheckoutInitData] No checkout init data found');
+        return null;
+    }
+    catch (error) {
+        console.error('Failed to extract checkout init data:', error);
+        return null;
+    }
+}
+/**
+ * Extract checkout initialization data from current browser URL
+ *
+ * @returns Checkout initialization data if found, null otherwise
+ *
+ * @example
+ * ```typescript
+ * // If current URL is "https://example.com/checkout?items=[...]&cartToken=abc"
+ * const data = extractCheckoutInitDataFromCurrentUrl();
+ * ```
+ */
+export function extractCheckoutInitDataFromCurrentUrl() {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    return extractCheckoutInitData(window.location.search);
+}
+/**
+ * Check if URL contains checkout initialization data
+ *
+ * @param searchParams - URLSearchParams object or search string
+ * @returns True if URL contains checkout init data, false otherwise
+ *
+ * @example
+ * ```typescript
+ * hasCheckoutInitData('?items=[{"id":"1","quantity":2}]') // true
+ * hasCheckoutInitData('?other=param') // false
+ * ```
+ */
+export function hasCheckoutInitData(searchParams) {
+    return extractCheckoutInitData(searchParams) !== null;
+}
+/**
+ * Check if current URL contains checkout initialization data
+ *
+ * @returns True if current URL contains checkout init data, false otherwise
+ *
+ * @example
+ * ```typescript
+ * // If current URL has checkout data
+ * if (hasCheckoutInitDataInCurrentUrl()) {
+ *   // Auto-initialize checkout
+ * }
+ * ```
+ */
+export function hasCheckoutInitDataInCurrentUrl() {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    return hasCheckoutInitData(window.location.search);
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@tagadapay/plugin-sdk",
+  "version": "1.0.2",
+  "description": "Modern React SDK for building Tagada Pay plugins",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "lint": "echo \"No linting configured\"",
+    "test": "echo \"No tests yet\" && exit 0",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run clean && npm run build",
+    "publish:patch": "npm version patch && npm publish",
+    "publish:minor": "npm version minor && npm publish",
+    "publish:major": "npm version major && npm publish",
+    "publish:beta": "npm version prerelease --preid=beta && npm publish --tag beta",
+    "publish:alpha": "npm version prerelease --preid=alpha && npm publish --tag alpha",
+    "version:patch": "npm version patch",
+    "version:minor": "npm version minor",
+    "version:major": "npm version major",
+    "version:beta": "npm version prerelease --preid=beta",
+    "version:alpha": "npm version prerelease --preid=alpha"
+  },
+  "keywords": [
+    "tagadapay",
+    "cms",
+    "plugin",
+    "sdk",
+    "react",
+    "typescript"
+  ],
+  "author": "Tagada Pay",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "react-intl": "^7.1.11"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tagadapay/plugin-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tagadapay/plugin-sdk/issues"
+  },
+  "homepage": "https://github.com/tagadapay/plugin-sdk#readme"
+}