@zonos/elements 1.3.267 → 1.3.268

package/dist/collection/components/checkout/zonos-checkout/zonos-checkout.js

@@ -1,6 +1,7 @@
 import { Fragment, h, Host, } from "@stencil/core";
 import { cartStore, cartStoreClearCheckoutInterval, cartStoreNextStep, cartStoreOnChange, cartStoreReset, cartStoreResetTabItems, cartStoreSetCheckoutSession, cartStoreStartCheckoutInterval, cartStoreUpdateItems, cartStoreUpdateToErrorState, } from "../../store/checkout/cart";
 import { paypalInitScript, paypalStore, paypalStoreHasPaypalEnabled, } from "../../store/checkout/paypal";
+import { isPolicyConsentRequired, policyConsentStore, policyConsentStoreReset, } from "../../store/checkout/policyConsent";
 import { storeCreditStoreApplyCredit, storeCreditStoreCoversFullAmount, storeCreditStoreCreateOrder, storeCreditStoreGetEffectiveAmount, } from "../../store/checkout/storeCredit";
 import { getCheckoutSessionBody, initStripeElements, stripeStore, stripeStoreCleanupDomesticShippingSession, stripeStoreConfirmPayment, stripeStoreGetPaymentIntent, stripeStoreHandleInventoryCheck, stripeStoreHandleInventoryRefund, stripeStoreInitCheckoutSession, stripeStoreOnChange, stripeStorePrefetchLandedCost, stripeStoreReset, stripeStoreRetrievePayment, stripeStoreUpdateCheckoutSessionBaseCurrency, } from "../../store/checkout/stripe";
 import { localizationStore, localizationStoreOnChange, } from "../../store/hello/localization";
@@ -562,6 +563,12 @@ export class ZonosCheckout {
             // reset cart store if it's not preview mode and only when checkout is in the finish step.
             cartStoreReset();
         }
+        // Clear policy consent on every close (not just finish) so a buyer who
+        // checked the box mid-flow and then closed can't carry the prior
+        // acceptance into a new attempt without a fresh checkbox click.
+        if (!this.preview) {
+            policyConsentStoreReset();
+        }
         // reset step to customer info
         cartStore.step = 'customer-info';
         // reset the tab item, so that user needs to click on Continue button to re-quote the landed cost if needed.
@@ -1390,77 +1397,104 @@ export class ZonosCheckout {
             stripeStore.shouldRenderPayInUsdButton &&
             !this.payInUsdConfirmDialogOpen) {
             this.payInUsdConfirmDialogOpen = true;
+            // Don't unlock consent here — the USD-confirm dialog is mid-flow; the
+            // lock should hold until the user resolves the dialog and we re-enter.
             return;
         }
         // Close the dialog after the user confirms to proceed with the payment in USD
         this.payInUsdConfirmDialogOpen = false;
