@stigg/react-sdk 5.7.0 → 5.9.0

package/dist/react-sdk.esm.js

@@ -31,7 +31,7 @@ import Box from '@mui/material/Box';
 import Tab from '@mui/material/Tab';
 import isEmpty from 'lodash-es/isEmpty';
 import Tabs from '@mui/material/Tabs';
-import { ArrowDown, ExternalLink, Minus, Plus } from 'react-feather';
+import { ArrowDown, ExternalLink, Minus, Plus, ChevronRight } from 'react-feather';
 import Link from '@mui/material/Link';
 import Tooltip, { tooltipClasses } from '@mui/material/Tooltip';
 import LinearProgress, { linearProgressClasses } from '@mui/material/LinearProgress';
@@ -50,8 +50,9 @@ import CircularProgress from '@mui/material/CircularProgress';
 import Paper from '@mui/material/Paper';
 import { loadStripe } from '@stripe/stripe-js';
 import Lottie from 'lottie-react';
-import Alert from '@mui/material/Alert';
+import { IconButton } from '@mui/material';
 import Collapse from '@mui/material/Collapse';
+import Alert from '@mui/material/Alert';
 import Radio from '@mui/material/Radio';
 import Chip from '@mui/material/Chip';
 
@@ -600,7 +601,8 @@ var getResolvedTheme = function getResolvedTheme(customizedTheme) {
       text: {
         primary: textColor.hex(),
         secondary: textColor.alpha(0.75).toString(),
-        disabled: textColor.alpha(0.5).toString()
+        tertiary: textColor.alpha(0.5).toString(),
+        disabled: textColor.alpha(0.35).toString()
       }
     },
     layout: {
@@ -843,6 +845,16 @@ function hasTierWithUnitPrice(tiers) {
     return unitPrice && !isNil(upTo);
   });
 }
