@stardeckai/autumn-js 0.1.85

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

@@ -0,0 +1,206 @@
+"use client";
+
+import {
+  useSize
+} from "./chunk-R4I7MVEX.mjs";
+import {
+  Primitive,
+  composeEventHandlers,
+  createContextScope,
+  useControllableState
+} from "./chunk-XGG7IZUQ.mjs";
+import {
+  useComposedRefs
+} from "./chunk-ACRIHVEO.mjs";
+import {
+  cn
+} from "./chunk-4J6OC4ZQ.mjs";
+
+// src/libraries/react/components/ui/switch.tsx
+import * as React3 from "react";
+
+// ../node_modules/.pnpm/@radix-ui+react-switch@1.2.5_@types+react-dom@19.2.3_@types+react@19.1.10__@types+react_df0c661b2d4b00af83e83e256ae42763/node_modules/@radix-ui/react-switch/dist/index.mjs
+import * as React2 from "react";
+
+// ../node_modules/.pnpm/@radix-ui+react-use-previous@1.1.1_@types+react@19.1.10_react@19.2.3/node_modules/@radix-ui/react-use-previous/dist/index.mjs
+import * as React from "react";
+function usePrevious(value) {
+  const ref = React.useRef({ value, previous: value });
+  return React.useMemo(() => {
+    if (ref.current.value !== value) {
+      ref.current.previous = ref.current.value;
+      ref.current.value = value;
+    }
+    return ref.current.previous;
+  }, [value]);
+}
+
+// ../node_modules/.pnpm/@radix-ui+react-switch@1.2.5_@types+react-dom@19.2.3_@types+react@19.1.10__@types+react_df0c661b2d4b00af83e83e256ae42763/node_modules/@radix-ui/react-switch/dist/index.mjs
+import { jsx, jsxs } from "react/jsx-runtime";
+var SWITCH_NAME = "Switch";
+var [createSwitchContext, createSwitchScope] = createContextScope(SWITCH_NAME);
+var [SwitchProvider, useSwitchContext] = createSwitchContext(SWITCH_NAME);
+var Switch = React2.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeSwitch,
+      name,
+      checked: checkedProp,
+      defaultChecked,
+      required,
+      disabled,
+      value = "on",
+      onCheckedChange,
+      form,
+      ...switchProps
+    } = props;
+    const [button, setButton] = React2.useState(null);
+    const composedRefs = useComposedRefs(forwardedRef, (node) => setButton(node));
+    const hasConsumerStoppedPropagationRef = React2.useRef(false);
+    const isFormControl = button ? form || !!button.closest("form") : true;
+    const [checked, setChecked] = useControllableState({
+      prop: checkedProp,
+      defaultProp: defaultChecked ?? false,
+      onChange: onCheckedChange,
+      caller: SWITCH_NAME
+    });
+    return /* @__PURE__ */ jsxs(SwitchProvider, { scope: __scopeSwitch, checked, disabled, children: [
+      /* @__PURE__ */ jsx(
+        Primitive.button,
+        {
+          type: "button",
+          role: "switch",
+          "aria-checked": checked,
+          "aria-required": required,
+          "data-state": getState(checked),
+          "data-disabled": disabled ? "" : void 0,
+          disabled,
+          value,
+          ...switchProps,
+          ref: composedRefs,
+          onClick: composeEventHandlers(props.onClick, (event) => {
+            setChecked((prevChecked) => !prevChecked);
+            if (isFormControl) {
+              hasConsumerStoppedPropagationRef.current = event.isPropagationStopped();
+              if (!hasConsumerStoppedPropagationRef.current) event.stopPropagation();
+            }
+          })
+        }
+      ),
+      isFormControl && /* @__PURE__ */ jsx(
+        SwitchBubbleInput,
+        {
+          control: button,
+          bubbles: !hasConsumerStoppedPropagationRef.current,
+          name,
+          value,
+          checked,
+          required,
+          disabled,
+          form,
+          style: { transform: "translateX(-100%)" }
+        }
+      )
+    ] });
+  }
+);
+Switch.displayName = SWITCH_NAME;
+var THUMB_NAME = "SwitchThumb";
+var SwitchThumb = React2.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeSwitch, ...thumbProps } = props;
+    const context = useSwitchContext(THUMB_NAME, __scopeSwitch);
+    return /* @__PURE__ */ jsx(
+      Primitive.span,
+      {
+        "data-state": getState(context.checked),
+        "data-disabled": context.disabled ? "" : void 0,
+        ...thumbProps,
+        ref: forwardedRef
+      }
+    );
+  }
+);
+SwitchThumb.displayName = THUMB_NAME;
+var BUBBLE_INPUT_NAME = "SwitchBubbleInput";
+var SwitchBubbleInput = React2.forwardRef(
+  ({
+    __scopeSwitch,
+    control,
+    checked,
+    bubbles = true,
+    ...props
+  }, forwardedRef) => {
+    const ref = React2.useRef(null);
+    const composedRefs = useComposedRefs(ref, forwardedRef);
+    const prevChecked = usePrevious(checked);
+    const controlSize = useSize(control);
+    React2.useEffect(() => {
+      const input = ref.current;
+      if (!input) return;
+      const inputProto = window.HTMLInputElement.prototype;
+      const descriptor = Object.getOwnPropertyDescriptor(
+        inputProto,
+        "checked"
+      );
+      const setChecked = descriptor.set;
+      if (prevChecked !== checked && setChecked) {
+        const event = new Event("click", { bubbles });
+        setChecked.call(input, checked);
+        input.dispatchEvent(event);
+      }
+    }, [prevChecked, checked, bubbles]);
+    return /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "checkbox",
+        "aria-hidden": true,
+        defaultChecked: checked,
+        ...props,
+        tabIndex: -1,
+        ref: composedRefs,
+        style: {
+          ...props.style,
+          ...controlSize,
+          position: "absolute",
+          pointerEvents: "none",
+          opacity: 0,
+          margin: 0
+        }
+      }
+    );
+  }
+);
+SwitchBubbleInput.displayName = BUBBLE_INPUT_NAME;
+function getState(checked) {
+  return checked ? "checked" : "unchecked";
+}
+var Root = Switch;
+var Thumb = SwitchThumb;
+
+// src/libraries/react/components/ui/switch.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Switch2 = React3.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx2(
+  Root,
+  {
+    className: cn(
+      "au-peer au-inline-flex au-h-5 au-w-9 au-shrink-0 au-cursor-pointer au-items-center au-rounded-full au-border-2 au-border-transparent au-shadow-sm au-transition-colors focus-visible:au-outline-none focus-visible:au-ring-2 focus-visible:au-ring-ring focus-visible:au-ring-offset-2 focus-visible:au-ring-offset-background au-disabled:cursor-not-allowed au-disabled:opacity-50 data-[state=checked]:au-bg-primary data-[state=unchecked]:au-bg-input",
+      className
+    ),
+    ...props,
+    ref,
+    children: /* @__PURE__ */ jsx2(
+      Thumb,
+      {
+        className: cn(
+          "au-pointer-events-none au-block au-h-4 au-w-4 au-rounded-full au-bg-background au-shadow-lg au-ring-0 au-transition-transform data-[state=checked]:au-translate-x-4 data-[state=unchecked]:au-translate-x-0"
+        )
+      }
+    )
+  }
+));
+Switch2.displayName = Root.displayName;
+
+export {
+  Switch2 as Switch
+};

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