-        // reset paypal error message
-        paypalStore.paypalErrorMessage = null;
-        // reset error state
-        stripeStore.hasPaymentError = false;
-        this.submitLoading = true;
-        // reset inventory check message
-        cartStore.inventoryCheckErrorMessage = null;
-        // Attempt to change settlement currency to USD
-        const baseCurrencyUpdateSuccess = await stripeStoreUpdateCheckoutSessionBaseCurrency();
-        // Should not proceed to confirm payment if base currency update failed
-        if (!baseCurrencyUpdateSuccess) {
-            stripeStore.hasPaymentError = true;
-            stripeStore.customErrorMessage = translate('Unable to complete payment in [currency]. Please try again or select a different currency. If the issue persists, contact our support team for assistance.', {
-                currency: stripeStore.checkoutSettlementCurrency,
-            });
-            this.submitLoading = false;
-            return;
-        }
+        // Track whether consent was required at the start of this flow so we know
+        // whether to release the lock in `finally`. The store reset on checkout
+        // close will catch any stragglers, but releasing here lets the buyer
+        // recover (uncheck / retry) when an async step aborts.
+        const consentWasRequired = isPolicyConsentRequired();
         try {
-            // check inventory before proceeding to payment
-            cartStore.inventoryCheckErrorMessage =
-                await stripeStoreHandleInventoryCheck();
-        }
-        catch (_a) {
-            // If user provide callback and it throw an exception, default to this message and stop the payment.
-            cartStore.inventoryCheckErrorMessage = translate('Unable to check inventory. Please try again.');
-        }
-        // Don't proceed to payment if there's an error message
-        if (cartStore.inventoryCheckErrorMessage) {
-            // stop the submit loading state
-            this.submitLoading = false;
-            return;
-        }
-        // Apply store credit if customer has selected an amount
-        const storeCreditAmount = storeCreditStoreGetEffectiveAmount();
-        if (storeCreditAmount > 0) {
-            const storeCreditResult = await storeCreditStoreApplyCredit();
-            if (!storeCreditResult.success) {
+            // reset paypal error message
+            paypalStore.paypalErrorMessage = null;
+            // reset error state
+            stripeStore.hasPaymentError = false;
+            this.submitLoading = true;
+            // reset inventory check message
+            cartStore.inventoryCheckErrorMessage = null;
+            // Attempt to change settlement currency to USD
+            const baseCurrencyUpdateSuccess = await stripeStoreUpdateCheckoutSessionBaseCurrency();
+            // Should not proceed to confirm payment if base currency update failed
+            if (!baseCurrencyUpdateSuccess) {
                 stripeStore.hasPaymentError = true;
-                stripeStore.customErrorMessage =
-                    storeCreditResult.error ||
-                        translate('Unable to apply store credit. Please try again.');
+                stripeStore.customErrorMessage = translate('Unable to complete payment in [currency]. Please try again or select a different currency. If the issue persists, contact our support team for assistance.', {
+                    currency: stripeStore.checkoutSettlementCurrency,
+                });
                 this.submitLoading = false;
                 return;
             }
-        }
-        // If store credit covers the full order, create order directly without payment
-        if (storeCreditStoreCoversFullAmount()) {
             try {
-                // Validate checkout session (landed cost ID, etc.) before creating order
-                const checkoutSessionStatus = await validateCheckoutSession();
-                if (!checkoutSessionStatus.valid) {
+                // check inventory before proceeding to payment
+                cartStore.inventoryCheckErrorMessage =
+                    await stripeStoreHandleInventoryCheck();
+            }
+            catch (_a) {
+                // If user provide callback and it throw an exception, default to this message and stop the payment.
+                cartStore.inventoryCheckErrorMessage = translate('Unable to check inventory. Please try again.');
+            }
+            // Don't proceed to payment if there's an error message
+            if (cartStore.inventoryCheckErrorMessage) {
+                // stop the submit loading state
+                this.submitLoading = false;
+                return;
+            }
+            // Apply store credit if customer has selected an amount
+            const storeCreditAmount = storeCreditStoreGetEffectiveAmount();
+            if (storeCreditAmount > 0) {
+                const storeCreditResult = await storeCreditStoreApplyCredit();
+                if (!storeCreditResult.success) {
                     stripeStore.hasPaymentError = true;
-                    stripeStore.customErrorMessage = checkoutSessionStatus.errorMessage;
+                    stripeStore.customErrorMessage =
+                        storeCreditResult.error ||
+                            translate('Unable to apply store credit. Please try again.');
                     this.submitLoading = false;
                     return;
                 }
-                const orderResult = await storeCreditStoreCreateOrder();
-                if (!orderResult.success) {
+            }
+            // If store credit covers the full order, create order directly without payment
+            if (storeCreditStoreCoversFullAmount()) {
+                try {
+                    // Validate checkout session (landed cost ID, etc.) before creating order
+                    const checkoutSessionStatus = await validateCheckoutSession();
+                    if (!checkoutSessionStatus.valid) {
+                        stripeStore.hasPaymentError = true;
+                        stripeStore.customErrorMessage = checkoutSessionStatus.errorMessage;
+                        this.submitLoading = false;
+                        return;
+                    }
+                    const orderResult = await storeCreditStoreCreateOrder();
+                    if (!orderResult.success) {
+                        stripeStore.hasPaymentError = true;
+                        stripeStore.customErrorMessage =
+                            orderResult.error ||
+                                translate('Unable to place order with store credit. Please try again.');
+                        this.submitLoading = false;
+                        return;
+                    }
+                    cartStoreNextStep();
+                    cartStoreClearCheckoutInterval();
+                }
+                catch (err) {
+                    logError(err);
+                    submitAnalytics({
+                        event: 'zonos-checkout-payment-fail',
+                        metadata: {
+                            checkoutSessionId: storageStore.checkoutSessionId,
+                        },
+                    });
                     stripeStore.hasPaymentError = true;
-                    stripeStore.customErrorMessage =
-                        orderResult.error ||
-                            translate('Unable to place order with store credit. Please try again.');
-                    this.submitLoading = false;
-                    return;
                 }
+                this.submitLoading = false;
+                return;
+            }
+            try {
+                await stripeStoreConfirmPayment();
                 cartStoreNextStep();
+                // clear the checkout session timeout timer when purchase is complete
                 cartStoreClearCheckoutInterval();
             }
             catch (err) {
@@ -1472,32 +1506,22 @@ export class ZonosCheckout {
                     },
                 });
                 stripeStore.hasPaymentError = true;
+                // should request inventory refund if there's an error during payment
+                if (stripeStore.shouldInventoryRefund) {
+                    void stripeStoreHandleInventoryRefund();
+                    stripeStore.shouldInventoryRefund = false;
+                }
             }
             this.submitLoading = false;
-            return;
         }
-        try {
-            await stripeStoreConfirmPayment();
-            cartStoreNextStep();
-            // clear the checkout session timeout timer when purchase is complete
-            cartStoreClearCheckoutInterval();
-        }
-        catch (err) {
-            logError(err);
-            submitAnalytics({
-                event: 'zonos-checkout-payment-fail',
-                metadata: {
-                    checkoutSessionId: storageStore.checkoutSessionId,
-                },
-            });
-            stripeStore.hasPaymentError = true;
-            // should request inventory refund if there's an error during payment
-            if (stripeStore.shouldInventoryRefund) {
-                void stripeStoreHandleInventoryRefund();
-                stripeStore.shouldInventoryRefund = false;
+        finally {
+            // Release the consent lock on every terminal exit (success or failure)
+            // so the buyer can re-toggle / retry. On success the cart advances and
+            // the close-handler reset would clean this up anyway.
+            if (consentWasRequired) {
+                policyConsentStore.locked = false;
             }
         }
-        this.submitLoading = false;
     }
     async handleFinishClick() {
         // reset stripe store
@@ -1509,6 +1533,8 @@ export class ZonosCheckout {
         }
         // reset cart store
         cartStoreReset();
+        // reset policy consent so the next checkout starts un-accepted
+        policyConsentStoreReset();
         // redirect to vendor store url if this is legacy checkout.
         if (window.Zonos.isLegacyCheckout && window.Zonos.cartData) {
             const storeBaseUrl = window.Zonos.cartData.storeBaseUrl ||
@@ -1710,6 +1736,8 @@ export class ZonosCheckout {
         stripeStoreReset();
         // reset cart store
         cartStoreReset();
+        // reset policy consent
+        policyConsentStoreReset();
         // cleanup onChange listener
         this.storeUnsubscribeList.forEach(unsubscribe => unsubscribe());
         window.removeEventListener('message', this.handleHostedOpenWindowCallback);

package/dist/collection/components/checkout/zonos-checkout/zonos-policy-consent/zonos-policy-consent.css

@@ -0,0 +1,93 @@
+:host {
+  font-family: var(--zonos--font-family, Inter), Inter;
+  display: block;
+  white-space: normal;
+}
+:host * {
+  font-family: var(--zonos--font-family, Inter), Inter;
+}
+:host img {
+  max-width: 100%;
+}
+:host dl,
+:host dd,
+:host h1,
+:host h2,
+:host h3,
+:host h4,
+:host h5,
+:host h6,
+:host hr,
+:host figure,
+:host p,
+:host pre {
+  margin: 0;
+}
+
+/* All sets of variable are here */
+/* smooth font rendering */
+:host {
+  -moz-osx-font-smoothing: grayscale;
+  -webkit-font-smoothing: antialiased;
+}
+
+:host {
+  display: block;
+  margin-top: 20px;
+}
+
+.zonos--policy-consent {
+  background-color: var(--zonos-elements-gray-50);
+  border: 1px solid var(--zonos-elements-gray-200);
+  border-radius: 8px;
+  padding: 12px 14px;
+  transition: border-color 0.15s ease, background-color 0.15s ease;
+}
+
+.zonos--policy-consent:hover {
+  border-color: var(--zonos-elements-gray-300);
+}
+
+.zonos--policy-consent--error {
+  background-color: var(--zonos-elements-red-50);
+  border-color: var(--zonos-elements-red-400);
+}
+
+.zonos--policy-consent-label {
+  align-items: center;
+  cursor: pointer;
+  display: flex;
+  gap: 10px;
+  user-select: none;
+}
+
+.zonos--policy-consent-checkbox {
+  accent-color: var(--zonos-elements-blue-600);
+  cursor: pointer;
+  flex-shrink: 0;
+  height: 18px;
+  margin: 0;
+  width: 18px;
+}
+
+.zonos--policy-consent-text {
+  color: var(--zonos-elements-gray-800);
+  font-size: 14px;
+  line-height: 1.45;
+}
+.zonos--policy-consent-text a {
+  color: var(--zonos-elements-blue-600);
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+.zonos--policy-consent-text a:hover {
+  color: var(--zonos-elements-blue-700);
+}
+
+.zonos--policy-consent-error {
+  color: var(--zonos-elements-red-600);
+  font-size: 13px;
+  line-height: 1.4;
+  margin-top: 8px;
+  padding: 0 4px;
+}

package/dist/collection/components/checkout/zonos-checkout/zonos-policy-consent/zonos-policy-consent.js

@@ -0,0 +1,93 @@
+import { Fragment, h, Host } from "@stencil/core";
+import { getEnabledPolicies, policyConsentStore, } from "../../../store/checkout/policyConsent";
+import { localizationStore } from "../../../store/hello/localization";
+import { translate } from "../../../store/translationStore";
+import { zonosStore } from "../../../store/zonosStore";
+const POLICIES_SENTINEL = 'POLICIES';
+export class ZonosPolicyConsent {
+    render() {
+        const policies = getEnabledPolicies();
+        if (!policies.length) {
+            return null;
+        }
+        // Build the locale-aware joined list ("X, Y, and Z" in English, equivalent in other locales).
+        const ListFormatCtor = Intl
+            .ListFormat;
+        const parts = ListFormatCtor
+            ? new ListFormatCtor(localizationStore.selectedLocale, {
+                style: 'long',
+                type: 'conjunction',
+            }).formatToParts(policies.map(p => p.name))
+            : // Fallback for environments without Intl.ListFormat: simple ", "-joined list.
+                policies.flatMap((p, idx) => idx === 0
+                    ? [{ type: 'element', value: p.name }]
+                    : [
+                        { type: 'literal', value: ', ' },
+                        { type: 'element', value: p.name },
+                    ]);
+        const listNodes = parts.map(part => {
+            if (part.type === 'literal') {
+                return part.value;
+            }
+            // 'element' part — match back to the policy by name to recover its URL.
+            const policy = policies.find(p => p.name === part.value);
+            if (!policy) {
+                return part.value;
+            }
+            return (h("a", { href: policy.url,
+                // Prevent the surrounding <label> from also activating the checkbox
+                // when the link is clicked — `stopPropagation` alone doesn't suppress
+                // the label's default behavior in every browser. We explicitly open
+                // the URL ourselves and call `preventDefault` to swallow the click.
+                onClick: (event) => {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    window.open(policy.url, '_blank', 'noopener,noreferrer');
+                }, rel: "noopener noreferrer", target: "_blank" }, part.value));
+        });
+        // Use the merchant-name template when an org name is available, falling back to the generic
+        // phrasing otherwise so we never render a stray apostrophe (e.g. " 's Terms...").
+        // Reads from `zonosStore` so this works when consumed via the npm package
+        // (where `window.Zonos.cartSettings` may not be populated).
+        const merchantName = zonosStore.organizationName;
+        const template = merchantName
+            ? translate("I agree to [merchantName]'s [policies]", {
+                merchantName,
+                policies: POLICIES_SENTINEL,
+            })
+            : translate('I agree to the [policies]', {
+                policies: POLICIES_SENTINEL,
+            });
+        const [before = '', after = ''] = template.split(POLICIES_SENTINEL);
+        const showError = policyConsentStore.showError;
+        const errorId = 'zonos--policy-consent-error';
+        return (h(Host, { class: "zonos--policy-consent-host" }, h("div", { class: `zonos--policy-consent${showError ? ' zonos--policy-consent--error' : ''}` }, h("label", { class: "zonos--policy-consent-label" }, h("input", { "aria-describedby": showError ? errorId : undefined, "aria-invalid": showError ? 'true' : 'false', checked: policyConsentStore.accepted, class: "zonos--policy-consent-checkbox", disabled: policyConsentStore.locked, onChange: (event) => {
+                const isChecked = event.target.checked;
+                policyConsentStore.accepted = isChecked;
+                if (isChecked) {
+                    // Snapshot the timestamp at the moment of acceptance so later
+                    // session-metadata updates don't drift it forward.
+                    if (!policyConsentStore.acceptedAt) {
+                        policyConsentStore.acceptedAt = new Date().toISOString();
+                    }
+                    policyConsentStore.showError = false;
+                }
+                else {
+                    // If the buyer un-checks, the prior acceptance is no longer valid.
+                    policyConsentStore.acceptedAt = null;
+                }
+            }, type: "checkbox" }), h("span", { class: "zonos--policy-consent-text" }, before, h(Fragment, null, listNodes), after))), showError && (h("div", { class: "zonos--policy-consent-error", id: errorId, role: "alert" }, translate('You must accept the policies to place this order')))));
+    }
+    static get is() { return "zonos-policy-consent"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["zonos-policy-consent.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["zonos-policy-consent.css"]
+        };
+    }
+}

package/dist/collection/components/store/checkout/paypal.js

@@ -1,8 +1,9 @@
 import { loadScript, } from "@paypal/paypal-js";
 import { createStore } from "@stencil/store";
 import { cartStore, cartStoreClearCheckoutInterval, cartStoreNextStep, } from "./cart";
+import { isPolicyConsentRequired, policyConsentStore, } from "./policyConsent";
 import { storeCreditStoreApplyCredit, storeCreditStoreCoversFullAmount, storeCreditStoreCreateOrder, storeCreditStoreGetEffectiveAmount, } from "./storeCredit";
-import { stripeStore, stripeStoreHandleInventoryCheck, } from "./stripe";
+import { stripeStore, stripeStoreHandleInventoryCheck, stripeStoreRecordPolicyConsent, } from "./stripe";
 import { storageStore } from "../storageStore";
 import { translate } from "../translationStore";
 import { zonosStore } from "../zonosStore";
@@ -81,6 +82,7 @@ const paypalButtonOptions = ({ checkoutSessionId, onPaypalFail, onPaypalSessionD
     });
     return {
         createOrder: async () => {
+            var _a;
             // Clicking on the paypal button should trigger the paymentInfoCompleted event
             void trackConversionEvent({
                 checkoutSessionId,
@@ -89,22 +91,42 @@ const paypalButtonOptions = ({ checkoutSessionId, onPaypalFail, onPaypalSessionD
                     paymentMethod: 'paypal',
                 },
             });
-            const checkoutSessionStatus = await validateCheckoutSession();
-            if (!checkoutSessionStatus.valid) {
-                paypalStore.paypalErrorMessage = checkoutSessionStatus.errorMessage;
-                // reset stripe error message
-                stripeStore.hasPaymentError = false;
-                stripeStore.customErrorMessage = null;
-                submitAnalytics({
-                    event: 'zonos-checkout-payment-fail',
-                    metadata: {
-                        checkoutSessionId,
-                    },
-                });
+            // Block PayPal submit when the merchant requires policy consent and the
+            // buyer hasn't accepted. Mirrors the Pay-button gate so both flows enforce
+            // the same legal contract.
+            if (isPolicyConsentRequired() && !policyConsentStore.accepted) {
+                policyConsentStore.showError = true;
+                (_a = document
+                    .querySelector('zonos-policy-consent')) === null || _a === void 0 ? void 0 : _a.scrollIntoView({ behavior: 'smooth' });
                 onPaypalFail === null || onPaypalFail === void 0 ? void 0 : onPaypalFail();
                 return '';
             }
+            // Lock consent for the rest of the flow so the buyer can't uncheck during
+            // the async PayPal handshake and create a race against the metadata writer.
+            // The `try/finally` below clears the lock on any non-success exit so the
+            // checkbox doesn't stay disabled when validation / inventory / store
+            // credit aborts before an order is actually created.
+            const consentRequired = isPolicyConsentRequired();
+            if (consentRequired) {
+                policyConsentStore.locked = true;
+            }
+            let handedOffToPayPal = false;
             try {
+                const checkoutSessionStatus = await validateCheckoutSession();
+                if (!checkoutSessionStatus.valid) {
+                    paypalStore.paypalErrorMessage = checkoutSessionStatus.errorMessage;
+                    // reset stripe error message
+                    stripeStore.hasPaymentError = false;
+                    stripeStore.customErrorMessage = null;
+                    submitAnalytics({
+                        event: 'zonos-checkout-payment-fail',
+                        metadata: {
+                            checkoutSessionId,
+                        },
+                    });
+                    onPaypalFail === null || onPaypalFail === void 0 ? void 0 : onPaypalFail();
+                    return '';
+                }
                 // reset paypal error banner
                 paypalStore.paypalErrorMessage = null;
                 // reset inventory check error message
@@ -114,7 +136,7 @@ const paypalButtonOptions = ({ checkoutSessionId, onPaypalFail, onPaypalSessionD
                     cartStore.inventoryCheckErrorMessage =
                         await stripeStoreHandleInventoryCheck();
                 }
-                catch (_a) {
+                catch (_b) {
                     // If user provide callback and it throw an exception, default to this message and stop the payment.
                     cartStore.inventoryCheckErrorMessage = translate('Unable to check inventory. Please try again.');
                 }
@@ -134,6 +156,13 @@ const paypalButtonOptions = ({ checkoutSessionId, onPaypalFail, onPaypalSessionD
                         return '';
                     }
                 }
+                // Persist consent into the checkout session metadata BEFORE either
+                // branch creates the order — both the store-credit-only path and the
+                // real PayPal path need the consent recorded. A transient failure here
+                // is logged (via `logError` inside the helper) but does NOT block the
+                // order: blocking on a flaky network would gate buyers from paying,
+                // and the buyer's consent intent is already captured client-side.
+                await stripeStoreRecordPolicyConsent();
                 // If store credit covers the full order, create order directly
                 if (storeCreditStoreCoversFullAmount()) {
                     const orderResult = await storeCreditStoreCreateOrder();
@@ -147,11 +176,18 @@ const paypalButtonOptions = ({ checkoutSessionId, onPaypalFail, onPaypalSessionD
                     onPaypalSessionDone === null || onPaypalSessionDone === void 0 ? void 0 : onPaypalSessionDone({ orderId: orderResult.orderId || '' });
                     cartStoreNextStep();
                     cartStoreClearCheckoutInterval();
+                    // Store-credit-only success: the cart advances to the next step
+                    // and the store reset on close will handle the lock cleanup.
+                    handedOffToPayPal = true;
                     return '';
                 }
                 const paypalOrderId = await paypalStoreCreaterOrder({
                     checkoutSessionId,
                 });
+                // Successful hand-off to PayPal — the popup opens next and onApprove
+                // will fire on completion. Keep the lock set so closes/resets later
+                // clean up; an empty ID falls through to the unlock in `finally`.
+                handedOffToPayPal = !!paypalOrderId;
                 return paypalOrderId;
             }
             catch (err) {
@@ -170,6 +206,13 @@ const paypalButtonOptions = ({ checkoutSessionId, onPaypalFail, onPaypalSessionD
                 onPaypalFail === null || onPaypalFail === void 0 ? void 0 : onPaypalFail();
                 return '';
             }
+            finally {
+                // Clear the lock unless we successfully handed off the order — on
+                // failures the buyer needs to be able to uncheck and retry.
+                if (consentRequired && !handedOffToPayPal) {
+                    policyConsentStore.locked = false;
+                }
+            }
         },
         onApprove: async (_, _actions) => {
             try {

package/dist/collection/components/store/checkout/policyConsent.js

@@ -0,0 +1,58 @@
+import { createStore } from "@stencil/store";
+import { translate } from "../translationStore";
+import { zonosStore } from "../zonosStore";
+const POLICY_ORDER = [
+    'termsAndConditions',
+    'privacyPolicy',
+    'refundPolicy',
+    'shippingPolicy',
+    'warrantyPolicy',
+];
+// Reuses the lowercase `'Privacy policy'` key already translated in 19 locales
+// (also used by the checkout footer) — the other four are new keys that follow
+// the same lowercase convention for visual consistency in the joined consent line.
+const POLICY_NAME_KEY = {
+    privacyPolicy: 'Privacy policy',
+    refundPolicy: 'Refund policy',
+    shippingPolicy: 'Shipping policy',
+    termsAndConditions: 'Terms and conditions',
+    warrantyPolicy: 'Warranty policy',
+};
+const { reset: policyConsentStoreReset, state: policyConsentStore } = createStore({
+    accepted: false,
+    acceptedAt: null,
+    locked: false,
+    showError: false,
+});
+export { policyConsentStore, policyConsentStoreReset };
+/**
+ * Returns the list of policies the merchant has configured (non-empty link).
+ * Policies are returned in a fixed display order so the rendered list is
+ * deterministic across renders and across locales. URLs that aren't absolute
+ * http(s) URLs are filtered out as defense-in-depth against `javascript:` or
+ * other unexpected schemes slipping through the backend validation.
+ *
+ * Reads from `zonosStore.checkoutSettings` (not `window.Zonos.cartSettings`)
+ * so the consent UI works when zonos-elements is consumed via the npm package,
+ * where `cartSettings` is not populated.
+ */
+export const getEnabledPolicies = () => {
+    const links = zonosStore.checkoutSettings.merchantPolicyLinks;
+    if (!links) {
+        return [];
+    }
+    return POLICY_ORDER.reduce((acc, key) => {
+        var _a, _b;
+        const rawUrl = (_b = (_a = links[key]) === null || _a === void 0 ? void 0 : _a.link) === null || _b === void 0 ? void 0 : _b.trim();
+        if (!rawUrl || !/^https?:\/\//i.test(rawUrl)) {
+            return acc;
+        }
+        acc.push({
+            key,
+            name: translate(POLICY_NAME_KEY[key]),
+            url: rawUrl,
+        });
+        return acc;
+    }, []);
+};
+export const isPolicyConsentRequired = () => getEnabledPolicies().length > 0;