autumn-js 0.0.66 → 0.0.72

package/dist/libraries/react/chunk-4PX3AQKX.mjs

@@ -0,0 +1,53 @@
+"use client";
+
+import {
+  getCheckContent
+} from "./chunk-MY2ODATB.mjs";
+import {
+  Button
+} from "./chunk-O4HHXBGR.mjs";
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogTitle,
+  LoaderCircle
+} from "./chunk-2XYYCR4J.mjs";
+import {
+  cn
+} from "./chunk-4CGZZYLG.mjs";
+
+// src/libraries/react/components/check-dialog/check-dialog-synced.tsx
+import { useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function CheckDialog(params) {
+  const [loading] = useState(false);
+  if (!params || !params.preview) {
+    return /* @__PURE__ */ jsx(Fragment, {});
+  }
+  const { open, setOpen } = params;
+  const { products } = params.preview;
+  const { title, message } = getCheckContent(params.preview);
+  return /* @__PURE__ */ jsx(Dialog, { open, onOpenChange: setOpen, children: /* @__PURE__ */ jsxs(DialogContent, { className: "p-0 pt-4 gap-0 text-foreground overflow-hidden text-sm", children: [
+    /* @__PURE__ */ jsx(DialogTitle, { className: cn("font-bold text-xl px-6"), children: title }),
+    /* @__PURE__ */ jsx("div", { className: "px-6 my-2", children: message }),
+    /* @__PURE__ */ jsx(DialogFooter, { className: "flex flex-col sm:flex-row justify-between gap-x-4 py-2 mt-4 pl-6 pr-3 bg-secondary border-t", children: /* @__PURE__ */ jsxs(
+      Button,
+      {
+        size: "sm",
+        className: "font-medium shadow transition min-w-20",
+        onClick: async () => {
+          setOpen(false);
+        },
+        children: [
+          loading && /* @__PURE__ */ jsx(LoaderCircle, { className: "w-4 h-4 mr-2 animate-spin" }),
+          "Confirm"
+        ]
+      }
+    ) })
+  ] }) });
+}
+
+export {
+  CheckDialog
+};

package/dist/libraries/react/chunk-7PRD7RPD.mjs

@@ -0,0 +1,20 @@
+"use client";
+
+import {
+  usePricingTableBase
+} from "./chunk-Q7CK32YT.mjs";
+import {
+  AutumnContext
+} from "./chunk-B7HGBQCO.mjs";
+
+// src/libraries/react/hooks/usePricingTable.tsx
+var usePricingTable = (params) => {
+  return usePricingTableBase({
+    AutumnContext,
+    params
+  });
+};
+
+export {
+  usePricingTable
+};

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

@@ -0,0 +1,48 @@
+"use client";
+
+import {
+  AutumnClient
+} from "./chunk-CE5BBB5H.mjs";
+
+// src/libraries/react/AutumnContext.tsx
+import { createContext, useContext } from "react";
+var AutumnContext = createContext({
+  initialized: false,
+  disableDialogs: false,
+  client: new AutumnClient({ backendUrl: "" }),
+  paywallDialog: {
+    props: null,
+    setProps: () => {
+    },
+    open: false,
+    setOpen: () => {
+    },
+    setComponent: () => {
+    }
+  },
+  attachDialog: {
+    props: null,
+    setProps: () => {
+    },
+    open: false,
+    setOpen: () => {
+    },
+    setComponent: () => {
+    }
+  }
+});
+var useAutumnContext = ({
+  AutumnContext: AutumnContext2,
+  name
+}) => {
+  const context = useContext(AutumnContext2);
+  if (!context.initialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
+  return context;
+};
+
+export {
+  AutumnContext,
+  useAutumnContext
+};

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

@@ -0,0 +1,125 @@
+"use client";
+
+
+// src/libraries/react/components/attach-dialog/lib/attach-content.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var getAttachContent = (preview) => {
+  const {
+    scenario,
+    product_name,
+    recurring,
+    current_product_name,
+    next_cycle_at
+  } = preview;
+  const nextCycleAtStr = next_cycle_at ? new Date(next_cycle_at).toLocaleDateString() : void 0;
+  switch (scenario) {
+    case "scheduled":
+      return {
+        title: /* @__PURE__ */ jsxs("p", { children: [
+          product_name,
+          " product already scheduled"
+        ] }),
+        message: /* @__PURE__ */ jsxs("p", { children: [
+          "You are currently on product ",
+          current_product_name,
+          " and are scheduled to start ",
+          product_name,
+          " on ",
+          nextCycleAtStr,
+          "."
+        ] })
+      };
+    case "active":
+      return {
+        title: /* @__PURE__ */ jsx("p", { children: "Product already active" }),
+        message: /* @__PURE__ */ jsx("p", { children: "You are already subscribed to this product." })
+      };
+    case "new":
+      if (recurring) {
+        return {
+          title: /* @__PURE__ */ jsxs("p", { children: [
+            "Subscribe to ",
+            product_name
+          ] }),
+          message: /* @__PURE__ */ jsxs("p", { children: [
+            "By clicking confirm, you will be subscribed to ",
+            product_name,
+            " and your card will be charged immediately."
+          ] })
+        };
+      } else {
+        return {
+          title: /* @__PURE__ */ jsxs("p", { children: [
+            "Purchase ",
+            product_name
+          ] }),
+          message: /* @__PURE__ */ jsxs("p", { children: [
+            "By clicking confirm, you will purchase ",
+            product_name,
+            " and your card will be charged immediately."
+          ] })
+        };
+      }
+    case "renew":
+      return {
+        title: /* @__PURE__ */ jsx("p", { children: "Renew" }),
+        message: /* @__PURE__ */ jsxs("p", { children: [
+          "By clicking confirm, you will renew your subscription to",
+          " ",
+          product_name,
+          "."
+        ] })
+      };
+    case "upgrade":
+      return {
+        title: /* @__PURE__ */ jsxs("p", { children: [
+          "Upgrade to ",
+          product_name
+        ] }),
+        message: /* @__PURE__ */ jsxs("p", { children: [
+          "By clicking confirm, you will upgrade to ",
+          product_name,
+          " and your payment method will be charged immediately."
+        ] })
+      };
+    case "downgrade":
+      return {
+        title: /* @__PURE__ */ jsxs("p", { children: [
+          "Downgrade to ",
+          product_name
+        ] }),
+        message: /* @__PURE__ */ jsxs("p", { children: [
+          "By clicking confirm, your current subscription to",
+          " ",
+          current_product_name,
+          " will be cancelled and a new subscription to",
+          " ",
+          product_name,
+          " will begin on ",
+          nextCycleAtStr,
+          "."
+        ] })
+      };
+    case "cancel":
+      return {
+        title: /* @__PURE__ */ jsx("p", { children: "Cancel" }),
+        message: /* @__PURE__ */ jsxs("p", { children: [
+          "By clicking confirm, your subscription to ",
+          current_product_name,
+          " ",
+          "will end on ",
+          nextCycleAtStr,
+          "."
+        ] })
+      };
+    default:
+      return {
+        title: /* @__PURE__ */ jsx("p", { children: "Change Subscription" }),
+        message: /* @__PURE__ */ jsx("p", { children: "You are about to change your subscription." })
+      };
+  }
+};
+
+export {
+  getAttachContent
+};

package/dist/libraries/react/{chunk-STABYMUY.mjs → chunk-CE5BBB5H.mjs}

@@ -1,19 +1,19 @@
 "use client";
 
 import {
-  attachMethod,
-  cancelMethod,
-  checkMethod,
-  openBillingPortalMethod,
-  trackMethod
-} from "./chunk-LS3NB4DU.mjs";
+  listProductsMethod
+} from "./chunk-YUV2Y2RW.mjs";
 import {
   createCode,
   redeemCode
 } from "./chunk-TBCLSIC2.mjs";
 import {
+  AutumnError,
   toContainerResult
-} from "./chunk-OCZFV7OX.mjs";
+} from "./chunk-EH2VPTFH.mjs";
+import {
+  logFetchError
+} from "./chunk-CIBQ4BJU.mjs";
 import {
   getPricingTableMethod
 } from "./chunk-NZ5PEXT2.mjs";
