@tagadapay/headless-sdk 1.8.0-rc.0 → 1.8.0

package/dist/react/hooks/useRx.d.ts

@@ -0,0 +1,64 @@
+import type { RxCaseSummary, RxQuestionsForProduct, RxRequiredForProduct, RxSubmitCaseInput, RxSubmitCaseResult } from '../../core/modules/rx.js';
+export interface UseRxReturn {
+    /** Cases attached to the current order (populated by `pollOrder`). */
+    cases: RxCaseSummary[];
+    /** Result of the last `submitCase` call, kept for the thank-you page. */
+    lastSubmission: RxSubmitCaseResult | null;
+    /** True while ANY rx call is in flight. */
+    isLoading: boolean;
+    error: Error | null;
+    /**
+     * Ask whether a product needs an Rx case before submitting payment.
+     * Storefronts call this at product-page load to decide whether to
+     * render the intake step.
+     */
+    isRequiredForProduct: (productId: string, opts?: {
+        clinicalNetworkId?: string;
+    }) => Promise<RxRequiredForProduct>;
+    /** Fetch network-authored intake questions for a product. */
+    getQuestionsForProduct: (productId: string) => Promise<RxQuestionsForProduct>;
+    /**
+     * Submit a fresh case after the order is paid. The result is also
+     * stored in `lastSubmission` so the thank-you page can read it.
+     */
+    submitCase: (input: RxSubmitCaseInput) => Promise<RxSubmitCaseResult>;
+    /**
+     * Fetch the public summary of every case attached to a paid order.
+     * Useful for the thank-you page or order history.
+     */
+    fetchCasesForOrder: (input: {
+        orderId: string;
+        checkoutToken: string;
+    }) => Promise<RxCaseSummary[]>;
+    /**
+     * Auto-poll the cases for an order until they all reach a terminal
+     * status (approved / shipped / delivered / declined / cancelled /
+     * error). Returns a `stop()` function to cancel the polling.
+     */
+    pollOrder: (input: {
+        orderId: string;
+        checkoutToken: string;
+    }, opts?: {
+        intervalMs?: number;
+        onUpdate?: (cases: RxCaseSummary[]) => void;
+    }) => () => void;
+}
+/**
+ * React hook for Tagada Rx storefronts.
+ *
+ * @example
+ * ```tsx
+ * const { isRequiredForProduct, submitCase, lastSubmission, pollOrder } = useRx();
+ *
+ * useEffect(() => {
+ *   if (orderId && checkoutToken) {
+ *     const stop = pollOrder({ orderId, checkoutToken }, {
+ *       onUpdate: (cases) => setCases(cases),
+ *     });
+ *     return stop;
+ *   }
+ * }, [orderId, checkoutToken, pollOrder]);
+ * ```
+ */
+export declare function useRx(): UseRxReturn;
+//# sourceMappingURL=useRx.d.ts.map

package/dist/react/hooks/useRx.js