+function isBulkTiers(tiers) {
+  return tiers == null ? void 0 : tiers.every(function (_ref3) {
+    var unitPrice = _ref3.unitPrice,
+        upTo = _ref3.upTo;
+    return !unitPrice || isNil(upTo);
+  });
+}
+function isQuantityInFirstTier(tiers, quantity) {
+  return (tiers == null ? void 0 : tiers[0].upTo) && quantity <= tiers[0].upTo;
+}
 function getTiersPerUnitQuantities(plan, billingPeriod, currentSubscription, selectDefaultTierIndex) {
   var planTierPrices = plan.pricePoints.filter(function (price) {
     return price.billingPeriod === billingPeriod && price.isTieredPrice;
@@ -12529,19 +12541,157 @@ function CheckoutCaptions(props) {
   return React__default.createElement(React__default.Fragment, null, React__default.createElement(RemainingCreditsCaption, Object.assign({}, props)), React__default.createElement(ScheduledUpdatesCaption, Object.assign({}, props)), React__default.createElement(NextBillingCaption, Object.assign({}, props)));
 }
 
+function numberFormatter(number, _temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      locate = _ref.locate;
+
+  return new Intl.NumberFormat(locate).format(number);
+}
+
+function formatPricePerUnit(_ref) {
+  var quantity = _ref.quantity,
+      totalAmount = _ref.totalAmount,
+      pricingModel = _ref.pricingModel,
+      billingPeriod = _ref.billingPeriod,
+      currency = _ref.currency;
+  var isPerUnit = pricingModel === BillingModel.PerUnit;
+  var featureUnits = quantity && (isPerUnit || quantity > 1) ? numberFormatter(quantity) + " x " : '';
+  var billingPeriodString = billingPeriod === BillingPeriod.Annually ? ' x 12 months' : '';
+  var unitPrice = totalAmount / quantity / (billingPeriod === BillingPeriod.Annually ? 12 : 1);
+  var formattedUnitPrice = currencyPriceFormatter({
+    amount: unitPrice,
+    currency: currency,
+    minimumFractionDigits: 2
+  });
+  var formattedTotalPrice = currencyPriceFormatter({
+    amount: totalAmount,
+    currency: currency,
+    minimumFractionDigits: 2
+  });
+  return "" + featureUnits + formattedUnitPrice + billingPeriodString + " " + (billingPeriodString || featureUnits ? " =  " + formattedTotalPrice : '');
+}
+function getPriceBreakdownString(params) {
+  var totalAmount = params.totalAmount,
+      quantity = params.quantity,
+      tiersMode = params.tiersMode,
+      tiers = params.tiers,
+      currency = params.currency;
+
+  if (isBulkTiers(tiers) || tiersMode === TiersMode.Graduated && !isQuantityInFirstTier(tiers, quantity)) {
+    var formattedTotalPrice = currencyPriceFormatter({
+      amount: totalAmount,
+      currency: currency,
+      minimumFractionDigits: 2
+    });
+    return numberFormatter(quantity) + " for " + formattedTotalPrice;
+  }
+
+  return formatPricePerUnit(params);
+}
+
+function getLabel(tiers, index) {
+  var _tiers$index = tiers[index],
+      unitPrice = _tiers$index.unitPrice,
+      upTo = _tiers$index.upTo;
+
+  if (!unitPrice) {
+    return '';
+  }
+
+  if (index === 0) {
+    return "First " + upTo;
+  }
+
+  var previousTierUpTo = tiers[index - 1].upTo || 0;
+  var startUnit = previousTierUpTo + 1;
+  return isNil(upTo) ? numberFormatter(startUnit) + " and above" : "Next " + numberFormatter(startUnit) + " to " + numberFormatter(upTo);
+}
+
+function GraduatedPriceBreakdown(_ref) {
+  var price = _ref.price,
+      unitQuantity = _ref.unitQuantity;
+  var tiers = price.tiers || [];
+
+  var _calculateTierPriceGr = calculateTierPriceGraduated(tiers, unitQuantity),
+      breakdown = _calculateTierPriceGr.breakdown;
+
+  if (breakdown.length === 1) {
+    return null;
+  }
+
+  return React__default.createElement(React__default.Fragment, null, breakdown.map(function (_ref2, index) {
+    var unitQuantity = _ref2.unitQuantity,
+        amount = _ref2.amount;
+    return React__default.createElement(LineItemContainer, null, React__default.createElement(LineItemRow, {
+      key: index,
+      style: {
+        alignItems: 'flex-start'
+      }
+    }, React__default.createElement(Typography, {
+      variant: "body1",
+      color: "tertiary",
+      style: {
+        whiteSpace: 'nowrap'
+      }
+    }, getLabel(tiers, index)), React__default.createElement(Typography, {
+      variant: "body1",
+      color: "tertiary",
+      style: {
+        whiteSpace: 'nowrap'
+      }
+    }, formatPricePerUnit({
+      quantity: unitQuantity,
+      totalAmount: amount,
+      currency: price.currency,
+      pricingModel: price.pricingModel,
+      billingPeriod: price.billingPeriod,
+      tiers: price.tiers,
+      tiersMode: price.tiersMode
+    }))));
+  }));
+}
+
+var _templateObject$6;
+var CollapsableSectionIcon = /*#__PURE__*/styled$1(ChevronRight)(_templateObject$6 || (_templateObject$6 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  height: ", ";\n  width: ", ";\n  transition: all 0.2s ease-in;\n  ", "\n"])), function (_ref) {
+  var _ref$$size = _ref.$size,
+      $size = _ref$$size === void 0 ? 24 : _ref$$size;
+  return $size + "px";
+}, function (_ref2) {
+  var _ref2$$size = _ref2.$size,
+      $size = _ref2$$size === void 0 ? 24 : _ref2$$size;
+  return $size + "px";
+}, function (_ref3) {
+  var $isOpen = _ref3.$isOpen;
+  return $isOpen && "transform: rotate(90deg)";
+});
+
 function _EMOTION_STRINGIFIED_CSS_ERROR__$o() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
 var LineItemContainer = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1ultpe62"
+} : {
+  target: "e1ultpe62",
+  label: "LineItemContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "x9km8e",
+  styles: "&+&{margin-top:16px;}"
+} : {
+  name: "x9km8e",
+  styles: "&+&{margin-top:16px;}",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["LineItems.tsx"],"names":[],"mappings":"AAmB4C","file":"LineItems.tsx","sourcesContent":["import React, { useState } from 'react';\r\nimport styled from '@emotion/styled/macro';\r\nimport Grid from '@mui/material/Grid';\r\nimport { BillingModel, TiersMode, } from '@stigg/js-client-sdk';\r\nimport isEmpty from 'lodash/isEmpty';\r\nimport isNil from 'lodash/isNil';\r\nimport Link from '@mui/material/Link';\r\nimport { IconButton } from '@mui/material';\r\nimport Collapse from '@mui/material/Collapse';\r\nimport { Typography } from '../../../common/Typography';\r\nimport { currencyPriceFormatter } from '../../../utils/currencyUtils';\r\nimport { WithSkeleton } from './WithSkeleton';\r\nimport { Skeleton } from '../../components/Skeletons.style';\r\nimport { Icon } from '../../../common/Icon';\r\nimport { InformationTooltip } from '../../../common/InformationTooltip';\r\nimport { getPriceBreakdownString } from './getPriceBreakdownString';\r\nimport { GraduatedPriceBreakdown } from './GraduatedPriceBreakdown';\r\nimport { CollapsableSectionIcon } from '../../../common/CollapsableSectionIcon';\r\nimport { calculateTierPrice } from '../../../utils/priceTierUtils';\r\nexport const LineItemContainer = styled.div `\n  & + & {\n    margin-top: 16px;\n  }\n`;\r\nexport const NestedBreakdownContainer = styled.div `\n  margin-top: 16px;\n  margin-left: 16px;\n`;\r\nexport const LineItemRow = styled.div `\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  gap: 16px;\n`;\r\nconst PayAsYouGoPriceTooltip = ({ checkoutLocalization }) => {\r\n    const title = React.createElement(Typography, { variant: \"body1\" }, checkoutLocalization.summary.payAsYouGoTooltipText);\r\n    return (React.createElement(InformationTooltip, { placement: \"left\", title: title },\r\n        React.createElement(Icon, { icon: \"PayAsYouGoCharge\", style: { display: 'flex' } })));\r\n};\r\nexport const BilledPriceLineItem = ({ checkoutLocalization, label, quantity, price, }) => {\r\n    const [isNestedBreakdownOpen, setIsNestedBreakdownOpen] = useState(false);\r\n    const toggleNestedBreakdown = () => setIsNestedBreakdownOpen((prev) => !prev);\r\n    const isPayAsYouGo = price.pricingModel === BillingModel.UsageBased;\r\n    const totalAmount = price.isTieredPrice ? calculateTierPrice(price, quantity) : (price.amount || 0) * quantity;\r\n    let nestedBreakdown;\r\n    const shouldShowGraduatedPriceBreakdown = price.tiersMode === TiersMode.Graduated &&\r\n        !!price.tiers &&\r\n        !isEmpty(price.tiers) &&\r\n        !isNil(price.tiers[0].upTo) &&\r\n        quantity > price.tiers[0].upTo;\r\n    if (shouldShowGraduatedPriceBreakdown) {\r\n        nestedBreakdown = React.createElement(GraduatedPriceBreakdown, { price: price, unitQuantity: quantity });\r\n    }\r\n    let title = (React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label));\r\n    if (nestedBreakdown) {\r\n        title = (React.createElement(Link, { onClick: toggleNestedBreakdown, underline: \"none\", style: { cursor: 'pointer' } }, title));\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-start' } },\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 0.5, style: { whiteSpace: 'nowrap' } },\r\n                title,\r\n                nestedBreakdown && (React.createElement(IconButton, { onClick: toggleNestedBreakdown, sx: { padding: 0 } },\r\n                    React.createElement(CollapsableSectionIcon, { \"$isOpen\": isNestedBreakdownOpen, \"$size\": 16 })))),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                isPayAsYouGo && React.createElement(PayAsYouGoPriceTooltip, { checkoutLocalization: checkoutLocalization }),\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { whiteSpace: 'nowrap' } },\r\n                    getPriceBreakdownString({\r\n                        totalAmount,\r\n                        quantity,\r\n                        currency: price.currency,\r\n                        pricingModel: price.pricingModel,\r\n                        billingPeriod: price.billingPeriod,\r\n                        tiers: price.tiers,\r\n                        tiersMode: price.tiersMode,\r\n                    }),\r\n                    isPayAsYouGo && ' / unit'))),\r\n        nestedBreakdown && (React.createElement(Collapse, { in: isNestedBreakdownOpen },\r\n            React.createElement(NestedBreakdownContainer, null, nestedBreakdown)))));\r\n};\r\nexport const FreeChargeLineItem = ({ label }) => {\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-end' } },\r\n            React.createElement(Grid, { item: true },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label)),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { wordBreak: 'break-word' } }, \"Free\")))));\r\n};\r\nexport const DiscountLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice, recurringInvoice } = subscriptionPreview;\r\n    const { discount, discountDetails } = recurringInvoice || {};\r\n    if (!discount || !discountDetails) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.discountText({\r\n                discountDetails,\r\n                currency: immediateInvoice.total.currency,\r\n            })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, isFetchingSubscriptionPreview ? (React.createElement(Skeleton, { width: 50, height: 16 })) : (currencyPriceFormatter({\r\n                amount: discount.amount,\r\n                currency: discount.currency,\r\n                minimumFractionDigits: 2,\r\n            }))))));\r\n};\r\nexport const AppliedCreditsLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice } = subscriptionPreview || {};\r\n    const { credits } = immediateInvoice || {};\r\n    if (!credits || !credits.used || credits.used.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.appliedCreditsTitle),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({\r\n                    amount: -1 * credits.used.amount,\r\n                    currency: credits.used.currency,\r\n                    minimumFractionDigits: 2,\r\n                }))))));\r\n};\r\nexport const TaxLineItem = ({ tax, taxDetails, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    if (!taxDetails || !tax || tax?.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.taxTitle({ taxDetails })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({ amount: tax?.amount, currency: tax?.currency, minimumFractionDigits: 2 }))))));\r\n};\r\n//# sourceMappingURL=LineItems.js.map"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__$o
+});
+var NestedBreakdownContainer = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
   target: "e1ultpe61"
 } : {
   target: "e1ultpe61",
-  label: "LineItemContainer"
+  label: "NestedBreakdownContainer"
 })(process.env.NODE_ENV === "production" ? {
-  name: "rdmn2i",
-  styles: "&+&{margin-top:8px;}"
+  name: "96yaa5",
+  styles: "margin-top:16px;margin-left:16px"
 } : {
-  name: "rdmn2i",
-  styles: "&+&{margin-top:8px;}",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["LineItems.tsx"],"names":[],"mappings":"AAW4C","file":"LineItems.tsx","sourcesContent":["import React from 'react';\r\nimport styled from '@emotion/styled/macro';\r\nimport Grid from '@mui/material/Grid';\r\nimport { BillingModel, BillingPeriod, } from '@stigg/js-client-sdk';\r\nimport { Typography } from '../../../common/Typography';\r\nimport { currencyPriceFormatter } from '../../../utils/currencyUtils';\r\nimport { calculateTierPrice } from '../../../utils/priceTierUtils';\r\nimport { WithSkeleton } from './WithSkeleton';\r\nimport { Skeleton } from '../../components/Skeletons.style';\r\nimport { Icon } from '../../../common/Icon';\r\nimport { InformationTooltip } from '../../../common/InformationTooltip';\r\nexport const LineItemContainer = styled.div `\n  & + & {\n    margin-top: 8px;\n  }\n`;\r\nexport const LineItemRow = styled.div `\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n`;\r\nexport const getPriceString = ({ amount, price, quantity }) => {\r\n    const { billingPeriod } = price;\r\n    let billingPeriodString = null;\r\n    if (quantity) {\r\n        amount /= quantity;\r\n    }\r\n    if (billingPeriod === BillingPeriod.Annually) {\r\n        amount /= 12;\r\n        billingPeriodString = '12 months';\r\n    }\r\n    const addonPriceFormat = currencyPriceFormatter({ amount, currency: price.currency, minimumFractionDigits: 2 });\r\n    return `${quantity > 1 ? `${quantity} x ${addonPriceFormat} each` : addonPriceFormat}${billingPeriodString ? ` x ${billingPeriodString}` : ''}`;\r\n};\r\nconst PayAsYouGoPriceTooltip = ({ checkoutLocalization }) => {\r\n    const title = React.createElement(Typography, { variant: \"body1\" }, checkoutLocalization.summary.payAsYouGoTooltipText);\r\n    return (React.createElement(InformationTooltip, { placement: \"left\", title: title },\r\n        React.createElement(Icon, { icon: \"PayAsYouGoCharge\", style: { display: 'flex' } })));\r\n};\r\nexport const BilledPriceLineItem = ({ checkoutLocalization, label, quantity, price, }) => {\r\n    const { billingPeriod } = price;\r\n    const isPayAsYouGo = price.pricingModel === BillingModel.UsageBased;\r\n    let amount;\r\n    if (price.isTieredPrice) {\r\n        amount = calculateTierPrice(price, quantity);\r\n    }\r\n    else {\r\n        amount = price.amount * quantity;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-start' } },\r\n            React.createElement(Grid, { item: true },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label),\r\n                (quantity > 1 || billingPeriod === BillingPeriod.Annually) && (React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, getPriceString({ amount, price, quantity })))),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                isPayAsYouGo && React.createElement(PayAsYouGoPriceTooltip, { checkoutLocalization: checkoutLocalization }),\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { wordBreak: 'break-word' } },\r\n                    currencyPriceFormatter({\r\n                        amount,\r\n                        currency: price.currency,\r\n                        minimumFractionDigits: 2,\r\n                    }),\r\n                    isPayAsYouGo && ' / unit')))));\r\n};\r\nexport const FreeChargeLineItem = ({ label }) => {\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-end' } },\r\n            React.createElement(Grid, { item: true },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label)),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { wordBreak: 'break-word' } }, \"Free\")))));\r\n};\r\nexport const DiscountLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice, recurringInvoice } = subscriptionPreview;\r\n    const { discount, discountDetails } = recurringInvoice || {};\r\n    if (!discount || !discountDetails) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.discountText({\r\n                discountDetails,\r\n                currency: immediateInvoice.total.currency,\r\n            })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, isFetchingSubscriptionPreview ? (React.createElement(Skeleton, { width: 50, height: 16 })) : (currencyPriceFormatter({\r\n                amount: discount.amount,\r\n                currency: discount.currency,\r\n                minimumFractionDigits: 2,\r\n            }))))));\r\n};\r\nexport const AppliedCreditsLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice } = subscriptionPreview || {};\r\n    const { credits } = immediateInvoice || {};\r\n    if (!credits || !credits.used || credits.used.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.appliedCreditsTitle),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({\r\n                    amount: -1 * credits.used.amount,\r\n                    currency: credits.used.currency,\r\n                    minimumFractionDigits: 2,\r\n                }))))));\r\n};\r\nexport const TaxLineItem = ({ tax, taxDetails, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    if (!taxDetails || !tax || tax?.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.taxTitle({ taxDetails })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({ amount: tax?.amount, currency: tax?.currency, minimumFractionDigits: 2 }))))));\r\n};\r\n//# sourceMappingURL=LineItems.js.map"]} */",
+  name: "96yaa5",
+  styles: "margin-top:16px;margin-left:16px",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["LineItems.tsx"],"names":[],"mappings":"AAwBmD","file":"LineItems.tsx","sourcesContent":["import React, { useState } from 'react';\r\nimport styled from '@emotion/styled/macro';\r\nimport Grid from '@mui/material/Grid';\r\nimport { BillingModel, TiersMode, } from '@stigg/js-client-sdk';\r\nimport isEmpty from 'lodash/isEmpty';\r\nimport isNil from 'lodash/isNil';\r\nimport Link from '@mui/material/Link';\r\nimport { IconButton } from '@mui/material';\r\nimport Collapse from '@mui/material/Collapse';\r\nimport { Typography } from '../../../common/Typography';\r\nimport { currencyPriceFormatter } from '../../../utils/currencyUtils';\r\nimport { WithSkeleton } from './WithSkeleton';\r\nimport { Skeleton } from '../../components/Skeletons.style';\r\nimport { Icon } from '../../../common/Icon';\r\nimport { InformationTooltip } from '../../../common/InformationTooltip';\r\nimport { getPriceBreakdownString } from './getPriceBreakdownString';\r\nimport { GraduatedPriceBreakdown } from './GraduatedPriceBreakdown';\r\nimport { CollapsableSectionIcon } from '../../../common/CollapsableSectionIcon';\r\nimport { calculateTierPrice } from '../../../utils/priceTierUtils';\r\nexport const LineItemContainer = styled.div `\n  & + & {\n    margin-top: 16px;\n  }\n`;\r\nexport const NestedBreakdownContainer = styled.div `\n  margin-top: 16px;\n  margin-left: 16px;\n`;\r\nexport const LineItemRow = styled.div `\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  gap: 16px;\n`;\r\nconst PayAsYouGoPriceTooltip = ({ checkoutLocalization }) => {\r\n    const title = React.createElement(Typography, { variant: \"body1\" }, checkoutLocalization.summary.payAsYouGoTooltipText);\r\n    return (React.createElement(InformationTooltip, { placement: \"left\", title: title },\r\n        React.createElement(Icon, { icon: \"PayAsYouGoCharge\", style: { display: 'flex' } })));\r\n};\r\nexport const BilledPriceLineItem = ({ checkoutLocalization, label, quantity, price, }) => {\r\n    const [isNestedBreakdownOpen, setIsNestedBreakdownOpen] = useState(false);\r\n    const toggleNestedBreakdown = () => setIsNestedBreakdownOpen((prev) => !prev);\r\n    const isPayAsYouGo = price.pricingModel === BillingModel.UsageBased;\r\n    const totalAmount = price.isTieredPrice ? calculateTierPrice(price, quantity) : (price.amount || 0) * quantity;\r\n    let nestedBreakdown;\r\n    const shouldShowGraduatedPriceBreakdown = price.tiersMode === TiersMode.Graduated &&\r\n        !!price.tiers &&\r\n        !isEmpty(price.tiers) &&\r\n        !isNil(price.tiers[0].upTo) &&\r\n        quantity > price.tiers[0].upTo;\r\n    if (shouldShowGraduatedPriceBreakdown) {\r\n        nestedBreakdown = React.createElement(GraduatedPriceBreakdown, { price: price, unitQuantity: quantity });\r\n    }\r\n    let title = (React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label));\r\n    if (nestedBreakdown) {\r\n        title = (React.createElement(Link, { onClick: toggleNestedBreakdown, underline: \"none\", style: { cursor: 'pointer' } }, title));\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-start' } },\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 0.5, style: { whiteSpace: 'nowrap' } },\r\n                title,\r\n                nestedBreakdown && (React.createElement(IconButton, { onClick: toggleNestedBreakdown, sx: { padding: 0 } },\r\n                    React.createElement(CollapsableSectionIcon, { \"$isOpen\": isNestedBreakdownOpen, \"$size\": 16 })))),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                isPayAsYouGo && React.createElement(PayAsYouGoPriceTooltip, { checkoutLocalization: checkoutLocalization }),\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { whiteSpace: 'nowrap' } },\r\n                    getPriceBreakdownString({\r\n                        totalAmount,\r\n                        quantity,\r\n                        currency: price.currency,\r\n                        pricingModel: price.pricingModel,\r\n                        billingPeriod: price.billingPeriod,\r\n                        tiers: price.tiers,\r\n                        tiersMode: price.tiersMode,\r\n                    }),\r\n                    isPayAsYouGo && ' / unit'))),\r\n        nestedBreakdown && (React.createElement(Collapse, { in: isNestedBreakdownOpen },\r\n            React.createElement(NestedBreakdownContainer, null, nestedBreakdown)))));\r\n};\r\nexport const FreeChargeLineItem = ({ label }) => {\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-end' } },\r\n            React.createElement(Grid, { item: true },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label)),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { wordBreak: 'break-word' } }, \"Free\")))));\r\n};\r\nexport const DiscountLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice, recurringInvoice } = subscriptionPreview;\r\n    const { discount, discountDetails } = recurringInvoice || {};\r\n    if (!discount || !discountDetails) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.discountText({\r\n                discountDetails,\r\n                currency: immediateInvoice.total.currency,\r\n            })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, isFetchingSubscriptionPreview ? (React.createElement(Skeleton, { width: 50, height: 16 })) : (currencyPriceFormatter({\r\n                amount: discount.amount,\r\n                currency: discount.currency,\r\n                minimumFractionDigits: 2,\r\n            }))))));\r\n};\r\nexport const AppliedCreditsLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice } = subscriptionPreview || {};\r\n    const { credits } = immediateInvoice || {};\r\n    if (!credits || !credits.used || credits.used.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.appliedCreditsTitle),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({\r\n                    amount: -1 * credits.used.amount,\r\n                    currency: credits.used.currency,\r\n                    minimumFractionDigits: 2,\r\n                }))))));\r\n};\r\nexport const TaxLineItem = ({ tax, taxDetails, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    if (!taxDetails || !tax || tax?.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.taxTitle({ taxDetails })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({ amount: tax?.amount, currency: tax?.currency, minimumFractionDigits: 2 }))))));\r\n};\r\n//# sourceMappingURL=LineItems.js.map"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$o
 });
 var LineItemRow = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