@@ -0,0 +1,46 @@
+"use client";
+
+import {
+  useLayoutEffect2
+} from "./chunk-XGG7IZUQ.mjs";
+
+// ../node_modules/.pnpm/@radix-ui+react-use-size@1.1.1_@types+react@19.1.10_react@19.2.3/node_modules/@radix-ui/react-use-size/dist/index.mjs
+import * as React from "react";
+function useSize(element) {
+  const [size, setSize] = React.useState(void 0);
+  useLayoutEffect2(() => {
+    if (element) {
+      setSize({ width: element.offsetWidth, height: element.offsetHeight });
+      const resizeObserver = new ResizeObserver((entries) => {
+        if (!Array.isArray(entries)) {
+          return;
+        }
+        if (!entries.length) {
+          return;
+        }
+        const entry = entries[0];
+        let width;
+        let height;
+        if ("borderBoxSize" in entry) {
+          const borderSizeEntry = entry["borderBoxSize"];
+          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+          width = borderSize["inlineSize"];
+          height = borderSize["blockSize"];
+        } else {
+          width = element.offsetWidth;
+          height = element.offsetHeight;
+        }
+        setSize({ width, height });
+      });
+      resizeObserver.observe(element, { box: "border-box" });
+      return () => resizeObserver.unobserve(element);
+    } else {
+      setSize(void 0);
+    }
+  }, [element]);
+  return size;
+}
+
+export {
+  useSize
+};

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

