@zonos/elements 1.2.3 → 1.2.4-alpha.10

package/README.md

@@ -19,4 +19,18 @@
   - `tsconfig`: will include all folders to have all of the intellisense throughout the project.
   - `tsconfig.build`: stencil building process
   - `tsconfig.demo-script`: script for demo script
-  - `tsconfig.scripts`: rollup bundling for loading script.
+  - `tsconfig.scripts`: rollup bundling for loading script.
+
+## Developing/Release process
+
+### Merging strategy
+The github action would bump the version conditionally on qa and main branch merged event. 
++ qa branch merge flow: Only bump, publish version and create CDN when the version has alpha word.
++ main branch merge flow: Create a branch against qa and run pnpm version:[patch|major|minor], have it merged to qa, it would not trigger the publish version and create CDN until the changes on qa get merged to main.
+
+### Steps
+1. Each PR against qa will need to be prerelease pumped by running pnpm version:alpha.
+2. PR get merged to qa will trigger the github action to publish to npm with alpha tag and create a cdn domain alpha.js.zonos.com - alpha cdn doesn’t need to be versioned, so that when rolling back, the changes will be affected right away. 
+3. The release process would happen on qa. If we want to release, a new branch named build/v1.x.x will need to be checkout from qa. Bump the version (major, minor or patch), and then merge to qa.  
+4. Create a new branch with the same name build/v1.x.xoff of main, pull from qa and just create PR and merge to main. 
+5. PR get merged to `main` will trigger the github action to publish to npm with major, minor or patch tag and create a cdn domain v1.2.3.js.zonos.com.

package/dist/cjs/cart-90f7c8c0.js