@@ -12550,40 +12700,17 @@ var LineItemRow = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "producti
   target: "e1ultpe60",
   label: "LineItemRow"
 })(process.env.NODE_ENV === "production" ? {
-  name: "bcffy2",
-  styles: "display:flex;align-items:center;justify-content:space-between"
+  name: "153q11y",
+  styles: "display:flex;align-items:center;justify-content:space-between;gap:16px"
 } : {
-  name: "bcffy2",
-  styles: "display:flex;align-items:center;justify-content:space-between",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["LineItems.tsx"],"names":[],"mappings":"AAgBsC","file":"LineItems.tsx","sourcesContent":["import React from 'react';\r\nimport styled from '@emotion/styled/macro';\r\nimport Grid from '@mui/material/Grid';\r\nimport { BillingModel, BillingPeriod, } from '@stigg/js-client-sdk';\r\nimport { Typography } from '../../../common/Typography';\r\nimport { currencyPriceFormatter } from '../../../utils/currencyUtils';\r\nimport { calculateTierPrice } from '../../../utils/priceTierUtils';\r\nimport { WithSkeleton } from './WithSkeleton';\r\nimport { Skeleton } from '../../components/Skeletons.style';\r\nimport { Icon } from '../../../common/Icon';\r\nimport { InformationTooltip } from '../../../common/InformationTooltip';\r\nexport const LineItemContainer = styled.div `\n  & + & {\n    margin-top: 8px;\n  }\n`;\r\nexport const LineItemRow = styled.div `\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n`;\r\nexport const getPriceString = ({ amount, price, quantity }) => {\r\n    const { billingPeriod } = price;\r\n    let billingPeriodString = null;\r\n    if (quantity) {\r\n        amount /= quantity;\r\n    }\r\n    if (billingPeriod === BillingPeriod.Annually) {\r\n        amount /= 12;\r\n        billingPeriodString = '12 months';\r\n    }\r\n    const addonPriceFormat = currencyPriceFormatter({ amount, currency: price.currency, minimumFractionDigits: 2 });\r\n    return `${quantity > 1 ? `${quantity} x ${addonPriceFormat} each` : addonPriceFormat}${billingPeriodString ? ` x ${billingPeriodString}` : ''}`;\r\n};\r\nconst PayAsYouGoPriceTooltip = ({ checkoutLocalization }) => {\r\n    const title = React.createElement(Typography, { variant: \"body1\" }, checkoutLocalization.summary.payAsYouGoTooltipText);\r\n    return (React.createElement(InformationTooltip, { placement: \"left\", title: title },\r\n        React.createElement(Icon, { icon: \"PayAsYouGoCharge\", style: { display: 'flex' } })));\r\n};\r\nexport const BilledPriceLineItem = ({ checkoutLocalization, label, quantity, price, }) => {\r\n    const { billingPeriod } = price;\r\n    const isPayAsYouGo = price.pricingModel === BillingModel.UsageBased;\r\n    let amount;\r\n    if (price.isTieredPrice) {\r\n        amount = calculateTierPrice(price, quantity);\r\n    }\r\n    else {\r\n        amount = price.amount * quantity;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-start' } },\r\n            React.createElement(Grid, { item: true },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label),\r\n                (quantity > 1 || billingPeriod === BillingPeriod.Annually) && (React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, getPriceString({ amount, price, quantity })))),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                isPayAsYouGo && React.createElement(PayAsYouGoPriceTooltip, { checkoutLocalization: checkoutLocalization }),\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { wordBreak: 'break-word' } },\r\n                    currencyPriceFormatter({\r\n                        amount,\r\n                        currency: price.currency,\r\n                        minimumFractionDigits: 2,\r\n                    }),\r\n                    isPayAsYouGo && ' / unit')))));\r\n};\r\nexport const FreeChargeLineItem = ({ label }) => {\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-end' } },\r\n            React.createElement(Grid, { item: true },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label)),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { wordBreak: 'break-word' } }, \"Free\")))));\r\n};\r\nexport const DiscountLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice, recurringInvoice } = subscriptionPreview;\r\n    const { discount, discountDetails } = recurringInvoice || {};\r\n    if (!discount || !discountDetails) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.discountText({\r\n                discountDetails,\r\n                currency: immediateInvoice.total.currency,\r\n            })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, isFetchingSubscriptionPreview ? (React.createElement(Skeleton, { width: 50, height: 16 })) : (currencyPriceFormatter({\r\n                amount: discount.amount,\r\n                currency: discount.currency,\r\n                minimumFractionDigits: 2,\r\n            }))))));\r\n};\r\nexport const AppliedCreditsLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice } = subscriptionPreview || {};\r\n    const { credits } = immediateInvoice || {};\r\n    if (!credits || !credits.used || credits.used.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.appliedCreditsTitle),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({\r\n                    amount: -1 * credits.used.amount,\r\n                    currency: credits.used.currency,\r\n                    minimumFractionDigits: 2,\r\n                }))))));\r\n};\r\nexport const TaxLineItem = ({ tax, taxDetails, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    if (!taxDetails || !tax || tax?.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.taxTitle({ taxDetails })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({ amount: tax?.amount, currency: tax?.currency, minimumFractionDigits: 2 }))))));\r\n};\r\n//# sourceMappingURL=LineItems.js.map"]} */",
+  name: "153q11y",
+  styles: "display:flex;align-items:center;justify-content:space-between;gap:16px",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["LineItems.tsx"],"names":[],"mappings":"AA4BsC","file":"LineItems.tsx","sourcesContent":["import React, { useState } from 'react';\r\nimport styled from '@emotion/styled/macro';\r\nimport Grid from '@mui/material/Grid';\r\nimport { BillingModel, TiersMode, } from '@stigg/js-client-sdk';\r\nimport isEmpty from 'lodash/isEmpty';\r\nimport isNil from 'lodash/isNil';\r\nimport Link from '@mui/material/Link';\r\nimport { IconButton } from '@mui/material';\r\nimport Collapse from '@mui/material/Collapse';\r\nimport { Typography } from '../../../common/Typography';\r\nimport { currencyPriceFormatter } from '../../../utils/currencyUtils';\r\nimport { WithSkeleton } from './WithSkeleton';\r\nimport { Skeleton } from '../../components/Skeletons.style';\r\nimport { Icon } from '../../../common/Icon';\r\nimport { InformationTooltip } from '../../../common/InformationTooltip';\r\nimport { getPriceBreakdownString } from './getPriceBreakdownString';\r\nimport { GraduatedPriceBreakdown } from './GraduatedPriceBreakdown';\r\nimport { CollapsableSectionIcon } from '../../../common/CollapsableSectionIcon';\r\nimport { calculateTierPrice } from '../../../utils/priceTierUtils';\r\nexport const LineItemContainer = styled.div `\n  & + & {\n    margin-top: 16px;\n  }\n`;\r\nexport const NestedBreakdownContainer = styled.div `\n  margin-top: 16px;\n  margin-left: 16px;\n`;\r\nexport const LineItemRow = styled.div `\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  gap: 16px;\n`;\r\nconst PayAsYouGoPriceTooltip = ({ checkoutLocalization }) => {\r\n    const title = React.createElement(Typography, { variant: \"body1\" }, checkoutLocalization.summary.payAsYouGoTooltipText);\r\n    return (React.createElement(InformationTooltip, { placement: \"left\", title: title },\r\n        React.createElement(Icon, { icon: \"PayAsYouGoCharge\", style: { display: 'flex' } })));\r\n};\r\nexport const BilledPriceLineItem = ({ checkoutLocalization, label, quantity, price, }) => {\r\n    const [isNestedBreakdownOpen, setIsNestedBreakdownOpen] = useState(false);\r\n    const toggleNestedBreakdown = () => setIsNestedBreakdownOpen((prev) => !prev);\r\n    const isPayAsYouGo = price.pricingModel === BillingModel.UsageBased;\r\n    const totalAmount = price.isTieredPrice ? calculateTierPrice(price, quantity) : (price.amount || 0) * quantity;\r\n    let nestedBreakdown;\r\n    const shouldShowGraduatedPriceBreakdown = price.tiersMode === TiersMode.Graduated &&\r\n        !!price.tiers &&\r\n        !isEmpty(price.tiers) &&\r\n        !isNil(price.tiers[0].upTo) &&\r\n        quantity > price.tiers[0].upTo;\r\n    if (shouldShowGraduatedPriceBreakdown) {\r\n        nestedBreakdown = React.createElement(GraduatedPriceBreakdown, { price: price, unitQuantity: quantity });\r\n    }\r\n    let title = (React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label));\r\n    if (nestedBreakdown) {\r\n        title = (React.createElement(Link, { onClick: toggleNestedBreakdown, underline: \"none\", style: { cursor: 'pointer' } }, title));\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-start' } },\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 0.5, style: { whiteSpace: 'nowrap' } },\r\n                title,\r\n                nestedBreakdown && (React.createElement(IconButton, { onClick: toggleNestedBreakdown, sx: { padding: 0 } },\r\n                    React.createElement(CollapsableSectionIcon, { \"$isOpen\": isNestedBreakdownOpen, \"$size\": 16 })))),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                isPayAsYouGo && React.createElement(PayAsYouGoPriceTooltip, { checkoutLocalization: checkoutLocalization }),\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { whiteSpace: 'nowrap' } },\r\n                    getPriceBreakdownString({\r\n                        totalAmount,\r\n                        quantity,\r\n                        currency: price.currency,\r\n                        pricingModel: price.pricingModel,\r\n                        billingPeriod: price.billingPeriod,\r\n                        tiers: price.tiers,\r\n                        tiersMode: price.tiersMode,\r\n                    }),\r\n                    isPayAsYouGo && ' / unit'))),\r\n        nestedBreakdown && (React.createElement(Collapse, { in: isNestedBreakdownOpen },\r\n            React.createElement(NestedBreakdownContainer, null, nestedBreakdown)))));\r\n};\r\nexport const FreeChargeLineItem = ({ label }) => {\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, { style: { alignItems: 'flex-end' } },\r\n            React.createElement(Grid, { item: true },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, label)),\r\n            React.createElement(Grid, { item: true, display: \"flex\", gap: 1, alignItems: \"center\" },\r\n                React.createElement(Typography, { variant: \"body1\", color: \"secondary\", style: { wordBreak: 'break-word' } }, \"Free\")))));\r\n};\r\nexport const DiscountLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice, recurringInvoice } = subscriptionPreview;\r\n    const { discount, discountDetails } = recurringInvoice || {};\r\n    if (!discount || !discountDetails) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.discountText({\r\n                discountDetails,\r\n                currency: immediateInvoice.total.currency,\r\n            })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, isFetchingSubscriptionPreview ? (React.createElement(Skeleton, { width: 50, height: 16 })) : (currencyPriceFormatter({\r\n                amount: discount.amount,\r\n                currency: discount.currency,\r\n                minimumFractionDigits: 2,\r\n            }))))));\r\n};\r\nexport const AppliedCreditsLineItem = ({ subscriptionPreview, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    const { immediateInvoice } = subscriptionPreview || {};\r\n    const { credits } = immediateInvoice || {};\r\n    if (!credits || !credits.used || credits.used.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.appliedCreditsTitle),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({\r\n                    amount: -1 * credits.used.amount,\r\n                    currency: credits.used.currency,\r\n                    minimumFractionDigits: 2,\r\n                }))))));\r\n};\r\nexport const TaxLineItem = ({ tax, taxDetails, isFetchingSubscriptionPreview, checkoutLocalization, }) => {\r\n    if (!taxDetails || !tax || tax?.amount <= 0) {\r\n        return null;\r\n    }\r\n    return (React.createElement(LineItemContainer, null,\r\n        React.createElement(LineItemRow, null,\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" }, checkoutLocalization.summary.taxTitle({ taxDetails })),\r\n            React.createElement(Typography, { variant: \"body1\", color: \"secondary\" },\r\n                React.createElement(WithSkeleton, { isLoading: isFetchingSubscriptionPreview }, currencyPriceFormatter({ amount: tax?.amount, currency: tax?.currency, minimumFractionDigits: 2 }))))));\r\n};\r\n//# sourceMappingURL=LineItems.js.map"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$o
 });
