autumn-js 0.0.66 → 0.0.72

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

@@ -0,0 +1,29 @@
+"use client";
+
+import {
+  AutumnContext,
+  useAutumnContext
+} from "../chunk-B7HGBQCO.mjs";
+import "../chunk-CE5BBB5H.mjs";
+import "../chunk-YUV2Y2RW.mjs";
+import "../chunk-TBCLSIC2.mjs";
+import "../chunk-EH2VPTFH.mjs";
+import "../chunk-CIBQ4BJU.mjs";
+import "../chunk-NZ5PEXT2.mjs";
+import "../chunk-TGX6UKKS.mjs";
+import "../chunk-4KKWHG2V.mjs";
+import "../chunk-LS3NB4DU.mjs";
+import "../chunk-ZNPQQ2WK.mjs";
+
+// src/libraries/react/hooks/useProductsBase.tsx
+var useProductsBase = () => {
+  const context = useAutumnContext({ AutumnContext, name: "useProducts" });
+  const fetcher = async () => {
+    const { data, error } = await context.client.products.list();
+    if (error) throw error;
+    return data?.list || [];
+  };
+};
+export {
+  useProductsBase
+};

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

@@ -1,16 +1,485 @@
-export { ReactAutumnProvider as AutumnProvider } from './ReactAutumnProvider.js';
-export { useCustomer } from './hooks/useCustomer.js';
-export { useAutumn } from './hooks/useAutumn.js';
-export { usePricingTable } from './hooks/usePricingTable.js';
-export { useEntity } from './hooks/useEntity.js';
-import 'react/jsx-runtime';
-import './cusTypes-Cf-s9PYP.js';
-import './hooks/useCustomerProvider.js';
-import './ReactAutumnClient-DNcV0gAT.js';
-import './client/types/clientReferralTypes.js';
-import './client/types/clientEntTypes.js';
-import './client/types/clientGenTypes.js';
-import './response-B1KyqUB9.js';
-import './error-CG2LXoa7.js';
-import './entTypes-BbIk0Toa.js';
-import './client/types/clientPricingTableTypes.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as swr from 'swr';
+
+interface ErrorResponse {
+    message: string;
+    code: string;
+}
+declare class AutumnError extends Error {
+    readonly message: string;
+    readonly code: string;
+    constructor(response: ErrorResponse);
+    static fromError(error: any): AutumnError;
+    toString(): string;
+    toJSON(): {
+        message: string;
+        code: string;
+    };
+}
+
+declare enum AppEnv {
+    Sandbox = "sandbox",
+    Live = "live"
+}
+
+declare const Infinite = "inf";
+declare enum FreeTrialDuration {
+    Day = "day"
+}
+declare enum UsageModel {
+    Prepaid = "prepaid",
+    PayPerUse = "pay_per_use"
+}
+type UsageModelType = "prepaid" | "pay_per_use";
+declare enum ProductItemInterval {
+    Minute = "minute",
+    Hour = "hour",
+    Day = "day",
+    Week = "week",
+    Month = "month",
+    Quarter = "quarter",
+    SemiAnnual = "semi_annual",
+    Year = "year",
+    Multiple = "multiple"
+}
+type ProductItemIntervalType = "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | "multiple";
+
+declare enum ProductStatus {
+    Active = "active",
+    Expired = "expired",
+    Trialing = "trialing",
+    Scheduled = "scheduled",
+    PastDue = "past_due"
+}
+type CustomerExpandOption = "invoices" | "rewards" | "trials_used" | "entities";
+
+interface CoreCustomerFeature {
+    unlimited?: boolean;
+    interval?: ProductItemInterval | null;
+    balance?: number;
+    usage?: number;
+    included_usage?: number;
+    next_reset_at?: number | null;
+    overage_allowed?: boolean;
+    breakdown?: {
+        interval: ProductItemInterval;
+        balance?: number;
+        usage?: number;
+        included_usage?: number;
+        next_reset_at?: number;
+    }[];
+    credit_schema?: {
+        feature_id: string;
+        credit_amount: number;
+    }[];
+}
+interface CustomerFeature extends CoreCustomerFeature {
+    id: string;
+    name: string;
+    type: "static" | "single_use" | "continuous_use";
+}
+interface CustomerProduct {
+    id: string;
+    name: string | null;
+    group: string | null;
+    status: ProductStatus;
+    started_at: number;
+    canceled_at: number | null;
+    subscription_ids?: string[] | null;
+    current_period_start?: number | null;
+    current_period_end?: number | null;
+    trial_ends_at?: number;
+    entity_id?: string;
+    is_add_on: boolean;
+    is_default: boolean;
+}
+interface Customer {
+    id: string | null;
+    created_at: number;
+    name: string | null;
+    email: string | null;
+    fingerprint: string | null;
+    stripe_id: string | null;
+    env: AppEnv;
+    metadata: Record<string, any>;
+    products: CustomerProduct[];
+    features: Record<string, CustomerFeature>;
+    invoices?: CustomerInvoice[];
+}
+interface CustomerData {
+    name?: string;
+    email?: string;
+    fingerprint?: string;
+}
+interface BillingPortalResult {
+    customer_id: string;
+    url: string;
+}
+interface CustomerInvoice {
+    product_ids: string[];
+    stripe_id: string;
+    status: string;
+    total: number;
+    currency: string;
+    created_at: number;
+}
+
+interface Entity {
+    id: string;
+    name: string;
+    customer_id: string;
+    created_at: number;
+    env: string;
+    products: CustomerProduct[];
+    features: Record<string, CustomerFeature>;
+    invoices?: CustomerInvoice[];
+}
+
+interface ProductItem {
+    feature_id?: string;
+    included_usage?: number | typeof Infinite;
+    interval?: ProductItemIntervalType;
+    usage_model?: UsageModel;
+    price?: number;
+    billing_units?: number;
+    entity_feature_id?: string;
+    reset_usage_on_billing?: boolean;
+    reset_usage_when_enabled?: boolean;
+    display?: {
+        primary_text?: string;
+        secondary_text?: string;
+    };
+}
+interface FreeTrial {
+    duration: FreeTrialDuration;
+    length: number;
+    unique_fingerprint: boolean;
+    trial_available?: boolean;
+}
+interface Product {
+    id: string;
+    created_at: number;
+    name: string;
+    env: AppEnv;
+    is_add_on: boolean;
+    is_default: boolean;
+    group: string;
+    version: number;
+    items: ProductItem[];
+    free_trial: FreeTrial | null;
+    scenario?: ProductScenario;
+    properties?: {
+        is_free?: boolean;
+        is_one_off?: boolean;
+        interval_group?: string;
+    };
+    display?: {
+        description?: string;
+        button_text?: string;
+        recommend_text?: string;
+        everything_from?: string;
+        button_url?: string;
+    };
+}
+
+type CheckFeatureScenario = "usage_limit" | "feature_flag";
+interface CheckFeatureResult extends CoreCustomerFeature {
+    allowed: boolean;
+    feature_id: string;
+    customer_id: string;
+    entity_id?: string;
+    required_balance: number;
+    code: string;
+    preview?: CheckFeaturePreview;
+}
+interface CheckFeaturePreview {
+    scenario: CheckFeatureScenario;
+    title: string;
+    message: string;
+    feature_id: string;
+    feature_name: string;
+    products: Product[];
+}
+type ProductScenario = "scheduled" | "active" | "new" | "renew" | "upgrade" | "downgrade" | "cancel";
+interface CheckProductResult {
+    allowed: boolean;
+    customer_id: string;
+    product_id: string;
+    code: string;
+    status?: string;
+    preview?: CheckProductPreview;
+}
+interface CheckProductPreview {
+    scenario: ProductScenario;
+    product_id: string;
+    product_name: string;
+    recurring: boolean;
+    error_on_attach?: boolean;
+    next_cycle_at?: number;
+    current_product_name?: string;
+    items?: {
+        price: string;
+        description: string;
+        usage_model?: UsageModelType;
+    }[];
+    options?: {
+        feature_id: string;
+        feature_name: string;
+        billing_units: number;
+        price?: number;
+        tiers?: {
+            to: number | string;
+            amount: number;
+        }[];
+    }[];
+    due_today?: {
+        price: number;
+        currency: string;
+    };
+    due_next_cycle?: {
+        price: number;
+        currency: string;
+    };
+}
+
+interface CancelResult {
+    success: boolean;
+    customer_id: string;
+    product_id: string;
+}
+interface AttachResult {
+    checkout_url?: string;
+    customer_id: string;
+    product_ids: string[];
+    code: string;
+    message: string;
+    customer_data?: CustomerData;
+}
+interface TrackResult {
+    id: string;
+    code: string;
+    customer_id: string;
+    feature_id?: string;
+    event_name?: string;
+}
+type CheckResult = CheckFeatureResult & CheckProductResult;
+
+type Success<T> = {
+    data: T;
+    error: null;
+    statusCode?: number;
+};
+type Failure<E> = {
+    data: null;
+    error: E;
+    statusCode?: number;
+};
+type Result<T, E> = Success<T> | Failure<E>;
+type AutumnPromise<T> = Promise<Result<T, AutumnError>>;
+
+interface PricingTableProduct {
+    id: string;
+    name: string;
+    description?: string;
+    button_text?: string;
+    recommend_text?: string;
+    everything_from?: string;
+    price: {
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem;
+    items: ({
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem)[];
+    scenario: ProductScenario;
+}
+
+interface CreateReferralCodeResult {
+    code: string;
+    customer_id: string;
+    created_at: number;
+}
+interface RedeemReferralCodeResult {
+    id: string;
+    customer_id: string;
+    reward_id: string;
+    applied: boolean;
+}
+
+declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, disableDialogs, }: {
+    children: React.ReactNode;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    backendUrl?: string;
+    customerData?: CustomerData;
+    includeCredentials?: boolean;
+    disableDialogs?: boolean;
+}) => react_jsx_runtime.JSX.Element;
+
+interface ProductDetails {
+    id?: string;
+    name?: string;
+    description?: string;
+    buttonText?: string;
+    buttonUrl?: string;
+    recommendText?: string;
+    everythingFrom?: string;
+    price?: {
+        primaryText: string;
+        secondaryText?: string;
+    };
+    items?: {
+        featureId?: string;
+        primaryText?: string;
+        secondaryText?: string;
+    }[];
+}
+
+interface CreateEntityParams {
+    id: string;
+    name?: string;
+    featureId: string;
+}
+interface GetEntityParams {
+    expand?: string[];
+}
+interface EntityDataParams {
+    name?: string;
+    featureId: string;
+}
+
+interface CreateReferralCodeParams {
+    programId: string;
+}
+interface RedeemReferralCodeParams {
+    code: string;
+}
+
+interface AttachFeatureOptions {
+    featureId: string;
+    quantity: number;
+}
+interface AttachParams {
+    productId?: string;
+    entityId?: string;
+    options?: AttachFeatureOptions[];
+    productIds?: string[];
+    freeTrial?: boolean;
+    successUrl?: string;
+    metadata?: Record<string, string>;
+    forceCheckout?: boolean;
+    dialog?: (data: any) => JSX.Element | React.ReactNode;
+    entityData?: EntityDataParams;
+    openInNewTab?: boolean;
+    reward?: string;
+}
+interface CancelParams {
+    productId: string;
+    entityId?: string;
+    cancelImmediately?: boolean;
+}
+interface CheckParams {
+    featureId?: string;
+    productId?: string;
+    entityId?: string;
+    requiredBalance?: number;
+    sendEvent?: boolean;
+    withPreview?: boolean;
+    dialog?: (data: any) => JSX.Element | React.ReactNode;
+    entityData?: EntityDataParams;
+}
+interface TrackParams {
+    featureId?: string;
+    eventName?: string;
+    entityId?: string;
+    value?: number;
+    idempotencyKey?: string;
+    entityData?: EntityDataParams;
+}
+interface OpenBillingPortalParams {
+    returnUrl?: string;
+    openInNewTab?: boolean;
+}
+
+interface AllowedParams {
+    featureId?: string;
+    productId?: string;
+    requiredBalance?: number;
+}
+
+interface UseCustomerResult {
+    customer: Customer | null;
+    isLoading: boolean;
+    error: AutumnError | null;
+    attach: (params: AttachParams) => AutumnPromise<AttachResult>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    openBillingPortal: (params?: OpenBillingPortalParams) => AutumnPromise<BillingPortalResult>;
+    refetch: () => Promise<Customer | null>;
+    createEntity: (params: CreateEntityParams | CreateEntityParams[]) => AutumnPromise<Entity | Entity[]>;
+    createReferralCode: (params: CreateReferralCodeParams) => AutumnPromise<CreateReferralCodeResult>;
+    redeemReferralCode: (params: RedeemReferralCodeParams) => AutumnPromise<RedeemReferralCodeResult>;
+    allowed: (params: AllowedParams) => boolean;
+}
+interface UseCustomerParams {
+    errorOnNotFound?: boolean;
+    expand?: CustomerExpandOption[];
+}
+
+declare const useCustomer: (params?: UseCustomerParams) => UseCustomerResult;
+
+declare const usePricingTable: (params?: {
+    productDetails?: ProductDetails[];
+}) => {
+    products: Product[] | null;
+    isLoading: boolean;
+    error: AutumnError | undefined;
+    refetch: swr.KeyedMutator<Product[]>;
+};
+
+declare const useEntity: (entityId: string | null, params?: GetEntityParams) => {
+    entity: null;
+    isLoading: boolean;
+    error: null;
+    refetch: swr.KeyedMutator<Entity | null>;
+    allowed?: undefined;
+} | {
+    entity: Entity | null;
+    isLoading: boolean;
+    error: any;
+    refetch: swr.KeyedMutator<Entity | null>;
+    allowed: (params: AllowedParams) => boolean;
+};
+
+/**
+ * @deprecated The functions exported from this hook can now be found in useCustomer
+ */
+declare const useAutumn: () => {
+    attach: (params: AttachParams) => Promise<Result<AttachResult | CheckResult, AutumnError>>;
+    check: (params: CheckParams) => AutumnPromise<CheckResult>;
+    track: (params: TrackParams) => AutumnPromise<TrackResult>;
+    cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
+    openBillingPortal: (params?: OpenBillingPortalParams) => AutumnPromise<BillingPortalResult>;
+};
+
+interface AttachDialogProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    preview: CheckProductPreview;
+    onClick: (options?: any) => Promise<void>;
+}
+declare function AttachDialog(params?: AttachDialogProps): react_jsx_runtime.JSX.Element;
+
+interface CheckDialogProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    preview: CheckFeaturePreview;
+}
+declare function CheckDialog(params?: CheckDialogProps): react_jsx_runtime.JSX.Element;
+
+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 };