@@ -0,0 +1,145 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useHeadlessClient } from '../provider.js';
+const TERMINAL_STATUSES = new Set([
+    'approved',
+    'shipped',
+    'delivered',
+    'declined',
+    'cancelled',
+    'error',
+]);
+/**
+ * React hook for Tagada Rx storefronts.
+ *
+ * @example
+ * ```tsx
+ * const { isRequiredForProduct, submitCase, lastSubmission, pollOrder } = useRx();
+ *
+ * useEffect(() => {
+ *   if (orderId && checkoutToken) {
+ *     const stop = pollOrder({ orderId, checkoutToken }, {
+ *       onUpdate: (cases) => setCases(cases),
+ *     });
+ *     return stop;
+ *   }
+ * }, [orderId, checkoutToken, pollOrder]);
+ * ```
+ */
+export function useRx() {
+    const client = useHeadlessClient();
+    const [cases, setCases] = useState([]);
+    const [lastSubmission, setLastSubmission] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const pollTimerRef = useRef(null);
+    useEffect(() => {
+        return () => {
+            if (pollTimerRef.current)
+                clearInterval(pollTimerRef.current);
+        };
+    }, []);
+    const isRequiredForProduct = useCallback(async (productId, opts) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            return await client.rx.isRequiredForProduct(productId, opts);
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    const getQuestionsForProduct = useCallback(async (productId) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            return await client.rx.getQuestionsForProduct(productId);
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    const submitCase = useCallback(async (input) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const res = await client.rx.submitCase(input);
+            setLastSubmission(res);
+            return res;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    const fetchCasesForOrder = useCallback(async (input) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const res = await client.rx.getCasesForOrder(input);
+            setCases(res.cases);
+            return res.cases;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    const pollOrder = useCallback(({ orderId, checkoutToken }, opts) => {
+        if (pollTimerRef.current)
+            clearInterval(pollTimerRef.current);
+        const intervalMs = opts?.intervalMs ?? 5000;
+        const tick = async () => {
+            try {
+                const res = await client.rx.getCasesForOrder({ orderId, checkoutToken });
+                setCases(res.cases);
+                opts?.onUpdate?.(res.cases);
+                if (res.cases.length > 0 && res.cases.every((c) => TERMINAL_STATUSES.has(c.status))) {
+                    if (pollTimerRef.current)
+                        clearInterval(pollTimerRef.current);
+                    pollTimerRef.current = null;
+                }
+            }
+            catch (err) {
+                const e = err instanceof Error ? err : new Error(String(err));
+                setError(e);
+            }
+        };
+        void tick();
+        pollTimerRef.current = setInterval(tick, intervalMs);
+        return () => {
+            if (pollTimerRef.current)
+                clearInterval(pollTimerRef.current);
+            pollTimerRef.current = null;
+        };
+    }, [client]);
+    return {
+        cases,
+        lastSubmission,
+        isLoading,
+        error,
+        isRequiredForProduct,
+        getQuestionsForProduct,
+        submitCase,
+        fetchCasesForOrder,
+        pollOrder,
+    };
+}
+//# sourceMappingURL=useRx.js.map

package/dist/react/index.d.ts

@@ -0,0 +1,22 @@
+export { TagadaHeadlessProvider, useHeadlessClient } from './provider.js';
+export type { TagadaHeadlessProviderProps } from './provider.js';
+export { useCheckout } from './hooks/useCheckout.js';
+export type { UseCheckoutReturn } from './hooks/useCheckout.js';
+export { usePayment } from './hooks/usePayment.js';
+export type { UsePaymentReturn, UsePaymentOptions } from './hooks/usePayment.js';
+export { useOffers } from './hooks/useOffers.js';
+export type { UseOffersReturn } from './hooks/useOffers.js';
+export { useCustomer } from './hooks/useCustomer.js';
+export type { UseCustomerReturn } from './hooks/useCustomer.js';
+export { useCatalog } from './hooks/useCatalog.js';
+export type { UseCatalogReturn } from './hooks/useCatalog.js';
+export { useRx } from './hooks/useRx.js';
+export type { UseRxReturn } from './hooks/useRx.js';
+export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete.js';
+export type { UseGoogleAutocompleteOptions, UseGoogleAutocompleteReturn } from './hooks/useGoogleAutocomplete.js';
+export { useISOData, useCountryOptions, useRegionOptions } from './hooks/useISOData.js';
+export type { UseISODataReturn } from './hooks/useISOData.js';
+export type { GooglePrediction, GooglePlaceDetails, ExtractedAddress, FormattedAddress, SupportedLanguage, ISOCountry, ISORegion, Currency, } from '../core/helpers/index.js';
+export { formatMoney, CurrencyUtils, ISODataCore, GoogleAutocompleteCore, loadGoogleMapsScript } from '../core/helpers/index.js';
+export type { HeadlessConfig, Environment, CheckoutSession, CheckoutLineItem, CheckoutTotals, CheckoutCustomer, Address, ShippingRate, LineItem, PaymentSetupConfig, PaymentMethodConfig, ExpressMethods, ExpressMethod, StoreConfig, PayResult, PayOptions, PaymentStatus, ProcessPaymentOptions, ProcessPaymentResult, Offer, OfferLineItem, OfferPreview, OfferPreviewItem, OfferPayResult, Customer, Order, Subscription, CatalogProduct, CatalogVariant, CatalogPrice, CurrencyOption, StripeExpressOptions, } from '../core/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -0,0 +1,12 @@
+export { TagadaHeadlessProvider, useHeadlessClient } from './provider.js';
+export { useCheckout } from './hooks/useCheckout.js';
+export { usePayment } from './hooks/usePayment.js';
+export { useOffers } from './hooks/useOffers.js';
+export { useCustomer } from './hooks/useCustomer.js';
+export { useCatalog } from './hooks/useCatalog.js';
+export { useRx } from './hooks/useRx.js';
+// Helpers hooks
+export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete.js';
+export { useISOData, useCountryOptions, useRegionOptions } from './hooks/useISOData.js';
+export { formatMoney, CurrencyUtils, ISODataCore, GoogleAutocompleteCore, loadGoogleMapsScript } from '../core/helpers/index.js';
+//# sourceMappingURL=index.js.map

package/dist/react/internal/redirectGuard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Try to claim ownership of resuming a payment. Returns `true` if the
+ * caller is the first one to claim it (and should proceed); `false` if
+ * another hook has already claimed it.
+ */
+export declare function tryClaimResume(paymentId: string): boolean;
+/** Reset the guard. Useful in tests and on hard refresh logic. */
+export declare function resetResumeGuard(): void;
+//# sourceMappingURL=redirectGuard.d.ts.map

package/dist/react/internal/redirectGuard.js

@@ -0,0 +1,25 @@
+/**
+ * Module-level guard preventing two hooks (`usePayment`, `useOffers`) from
+ * both resuming the same payment after a 3DS / processor redirect.
+ *
+ * Each `paymentId` is processed at most once per page load. The first hook
+ * that wins the race calls `client.payment.resumeAfterRedirect` and fires
+ * its callback; the other hook becomes a no-op.
+ */
+const RESUMED_PAYMENT_IDS = new Set();
+/**
+ * Try to claim ownership of resuming a payment. Returns `true` if the
+ * caller is the first one to claim it (and should proceed); `false` if
+ * another hook has already claimed it.
+ */
+export function tryClaimResume(paymentId) {
+    if (RESUMED_PAYMENT_IDS.has(paymentId))
+        return false;
+    RESUMED_PAYMENT_IDS.add(paymentId);
+    return true;
+}
+/** Reset the guard. Useful in tests and on hard refresh logic. */
+export function resetResumeGuard() {
+    RESUMED_PAYMENT_IDS.clear();
+}
+//# sourceMappingURL=redirectGuard.js.map

package/dist/react/provider.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { HeadlessClient } from '../core/client.js';
+import type { HeadlessConfig, Environment } from '../core/types.js';
+export interface TagadaHeadlessProviderProps {
+    /** Your TagadaPay store ID. */
+    storeId: string;
+    /** Environment. Defaults to "production". */
+    environment?: Environment;
+    /** Public API key for authenticated requests. */
+    apiKey?: string;
+    /** Override the base API URL. */
+    baseUrl?: string;
+    /** Full config object (alternative to individual props). */
+    config?: HeadlessConfig;
+    children: React.ReactNode;
+}
+/**
+ * Root provider for the TagadaPay Headless SDK React integration.
+ * Creates a single HeadlessClient and shares it via context.
+ *
+ * @example
+ * ```tsx
+ * <TagadaHeadlessProvider storeId="store_abc123" environment="production">
+ *   <App />
+ * </TagadaHeadlessProvider>
+ * ```
+ */
+export declare function TagadaHeadlessProvider({ storeId, environment, apiKey, baseUrl, config, children, }: TagadaHeadlessProviderProps): import("react/jsx-runtime.js").JSX.Element;
+/** Access the HeadlessClient from context. Throws if used outside the provider. */
+export declare function useHeadlessClient(): HeadlessClient;
+//# sourceMappingURL=provider.d.ts.map

package/dist/react/provider.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { createHeadlessClient } from '../core/client.js';
+const TagadaHeadlessContext = createContext(null);
+/**
+ * Root provider for the TagadaPay Headless SDK React integration.
+ * Creates a single HeadlessClient and shares it via context.
+ *
+ * @example
+ * ```tsx
+ * <TagadaHeadlessProvider storeId="store_abc123" environment="production">
+ *   <App />
+ * </TagadaHeadlessProvider>
+ * ```
+ */
+export function TagadaHeadlessProvider({ storeId, environment, apiKey, baseUrl, config, children, }) {
+    const client = useMemo(() => {
+        const cfg = config ?? { storeId, environment, apiKey, baseUrl };
+        return createHeadlessClient(cfg);
+    }, [storeId, environment, apiKey, baseUrl, config]);
+    const value = useMemo(() => ({ client }), [client]);
+    return (_jsx(TagadaHeadlessContext.Provider, { value: value, children: children }));
+}
+/** Access the HeadlessClient from context. Throws if used outside the provider. */
+export function useHeadlessClient() {
+    const ctx = useContext(TagadaHeadlessContext);
+    if (!ctx) {
+        throw new Error('useHeadlessClient must be used within <TagadaHeadlessProvider>');
+    }
+    return ctx.client;
+}
+//# sourceMappingURL=provider.js.map

package/dist/stripe/StripeExpressButton.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { UseStripeExpressOptions } from './useStripeExpress.js';
+export type StripeExpressButtonProps = UseStripeExpressOptions & {
+    /** CSS class for the wrapper div. */
+    className?: string;
+    /** Inline style for the wrapper div. */
+    style?: React.CSSProperties;
+};
+/**
+ * Drop-in React component that renders Stripe Express Checkout buttons
+ * (Apple Pay, Google Pay, Link, etc.).
+ *
+ * Internally uses `useStripeExpress` which handles the full flow:
+ * discover config -> load Stripe -> mount ECE -> confirm -> poll -> callbacks.
+ *
+ * @example
+ * ```tsx
+ * import { StripeExpressButton } from '@tagadapay/headless-sdk/stripe';
+ *
+ * <StripeExpressButton
+ *   checkoutSessionId={session.id}
+ *   amount={totals.total}
+ *   currency={totals.currency}
+ *   onSuccess={() => router.push('/confirmation')}
+ *   onError={(msg) => toast.error(msg)}
+ * />
+ * ```
+ */
+export declare function StripeExpressButton({ className, style, ...hookOpts }: StripeExpressButtonProps): import("react/jsx-runtime.js").JSX.Element;
+//# sourceMappingURL=StripeExpressButton.d.ts.map

package/dist/stripe/StripeExpressButton.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useStripeExpress } from './useStripeExpress.js';
+/**
+ * Drop-in React component that renders Stripe Express Checkout buttons
+ * (Apple Pay, Google Pay, Link, etc.).
+ *
+ * Internally uses `useStripeExpress` which handles the full flow:
+ * discover config -> load Stripe -> mount ECE -> confirm -> poll -> callbacks.
+ *
+ * @example
+ * ```tsx
+ * import { StripeExpressButton } from '@tagadapay/headless-sdk/stripe';
+ *
+ * <StripeExpressButton
+ *   checkoutSessionId={session.id}
+ *   amount={totals.total}
+ *   currency={totals.currency}
+ *   onSuccess={() => router.push('/confirmation')}
+ *   onError={(msg) => toast.error(msg)}
+ * />
+ * ```
+ */
+export function StripeExpressButton({ className, style, ...hookOpts }) {
+    const { containerRef, isReady } = useStripeExpress(hookOpts);
+    return (_jsx("div", { ref: containerRef, className: className, style: {
+            visibility: isReady ? 'visible' : 'hidden',
+            minHeight: isReady ? undefined : 0,
+            overflow: isReady ? undefined : 'hidden',
+            ...style,
+        } }));
+}
+//# sourceMappingURL=StripeExpressButton.js.map

package/dist/stripe/StripeExpressCheckout.d.ts

@@ -0,0 +1,98 @@
+import type { HeadlessClient } from '../core/client.js';
+import type { StripeExpressOptions, PaymentStatus } from '../core/types.js';
+type EventMap = {
+    ready: {
+        availablePaymentMethods: Record<string, boolean> | undefined;
+    };
+    success: {
+        payment: PaymentStatus;
+        order?: {
+            id: string;
+            checkoutSessionId?: string;
+        };
+    };
+    error: string;
+    cancel: void;
+};
+type EventHandler<K extends keyof EventMap> = (data: EventMap[K]) => void;
+/**
+ * Session-based Stripe Express Checkout integration.
+ *
+ * Mounts the Stripe `ExpressCheckoutElement` (Apple Pay, Google Pay, Link,
+ * PayPal, Klarna express) into any DOM container, wired to a Tagada
+ * checkout session. Drives the full flow:
+ * mount &rarr; wallet confirm &rarr; backend `payDirect` (`processStripeExpress`)
+ * &rarr; `stripe.confirmPayment` &rarr; poll payment status &rarr; emit `success`.
+ *
+ * **Session-free / partner S2S flow?** Use the lower-level primitive
+ * `startStripeExpressCheckout` exported from `@tagadapay/core-js`
+ * (also re-exported from `@tagadapay/headless-sdk/stripe`). It uses
+ * Stripe's older Payment Request API, stops at tokenization, and
+ * returns a `paymentMethodId` for partner-server-side processing.
+ *
+ * @example
+ * ```ts
+ * import { createHeadlessClient } from '@tagadapay/headless-sdk';
+ * import { StripeExpressCheckout } from '@tagadapay/headless-sdk/stripe';
+ *
+ * const client = createHeadlessClient({ storeId: 'store_xxx' });
+ * const session = await client.checkout.loadSession(checkoutToken);
+ * const express = await client.payment.getExpressMethods(session.id);
+ *
+ * const ece = new StripeExpressCheckout({
+ *   client,
+ *   publishableKey: express.applePay?.publishableKey!,
+ *   processorId: express.applePay?.processorId!,
+ * });
+ *
+ * ece.on('success', ({ payment }) => console.log('Paid!', payment.id));
+ * ece.on('error', (msg) => console.error(msg));
+ *
+ * await ece.mount(document.getElementById('express-container')!, {
+ *   checkoutSessionId: session.id,
+ *   amount: session.totals.total,
+ *   currency: session.totals.currency,
+ * });
+ * ```
+ */
+export declare class StripeExpressCheckout {
+    private stripe;
+    private elements;
+    private expressElement;
+    private container;
+    private isProcessing;
+    private listeners;
+    private readonly client;
+    private readonly publishableKey;
+    private readonly processorId;
+    private readonly enabledMethods;
+    private readonly buttonHeight;
+    private readonly buttonType;
+    private readonly emailRequired;
+    private readonly billingAddressRequired;
+    constructor(opts: {
+        client: HeadlessClient;
+    } & StripeExpressOptions);
+    on<K extends keyof EventMap>(event: K, handler: EventHandler<K>): void;
+    off<K extends keyof EventMap>(event: K, handler: EventHandler<K>): void;
+    /**
+     * Load Stripe.js, create Elements, and mount the ExpressCheckoutElement.
+     */
+    mount(container: HTMLElement, opts: {
+        checkoutSessionId: string;
+        amount: number;
+        currency: string;
+    }): Promise<void>;
+    /**
+     * Update the payment amount (e.g. after a cart change).
+     */
+    updateAmount(amount: number, currency?: string): void;
+    /**
+     * Clean up: unmount the element and release references.
+     */
+    unmount(): void;
+    private emit;
+    private extractClientSecret;
+}
+export {};
+//# sourceMappingURL=StripeExpressCheckout.d.ts.map