-var getPriceString = function getPriceString(_ref) {
-  var amount = _ref.amount,
-      price = _ref.price,
-      quantity = _ref.quantity;
-  var billingPeriod = price.billingPeriod;
-  var billingPeriodString = null;
-
-  if (quantity) {
-    amount /= quantity;
-  }
-
-  if (billingPeriod === BillingPeriod.Annually) {
-    amount /= 12;
-    billingPeriodString = '12 months';
-  }
-
-  var addonPriceFormat = currencyPriceFormatter({
-    amount: amount,
-    currency: price.currency,
-    minimumFractionDigits: 2
-  });
-  return "" + (quantity > 1 ? quantity + " x " + addonPriceFormat + " each" : addonPriceFormat) + (billingPeriodString ? " x " + billingPeriodString : '');
-};
 
-var PayAsYouGoPriceTooltip = function PayAsYouGoPriceTooltip(_ref2) {
-  var checkoutLocalization = _ref2.checkoutLocalization;
+var PayAsYouGoPriceTooltip = function PayAsYouGoPriceTooltip(_ref) {
+  var checkoutLocalization = _ref.checkoutLocalization;
   var title = React__default.createElement(Typography, {
     variant: "body1"
   }, checkoutLocalization.summary.payAsYouGoTooltipText);
@@ -12598,19 +12725,47 @@ var PayAsYouGoPriceTooltip = function PayAsYouGoPriceTooltip(_ref2) {
   }));
 };
 