@@ -0,0 +1,21 @@
+"use client";
+
+
+// src/libraries/react/hooks/helpers/useDialog.tsx
+import { useState, useEffect } from "react";
+var useDialog = (component) => {
+  const [dialogProps, setDialogProps] = useState(null);
+  const [dialogOpen, setDialogOpen] = useState(false);
+  useEffect(() => {
+    if (!dialogOpen) {
+      setTimeout(() => {
+        setDialogProps(null);
+      }, 200);
+    }
+  }, [dialogOpen]);
+  return [dialogProps, setDialogProps, dialogOpen, setDialogOpen];
+};
+
+export {
+  useDialog
+};

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

@@ -0,0 +1,44 @@
+"use client";
+
+import {
+  AutumnContext,
+  useAutumnContext
+} from "./chunk-D2TXVOAD.mjs";
+
+// src/libraries/react/hooks/usePaywall.tsx
+import useSWR from "swr";
+var usePaywall = ({
+  featureId,
+  entityId
+}) => {
+  const context = useAutumnContext({
+    AutumnContext,
+    name: "usePaywall"
+  });
+  const enabled = !!featureId && !!context;
+  const fetcher = async () => {
+    if (!featureId) {
+      return { preview: void 0 };
+    }
+    const { data: data2, error: error2 } = await context.client.check({
+      featureId,
+      withPreview: true
+    });
+    if (error2) throw error2;
+    return data2;
+  };
+  const queryKey = [`check`, featureId, entityId];
+  const { data, error, isLoading } = useSWR(queryKey, fetcher, {
+    refreshInterval: 0,
+    enabled
+  });
+  return {
+    data: data?.preview,
+    error,
+    isLoading
+  };
+};
+
+export {
+  usePaywall
+};

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

@@ -0,0 +1,17 @@
+"use client";
+
+
+// src/libraries/react/client/clientReferralMethods.ts
+async function createCode(params) {
+  const res = await this.post(`${this.prefix}/referrals/code`, params);
+  return res;
+}
+async function redeemCode(params) {
+  const res = await this.post(`${this.prefix}/referrals/redeem`, params);
+  return res;
+}
+
+export {
+  createCode,
+  redeemCode
+};

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

