@foldspace-fe/casdoor-next-auth-kit 0.1.1

package/dist/react/index.js

@@ -0,0 +1,774 @@
+import {
+  buildBillingActionPayload,
+  deriveBillingCreditsState,
+  deriveBillingEntitlements,
+  filterProductsByKind,
+  normalizeBillingCatalogConfig,
+  normalizeBillingPurchaseStatus,
+  normalizeBillingRuntimeConfig,
+  resolveBillingItem,
+  resolveBillingProductSnapshot,
+  resolveBillingSubscriptionProduct
+} from "../chunk-RGTVPBH7.js";
+import {
+  buildAuthJumpHref
+} from "../chunk-T2M5MVPE.js";
+
+// src/react/provider.tsx
+import { SessionProvider } from "next-auth/react";
+import { jsx } from "react/jsx-runtime";
+function AuthProvider({
+  children,
+  session
+}) {
+  return /* @__PURE__ */ jsx(SessionProvider, { session, children });
+}
+
+// src/react/hooks.ts
+import { useSession } from "next-auth/react";
+function getUserSummary(session) {
+  const user = session?.user;
+  const name = user?.name || "\u767B\u5F55";
+  const isAuthenticated = Boolean(user);
+  const isAdmin = Boolean(user?.isAdmin);
+  const role = !isAuthenticated ? "guest" : isAdmin ? "admin" : "user";
+  return {
+    id: user?.id ?? null,
+    name,
+    email: user?.email ?? null,
+    image: user?.image ?? null,
+    isAuthenticated,
+    isAdmin,
+    tokenBalance: Number(user?.tokenBalance ?? 2580),
+    isVip: Boolean(user?.isVip ?? true),
+    role
+  };
+}
+function useAuthSession() {
+  return useSession();
+}
+function useAuthUser() {
+  const { data: session } = useAuthSession();
+  return getUserSummary(session ?? null);
+}
+function useAuthRole() {
+  return useAuthUser().role;
+}
+function useAuthActions(options = {}) {
+  const user = useAuthUser();
+  const redirect = options.redirect ?? null;
+  return {
+    loginHref: buildAuthJumpHref("login", redirect ?? void 0),
+    signupHref: buildAuthJumpHref("signup", redirect ?? void 0),
+    logoutHref: "/logout",
+    accountHref: user.isAdmin ? "/admin" : "/user/account",
+    adminHref: "/admin"
+  };
+}
+
+// src/billing/react.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var BillingCoreContext = createContext(null);
+var BillingSubscriptionContext = createContext(null);
+var BillingProductContext = createContext(null);
+var BillingCreditsContext = createContext(null);
+function useOptionalContext(context) {
+  return useContext(context);
+}
+function useRequiredCoreContext() {
+  const context = useContext(BillingCoreContext);
+  if (!context) {
+    throw new Error("Billing hooks must be used inside BillingProvider or BillingCoreProvider.");
+  }
+  return context;
+}
+function choose(primary, fallback) {
+  return primary ?? fallback;
+}
+function getLatestOrder(orders) {
+  return [...orders ?? []].sort((a, b) => {
+    const left = Date.parse(b.updatedAt ?? b.createdAt ?? "") || 0;
+    const right = Date.parse(a.updatedAt ?? a.createdAt ?? "") || 0;
+    return left - right;
+  })[0];
+}
+function getLatestPayment(payments) {
+  return [...payments ?? []].sort((a, b) => {
+    const left = Date.parse(b.updatedAt ?? b.createdAt ?? "") || 0;
+    const right = Date.parse(a.updatedAt ?? a.createdAt ?? "") || 0;
+    return left - right;
+  })[0];
+}
+function normalizeRuntimeConfigInput(config) {
+  if (!config) return void 0;
+  return normalizeBillingRuntimeConfig(config);
+}
+function normalizeCatalogConfigInput(config) {
+  if (!config) return void 0;
+  return normalizeBillingCatalogConfig(config);
+}
+function buildCoreValue(input) {
+  return {
+    apiClient: input.apiClient,
+    loaders: input.loaders,
+    runtimeConfigLoader: input.runtimeConfigLoader,
+    actionExecutor: input.actionExecutor,
+    defaults: input.defaults,
+    runtimeConfig: input.runtimeConfig,
+    runtimeCatalog: input.runtimeCatalog,
+    runtimeConfigLoading: input.runtimeConfigLoading,
+    runtimeConfigError: input.runtimeConfigError,
+    subscription: input.subscription,
+    subscriptionHistory: input.subscriptionHistory,
+    products: input.products,
+    orderHistory: input.orderHistory,
+    paymentHistory: input.paymentHistory,
+    credits: input.credits,
+    entitlements: input.entitlements,
+    purchaseStatus: input.purchaseStatus,
+    status: input.status,
+    refresh: input.refresh,
+    runAction: input.runAction,
+    setRuntimeConfig: input.setRuntimeConfig,
+    setSubscription: input.setSubscription,
+    setSubscriptionHistory: input.setSubscriptionHistory,
+    setProducts: input.setProducts,
+    setOrderHistory: input.setOrderHistory,
+    setPaymentHistory: input.setPaymentHistory,
+    setCredits: input.setCredits,
+    setEntitlements: input.setEntitlements,
+    setPurchaseStatus: input.setPurchaseStatus,
+    setStatus: input.setStatus
+  };
+}
+function BillingProvider({
+  children,
+  apiClient,
+  loaders,
+  runtimeConfigLoader,
+  actionExecutor,
+  defaults,
+  runtimeConfig: runtimeConfigProp,
+  subscription: subscriptionProp,
+  subscriptionHistory: subscriptionHistoryProp,
+  products: productsProp,
+  orderHistory: orderHistoryProp,
+  paymentHistory: paymentHistoryProp,
+  credits: creditsProp,
+  entitlements: entitlementsProp,
+  status: statusProp,
+  purchaseStatus: purchaseStatusProp,
+  autoRefresh = true
+}) {
+  const [runtimeConfig, setRuntimeConfig] = useState(normalizeRuntimeConfigInput(runtimeConfigProp));
+  const [runtimeCatalog, setRuntimeCatalog] = useState(normalizeCatalogConfigInput(runtimeConfigProp));
+  const [runtimeConfigLoading, setRuntimeConfigLoading] = useState(false);
+  const [runtimeConfigError, setRuntimeConfigError] = useState(null);
+  const [subscription, setSubscription] = useState(subscriptionProp);
+  const [subscriptionHistory, setSubscriptionHistory] = useState(subscriptionHistoryProp);
+  const [products, setProducts] = useState(productsProp);
+  const [orderHistory, setOrderHistory] = useState(orderHistoryProp);
+  const [paymentHistory, setPaymentHistory] = useState(paymentHistoryProp);
+  const [credits, setCredits] = useState(creditsProp);
+  const [entitlements, setEntitlements] = useState(entitlementsProp);
+  const [purchaseStatus, setPurchaseStatus] = useState(purchaseStatusProp);
+  const [status, setStatus] = useState(
+    statusProp ?? { loading: false, refreshing: false, error: null }
+  );
+  useEffect(() => {
+    if (runtimeConfigProp) {
+      setRuntimeConfig(normalizeRuntimeConfigInput(runtimeConfigProp));
+      setRuntimeCatalog(normalizeCatalogConfigInput(runtimeConfigProp));
+    }
+  }, [runtimeConfigProp]);
+  useEffect(() => {
+    if (subscriptionProp) setSubscription(subscriptionProp);
+  }, [subscriptionProp]);
+  useEffect(() => {
+    if (subscriptionHistoryProp) setSubscriptionHistory(subscriptionHistoryProp);
+  }, [subscriptionHistoryProp]);
+  useEffect(() => {
+    if (productsProp) setProducts(productsProp);
+  }, [productsProp]);
+  useEffect(() => {
+    if (orderHistoryProp) setOrderHistory(orderHistoryProp);
+  }, [orderHistoryProp]);
+  useEffect(() => {
+    if (paymentHistoryProp) setPaymentHistory(paymentHistoryProp);
+  }, [paymentHistoryProp]);
+  useEffect(() => {
+    if (creditsProp) setCredits(creditsProp);
+  }, [creditsProp]);
+  useEffect(() => {
+    if (entitlementsProp) setEntitlements(entitlementsProp);
+  }, [entitlementsProp]);
+  useEffect(() => {
+    if (purchaseStatusProp) setPurchaseStatus(purchaseStatusProp);
+  }, [purchaseStatusProp]);
+  useEffect(() => {
+    if (statusProp) setStatus(statusProp);
+  }, [statusProp]);
+  const refresh = useCallback(async () => {
+    const catalogKey = runtimeCatalog?.catalogKey ?? runtimeConfig?.catalogKey ?? "default";
+    const runtimeLoader = runtimeConfigLoader ?? apiClient.fetchRuntimeConfig;
+    const resolvedLoaders = loaders ?? {};
+    const subscriptionLoader = resolvedLoaders.subscriptionLoader ?? apiClient.fetchSubscription;
+    const subscriptionHistoryLoader = resolvedLoaders.subscriptionHistoryLoader ?? apiClient.fetchSubscriptionHistory;
+    const productsLoader = resolvedLoaders.productsLoader ?? apiClient.fetchProducts;
+    const orderHistoryLoader = resolvedLoaders.orderHistoryLoader ?? apiClient.fetchOrderHistory;
+    const paymentHistoryLoader = resolvedLoaders.paymentHistoryLoader ?? apiClient.fetchPaymentHistory;
+    const purchaseStatusLoader = resolvedLoaders.purchaseStatusLoader ?? apiClient.fetchPurchaseStatus;
+    const creditsLoader = resolvedLoaders.creditsLoader ?? apiClient.fetchCredits;
+    const entitlementsLoader = resolvedLoaders.entitlementsLoader ?? apiClient.fetchEntitlements;
+    setRuntimeConfigLoading(true);
+    setRuntimeConfigError(null);
+    setStatus((current) => ({ ...current, loading: true, refreshing: true, error: null }));
+    try {
+      const nextRuntimeCatalog = normalizeCatalogConfigInput(await runtimeLoader(catalogKey));
+      const nextRuntimeConfig = nextRuntimeCatalog ? normalizeRuntimeConfigInput(nextRuntimeCatalog) : void 0;
+      if (nextRuntimeConfig) {
+        setRuntimeCatalog(nextRuntimeCatalog);
+        setRuntimeConfig(nextRuntimeConfig);
+      }
+      const nextCatalogKey = nextRuntimeConfig?.catalogKey ?? nextRuntimeCatalog?.catalogKey ?? catalogKey;
+      const [
+        nextSubscription,
+        nextSubscriptionHistory,
+        nextProducts,
+        nextOrderHistory,
+        nextPaymentHistory,
+        nextCredits,
+        nextEntitlements
+      ] = await Promise.all([
+        subscriptionLoader({ catalogKey: nextCatalogKey }),
+        subscriptionHistoryLoader({ catalogKey: nextCatalogKey }),
+        productsLoader({ catalogKey: nextCatalogKey }),
+        orderHistoryLoader({ catalogKey: nextCatalogKey }),
+        paymentHistoryLoader({ catalogKey: nextCatalogKey }),
+        creditsLoader({ catalogKey: nextCatalogKey }),
+        entitlementsLoader({ catalogKey: nextCatalogKey })
+      ]);
+      const subscriptionWithProduct = nextSubscription ? {
+        ...nextSubscription,
+        product: resolveBillingSubscriptionProduct(nextSubscription, nextRuntimeConfig ?? runtimeConfig)
+      } : void 0;
+      const normalizedCredits = deriveBillingCreditsState(nextCredits, nextProducts, nextRuntimeConfig?.conversionRules ?? runtimeConfig?.conversionRules);
+      const normalizedEntitlements = nextEntitlements ?? deriveBillingEntitlements(subscriptionWithProduct, nextProducts, normalizedCredits, nextRuntimeConfig ?? runtimeConfig);
+      const latestOrder = getLatestOrder(nextOrderHistory);
+      const latestPayment = getLatestPayment(nextPaymentHistory);
+      const fetchedPurchaseStatus = await purchaseStatusLoader({
+        orderId: latestOrder?.orderId,
+        paymentId: latestPayment?.paymentId,
+        transactionId: latestPayment?.transactionId ?? latestOrder?.transactionId
+      }).catch(() => void 0);
+      const normalizedPurchaseStatus = normalizeBillingPurchaseStatus(
+        fetchedPurchaseStatus,
+        latestOrder,
+        latestPayment
+      );
+      setSubscription(subscriptionWithProduct);
+      setSubscriptionHistory(nextSubscriptionHistory);
+      setProducts(nextProducts);
+      setOrderHistory(nextOrderHistory);
+      setPaymentHistory(nextPaymentHistory);
+      setCredits(normalizedCredits);
+      setEntitlements(normalizedEntitlements);
+      setPurchaseStatus(normalizedPurchaseStatus);
+      setStatus({ loading: false, refreshing: false, error: null, lastFetchedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setRuntimeConfigError(message);
+      setStatus((current) => ({ ...current, loading: false, refreshing: false, error: message }));
+    } finally {
+      setRuntimeConfigLoading(false);
+    }
+  }, [apiClient, loaders, runtimeConfig, runtimeConfigLoader, runtimeCatalog]);
+  const runAction = useCallback(
+    async (payload) => {
+      const prepared = buildBillingActionPayload(payload, runtimeConfig);
+      const executor = actionExecutor ?? ((input) => apiClient.createAction(input));
+      setPurchaseStatus((current) => ({
+        actionKey: prepared.key,
+        orderId: current?.orderId,
+        paymentId: current?.paymentId,
+        transactionId: current?.transactionId,
+        status: "pending",
+        redirectTo: current?.redirectTo,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      setStatus((current) => ({ ...current, loading: true, refreshing: true, error: null }));
+      try {
+        const result = await executor(prepared);
+        setPurchaseStatus((current) => ({
+          actionKey: prepared.key,
+          orderId: current?.orderId,
+          paymentId: current?.paymentId,
+          transactionId: current?.transactionId,
+          status: result.status === "failed" ? "failed" : result.status === "succeeded" ? "paid" : "pending",
+          redirectTo: result.redirectTo ?? current?.redirectTo,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        if (result.redirectTo || result.nextAction) {
+        }
+        await refresh();
+        return result;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        setPurchaseStatus((current) => ({
+          actionKey: prepared.key,
+          orderId: current?.orderId,
+          paymentId: current?.paymentId,
+          transactionId: current?.transactionId,
+          status: "failed",
+          redirectTo: current?.redirectTo,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        setStatus((current) => ({ ...current, loading: false, refreshing: false, error: message }));
+        throw error;
+      }
+    },
+    [actionExecutor, apiClient, refresh, runtimeConfig]
+  );
+  useEffect(() => {
+    if (!autoRefresh) return;
+    if (runtimeConfigLoading) return;
+    if (!runtimeConfig && !runtimeConfigError) {
+      void refresh();
+    }
+  }, [autoRefresh, refresh, runtimeConfig, runtimeConfigError, runtimeConfigLoading]);
+  const coreValue = useMemo(
+    () => buildCoreValue({
+      apiClient,
+      loaders,
+      runtimeConfigLoader,
+      actionExecutor,
+      defaults,
+      runtimeConfig,
+      runtimeCatalog,
+      runtimeConfigLoading,
+      runtimeConfigError,
+      subscription,
+      subscriptionHistory,
+      products,
+      orderHistory,
+      paymentHistory,
+      credits,
+      entitlements,
+      purchaseStatus,
+      status,
+      refresh,
+      runAction,
+      setRuntimeConfig,
+      setSubscription,
+      setSubscriptionHistory,
+      setProducts,
+      setOrderHistory,
+      setPaymentHistory,
+      setCredits,
+      setEntitlements,
+      setPurchaseStatus,
+      setStatus
+    }),
+    [
+      actionExecutor,
+      apiClient,
+      credits,
+      defaults,
+      entitlements,
+      orderHistory,
+      paymentHistory,
+      products,
+      purchaseStatus,
+      refresh,
+      runAction,
+      runtimeConfig,
+      runtimeConfigError,
+      runtimeConfigLoader,
+      runtimeConfigLoading,
+      runtimeCatalog,
+      loaders,
+      status,
+      subscription,
+      subscriptionHistory
+    ]
+  );
+  return /* @__PURE__ */ jsx2(BillingCoreContext.Provider, { value: coreValue, children: /* @__PURE__ */ jsx2(SubscriptionProvider, { subscription, subscriptionHistory, entitlements, status, children: /* @__PURE__ */ jsx2(ProductProvider, { products, orderHistory, paymentHistory, status, children: /* @__PURE__ */ jsx2(CreditsProvider, { credits, status, children }) }) }) });
+}
+function BillingCoreProvider(props) {
+  return /* @__PURE__ */ jsx2(BillingProvider, { ...props });
+}
+function SubscriptionProvider({
+  children,
+  availablePlans,
+  subscription,
+  subscriptionHistory,
+  entitlements,
+  status
+}) {
+  const core = useOptionalContext(BillingCoreContext);
+  const value = useMemo(
+    () => ({
+      availablePlans: choose(availablePlans, core?.runtimeConfig?.items?.filter((item) => item.kind === "subscription")),
+      subscription: choose(subscription, core?.subscription),
+      subscriptionHistory: choose(subscriptionHistory, core?.subscriptionHistory),
+      entitlements: choose(entitlements, core?.entitlements),
+      status: choose(status, core?.status)
+    }),
+    [availablePlans, core?.entitlements, core?.runtimeConfig?.items, core?.status, core?.subscription, core?.subscriptionHistory, entitlements, status, subscription, subscriptionHistory]
+  );
+  return /* @__PURE__ */ jsx2(BillingSubscriptionContext.Provider, { value, children });
+}
+function ProductProvider({
+  children,
+  availableProducts,
+  products,
+  orderHistory,
+  paymentHistory,
+  status
+}) {
+  const core = useOptionalContext(BillingCoreContext);
+  const value = useMemo(
+    () => ({
+      availableProducts: choose(availableProducts, core?.runtimeConfig?.items?.filter((item) => item.kind === "product" || item.kind === "credits")),
+      products: choose(products, core?.products),
+      orderHistory: choose(orderHistory, core?.orderHistory),
+      paymentHistory: choose(paymentHistory, core?.paymentHistory),
+      status: choose(status, core?.status)
+    }),
+    [availableProducts, core?.orderHistory, core?.paymentHistory, core?.products, core?.runtimeConfig?.items, core?.status, orderHistory, paymentHistory, products, status]
+  );
+  return /* @__PURE__ */ jsx2(BillingProductContext.Provider, { value, children });
+}
+function CreditsProvider({ children, credits, status }) {
+  const core = useOptionalContext(BillingCoreContext);
+  const value = useMemo(
+    () => ({
+      credits: choose(credits, core?.credits),
+      status: choose(status, core?.status)
+    }),
+    [credits, core?.credits, core?.status, status]
+  );
+  return /* @__PURE__ */ jsx2(BillingCreditsContext.Provider, { value, children });
+}
+function useBillingContext() {
+  return useRequiredCoreContext();
+}
+function useBillingCatalog() {
+  const core = useRequiredCoreContext();
+  return useMemo(
+    () => ({
+      catalog: core.runtimeCatalog ?? core.runtimeConfig,
+      loading: core.runtimeConfigLoading,
+      error: core.runtimeConfigError,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeCatalog, core.runtimeConfig, core.runtimeConfigError, core.runtimeConfigLoading]
+  );
+}
+function useBillingItem(itemKey) {
+  const core = useRequiredCoreContext();
+  return useMemo(() => {
+    const item = resolveBillingItem(core.runtimeConfig?.items, itemKey);
+    return {
+      item: resolveBillingProductSnapshot(item),
+      loading: core.runtimeConfigLoading,
+      error: core.runtimeConfigError,
+      refresh: core.refresh
+    };
+  }, [core.refresh, core.runtimeConfig?.items, core.runtimeConfigError, core.runtimeConfigLoading, itemKey]);
+}
+function useBillingProducts(options = {}) {
+  const core = useRequiredCoreContext();
+  const productContext = useOptionalContext(BillingProductContext);
+  const products = choose(productContext?.products, core.products) ?? [];
+  return useMemo(
+    () => ({
+      products: filterProductsByKind(products, options.kind),
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, options.kind, products]
+  );
+}
+function useBillingAvailablePlans() {
+  const core = useRequiredCoreContext();
+  const subscriptionContext = useOptionalContext(BillingSubscriptionContext);
+  const plans = choose(subscriptionContext?.availablePlans, core.runtimeConfig?.items?.filter((item) => item.kind === "subscription")) ?? [];
+  return useMemo(
+    () => ({
+      plans,
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfig?.items, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, plans]
+  );
+}
+function useBillingAvailableProducts() {
+  const core = useRequiredCoreContext();
+  const productContext = useOptionalContext(BillingProductContext);
+  const items = choose(productContext?.availableProducts, core.runtimeConfig?.items?.filter((item) => item.kind === "product" || item.kind === "credits")) ?? [];
+  return useMemo(
+    () => ({
+      items,
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfig?.items, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, items]
+  );
+}
+function useBillingOrderHistory(_options = {}) {
+  const core = useRequiredCoreContext();
+  const productContext = useOptionalContext(BillingProductContext);
+  const orders = choose(productContext?.orderHistory, core.orderHistory) ?? [];
+  return useMemo(
+    () => ({
+      orders,
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, orders]
+  );
+}
+function useBillingPaymentHistory(_options = {}) {
+  const core = useRequiredCoreContext();
+  const productContext = useOptionalContext(BillingProductContext);
+  const payments = choose(productContext?.paymentHistory, core.paymentHistory) ?? [];
+  return useMemo(
+    () => ({
+      payments,
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, payments]
+  );
+}
+function useBillingSubscription() {
+  const core = useRequiredCoreContext();
+  const subscriptionContext = useOptionalContext(BillingSubscriptionContext);
+  return useMemo(
+    () => ({
+      subscription: choose(subscriptionContext?.subscription, core.subscription),
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, core.subscription, subscriptionContext?.subscription]
+  );
+}
+function useBillingSubscriptionProduct() {
+  const core = useRequiredCoreContext();
+  const subscriptionContext = useOptionalContext(BillingSubscriptionContext);
+  const subscription = choose(subscriptionContext?.subscription, core.subscription);
+  return useMemo(
+    () => ({
+      product: subscription?.product ?? resolveBillingSubscriptionProduct(subscription, core.runtimeConfig),
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfig, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, subscription]
+  );
+}
+function useBillingSubscriptionHistory(_options = {}) {
+  const core = useRequiredCoreContext();
+  const subscriptionContext = useOptionalContext(BillingSubscriptionContext);
+  const history = choose(subscriptionContext?.subscriptionHistory, core.subscriptionHistory) ?? [];
+  return useMemo(
+    () => ({
+      history,
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, history]
+  );
+}
+function useBillingCredits() {
+  const core = useRequiredCoreContext();
+  const creditsContext = useOptionalContext(BillingCreditsContext);
+  const credits = choose(creditsContext?.credits, core.credits) ?? deriveBillingCreditsState(void 0, core.products, core.runtimeConfig?.conversionRules);
+  return useMemo(
+    () => ({
+      credits,
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfig?.conversionRules, core.runtimeConfigError, core.runtimeConfigLoading, core.products, core.status.error, core.status.loading, credits]
+  );
+}
+function useBillingEntitlements() {
+  const core = useRequiredCoreContext();
+  const subscriptionContext = useOptionalContext(BillingSubscriptionContext);
+  const entitlements = choose(subscriptionContext?.entitlements, core.entitlements) ?? deriveBillingEntitlements(subscriptionContext?.subscription ?? core.subscription, core.products, core.credits, core.runtimeConfig);
+  return useMemo(
+    () => ({
+      entitlements,
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.credits, core.products, core.refresh, core.runtimeConfig, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, entitlements, subscriptionContext?.subscription, core.subscription]
+  );
+}
+function useBillingPurchaseStatus() {
+  const core = useRequiredCoreContext();
+  const productContext = useOptionalContext(BillingProductContext);
+  const order = getLatestOrder(choose(productContext?.orderHistory, core.orderHistory));
+  const payment = getLatestPayment(choose(productContext?.paymentHistory, core.paymentHistory));
+  const purchaseStatus = core.purchaseStatus ?? normalizeBillingPurchaseStatus(void 0, order, payment);
+  return useMemo(
+    () => ({
+      purchaseStatus,
+      loading: core.runtimeConfigLoading || core.status.loading,
+      error: core.runtimeConfigError ?? core.status.error,
+      refresh: core.refresh
+    }),
+    [core.purchaseStatus, core.refresh, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, order, payment, purchaseStatus]
+  );
+}
+function useBillingStatus() {
+  const core = useRequiredCoreContext();
+  return useMemo(() => ({ status: core.status }), [core.status]);
+}
+function useBillingRefresh() {
+  const core = useRequiredCoreContext();
+  return useMemo(() => ({ refresh: core.refresh }), [core.refresh]);
+}
+function useBillingPipeline(options = {}) {
+  const core = useRequiredCoreContext();
+  const purchaseStatusView = useBillingPurchaseStatus();
+  const run = useCallback(
+    async (payload) => {
+      const prepared = options.onBeforeAction ? await options.onBeforeAction(payload) : payload;
+      try {
+        const result = await core.runAction(prepared);
+        if (options.onAfterAction) {
+          await options.onAfterAction({ redirectTo: result.redirectTo, nextAction: result.nextAction });
+        }
+      } catch (error) {
+        if (options.onError) {
+          await options.onError(error);
+        }
+        throw error;
+      }
+    },
+    [core, options]
+  );
+  return useMemo(
+    () => ({
+      run,
+      loading: core.status.loading || core.runtimeConfigLoading,
+      error: core.status.error ?? core.runtimeConfigError,
+      purchaseStatus: purchaseStatusView.purchaseStatus,
+      refresh: core.refresh
+    }),
+    [core.refresh, core.runtimeConfigError, core.runtimeConfigLoading, core.status.error, core.status.loading, purchaseStatusView.purchaseStatus, run]
+  );
+}
+function useBillingActionRunner(kind, defaults) {
+  const pipeline = useBillingPipeline();
+  const run = useCallback(
+    async (payload) => {
+      await pipeline.run({
+        ...defaults,
+        ...payload,
+        kind
+      });
+    },
+    [defaults, kind, pipeline]
+  );
+  return useMemo(
+    () => ({
+      run,
+      loading: pipeline.loading,
+      error: pipeline.error
+    }),
+    [pipeline.error, pipeline.loading, run]
+  );
+}
+function useSubscribePlan() {
+  return useBillingActionRunner("subscribe");
+}
+function useManageSubscription() {
+  return useBillingActionRunner("manage");
+}
+function useUpgradePlan() {
+  return useBillingActionRunner("upgrade");
+}
+function useCancelSubscription() {
+  return useBillingActionRunner("cancel");
+}
+function usePurchaseCredits() {
+  return useBillingActionRunner("purchase");
+}
+function usePurchaseProduct() {
+  return useBillingActionRunner("purchase");
+}
+function useBillingProduct(productKey) {
+  const productsState = useBillingProducts();
+  const product = productsState.products.find((item) => item.productKey === productKey);
+  return useMemo(
+    () => ({
+      product,
+      loading: productsState.loading,
+      error: productsState.error,
+      refresh: productsState.refresh
+    }),
+    [product, productsState.error, productsState.loading, productsState.refresh]
+  );
+}
+function useBillingCatalogConfig() {
+  return useBillingCatalog();
+}
+export {
+  AuthProvider,
+  BillingCoreProvider,
+  BillingProvider,
+  CreditsProvider,
+  ProductProvider,
+  SubscriptionProvider,
+  useAuthActions,
+  useAuthRole,
+  useAuthSession,
+  useAuthUser,
+  useBillingAvailablePlans,
+  useBillingAvailableProducts,
+  useBillingCatalog,
+  useBillingCatalogConfig,
+  useBillingContext,
+  useBillingCredits,
+  useBillingEntitlements,
+  useBillingItem,
+  useBillingOrderHistory,
+  useBillingPaymentHistory,
+  useBillingPipeline,
+  useBillingProduct,
+  useBillingProducts,
+  useBillingPurchaseStatus,
+  useBillingRefresh,
+  useBillingStatus,
+  useBillingSubscription,
+  useBillingSubscriptionHistory,
+  useBillingSubscriptionProduct,
+  useCancelSubscription,
+  useManageSubscription,
+  usePurchaseCredits,
+  usePurchaseProduct,
+  useSubscribePlan,
+  useUpgradePlan
+};
+//# sourceMappingURL=index.js.map