-var BilledPriceLineItem = function BilledPriceLineItem(_ref3) {
-  var checkoutLocalization = _ref3.checkoutLocalization,
-      label = _ref3.label,
-      quantity = _ref3.quantity,
-      price = _ref3.price;
-  var billingPeriod = price.billingPeriod;
+var BilledPriceLineItem = function BilledPriceLineItem(_ref2) {
+  var checkoutLocalization = _ref2.checkoutLocalization,
+      label = _ref2.label,
+      quantity = _ref2.quantity,
+      price = _ref2.price;
+
+  var _useState = useState(false),
+      isNestedBreakdownOpen = _useState[0],
+      setIsNestedBreakdownOpen = _useState[1];
+
+  var toggleNestedBreakdown = function toggleNestedBreakdown() {
+    return setIsNestedBreakdownOpen(function (prev) {
+      return !prev;
+    });
+  };
+
   var isPayAsYouGo = price.pricingModel === BillingModel.UsageBased;
-  var amount;
+  var totalAmount = price.isTieredPrice ? calculateTierPrice(price, quantity) : (price.amount || 0) * quantity;
+  var nestedBreakdown;
+  var shouldShowGraduatedPriceBreakdown = price.tiersMode === TiersMode.Graduated && !!price.tiers && !isEmpty(price.tiers) && !isNil(price.tiers[0].upTo) && quantity > price.tiers[0].upTo;
+
+  if (shouldShowGraduatedPriceBreakdown) {
+    nestedBreakdown = React__default.createElement(GraduatedPriceBreakdown, {
+      price: price,
+      unitQuantity: quantity
+    });
+  }
 
-  if (price.isTieredPrice) {
-    amount = calculateTierPrice(price, quantity);
-  } else {
-    amount = price.amount * quantity;
+  var title = React__default.createElement(Typography, {
+    variant: "body1",
+    color: "secondary"
+  }, label);
+
+  if (nestedBreakdown) {
+    title = React__default.createElement(Link, {
+      onClick: toggleNestedBreakdown,
+      underline: "none",
+      style: {
+        cursor: 'pointer'
+      }
+    }, title);
   }
 
   return React__default.createElement(LineItemContainer, null, React__default.createElement(LineItemRow, {
@@ -12618,17 +12773,20 @@ var BilledPriceLineItem = function BilledPriceLineItem(_ref3) {
       alignItems: 'flex-start'
     }
   }, React__default.createElement(Grid, {
-    item: true
-  }, React__default.createElement(Typography, {
-    variant: "body1",
-    color: "secondary"
-  }, label), (quantity > 1 || billingPeriod === BillingPeriod.Annually) && React__default.createElement(Typography, {
-    variant: "body1",
-    color: "secondary"
-  }, getPriceString({
-    amount: amount,
-    price: price,
-    quantity: quantity
+    item: true,
+    display: "flex",
+    gap: 0.5,
+    style: {
+      whiteSpace: 'nowrap'
+    }
+  }, title, nestedBreakdown && React__default.createElement(IconButton, {
+    onClick: toggleNestedBreakdown,
+    sx: {
+      padding: 0
+    }
+  }, React__default.createElement(CollapsableSectionIcon, {
+    "$isOpen": isNestedBreakdownOpen,
+    "$size": 16
   }))), React__default.createElement(Grid, {
     item: true,
     display: "flex",
@@ -12640,16 +12798,22 @@ var BilledPriceLineItem = function BilledPriceLineItem(_ref3) {
     variant: "body1",
     color: "secondary",
     style: {
-      wordBreak: 'break-word'
+      whiteSpace: 'nowrap'
     }
-  }, currencyPriceFormatter({
-    amount: amount,
+  }, getPriceBreakdownString({
+    totalAmount: totalAmount,
+    quantity: quantity,
     currency: price.currency,
-    minimumFractionDigits: 2
-  }), isPayAsYouGo && ' / unit'))));
+    pricingModel: price.pricingModel,
+    billingPeriod: price.billingPeriod,
+    tiers: price.tiers,
+    tiersMode: price.tiersMode
+  }), isPayAsYouGo && ' / unit'))), nestedBreakdown && React__default.createElement(Collapse, {
+    "in": isNestedBreakdownOpen
+  }, React__default.createElement(NestedBreakdownContainer, null, nestedBreakdown)));
 };
