autumn-js 0.0.108 → 0.0.110

package/dist/libraries/react/hooks/useProductsBase.mjs

@@ -1,28 +1,19 @@
 "use client";
 
-import {
-  AutumnContext,
-  useAutumnContext
-} from "../chunk-LXD6AEZW.mjs";
-import "../chunk-2PVRCDDK.mjs";
-import "../chunk-V575SGOW.mjs";
-import "../chunk-ZV4RPZTM.mjs";
-import "../chunk-JVCOY7ZL.mjs";
-import "../chunk-CIBQ4BJU.mjs";
-import "../chunk-VTGR7VVK.mjs";
-import "../chunk-WFFVOEUG.mjs";
-import "../chunk-ZF2HUCN6.mjs";
-import "../chunk-253MTZP3.mjs";
-import "../chunk-KQT5G3HT.mjs";
 
 // src/libraries/react/hooks/useProductsBase.tsx
-var useProductsBase = () => {
-  const context = useAutumnContext({ AutumnContext, name: "useProducts" });
+import useSWR from "swr";
+var useProductsBase = ({ client }) => {
   const fetcher = async () => {
-    const { data, error } = await context.client.products.list();
-    if (error) throw error;
-    return data?.list || [];
+    const { data: data2, error: error2 } = await client.products.list();
+    if (error2) throw error2;
+    return data2?.list || [];
   };
+  const queryKey = [`products`];
+  const { data, error, isLoading } = useSWR(queryKey, fetcher, {
+    refreshInterval: 0
+  });
+  return { products: data, error, isLoading };
 };
 export {
   useProductsBase

package/dist/libraries/react/index.d.mts

@@ -42,16 +42,102 @@ declare enum ProductItemInterval {
 type ProductItemIntervalType = "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | "multiple";
 
 type CheckFeatureScenario = "usage_limit" | "feature_flag";
-interface CheckFeatureResult extends CoreCustomerFeature {
+declare const CheckFeatureResultSchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    feature_id: z.ZodString;
+    customer_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    required_balance: z.ZodNumber;
+} & {
+    unlimited: z.ZodOptional<z.ZodBoolean>;
+    interval: z.ZodOptional<z.ZodNativeEnum<typeof ProductItemInterval>>;
+    balance: z.ZodOptional<z.ZodNumber>;
+    usage: z.ZodOptional<z.ZodNumber>;
+    included_usage: z.ZodOptional<z.ZodNumber>;
+    next_reset_at: z.ZodOptional<z.ZodNumber>;
+    overage_allowed: z.ZodOptional<z.ZodBoolean>;
+    usage_limit: z.ZodOptional<z.ZodNumber>;
+    breakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        interval: z.ZodNativeEnum<typeof ProductItemInterval>;
+        balance: z.ZodOptional<z.ZodNumber>;
+        usage: z.ZodOptional<z.ZodNumber>;
+        included_usage: z.ZodOptional<z.ZodNumber>;
+        next_reset_at: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        interval: ProductItemInterval;
+        balance?: number | undefined;
+        usage?: number | undefined;
+        included_usage?: number | undefined;
+        next_reset_at?: number | undefined;
+    }, {
+        interval: ProductItemInterval;
+        balance?: number | undefined;
+        usage?: number | undefined;
+        included_usage?: number | undefined;
+        next_reset_at?: number | undefined;
+    }>, "many">>;
+    credit_schema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        credit_amount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        feature_id: string;
+        credit_amount: number;
+    }, {
+        feature_id: string;
+        credit_amount: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
     allowed: boolean;
     feature_id: string;
     customer_id: string;
-    entity_id?: string;
     required_balance: number;
-    code: string;
-    usage_limit?: number;
-    preview?: CheckFeaturePreview;
-}
+    usage_limit?: number | undefined;
+    entity_id?: string | undefined;
+    unlimited?: boolean | undefined;
+    interval?: ProductItemInterval | undefined;
+    balance?: number | undefined;
+    usage?: number | undefined;
+    included_usage?: number | undefined;
+    next_reset_at?: number | undefined;
+    overage_allowed?: boolean | undefined;
+    breakdown?: {
+        interval: ProductItemInterval;
+        balance?: number | undefined;
+        usage?: number | undefined;
+        included_usage?: number | undefined;
+        next_reset_at?: number | undefined;
+    }[] | undefined;
+    credit_schema?: {
+        feature_id: string;
+        credit_amount: number;
+    }[] | undefined;
+}, {
+    allowed: boolean;
+    feature_id: string;
+    customer_id: string;
+    required_balance: number;
+    usage_limit?: number | undefined;
+    entity_id?: string | undefined;
+    unlimited?: boolean | undefined;
+    interval?: ProductItemInterval | undefined;
+    balance?: number | undefined;
+    usage?: number | undefined;
+    included_usage?: number | undefined;
+    next_reset_at?: number | undefined;
+    overage_allowed?: boolean | undefined;
+    breakdown?: {
+        interval: ProductItemInterval;
+        balance?: number | undefined;
+        usage?: number | undefined;
+        included_usage?: number | undefined;
+        next_reset_at?: number | undefined;
+    }[] | undefined;
+    credit_schema?: {
+        feature_id: string;
+        credit_amount: number;
+    }[] | undefined;
+}>;
+type CheckFeatureResult = z.infer<typeof CheckFeatureResultSchema>;
 interface CheckFeaturePreview {
     scenario: CheckFeatureScenario;
     title: string;
@@ -65,7 +151,7 @@ interface CheckProductResult {
     allowed: boolean;
     customer_id: string;
     product_id: string;
-    code: string;
+    entity_id?: string;
     status?: string;
     preview?: CheckProductPreview;
 }
@@ -175,27 +261,86 @@ declare enum ProductStatus {
 }
 type CustomerExpandOption = "invoices" | "rewards" | "trials_used" | "entities" | "referrals" | "payment_method";
 
-interface CoreCustomerFeature {
-    unlimited?: boolean;
-    interval?: ProductItemInterval | null;
-    balance?: number;
-    usage?: number;
-    included_usage?: number;
-    next_reset_at?: number | null;
-    overage_allowed?: boolean;
-    usage_limit?: number;
+declare const CoreCusFeatureSchema: z.ZodObject<{
+    unlimited: z.ZodOptional<z.ZodBoolean>;
+    interval: z.ZodOptional<z.ZodNativeEnum<typeof ProductItemInterval>>;
+    balance: z.ZodOptional<z.ZodNumber>;
+    usage: z.ZodOptional<z.ZodNumber>;
+    included_usage: z.ZodOptional<z.ZodNumber>;
+    next_reset_at: z.ZodOptional<z.ZodNumber>;
+    overage_allowed: z.ZodOptional<z.ZodBoolean>;
+    usage_limit: z.ZodOptional<z.ZodNumber>;
+    breakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        interval: z.ZodNativeEnum<typeof ProductItemInterval>;
+        balance: z.ZodOptional<z.ZodNumber>;
+        usage: z.ZodOptional<z.ZodNumber>;
+        included_usage: z.ZodOptional<z.ZodNumber>;
+        next_reset_at: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        interval: ProductItemInterval;
+        balance?: number | undefined;
+        usage?: number | undefined;
+        included_usage?: number | undefined;
+        next_reset_at?: number | undefined;
+    }, {
+        interval: ProductItemInterval;
+        balance?: number | undefined;
+        usage?: number | undefined;
+        included_usage?: number | undefined;
+        next_reset_at?: number | undefined;
+    }>, "many">>;
+    credit_schema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        credit_amount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        feature_id: string;
+        credit_amount: number;
+    }, {
+        feature_id: string;
+        credit_amount: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    usage_limit?: number | undefined;
+    unlimited?: boolean | undefined;
+    interval?: ProductItemInterval | undefined;
+    balance?: number | undefined;
+    usage?: number | undefined;
+    included_usage?: number | undefined;
+    next_reset_at?: number | undefined;
+    overage_allowed?: boolean | undefined;
     breakdown?: {
         interval: ProductItemInterval;
-        balance?: number;
-        usage?: number;
-        included_usage?: number;
-        next_reset_at?: number;
-    }[];
+        balance?: number | undefined;
+        usage?: number | undefined;
+        included_usage?: number | undefined;
+        next_reset_at?: number | undefined;
+    }[] | undefined;
     credit_schema?: {
         feature_id: string;
         credit_amount: number;
-    }[];
-}
+    }[] | undefined;
+}, {
+    usage_limit?: number | undefined;
+    unlimited?: boolean | undefined;
+    interval?: ProductItemInterval | undefined;
+    balance?: number | undefined;
+    usage?: number | undefined;
+    included_usage?: number | undefined;
+    next_reset_at?: number | undefined;
+    overage_allowed?: boolean | undefined;
+    breakdown?: {
+        interval: ProductItemInterval;
+        balance?: number | undefined;
+        usage?: number | undefined;
+        included_usage?: number | undefined;
+        next_reset_at?: number | undefined;
+    }[] | undefined;
+    credit_schema?: {
+        feature_id: string;
+        credit_amount: number;
+    }[] | undefined;
+}>;
+type CoreCustomerFeature = z.infer<typeof CoreCusFeatureSchema>;
 interface CustomerFeature extends CoreCustomerFeature {
     id: string;
     name: string;
@@ -298,6 +443,13 @@ interface SetupPaymentResult {
     customer_id: string;
     url: string;
 }
+type QueryResult = {
+    list: Array<{
+        period: string;
+    } & {
+        [key: string]: number;
+    }>;
+};
 
 declare const AttachFeatureOptionsSchema: z.ZodObject<{
     feature_id: z.ZodString;
@@ -536,6 +688,17 @@ interface SetupPaymentParams {
     checkoutSessionParams?: Record<string, any>;
     openInNewTab?: boolean;
 }
+declare const QueryParamsSchema: z.ZodObject<{
+    featureId: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    range: z.ZodOptional<z.ZodEnum<["24h", "7d", "30d", "90d", "last_cycle"]>>;
+}, "strip", z.ZodTypeAny, {
+    featureId: string | string[];
+    range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | undefined;
+}, {
+    featureId: string | string[];
+    range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | undefined;
+}>;
+type QueryParams = z.infer<typeof QueryParamsSchema>;
 
 interface AllowedParams {
     featureId?: string;
@@ -648,8 +811,7 @@ interface UseCustomerResult {
     customer: Customer | null;
     isLoading: boolean;
     error: AutumnError | null;
-    attach: (params: AttachParams) => AutumnPromise<AttachResult>;
-    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    attach: (params: AttachParams) => AutumnPromise<AttachResult | CheckResult>;
     track: (params: TrackParams) => AutumnPromise<TrackResult>;
     cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
     setupPayment: (params: SetupPaymentParams) => AutumnPromise<SetupPaymentResult>;
@@ -659,6 +821,7 @@ interface UseCustomerResult {
     createEntity: (params: CreateEntityParams | CreateEntityParams[]) => AutumnPromise<Entity | Entity[]>;
     createReferralCode: (params: CreateReferralCodeParams) => AutumnPromise<CreateReferralCodeResult>;
     redeemReferralCode: (params: RedeemReferralCodeParams) => AutumnPromise<RedeemReferralCodeResult>;
+    check: (params: CheckParams) => CheckResult;
     allowed: (params: AllowedParams) => boolean;
 }
 interface UseCustomerParams {
@@ -683,8 +846,7 @@ declare const useEntity: (entityId: string | null, params?: GetEntityParams) =>
     isLoading: boolean;
     error: any;
     refetch: swr.KeyedMutator<Entity | null>;
-    allowed: (params: AllowedParams) => boolean;
-    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    check: (params: CheckParams) => CheckResult;
     attach: (params: AttachParams) => Promise<Result<{
         customer_id: string;
         code: string;
@@ -707,30 +869,24 @@ declare const useEntity: (entityId: string | null, params?: GetEntityParams) =>
     }>;
 };
 
-/**
- * @deprecated The functions exported from this hook can now be found in useCustomer
- */
-declare const useAutumn: () => {
-    attach: (params: AttachParams) => Promise<Result<{
-        customer_id: string;
-        code: string;
-        message: string;
-        product_ids: string[];
-        customer_data?: any;
-        checkout_url?: string | undefined;
-    } | CheckResult, AutumnError>>;
-    check: (params: CheckParams) => AutumnPromise<CheckResult>;
-    track: (params: TrackParams) => AutumnPromise<TrackResult>;
-    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
-    openBillingPortal: (params?: OpenBillingPortalParams) => AutumnPromise<BillingPortalResult>;
-    setupPayment: (params?: SetupPaymentParams) => AutumnPromise<SetupPaymentResult>;
-    checkout: (params: CheckoutParams) => Promise<{
-        data: null;
-        error: AutumnError;
-    } | {
-        data: CheckoutResult;
-        error: null;
-    }>;
+declare const useAnalytics: (params: QueryParams) => {
+    data: ({
+        period: string;
+    } & {
+        [key: string]: number;
+    })[] | undefined;
+    isLoading: boolean;
+    error: AutumnError | undefined;
+    refetch: swr.KeyedMutator<QueryResult>;
+};
+
+declare const usePaywall: ({ featureId, entityId, }: {
+    featureId?: string;
+    entityId?: string;
+}) => {
+    data: CheckFeaturePreview | undefined;
+    error: any;
+    isLoading: boolean;
 };
 
 interface AttachDialogProps {
@@ -743,7 +899,8 @@ declare function AttachDialog(params: AttachDialogProps): react_jsx_runtime.JSX.
 interface CheckDialogProps {
     open: boolean;
     setOpen: (open: boolean) => void;
-    preview: CheckFeaturePreview;
+    featureId: string;
+    entityId?: string;
 }
 declare function CheckDialog(params?: CheckDialogProps): react_jsx_runtime.JSX.Element;
 
@@ -751,4 +908,7 @@ declare function PricingTable({ productDetails, }: {
     productDetails?: any;
 }): react_jsx_runtime.JSX.Element;
 
-export { AttachDialog, ReactAutumnProvider as AutumnProvider, CheckDialog, PricingTable, type PricingTableProduct, type ProductDetails, useAutumn, useCustomer, useEntity, usePricingTable };
+/** @deprecated */
+declare const useAutumn: () => void;
+
+export { AttachDialog, ReactAutumnProvider as AutumnProvider, CheckDialog, PricingTable, type PricingTableProduct, type ProductDetails, useAnalytics, useAutumn, useCustomer, useEntity, usePaywall, usePricingTable };