@onborn/billing 0.1.0-beta.1

package/dist/client.d.ts

@@ -0,0 +1,58 @@
+import { type CustomerEntitlementsResponse, type GetOfferingResponse, type GetPaywallResponse, type PurchaseValidationResponse, type RestorePurchasesRequest, type ValidatePurchaseRequest } from "@onborn/sdk-contracts";
+export type BillingClientOptions = {
+    sourceId?: string;
+};
+export declare class BillingClient {
+    private readonly options;
+    private readonly config;
+    private readonly userId;
+    private readonly fetchImpl;
+    private readonly emitAnalyticsEvents;
+    constructor(options?: BillingClientOptions);
+    loadPaywall(paywallId: string): Promise<GetPaywallResponse>;
+    loadOffering(offeringId: string): Promise<GetOfferingResponse>;
+    validatePurchase(input: Omit<ValidatePurchaseRequest, "userId">): Promise<PurchaseValidationResponse>;
+    restorePurchases(input: Omit<RestorePurchasesRequest, "userId">): Promise<PurchaseValidationResponse>;
+    loadCustomerEntitlements(): Promise<CustomerEntitlementsResponse>;
+    trackPaywallPackageSelected(params: PaywallPackageEvent & {
+        packageId: string;
+    }): Promise<void>;
+    trackPaywallPurchaseStarted(params: PaywallPackageEvent): Promise<void>;
+    trackPaywallTrialStarted(params: PaywallPackageEvent & {
+        trialPeriod?: string;
+    }): Promise<void>;
+    trackPaywallPurchaseFailed(params: PaywallPackageEvent & {
+        reason: "cancelled" | "error" | "pending";
+        message?: string;
+    }): Promise<void>;
+    trackPaywallConverted(params: PaywallBaseEvent & {
+        productId: string;
+        priceUsd?: number;
+    }): Promise<void>;
+    trackPaywallRestoreStarted(params: PaywallBaseEvent): Promise<void>;
+    trackPaywallRestoreCompleted(params: PaywallBaseEvent & {
+        restored: boolean;
+    }): Promise<void>;
+    trackPaywallRestoreFailed(params: PaywallBaseEvent & {
+        message?: string;
+    }): Promise<void>;
+    flushEvents(): Promise<void>;
+    private runtimeUrl;
+    private getJson;
+    private sendPurchaseRequest;
+    private authorizationHeaders;
+    private track;
+}
+type PaywallBaseEvent = {
+    sessionId: string;
+    stepId: string;
+    paywallId?: string;
+    paywallTemplate: string;
+    variant?: string;
+};
+type PaywallPackageEvent = PaywallBaseEvent & {
+    packageId?: string;
+    productId?: string;
+};
+export declare function createBillingClient(options?: BillingClientOptions): BillingClient;
+export {};

package/dist/client.js