-var FreeChargeLineItem = function FreeChargeLineItem(_ref4) {
-  var label = _ref4.label;
+var FreeChargeLineItem = function FreeChargeLineItem(_ref3) {
+  var label = _ref3.label;
   return React__default.createElement(LineItemContainer, null, React__default.createElement(LineItemRow, {
     style: {
       alignItems: 'flex-end'
@@ -12672,16 +12836,16 @@ var FreeChargeLineItem = function FreeChargeLineItem(_ref4) {
     }
   }, "Free"))));
 };
-var DiscountLineItem = function DiscountLineItem(_ref5) {
-  var subscriptionPreview = _ref5.subscriptionPreview,
-      isFetchingSubscriptionPreview = _ref5.isFetchingSubscriptionPreview,
-      checkoutLocalization = _ref5.checkoutLocalization;
+var DiscountLineItem = function DiscountLineItem(_ref4) {
+  var subscriptionPreview = _ref4.subscriptionPreview,
+      isFetchingSubscriptionPreview = _ref4.isFetchingSubscriptionPreview,
+      checkoutLocalization = _ref4.checkoutLocalization;
   var immediateInvoice = subscriptionPreview.immediateInvoice,
       recurringInvoice = subscriptionPreview.recurringInvoice;
 
-  var _ref6 = recurringInvoice || {},
-      discount = _ref6.discount,
-      discountDetails = _ref6.discountDetails;
+  var _ref5 = recurringInvoice || {},
+      discount = _ref5.discount,
+      discountDetails = _ref5.discountDetails;
 
   if (!discount || !discountDetails) {
     return null;
@@ -12705,16 +12869,16 @@ var DiscountLineItem = function DiscountLineItem(_ref5) {
     minimumFractionDigits: 2
   }))));
 };
