@lumnsh/react 0.1.1

package/dist/index.mjs

@@ -0,0 +1,661 @@
+// src/components/LumnProvider.tsx
+import { createContext, useContext, useMemo } from "react";
+import { Lumn } from "@lumnsh/node";
+import { jsx } from "react/jsx-runtime";
+var ENV_TO_INTERNAL = {
+  sandbox: "development",
+  live: "production"
+};
+var LumnContext = createContext(null);
+var THEME_VARS_DARK = {
+  ["--lumn-bg"]: "hsl(220 13% 8%)",
+  ["--lumn-bg-elevated"]: "hsl(220 13% 12%)",
+  ["--lumn-text"]: "hsl(0 0% 98%)",
+  ["--lumn-text-muted"]: "hsl(215 10% 75%)",
+  ["--lumn-border"]: "hsl(220 10% 18%)",
+  ["--lumn-border-light"]: "hsl(220 10% 15%)",
+  ["--lumn-error"]: "hsl(0 63% 50%)"
+};
+var THEME_VARS_LIGHT = {
+  ["--lumn-bg"]: "hsl(0 0% 98%)",
+  ["--lumn-bg-elevated"]: "hsl(0 0% 96%)",
+  ["--lumn-text"]: "hsl(220 13% 8%)",
+  ["--lumn-text-muted"]: "hsl(220 10% 45%)",
+  ["--lumn-border"]: "hsl(220 10% 85%)",
+  ["--lumn-border-light"]: "hsl(220 10% 75%)",
+  ["--lumn-error"]: "hsl(0 63% 45%)"
+};
+var DEFAULT_BASE_URL = "https://app.lumn.dev";
+var DEFAULT_ACCENT = "#22c55e";
+function LumnProvider({
+  apiKey,
+  baseUrl = DEFAULT_BASE_URL,
+  environment,
+  accentColor = DEFAULT_ACCENT,
+  theme = "dark",
+  children
+}) {
+  const lumn = useMemo(() => new Lumn({ apiKey, baseUrl }), [apiKey, baseUrl]);
+  const value = useMemo(
+    () => ({
+      lumn,
+      environment: environment ? ENV_TO_INTERNAL[environment] : void 0,
+      accentColor,
+      theme
+    }),
+    [lumn, environment, accentColor, theme]
+  );
+  const themeVars = theme === "light" ? THEME_VARS_LIGHT : THEME_VARS_DARK;
+  return /* @__PURE__ */ jsx(LumnContext.Provider, { value, children: /* @__PURE__ */ jsx("div", { style: themeVars, children }) });
+}
+function useLumnContext() {
+  const ctx = useContext(LumnContext);
+  if (!ctx) {
+    throw new Error("useLumnContext must be used within LumnProvider");
+  }
+  return ctx;
+}
+
+// src/components/LumnCheckout.tsx
+import { useState, useEffect, useMemo as useMemo2 } from "react";
+import { loadStripe } from "@stripe/stripe-js";
+import { EmbeddedCheckoutProvider, EmbeddedCheckout } from "@stripe/react-stripe-js";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var stripePromiseCache = /* @__PURE__ */ new Map();
+function getStripePromise(publishableKey) {
+  let p = stripePromiseCache.get(publishableKey);
+  if (!p) {
+    p = loadStripe(publishableKey);
+    stripePromiseCache.set(publishableKey, p);
+  }
+  return p;
+}
+function LumnCheckout({
+  customerId,
+  productSlug,
+  priceInterval = "monthly",
+  branding,
+  onComplete,
+  className = ""
+}) {
+  const { lumn } = useLumnContext();
+  const [session, setSession] = useState(null);
+  const [error, setError] = useState(null);
+  const brandingKey = JSON.stringify(branding ?? {});
+  useEffect(() => {
+    if (!customerId || !productSlug) return;
+    let cancelled = false;
+    setError(null);
+    setSession(null);
+    const returnUrl = typeof window !== "undefined" ? window.location.href : "";
+    const brandingPayload = branding && Object.keys(branding).length > 0 ? branding : void 0;
+    lumn.checkout.create({
+      customer_id: customerId,
+      product_slug: productSlug,
+      price_interval: priceInterval,
+      ui_mode: "embedded",
+      return_url: returnUrl,
+      ...brandingPayload && { branding_settings: brandingPayload }
+    }).then((d) => {
+      if (cancelled) return;
+      if (!d?.publishable_key) {
+        throw new Error("Missing publishable_key \u2014 configure a publishable key on your Stripe connection");
+      }
+      if (!d?.client_secret) {
+        throw new Error("Missing client_secret from checkout session");
+      }
+      setSession({
+        clientSecret: d.client_secret,
+        publishableKey: d.publishable_key
+      });
+    }).catch((e) => {
+      if (!cancelled) {
+        setError(e instanceof Error ? e.message : "Checkout failed");
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [lumn, customerId, productSlug, priceInterval, brandingKey]);
+  const stripePromise = session?.publishableKey ? getStripePromise(session.publishableKey) : null;
+  const fetchClientSecret = useMemo2(() => {
+    const secret = session?.clientSecret?.trim();
+    if (!secret) return void 0;
+    return () => Promise.resolve(secret);
+  }, [session?.clientSecret]);
+  if (!customerId || !productSlug) {
+    return /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className,
+        style: { color: "#ef4444", fontSize: "0.875rem" },
+        children: "customerId and productSlug are required"
+      }
+    );
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className,
+        style: { color: "#ef4444", fontSize: "0.875rem" },
+        children: error
+      }
+    );
+  }
+  if (!session || !stripePromise || !fetchClientSecret) {
+    return /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className,
+        style: { color: "#737373", fontSize: "0.875rem" },
+        children: "Loading checkout\u2026"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx2("div", { className, children: /* @__PURE__ */ jsx2(
+    EmbeddedCheckoutProvider,
+    {
+      stripe: stripePromise,
+      options: {
+        fetchClientSecret,
+        onComplete: onComplete ?? void 0
+      },
+      children: /* @__PURE__ */ jsx2(EmbeddedCheckout, {})
+    }
+  ) });
+}
+
+// src/components/LumnPricing.tsx
+import { useState as useState3, useCallback as useCallback2 } from "react";
+
+// src/hooks/usePricing.ts
+import { useState as useState2, useEffect as useEffect2, useCallback } from "react";
+function formatIntervalPrice(plan, _interval, options) {
+  const locale = options?.locale ?? "en-US";
+  const opts = { style: "currency", currency: plan.currency || "usd" };
+  if (plan.tiers && plan.tiers.length > 0) {
+    const first = plan.tiers[0];
+    const amt = first?.unitAmount ?? 0;
+    if (amt === 0) return "From Free";
+    return `From ${(amt / 100).toLocaleString(locale, opts)}`;
+  }
+  if (plan.amount != null) {
+    if (plan.amount === 0) return "Free";
+    return (plan.amount / 100).toLocaleString(locale, opts);
+  }
+  return "Custom";
+}
+function usePricing(options) {
+  const { lumn } = useLumnContext();
+  const [products, setProducts] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(!options?.skip);
+  const [error, setError] = useState2(null);
+  const fetchProducts = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await lumn.products.list({ limit: 50, active: true });
+      setProducts(result.data ?? []);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error("Failed to fetch products"));
+      setProducts([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [lumn]);
+  useEffect2(() => {
+    if (options?.skip) return;
+    fetchProducts();
+  }, [fetchProducts, options?.skip]);
+  return { products, isLoading: options?.skip ? false : isLoading, error: options?.skip ? null : error, refetch: fetchProducts };
+}
+
+// src/components/IntervalSwitcher.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function IntervalSwitcher({
+  intervals,
+  selected,
+  onSelect,
+  accentColor = "#22c55e"
+}) {
+  if (intervals.length <= 1) return null;
+  return /* @__PURE__ */ jsx3("div", { style: { marginBottom: "1rem", display: "flex", gap: "0.5rem" }, children: intervals.map((iv) => /* @__PURE__ */ jsx3(
+    "button",
+    {
+      type: "button",
+      onClick: () => onSelect(iv),
+      style: {
+        padding: "0.375rem 0.75rem",
+        fontSize: "0.875rem",
+        fontFamily: "Inter, system-ui, sans-serif",
+        border: selected === iv ? `1px solid ${accentColor}` : "1px solid var(--lumn-border-light, hsl(220 10% 15%))",
+        borderRadius: "0.5rem",
+        background: selected === iv ? `${accentColor}1a` : "var(--lumn-bg-elevated, hsl(220 13% 12%))",
+        color: selected === iv ? accentColor : "var(--lumn-text, hsl(0 0% 98%))",
+        cursor: "pointer"
+      },
+      children: iv.charAt(0).toUpperCase() + iv.slice(1)
+    },
+    iv
+  )) });
+}
+
+// src/components/PricingCard.tsx
+import { Fragment, jsx as jsx4, jsxs } from "react/jsx-runtime";
+function formatTierRange(tierIndex, tiers) {
+  const tier = tiers[tierIndex];
+  const prevUpTo = tierIndex === 0 ? 0 : tiers[tierIndex - 1].upTo ?? 0;
+  if (tier.upTo === null) return `${prevUpTo + 1}+`;
+  if (prevUpTo === 0) return `1\u2013${tier.upTo}`;
+  return `${prevUpTo + 1}\u2013${tier.upTo}`;
+}
+function PricingCard({
+  product,
+  priceInterval,
+  plan,
+  priceStr,
+  period,
+  trialDays,
+  isCheckoutLoading,
+  checkoutError,
+  cardStyle,
+  accentColor,
+  locale,
+  canSubscribe,
+  onCtaClick
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        background: "var(--lumn-bg, hsl(220 13% 8%))",
+        border: `1px solid ${cardStyle.borderColor}`,
+        borderRadius: "0.5rem",
+        padding: "1.5rem",
+        display: "flex",
+        flexDirection: "column",
+        boxShadow: "0 0 20px hsl(90 100% 50% / 0.05)"
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ jsx4("div", { style: { fontWeight: 600, fontSize: "1.125rem", color: "var(--lumn-text, hsl(0 0% 98%))" }, children: product.name }),
+          /* @__PURE__ */ jsx4(
+            "span",
+            {
+              style: {
+                fontSize: "0.65rem",
+                fontWeight: 600,
+                textTransform: "uppercase",
+                letterSpacing: "0.05em",
+                padding: "0.2rem 0.5rem",
+                borderRadius: "0.25rem",
+                background: cardStyle.badgeBg,
+                color: cardStyle.badgeColor
+              },
+              children: product.type ?? "recurring"
+            }
+          )
+        ] }),
+        product.description && /* @__PURE__ */ jsx4("div", { style: { marginBottom: "1rem", fontSize: "0.875rem", color: "var(--lumn-text-muted, hsl(215 10% 75%))" }, children: product.description }),
+        /* @__PURE__ */ jsxs("div", { style: { marginTop: "auto", display: "flex", flexDirection: "column", gap: "0.5rem" }, children: [
+          /* @__PURE__ */ jsxs("div", { style: { fontSize: "1.5rem", fontWeight: 600, color: "var(--lumn-text, hsl(0 0% 98%))" }, children: [
+            priceStr,
+            period && /* @__PURE__ */ jsx4("span", { style: { fontSize: "0.875rem", fontWeight: 400, color: "var(--lumn-text-muted, hsl(215 10% 75%))" }, children: period })
+          ] }),
+          plan?.tiers && plan.tiers.length > 0 && /* @__PURE__ */ jsxs(
+            "div",
+            {
+              style: {
+                marginTop: "0.25rem",
+                padding: "0.5rem 0.75rem",
+                borderRadius: "0.375rem",
+                background: "var(--lumn-bg-elevated, hsl(220 13% 12%))",
+                border: "1px solid var(--lumn-border, hsl(220 10% 18%))"
+              },
+              children: [
+                /* @__PURE__ */ jsx4("div", { style: { fontSize: "0.65rem", fontWeight: 600, textTransform: "uppercase", letterSpacing: "0.04em", color: "var(--lumn-text-muted, hsl(215 10% 65%))", marginBottom: "0.375rem" }, children: "Tiers" }),
+                /* @__PURE__ */ jsx4("div", { style: { display: "flex", flexDirection: "column", gap: 0 }, children: plan.tiers.map((tier, i) => {
+                  const range = formatTierRange(i, plan.tiers);
+                  const currency = plan.currency ?? "usd";
+                  const isFree = tier.unitAmount === 0;
+                  const perUnit = isFree ? "Free" : (tier.unitAmount / 100).toLocaleString(locale ?? "en-US", { style: "currency", currency });
+                  return /* @__PURE__ */ jsxs(
+                    "div",
+                    {
+                      style: {
+                        display: "flex",
+                        justifyContent: "space-between",
+                        alignItems: "center",
+                        padding: "0.25rem 0",
+                        fontSize: "0.8125rem",
+                        color: "var(--lumn-text-muted, hsl(215 10% 75%))",
+                        borderBottom: i < plan.tiers.length - 1 ? "1px solid var(--lumn-border, hsl(220 10% 18%))" : "none"
+                      },
+                      children: [
+                        /* @__PURE__ */ jsx4("span", { style: { fontFamily: "JetBrains Mono, monospace" }, children: range }),
+                        /* @__PURE__ */ jsxs("span", { style: { fontWeight: 500, color: "var(--lumn-text, hsl(0 0% 92%))" }, children: [
+                          perUnit,
+                          !isFree && /* @__PURE__ */ jsx4("span", { style: { fontWeight: 400, color: "var(--lumn-text-muted, hsl(215 10% 65%))", fontSize: "0.75rem" }, children: "/unit" })
+                        ] })
+                      ]
+                    },
+                    i
+                  );
+                }) })
+              ]
+            }
+          ),
+          trialDays != null && trialDays > 0 && /* @__PURE__ */ jsxs("div", { style: { fontSize: "0.75rem", color: accentColor }, children: [
+            trialDays,
+            "-day free trial"
+          ] }),
+          canSubscribe ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx4(
+              "button",
+              {
+                type: "button",
+                onClick: () => priceInterval && onCtaClick(product, priceInterval),
+                disabled: !!isCheckoutLoading || !priceInterval,
+                style: {
+                  padding: "0.5rem 1rem",
+                  fontSize: "0.875rem",
+                  fontWeight: 500,
+                  fontFamily: "Inter, system-ui, sans-serif",
+                  border: `1px solid ${accentColor}`,
+                  borderRadius: "0.5rem",
+                  background: `${accentColor}1a`,
+                  color: accentColor,
+                  cursor: isCheckoutLoading ? "wait" : "pointer"
+                },
+                children: isCheckoutLoading ? "Loading\u2026" : "Subscribe"
+              }
+            ),
+            checkoutError && /* @__PURE__ */ jsx4("div", { style: { fontSize: "0.75rem", color: "var(--lumn-error, hsl(0 63% 50%))" }, children: checkoutError })
+          ] }) : /* @__PURE__ */ jsx4("div", { style: { fontSize: "0.75rem", color: "var(--lumn-text-muted, hsl(215 10% 75%))" }, children: "Sign in to subscribe" })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/LumnPricing.tsx
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var DEFAULT_INTERVALS = ["monthly", "yearly"];
+var intervalPeriod = {
+  monthly: "/month",
+  quarterly: "/quarter",
+  yearly: "/year"
+};
+var CARD_STYLE_BY_TYPE = {
+  recurring: { borderColor: "hsl(90 100% 50% / 0.5)", badgeBg: "hsl(90 100% 50% / 0.15)", badgeColor: "hsl(90 100% 55%)" },
+  one_time: { borderColor: "hsl(199 89% 48% / 0.5)", badgeBg: "hsl(199 89% 48% / 0.15)", badgeColor: "hsl(199 89% 55%)" },
+  usage_based: { borderColor: "hsl(45 93% 47% / 0.5)", badgeBg: "hsl(45 93% 47% / 0.15)", badgeColor: "hsl(45 93% 55%)" },
+  seat_based: { borderColor: "hsl(280 65% 60% / 0.5)", badgeBg: "hsl(280 65% 60% / 0.15)", badgeColor: "hsl(280 65% 70%)" },
+  tiered: { borderColor: "hsl(340 75% 55% / 0.5)", badgeBg: "hsl(340 75% 55% / 0.15)", badgeColor: "hsl(340 75% 65%)" }
+};
+function getCardStyle(type) {
+  const key = type ?? "recurring";
+  return CARD_STYLE_BY_TYPE[key] ?? CARD_STYLE_BY_TYPE.recurring;
+}
+function getPriceInterval(product, selectedInterval, intervals) {
+  const idx = intervals.indexOf(selectedInterval);
+  if (idx === -1) return void 0;
+  for (let i = idx; i >= 0; i--) {
+    const iv = intervals[i];
+    if (product.pricing?.[iv]) return iv;
+  }
+  return void 0;
+}
+function LumnPricing({
+  customerId,
+  products: productsProp,
+  intervals = DEFAULT_INTERVALS,
+  defaultInterval = "monthly",
+  locale,
+  onSelectPlan,
+  renderCard,
+  formatPrice,
+  loadingComponent,
+  emptyComponent,
+  errorComponent,
+  className = ""
+}) {
+  const { lumn, accentColor = "#22c55e" } = useLumnContext();
+  const priceFormatter = formatPrice ?? ((plan, interval) => formatIntervalPrice(plan, interval, locale ? { locale } : void 0));
+  const { products: fetchedProducts, isLoading, error } = usePricing({ skip: productsProp !== void 0 });
+  const products = productsProp ?? fetchedProducts;
+  const [selectedInterval, setSelectedInterval] = useState3(defaultInterval);
+  const [checkoutLoading, setCheckoutLoading] = useState3(null);
+  const [checkoutErrorBySlug, setCheckoutErrorBySlug] = useState3({});
+  const createCheckout = useCallback2(
+    async (productSlug, priceInterval) => {
+      if (!customerId) return;
+      const fallbackUrl = typeof window !== "undefined" ? window.location.href : "";
+      const session = await lumn.checkout.create({
+        customer_id: customerId,
+        product_slug: productSlug,
+        price_interval: priceInterval,
+        ui_mode: "hosted",
+        success_url: fallbackUrl,
+        cancel_url: fallbackUrl
+      });
+      const checkoutUrl = session?.checkout_url;
+      if (checkoutUrl && typeof window !== "undefined") {
+        window.location.href = checkoutUrl;
+      }
+    },
+    [lumn, customerId]
+  );
+  const handleCtaClick = useCallback2(
+    async (product, interval) => {
+      if (!customerId) return;
+      const plan = product.pricing?.[interval];
+      if (!plan) return;
+      const checkout = () => {
+        setCheckoutLoading(product.slug);
+        setCheckoutErrorBySlug((prev) => ({ ...prev, [product.slug]: "" }));
+        createCheckout(product.slug, interval).catch((err) => {
+          const msg = err instanceof Error ? err.message : "Checkout failed";
+          setCheckoutErrorBySlug((prev) => ({ ...prev, [product.slug]: msg }));
+        }).finally(() => setCheckoutLoading(null));
+      };
+      if (onSelectPlan) {
+        onSelectPlan({ product, interval, checkout });
+      } else {
+        checkout();
+      }
+    },
+    [customerId, createCheckout, onSelectPlan]
+  );
+  const filteredProducts = products.filter((p) => p.active);
+  const effectiveInterval = intervals.includes(selectedInterval) ? selectedInterval : intervals[0];
+  if (isLoading && !productsProp?.length) {
+    if (loadingComponent) return /* @__PURE__ */ jsx5("div", { className, children: loadingComponent });
+    return /* @__PURE__ */ jsx5("div", { className, style: { padding: "1.5rem", color: "var(--lumn-text-muted, hsl(215 10% 75%))", fontSize: "0.875rem", fontFamily: "Inter, system-ui, sans-serif" }, children: "Loading\u2026" });
+  }
+  if (error && !productsProp?.length) {
+    if (errorComponent) return /* @__PURE__ */ jsx5("div", { className, children: errorComponent(error) });
+    return /* @__PURE__ */ jsx5("div", { className, style: { padding: "1.5rem", color: "var(--lumn-error, hsl(0 63% 50%))", fontSize: "0.875rem", fontFamily: "Inter, system-ui, sans-serif" }, children: error?.message ?? "Failed to load products" });
+  }
+  if (filteredProducts.length === 0) {
+    if (emptyComponent) return /* @__PURE__ */ jsx5("div", { className, children: emptyComponent });
+    return /* @__PURE__ */ jsx5("div", { className, style: { padding: "1.5rem", color: "var(--lumn-text-muted, hsl(215 10% 75%))", fontSize: "0.875rem", fontFamily: "Inter, system-ui, sans-serif" }, children: "No products available." });
+  }
+  if (renderCard) {
+    return /* @__PURE__ */ jsxs2("div", { className, children: [
+      /* @__PURE__ */ jsx5(
+        IntervalSwitcher,
+        {
+          intervals,
+          selected: selectedInterval,
+          onSelect: setSelectedInterval,
+          accentColor
+        }
+      ),
+      /* @__PURE__ */ jsx5("div", { style: { display: "grid", gridTemplateColumns: "repeat(auto-fill, minmax(280px, 1fr))", gap: "1.5rem" }, children: filteredProducts.map((p) => renderCard(p, effectiveInterval)) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2("div", { className, style: { fontFamily: "Inter, system-ui, sans-serif" }, children: [
+    /* @__PURE__ */ jsx5(
+      IntervalSwitcher,
+      {
+        intervals,
+        selected: selectedInterval,
+        onSelect: setSelectedInterval,
+        accentColor
+      }
+    ),
+    /* @__PURE__ */ jsx5("div", { style: { display: "grid", gridTemplateColumns: "repeat(auto-fill, minmax(280px, 1fr))", gap: "1.5rem" }, children: filteredProducts.map((product) => {
+      const priceInterval = getPriceInterval(product, effectiveInterval, intervals);
+      const plan = priceInterval ? product.pricing?.[priceInterval] : void 0;
+      const priceStr = plan && priceInterval ? priceFormatter(plan, priceInterval) : "Custom";
+      const period = priceInterval ? intervalPeriod[priceInterval] : "";
+      const trialDays = product.pricing?.trial?.days;
+      const isCheckoutLoading = checkoutLoading === product.slug;
+      const checkoutError = checkoutErrorBySlug[product.slug];
+      const cardStyle = getCardStyle(product.type);
+      return /* @__PURE__ */ jsx5(
+        PricingCard,
+        {
+          product,
+          priceInterval,
+          plan,
+          priceStr,
+          period,
+          trialDays,
+          isCheckoutLoading: !!isCheckoutLoading,
+          checkoutError,
+          cardStyle,
+          accentColor,
+          locale,
+          canSubscribe: !!customerId,
+          onCtaClick: handleCtaClick
+        },
+        product.id
+      );
+    }) })
+  ] });
+}
+
+// src/components/LumnGate.tsx
+import { useState as useState4, useEffect as useEffect3 } from "react";
+
+// src/hooks/useEntitlements.ts
+import { useCallback as useCallback3 } from "react";
+function useEntitlements() {
+  const { lumn } = useLumnContext();
+  const checkEntitlement = useCallback3(
+    async (featureKey, customerId) => {
+      if (!customerId) {
+        return { entitled: false, feature_key: featureKey };
+      }
+      return lumn.entitlements.check({
+        customer_id: customerId,
+        feature_key: featureKey
+      });
+    },
+    [lumn]
+  );
+  const getUsageBalance = useCallback3(
+    async (featureKey, customerId) => {
+      const result = await checkEntitlement(featureKey, customerId);
+      return {
+        entitled: result.entitled,
+        feature_key: result.feature_key,
+        limit: result.limit,
+        unit_price_cents: result.unit_price_cents,
+        feature_type: result.feature_type,
+        used: result.used,
+        remaining: result.remaining,
+        reset_at: result.reset_at
+      };
+    },
+    [checkEntitlement]
+  );
+  return {
+    checkEntitlement,
+    getUsageBalance
+  };
+}
+
+// src/components/LumnGate.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function LumnGate({
+  feature,
+  customerId,
+  fallback = null,
+  loadingFallback,
+  renderUsage,
+  children
+}) {
+  const { checkEntitlement } = useEntitlements();
+  const [result, setResult] = useState4(null);
+  useEffect3(() => {
+    let cancelled = false;
+    setResult(null);
+    checkEntitlement(feature, customerId).then((res) => {
+      if (cancelled) return;
+      setResult(res);
+    }).catch(() => {
+      if (cancelled) return;
+      setResult({ entitled: false, feature_key: feature });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [feature, customerId, checkEntitlement]);
+  if (result === null) {
+    return loadingFallback ?? null;
+  }
+  const entitled = result.entitled;
+  const hasRemaining = result.remaining === void 0 || result.remaining === null || result.remaining > 0;
+  const allowed = entitled && hasRemaining;
+  const usageData = result.used != null && result.remaining != null && result.reset_at != null ? { used: result.used, remaining: result.remaining, reset_at: result.reset_at } : null;
+  return /* @__PURE__ */ jsxs3(Fragment2, { children: [
+    renderUsage && usageData ? renderUsage(usageData) : null,
+    allowed ? /* @__PURE__ */ jsx6(Fragment2, { children }) : /* @__PURE__ */ jsx6(Fragment2, { children: fallback })
+  ] });
+}
+
+// src/hooks/useSubscriptions.ts
+import { useCallback as useCallback4 } from "react";
+function useSubscriptions() {
+  const { lumn } = useLumnContext();
+  const getSubscriptionState = useCallback4(
+    async (customerId, productId) => {
+      const result = await lumn.subscriptions.list({
+        customer_id: customerId,
+        ...productId && { product_id: productId }
+      });
+      return result.data;
+    },
+    [lumn]
+  );
+  return {
+    getSubscriptionState
+  };
+}
+
+// src/hooks/useLumn.ts
+function useLumn() {
+  const { checkEntitlement, getUsageBalance } = useEntitlements();
+  const { getSubscriptionState } = useSubscriptions();
+  return {
+    checkEntitlement,
+    getUsageBalance,
+    getSubscriptionState
+  };
+}
+export {
+  LumnCheckout,
+  LumnGate,
+  LumnPricing,
+  LumnProvider,
+  formatIntervalPrice,
+  useEntitlements,
+  useLumn,
+  useLumnContext,
+  usePricing,
+  useSubscriptions
+};