@openrails/billing-ui 0.0.0-stage → 0.230.0

package/dist/react/hooks.d.ts

@@ -0,0 +1,76 @@
+import { SendSolanaTransaction, SolanaCancelStage } from '../client/client';
+import { BillingError } from '../client/errors';
+import { NewCard, Payment, PaymentMethod, Product, Subscription, TierChange } from '../client/types';
+export type ActionResult = Promise<BillingError | null>;
+export type SubscriptionAction = "cancel" | "resume" | "payment_method" | "change_tier" | SolanaCancelStage;
+export interface SubscriptionsOptions {
+    /** Server filter; default `all`. */
+    status?: string;
+    limit?: number;
+}
+export interface SubscriptionsState {
+    subscriptions: Subscription[] | null;
+    total: number | null;
+    loading: boolean;
+    error: BillingError | null;
+    refetch: () => void;
+    /** In-flight action per subscription id. */
+    pending: Readonly<Record<string, SubscriptionAction>>;
+    cancel: (subscriptionId: string, feedback: string) => ActionResult;
+    /** Solana rail: the wallet signs the server-prepared cancel transaction. */
+    cancelOnChain: (subscriptionId: string, sendTransaction: SendSolanaTransaction) => ActionResult;
+    resume: (subscriptionId: string) => ActionResult;
+    setPaymentMethod: (subscriptionId: string, paymentMethodId: string) => ActionResult;
+    /**
+     * Card rails: `client.changeTier`. Resolves to the change, whose `status`
+     * may still be `processing` or `requires_action`, or to the error.
+     */
+    changeTier: (subscriptionId: string, input: {
+        priceId: string;
+        idempotencyKey: string;
+    }) => Promise<TierChange | BillingError>;
+}
+export declare function useSubscriptions(options?: SubscriptionsOptions): SubscriptionsState;
+export interface ProductsState {
+    products: Product[] | null;
+    total: number | null;
+    loading: boolean;
+    error: BillingError | null;
+    refetch: () => void;
+}
+/** The catalog: active products with their active prices. */
+export declare function useProducts(options?: {
+    limit?: number;
+}): ProductsState;
+export type PaymentMethodAction = "remove" | "default";
+export interface PaymentMethodsState {
+    methods: PaymentMethod[] | null;
+    loading: boolean;
+    error: BillingError | null;
+    refetch: () => void;
+    pending: Readonly<Record<string, PaymentMethodAction>>;
+    adding: boolean;
+    add: (card: NewCard) => ActionResult;
+    remove: (paymentMethodId: string) => ActionResult;
+    /** Default collector for one currency's invoices. */
+    setDefault: (paymentMethodId: string, currency: string) => ActionResult;
+}
+export declare function usePaymentMethods(): PaymentMethodsState;
+export interface PaymentsOptions {
+    pageSize?: number;
+    /** Filter by rail. */
+    rail?: string;
+}
+export interface PaymentsState {
+    payments: Payment[] | null;
+    /** Zero-based. */
+    page: number;
+    hasMore: boolean;
+    total: number | null;
+    loading: boolean;
+    error: BillingError | null;
+    next: () => void;
+    previous: () => void;
+    refetch: () => void;
+}
+export declare function usePayments(options?: PaymentsOptions): PaymentsState;

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export { BillingProvider, type BillingProviderProps } from './provider';
+export { useBillingClient, useBillingRefresh, useOptionalBillingContext, type BillingChange, type BillingContextValue, } from './context';
+export { usePaymentMethods, usePayments, useProducts, useSubscriptions, type ActionResult, type PaymentMethodAction, type PaymentMethodsState, type PaymentsOptions, type PaymentsState, type ProductsState, type SubscriptionAction, type SubscriptionsOptions, type SubscriptionsState, } from './hooks';