-var AppliedCreditsLineItem = function AppliedCreditsLineItem(_ref7) {
-  var subscriptionPreview = _ref7.subscriptionPreview,
-      isFetchingSubscriptionPreview = _ref7.isFetchingSubscriptionPreview,
-      checkoutLocalization = _ref7.checkoutLocalization;
+var AppliedCreditsLineItem = function AppliedCreditsLineItem(_ref6) {
+  var subscriptionPreview = _ref6.subscriptionPreview,
+      isFetchingSubscriptionPreview = _ref6.isFetchingSubscriptionPreview,
+      checkoutLocalization = _ref6.checkoutLocalization;
 
-  var _ref8 = subscriptionPreview || {},
-      immediateInvoice = _ref8.immediateInvoice;
+  var _ref7 = subscriptionPreview || {},
+      immediateInvoice = _ref7.immediateInvoice;
 
-  var _ref9 = immediateInvoice || {},
-      credits = _ref9.credits;
+  var _ref8 = immediateInvoice || {},
+      credits = _ref8.credits;
 
   if (!credits || !credits.used || credits.used.amount <= 0) {
     return null;
@@ -12734,11 +12898,11 @@ var AppliedCreditsLineItem = function AppliedCreditsLineItem(_ref7) {
     minimumFractionDigits: 2
   })))));
 };
