@usethrottle/subscriptions 1.0.0

package/dist/index.cjs

@@ -0,0 +1,736 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.tsx
+var index_exports = {};
+__export(index_exports, {
+  DunningBanner: () => DunningBanner,
+  SubscriptionProvider: () => SubscriptionProvider,
+  SubscriptionProviderWithClient: () => SubscriptionProviderWithClient,
+  SubscriptionStatusBadge: () => SubscriptionStatusBadge,
+  SubscriptionsClient: () => SubscriptionsClient,
+  ThrottleSubscriptionsError: () => ThrottleSubscriptionsError,
+  TrialCountdown: () => TrialCountdown,
+  canCancelSubscription: () => canCancelSubscription,
+  canPauseSubscription: () => canPauseSubscription,
+  canResumeSubscription: () => canResumeSubscription,
+  createSubscriptionFetcher: () => createSubscriptionFetcher,
+  createSubscriptionsClient: () => createSubscriptionsClient,
+  daysUntil: () => daysUntil,
+  isSubscriptionPastDue: () => isSubscriptionPastDue,
+  isSubscriptionTrialing: () => isSubscriptionTrialing,
+  isTerminalSubscription: () => isTerminalSubscription,
+  useCancelSubscription: () => useCancelSubscription,
+  useChangePlan: () => useChangePlan,
+  useCreateCheckoutSession: () => useCreateCheckoutSession,
+  useCreateSubscription: () => useCreateSubscription,
+  useCustomerByExternalId: () => useCustomerByExternalId,
+  usePauseSubscription: () => usePauseSubscription,
+  useResumeSubscription: () => useResumeSubscription,
+  useSubscription: () => useSubscription,
+  useSubscriptionClient: () => useSubscriptionClient,
+  useSubscriptionInvalidation: () => useSubscriptionInvalidation,
+  useSubscriptions: () => useSubscriptions,
+  useTrialEligibility: () => useTrialEligibility,
+  useUpdateSubscription: () => useUpdateSubscription
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var ThrottleSubscriptionsError = class extends Error {
+  code;
+  statusCode;
+  details;
+  constructor(args) {
+    super(args.message);
+    this.name = "ThrottleSubscriptionsError";
+    this.code = args.code;
+    this.statusCode = args.statusCode;
+    this.details = args.details;
+  }
+};
+
+// src/normalize.ts
+function normalizeSubscription(raw) {
+  return {
+    id: requiredString(raw?.id, "subscription.id"),
+    merchantId: optionalString(raw?.merchantId ?? raw?.merchant_id),
+    storeId: optionalString(raw?.storeId ?? raw?.store_id),
+    customerId: requiredString(raw?.customerId ?? raw?.customer_id, "subscription.customerId"),
+    status: raw?.status ?? "active",
+    planReference: requiredString(
+      raw?.planReference ?? raw?.plan_reference,
+      "subscription.planReference"
+    ),
+    planName: optionalString(raw?.planName ?? raw?.plan_name),
+    interval: raw?.interval ?? "monthly",
+    amount: Number(raw?.amount ?? 0),
+    currency: optionalString(raw?.currency) ?? "USD",
+    currentPeriodStart: requiredDateString(
+      raw?.currentPeriodStart ?? raw?.current_period_start,
+      "subscription.currentPeriodStart"
+    ),
+    currentPeriodEnd: requiredDateString(
+      raw?.currentPeriodEnd ?? raw?.current_period_end,
+      "subscription.currentPeriodEnd"
+    ),
+    trialEnd: optionalDateString(raw?.trialEnd ?? raw?.trial_end),
+    cancelAtPeriodEnd: Boolean(raw?.cancelAtPeriodEnd ?? raw?.cancel_at_period_end ?? false),
+    failureCount: Number(raw?.failureCount ?? raw?.failure_count ?? 0),
+    lastPaymentAt: optionalDateString(raw?.lastPaymentAt ?? raw?.last_payment_at),
+    pausedAt: optionalDateString(raw?.pausedAt ?? raw?.paused_at),
+    cancelledAt: optionalDateString(raw?.cancelledAt ?? raw?.cancelled_at),
+    metadata: objectOrEmpty(raw?.metadata),
+    createdAt: optionalDateString(raw?.createdAt ?? raw?.created_at) ?? void 0,
+    updatedAt: optionalDateString(raw?.updatedAt ?? raw?.updated_at) ?? void 0
+  };
+}
+function normalizeCustomer(raw) {
+  if (!raw) return null;
+  return {
+    id: requiredString(raw?.id, "customer.id"),
+    externalId: optionalString(raw?.externalId ?? raw?.external_id),
+    email: optionalString(raw?.email),
+    firstName: optionalString(raw?.firstName ?? raw?.first_name),
+    lastName: optionalString(raw?.lastName ?? raw?.last_name),
+    phone: optionalString(raw?.phone),
+    metadata: objectOrEmpty(raw?.metadata),
+    createdAt: optionalDateString(raw?.createdAt ?? raw?.created_at) ?? void 0,
+    updatedAt: optionalDateString(raw?.updatedAt ?? raw?.updated_at) ?? void 0
+  };
+}
+function normalizeCheckoutSession(raw) {
+  const sessionId = raw?.sessionId ?? raw?.session_id ?? raw?.id;
+  return {
+    ...raw,
+    id: optionalString(raw?.id),
+    sessionId: requiredString(sessionId, "checkoutSession.sessionId"),
+    checkoutUrl: optionalString(raw?.checkoutUrl ?? raw?.checkout_url),
+    embedToken: optionalString(raw?.embedToken ?? raw?.embed_token),
+    expiresAt: optionalDateString(raw?.expiresAt ?? raw?.expires_at) ?? void 0
+  };
+}
+function normalizeTrialEligibility(raw) {
+  return {
+    eligible: Boolean(raw?.eligible),
+    reason: raw?.reason
+  };
+}
+function normalizePagination(raw) {
+  if (!raw) return void 0;
+  return {
+    cursor: raw.cursor ?? null,
+    hasMore: Boolean(raw.hasMore ?? raw.has_more ?? false)
+  };
+}
+function toIso(value) {
+  if (value === void 0) return void 0;
+  return value instanceof Date ? value.toISOString() : value;
+}
+function requiredString(value, label) {
+  if (typeof value === "string" && value.length > 0) return value;
+  throw new Error(`Invalid Throttle response: missing ${label}`);
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : null;
+}
+function requiredDateString(value, label) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" && value.length > 0) return value;
+  throw new Error(`Invalid Throttle response: missing ${label}`);
+}
+function optionalDateString(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" && value.length > 0) return value;
+  return null;
+}
+function objectOrEmpty(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+// src/client.ts
+var SubscriptionsClient = class {
+  apiKey;
+  baseUrl;
+  fetchImpl;
+  fetcher;
+  timeoutMs;
+  constructor(opts = {}) {
+    const fetchImpl = opts.fetch ?? globalThis.fetch;
+    if (!fetchImpl) throw new Error("SubscriptionsClient: fetch is required");
+    if (!opts.apiKey && !opts.fetcher) {
+      throw new Error("SubscriptionsClient: apiKey or fetcher is required");
+    }
+    this.apiKey = opts.apiKey;
+    this.baseUrl = (opts.baseUrl ?? "https://api.usethrottle.dev").replace(/\/+$/, "");
+    this.fetchImpl = fetchImpl;
+    this.fetcher = opts.fetcher;
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+  }
+  async request(method, path, body) {
+    const envelope = await this.requestEnvelope(method, path, body);
+    return envelope.data;
+  }
+  async requestEnvelope(method, path, body) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const init = {
+        method,
+        headers: {
+          "content-type": "application/json",
+          ...this.apiKey ? { "x-api-key": this.apiKey } : {}
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: ctrl.signal
+      };
+      const res = this.fetcher ? await this.fetcher(path, init) : await this.fetchImpl(toAbsoluteUrl(this.baseUrl, path), init);
+      if (res.status === 204) return { data: void 0 };
+      const json = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        throw new ThrottleSubscriptionsError({
+          code: json.error?.code ?? "unknown_error",
+          message: json.error?.message ?? `HTTP ${res.status}`,
+          statusCode: res.status,
+          details: json.error?.details
+        });
+      }
+      return json;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async create(input) {
+    const customerId = await this.resolveCustomerId(input.customerId, input.externalCustomerId);
+    const data = await this.request("POST", "/api/v1/subscriptions", {
+      storeId: input.storeId,
+      customerId,
+      planReference: input.planReference,
+      planName: input.planName,
+      interval: input.interval,
+      amount: input.amount,
+      currency: input.currency,
+      currentPeriodStart: toIso(input.currentPeriodStart),
+      currentPeriodEnd: toIso(input.currentPeriodEnd),
+      trialEnd: toIso(input.trialEnd),
+      metadata: input.metadata ?? {}
+    });
+    return normalizeSubscription(data);
+  }
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    setQuery(query, "customerId", params.customerId);
+    setQuery(query, "externalCustomerId", params.externalCustomerId);
+    setQuery(query, "status", params.status);
+    setQuery(query, "interval", params.interval);
+    setQuery(query, "q", params.q);
+    setQuery(query, "cursor", params.cursor);
+    setQuery(query, "limit", params.limit);
+    setQuery(query, "sort", params.sort);
+    setQuery(query, "createdAfter", toIso(params.createdAfter));
+    setQuery(query, "createdBefore", toIso(params.createdBefore));
+    const suffix = query.toString() ? `?${query}` : "";
+    const envelope = await this.requestEnvelope("GET", `/api/v1/subscriptions${suffix}`);
+    return {
+      data: (envelope.data ?? []).map(normalizeSubscription),
+      pagination: normalizePagination(envelope.meta?.pagination)
+    };
+  }
+  async get(id) {
+    const data = await this.request(
+      "GET",
+      `/api/v1/subscriptions/${encodeURIComponent(id)}`
+    );
+    return normalizeSubscription(data);
+  }
+  async update(id, input) {
+    const data = await this.request(
+      "PATCH",
+      `/api/v1/subscriptions/${encodeURIComponent(id)}`,
+      input
+    );
+    return normalizeSubscription(data);
+  }
+  changePlan(input) {
+    const { id, ...body } = input;
+    return this.update(id, body);
+  }
+  async pause(id) {
+    const data = await this.request(
+      "POST",
+      `/api/v1/subscriptions/${encodeURIComponent(id)}/pause`
+    );
+    return normalizeSubscription(data);
+  }
+  async resume(id) {
+    const data = await this.request(
+      "POST",
+      `/api/v1/subscriptions/${encodeURIComponent(id)}/resume`
+    );
+    return normalizeSubscription(data);
+  }
+  async cancel(id, input = {}) {
+    const data = await this.request(
+      "POST",
+      `/api/v1/subscriptions/${encodeURIComponent(id)}/cancel`,
+      { atPeriodEnd: input.atPeriodEnd ?? false }
+    );
+    return normalizeSubscription(data);
+  }
+  async createCheckoutSession(input) {
+    const data = await this.request("POST", "/api/v1/checkout/sessions", input);
+    return normalizeCheckoutSession(data);
+  }
+  async checkTrialEligibility(input) {
+    const data = await this.request("POST", "/api/v1/subscriptions/eligibility-check", {
+      payment_method_id: input.paymentMethodId
+    });
+    return normalizeTrialEligibility(data);
+  }
+  async getCustomerByExternalId(externalId) {
+    try {
+      const data = await this.request(
+        "GET",
+        `/api/v1/customers/by-external/${encodeURIComponent(externalId)}`
+      );
+      return normalizeCustomer(data);
+    } catch (err) {
+      if (err instanceof ThrottleSubscriptionsError && err.statusCode === 404) return null;
+      throw err;
+    }
+  }
+  async resolveCustomerId(customerId, externalCustomerId) {
+    if (customerId) return customerId;
+    if (!externalCustomerId) {
+      throw new ThrottleSubscriptionsError({
+        code: "invalid_request",
+        message: "customerId or externalCustomerId is required",
+        statusCode: 400
+      });
+    }
+    const customer = await this.getCustomerByExternalId(externalCustomerId);
+    if (!customer) {
+      throw new ThrottleSubscriptionsError({
+        code: "customer_not_found",
+        message: "Customer not found",
+        statusCode: 404
+      });
+    }
+    return customer.id;
+  }
+};
+function createSubscriptionsClient(opts) {
+  return new SubscriptionsClient(opts);
+}
+function toAbsoluteUrl(baseUrl, path) {
+  if (/^https?:\/\//i.test(path)) return path;
+  return `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+}
+function setQuery(query, key, value) {
+  if (value === void 0 || value === null || value === "") return;
+  query.set(key, String(value));
+}
+
+// src/provider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var SubscriptionContext = (0, import_react.createContext)(null);
+function SubscriptionProvider({
+  children,
+  client,
+  fetcher,
+  baseUrl,
+  timeoutMs
+}) {
+  const [cacheVersion, invalidate] = (0, import_react.useReducer)((value2) => value2 + 1, 0);
+  const resolvedClient = (0, import_react.useMemo)(() => {
+    if (client) return client;
+    return new SubscriptionsClient({
+      fetcher: fetcher ?? createSubscriptionFetcher("/api/throttle"),
+      baseUrl,
+      timeoutMs
+    });
+  }, [baseUrl, client, fetcher, timeoutMs]);
+  const value = (0, import_react.useMemo)(
+    () => ({ client: resolvedClient, cacheVersion, invalidate }),
+    [cacheVersion, resolvedClient]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SubscriptionContext.Provider, { value, children });
+}
+function useSubscriptionClient() {
+  return useSubscriptionContext().client;
+}
+function useSubscriptionInvalidation() {
+  return useSubscriptionContext().invalidate;
+}
+function useSubscriptionCacheVersion() {
+  return useSubscriptionContext().cacheVersion;
+}
+function createSubscriptionFetcher(basePath) {
+  const cleanBase = basePath.replace(/\/+$/, "");
+  return (path, init) => {
+    const cleanPath = path.startsWith("/") ? path : `/${path}`;
+    return fetch(`${cleanBase}${cleanPath}`, init);
+  };
+}
+function useSubscriptionContext() {
+  const ctx = (0, import_react.useContext)(SubscriptionContext);
+  if (!ctx) {
+    throw new Error(
+      "@usethrottle/subscriptions hooks must be used inside <SubscriptionProvider />"
+    );
+  }
+  return ctx;
+}
+function SubscriptionProviderWithClient({
+  children,
+  client
+}) {
+  const [cacheVersion, invalidate] = (0, import_react.useReducer)((value2) => value2 + 1, 0);
+  const value = (0, import_react.useMemo)(() => ({ client, cacheVersion, invalidate }), [cacheVersion, client]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SubscriptionContext.Provider, { value, children });
+}
+
+// src/hooks.ts
+var import_react2 = require("react");
+function useSubscriptions(params = {}, options = {}) {
+  const client = useSubscriptionClient();
+  const cacheVersion = useSubscriptionCacheVersion();
+  const stableParams = useStableValue(params);
+  return useAsyncQuery(
+    () => client.list(stableParams),
+    [client, stableParams, cacheVersion],
+    options
+  );
+}
+function useSubscription(id, options = {}) {
+  const client = useSubscriptionClient();
+  const cacheVersion = useSubscriptionCacheVersion();
+  return useAsyncQuery(
+    () => id ? client.get(id) : Promise.resolve(null),
+    [client, id, cacheVersion],
+    { ...options, enabled: options.enabled ?? Boolean(id) }
+  );
+}
+function useCustomerByExternalId(externalId, options = {}) {
+  const client = useSubscriptionClient();
+  const cacheVersion = useSubscriptionCacheVersion();
+  return useAsyncQuery(
+    () => externalId ? client.getCustomerByExternalId(externalId) : Promise.resolve(null),
+    [client, externalId, cacheVersion],
+    { ...options, enabled: options.enabled ?? Boolean(externalId) }
+  );
+}
+function useTrialEligibility() {
+  const client = useSubscriptionClient();
+  return useAsyncMutation((input) => client.checkTrialEligibility(input));
+}
+function useCreateSubscription() {
+  const client = useSubscriptionClient();
+  const invalidate = useSubscriptionInvalidation();
+  return useAsyncMutation((input) => client.create(input), invalidate);
+}
+function useUpdateSubscription() {
+  const client = useSubscriptionClient();
+  const invalidate = useSubscriptionInvalidation();
+  return useAsyncMutation(({ id, data }) => client.update(id, data), invalidate);
+}
+function useChangePlan() {
+  const client = useSubscriptionClient();
+  const invalidate = useSubscriptionInvalidation();
+  return useAsyncMutation((input) => client.changePlan(input), invalidate);
+}
+function useCancelSubscription() {
+  const client = useSubscriptionClient();
+  const invalidate = useSubscriptionInvalidation();
+  return useAsyncMutation(
+    (input) => client.cancel(input.id, { atPeriodEnd: input.atPeriodEnd }),
+    invalidate
+  );
+}
+function usePauseSubscription() {
+  const client = useSubscriptionClient();
+  const invalidate = useSubscriptionInvalidation();
+  return useAsyncMutation((input) => client.pause(input.id), invalidate);
+}
+function useResumeSubscription() {
+  const client = useSubscriptionClient();
+  const invalidate = useSubscriptionInvalidation();
+  return useAsyncMutation((input) => client.resume(input.id), invalidate);
+}
+function useCreateCheckoutSession() {
+  const client = useSubscriptionClient();
+  return useAsyncMutation((input) => client.createCheckoutSession(input));
+}
+function useAsyncQuery(load, deps, options) {
+  const enabled = options.enabled ?? true;
+  const [data, setData] = (0, import_react2.useState)(options.initialData ?? null);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(enabled && options.initialData === void 0);
+  const [isFetching, setIsFetching] = (0, import_react2.useState)(false);
+  const loadRef = (0, import_react2.useRef)(load);
+  loadRef.current = load;
+  const refetch = (0, import_react2.useCallback)(async () => {
+    if (!enabled) return data;
+    setIsFetching(true);
+    setError(null);
+    try {
+      const next = await loadRef.current();
+      setData(next);
+      return next;
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsFetching(false);
+      setIsLoading(false);
+    }
+  }, [data, enabled]);
+  (0, import_react2.useEffect)(() => {
+    if (!enabled) {
+      setIsLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setIsFetching(true);
+    setError(null);
+    load().then((next) => {
+      if (!cancelled) setData(next);
+    }).catch((err) => {
+      if (!cancelled) setError(err);
+    }).finally(() => {
+      if (!cancelled) {
+        setIsLoading(false);
+        setIsFetching(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, ...deps]);
+  return { data, error, isLoading, isFetching, refetch };
+}
+function useAsyncMutation(action, onSuccess) {
+  const [data, setData] = (0, import_react2.useState)(null);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [isPending, setIsPending] = (0, import_react2.useState)(false);
+  const mutateAsync = (0, import_react2.useCallback)(
+    async (variables) => {
+      setIsPending(true);
+      setError(null);
+      try {
+        const next = await action(variables);
+        setData(next);
+        onSuccess?.();
+        return next;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setIsPending(false);
+      }
+    },
+    [action, onSuccess]
+  );
+  const mutate = (0, import_react2.useCallback)(
+    (variables) => {
+      void mutateAsync(variables).catch(() => void 0);
+    },
+    [mutateAsync]
+  );
+  const reset = (0, import_react2.useCallback)(() => {
+    setData(null);
+    setError(null);
+    setIsPending(false);
+  }, []);
+  return { data, error, isPending, mutate, mutateAsync, reset };
+}
+function useStableValue(value) {
+  const key = JSON.stringify(value);
+  return (0, import_react2.useMemo)(() => value, [key]);
+}
+
+// src/helpers.ts
+function isTerminalSubscription(status) {
+  return getStatus(status) === "cancelled";
+}
+function canPauseSubscription(status) {
+  return getStatus(status) === "active";
+}
+function canResumeSubscription(status) {
+  return getStatus(status) === "paused";
+}
+function canCancelSubscription(status) {
+  return getStatus(status) !== "cancelled";
+}
+function isSubscriptionPastDue(status) {
+  return getStatus(status) === "past_due";
+}
+function isSubscriptionTrialing(status) {
+  return getStatus(status) === "trialing";
+}
+function daysUntil(date, now = /* @__PURE__ */ new Date()) {
+  const end = date instanceof Date ? date : new Date(date);
+  const ms = end.getTime() - now.getTime();
+  if (!Number.isFinite(ms)) return 0;
+  return Math.max(0, Math.ceil(ms / 864e5));
+}
+function getStatus(input) {
+  return typeof input === "string" ? input : input.status;
+}
+
+// src/components.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var STATUS_LABELS = {
+  active: "Active",
+  paused: "Paused",
+  cancelled: "Cancelled",
+  past_due: "Past due",
+  trialing: "Trialing"
+};
+var STATUS_STYLES = {
+  active: { color: "#035c4f", background: "#dff8ef", borderColor: "#a8e8d2" },
+  paused: { color: "#735c00", background: "#fff4ca", borderColor: "#f3d46b" },
+  cancelled: { color: "#6c2632", background: "#ffe1e7", borderColor: "#f4a9b8" },
+  past_due: { color: "#7a2d00", background: "#ffe8d6", borderColor: "#f5b47f" },
+  trialing: { color: "#124c73", background: "#dff1ff", borderColor: "#9ed3fb" }
+};
+function SubscriptionStatusBadge({
+  status,
+  className,
+  style,
+  labels
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "span",
+    {
+      className,
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        border: "1px solid",
+        borderRadius: 999,
+        padding: "2px 8px",
+        fontSize: 12,
+        fontWeight: 700,
+        lineHeight: 1.6,
+        whiteSpace: "nowrap",
+        ...STATUS_STYLES[status],
+        ...style
+      },
+      children: labels?.[status] ?? STATUS_LABELS[status]
+    }
+  );
+}
+function TrialCountdown({
+  endDate,
+  now,
+  className,
+  style,
+  expiredLabel = "Trial ended",
+  prefix = "Trial ends in"
+}) {
+  const days = daysUntil(endDate, now);
+  const label = days <= 0 ? expiredLabel : `${prefix} ${days} ${days === 1 ? "day" : "days"}`;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className, style, children: label });
+}
+function DunningBanner({
+  subscription,
+  onUpdateCard,
+  title = "Payment needs attention",
+  message,
+  actionLabel = "Update card",
+  className,
+  style
+}) {
+  if (subscription.status !== "past_due") return null;
+  const fallbackMessage = subscription.failureCount > 0 ? `We could not renew this subscription after ${subscription.failureCount} failed payment attempt${subscription.failureCount === 1 ? "" : "s"}.` : "We could not renew this subscription with the saved payment method.";
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+    "div",
+    {
+      role: "status",
+      className,
+      style: {
+        border: "1px solid #f5b47f",
+        borderRadius: 8,
+        background: "#fff7ed",
+        color: "#7a2d00",
+        padding: 16,
+        display: "grid",
+        gap: 10,
+        ...style
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("strong", { children: title }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: message ?? fallbackMessage }),
+        onUpdateCard ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "button",
+          {
+            type: "button",
+            onClick: onUpdateCard,
+            style: {
+              width: "fit-content",
+              border: "1px solid #7a2d00",
+              borderRadius: 6,
+              background: "#7a2d00",
+              color: "#fff",
+              padding: "8px 12px",
+              fontWeight: 700,
+              cursor: "pointer"
+            },
+            children: actionLabel
+          }
+        ) : null
+      ]
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DunningBanner,
+  SubscriptionProvider,
+  SubscriptionProviderWithClient,
+  SubscriptionStatusBadge,
+  SubscriptionsClient,
+  ThrottleSubscriptionsError,
+  TrialCountdown,
+  canCancelSubscription,
+  canPauseSubscription,
+  canResumeSubscription,
+  createSubscriptionFetcher,
+  createSubscriptionsClient,
+  daysUntil,
+  isSubscriptionPastDue,
+  isSubscriptionTrialing,
+  isTerminalSubscription,
+  useCancelSubscription,
+  useChangePlan,
+  useCreateCheckoutSession,
+  useCreateSubscription,
+  useCustomerByExternalId,
+  usePauseSubscription,
+  useResumeSubscription,
+  useSubscription,
+  useSubscriptionClient,
+  useSubscriptionInvalidation,
+  useSubscriptions,
+  useTrialEligibility,
+  useUpdateSubscription
+});
+//# sourceMappingURL=index.cjs.map