@@ -0,0 +1,256 @@
+"use client";
+
+import {
+  createEntityMethod,
+  deleteEntityMethod,
+  getEntityMethod
+} from "./chunk-OYBOLAL5.mjs";
+import {
+  attachMethod,
+  cancelMethod,
+  checkMethod,
+  checkoutMethod,
+  openBillingPortalMethod,
+  queryMethod,
+  setupPaymentMethod,
+  trackMethod
+} from "./chunk-6EXNYWJX.mjs";
+import {
+  listProductsMethod
+} from "./chunk-V575SGOW.mjs";
+import {
+  createCode,
+  redeemCode
+} from "./chunk-SUENW2KS.mjs";
+import {
+  logAuthError
+} from "./chunk-JVCOY7ZL.mjs";
+import {
+  logFetchError
+} from "./chunk-CIBQ4BJU.mjs";
+import {
+  AutumnError,
+  toContainerResult
+} from "./chunk-ZJPIZX24.mjs";
+import {
+  eventAggregateMethod,
+  eventListMethod
+} from "./chunk-XDQLJ7QR.mjs";
+import {
+  createCustomerMethod
+} from "./chunk-WFFVOEUG.mjs";
+
+// src/libraries/react/client/ReactAutumnClient.tsx
+var AutumnClient = class {
+  backendUrl;
+  getBearerToken;
+  customerData;
+  includeCredentials;
+  prefix;
+  camelCase;
+  headers;
+  framework;
+  defaultReturnUrl;
+  suppressLogs;
+  constructor({
+    backendUrl,
+    getBearerToken,
+    customerData,
+    includeCredentials,
+    betterAuthUrl,
+    headers,
+    pathPrefix,
+    defaultReturnUrl,
+    suppressLogs
+  }) {
+    this.backendUrl = backendUrl;
+    this.getBearerToken = getBearerToken;
+    this.customerData = customerData;
+    this.includeCredentials = includeCredentials;
+    this.prefix = "/api/autumn";
+    let camelCase = false;
+    if (betterAuthUrl) {
+      this.prefix = "/api/auth/autumn";
+      this.backendUrl = betterAuthUrl;
+      camelCase = true;
+    }
+    const providedPrefix = pathPrefix;
+    if (providedPrefix) {
+      const normalized = `/${providedPrefix}`.replace(/\/+/g, "/").replace(/\/$/, "");
+      this.prefix = normalized;
+    }
+    this.headers = headers;
+    if (betterAuthUrl) camelCase = true;
+    this.camelCase = camelCase;
+    this.defaultReturnUrl = defaultReturnUrl;
+    this.suppressLogs = suppressLogs ?? false;
+  }
+  /**
+   * Detects if the backend supports CORS credentials by making an OPTIONS request
+   */
+  async detectCors() {
+    if (this.prefix?.includes("/api/auth")) {
+      return { valid: true, includeCredentials: true };
+    }
+    const testEndpoint = `${this.backendUrl}${this.prefix}/cors`;
+    try {
+      await fetch(testEndpoint, {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({})
+      });
+      return { valid: true, includeCredentials: true };
+    } catch (_) {
+      try {
+        await fetch(testEndpoint, {
+          method: "POST",
+          credentials: "omit",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({})
+        });
+        return { valid: true, includeCredentials: false };
+      } catch (_2) {
+        return { valid: false, includeCredentials: void 0 };
+      }
+    }
+  }
+  /**
+   * Automatically determines whether to include credentials based on CORS detection
+   */
+  async shouldIncludeCredentials() {
+    if (this.includeCredentials !== void 0) {
+      return this.includeCredentials;
+    }
+    try {
+      const corsResult = await this.detectCors();
+      if (corsResult.valid) {
+        console.warn(
+          `[Autumn] Detected CORS credentials: ${corsResult.includeCredentials}`
+        );
+        console.warn(
+          `[Autumn] To disable this warning, you can set includeCredentials={${corsResult.includeCredentials ? "true" : "false"}} in <AutumnProvider />`
+        );
+        this.includeCredentials = corsResult.includeCredentials;
+        return corsResult.includeCredentials || false;
+      }
+      console.warn(`[Autumn] CORS detection failed, defaulting to false`);
+      return false;
+    } catch (error) {
+      console.error(`[Autumn] Error detecting CORS: ${error.message}`);
+      return false;
+    }
+  }
+  async getHeaders() {
+    let headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.getBearerToken) {
+      try {
+        const token = await this.getBearerToken();
+        headers.Authorization = `Bearer ${token}`;
+      } catch (_) {
+        console.error(`Failed to call getToken() in AutumnProvider`);
+      }
+    }
+    if (this.headers) {
+      headers = { ...headers, ...this.headers };
+    }
+    return headers;
+  }
+  async handleFetch({
+    path,
+    method,
+    body
+  }) {
+    body = method === "POST" ? {
+      ...body,
+      [this.camelCase ? "customerData" : "customer_data"]: this.customerData || void 0
+    } : void 0;
+    const includeCredentials = await this.shouldIncludeCredentials();
+    try {
+      const response = await fetch(`${this.backendUrl}${path}`, {
+        method,
+        body: body ? JSON.stringify(body) : void 0,
+        headers: await this.getHeaders(),
+        credentials: includeCredentials ? "include" : "omit",
+        cache: "no-store"
+      });
+      const loggedError = this.suppressLogs ? false : await logAuthError(response);
+      return await toContainerResult({
+        response,
+        logger: console,
+        logError: !this.suppressLogs && !loggedError
+      });
+    } catch (error) {
+      if (!this.suppressLogs) {
+        logFetchError({
+          method,
+          backendUrl: this.backendUrl || "",
+          path,
+          error
+        });
+      }
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error instanceof Error ? error.message : JSON.stringify(error),
+          code: "fetch_failed"
+        })
+      };
+    }
+  }
+  async post(path, body) {
+    return await this.handleFetch({
+      path,
+      method: "POST",
+      body
+    });
+  }
+  async get(path) {
+    return await this.handleFetch({
+      path,
+      method: "GET"
+    });
+  }
+  async delete(path) {
+    return await this.handleFetch({
+      path,
+      method: "DELETE"
+    });
+  }
+  async createCustomer(params) {
+    return await createCustomerMethod({
+      client: this,
+      params
+    });
+  }
+  attach = attachMethod.bind(this);
+  checkout = checkoutMethod.bind(this);
+  cancel = cancelMethod.bind(this);
+  check = checkMethod.bind(this);
+  track = trackMethod.bind(this);
+  openBillingPortal = openBillingPortalMethod.bind(this);
+  setupPayment = setupPaymentMethod.bind(this);
+  query = queryMethod.bind(this);
+  entities = {
+    create: createEntityMethod.bind(this),
+    get: getEntityMethod.bind(this),
+    delete: deleteEntityMethod.bind(this)
+  };
+  referrals = {
+    createCode: createCode.bind(this),
+    redeemCode: redeemCode.bind(this)
+  };
+  products = {
+    list: listProductsMethod.bind(this)
+  };
+  events = {
+    list: eventListMethod.bind(this),
+    aggregate: eventAggregateMethod.bind(this)
+  };
+};
+
+export {
+  AutumnClient
+};

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