-var TaxLineItem = function TaxLineItem(_ref10) {
-  var tax = _ref10.tax,
-      taxDetails = _ref10.taxDetails,
-      isFetchingSubscriptionPreview = _ref10.isFetchingSubscriptionPreview,
-      checkoutLocalization = _ref10.checkoutLocalization;
+var TaxLineItem = function TaxLineItem(_ref9) {
+  var tax = _ref9.tax,
+      taxDetails = _ref9.taxDetails,
+      isFetchingSubscriptionPreview = _ref9.isFetchingSubscriptionPreview,
+      checkoutLocalization = _ref9.checkoutLocalization;
 
   if (!taxDetails || !tax || (tax == null ? void 0 : tax.amount) <= 0) {
     return null;
@@ -13536,12 +13700,12 @@ function CheckoutAddonsStep() {
   }));
 }
 
-var _templateObject$6, _templateObject2$2, _templateObject3$2, _templateObject4;
+var _templateObject$7, _templateObject2$2, _templateObject3$2, _templateObject4;
 var PaymentMethodContainer = /*#__PURE__*/styled(Grid, {
   shouldForwardProp: function shouldForwardProp(prop) {
     return !prop.startsWith('$');
   }
-})(_templateObject$6 || (_templateObject$6 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  padding: 8px;\n  border-radius: 10px;\n  border: 1px solid ", ";\n  cursor: ", ";\n  opacity: ", ";\n"])), function (_ref) {
+})(_templateObject$7 || (_templateObject$7 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  padding: 8px;\n  border-radius: 10px;\n  border: 1px solid ", ";\n  cursor: ", ";\n  opacity: ", ";\n"])), function (_ref) {
   var theme = _ref.theme;
   return theme.stigg.palette.outlinedBorder;
 }, function (_ref2) {
@@ -13633,8 +13797,8 @@ function NewPaymentMethod(_ref3) {
   })));
 }
 
-var _templateObject$7;
-var PaymentContainer = /*#__PURE__*/styled(Grid)(_templateObject$7 || (_templateObject$7 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: column;\n  gap: 24px;\n"])));
+var _templateObject$8;
+var PaymentContainer = /*#__PURE__*/styled(Grid)(_templateObject$8 || (_templateObject$8 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: column;\n  gap: 24px;\n"])));
 function PaymentStep(_ref) {
   var onBillingAddressChange = _ref.onBillingAddressChange,
       collectPhoneNumber = _ref.collectPhoneNumber;
@@ -13929,8 +14093,8 @@ function BillingPeriodPicker$1(_ref2) {
   })));
 }
 
-var _templateObject$8;
-var StyledPlanCharge = /*#__PURE__*/styled.div(_templateObject$8 || (_templateObject$8 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  align-items: center;\n  min-height: 60px;\n  margin-top: 16px;\n"])));
+var _templateObject$9;
+var StyledPlanCharge = /*#__PURE__*/styled.div(_templateObject$9 || (_templateObject$9 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  align-items: center;\n  min-height: 60px;\n  margin-top: 16px;\n"])));
 
 var getValidationText = function getValidationText(charge, quantity) {
   var minUnitQuantity = charge.minUnitQuantity,