@@ -0,0 +1,644 @@
+'use strict';
+
+const zonosStore = require('./zonosStore-b43ef5db.js');
+const localization = require('./localization-9caf3397.js');
+const isDarkColor = require('./isDarkColor-ff6ff183.js');
+const getBorderRadius = require('./getBorderRadius-bf4a4276.js');
+
+const prepCalculateLandedCost = () => {
+    // maybe we don't need email now for prefetch the landed cost
+    const stripeLinkData = stripeStore.stripeLinkEventData;
+    const stripeAddressData = stripeStore.stripeAddressEventData;
+    if (!stripeAddressData || !stripeAddressData.complete) {
+        throw new Error('Missing stripe address data');
+    }
+    return {
+        checkoutSessionId: cartStore.checkoutSessionId || '',
+        contact: {
+            email: (stripeLinkData === null || stripeLinkData === void 0 ? void 0 : stripeLinkData.value.email) || '',
+            // firstName and lastName should be valid now since stripe only mark
+            // the address as complete when both fields are filled.
+            firstName: stripeAddressData.value.firstName || '',
+            lastName: stripeAddressData.value.lastName || '',
+            phone: stripeAddressData.value.phone || '',
+        },
+        items: cartStore.items.map(item => item),
+        shippingAddress: {
+            addressLine1: stripeAddressData.value.address.line1,
+            addressLine2: stripeAddressData.value.address.line2 || '',
+            city: stripeAddressData.value.address.city,
+            country: stripeAddressData.value.address.country,
+            postalCode: stripeAddressData.value.address.postal_code,
+            state: stripeAddressData.value.address.state,
+        },
+    };
+};
+
+const triggerBuildLandedCost = async (buildLandedCost) => {
+    var _a;
+    const data = prepCalculateLandedCost();
+    const landedCost = await buildLandedCost(data.checkoutSessionId, data.contact, data.shippingAddress);
+    if (!landedCost) {
+        throw new Error('Failed to build landed cost');
+    }
+    // Validate the landed cost object to make sure the returned value from buildLandedCost has a valid schema
+    const { errors, json } = await localization.handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/validate-landed-cost`, {
+        body: landedCost,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    if (!json || errors.length) {
+        throw new Error(`Invalid landed cost object: ${((_a = errors.find(Boolean)) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown error'}`);
+    }
+    return landedCost;
+};
+
+const calculateLandedCost = async (abortController) => {
+    // If buildLandedCost callback is supplied, use that instead of our regular request to '/calculate-landed-cost'
+    const buildLandedCost = zonosStore.zonosStore.checkoutSettings.buildLandedCost;
+    if (buildLandedCost) {
+        const json = await triggerBuildLandedCost(buildLandedCost);
+        return json;
+    }
+    // request to get landed cost info
+    const url = `${"https://v1.route.js.zonos.com"}/api/zonos-elements/calculate-landed-cost`;
+    const { errors, json } = await localization.handleFetch(url, {
+        body: prepCalculateLandedCost(),
+        method: 'POST',
+        signal: abortController === null || abortController === void 0 ? void 0 : abortController.signal,
+    });
+    if (errors.length || !json) {
+        throw new Error('Failed to calculate landed cost');
+    }
+    return json;
+};
+
+const addressRuleStyle = ({ theme, }) => {
+    switch (theme) {
+        default:
+            return {
+                '.Input': {
+                    // need to reset everything and the paddingTop to default, otherwise the paddingTop will not be updated.
+                    padding: '0',
+                    paddingBottom: '8px',
+                    paddingLeft: '16px',
+                    paddingRight: '8px',
+                    // any value here will be add up to the default paddingTop (20px).
+                    paddingTop: '6px',
+                },
+            };
+    }
+};
+
+const defaultVariable = ({ borderStyle, theme, }) => {
+    switch (theme) {
+        case 'DARK':
+            return {
+                borderRadius: getBorderRadius.getBorderRadius(borderStyle),
+                colorBackground: '#101117',
+                colorBackgroundText: '#C5C6CA',
+                colorText: '#C5C6CA',
+                colorTextPlaceholder: '#C5C6CA',
+            };
+        default:
+            return {
+                borderRadius: getBorderRadius.getBorderRadius(borderStyle),
+            };
+    }
+};
+
+const { onChange: onChange$1, reset: reset$1, state: stripeStore, } = zonosStore.createStore(() => ({
+    clientSecret: sessionStorage.getItem('zonos--client-secret') || null,
+    fetchingLandedCostAbordController: null,
+    isFetchingLandedCost: false,
+    isFetchingSession: false,
+    stripe: null,
+    stripeAddressElement: null,
+    stripeAddressEventData: null,
+    stripeAddressUsedWhenFetchingLC: null,
+    stripeBillingAddressElement: null,
+    stripeElements: null,
+    stripeElementsOptions: null,
+    stripeLinkElement: null,
+    stripeLinkEventData: null,
+    stripeLinkUsedWhenFetchingLC: null,
+    stripePaymentElement: null,
+    stripePaymentEventData: null,
+}));
+const getStripeOptions = ({ clientSecret, overrideBorderRaidus, overridePrimaryColor, overrideTheme, }) => {
+    const primaryColor = overridePrimaryColor || zonosStore.zonosStore.appearance.colorPrimary;
+    const themeBasedColor = primaryColor && isDarkColor.isDarkColor(primaryColor) ? 'night' : 'flat';
+    // if overrideTheme is provided, use it. Otherwise, use theme based on primary color
+    const theme = overrideTheme === 'DARK' ? 'night' : 'flat';
+    return {
+        appearance: {
+            labels: 'floating',
+            rules: Object.assign({}, addressRuleStyle({ theme: 'LIGHT' })),
+            // get contrast theme color base on primary color
+            theme: overrideTheme ? theme : themeBasedColor,
+            variables: Object.assign({}, defaultVariable({
+                borderStyle: overrideBorderRaidus,
+                theme: 'LIGHT',
+            })),
+        },
+        clientSecret,
+        locale: localization.localizationStore.selectedLocale,
+    };
+};
+const initStripeElements = async (props) => {
+    var _a;
+    const clientSecret = stripeStore.clientSecret;
+    if (!stripeStore.stripe) {
+        localization.log('Skip. Stripe is not initialized');
+        return;
+    }
+    if (clientSecret) {
+        const stripeOptions = getStripeOptions({
+            clientSecret,
+            overrideBorderRaidus: props === null || props === void 0 ? void 0 : props.overrideBorderRaidus,
+            overridePrimaryColor: props === null || props === void 0 ? void 0 : props.overridePrimaryColor,
+            overrideTheme: props === null || props === void 0 ? void 0 : props.overrideTheme,
+        });
+        // compare with the previous options to see if we need to update
+        const isSameOptions = JSON.stringify(stripeOptions) ===
+            JSON.stringify(stripeStore.stripeElementsOptions);
+        if (!stripeStore.stripeElements) {
+            // init stripe elements if it doesn't exist
+            stripeStore.stripeElements = (_a = stripeStore.stripe) === null || _a === void 0 ? void 0 : _a.elements(stripeOptions);
+            // save stripe elements options for later comparison
+            stripeStore.stripeElementsOptions = stripeOptions;
+            localization.log('Stripe elements initialized');
+            return;
+        }
+        if (!isSameOptions) {
+            // update elements with new option if it already exists
+            stripeStore.stripeElements.update(stripeOptions);
+            // save stripe elements options for later comparison
+            stripeStore.stripeElementsOptions = stripeOptions;
+        }
+        localization.log('Stripe elements initialized');
+    }
+};
+const stripeStoreReset = () => {
+    // clean clientSecret so that we can start the new one.
+    sessionStorage.removeItem('zonos--client-secret');
+    // cleanup stripe elements
+    reset$1();
+    // set stripe back to window.Zonos.stripe
+    stripeStore.stripe = window.Zonos.stripe;
+};
+/**
+ * Check if the address and email info used when fetching landed cost with the current email and address info are different
+ * Purpose is to resend the request if the info used when fetching landed cost is different from the current info
+ */
+const isPrefetchInfoOutdated = () => {
+    var _a, _b, _c, _d;
+    const hasAbortController = stripeStore.fetchingLandedCostAbordController;
+    if (!hasAbortController) {
+        // if there is no abort controller, this is a new request
+        return false;
+    }
+    const isLinkDataDirty = JSON.stringify((_a = stripeStore.stripeLinkUsedWhenFetchingLC) === null || _a === void 0 ? void 0 : _a.value) !==
+        JSON.stringify((_b = stripeStore.stripeLinkEventData) === null || _b === void 0 ? void 0 : _b.value);
+    const isAddressDataDirty = JSON.stringify((_c = stripeStore.stripeAddressUsedWhenFetchingLC) === null || _c === void 0 ? void 0 : _c.value) !==
+        JSON.stringify((_d = stripeStore.stripeAddressEventData) === null || _d === void 0 ? void 0 : _d.value);
+    return isLinkDataDirty || isAddressDataDirty;
+};
+const stripeStorePrefetchLandedCost = async () => {
+    var _a, _b, _c, _d;
+    const stripeAddressReady = !!((_a = stripeStore.stripeAddressEventData) === null || _a === void 0 ? void 0 : _a.complete);
+    const stripeLinkReady = !!((_b = stripeStore.stripeLinkEventData) === null || _b === void 0 ? void 0 : _b.complete);
+    const shouldRefetch = isPrefetchInfoOutdated();
+    if (shouldRefetch) {
+        // if the info used when fetching landed cost is different from the current info, abort the previous request
+        (_c = stripeStore.fetchingLandedCostAbordController) === null || _c === void 0 ? void 0 : _c.abort();
+        stripeStore.fetchingLandedCostAbordController = null;
+    }
+    // only fetch if we are not fetching or we need to refetch
+    if (stripeAddressReady &&
+        stripeLinkReady &&
+        (shouldRefetch || !stripeStore.isFetchingLandedCost)) {
+        stripeStore.isFetchingLandedCost = true;
+        if (stripeStore.stripeAddressEventData) {
+            stripeStore.stripeAddressUsedWhenFetchingLC = Object.assign({}, stripeStore.stripeAddressEventData);
+        }
+        if (stripeStore.stripeLinkEventData) {
+            stripeStore.stripeLinkUsedWhenFetchingLC = Object.assign({}, stripeStore.stripeLinkEventData);
+        }
+        try {
+            const abortController = new AbortController();
+            stripeStore.fetchingLandedCostAbordController = abortController;
+            const { checkoutSessionWorkflow, shipmentRatingCalculateWorkflow } = await calculateLandedCost(abortController);
+            // reset abort controller after we are done
+            stripeStore.fetchingLandedCostAbordController = null;
+            // update cart store with landed cost info
+            cartStore.landedCostData =
+                (checkoutSessionWorkflow === null || checkoutSessionWorkflow === void 0 ? void 0 : checkoutSessionWorkflow.filter(Boolean)) || null;
+            cartStore.shippingData =
+                (shipmentRatingCalculateWorkflow === null || shipmentRatingCalculateWorkflow === void 0 ? void 0 : shipmentRatingCalculateWorkflow.filter(Boolean)) || null;
+            // apply new subtotal and total, this is mainly to show items in the presentment currency
+            const firstLandedCostData = (_d = cartStore.landedCostData) === null || _d === void 0 ? void 0 : _d.find(Boolean);
+            const subtotals = !!firstLandedCostData
+                ? firstLandedCostData.subtotals
+                : null;
+            if (subtotals) {
+                // prefetch landed cost will not update shipping and taxes since we haven't selected shipping method yet
+                cartStoreApplySubtotals({
+                    exchangeRate: subtotals.exchangeRate,
+                    items: subtotals.items,
+                    landedCostTotal: 0,
+                    presentmentCurrencyCode: subtotals.presentmentCurrencyCode,
+                    shipping: 0,
+                    total: subtotals.items,
+                });
+            }
+        }
+        catch (err) {
+            localization.logError(err);
+        }
+        stripeStore.isFetchingLandedCost = false;
+    }
+};
+const getStripeMessageBasedOnStatus = (status) => {
+    let messages = [];
+    let isError = true;
+    // Inspect the PaymentIntent `status` to indicate the status of the payment
+    // to your customer.
+    //
+    // Some payment methods will [immediately succeed or fail][0] upon
+    // confirmation, while others will first enter a `processing` state.
+    //
+    // [0]: https://stripe.com/docs/payments/payment-methods#payment-notification
+    switch (status) {
+        case 'succeeded': {
+            messages = [
+                localization.translate('Your payment went through successfully! Thank you for shopping with us! We hope you had an enjoyable experience and your support means the world to us.'),
+                '',
+                '',
+                localization.translate("We've sent an email confirmation of the order details for your review. And our team is carefully preparing your order so it arrives on time."),
+            ];
+            isError = false;
+            break;
+        }
+        case 'requires_capture':
+        case 'processing': {
+            messages = [
+                localization.translate("Payment processing. We'll update you when payment is received."),
+            ];
+            isError = false;
+            break;
+        }
+        case 'requires_payment_method': {
+            messages = [
+                localization.translate('Payment failed. Please try another payment method.'),
+            ];
+            break;
+        }
+        default: {
+            messages = [localization.translate('Something went wrong.')];
+            break;
+        }
+    }
+    return {
+        isError,
+        messages,
+    };
+};
+const stripeStoreRetrievePayment = async ({ clientSecret: _clientSecret, storybookForceStatus, }) => {
+    if (storybookForceStatus) {
+        // return status right away if we are in storybook mode
+        const { isError, messages } = getStripeMessageBasedOnStatus(storybookForceStatus);
+        return { error: isError, messages };
+    }
+    const clientSecret = _clientSecret || stripeStore.clientSecret;
+    if (!stripeStore.stripe || !clientSecret) {
+        localization.logError('Failed to retrieve payment intent. Stripe is not initialized');
+        return { error: true, message: [localization.translate('Something went wrong.')] };
+    }
+    const { paymentIntent } = await stripeStore.stripe.retrievePaymentIntent(clientSecret);
+    const status = paymentIntent === null || paymentIntent === void 0 ? void 0 : paymentIntent.status;
+    const { isError, messages } = getStripeMessageBasedOnStatus(status);
+    return { error: isError, messages };
+};
+const stripeStoreConfirmPayment = async () => {
+    var _a, _b, _c;
+    const stripePaymentReady = !!((_a = stripeStore.stripePaymentEventData) === null || _a === void 0 ? void 0 : _a.complete);
+    const stripeElements = stripeStore.stripeElements;
+    const stripe = stripeStore.stripe;
+    const stripeClientSecret = stripeStore.clientSecret;
+    if (stripe && stripeElements && stripePaymentReady && stripeClientSecret) {
+        const { error } = await stripe.confirmPayment({
+            confirmParams: {
+                receipt_email: (_c = (_b = stripeStore.stripeLinkEventData) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c.email,
+                return_url: window.location.href,
+            },
+            elements: stripeElements,
+            redirect: 'if_required',
+        });
+        if (error) {
+            if (error.type === 'card_error' || error.type === 'validation_error') {
+                throw new Error(error.message);
+            }
+            if (error.type === 'invalid_request_error') {
+                if (error.code === 'payment_intent_unexpected_state') {
+                    // PaymentIntent was canceled or expired, or status is `require_capture`.
+                    // don't throw error here because we will reset the checkout session last step
+                    return;
+                }
+            }
+            throw new Error('An unexpected error occurred.');
+        }
+    }
+};
+/**
+ * Init checkout session
+ * @returns {boolean} whether or not the checkout session is successfully created
+ */
+const stripeStoreInitCheckoutSession = async () => {
+    var _a;
+    const total = cartStore.items.reduce((amount, item) => amount + item.amount * item.quantity, 0);
+    if (!total || !localization.localizationStore.targetCurrency) {
+        localization.logError('Fail to create checkout session - invalid total or currency');
+        return false;
+    }
+    stripeStore.isFetchingSession = true;
+    const { errors, json } = await localization.handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/create-checkout-session`, {
+        body: {
+            currency: ((_a = cartStore.items.find(Boolean)) === null || _a === void 0 ? void 0 : _a.currencyCode) || '',
+            itemsAmount: total,
+            presentmentCountryCode: localization.localizationStore.selectedCountryCode || null,
+        },
+        method: 'POST',
+    });
+    stripeStore.isFetchingSession = false;
+    if (errors.length || !json) {
+        localization.logError('Error occurs when creating checkout session', JSON.stringify(errors, null, 2));
+        return false;
+    }
+    const result = json.checkoutSessionCreate;
+    stripeStore.clientSecret = result.clientSecret;
+    // update cart store with updated informations
+    cartStore.checkoutSessionId = result.id;
+    cartStoreApplySubtotals(Object.assign(Object.assign({}, result.subtotals), { landedCostTotal: 0, shipping: 0, total: result.subtotals.items }));
+    localization.log('Exchange rate updated for cart items (checkout session create)', 'info', cartStore.exchangeRate);
+    localization.log('done-init-checkout-session');
+    return true;
+};
+/**
+ * Update checkout session. Use for updating amount with landed cost id, or update session when cart items change
+ */
+const stripeStoreUpdateCheckoutSession = async ({ currency, id, itemsAmount, landedCostId, presentmentCountryCode, }) => {
+    // No need to set loading state here because this function will be called under the hood to update
+    // landed cost id for the section.
+    const { errors, json } = await localization.handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/update-checkout-session`, {
+        body: {
+            currency,
+            id,
+            itemsAmount,
+            landedCostId,
+            presentmentCountryCode,
+        },
+        method: 'POST',
+    });
+    if (errors.length || !json) {
+        localization.logError('Error occurs when updating checkout session', JSON.stringify(errors, null, 2));
+        return { errors, json };
+    }
+    return { errors: [], json };
+};
+onChange$1('clientSecret', clientSecret => {
+    // update stripe elements when client secret changes
+    if (clientSecret && stripeStore.stripe) {
+        sessionStorage.setItem('zonos--client-secret', clientSecret);
+    }
+    if (!clientSecret) {
+        sessionStorage.removeItem('zonos--client-secret');
+    }
+});
+
+const formatDate = ({ date, formatOptions = { day: 'numeric', weekday: 'long', year: 'numeric' }, }) => {
+    // format date to Thursday 3, 2023
+    return new Intl.DateTimeFormat('en-US', formatOptions).format(date);
+};
+
+const getDaysDifference = (targetDate) => {
+    const currentDate = new Date();
+    const timeDifference = targetDate.getTime() - currentDate.getTime();
+    const daysDifference = Math.floor(timeDifference / (1000 * 60 * 60 * 24)); // Convert milliseconds to days
+    return daysDifference;
+};
+
+const { onChange, reset, state: cartStore, } = zonosStore.createStore(() => ({
+    checkoutSessionId: sessionStorage.getItem('zonos--checkout-session-id') || null,
+    currency: 'USD',
+    dutiesTaxFees: 0,
+    error: null,
+    exchangeRate: null,
+    isSelectedShippingAboveDeminimis: false,
+    isSelectedShippingGuarantee: false,
+    items: [],
+    landedCostData: null,
+    selectedLandedCost: null,
+    selectedShippingOption: null,
+    selectedShippingOptionExpectedDate: '',
+    selectedShippingOptionTransitTime: '',
+    shipping: 0,
+    shippingData: null,
+    step: 'customer-info',
+    subtotal: 0,
+    total: 0,
+}));
+/**
+ * Format shipping transit info to be displayed on UI
+ * @returns
+ * - expectedDate: Thursday, Aug 12
+ * - maxTransit: 5
+ * - minTransit: 3
+ */
+const cartStoreGetShippingTransitInfo = (item) => {
+    const minTransit = item.minTransitAt
+        ? getDaysDifference(new Date(item.minTransitAt))
+        : '';
+    const maxTransit = item.maxTransitAt
+        ? getDaysDifference(new Date(item.maxTransitAt))
+        : '';
+    const expectedDate = item.minTransitAt
+        ? formatDate({
+            date: new Date(item.minTransitAt),
+        })
+        : '';
+    return {
+        expectedDate,
+        maxTransit,
+        minTransit,
+    };
+};
+const cartStoreReset = () => {
+    sessionStorage.removeItem('zonos--checkout-session-id');
+    // reset cart store
+    reset();
+};
+const cartStoreUpdateToErrorState = ({ messages, title, }) => {
+    cartStore.step = 'error';
+    cartStore.error = {
+        messages,
+        title,
+    };
+};
+const cartStoreApplySubtotals = (subtotals) => {
+    // update exchange rate so we can use it to display cart items
+    cartStore.exchangeRate = subtotals.exchangeRate;
+    cartStore.dutiesTaxFees = subtotals.landedCostTotal;
+    cartStore.subtotal = subtotals.items;
+    cartStore.total = subtotals.total;
+    cartStore.currency = subtotals.presentmentCurrencyCode;
+};
+const cartStoreReCalculateTotal = async ({ currency, itemsAmount, landedCostId, }) => {
+    if (landedCostId && cartStore.selectedLandedCost) {
+        // update cart total right away if we have landed cost id to avoid order total flickering
+        const subtotals = cartStore.selectedLandedCost.subtotals;
+        cartStoreApplySubtotals(subtotals);
+        localization.log('Exchange rate updated for cart items (landed cost subtotal)', 'info', cartStore.exchangeRate);
+    }
+    // update checkout session
+    if (!cartStore.checkoutSessionId) {
+        localization.logError('Could not update cart total without checkout session id');
+        return false;
+    }
+    const { json } = await stripeStoreUpdateCheckoutSession({
+        currency,
+        id: cartStore.checkoutSessionId,
+        itemsAmount,
+        landedCostId,
+        presentmentCountryCode: localization.localizationStore.selectedCountryCode,
+    });
+    if (!json) {
+        // do nothing if we can't get checkout session
+        localization.logError('Error occurs when updating checkout session');
+        cartStoreUpdateToErrorState({
+            messages: [
+                localization.translate("There's been an error updating your checkout session. Please reload and try again or contact support if the error persists"),
+            ],
+            title: localization.translate('Error updating Checkout'),
+        });
+        return false;
+    }
+    if (!landedCostId) {
+        // This is when first open the checkout modal and we just want to get info from the old cart session.
+        // use subtotals from checkout session to update cart total
+        cartStoreApplySubtotals(json.checkoutSessionUpdate.subtotals);
+        localization.log('Exchange rate updated for cart items (checkout session update)', 'info', cartStore.exchangeRate);
+    }
+    return true;
+};
+const cartStoreUpdateSelectedShippingOption = async (selectedShippingOption) => {
+    var _a, _b, _c, _d, _e;
+    cartStore.selectedShippingOption = selectedShippingOption;
+    // update shipping transit info
+    const { expectedDate, maxTransit, minTransit } = cartStoreGetShippingTransitInfo(cartStore.selectedShippingOption);
+    cartStore.selectedShippingOptionExpectedDate = expectedDate;
+    cartStore.selectedShippingOptionTransitTime =
+        minTransit && maxTransit
+            ? `${minTransit}-${maxTransit}`
+            : `${minTransit || maxTransit}`;
+    const selectedLandedCost = (_a = cartStore.landedCostData) === null || _a === void 0 ? void 0 : _a.find(checkoutSessionPresentment => {
+        var _a, _b, _c;
+        return ((_b = (_a = checkoutSessionPresentment.landedCost) === null || _a === void 0 ? void 0 : _a.shipmentRating) === null || _b === void 0 ? void 0 : _b.id) ===
+            ((_c = cartStore.selectedShippingOption) === null || _c === void 0 ? void 0 : _c.id);
+    });
+    // save selected landed cost for later use
+    cartStore.selectedLandedCost = selectedLandedCost || null;
+    if (!selectedLandedCost) {
+        // do nothing if we can't find landed cost for selected shipping option
+        return false;
+    }
+    // update shipping value and dutiesTaxFees on selectedShippingOption change
+    cartStore.shipping = selectedLandedCost.subtotals.shipping;
+    // update deminimis status
+    const isGuarantee = ((_b = selectedLandedCost === null || selectedLandedCost === void 0 ? void 0 : selectedLandedCost.landedCost) === null || _b === void 0 ? void 0 : _b.landedCostGuaranteeCode) === 'ZONOS';
+    // one item in deminimis with type of duty and tax has threshold value is "ABOVE"
+    const isAboveDeminimis = !!((_d = (_c = selectedLandedCost === null || selectedLandedCost === void 0 ? void 0 : selectedLandedCost.landedCost) === null || _c === void 0 ? void 0 : _c.deMinimis) === null || _d === void 0 ? void 0 : _d.find(item => ['DUTY', 'TAX'].includes(item.type) && item.threshold === 'ABOVE'));
+    cartStore.isSelectedShippingAboveDeminimis = isAboveDeminimis;
+    cartStore.isSelectedShippingGuarantee = isGuarantee;
+    // update session with selected landed cost
+    const updateCalulateStatus = await cartStoreReCalculateTotal({
+        landedCostId: (_e = selectedLandedCost.landedCost) === null || _e === void 0 ? void 0 : _e.id,
+    });
+    return updateCalulateStatus;
+};
+onChange('checkoutSessionId', () => {
+    if (!cartStore.checkoutSessionId) {
+        sessionStorage.removeItem('zonos--checkout-session-id');
+        return;
+    }
+    sessionStorage.setItem('zonos--checkout-session-id', cartStore.checkoutSessionId);
+});
+const cartStoreUpdateItems = async (items) => {
+    var _a;
+    cartStore.items = items;
+    const currency = (_a = items.find(Boolean)) === null || _a === void 0 ? void 0 : _a.currencyCode;
+    const total = items.reduce((amt, item) => {
+        return amt + item.amount * item.quantity;
+    }, 0);
+    if (!currency || !total) {
+        // do nothing if we can't get currency or total
+        return;
+    }
+    cartStore.currency = currency;
+    // set loading state here because this is first load checkout session when we already have checkout session id stored
+    stripeStore.isFetchingSession = true;
+    await cartStoreReCalculateTotal({
+        currency: currency,
+        itemsAmount: total,
+    });
+    stripeStore.isFetchingSession = false;
+};
+const cartStoreResetSelectedShippingOption = () => {
+    cartStore.selectedShippingOption = null;
+    cartStore.isSelectedShippingAboveDeminimis = false;
+    cartStore.isSelectedShippingGuarantee = false;
+    cartStore.selectedShippingOptionExpectedDate = '';
+    cartStore.selectedShippingOptionTransitTime = '';
+    cartStore.shipping = 0;
+};
+const cartStoreNextStep = () => {
+    if (cartStore.step === 'customer-info') {
+        cartStore.step = 'shipping';
+    }
+    else if (cartStore.step === 'shipping') {
+        cartStore.step = 'payment';
+    }
+    else if (cartStore.step === 'payment') {
+        cartStore.step = 'finish';
+    }
+};
+const cartStorePreviousStep = () => {
+    if (cartStore.step === 'payment') {
+        cartStore.step = 'shipping';
+    }
+    else if (cartStore.step === 'shipping') {
+        cartStore.step = 'customer-info';
+        // reset selected shipping option
+        cartStoreResetSelectedShippingOption();
+    }
+};
+
+exports.cartStore = cartStore;
+exports.cartStoreApplySubtotals = cartStoreApplySubtotals;
+exports.cartStoreGetShippingTransitInfo = cartStoreGetShippingTransitInfo;
+exports.cartStoreNextStep = cartStoreNextStep;
+exports.cartStorePreviousStep = cartStorePreviousStep;
+exports.cartStoreReCalculateTotal = cartStoreReCalculateTotal;
+exports.cartStoreReset = cartStoreReset;
+exports.cartStoreUpdateItems = cartStoreUpdateItems;
+exports.cartStoreUpdateSelectedShippingOption = cartStoreUpdateSelectedShippingOption;
+exports.cartStoreUpdateToErrorState = cartStoreUpdateToErrorState;
+exports.initStripeElements = initStripeElements;
+exports.stripeStore = stripeStore;
+exports.stripeStoreConfirmPayment = stripeStoreConfirmPayment;
+exports.stripeStoreInitCheckoutSession = stripeStoreInitCheckoutSession;
+exports.stripeStorePrefetchLandedCost = stripeStorePrefetchLandedCost;
+exports.stripeStoreReset = stripeStoreReset;
+exports.stripeStoreRetrievePayment = stripeStoreRetrievePayment;

package/dist/cjs/getBorderRadius-bf4a4276.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const zonosStore = require('./zonosStore-b43ef5db.js');
+
+/**
+ * Get the border radius for the elements based on the style
+ * @param overrideBorderStyle
+ * @returns
+ */
+const getBorderRadius = (overrideBorderStyle) => {
+    if (overrideBorderStyle) {
+        // If the override is set, use that, otherwise use the default radius style
+        return overrideBorderStyle === 'SHARP' ? '0px' : '10px';
+    }
+    return zonosStore.zonosStore.appearance.style === 'SHARP' ? '0px' : '10px';
+};
+
+exports.getBorderRadius = getBorderRadius;