@@ -0,0 +1,148 @@
+import { Onborn, } from "@onborn/analytics";
+import { resolveOnbornBillingConfig } from "./runtime";
+import { CustomerEntitlementsResponseSchema, GetOfferingResponseSchema, GetPaywallResponseSchema, PurchaseValidationResponseSchema, } from "@onborn/sdk-contracts";
+const ONBORN_API_BASE_URL = "https://api.testing.onborn.app";
+export class BillingClient {
+    options;
+    config;
+    userId;
+    fetchImpl;
+    emitAnalyticsEvents;
+    constructor(options = {}) {
+        this.options = options;
+        this.config = resolveOnbornBillingConfig();
+        this.userId = this.config.userId ?? createAnonymousUserId();
+        this.fetchImpl = this.config.fetchImpl ?? fetch;
+        this.emitAnalyticsEvents = this.config.emitAnalyticsEvents !== false;
+    }
+    async loadPaywall(paywallId) {
+        const url = this.runtimeUrl(`/paywalls/${encodeURIComponent(paywallId)}`);
+        const payload = await this.getJson(url, `paywall '${paywallId}'`);
+        const parsed = GetPaywallResponseSchema.safeParse(payload);
+        if (!parsed.success) {
+            throw new Error("Invalid paywall response payload");
+        }
+        return parsed.data;
+    }
+    async loadOffering(offeringId) {
+        const url = this.runtimeUrl(`/offerings/${encodeURIComponent(offeringId)}`);
+        const payload = await this.getJson(url, `offering '${offeringId}'`);
+        const parsed = GetOfferingResponseSchema.safeParse(payload);
+        if (!parsed.success) {
+            throw new Error("Invalid offering response payload");
+        }
+        return parsed.data;
+    }
+    async validatePurchase(input) {
+        return this.sendPurchaseRequest("/purchases/validate", {
+            ...input,
+            userId: this.userId,
+        });
+    }
+    async restorePurchases(input) {
+        return this.sendPurchaseRequest("/purchases/restore", {
+            ...input,
+            userId: this.userId,
+        });
+    }
+    async loadCustomerEntitlements() {
+        const url = new URL(`${ONBORN_API_BASE_URL}/entitlements`);
+        url.searchParams.set("userId", this.userId);
+        const payload = await this.getJson(url, "customer entitlements");
+        const parsed = CustomerEntitlementsResponseSchema.safeParse(payload);
+        if (!parsed.success) {
+            throw new Error("Invalid customer entitlements response payload");
+        }
+        return parsed.data;
+    }
+    trackPaywallPackageSelected(params) {
+        return this.track({ type: "paywall_package_selected", ...params });
+    }
+    trackPaywallPurchaseStarted(params) {
+        return this.track({ type: "paywall_purchase_started", ...params });
+    }
+    trackPaywallTrialStarted(params) {
+        return this.track({ type: "paywall_trial_started", ...params });
+    }
+    trackPaywallPurchaseFailed(params) {
+        return this.track({ type: "paywall_purchase_failed", ...params });
+    }
+    trackPaywallConverted(params) {
+        return this.track({ type: "paywall_converted", ...params });
+    }
+    trackPaywallRestoreStarted(params) {
+        return this.track({ type: "paywall_restore_started", ...params });
+    }
+    trackPaywallRestoreCompleted(params) {
+        return this.track({ type: "paywall_restore_completed", ...params });
+    }
+    trackPaywallRestoreFailed(params) {
+        return this.track({ type: "paywall_restore_failed", ...params });
+    }
+    async flushEvents() {
+        if (this.emitAnalyticsEvents) {
+            await Onborn.flush();
+        }
+    }
+    runtimeUrl(path) {
+        const url = new URL(`${ONBORN_API_BASE_URL}${path}`);
+        appendParam(url, "userId", this.userId);
+        appendParam(url, "locale", this.config.locale);
+        appendParam(url, "platform", this.config.platform);
+        appendParam(url, "country", this.config.country);
+        appendParam(url, "appVersion", this.config.appVersion);
+        appendParam(url, "userType", this.config.userType);
+        return url;
+    }
+    async getJson(url, label) {
+        const response = await this.fetchImpl(url.toString(), {
+            headers: this.authorizationHeaders(),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${label} (${response.status})`);
+        }
+        return response.json();
+    }
+    async sendPurchaseRequest(path, payload) {
+        const response = await this.fetchImpl(`${ONBORN_API_BASE_URL}${path}`, {
+            method: "POST",
+            headers: {
+                ...this.authorizationHeaders(),
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Purchase request failed (${response.status})`);
+        }
+        const parsed = PurchaseValidationResponseSchema.safeParse(await response.json());
+        if (!parsed.success) {
+            throw new Error("Invalid purchase validation response payload");
+        }
+        return parsed.data;
+    }
+    authorizationHeaders() {
+        return { Authorization: `Bearer ${this.config.apiKey}` };
+    }
+    async track(input) {
+        if (!this.emitAnalyticsEvents) {
+            return;
+        }
+        await Onborn.track({
+            ...input,
+            flowId: this.options.sourceId ?? "billing",
+            userId: this.userId,
+        });
+    }
+}
+export function createBillingClient(options = {}) {
+    return new BillingClient(options);
+}
+function appendParam(url, key, value) {
+    if (value) {
+        url.searchParams.set(key, value);
+    }
+}
+function createAnonymousUserId() {
+    return `anon-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./adapters";
+export * from "./client";
+export * from "./runtime";
+export * from "./types";
+export * from "./useOnbornEntitlements";
+export * from "./useOnbornOffering";
+export * from "./useOnbornPaywall";
+export * from "./utils";
+export * from "./validation";

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./adapters";
+export * from "./client";
+export * from "./runtime";
+export * from "./types";
+export * from "./useOnbornEntitlements";
+export * from "./useOnbornOffering";
+export * from "./useOnbornPaywall";
+export * from "./utils";
+export * from "./validation";

package/dist/runtime.d.ts

@@ -0,0 +1,5 @@
+import { Onborn, type OnbornConfig } from "@onborn/analytics";
+export { Onborn };
+export type { OnbornConfig };
+export declare function resolveOnbornBillingConfig<T extends object>(overrides?: T): T & OnbornConfig;
+export declare function useOnbornBillingConfig<T extends object>(overrides?: T): T & OnbornConfig;

package/dist/runtime.js

@@ -0,0 +1,38 @@
+import { Onborn, } from "@onborn/analytics";
+const GLOBAL_CONFIG_KEYS = [
+    "apiKey",
+    "userId",
+    "locale",
+    "appId",
+    "platform",
+    "country",
+    "appVersion",
+    "userType",
+    "sdkVersion",
+    "fetchImpl",
+    "emitAnalyticsEvents",
+    "emitSdkConnectionSignal",
+    "autoFlushMs",
+    "maxAnalyticsBatchSize",
+    "maxAnalyticsQueueSize",
+    "analyticsQueueKey",
+    "analyticsStorage",
+];
+export { Onborn };
+export function resolveOnbornBillingConfig(overrides) {
+    const globalConfig = Onborn.getConfig();
+    if (!globalConfig) {
+        throw new Error("Onborn is not initialized. Call Onborn.init({ apiKey, ...config }) before using Onborn billing hooks.");
+    }
+    const safeOverrides = { ...(overrides ?? {}) };
+    for (const key of GLOBAL_CONFIG_KEYS) {
+        delete safeOverrides[key];
+    }
+    return {
+        ...globalConfig,
+        ...safeOverrides,
+    };
+}
+export function useOnbornBillingConfig(overrides) {
+    return resolveOnbornBillingConfig(overrides);
+}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+import type { BillingOffering, BillingPlatform, BillingPackage, BillingProduct, CustomerEntitlement, GetFlowResponse, GetOfferingResponse, GetPaywallResponse, NativeStoreRestoredPurchase, PaywallConfig, PurchaseStatus } from "@onborn/sdk-contracts";
+export type { CustomerEntitlement } from "@onborn/sdk-contracts";
+export type OnbornPackageWithProduct = {
+    package: BillingPackage;
+    product?: BillingProduct;
+};
+export type OnbornPurchaseInput = {
+    paywall?: PaywallConfig;
+    offering: BillingOffering;
+    package: BillingPackage;
+    product?: BillingProduct;
+    userId?: string;
+};
+export type OnbornPurchaseResult = {
+    success: boolean;
+    status?: PurchaseStatus;
+    purchaseId?: string;
+    transactionId?: string;
+    purchaseToken?: string;
+    receipt?: string;
+    productId?: string;
+    packageId?: string;
+    entitlementIds?: string[];
+    activeProductIds?: string[];
+    entitlements?: CustomerEntitlement[];
+    raw?: unknown;
+};
+export type OnbornRestoreInput = {
+    paywall?: PaywallConfig;
+    offering?: BillingOffering;
+    products: BillingProduct[];
+    userId?: string;
+};
+export type OnbornLoadProductsInput = {
+    paywall?: PaywallConfig;
+    offering?: BillingOffering;
+    products: BillingProduct[];
+    userId?: string;
+};
+export type OnbornRestoreResult = {
+    success: boolean;
+    status?: PurchaseStatus;
+    purchaseId?: string;
+    entitlementIds?: string[];
+    activeProductIds?: string[];
+    purchases?: NativeStoreRestoredPurchase[];
+    entitlements?: CustomerEntitlement[];
+    raw?: unknown;
+};
+export type OnbornBillingAdapter = {
+    loadProducts?: (input: OnbornLoadProductsInput) => Promise<BillingProduct[]>;
+    purchasePackage: (input: OnbornPurchaseInput) => Promise<OnbornPurchaseResult>;
+    restorePurchases?: (input: OnbornRestoreInput) => Promise<OnbornRestoreResult>;
+    refetchCustomerEntitlements?: (input: {
+        userId?: string;
+    }) => Promise<OnbornRestoreResult>;
+};
+export type OnbornPaywallRuntimeContext = {
+    paywall?: PaywallConfig;
+    offering?: BillingOffering;
+    products?: BillingProduct[];
+    platform?: BillingPlatform;
+    presentationMode?: "standalone" | "flow";
+    experiment?: NonNullable<GetFlowResponse["experiment"]>;
+    selectedPackageId?: string;
+    onSelectPackage?: (packageId: string) => void;
+    onPurchaseSelectedPackage?: () => void;
+    onRestorePurchases?: () => void;
+    onDismissPaywall?: () => void;
+    onLinkPress?: (link: {
+        url: string;
+        label?: string;
+    }) => void;
+    purchasing?: boolean;
+    restoring?: boolean;
+};
+export type OnbornPaywallData = GetPaywallResponse;
+export type OnbornOfferingData = GetOfferingResponse;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/useOnbornEntitlements.d.ts

@@ -0,0 +1,12 @@
+import { type CustomerEntitlementsResponse } from "@onborn/sdk-contracts";
+export type UseOnbornEntitlementsOptions = {
+    autoLoad?: boolean;
+};
+export type UseOnbornEntitlementsState = {
+    data: CustomerEntitlementsResponse | null;
+    loading: boolean;
+    error: string | null;
+    reload: () => Promise<CustomerEntitlementsResponse>;
+    hasEntitlement: (keyOrId: string) => boolean;
+};
+export declare function useOnbornEntitlements(options?: UseOnbornEntitlementsOptions): UseOnbornEntitlementsState;

package/dist/useOnbornEntitlements.js

@@ -0,0 +1,59 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { createBillingClient } from "./client";
+import { useOnbornBillingConfig } from "./runtime";
+export function useOnbornEntitlements(options = {}) {
+    const runtimeOptions = useOnbornBillingConfig(options);
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(options.autoLoad !== false);
+    const [error, setError] = useState(null);
+    const client = useMemo(() => createBillingClient({
+        sourceId: "entitlements",
+    }), [
+        runtimeOptions.apiKey,
+        runtimeOptions.appId,
+        runtimeOptions.appVersion,
+        runtimeOptions.autoFlushMs,
+        runtimeOptions.emitAnalyticsEvents,
+        runtimeOptions.emitSdkConnectionSignal,
+        runtimeOptions.fetchImpl,
+        runtimeOptions.locale,
+        runtimeOptions.platform,
+        runtimeOptions.sdkVersion,
+        runtimeOptions.userId,
+    ]);
+    const reload = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await client.loadCustomerEntitlements();
+            setData(response);
+            return response;
+        }
+        catch (loadError) {
+            const message = toError(loadError).message;
+            setError(message);
+            throw loadError;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client]);
+    useEffect(() => {
+        if (options.autoLoad === false) {
+            return;
+        }
+        void reload();
+    }, [options.autoLoad, reload]);
+    const hasEntitlement = useCallback((keyOrId) => data?.entitlements.some((item) => item.active &&
+        (item.key === keyOrId || item.entitlementId === keyOrId)) ?? false, [data?.entitlements]);
+    return {
+        data,
+        loading,
+        error,
+        reload,
+        hasEntitlement,
+    };
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error("Unknown error");
+}

package/dist/useOnbornOffering.d.ts

@@ -0,0 +1,29 @@
+import { type CustomerEntitlement, type GetOfferingResponse } from "@onborn/sdk-contracts";
+import type { OnbornBillingAdapter, OnbornPackageWithProduct, OnbornPurchaseResult, OnbornRestoreResult } from "./types";
+export type UseOnbornOfferingOptions = {
+    offeringId: string;
+    initialPackageId?: string;
+    billingAdapter?: OnbornBillingAdapter;
+    onPurchaseStarted?: (item: OnbornPackageWithProduct) => void;
+    onPurchaseCompleted?: (result: OnbornPurchaseResult) => void;
+    onPurchaseFailed?: (error: Error) => void;
+    onRestoreCompleted?: (result: OnbornRestoreResult) => void;
+    onRestoreFailed?: (error: Error) => void;
+    onEntitlementsChanged?: (entitlements: CustomerEntitlement[]) => void;
+};
+export type UseOnbornOfferingState = {
+    data: GetOfferingResponse | null;
+    packages: OnbornPackageWithProduct[];
+    selectedPackage: OnbornPackageWithProduct | null;
+    selectedPackageId: string | null;
+    loading: boolean;
+    purchasing: boolean;
+    restoring: boolean;
+    error: string | null;
+    selectPackage: (packageId: string) => void;
+    reload: () => Promise<void>;
+    purchasePackage: (packageId?: string) => Promise<OnbornPurchaseResult>;
+    restorePurchases: () => Promise<OnbornRestoreResult>;
+    refetchCustomerEntitlements: () => Promise<OnbornRestoreResult>;
+};
+export declare function useOnbornOffering(options: UseOnbornOfferingOptions): UseOnbornOfferingState;

package/dist/useOnbornOffering.js

@@ -0,0 +1,194 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { createBillingClient } from "./client";
+import { useOnbornBillingConfig } from "./runtime";
+import { findPackageWithProduct, getPackagesWithProducts, resolveDefaultPackageId, } from "./utils";
+import { validateBillingPurchase, validateBillingRestore } from "./validation";
+export function useOnbornOffering(options) {
+    const runtimeOptions = useOnbornBillingConfig(options);
+    const [data, setData] = useState(null);
+    const [selectedPackageId, setSelectedPackageId] = useState(runtimeOptions.initialPackageId ?? null);
+    const [loading, setLoading] = useState(true);
+    const [purchasing, setPurchasing] = useState(false);
+    const [restoring, setRestoring] = useState(false);
+    const [error, setError] = useState(null);
+    const client = useMemo(() => createBillingClient({
+        sourceId: `offering:${runtimeOptions.offeringId}`,
+    }), [
+        runtimeOptions.apiKey,
+        runtimeOptions.appId,
+        runtimeOptions.appVersion,
+        runtimeOptions.autoFlushMs,
+        runtimeOptions.country,
+        runtimeOptions.emitAnalyticsEvents,
+        runtimeOptions.emitSdkConnectionSignal,
+        runtimeOptions.fetchImpl,
+        runtimeOptions.locale,
+        runtimeOptions.offeringId,
+        runtimeOptions.platform,
+        runtimeOptions.sdkVersion,
+        runtimeOptions.userId,
+        runtimeOptions.userType,
+    ]);
+    const packages = useMemo(() => getPackagesWithProducts(data?.offering, data?.products, runtimeOptions.platform), [data?.offering, data?.products, runtimeOptions.platform]);
+    const selectedPackage = useMemo(() => {
+        const fallbackPackageId = selectedPackageId ?? resolveDefaultPackageId(data?.offering);
+        return findPackageWithProduct(packages, fallbackPackageId) ?? null;
+    }, [data?.offering, packages, selectedPackageId]);
+    const load = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await client.loadOffering(runtimeOptions.offeringId);
+            const products = await loadLocalizedProducts(runtimeOptions.billingAdapter, {
+                offering: response.offering,
+                products: response.products,
+                userId: runtimeOptions.userId,
+            });
+            setData({ ...response, products });
+            setSelectedPackageId((current) => {
+                if (current &&
+                    response.offering.packages.some((item) => item.id === current)) {
+                    return current;
+                }
+                return resolveDefaultPackageId(response.offering) ?? null;
+            });
+        }
+        catch (loadError) {
+            setError(toErrorMessage(loadError));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [
+        client,
+        runtimeOptions.billingAdapter,
+        runtimeOptions.offeringId,
+        runtimeOptions.userId,
+    ]);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    const selectPackage = useCallback((packageId) => {
+        setSelectedPackageId(packageId);
+    }, []);
+    const purchasePackage = useCallback(async (packageId) => {
+        const item = findPackageWithProduct(packages, packageId) ?? selectedPackage;
+        if (!item || !data?.offering) {
+            throw new Error("No offering package selected");
+        }
+        if (!runtimeOptions.billingAdapter) {
+            throw new Error("Missing ONBORN billingAdapter. Provide one to purchase from a custom paywall.");
+        }
+        setPurchasing(true);
+        runtimeOptions.onPurchaseStarted?.(item);
+        try {
+            const adapterResult = await runtimeOptions.billingAdapter.purchasePackage({
+                offering: data.offering,
+                package: item.package,
+                product: item.product,
+                userId: runtimeOptions.userId,
+            });
+            const result = adapterResult.success
+                ? await validateBillingPurchase({
+                    client,
+                    offering: data.offering,
+                    item,
+                    result: adapterResult,
+                })
+                : adapterResult;
+            runtimeOptions.onPurchaseCompleted?.(result);
+            notifyEntitlementsChanged(result.entitlements, runtimeOptions.onEntitlementsChanged);
+            return result;
+        }
+        catch (purchaseError) {
+            const errorObject = toError(purchaseError);
+            runtimeOptions.onPurchaseFailed?.(errorObject);
+            throw errorObject;
+        }
+        finally {
+            setPurchasing(false);
+        }
+    }, [client, data?.offering, runtimeOptions, packages, selectedPackage]);
+    const restorePurchases = useCallback(async () => {
+        if (!runtimeOptions.billingAdapter?.restorePurchases) {
+            throw new Error("Missing restorePurchases on ONBORN billingAdapter.");
+        }
+        setRestoring(true);
+        try {
+            const adapterResult = await runtimeOptions.billingAdapter.restorePurchases({
+                offering: data?.offering,
+                products: data?.products ?? [],
+                userId: runtimeOptions.userId,
+            });
+            const result = await validateBillingRestore({
+                client,
+                offering: data?.offering,
+                result: adapterResult,
+            });
+            runtimeOptions.onRestoreCompleted?.(result);
+            notifyEntitlementsChanged(result.entitlements, runtimeOptions.onEntitlementsChanged);
+            return result;
+        }
+        catch (restoreError) {
+            const errorObject = toError(restoreError);
+            runtimeOptions.onRestoreFailed?.(errorObject);
+            throw errorObject;
+        }
+        finally {
+            setRestoring(false);
+        }
+    }, [client, data, runtimeOptions]);
+    const refetchCustomerEntitlements = useCallback(async () => {
+        if (!runtimeOptions.billingAdapter?.refetchCustomerEntitlements) {
+            throw new Error("Missing refetchCustomerEntitlements on ONBORN billingAdapter.");
+        }
+        const adapterResult = await runtimeOptions.billingAdapter.refetchCustomerEntitlements({
+            userId: runtimeOptions.userId,
+        });
+        const result = await validateBillingRestore({
+            client,
+            offering: data?.offering,
+            result: adapterResult,
+        });
+        notifyEntitlementsChanged(result.entitlements, runtimeOptions.onEntitlementsChanged);
+        return result;
+    }, [client, data?.offering, runtimeOptions]);
+    return {
+        data,
+        packages,
+        selectedPackage,
+        selectedPackageId: selectedPackage?.package.id ?? null,
+        loading,
+        purchasing,
+        restoring,
+        error,
+        selectPackage,
+        reload: load,
+        purchasePackage,
+        restorePurchases,
+        refetchCustomerEntitlements,
+    };
+}
+function toErrorMessage(error) {
+    return toError(error).message;
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error("Unknown error");
+}
+async function loadLocalizedProducts(billingAdapter, input) {
+    if (!billingAdapter?.loadProducts) {
+        return input.products;
+    }
+    try {
+        return await billingAdapter.loadProducts(input);
+    }
+    catch {
+        return input.products;
+    }
+}
+function notifyEntitlementsChanged(entitlements, callback) {
+    if (!entitlements) {
+        return;
+    }
+    callback?.(entitlements);
+}

package/dist/useOnbornPaywall.d.ts

@@ -0,0 +1,31 @@
+import { type CustomerEntitlement, type GetPaywallResponse } from "@onborn/sdk-contracts";
+import type { OnbornBillingAdapter, OnbornPackageWithProduct, OnbornPurchaseResult, OnbornRestoreResult } from "./types";
+export type UseOnbornPaywallOptions = {
+    paywallId: string;
+    initialPackageId?: string;
+    billingAdapter?: OnbornBillingAdapter;
+    onStartTrial?: (item: OnbornPackageWithProduct) => void | false | Promise<void | false>;
+    onPurchaseStarted?: (item: OnbornPackageWithProduct) => void;
+    onPurchaseCompleted?: (result: OnbornPurchaseResult) => void;
+    onPurchaseFailed?: (error: Error) => void;
+    onRestoreCompleted?: (result: OnbornRestoreResult) => void;
+    onRestoreFailed?: (error: Error) => void;
+    onEntitlementsChanged?: (entitlements: CustomerEntitlement[]) => void;
+};
+export type UseOnbornPaywallState = {
+    data: GetPaywallResponse | null;
+    packages: OnbornPackageWithProduct[];
+    selectedPackage: OnbornPackageWithProduct | null;
+    selectedPackageId: string | null;
+    loading: boolean;
+    purchasing: boolean;
+    restoring: boolean;
+    error: string | null;
+    selectPackage: (packageId: string) => void;
+    reload: () => Promise<void>;
+    purchasePackage: (packageId?: string) => Promise<OnbornPurchaseResult>;
+    startTrialPackage: (packageId?: string) => Promise<OnbornPurchaseResult>;
+    restorePurchases: () => Promise<OnbornRestoreResult>;
+    refetchCustomerEntitlements: () => Promise<OnbornRestoreResult>;
+};
+export declare function useOnbornPaywall(options: UseOnbornPaywallOptions): UseOnbornPaywallState;