autumn-js 0.0.66 → 0.0.72

package/dist/libraries/react/BaseAutumnProvider.js

@@ -1,9 +1,12 @@
 "use client";
 
 "use strict";
+"use client";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,6 +20,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/libraries/react/BaseAutumnProvider.tsx
@@ -25,12 +36,28 @@ __export(BaseAutumnProvider_exports, {
   BaseAutumnProvider: () => BaseAutumnProvider
 });
 module.exports = __toCommonJS(BaseAutumnProvider_exports);
+var import_react3 = require("react");
 
-// src/libraries/react/AutumnContext.tsx
+// src/libraries/react/hooks/useDialog.tsx
 var import_react = require("react");
+var useDialog = (component) => {
+  const [dialogProps, setDialogProps] = (0, import_react.useState)(null);
+  const [dialogOpen, setDialogOpen] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    if (!dialogOpen) {
+      setTimeout(() => {
+        setDialogProps(null);
+      }, 200);
+    }
+  }, [dialogOpen]);
+  return [dialogProps, setDialogProps, dialogOpen, setDialogOpen];
+};
+
+// src/libraries/react/hooks/useCustomerBase.tsx
+var import_swr2 = __toESM(require("swr"));
 
 // src/sdk/error.ts
-var AutumnError = class extends Error {
+var AutumnError = class _AutumnError extends Error {
   message;
   code;
   constructor(response) {
@@ -38,6 +65,12 @@ var AutumnError = class extends Error {
     this.message = response.message;
     this.code = response.code;
   }
+  static fromError(error) {
+    return new _AutumnError({
+      message: error.message || "Unknown error",
+      code: error.code || "unknown_error"
+    });
+  }
   toString() {
     return `${this.message} (code: ${this.code})`;
   }
@@ -49,6 +82,53 @@ var AutumnError = class extends Error {
   }
 };
 
+// src/sdk/general/genMethods.ts
+var handleAttach = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/attach", params);
+};
+var handleCancel = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/cancel", params);
+};
+var handleEntitled = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/entitled", params);
+};
+var handleEvent = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/events", params);
+};
+var handleTrack = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/track", params);
+};
+var handleUsage = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/usage", params);
+};
+var handleCheck = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/check", params);
+};
+
+// src/libraries/backend/constants.ts
+var autumnApiUrl = "https://api.useautumn.com/v1";
+
 // src/sdk/utils.ts
 var staticWrapper = (callback, instance, args) => {
   if (!instance) {
@@ -161,50 +241,6 @@ var deleteEntity = async ({
   return instance.delete(`/customers/${customer_id}/entities/${entity_id}`);
 };
 
-// src/sdk/general/genMethods.ts
-var handleAttach = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/attach", params);
-};
-var handleCancel = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/cancel", params);
-};
-var handleEntitled = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/entitled", params);
-};
-var handleEvent = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/events", params);
-};
-var handleTrack = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/track", params);
-};
-var handleUsage = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/usage", params);
-};
-var handleCheck = async ({
-  instance,
-  params
-}) => {
-  return instance.post("/check", params);
-};
-
 // src/sdk/products/prodMethods.ts
 var productMethods = (instance) => {
   return {
@@ -217,7 +253,7 @@ var listProducts = async ({
   instance,
   params
 }) => {
-  let path = "/products";
+  let path = "/products_beta";
   if (params) {
     const queryParams = new URLSearchParams();
     for (const [key, value] of Object.entries(params)) {
@@ -266,12 +302,14 @@ var redeemReferralCode = async ({
 };
 
 // src/sdk/response.ts
-var toContainerResult = async (response) => {
+var toContainerResult = async ({ response, logger: logger2 }) => {
   if (response.status < 200 || response.status >= 300) {
     let error;
     try {
       error = await response.json();
+      logger2.error(`[Autumn] ${error.message}`);
     } catch (error2) {
+      throw error2;
       return {
         data: null,
         error: new AutumnError({
@@ -298,6 +336,7 @@ var toContainerResult = async (response) => {
       statusCode: response?.status
     };
   } catch (error) {
+    throw error;
     return {
       data: null,
       error: new AutumnError({
@@ -309,14 +348,52 @@ var toContainerResult = async (response) => {
   }
 };
 
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var getTime = () => {
+  let timeString = (/* @__PURE__ */ new Date()).toISOString();
+  return `[${timeString.split("T")[1].split(".")[0]}]`;
+};
+var greaterThanLevel = (level) => {
+  return levels.indexOf(level) >= levels.indexOf(logger.level);
+};
+var levels = ["debug", "info", "warn", "error", "fatal"];
+var logger = {
+  ...console,
+  level: "info",
+  debug: (...args) => {
+    if (greaterThanLevel("debug")) {
+      console.log(getTime(), import_chalk.default.gray("DEBUG"), ...args);
+    }
+  },
+  log: (...args) => {
+    console.log(getTime(), import_chalk.default.blue("INFO"), ...args);
+  },
+  info: (...args) => {
+    if (greaterThanLevel("info")) {
+      console.log(getTime(), import_chalk.default.blue("INFO"), ...args);
+    }
+  },
+  warn: (...args) => {
+    if (greaterThanLevel("warn")) {
+      console.log(getTime(), import_chalk.default.yellow("WARN"), ...args);
+    }
+  },
+  error: (...args) => {
+    if (greaterThanLevel("error")) {
+      console.log(getTime(), import_chalk.default.red("ERROR"), ...args);
+    }
+  }
+};
+
 // src/sdk/client.ts
 var LATEST_API_VERSION = "1.2";
 var Autumn = class {
   secretKey;
   publishableKey;
-  level;
   headers;
   url;
+  logger = console;
   constructor(options) {
     try {
       this.secretKey = options?.secretKey || process.env.AUTUMN_SECRET_KEY;
@@ -332,17 +409,15 @@ var Autumn = class {
     };
     let version = options?.version || LATEST_API_VERSION;
     this.headers["x-api-version"] = version;
-    this.url = options?.url || "https://api.useautumn.com/v1";
-    this.level = this.secretKey ? "secret" : "publishable";
-  }
-  getLevel() {
-    return this.level;
+    this.url = options?.url || autumnApiUrl;
+    this.logger = logger;
+    this.logger.level = options?.logLevel || "info";
   }
   async get(path) {
     const response = await fetch(`${this.url}${path}`, {
       headers: this.headers
     });
-    return toContainerResult(response);
+    return toContainerResult({ response, logger: this.logger });
   }
   async post(path, body) {
     try {
@@ -351,7 +426,7 @@ var Autumn = class {
         headers: this.headers,
         body: JSON.stringify(body)
       });
-      return toContainerResult(response);
+      return toContainerResult({ response, logger: this.logger });
     } catch (error) {
       console.error("Error sending request:", error);
       throw error;
@@ -362,7 +437,7 @@ var Autumn = class {
       method: "DELETE",
       headers: this.headers
     });
-    return toContainerResult(response);
+    return toContainerResult({ response, logger: this.logger });
   }
   static customers = customerMethods();
   static products = productMethods();
@@ -439,6 +514,19 @@ var Autumn = class {
   }
 };
 
+// src/libraries/react/errorUtils/logFetchError.ts
+var logFetchError = ({
+  method,
+  backendUrl,
+  path,
+  error
+}) => {
+  console.error(`[Autumn] Fetch failed: ${method} ${backendUrl}${path}
+
+1. Check that backendUrl in <AutumnProvider/> is correctly set.
+2. Check that autumnHandler is correctly registered on your backend.`);
+};
+
 // src/libraries/react/client/clientCompMethods.ts
 async function getPricingTableMethod() {
   const res = await this.get("/api/autumn/components/pricing_table");
@@ -526,6 +614,12 @@ async function openBillingPortalMethod(params) {
   return res;
 }
 
+// src/libraries/react/client/clientProdMethods.ts
+async function listProductsMethod() {
+  const res = await this.get("/api/autumn/products");
+  return res;
+}
+
 // src/libraries/react/client/clientReferralMethods.ts
 async function createCode(params) {
   let snakeParams = toSnakeCase(params);
@@ -569,36 +663,57 @@ var AutumnClient = class {
     }
     return headers;
   }
-  async handleFetchResult(result) {
-    let res = await toContainerResult(result);
-    return res;
+  async handleFetch({
+    path,
+    method,
+    body
+  }) {
+    body = method === "POST" ? JSON.stringify({
+      ...body,
+      customer_data: this.customerData || void 0
+    }) : void 0;
+    try {
+      const response = await fetch(`${this.backendUrl}${path}`, {
+        method,
+        body,
+        headers: await this.getHeaders(),
+        credentials: this.includeCredentials ? "include" : void 0
+      });
+      return await toContainerResult({ response, logger: console });
+    } catch (error) {
+      logFetchError({
+        method,
+        backendUrl: this.backendUrl || "",
+        path,
+        error
+      });
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "fetch_failed"
+        })
+      };
+    }
   }
   async post(path, body) {
-    const response = await fetch(`${this.backendUrl}${path}`, {
+    return await this.handleFetch({
+      path,
       method: "POST",
-      body: JSON.stringify({
-        ...body,
-        customer_data: this.customerData || void 0
-      }),
-      headers: await this.getHeaders(),
-      credentials: this.includeCredentials ? "include" : void 0
+      body
     });
-    return await this.handleFetchResult(response);
   }
   async get(path) {
-    const response = await fetch(`${this.backendUrl}${path}`, {
-      method: "GET",
-      headers: await this.getHeaders(),
-      credentials: this.includeCredentials ? "include" : void 0
+    return await this.handleFetch({
+      path,
+      method: "GET"
     });
-    return await this.handleFetchResult(response);
   }
   async delete(path) {
-    const response = await fetch(`${this.backendUrl}${path}`, {
-      method: "DELETE",
-      headers: await this.getHeaders()
+    return await this.handleFetch({
+      path,
+      method: "DELETE"
     });
-    return await this.handleFetchResult(response);
   }
   async createCustomer(params) {
     return await createCustomerMethod({
@@ -623,27 +738,17 @@ var AutumnClient = class {
     createCode: createCode.bind(this),
     redeemCode: redeemCode.bind(this)
   };
+  products = {
+    list: listProductsMethod.bind(this)
+  };
 };
 
 // src/libraries/react/AutumnContext.tsx
-var AutumnContext = (0, import_react.createContext)({
-  customerProvider: null,
-  pricingTableProvider: {
-    pricingTableProducts: null,
-    isLoading: true,
-    error: null,
-    refetch: () => Promise.resolve()
-  },
-  entityProvider: {
-    entity: null,
-    isLoading: true,
-    error: null,
-    refetch: () => Promise.resolve(),
-    lastParams: null
-  },
-  client: new AutumnClient({
-    backendUrl: "http://localhost:8000"
-  }),
+var import_react2 = require("react");
+var AutumnContext = (0, import_react2.createContext)({
+  initialized: false,
+  disableDialogs: false,
+  client: new AutumnClient({ backendUrl: "" }),
   paywallDialog: {
     props: null,
     setProps: () => {
@@ -654,7 +759,7 @@ var AutumnContext = (0, import_react.createContext)({
     setComponent: () => {
     }
   },
-  prodChangeDialog: {
+  attachDialog: {
     props: null,
     setProps: () => {
     },
@@ -665,181 +770,427 @@ var AutumnContext = (0, import_react.createContext)({
     }
   }
 });
+var useAutumnContext = ({
+  AutumnContext: AutumnContext2,
+  name
+}) => {
+  const context = (0, import_react2.useContext)(AutumnContext2);
+  if (!context.initialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
+  return context;
+};
 
-// src/libraries/react/BaseAutumnProvider.tsx
-var import_react6 = require("react");
-
-// src/libraries/react/hooks/useDialog.tsx
-var import_react2 = require("react");
-var useDialog = (component) => {
-  const [dialogProps, setDialogProps] = (0, import_react2.useState)(null);
-  const [dialogOpen, setDialogOpen] = (0, import_react2.useState)(false);
-  (0, import_react2.useEffect)(() => {
-    if (!dialogOpen) {
-      setTimeout(() => {
-        setDialogProps(null);
-      }, 200);
+// src/libraries/react/hooks/usePricingTableBase.tsx
+var import_swr = __toESM(require("swr"));
+var mergeProductDetails = (products, productDetails) => {
+  if (!products) {
+    return null;
+  }
+  if (!productDetails) {
+    return products;
+  }
+  let fetchedProducts = structuredClone(products);
+  let mergedProducts = [];
+  for (const overrideDetails of productDetails) {
+    if (!overrideDetails.id) {
+      let properties = {};
+      let overrideItems2 = overrideDetails.items?.map((item) => ({
+        display: {
+          primary_text: item.primaryText,
+          secondary_text: item.secondaryText
+        }
+      }));
+      let overridePrice2 = overrideDetails.price;
+      if (overrideDetails.price) {
+        properties.is_free = false;
+        overrideItems2 = [
+          {
+            display: {
+              primary_text: overridePrice2?.primaryText,
+              secondary_text: overridePrice2?.secondaryText
+            }
+          },
+          ...overrideItems2 || []
+        ];
+      }
+      mergedProducts.push({
+        name: overrideDetails.name || "",
+        display: {
+          description: overrideDetails.description,
+          button_text: overrideDetails.buttonText,
+          recommend_text: overrideDetails.recommendText,
+          everything_from: overrideDetails.everythingFrom,
+          button_url: overrideDetails.buttonUrl
+        },
+        items: overrideItems2,
+        properties
+      });
+      continue;
     }
-  }, [dialogOpen]);
-  return [dialogProps, setDialogProps, dialogOpen, setDialogOpen];
+    let fetchedProduct = fetchedProducts.find(
+      (p) => p.id === overrideDetails.id
+    );
+    if (!fetchedProduct) {
+      continue;
+    }
+    const originalIsFree = fetchedProduct.properties?.is_free;
+    let overrideProperties = fetchedProduct.properties || {};
+    let overrideItems = overrideDetails.items;
+    let overridePrice = overrideDetails.price;
+    let mergedItems = [];
+    if (overridePrice) {
+      overrideProperties.is_free = false;
+      if (originalIsFree || overrideItems !== void 0) {
+        mergedItems.push({
+          display: {
+            primary_text: overridePrice.primaryText,
+            secondary_text: overridePrice.secondaryText
+          }
+        });
+      } else {
+        fetchedProduct.items[0].display = {
+          primary_text: overridePrice.primaryText,
+          secondary_text: overridePrice.secondaryText
+        };
+      }
+    } else {
+      if (overrideItems && !originalIsFree) {
+        mergedItems.push(fetchedProduct.items[0]);
+      }
+    }
+    if (overrideItems) {
+      for (const overrideItem of overrideItems) {
+        if (!overrideItem.featureId) {
+          mergedItems.push({
+            display: {
+              primary_text: overrideItem.primaryText,
+              secondary_text: overrideItem.secondaryText
+            }
+          });
+        } else {
+          let fetchedItem = fetchedProduct.items.find(
+            (i) => i.feature_id === overrideItem.featureId
+          );
+          if (!fetchedItem) {
+            console.error(
+              `Feature with id ${overrideItem.featureId} not found for product ${fetchedProduct.id}`
+            );
+            continue;
+          }
+          mergedItems.push({
+            ...fetchedItem,
+            display: {
+              primary_text: overrideItem.primaryText || fetchedItem.display?.primary_text,
+              secondary_text: overrideItem.secondaryText || fetchedItem.display?.secondary_text
+            }
+          });
+        }
+      }
+    } else {
+      mergedItems = fetchedProduct.items;
+    }
+    const mergedProduct = {
+      ...fetchedProduct,
+      name: overrideDetails.name || fetchedProduct.name,
+      items: mergedItems,
+      properties: overrideProperties,
+      display: {
+        description: overrideDetails.description,
+        button_text: overrideDetails.buttonText,
+        recommend_text: overrideDetails.recommendText,
+        everything_from: overrideDetails.everythingFrom,
+        button_url: overrideDetails.buttonUrl
+      }
+      // description: overrideDetails.description,
+      // button_text: overrideDetails.buttonText,
+      // recommend_text: overrideDetails.recommendText,
+      // everything_from: overrideDetails.everythingFrom,
+    };
+    mergedProducts.push(mergedProduct);
+  }
+  return mergedProducts;
 };
-
-// src/libraries/react/hooks/usePricingTableProvider.tsx
-var import_react3 = require("react");
-var usePricingTableProvider = ({
-  client
+var usePricingTableBase = ({
+  AutumnContext: AutumnContext2,
+  params
 }) => {
-  const [pricingTableProducts, setPricingTableProducts] = (0, import_react3.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react3.useState)(true);
-  const [error, setError] = (0, import_react3.useState)(null);
-  const fetchProducts = async () => {
+  const context = useAutumnContext({ AutumnContext: AutumnContext2, name: "usePricingTable" });
+  const fetcher = async () => {
     try {
-      setIsLoading(true);
-      const { data, error: error2 } = await client.getPricingTable();
-      if (error2) {
-        setError(error2);
-        setPricingTableProducts(null);
-      } else {
-        setPricingTableProducts(data?.list || []);
-        setError(null);
-      }
+      const { data: data2, error: error2 } = await context.client.products.list();
+      if (error2) throw error2;
+      return data2?.list || [];
     } catch (error2) {
-      setError(
-        new AutumnError({
-          message: "Failed to fetch pricing table products",
-          code: "failed_to_fetch_pricing_table_products"
-        })
-      );
-      setPricingTableProducts(null);
-    } finally {
-      setIsLoading(false);
+      throw new AutumnError({
+        message: "Failed to fetch pricing table products",
+        code: "failed_to_fetch_pricing_table_products"
+      });
     }
   };
+  const { data, error, mutate } = (0, import_swr.default)(
+    "pricing-table",
+    fetcher
+  );
   return {
-    pricingTableProducts,
-    isLoading: isLoading && !pricingTableProducts,
+    products: mergeProductDetails(data || [], params?.productDetails),
+    // products: data || [],
+    isLoading: !error && !data,
     error,
-    refetch: fetchProducts
+    refetch: mutate
   };
 };
 
-// src/libraries/react/hooks/useEntityProvider.tsx
-var import_react4 = require("react");
-var useEntityProvider = ({ client }) => {
-  const [entity, setEntity] = (0, import_react4.useState)(null);
-  const [error, setError] = (0, import_react4.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react4.useState)(true);
-  const [lastParams, setLastParams] = (0, import_react4.useState)(null);
-  const fetchEntity = async ({
-    entityId,
-    params
-  }) => {
-    if (!entityId) {
-      console.warn("(Autumn) No entity ID provided in useEntity hook");
-      return;
-    }
-    setIsLoading(true);
-    setLastParams(params || null);
-    try {
-      const { data, error: error2 } = await client.entities.get(entityId, params);
-      if (error2) {
-        setError(error2);
-        setEntity(null);
+// 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 {
-        setEntity(data);
-        setError(null);
+        window.location.href = data.checkout_url;
       }
-    } catch (error2) {
-      setError(
-        new AutumnError({
-          message: error2?.message || "Failed to fetch entity",
-          code: "entity_fetch_failed"
-        })
-      );
     }
-    setIsLoading(false);
+    await refetchPricingTable();
+    if (setAttachOpen) {
+      setAttachOpen(false);
+    }
+    return result;
   };
-  return { entity, isLoading, error, refetch: fetchEntity, lastParams };
-};
-
-// src/libraries/react/hooks/useCustomerProvider.tsx
-var import_react5 = require("react");
-function useCustomerProvider(client) {
-  const [stateMap, setStateMap] = (0, import_react5.useState)({});
-  const inProgressFetches = (0, import_react5.useRef)({});
-  const getQueryKey = (params) => {
-    return JSON.stringify(params || {});
+  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 getState = (params) => {
-    const queryKey = getQueryKey(params);
-    if (!stateMap[queryKey]) {
-      return {
-        customer: null,
-        isLoading: true,
-        error: null
-      };
+  const attach = async (params) => {
+    const { dialog, openInNewTab } = params;
+    let finalDialog = dialog;
+    if (finalDialog && !attachOpen) {
+      setAttachComponent(finalDialog);
+      return await attachWithDialog(params);
     }
-    return stateMap[queryKey];
+    return await attachWithoutDialog(params);
   };
-  const refetch = async ({
-    params,
-    errorOnNotFound = true
-  }) => {
-    const queryKey = getQueryKey(params);
-    if (inProgressFetches.current[queryKey]) {
-      return;
-    }
-    inProgressFetches.current[queryKey] = true;
-    setStateMap((prevState) => ({
-      ...prevState,
-      [queryKey]: {
-        ...prevState[queryKey] || { customer: null },
-        isLoading: true,
-        error: null
-      }
-    }));
-    const { data, error } = await client.createCustomer({
-      expand: params?.expand,
-      errorOnNotFound
+  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
     });
-    let newState = {
-      customer: data,
-      isLoading: false,
-      error
-    };
-    setStateMap((prevState) => ({
-      ...prevState,
-      [queryKey]: newState
-    }));
-    inProgressFetches.current[queryKey] = 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 refetchFirstTwo = async () => {
-    try {
-      let batchRefetch = [];
-      for (const key of Object.keys(stateMap)) {
-        batchRefetch.push(refetch({ params: JSON.parse(key) }));
+  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");
       }
-      await Promise.all(batchRefetch);
-    } catch (error) {
-      console.error("Failed to refetch customer (useCustomerProvider)");
-      console.error(error);
+      return res;
+    } else {
+      return res;
     }
   };
   return {
-    // stateMap,
-    getState,
-    refetch,
-    refetchFirstTwo
+    attach,
+    check,
+    track,
+    cancel,
+    openBillingPortal
   };
-}
+};
+
+// src/libraries/react/hooks/handleAllowed.ts
+var getCusFeature = ({
+  customer,
+  featureId,
+  requiredBalance = 1
+}) => {
+  let creditSchema = Object.values(customer.features).find((f) => f.credit_schema && f.credit_schema.some((c) => c.feature_id === featureId));
+  if (creditSchema) {
+    let schemaItem = creditSchema.credit_schema?.find((c) => c.feature_id === featureId);
+    return {
+      feature: creditSchema,
+      requiredBalance: schemaItem.credit_amount * requiredBalance
+    };
+  }
+  return {
+    cusFeature: customer.features[featureId],
+    requiredBalance
+  };
+};
+var handleFeatureAllowed = ({ customer, params }) => {
+  let { cusFeature, requiredBalance } = getCusFeature({ customer, featureId: params.featureId });
+  if (!cusFeature) return false;
+  if (cusFeature.type == "static") return true;
+  if (cusFeature.unlimited || cusFeature.overage_allowed) return true;
+  return (cusFeature.balance || 0) >= requiredBalance;
+};
+var handleAllowed = ({ customer, params }) => {
+  if (!customer) return false;
+  if (!params.featureId && !params.productId) {
+    throw new Error("allowed() requires either featureId or productId");
+  }
+  if (params.featureId) {
+    return handleFeatureAllowed({ customer, params });
+  }
+  if (params.productId) {
+    let product = customer.products.find((p) => p.id == params.productId);
+    if (!product) return false;
+    let status = product.status;
+    if (status == "scheduled") return false;
+    return true;
+  }
+  return false;
+};
+
+// 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 } = (0, import_swr2.default)(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
 var import_jsx_runtime = require("react/jsx-runtime");
 function BaseAutumnProvider({
   client,
-  children
+  children,
+  AutumnContext: AutumnContext2,
+  disableDialogs = false
 }) {
-  const [components, setComponents] = (0, import_react6.useState)({});
+  const [components, setComponents] = (0, import_react3.useState)({});
   const [paywallProps, setPaywallProps, paywallOpen, setPaywallOpen] = useDialog(components.paywallDialog);
   const [
     productChangeProps,
@@ -847,34 +1198,14 @@ function BaseAutumnProvider({
     productChangeOpen,
     setProductChangeOpen
   ] = useDialog(components.productChangeDialog);
-  const customerProvider = useCustomerProvider(client);
-  const entityProvider = useEntityProvider({ client });
-  const {
-    pricingTableProducts,
-    isLoading: pricingTableLoading,
-    error: pricingTableError,
-    refetch
-  } = usePricingTableProvider({
-    client
-  });
-  (0, import_react6.useEffect)(() => {
-    customerProvider.refetch({
-      errorOnNotFound: false
-    });
-  }, []);
+  useCustomerBase({ client, params: { errorOnNotFound: false } });
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
-    AutumnContext.Provider,
+    AutumnContext2.Provider,
     {
       value: {
-        customerProvider,
-        entityProvider,
-        pricingTableProvider: {
-          pricingTableProducts,
-          isLoading: pricingTableLoading,
-          error: pricingTableError,
-          refetch
-        },
+        initialized: true,
         client,
+        disableDialogs,
         paywallDialog: {
           props: paywallProps,
           setProps: setPaywallProps,
@@ -887,7 +1218,7 @@ function BaseAutumnProvider({
             });
           }
         },
-        prodChangeDialog: {
+        attachDialog: {
           props: productChangeProps,
           setProps: setProductChangeProps,
           open: productChangeOpen,