package/dist/react/provider.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { BillingClient } from '../client/client';
+import { BillingChange } from './context';
+export interface BillingProviderProps {
+    client: BillingClient;
+    /** Fires after each successful mutation: the host's cache-invalidation hook. */
+    onChange?: (change: BillingChange) => void;
+    /**
+     * Cancel and resume are queued server-side (202); hooks re-read the
+     * subscription until the change shows. Default 1000 ms x 10.
+     */
+    settle?: {
+        intervalMs?: number;
+        attempts?: number;
+    };
+    children?: ReactNode;
+}
+export declare function BillingProvider({ client, onChange, settle, children, }: BillingProviderProps): import("react").JSX.Element;

package/dist/react/remote.d.ts

@@ -0,0 +1,11 @@
+import { BillingError } from '../client/errors';
+export interface RemoteState<T> {
+    data: T | null;
+    loading: boolean;
+    error: BillingError | null;
+    refetch: () => void;
+}
+export declare function useRemote<T>(key: string, load: (signal: AbortSignal) => Promise<T>): RemoteState<T> & {
+    replace: (update: (data: T) => T) => void;
+};
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/react.js

@@ -0,0 +1,37 @@
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, t as s } from "./hooks-DLFF-zx5.js";
+import { useCallback as c, useEffect as l, useMemo as u, useRef as d, useState as f } from "react";
+import { jsx as p } from "react/jsx-runtime";
+//#region src/react/provider.tsx
+function m({ client: t, onChange: n, settle: r, children: i }) {
+	let [a, o] = f(0), s = d(n);
+	l(() => {
+		s.current = n;
+	});
+	let m = c((e) => {
+		o((e) => e + 1), s.current?.(e);
+	}, []), h = c(() => o((e) => e + 1), []), g = r?.intervalMs ?? 1e3, _ = r?.attempts ?? 10, v = u(() => ({
+		client: t,
+		version: a,
+		notify: m,
+		refresh: h,
+		settle: {
+			intervalMs: g,
+			attempts: _
+		}
+	}), [
+		t,
+		a,
+		m,
+		h,
+		g,
+		_
+	]);
+	return /* @__PURE__ */ p(e.Provider, {
+		value: v,
+		children: i
+	});
+}
+//#endregion
+export { m as BillingProvider, a as useBillingClient, t as useBillingRefresh, r as useOptionalBillingContext, s as usePaymentMethods, i as usePayments, o as useProducts, n as useSubscriptions };
+
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../src/react/provider.tsx"],"sourcesContent":["import {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ReactNode,\n} from \"react\"\n\nimport type { BillingClient } from \"../client/client\"\nimport { BillingContext, type BillingChange } from \"./context\"\n\nexport interface BillingProviderProps {\n  client: BillingClient\n  /** Fires after each successful mutation: the host's cache-invalidation hook. */\n  onChange?: (change: BillingChange) => void\n  /**\n   * Cancel and resume are queued server-side (202); hooks re-read the\n   * subscription until the change shows. Default 1000 ms x 10.\n   */\n  settle?: { intervalMs?: number; attempts?: number }\n  children?: ReactNode\n}\n\nexport function BillingProvider({\n  client,\n  onChange,\n  settle,\n  children,\n}: BillingProviderProps) {\n  const [version, setVersion] = useState(0)\n  const onChangeRef = useRef(onChange)\n  useEffect(() => {\n    onChangeRef.current = onChange\n  })\n  const notify = useCallback((change: BillingChange) => {\n    setVersion((v) => v + 1)\n    onChangeRef.current?.(change)\n  }, [])\n  const refresh = useCallback(() => setVersion((v) => v + 1), [])\n  const intervalMs = settle?.intervalMs ?? 1000\n  const attempts = settle?.attempts ?? 10\n  const value = useMemo(\n    () => ({\n      client,\n      version,\n      notify,\n      refresh,\n      settle: { intervalMs, attempts },\n    }),\n    [client, version, notify, refresh, intervalMs, attempts]\n  )\n  return (\n    <BillingContext.Provider value={value}>{children}</BillingContext.Provider>\n  )\n}\n"],"mappings":";;;;AAwBA,SAAgB,EAAgB,EAC9B,WACA,aACA,WACA,eACuB;CACvB,IAAM,CAAC,GAAS,KAAc,EAAS,CAAC,GAClC,IAAc,EAAO,CAAQ;CACnC,QAAgB;EACd,EAAY,UAAU;CACxB,CAAC;CACD,IAAM,IAAS,GAAa,MAA0B;EAEpD,AADA,GAAY,MAAM,IAAI,CAAC,GACvB,EAAY,UAAU,CAAM;CAC9B,GAAG,CAAC,CAAC,GACC,IAAU,QAAkB,GAAY,MAAM,IAAI,CAAC,GAAG,CAAC,CAAC,GACxD,IAAa,GAAQ,cAAc,KACnC,IAAW,GAAQ,YAAY,IAC/B,IAAQ,SACL;EACL;EACA;EACA;EACA;EACA,QAAQ;GAAE;GAAY;EAAS;CACjC,IACA;EAAC;EAAQ;EAAS;EAAQ;EAAS;EAAY;CAAQ,CACzD;CACA,OACE,kBAAC,EAAe,UAAhB;EAAgC;EAAQ;CAAkC,CAAA;AAE9E"}

