@fayz-ai/admin 0.10.0

package/dist/chunk-5O2UJAQ7.js

@@ -0,0 +1,534 @@
+import { useTranslation } from './chunk-YUHCC7JY.js';
+import { useBillingStore, resolvePlanBadge } from './chunk-VN5NTK26.js';
+import { useOrganizationStore, useTenantOptional, useOrgAdapterOptional } from './chunk-PNAJODZM.js';
+import { usePermissionsStore } from './chunk-VTEP2AQX.js';
+import * as React from 'react';
+import { Sparkles, Check, Crown, Minus } from 'lucide-react';
+import { cn, Card, CardContent, Badge, CardHeader, Button, ConfirmDialog, toast } from '@fayz-ai/ui';
+export { cn } from '@fayz-ai/ui';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { invalidateCount, usePluginRuntimeOptional, getAllEntities, countByTenant } from '@fayz-ai/core';
+import { useAuthStore } from '@fayz-ai/auth';
+import { mergeLimitDeclarations, isEntitledByPlan, resolveAccess, resolveLimit, agentDenial } from '@fayz-ai/core/access';
+export { UPGRADE_URL, agentDenial, isEntitledByPlan, resolveAccess } from '@fayz-ai/core/access';
+import { create } from 'zustand';
+
+function parsePlanFeature(feature) {
+  return feature.startsWith("*") ? { label: feature.slice(1).trim(), highlighted: true } : { label: feature, highlighted: false };
+}
+function PlanFeatureItem({ feature, className, iconClassName }) {
+  const { label, highlighted } = parsePlanFeature(feature);
+  return /* @__PURE__ */ jsxs("li", { className: cn("flex items-start gap-2", className, highlighted && "font-medium text-primary"), children: [
+    highlighted ? /* @__PURE__ */ jsx(Sparkles, { className: cn("mt-0.5 shrink-0 text-primary", iconClassName), "aria-hidden": "true" }) : /* @__PURE__ */ jsx(Check, { className: cn("mt-0.5 shrink-0 text-primary", iconClassName), "aria-hidden": "true" }),
+    /* @__PURE__ */ jsx("span", { children: label })
+  ] });
+}
+var CORE_LIMIT_DECLARATIONS = [
+  { key: "users", label: "Users", table: "tenant_members" },
+  { key: "locations", label: "Locations", table: "locations" }
+];
+function entityDerivedLimitDeclarations(entities) {
+  const out = [];
+  for (const e of entities) {
+    const def = e.entityDef;
+    if (def?.limitKey && def.data?.table) {
+      out.push({
+        key: def.limitKey,
+        label: e.labelPlural,
+        table: def.data.table,
+        kindFilter: def.data.archetypeKind
+      });
+    }
+  }
+  return out;
+}
+var registry = /* @__PURE__ */ new Map();
+function setLimitRegistry(declarations) {
+  const next = /* @__PURE__ */ new Map();
+  for (const decl of declarations) next.set(decl.key, decl);
+  registry = next;
+}
+function getLimitDeclaration(key) {
+  return registry.get(key);
+}
+var listeners = /* @__PURE__ */ new Map();
+function subscribeLimit(key, cb) {
+  let set = listeners.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    listeners.set(key, set);
+  }
+  set.add(cb);
+  return () => {
+    set?.delete(cb);
+    if (set && set.size === 0) listeners.delete(key);
+  };
+}
+function invalidateLimit(key) {
+  const decl = registry.get(key);
+  if (decl) invalidateCount(decl.table);
+  listeners.get(key)?.forEach((cb) => cb());
+}
+var useUpgradeModalStore = create((set) => ({
+  current: null,
+  open: (payload) => set({ current: payload }),
+  close: () => set({ current: null })
+}));
+var AccessContext = React.createContext(null);
+function AccessProvider({ children, limitDeclarations }) {
+  const user = useAuthStore((s) => s.user);
+  const org = useOrganizationStore((s) => s.currentOrg);
+  const profile = usePermissionsStore((s) => s.currentProfile);
+  const plans = useBillingStore((s) => s.plans);
+  const runtime = usePluginRuntimeOptional();
+  const pluginLimits = runtime?.pluginLimits;
+  React.useEffect(() => {
+    setLimitRegistry(
+      mergeLimitDeclarations(
+        CORE_LIMIT_DECLARATIONS,
+        entityDerivedLimitDeclarations(getAllEntities()),
+        pluginLimits,
+        limitDeclarations
+      )
+    );
+  }, [pluginLimits, limitDeclarations]);
+  const plan = React.useMemo(
+    () => org?.plan ? plans.find((p) => p.id === org.plan) ?? null : null,
+    [plans, org?.plan]
+  );
+  const session = React.useMemo(
+    () => ({ user, org, profile, plan }),
+    [user, org, profile, plan]
+  );
+  const value = React.useMemo(
+    () => ({
+      session,
+      can: (feature, action) => resolveAccess(session, feature, action),
+      entitled: (feature) => isEntitledByPlan(session.plan, feature)
+    }),
+    [session]
+  );
+  return /* @__PURE__ */ jsx(AccessContext.Provider, { value, children });
+}
+AccessProvider.displayName = "AccessProvider";
+var ALLOW_ALL = {
+  can: () => ({ allowed: true }),
+  entitled: () => true
+};
+function useAccess() {
+  const ctx = React.useContext(AccessContext);
+  if (!ctx) throw new Error("useAccess must be used inside <AccessProvider>");
+  return { can: ctx.can, entitled: ctx.entitled };
+}
+function useAccessOptional() {
+  const ctx = React.useContext(AccessContext);
+  return ctx ? { can: ctx.can, entitled: ctx.entitled } : ALLOW_ALL;
+}
+function useAccessSession() {
+  return React.useContext(AccessContext)?.session ?? null;
+}
+function resolveCap(plan, key) {
+  return plan?.entitlements?.limits?.[key];
+}
+function useLimit(key) {
+  const session = useAccessSession();
+  const tenantId = session?.org?.id;
+  const cap = resolveCap(session?.plan ?? null, key);
+  const declaration = getLimitDeclaration(key);
+  const unlimited = !declaration || cap === void 0 || cap === -1;
+  const [used, setUsed] = React.useState(0);
+  const [loading, setLoading] = React.useState(!unlimited);
+  const [version, setVersion] = React.useState(0);
+  const refresh = React.useCallback(() => setVersion((v) => v + 1), []);
+  React.useEffect(() => subscribeLimit(key, refresh), [key, refresh]);
+  React.useEffect(() => {
+    if (unlimited || !declaration || !tenantId) {
+      setUsed(0);
+      setLoading(false);
+      return;
+    }
+    let active = true;
+    setLoading(true);
+    countByTenant(declaration.table, {
+      kind: declaration.kindFilter,
+      period: declaration.period,
+      tenantId,
+      fresh: version > 0
+    }).then((n) => {
+      if (active) {
+        setUsed(n);
+        setLoading(false);
+      }
+    }).catch(() => {
+      if (active) setLoading(false);
+    });
+    return () => {
+      active = false;
+    };
+  }, [unlimited, declaration, tenantId, version]);
+  const bounds = resolveLimit({ cap, hasDeclaration: Boolean(declaration), used });
+  return { key, ...bounds, loading, refresh };
+}
+function useLimitGuard(key) {
+  const session = useAccessSession();
+  const tenantId = session?.org?.id;
+  const plan = session?.plan ?? null;
+  const openModal = useUpgradeModalStore((s) => s.open);
+  return React.useCallback(
+    async (n = 1) => {
+      const cap = resolveCap(plan, key);
+      const declaration = getLimitDeclaration(key);
+      if (!declaration || cap === void 0 || cap === -1 || !tenantId) return "ok";
+      const used = await countByTenant(declaration.table, {
+        kind: declaration.kindFilter,
+        period: declaration.period,
+        tenantId,
+        fresh: true
+      });
+      if (used + n > cap) {
+        openModal({ limitKey: key });
+        return "blocked";
+      }
+      return "ok";
+    },
+    [key, plan, tenantId, openModal]
+  );
+}
+function getAccessSnapshot() {
+  const user = useAuthStore.getState().user;
+  const org = useOrganizationStore.getState().currentOrg;
+  const profile = usePermissionsStore.getState().currentProfile;
+  const plans = useBillingStore.getState().plans;
+  const plan = org?.plan ? plans.find((p) => p.id === org.plan) ?? null : null;
+  return { user, org, profile, plan };
+}
+function checkAccess(feature, action) {
+  const session = getAccessSnapshot();
+  const decision = resolveAccess(session, feature, action);
+  if (decision.allowed) return { allowed: true };
+  return agentDenial(decision.reason ?? "role");
+}
+async function guardLimit(key, n = 1) {
+  const session = getAccessSnapshot();
+  const tenantId = session.org?.id;
+  const cap = session.plan?.entitlements?.limits?.[key];
+  const declaration = getLimitDeclaration(key);
+  if (!declaration || cap === void 0 || cap === -1 || !tenantId) return { allowed: true };
+  const used = await countByTenant(declaration.table, {
+    kind: declaration.kindFilter,
+    period: declaration.period,
+    tenantId,
+    fresh: true
+  });
+  if (used + n > cap) {
+    return agentDenial("limit", { key, max: cap, used });
+  }
+  return { allowed: true };
+}
+function applyNavAccess(items, access, knownFeatures) {
+  const decorate = (item) => {
+    const children = item.children ? item.children.map(decorate).filter((c) => c !== null) : void 0;
+    if (!item.feature) {
+      return children ? { ...item, children } : item;
+    }
+    if (knownFeatures.has(item.feature)) {
+      const decision = access.can(item.feature, "read");
+      if (!decision.allowed && decision.reason === "role") return null;
+    }
+    const premium = access.entitled(item.feature) === false;
+    return children ? { ...item, premium, children } : { ...item, premium };
+  };
+  return items.map(decorate).filter((i) => i !== null);
+}
+function useModuleNavAccess(items) {
+  const access = useAccessOptional();
+  const features = usePermissionsStore((s) => s.features);
+  const knownFeatures = React.useMemo(
+    () => new Set(features.map((f) => f.id)),
+    [features]
+  );
+  return React.useMemo(
+    () => applyNavAccess(items, access, knownFeatures),
+    [items, access, knownFeatures]
+  );
+}
+
+// src/components/billing/access-contract.ts
+function getPlanEntitlements(plan) {
+  return plan?.entitlements;
+}
+function featureDisplayName(label) {
+  if (!label) return "";
+  return label.replace(/\s*\([^)]*\)\s*$/, "").trim() || label.trim();
+}
+var CURRENCY_BY_REGION = {
+  BR: "BRL",
+  PT: "EUR",
+  ES: "EUR",
+  FR: "EUR",
+  DE: "EUR",
+  IT: "EUR",
+  NL: "EUR",
+  IE: "EUR",
+  GB: "GBP",
+  US: "USD",
+  CA: "CAD",
+  AU: "AUD",
+  MX: "MXN",
+  AR: "ARS",
+  CL: "CLP",
+  CO: "COP"
+};
+function resolvePlanCurrency(planCurrency, locale) {
+  if (planCurrency) return planCurrency;
+  const region = locale?.split(/[-_]/)[1]?.toUpperCase();
+  return region && CURRENCY_BY_REGION[region] || "USD";
+}
+function formatPrice(plan, tr) {
+  if (plan.price <= 0) return tr("billing.free", "Free");
+  try {
+    const isInteger = Number.isInteger(plan.price);
+    return new Intl.NumberFormat(void 0, {
+      style: "currency",
+      currency: plan.currency || "USD",
+      minimumFractionDigits: isInteger ? 0 : 2
+    }).format(plan.price);
+  } catch {
+    return `${plan.currency || ""} ${plan.price}`.trim();
+  }
+}
+function intervalSuffix(plan, tr) {
+  if (plan.price <= 0) return "";
+  return plan.interval === "year" ? tr("billing.perYear", "/yr") : tr("billing.perMonth", "/mo");
+}
+function SubscriptionPage({ className }) {
+  const { t } = useTranslation();
+  const tr = (key, fallback) => {
+    const v = t(key);
+    return !v || v === key ? fallback : v;
+  };
+  const plans = useBillingStore((s) => s.plans);
+  const checkout = useBillingStore((s) => s.checkout);
+  useTenantOptional();
+  const adapter = useOrgAdapterOptional();
+  const setCurrentOrg = useOrganizationStore((s) => s.setCurrentOrg);
+  const currentOrg = useOrganizationStore((s) => s.currentOrg);
+  const currentPlanId = currentOrg?.plan || "free";
+  const currentBadge = resolvePlanBadge(currentPlanId, plans);
+  const currentPlan = plans.find((p) => p.id === currentPlanId);
+  const [pending, setPending] = React.useState(null);
+  const [busy, setBusy] = React.useState(false);
+  const allFeatures = React.useMemo(() => {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const plan of plans) {
+      for (const f of plan.features) {
+        if (!seen.has(f)) {
+          seen.add(f);
+          out.push(f);
+        }
+      }
+    }
+    return out;
+  }, [plans]);
+  const featureCatalog = usePermissionsStore((s) => s.features);
+  const entitlementsMatrix = React.useMemo(() => {
+    const hasAny = plans.some((p) => getPlanEntitlements(p));
+    if (!hasAny) return null;
+    const featureIds = [];
+    const featureSeen = /* @__PURE__ */ new Set();
+    const limitKeys = [];
+    const limitSeen = /* @__PURE__ */ new Set();
+    for (const plan of plans) {
+      const ent = getPlanEntitlements(plan);
+      for (const id of Object.keys(ent?.features ?? {})) {
+        if (!featureSeen.has(id)) {
+          featureSeen.add(id);
+          featureIds.push(id);
+        }
+      }
+      for (const key of Object.keys(ent?.limits ?? {})) {
+        if (!limitSeen.has(key)) {
+          limitSeen.add(key);
+          limitKeys.push(key);
+        }
+      }
+    }
+    if (featureIds.length === 0 && limitKeys.length === 0) return null;
+    const labelForFeature = (id) => featureCatalog.find((f) => f.id === id)?.label ?? id;
+    const labelForLimit = (key) => {
+      const v = t(`limit.label.${key}`);
+      return !v || v === `limit.label.${key}` ? key : v;
+    };
+    return { featureIds, limitKeys, labelForFeature, labelForLimit };
+  }, [plans, featureCatalog, t]);
+  async function applyChange(plan) {
+    setBusy(true);
+    try {
+      if (checkout) {
+        await checkout(plan.id);
+        setPending(null);
+        return;
+      }
+      if (adapter && currentOrg) {
+        const updated = await adapter.updateOrg(currentOrg.id, { plan: plan.id });
+        setCurrentOrg(updated);
+      } else if (currentOrg) {
+        setCurrentOrg({ ...currentOrg, plan: plan.id });
+      }
+      toast.success(
+        tr("billing.planChanged", "Plan updated").replace("{{plan}}", plan.name)
+      );
+      setPending(null);
+    } catch {
+      toast.error(tr("billing.planChangeFailed", "Couldn't change your plan. Please try again."));
+    } finally {
+      setBusy(false);
+    }
+  }
+  if (plans.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: className ?? "mx-auto max-w-5xl", children: /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: tr("billing.noPlans", "No plans are configured.") }) });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: className ?? "mx-auto max-w-5xl space-y-8", children: [
+    /* @__PURE__ */ jsxs("div", { children: [
+      /* @__PURE__ */ jsx("h1", { className: "text-2xl font-bold tracking-tight", children: tr("billing.subscription.title", "Subscription") }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: tr("billing.subscription.subtitle", "Manage your plan and unlock more features.") })
+    ] }),
+    /* @__PURE__ */ jsx(
+      Card,
+      {
+        className: cn(
+          "relative overflow-hidden",
+          currentBadge.paid && "border-amber-400/60 bg-gradient-to-br from-amber-50/60 to-transparent dark:from-amber-950/20"
+        ),
+        children: /* @__PURE__ */ jsxs(CardContent, { className: "flex flex-wrap items-center justify-between gap-4 p-6", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4", children: [
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: cn(
+                  "flex h-12 w-12 shrink-0 items-center justify-center rounded-xl",
+                  currentBadge.paid ? "bg-amber-400/20 text-amber-600 dark:text-amber-400" : "bg-muted text-muted-foreground"
+                ),
+                children: currentBadge.paid ? /* @__PURE__ */ jsx(Crown, { className: "h-6 w-6" }) : /* @__PURE__ */ jsx(Sparkles, { className: "h-6 w-6" })
+              }
+            ),
+            /* @__PURE__ */ jsxs("div", { children: [
+              /* @__PURE__ */ jsx("p", { className: "text-xs font-medium uppercase tracking-wide text-muted-foreground", children: tr("billing.currentPlan", "Current Plan") }),
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ jsx("span", { className: "text-xl font-bold", children: currentBadge.label }),
+                currentBadge.paid && // Paid marker only — a literal "Pro" here was misleading next
+                // to non-Pro paid tiers ("Starter / Pro", QA finding).
+                /* @__PURE__ */ jsx(
+                  Badge,
+                  {
+                    "aria-label": tr("billing.paidPlan", "Paid plan"),
+                    className: "border-amber-400/40 bg-amber-400/15 text-amber-700 dark:text-amber-300",
+                    children: /* @__PURE__ */ jsx(Crown, { className: "h-3 w-3" })
+                  }
+                )
+              ] })
+            ] })
+          ] }),
+          currentPlan && /* @__PURE__ */ jsxs("div", { className: "text-right", children: [
+            /* @__PURE__ */ jsx("span", { className: "text-2xl font-bold", children: formatPrice(currentPlan, tr) }),
+            /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground", children: intervalSuffix(currentPlan, tr) })
+          ] })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "grid gap-6 md:grid-cols-2 lg:grid-cols-3", children: plans.map((plan) => {
+      const isCurrent = plan.id === currentPlanId;
+      const paid = plan.price > 0;
+      return /* @__PURE__ */ jsxs(
+        Card,
+        {
+          className: cn(
+            "relative flex flex-col",
+            plan.highlighted && "border-primary shadow-md",
+            isCurrent && "ring-2 ring-primary/40"
+          ),
+          children: [
+            plan.highlighted && /* @__PURE__ */ jsx("div", { className: "absolute -top-3 left-1/2 -translate-x-1/2", children: /* @__PURE__ */ jsxs(Badge, { children: [
+              /* @__PURE__ */ jsx(Crown, { className: "mr-1 h-3 w-3" }),
+              tr("billing.mostPopular", "Most Popular")
+            ] }) }),
+            /* @__PURE__ */ jsxs(CardHeader, { className: "pb-0", children: [
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ jsx("h3", { className: "text-xl font-semibold", children: plan.name }),
+                paid && /* @__PURE__ */ jsx(Crown, { className: "h-4 w-4 text-amber-500" })
+              ] }),
+              plan.description && /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: plan.description })
+            ] }),
+            /* @__PURE__ */ jsxs(CardContent, { className: "flex flex-1 flex-col pt-4", children: [
+              /* @__PURE__ */ jsxs("div", { className: "mb-6", children: [
+                /* @__PURE__ */ jsx("span", { className: "text-4xl font-bold", children: formatPrice(plan, tr) }),
+                /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: intervalSuffix(plan, tr) })
+              ] }),
+              /* @__PURE__ */ jsx("ul", { className: "mb-6 flex-1 space-y-3", children: plan.features.map((feature) => /* @__PURE__ */ jsx(PlanFeatureItem, { feature, className: "text-sm", iconClassName: "h-4 w-4" }, feature)) }),
+              isCurrent ? /* @__PURE__ */ jsx(Button, { variant: "outline", className: "w-full", disabled: true, children: tr("billing.currentPlan", "Current Plan") }) : /* @__PURE__ */ jsx(
+                Button,
+                {
+                  className: "w-full",
+                  variant: plan.highlighted ? "default" : "outline",
+                  onClick: () => setPending(plan),
+                  children: tr("billing.changeToPlan", "Switch to this plan")
+                }
+              )
+            ] })
+          ]
+        },
+        plan.id
+      );
+    }) }),
+    (entitlementsMatrix || allFeatures.length > 0) && /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+      /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold", children: tr("billing.featureMatrix", "Feature comparison") }),
+      /* @__PURE__ */ jsx("div", { className: "overflow-x-auto rounded-lg border", children: /* @__PURE__ */ jsxs("table", { className: "w-full border-collapse text-sm", children: [
+        /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { className: "border-b bg-muted/40", children: [
+          /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-left font-medium", children: tr("billing.features", "Features") }),
+          plans.map((plan) => /* @__PURE__ */ jsx("th", { className: "px-4 py-3 text-center font-medium", children: /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1", children: [
+            plan.price > 0 && /* @__PURE__ */ jsx(Crown, { className: "h-3.5 w-3.5 text-amber-500" }),
+            plan.name
+          ] }) }, plan.id))
+        ] }) }),
+        /* @__PURE__ */ jsx("tbody", { children: entitlementsMatrix ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          entitlementsMatrix.featureIds.map((id, i) => /* @__PURE__ */ jsxs("tr", { className: cn(i % 2 === 1 && "bg-muted/20"), children: [
+            /* @__PURE__ */ jsx("td", { className: "px-4 py-2.5 text-left", children: entitlementsMatrix.labelForFeature(id) }),
+            plans.map((plan) => {
+              const entitled = getPlanEntitlements(plan)?.features?.[id] !== false;
+              return /* @__PURE__ */ jsx("td", { className: "px-4 py-2.5 text-center", children: entitled ? /* @__PURE__ */ jsx(Check, { className: "mx-auto h-4 w-4 text-primary" }) : /* @__PURE__ */ jsx(Minus, { className: "mx-auto h-4 w-4 text-muted-foreground/40" }) }, plan.id);
+            })
+          ] }, `f:${id}`)),
+          entitlementsMatrix.limitKeys.map((key, i) => /* @__PURE__ */ jsxs("tr", { className: cn((entitlementsMatrix.featureIds.length + i) % 2 === 1 && "bg-muted/20"), children: [
+            /* @__PURE__ */ jsx("td", { className: "px-4 py-2.5 text-left", children: entitlementsMatrix.labelForLimit(key) }),
+            plans.map((plan) => {
+              const cap = getPlanEntitlements(plan)?.limits?.[key];
+              const cell = cap === void 0 ? "\u2014" : cap < 0 ? tr("billing.unlimited", "Unlimited") : tr("billing.upTo", "Up to {count}").replace("{count}", String(cap)).replace("{{count}}", String(cap));
+              return /* @__PURE__ */ jsx("td", { className: "px-4 py-2.5 text-center text-muted-foreground", children: cell }, plan.id);
+            })
+          ] }, `l:${key}`))
+        ] }) : allFeatures.map((feature, i) => /* @__PURE__ */ jsxs("tr", { className: cn(i % 2 === 1 && "bg-muted/20"), children: [
+          /* @__PURE__ */ jsx("td", { className: "px-4 py-2.5 text-left", children: parsePlanFeature(feature).label }),
+          plans.map((plan) => /* @__PURE__ */ jsx("td", { className: "px-4 py-2.5 text-center", children: plan.features.includes(feature) ? /* @__PURE__ */ jsx(Check, { className: "mx-auto h-4 w-4 text-primary" }) : /* @__PURE__ */ jsx(Minus, { className: "mx-auto h-4 w-4 text-muted-foreground/40" }) }, plan.id))
+        ] }, feature)) })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      ConfirmDialog,
+      {
+        open: pending !== null,
+        onConfirm: () => pending && void applyChange(pending),
+        onCancel: () => setPending(null),
+        title: tr("billing.changePlanConfirmTitle", "Change plan?"),
+        description: pending ? tr("billing.changePlanConfirmBody", "You're switching to the {{plan}} plan.").replace("{{plan}}", pending.name) : void 0,
+        confirmLabel: tr("billing.changePlanConfirm", "Switch plan"),
+        cancelLabel: tr("common.cancel", "Cancel"),
+        loading: busy
+      }
+    )
+  ] });
+}
+
+export { AccessProvider, CORE_LIMIT_DECLARATIONS, PlanFeatureItem, SubscriptionPage, checkAccess, entityDerivedLimitDeclarations, featureDisplayName, getAccessSnapshot, getPlanEntitlements, guardLimit, invalidateLimit, resolvePlanCurrency, useAccess, useAccessOptional, useLimit, useLimitGuard, useModuleNavAccess, useUpgradeModalStore };
+//# sourceMappingURL=chunk-5O2UJAQ7.js.map
+//# sourceMappingURL=chunk-5O2UJAQ7.js.map