@zonos/elements 1.0.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+# Zonos Component UI for Stripe elements
+
+## Project build architecture:
+  - `/src/components` (**Will be bundled with Stencil**): stencil web component, separate folder into 4 types:
+    - `main`: component that will receive custom configuration from users, do all of the script and css injection into consumer page and also control how other components will show/hide by using stencil `store`.
+    - `checkout`: main components that will handle zonos checkout
+    - `hello`: main components that will handle zonos hello (currently holding the component placeholder)
+    - `store`: this is state management amongs all of the components. 
+    - `stripe`: the folder that will hold all of the stripe wrapper web components
+    - `utils`: folders that will hold all of the necessary utilities for all of the components in stencil
+    - `components.d.ts`: generated typed component that will have global types for all web components
+  - `/src/scripts` (**Will be bundled with regular rollup**): scripts that will be bundled into cdn and init global utility function when consumer inject cdn into their page. Consumer then can use to init zonos elements.
+    - `/src/scripts/demo`: base scripts for the demo. `setup.ts` is for how to setup configuration and `customer-site-interaction.ts` is just base interaction for website (add to cart behavior).
+  - `/src/styled`: folder that will hold all of the styling related for all web components
+    - `variables`: scss variables that will be used throughout the web components application (better to just have scss variables and should not have css) 
+    - `css`: folder that will hold all of the global css (this will be generated and inject into `<head>` consumer site)
+- Have environment `t3` setup, but currently it's only being used in `rollup` and `stencil` config for build time checking. It may be will remove this in the future if we don't have any severless api or api using related (right now using just native `process.env`, and have the rollup env plugin to transfer that env into actual value when building.
+- separate tsconfig for each bundling:
+  - `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.

package/dist/cjs/cart-e27fd17c.js

@@ -0,0 +1,607 @@
+'use strict';
+
+const zonosStore = require('./zonosStore-960e5542.js');
+const localization = require('./localization-f6a1b679.js');
+const isDarkColor = require('./isDarkColor-a86b8a05.js');
+const getBorderRadius = require('./getBorderRadius-2904800c.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 => ({
+      amount: item.amount,
+      countryOfOrigin: item.countryOfOrigin,
+      currencyCode: item.currencyCode,
+      imageUrl: item.imageUrl,
+      name: item.name,
+      productId: item.productId,
+      quantity: item.quantity,
+    })),
+    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 calculateLandedCost = async (abortController) => {
+  // request to get landed cost info
+  const url = `${"https://route.js.zonos.com"}/api/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,
+  stripeElements: 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,
+    });
+    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);
+    }
+    else {
+      // update elements with new option if it already exists
+      stripeStore.stripeElements.update(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({
+          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://route.js.zonos.com"}/api/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('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://route.js.zonos.com"}/api/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,
+  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) => {
+  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);
+  }
+  // update checkout session
+  if (!cartStore.checkoutSessionId) {
+    localization.logError('Could 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);
+  }
+  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.cartStoreGetShippingTransitInfo = cartStoreGetShippingTransitInfo;
+exports.cartStoreNextStep = cartStoreNextStep;
+exports.cartStorePreviousStep = cartStorePreviousStep;
+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;
+
+//# sourceMappingURL=cart-e27fd17c.js.map