package/dist/save-payment-method.d.ts

@@ -0,0 +1,26 @@
+import { CheckoutAppearance } from './appearance';
+import { PspConfig } from './psp';
+import * as React from "react";
+export interface SavePaymentMethodProps {
+    /** The PSP to save the card with, from OpenRails's checkout config. */
+    psp: PspConfig;
+    onSaved: (paymentMethodId: string) => void;
+    /**
+     * Where the provider returns after an off-page verification (3-D Secure),
+     * given the setup id to confirm with `client.confirmCardSetup`. Default:
+     * the current page with `?setup_id=`.
+     */
+    returnURL?: (setupId: string) => string;
+    /** Billing country to preselect; default: the browser locale's region. */
+    defaultCountry?: string;
+    submitLabel?: string;
+    appearance?: CheckoutAppearance;
+    className?: string;
+}
+/**
+ * Saves a card to the customer's account with any PSP OpenRails serves, in
+ * the page. The PSP's configuration picks the flow: card data enters the
+ * provider's own frames, or, for a PSP whose card_entry is server, is posted
+ * to OpenRails. Requires `BillingProvider`.
+ */
+export declare function SavePaymentMethod(props: SavePaymentMethodProps): React.JSX.Element;

package/dist/scope-context.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'react';
+import { CheckoutAppearance, CheckoutTheme } from './appearance';
+export type Navigate = (to: string) => void;
+export interface UiSettings {
+    appearance?: CheckoutAppearance;
+    locale?: string;
+    navigate?: Navigate;
+}
+export declare const UiContext: import('react').Context<UiSettings>;
+export declare const useUiSettings: () => UiSettings;
+export interface ScopeProps {
+    className: string;
+    "data-orck-theme": CheckoutTheme;
+    style?: CSSProperties;
+}
+/** Props that make an element a styling root; portals carry them too. */
+export declare function useScopeProps(appearance?: CheckoutAppearance): ScopeProps;

package/dist/scope.d.ts

@@ -0,0 +1,6 @@
+import { ComponentProps } from 'react';
+import { CheckoutAppearance } from './appearance';
+/** Styling root for in-page billing surfaces. */
+export declare function BillingUiRoot({ appearance, className, style, ...props }: ComponentProps<"div"> & {
+    appearance?: CheckoutAppearance;
+}): import("react").JSX.Element;

package/dist/source.d.ts

@@ -0,0 +1,14 @@
+import { CheckoutSession, PayRequest, PayResult } from './types';
+export interface CheckoutSource {
+    getSession(): Promise<CheckoutSession>;
+    pay(request: PayRequest): Promise<PayResult>;
+}
+export declare class CheckoutSourceError extends Error {
+    readonly status?: number;
+    constructor(message: string, status?: number);
+}
+export declare function createHttpSource(options: {
+    baseUrl: string;
+    sessionId: string;
+    fetch?: typeof fetch;
+}): CheckoutSource;