autumn-js 0.0.67 → 0.0.74

package/dist/libraries/react/chunk-MF3MHICX.mjs

@@ -0,0 +1,983 @@
+"use client";
+
+import {
+  getAttachContent
+} from "./chunk-BCMBFJ7E.mjs";
+import {
+  getPricingTableContent
+} from "./chunk-QBBE72EF.mjs";
+import {
+  Button
+} from "./chunk-P2O4LZFD.mjs";
+import {
+  ArrowRight,
+  Check,
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogTitle,
+  LoaderCircle
+} from "./chunk-5FZ7IV6P.mjs";
+import {
+  Switch
+} from "./chunk-CMO5LYYU.mjs";
+import {
+  cn
+} from "./chunk-4J6OC4ZQ.mjs";
+import {
+  usePricingTable
+} from "./chunk-D3H6GCJ4.mjs";
+import {
+  usePricingTableBase
+} from "./chunk-PFTFPWFN.mjs";
+import {
+  handleAllowed
+} from "./chunk-JFXBUWKA.mjs";
+import {
+  useDialog
+} from "./chunk-4QPHNIQ7.mjs";
+import {
+  AutumnContext,
+  useAutumnContext
+} from "./chunk-6N2SUOJ6.mjs";
+import {
+  AutumnClient
+} from "./chunk-TLRISML2.mjs";
+
+// src/libraries/react/BaseAutumnProvider.tsx
+import { useState as useState3 } from "react";
+
+// src/libraries/react/hooks/useCustomerBase.tsx
+import useSWR2 from "swr";
+
+// src/libraries/react/components/attach-dialog/attach-dialog-synced.tsx
+import { useEffect, useState as useState2 } from "react";
+
+// src/libraries/react/hooks/useCustomer.tsx
+var useCustomer = (params) => {
+  return useCustomerBase({
+    params,
+    AutumnContext
+  });
+};
+
+// src/libraries/react/hooks/useEntityBase.tsx
+import useSWR from "swr";
+import { useContext } from "react";
+var useEntityBase = ({
+  entityId,
+  params,
+  AutumnContext: AutumnContext2
+}) => {
+  const { client } = useContext(AutumnContext2);
+  const queryKey = ["entity", entityId, params?.expand];
+  const fetchEntity = async () => {
+    if (!entityId) {
+      return null;
+    }
+    const { data: data2, error: error2 } = await client.entities.get(entityId, params);
+    if (error2) {
+      throw error2;
+    }
+    if (!data2) {
+      return null;
+    }
+    return data2;
+  };
+  const { data, error, isLoading, mutate } = useSWR(queryKey, fetchEntity, {
+    fallbackData: null,
+    onErrorRetry: (error2, key, config) => {
+      if (error2.code == "entity_not_found") {
+        return false;
+      }
+      return true;
+    }
+  });
+  const {
+    check: checkAutumn,
+    attach: attachAutumn,
+    cancel: cancelAutumn,
+    track: trackAutumn
+  } = useAutumnBase({
+    AutumnContext: AutumnContext2
+  });
+  const allowed = (params2) => handleAllowed({ customer: data, params: params2 });
+  const check = (params2) => checkAutumn({ ...params2, entityId: entityId || void 0 });
+  const attach = (params2) => attachAutumn({ ...params2, entityId: entityId || void 0 });
+  const cancel = (params2) => cancelAutumn({ ...params2, entityId: entityId || void 0 });
+  const track = (params2) => trackAutumn({ ...params2, entityId: entityId || void 0 });
+  if (!entityId) {
+    return {
+      entity: null,
+      isLoading: false,
+      error: null,
+      refetch: mutate,
+      allowed,
+      check,
+      attach,
+      cancel,
+      track
+    };
+  }
+  return {
+    entity: error ? null : data,
+    isLoading,
+    error,
+    refetch: mutate,
+    allowed,
+    check,
+    attach,
+    cancel,
+    track
+  };
+};
+
+// src/libraries/react/hooks/useEntity.tsx
+var useEntity = (entityId, params) => {
+  return useEntityBase({ AutumnContext, entityId, params });
+};
+
+// src/libraries/react/hooks/useAutumn.tsx
+var useAutumn = () => {
+  return useAutumnBase({ AutumnContext });
+};
+
+// src/libraries/react/components/pricing-table/pricing-table-synced.tsx
+import React from "react";
+import { createContext, useContext as useContext2, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function PricingTable({
+  productDetails
+}) {
+  const { attach } = useCustomer();
+  const [isAnnual, setIsAnnual] = useState(false);
+  const { products, isLoading, error } = usePricingTable({ productDetails });
+  if (isLoading) {
+    return /* @__PURE__ */ jsx("div", { className: "au-w-full au-h-full au-flex au-justify-center au-items-center au-min-h-[300px]", children: /* @__PURE__ */ jsx(LoaderCircle, { className: "au-w-6 au-h-6 au-text-zinc-400 au-animate-spin" }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx("div", { children: " Something went wrong..." });
+  }
+  const intervals = Array.from(
+    new Set(
+      products?.map((p) => p.properties?.interval_group).filter((i) => !!i)
+    )
+  );
+  const multiInterval = intervals.length > 1;
+  const intervalFilter = (product) => {
+    if (!product.properties?.interval_group) {
+      return true;
+    }
+    if (multiInterval) {
+      if (isAnnual) {
+        return product.properties?.interval_group === "year";
+      } else {
+        return product.properties?.interval_group === "month";
+      }
+    }
+    return true;
+  };
+  const hasRecommended = products?.some((p) => p.display?.recommend_text);
+  return /* @__PURE__ */ jsx("div", { className: "au-root", children: products && /* @__PURE__ */ jsx(
+    PricingTableContainer,
+    {
+      products,
+      isAnnualToggle: isAnnual,
+      setIsAnnualToggle: setIsAnnual,
+      multiInterval,
+      children: products.filter(intervalFilter).map((product, index) => /* @__PURE__ */ jsx(
+        PricingCard,
+        {
+          productId: product.id,
+          buttonProps: {
+            disabled: product.scenario === "active" || product.scenario === "scheduled",
+            onClick: async () => {
+              if (product.id) {
+                await attach({
+                  productId: product.id,
+                  dialog: AttachDialog
+                });
+              } else if (product.display?.button_url) {
+                window.open(product.display?.button_url, "_blank");
+              }
+            }
+          }
+        },
+        index
+      ))
+    }
+  ) });
+}
+var PricingTableContext = createContext({
+  isAnnualToggle: false,
+  setIsAnnualToggle: () => {
+  },
+  products: [],
+  showFeatures: true
+});
+var usePricingTableContext = (componentName) => {
+  const context = useContext2(PricingTableContext);
+  if (context === void 0) {
+    throw new Error(`${componentName} must be used within <PricingTable />`);
+  }
+  return context;
+};
+var PricingTableContainer = ({
+  children,
+  products,
+  showFeatures = true,
+  className,
+  isAnnualToggle,
+  setIsAnnualToggle,
+  multiInterval
+}) => {
+  if (!products) {
+    throw new Error("products is required in <PricingTable />");
+  }
+  if (products.length === 0) {
+    return /* @__PURE__ */ jsx(Fragment, {});
+  }
+  return /* @__PURE__ */ jsx(
+    PricingTableContext.Provider,
+    {
+      value: { isAnnualToggle, setIsAnnualToggle, products, showFeatures },
+      children: /* @__PURE__ */ jsxs("div", { className: cn("au-flex au-items-center au-flex-col"), children: [
+        multiInterval && /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              products.some((p) => p.display?.recommend_text) && "au-mb-8"
+            ),
+            children: /* @__PURE__ */ jsx(
+              AnnualSwitch,
+              {
+                isAnnualToggle,
+                setIsAnnualToggle
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              "au-grid au-grid-cols-1 sm:au-grid-cols-2 lg:au-grid-cols-[repeat(auto-fit,minmax(200px,1fr))] au-w-full au-gap-2",
+              className
+            ),
+            children
+          }
+        )
+      ] })
+    }
+  );
+};
+var PricingCard = ({
+  productId,
+  className,
+  buttonProps
+}) => {
+  const { products, showFeatures } = usePricingTableContext("PricingCard");
+  const product = products.find((p) => p.id === productId);
+  if (!product) {
+    throw new Error(`Product with id ${productId} not found`);
+  }
+  const { name, display: productDisplay, items } = product;
+  const { buttonText } = getPricingTableContent(product);
+  const isRecommended = productDisplay?.recommend_text ? true : false;
+  const mainPriceDisplay = product.properties?.is_free ? {
+    primary_text: "Free"
+  } : product.items[0].display;
+  const featureItems = product.properties?.is_free ? product.items : product.items.slice(1);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "au-w-full au-h-full au-py-6 au-text-foreground au-border au-rounded-lg au-shadow-sm au-max-w-xl",
+        isRecommended && "lg:au--translate-y-6 lg:au-shadow-lg dark:au-shadow-zinc-800/80 lg:au-h-[calc(100%+48px)] au-bg-secondary/40",
+        className
+      ),
+      children: [
+        productDisplay?.recommend_text && /* @__PURE__ */ jsx(RecommendedBadge, { recommended: productDisplay?.recommend_text }),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: cn(
+              "au-flex au-flex-col au-h-full au-flex-grow",
+              isRecommended && "lg:au-translate-y-6"
+            ),
+            children: [
+              /* @__PURE__ */ jsxs("div", { className: "au-h-full", children: [
+                /* @__PURE__ */ jsxs("div", { className: "au-flex au-flex-col", children: [
+                  /* @__PURE__ */ jsxs("div", { className: "au-pb-4", children: [
+                    /* @__PURE__ */ jsx("h2", { className: "au-text-2xl au-font-semibold au-px-6 au-truncate", children: productDisplay?.name || name }),
+                    productDisplay?.description && /* @__PURE__ */ jsx("div", { className: "au-text-sm au-text-muted-foreground au-px-6 au-h-8", children: /* @__PURE__ */ jsxs("p", { className: "au-line-clamp-2", children: [
+                      "Everything from ",
+                      productDisplay?.description,
+                      ", plus:"
+                    ] }) })
+                  ] }),
+                  /* @__PURE__ */ jsx("div", { className: "au-mb-2", children: /* @__PURE__ */ jsx("h3", { className: "au-font-semibold au-h-16 au-flex au-px-6 au-items-center au-border-y au-mb-4 au-bg-secondary/40", children: /* @__PURE__ */ jsxs("div", { className: "au-line-clamp-2", children: [
+                    mainPriceDisplay?.primary_text,
+                    " ",
+                    mainPriceDisplay?.secondary_text && /* @__PURE__ */ jsx("span", { className: "au-font-normal au-text-muted-foreground au-mt-1", children: mainPriceDisplay?.secondary_text })
+                  ] }) }) })
+                ] }),
+                showFeatures && featureItems.length > 0 && /* @__PURE__ */ jsx("div", { className: "au-flex-grow au-px-6 au-mb-6", children: /* @__PURE__ */ jsx(
+                  PricingFeatureList,
+                  {
+                    items: featureItems,
+                    showIcon: true,
+                    everythingFrom: product.display?.everything_from
+                  }
+                ) })
+              ] }),
+              /* @__PURE__ */ jsx(
+                "div",
+                {
+                  className: cn(" au-px-6 ", isRecommended && "lg:au--translate-y-12"),
+                  children: /* @__PURE__ */ jsx(
+                    PricingCardButton,
+                    {
+                      recommended: productDisplay?.recommend_text ? true : false,
+                      ...buttonProps,
+                      children: buttonText
+                    }
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+var PricingFeatureList = ({
+  items,
+  showIcon = true,
+  everythingFrom,
+  className
+}) => {
+  return /* @__PURE__ */ jsxs("div", { className: cn("au-flex-grow", className), children: [
+    everythingFrom && /* @__PURE__ */ jsxs("p", { className: "au-text-sm au-mb-4", children: [
+      "Everything from ",
+      everythingFrom,
+      ", plus:"
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "au-space-y-3", children: items.map((item, index) => /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "au-flex au-items-start au-gap-2 au-text-sm",
+        children: [
+          showIcon && /* @__PURE__ */ jsx(Check, { className: "au-h-4 au-w-4 au-text-primary au-flex-shrink-0 au-mt-0.5" }),
+          /* @__PURE__ */ jsxs("div", { className: "au-flex au-flex-col", children: [
+            /* @__PURE__ */ jsx("span", { children: item.display?.primary_text }),
+            item.display?.secondary_text && /* @__PURE__ */ jsx("span", { className: "au-text-sm au-text-muted-foreground", children: item.display?.secondary_text })
+          ] })
+        ]
+      },
+      index
+    )) })
+  ] });
+};
+var PricingCardButton = React.forwardRef(({ recommended, children, className, onClick, ...props }, ref) => {
+  const [loading, setLoading] = useState(false);
+  const handleClick = async (e) => {
+    setLoading(true);
+    try {
+      await onClick?.(e);
+    } catch (error) {
+      console.error(error);
+    } finally {
+      setLoading(false);
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      className: cn(
+        "au-w-full au-py-3 au-px-4 au-group au-overflow-hidden au-relative au-transition-all au-duration-300 hover:au-brightness-90 au-border au-rounded-lg",
+        className
+      ),
+      ...props,
+      variant: recommended ? "default" : "secondary",
+      ref,
+      disabled: loading || props.disabled,
+      onClick: handleClick,
+      children: loading ? /* @__PURE__ */ jsx(LoaderCircle, { className: "au-h-4 au-w-4 au-animate-spin" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs("div", { className: "au-flex au-items-center au-justify-between au-w-full au-transition-transform au-duration-300 group-hover:au-translate-y-[-130%]", children: [
+          /* @__PURE__ */ jsx("span", { children }),
+          /* @__PURE__ */ jsx("span", { className: "au-text-sm", children: "\u2192" })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "au-flex au-items-center au-justify-between au-w-full au-absolute au-px-4 au-translate-y-[130%] au-transition-transform au-duration-300 group-hover:au-translate-y-0 au-mt-2 group-hover:au-mt-0", children: [
+          /* @__PURE__ */ jsx("span", { children }),
+          /* @__PURE__ */ jsx("span", { className: "au-text-sm", children: "\u2192" })
+        ] })
+      ] })
+    }
+  );
+});
+PricingCardButton.displayName = "PricingCardButton";
+var AnnualSwitch = ({
+  isAnnualToggle,
+  setIsAnnualToggle
+}) => {
+  return /* @__PURE__ */ jsxs("div", { className: "au-flex au-items-center au-space-x-2 au-mb-4", children: [
+    /* @__PURE__ */ jsx("span", { className: "au-text-sm au-text-muted-foreground", children: "Monthly" }),
+    /* @__PURE__ */ jsx(
+      Switch,
+      {
+        id: "annual-billing",
+        checked: isAnnualToggle,
+        onCheckedChange: setIsAnnualToggle
+      }
+    ),
+    /* @__PURE__ */ jsx("span", { className: "au-text-sm au-text-muted-foreground", children: "Annual" })
+  ] });
+};
+var RecommendedBadge = ({ recommended }) => {
+  return /* @__PURE__ */ jsx("div", { className: "au-bg-secondary au-absolute au-border au-text-muted-foreground au-text-sm au-font-medium lg:au-rounded-full au-px-3 lg:au-py-0.5 lg:au-top-4 lg:au-right-4 au-top-[-1px] au-right-[-1px] au-rounded-bl-lg", children: recommended });
+};
+
+// src/libraries/react/components/attach-dialog/attach-dialog-synced.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function AttachDialog(params) {
+  const { attach } = useCustomer();
+  const [loading, setLoading] = useState2(false);
+  const [optionsInput, setOptionsInput] = useState2(
+    params?.preview?.options || []
+  );
+  const getTotalPrice = () => {
+    let sum = due_today?.price || 0;
+    optionsInput.forEach((option) => {
+      if (option.price && option.quantity) {
+        sum += option.price * (option.quantity / option.billing_units);
+      }
+    });
+    return sum;
+  };
+  useEffect(() => {
+    setOptionsInput(params?.preview?.options || []);
+  }, [params?.preview?.options]);
+  if (!params || !params.preview) {
+    return /* @__PURE__ */ jsx2(Fragment2, {});
+  }
+  const { open, setOpen, preview } = params;
+  const { items, due_today } = preview;
+  const { title, message } = getAttachContent(preview);
+  return /* @__PURE__ */ jsx2(Dialog, { open, onOpenChange: setOpen, children: /* @__PURE__ */ jsxs2(
+    DialogContent,
+    {
+      className: cn(
+        "au-p-0 au-pt-4 au-gap-0 au-text-foreground au-overflow-hidden au-text-sm"
+      ),
+      children: [
+        /* @__PURE__ */ jsx2(DialogTitle, { className: cn("au-px-6 au-mb-1 "), children: title }),
+        /* @__PURE__ */ jsx2("div", { className: cn("au-px-6 au-mt-1 au-mb-4 au-text-muted-foreground"), children: message }),
+        (items || optionsInput.length > 0) && /* @__PURE__ */ jsxs2("div", { className: "au-mb-6 au-px-6", children: [
+          items?.map((item) => /* @__PURE__ */ jsxs2(PriceItem, { children: [
+            /* @__PURE__ */ jsx2("span", { className: "au-truncate au-flex-1", children: item.description }),
+            /* @__PURE__ */ jsx2("span", { children: item.price })
+          ] }, item.description)),
+          optionsInput?.map((option, index) => {
+            return /* @__PURE__ */ jsx2(
+              OptionsInput,
+              {
+                option,
+                optionsInput,
+                setOptionsInput,
+                index
+              },
+              option.feature_name
+            );
+          })
+        ] }),
+        /* @__PURE__ */ jsxs2(DialogFooter, { className: "au-flex au-flex-col sm:au-flex-row au-justify-between au-gap-x-4 au-py-2 au-pl-6 au-pr-3 au-bg-secondary au-border-t au-shadow-inner", children: [
+          due_today && /* @__PURE__ */ jsxs2(TotalPrice, { children: [
+            /* @__PURE__ */ jsx2("span", { children: "Due Today" }),
+            /* @__PURE__ */ jsx2("span", { children: new Intl.NumberFormat("en-US", {
+              style: "currency",
+              currency: due_today.currency
+            }).format(getTotalPrice()) })
+          ] }),
+          /* @__PURE__ */ jsx2(
+            Button,
+            {
+              size: "sm",
+              onClick: async () => {
+                setLoading(true);
+                await attach({
+                  productId: preview.product_id,
+                  options: optionsInput.map((option) => ({
+                    featureId: option.feature_id,
+                    quantity: option.quantity || 0
+                  }))
+                });
+                setOpen(false);
+                setLoading(false);
+              },
+              disabled: loading,
+              className: "au-min-w-16 au-flex au-items-center au-gap-2",
+              children: loading ? /* @__PURE__ */ jsx2(LoaderCircle, { className: "au-w-4 au-h-4 au-animate-spin" }) : /* @__PURE__ */ jsx2(Fragment2, { children: /* @__PURE__ */ jsx2("span", { className: "au-whitespace-nowrap au-flex au-gap-1", children: "Confirm" }) })
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+var PriceItem = ({
+  children,
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: cn(
+        "au-flex au-flex-col au-pb-4 sm:au-pb-0 au-gap-1 sm:au-flex-row au-justify-between sm:au-h-7 sm:au-gap-2 sm:au-items-center",
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+};
+var OptionsInput = ({
+  className,
+  option,
+  optionsInput,
+  setOptionsInput,
+  index,
+  ...props
+}) => {
+  const { feature_name, billing_units, quantity, price } = option;
+  return /* @__PURE__ */ jsxs2(PriceItem, { children: [
+    /* @__PURE__ */ jsx2("span", { children: feature_name }),
+    /* @__PURE__ */ jsx2(
+      QuantityInput,
+      {
+        value: quantity ? quantity / billing_units : "",
+        onChange: (e) => {
+          const newOptions = [...optionsInput];
+          newOptions[index].quantity = parseInt(e.target.value) * billing_units;
+          setOptionsInput(newOptions);
+        },
+        children: /* @__PURE__ */ jsxs2("span", { className: "", children: [
+          "\xD7 $",
+          price,
+          " per ",
+          billing_units === 1 ? " " : billing_units,
+          " ",
+          feature_name
+        ] })
+      },
+      feature_name
+    )
+  ] }, feature_name);
+};
+var QuantityInput = ({
+  children,
+  onChange,
+  value,
+  className,
+  ...props
+}) => {
+  const currentValue = Number(value) || 0;
+  const handleValueChange = (newValue) => {
+    const syntheticEvent = {
+      target: { value: String(newValue) }
+    };
+    onChange(syntheticEvent);
+  };
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: cn(className, "au-flex au-flex-row au-items-center au-gap-4"),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsxs2("div", { className: "au-flex au-items-center au-gap-1", children: [
+          /* @__PURE__ */ jsx2(
+            Button,
+            {
+              variant: "outline",
+              size: "icon",
+              onClick: () => currentValue > 0 && handleValueChange(currentValue - 1),
+              disabled: currentValue <= 0,
+              className: "au-h-6 au-w-6 au-pb-0.5",
+              children: "-"
+            }
+          ),
+          /* @__PURE__ */ jsx2("span", { className: "au-w-8 au-text-center au-text-foreground", children: currentValue }),
+          /* @__PURE__ */ jsx2(
+            Button,
+            {
+              variant: "outline",
+              size: "icon",
+              onClick: () => handleValueChange(currentValue + 1),
+              className: "au-h-6 au-w-6 au-pb-0.5",
+              children: "+"
+            }
+          )
+        ] }),
+        children
+      ]
+    }
+  );
+};
+var TotalPrice = ({ children }) => {
+  return /* @__PURE__ */ jsx2("div", { className: "au-w-full au-font-semibold au-flex au-justify-between au-items-center", children });
+};
+var PricingDialogButton = ({
+  children,
+  size,
+  onClick,
+  disabled,
+  className
+}) => {
+  return /* @__PURE__ */ jsxs2(
+    Button,
+    {
+      onClick,
+      disabled,
+      size,
+      className: cn(className, "au-shadow-sm au-shadow-stone-400"),
+      children: [
+        children,
+        /* @__PURE__ */ jsx2(ArrowRight, { className: "!au-h-3" })
+      ]
+    }
+  );
+};
+
+// src/libraries/react/hooks/useAutumnBase.tsx
+var useAutumnBase = ({
+  AutumnContext: AutumnContext2
+}) => {
+  const context = useAutumnContext({ AutumnContext: AutumnContext2, name: "useAutumn" });
+  const { attachDialog, paywallDialog } = context;
+  const client = context.client;
+  const { refetch: refetchPricingTable } = usePricingTableBase({
+    AutumnContext: AutumnContext2
+  });
+  let {
+    open: attachOpen,
+    setProps: setAttachProps,
+    setOpen: setAttachOpen,
+    setComponent: setAttachComponent
+  } = attachDialog;
+  let {
+    setProps: setCheckProps,
+    setOpen: setCheckOpen,
+    setComponent: setPaywallComponent
+  } = paywallDialog;
+  const attachWithoutDialog = async (params) => {
+    const result = await client.attach(params);
+    if (result.error) {
+      return result;
+    }
+    let data = result.data;
+    if (data?.checkout_url && typeof window !== "undefined") {
+      if (params.openInNewTab) {
+        window.open(data.checkout_url, "_blank");
+      } else {
+        window.location.href = data.checkout_url;
+      }
+    }
+    await refetchPricingTable();
+    if (setAttachOpen) {
+      setAttachOpen(false);
+    }
+    return result;
+  };
+  const attachWithDialog = async (params) => {
+    let { dialog, ...rest } = params;
+    const { productId, entityId, entityData } = params;
+    const checkRes = await client.check({
+      productId,
+      entityId,
+      entityData,
+      withPreview: true
+    });
+    if (checkRes.error) {
+      return checkRes;
+    }
+    let preview = checkRes.data.preview;
+    if (!preview) {
+      return await attachWithoutDialog(rest);
+    } else {
+      setAttachProps({ preview });
+      setAttachOpen(true);
+    }
+    return checkRes;
+  };
+  const attach = async (params) => {
+    const { dialog, openInNewTab } = params;
+    let finalDialog = dialog ? dialog : context.disableDialogs ? void 0 : AttachDialog;
+    if (finalDialog && !attachOpen) {
+      setAttachComponent(finalDialog);
+      return await attachWithDialog(params);
+    }
+    return await attachWithoutDialog(params);
+  };
+  const cancel = async (params) => {
+    const res = await client.cancel(params);
+    if (res.error) {
+      return res;
+    }
+    return res;
+  };
+  const check = async (params) => {
+    let { dialog, withPreview } = params;
+    if (dialog) {
+      setPaywallComponent(dialog);
+    }
+    const res = await client.check({
+      ...params,
+      withPreview: withPreview || dialog ? true : false
+    });
+    if (res.error) {
+      return res;
+    }
+    let data = res.data;
+    if (data && data.preview && dialog) {
+      let preview = data.preview;
+      setCheckProps({ preview });
+      setCheckOpen(true);
+    }
+    return res;
+  };
+  const track = async (params) => {
+    const res = await client.track(params);
+    if (res.error) {
+      return res;
+    }
+    return res;
+  };
+  const openBillingPortal = async (params) => {
+    let defaultParams = {
+      openInNewTab: false
+    };
+    let finalParams = {
+      ...defaultParams,
+      ...params
+    };
+    const res = await client.openBillingPortal(finalParams);
+    if (res.error) {
+      return res;
+    }
+    let data = res.data;
+    if (data?.url && typeof window !== "undefined") {
+      if (finalParams.openInNewTab) {
+        window.open(data.url, "_blank");
+      } else {
+        window.open(data.url, "_self");
+      }
+      return res;
+    } else {
+      return res;
+    }
+  };
+  return {
+    attach,
+    check,
+    track,
+    cancel,
+    openBillingPortal
+  };
+};
+
+// src/libraries/react/hooks/useCustomerBase.tsx
+var emptyDefaultFunctions = {
+  attach: "",
+  check: "",
+  track: "",
+  cancel: "",
+  openBillingPortal: ""
+};
+var useCustomerBase = ({
+  params,
+  AutumnContext: AutumnContext2,
+  client
+}) => {
+  const queryKey = ["customer"];
+  let context;
+  if (AutumnContext2) {
+    context = useAutumnContext({ AutumnContext: AutumnContext2, name: "useCustomer" });
+  }
+  if (!client) {
+    client = context.client;
+  }
+  const fetchCustomer = async () => {
+    const { data, error: error2 } = await client.createCustomer({
+      errorOnNotFound: params?.errorOnNotFound,
+      expand: params?.expand
+    });
+    if (error2) {
+      throw error2;
+    }
+    if (!data) {
+      return null;
+    }
+    return data;
+  };
+  const { data: customer, error, isLoading, mutate } = useSWR2(queryKey, fetchCustomer, {
+    fallbackData: null,
+    onErrorRetry: (error2, key, config) => {
+      if (error2.code == "entity_not_found") {
+        return false;
+      }
+      return true;
+    }
+  });
+  let autumnFunctions = emptyDefaultFunctions;
+  if (AutumnContext2) {
+    autumnFunctions = useAutumnBase({ AutumnContext: AutumnContext2 });
+  }
+  return {
+    customer: error ? null : customer,
+    isLoading,
+    error,
+    refetch: mutate,
+    ...autumnFunctions,
+    createEntity: client.entities.create,
+    createReferralCode: client.referrals.createCode,
+    redeemReferralCode: client.referrals.redeemCode,
+    allowed: (params2) => handleAllowed({ customer, params: params2 })
+  };
+};
+
+// src/libraries/react/BaseAutumnProvider.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function BaseAutumnProvider({
+  client,
+  children,
+  AutumnContext: AutumnContext2,
+  disableDialogs = false
+}) {
+  const [components, setComponents] = useState3({});
+  const [paywallProps, setPaywallProps, paywallOpen, setPaywallOpen] = useDialog(components.paywallDialog);
+  const [
+    productChangeProps,
+    setProductChangeProps,
+    productChangeOpen,
+    setProductChangeOpen
+  ] = useDialog(components.productChangeDialog);
+  useCustomerBase({ client, params: { errorOnNotFound: false } });
+  return /* @__PURE__ */ jsxs3(
+    AutumnContext2.Provider,
+    {
+      value: {
+        initialized: true,
+        client,
+        disableDialogs,
+        paywallDialog: {
+          props: paywallProps,
+          setProps: setPaywallProps,
+          open: paywallOpen,
+          setOpen: setPaywallOpen,
+          setComponent: (component) => {
+            setComponents({
+              ...components,
+              paywallDialog: component
+            });
+          }
+        },
+        attachDialog: {
+          props: productChangeProps,
+          setProps: setProductChangeProps,
+          open: productChangeOpen,
+          setOpen: setProductChangeOpen,
+          setComponent: (component) => {
+            setComponents({
+              ...components,
+              productChangeDialog: component
+            });
+          }
+        }
+      },
+      children: [
+        components.paywallDialog && /* @__PURE__ */ jsx3(
+          components.paywallDialog,
+          {
+            open: paywallOpen,
+            setOpen: setPaywallOpen,
+            ...paywallProps
+          }
+        ),
+        components.productChangeDialog && /* @__PURE__ */ jsx3(
+          components.productChangeDialog,
+          {
+            open: productChangeOpen,
+            setOpen: setProductChangeOpen,
+            ...productChangeProps
+          }
+        ),
+        children
+      ]
+    }
+  );
+}
+
+// src/libraries/react/ReactAutumnProvider.tsx
+import { useEffect as useEffect3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var ReactAutumnProvider = ({
+  children,
+  getBearerToken,
+  backendUrl,
+  customerData,
+  includeCredentials = true,
+  disableDialogs = false,
+  authClient
+}) => {
+  if (backendUrl && !backendUrl.startsWith("http")) {
+    console.warn(`backendUrl is not a valid URL: ${backendUrl}`);
+  }
+  let client = new AutumnClient({
+    backendUrl: backendUrl || "",
+    getBearerToken,
+    customerData,
+    includeCredentials
+  });
+  const analyseAuthClient = async () => {
+    console.log("Auth client:", authClient);
+  };
+  useEffect3(() => {
+    analyseAuthClient();
+  }, [authClient]);
+  return /* @__PURE__ */ jsx4(
+    BaseAutumnProvider,
+    {
+      client,
+      AutumnContext,
+      disableDialogs,
+      children
+    }
+  );
+};
+
+export {
+  ReactAutumnProvider,
+  useCustomer,
+  useEntityBase,
+  useEntity,
+  useAutumn,
+  PricingTable,
+  usePricingTableContext,
+  PricingTableContainer,
+  PricingCard,
+  PricingFeatureList,
+  PricingCardButton,
+  AnnualSwitch,
+  RecommendedBadge,
+  AttachDialog,
+  PriceItem,
+  OptionsInput,
+  QuantityInput,
+  TotalPrice,
+  PricingDialogButton,
+  useAutumnBase,
+  useCustomerBase,
+  BaseAutumnProvider
+};