@@ -0,0 +1,62 @@
+"use client";
+
+
+// src/libraries/react/components/pricing-table/lib/pricing-table-content.tsx
+import { jsx } from "react/jsx-runtime";
+var getPricingTableContent = (product) => {
+  const { scenario, free_trial, properties } = product;
+  const { is_one_off, updateable, has_trial } = properties;
+  if (has_trial) {
+    return {
+      buttonText: /* @__PURE__ */ jsx("p", { children: "Start Free Trial" })
+    };
+  }
+  switch (scenario) {
+    case "scheduled":
+      return {
+        buttonText: /* @__PURE__ */ jsx("p", { children: "Plan Scheduled" })
+      };
+    case "active":
+      if (updateable) {
+        return {
+          buttonText: /* @__PURE__ */ jsx("p", { children: "Update Plan" })
+        };
+      }
+      return {
+        buttonText: /* @__PURE__ */ jsx("p", { children: "Current Plan" })
+      };
+    case "new":
+      if (is_one_off) {
+        return {
+          buttonText: /* @__PURE__ */ jsx("p", { children: "Purchase" })
+        };
+      }
+      return {
+        buttonText: /* @__PURE__ */ jsx("p", { children: "Get started" })
+      };
+    case "renew":
+      return {
+        buttonText: /* @__PURE__ */ jsx("p", { children: "Renew" })
+      };
+    case "upgrade":
+      return {
+        buttonText: /* @__PURE__ */ jsx("p", { children: "Upgrade" })
+      };
+    case "downgrade":
+      return {
+        buttonText: /* @__PURE__ */ jsx("p", { children: "Downgrade" })
+      };
+    case "cancel":
+      return {
+        buttonText: /* @__PURE__ */ jsx("p", { children: "Cancel Plan" })
+      };
+    default:
+      return {
+        buttonText: /* @__PURE__ */ jsx("p", { children: "Get Started" })
+      };
+  }
+};
+
+export {
+  getPricingTableContent
+};

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

@@ -0,0 +1,12 @@
+"use client";
+
+
+// src/libraries/react/client/clientProdMethods.ts
+async function listProductsMethod() {
+  const res = await this.get(`${this.prefix}/products`);
+  return res;
+}
+
+export {
+  listProductsMethod
+};