@@ -25,6 +25,13 @@ import {
   deleteEntityMethod,
   getEntityMethod
 } from "./chunk-4KKWHG2V.mjs";
+import {
+  attachMethod,
+  cancelMethod,
+  checkMethod,
+  openBillingPortalMethod,
+  trackMethod
+} from "./chunk-LS3NB4DU.mjs";
 
 // src/libraries/react/client/ReactAutumnClient.tsx
 var AutumnClient = class {
@@ -57,36 +64,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({
@@ -111,6 +139,9 @@ var AutumnClient = class {
     createCode: createCode.bind(this),
     redeemCode: redeemCode.bind(this)
   };
+  products = {
+    list: listProductsMethod.bind(this)
+  };
 };
 
 export {

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

@@ -0,0 +1,19 @@
+"use client";
+
+
+// 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.`);
+};
+
+export {
+  logFetchError
+};

package/dist/libraries/react/{chunk-OCZFV7OX.mjs → chunk-EH2VPTFH.mjs}

@@ -2,7 +2,7 @@
 
 
 // src/sdk/error.ts
-var AutumnError = class extends Error {
+var AutumnError = class _AutumnError extends Error {
   message;
   code;
   constructor(response) {
@@ -10,6 +10,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})`;
   }
@@ -22,12 +28,14 @@ var AutumnError = class extends Error {
 };
 
 // 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({
@@ -54,6 +62,7 @@ var toContainerResult = async (response) => {
       statusCode: response?.status
     };
   } catch (error) {
+    throw error;
     return {
       data: null,
       error: new AutumnError({
@@ -65,6 +74,53 @@ var toContainerResult = async (response) => {
   }
 };
 
+// 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) {
@@ -177,50 +233,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 {
@@ -233,7 +245,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)) {
@@ -281,14 +293,52 @@ var redeemReferralCode = async ({
   return instance.post("/referrals/redeem", params);
 };
 
+// src/utils/logger.ts
+import chalk from "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(), chalk.gray("DEBUG"), ...args);
+    }
+  },
+  log: (...args) => {
+    console.log(getTime(), chalk.blue("INFO"), ...args);
+  },
+  info: (...args) => {
+    if (greaterThanLevel("info")) {
+      console.log(getTime(), chalk.blue("INFO"), ...args);
+    }
+  },
+  warn: (...args) => {
+    if (greaterThanLevel("warn")) {
+      console.log(getTime(), chalk.yellow("WARN"), ...args);
+    }
+  },
+  error: (...args) => {
+    if (greaterThanLevel("error")) {
+      console.log(getTime(), chalk.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;
@@ -304,17 +354,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 {
@@ -323,7 +371,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;
@@ -334,7 +382,7 @@ var Autumn = class {
       method: "DELETE",
       headers: this.headers
     });
-    return toContainerResult(response);
+    return toContainerResult({ response, logger: this.logger });
   }
   static customers = customerMethods();
   static products = productMethods();

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

@@ -0,0 +1,17 @@
+"use client";
+
+import {
+  useAutumnBase
+} from "./chunk-ZQ6LDLK5.mjs";
+import {
+  AutumnContext
+} from "./chunk-B7HGBQCO.mjs";
+
+// src/libraries/react/hooks/useAutumn.tsx
+var useAutumn = () => {
+  return useAutumnBase({ AutumnContext });
+};
+
+export {
+  useAutumn
+};