@funnelsgrove/payments 0.1.0

package/README.md

@@ -0,0 +1,36 @@
+# @funnelsgrove/payments
+
+Shared billing and checkout helpers for funnels.
+
+## Build And Publish
+
+- Build distributable output with `npm run build --workspace @funnelsgrove/payments`.
+- Publish from the repo root with `npm publish --workspace @funnelsgrove/payments --access public`.
+- The package pins `@funnelsgrove/runtime` to the same exact version and the build resolves against the runtime package's emitted `dist` contract.
+
+## Use This Package For
+
+- Stripe plan loading and checkout integration
+- global funnel billing catalog contracts
+- reusable plan-selector and checkout UI
+- billing catalog types and runtime helpers
+
+## Responsibilities
+
+- keep paywall behavior consistent across funnels
+- define the shared billing types used by funnel-local catalogs
+- expose one ordered funnel-local billing catalog contract
+
+## What Belongs Here
+
+- billing catalog types and normalization helpers
+- Stripe SDK wiring
+- checkout/plan-selector components
+
+## What Does Not Belong Here
+
+- funnel routing
+- funnel analytics
+- step-specific copy or layout
+- funnel-owned billing catalog entries
+- manifest validation

package/dist/components/shared/StripePlanSelector.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import type { BillingFallbackPlanConfig, BillingPlanCatalog } from '../../config/billing.config';
+import { type PaywallPlan } from '../../services/stripe.service';
+import type { RuntimeMode } from '@funnelsgrove/runtime';
+type StripePlanSelectorProps = {
+    planCatalog?: BillingPlanCatalog | readonly BillingFallbackPlanConfig[];
+    runtimeMode: RuntimeMode;
+    selectedPlanId: string | null;
+    onSelectPlan: (planId: string) => void;
+    onPlansLoaded?: (plans: readonly PaywallPlan[]) => void;
+    className?: string;
+    loadingClassName?: string;
+    errorClassName?: string;
+    renderPlan: (input: {
+        plan: PaywallPlan;
+        index: number;
+        isSelected: boolean;
+        onSelect: () => void;
+    }) => ReactNode;
+};
+export declare function StripePlanSelector({ planCatalog, runtimeMode, selectedPlanId, onSelectPlan, onPlansLoaded, className, loadingClassName, errorClassName, renderPlan, }: StripePlanSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/shared/StripePlanSelector.js

@@ -0,0 +1,74 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { getDefaultPlanId, getPaywallPlans, getFallbackPlans, } from '../../services/stripe.service';
+import { isPreviewFrameRuntime } from '@funnelsgrove/runtime';
+export function StripePlanSelector({ planCatalog, runtimeMode, selectedPlanId, onSelectPlan, onPlansLoaded, className, loadingClassName, errorClassName, renderPlan, }) {
+    const [plans, setPlans] = useState(() => getFallbackPlans(planCatalog));
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        let isActive = true;
+        const load = async () => {
+            setLoading(true);
+            setError(null);
+            if (isPreviewFrameRuntime()) {
+                const fallbackPlans = getFallbackPlans(planCatalog);
+                setPlans(fallbackPlans);
+                onPlansLoaded === null || onPlansLoaded === void 0 ? void 0 : onPlansLoaded(fallbackPlans);
+                setLoading(false);
+                return;
+            }
+            try {
+                const nextPlans = await getPaywallPlans(runtimeMode, planCatalog);
+                if (!isActive) {
+                    return;
+                }
+                setPlans(nextPlans);
+                onPlansLoaded === null || onPlansLoaded === void 0 ? void 0 : onPlansLoaded(nextPlans);
+            }
+            catch (nextError) {
+                if (!isActive) {
+                    return;
+                }
+                const fallbackPlans = getFallbackPlans(planCatalog);
+                setPlans(fallbackPlans);
+                onPlansLoaded === null || onPlansLoaded === void 0 ? void 0 : onPlansLoaded(fallbackPlans);
+                setError(nextError instanceof Error ? nextError.message : 'Unable to load plans');
+            }
+            finally {
+                if (isActive) {
+                    setLoading(false);
+                }
+            }
+        };
+        void load();
+        return () => {
+            isActive = false;
+        };
+    }, [onPlansLoaded, planCatalog, runtimeMode]);
+    useEffect(() => {
+        if (plans.length === 0) {
+            return;
+        }
+        if (selectedPlanId && plans.some((plan) => plan.id === selectedPlanId)) {
+            return;
+        }
+        const defaultPlanId = getDefaultPlanId(plans);
+        if (defaultPlanId) {
+            onSelectPlan(defaultPlanId);
+        }
+    }, [onSelectPlan, plans, selectedPlanId]);
+    const renderedPlans = useMemo(() => {
+        return plans.map((plan, index) => {
+            const isSelected = selectedPlanId === plan.id;
+            return renderPlan({
+                plan,
+                index,
+                isSelected,
+                onSelect: () => onSelectPlan(plan.id),
+            });
+        });
+    }, [onSelectPlan, plans, renderPlan, selectedPlanId]);
+    return (_jsxs(_Fragment, { children: [loading ? _jsx("p", { className: loadingClassName, children: "Loading plans..." }) : null, error ? _jsx("p", { className: errorClassName, children: error }) : null, _jsx("div", { className: className, children: renderedPlans })] }));
+}

package/dist/config/billing.config.d.ts

@@ -0,0 +1,123 @@
+export type BillingPlanComparison = {
+    perDay: string;
+    perWeek: string;
+    perMonth: string;
+    perYear: string;
+};
+export type BillingFallbackPlanConfig = {
+    id: string;
+    title: string;
+    description?: string;
+    providerPlanId?: string;
+    priceLabel: string;
+    oldPriceLabel?: string;
+    featuredTag?: string;
+    perDayAmount: string;
+    perDayLabel: string;
+    amountCents: number;
+    comparison?: BillingPlanComparison;
+    checkoutOriginalAmountCents?: number;
+    checkoutSummaryLabel?: string;
+};
+export type BillingPlanCatalog = Record<string, BillingFallbackPlanConfig>;
+export declare const billing: {
+    readonly plans: {
+        firstPlan: {
+            id: string;
+            title: string;
+            providerPlanId: string;
+            priceLabel: string;
+            featuredTag: string;
+            perDayAmount: string;
+            perDayLabel: string;
+            amountCents: number;
+            comparison: {
+                perDay: string;
+                perWeek: string;
+                perMonth: string;
+                perYear: string;
+            };
+        };
+        secondPlan: {
+            id: string;
+            title: string;
+            providerPlanId: string;
+            priceLabel: string;
+            oldPriceLabel: string;
+            perDayAmount: string;
+            perDayLabel: string;
+            amountCents: number;
+            comparison: {
+                perDay: string;
+                perWeek: string;
+                perMonth: string;
+                perYear: string;
+            };
+        };
+    };
+};
+export declare const billingPlans: {
+    firstPlan: {
+        id: string;
+        title: string;
+        providerPlanId: string;
+        priceLabel: string;
+        featuredTag: string;
+        perDayAmount: string;
+        perDayLabel: string;
+        amountCents: number;
+        comparison: {
+            perDay: string;
+            perWeek: string;
+            perMonth: string;
+            perYear: string;
+        };
+    };
+    secondPlan: {
+        id: string;
+        title: string;
+        providerPlanId: string;
+        priceLabel: string;
+        oldPriceLabel: string;
+        perDayAmount: string;
+        perDayLabel: string;
+        amountCents: number;
+        comparison: {
+            perDay: string;
+            perWeek: string;
+            perMonth: string;
+            perYear: string;
+        };
+    };
+};
+export declare const billingPlanList: ({
+    id: string;
+    title: string;
+    providerPlanId: string;
+    priceLabel: string;
+    featuredTag: string;
+    perDayAmount: string;
+    perDayLabel: string;
+    amountCents: number;
+    comparison: {
+        perDay: string;
+        perWeek: string;
+        perMonth: string;
+        perYear: string;
+    };
+} | {
+    id: string;
+    title: string;
+    providerPlanId: string;
+    priceLabel: string;
+    oldPriceLabel: string;
+    perDayAmount: string;
+    perDayLabel: string;
+    amountCents: number;
+    comparison: {
+        perDay: string;
+        perWeek: string;
+        perMonth: string;
+        perYear: string;
+    };
+})[];

package/dist/config/billing.config.js

@@ -0,0 +1,38 @@
+export const billing = {
+    plans: {
+        firstPlan: {
+            id: 'monthly',
+            title: '1-Month Plan',
+            providerPlanId: 'price_monthly',
+            priceLabel: '$29.95/month',
+            featuredTag: '🔥 Most Popular Choice',
+            perDayAmount: '$0.99',
+            perDayLabel: 'per day',
+            amountCents: 2995,
+            comparison: {
+                perDay: '$0.99/day',
+                perWeek: '$6.99/week',
+                perMonth: '$29.95/month',
+                perYear: '$363.34/year',
+            },
+        },
+        secondPlan: {
+            id: 'yearly',
+            title: '1-Year Plan',
+            providerPlanId: 'price_yearly',
+            priceLabel: '$191.40/year',
+            oldPriceLabel: '$359.40',
+            perDayAmount: '$0.53',
+            perDayLabel: 'per day',
+            amountCents: 19140,
+            comparison: {
+                perDay: '$0.53/day',
+                perWeek: '$3.67/week',
+                perMonth: '$15.95/month',
+                perYear: '$191.40/year',
+            },
+        },
+    },
+};
+export const billingPlans = billing.plans;
+export const billingPlanList = Object.values(billing.plans);

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './config/billing.config';
+export * from './services/preview-frame.service';
+export * from './services/runtime-mode.service';
+export * from './services/stripe.service';
+export * from './components/shared/StripePlanSelector';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './config/billing.config';
+export * from './services/preview-frame.service';
+export * from './services/runtime-mode.service';
+export * from './services/stripe.service';
+export * from './components/shared/StripePlanSelector';

package/dist/services/preview-frame.service.d.ts

@@ -0,0 +1 @@
+export * from '@funnelsgrove/runtime';

package/dist/services/preview-frame.service.js

@@ -0,0 +1 @@
+export * from '@funnelsgrove/runtime';

package/dist/services/runtime-mode.service.d.ts

@@ -0,0 +1 @@
+export * from '@funnelsgrove/runtime';

package/dist/services/runtime-mode.service.js

@@ -0,0 +1 @@
+export * from '@funnelsgrove/runtime';

package/dist/services/stripe.service.d.ts

@@ -0,0 +1,38 @@
+import { type Stripe } from '@stripe/stripe-js';
+import { type BillingFallbackPlanConfig, type BillingPlanCatalog } from '../config/billing.config';
+import type { RuntimeMode } from '@funnelsgrove/runtime';
+export type PaywallPlan = {
+    id: string;
+    title: string;
+    description?: string;
+    providerPlanId?: string;
+    priceLabel: string;
+    oldPriceLabel?: string;
+    featuredTag?: string;
+    perDayAmount: string;
+    perDayLabel: string;
+    amountCents: number;
+    comparison?: BillingFallbackPlanConfig['comparison'];
+    checkoutOriginalAmountCents?: number;
+    checkoutSummaryLabel?: string;
+    source: 'stripe' | 'config';
+};
+export declare function getFallbackPlans(planCatalog?: BillingPlanCatalog | readonly BillingFallbackPlanConfig[]): readonly PaywallPlan[];
+export declare function getDefaultPlanId(plans: readonly PaywallPlan[]): string | null;
+export declare function getStripeSyncedPlans(mode: RuntimeMode): Promise<readonly PaywallPlan[]>;
+export declare function getPaywallPlans(mode: RuntimeMode, planCatalog?: BillingPlanCatalog | readonly BillingFallbackPlanConfig[]): Promise<readonly PaywallPlan[]>;
+export declare function isStripeConfigured(mode: RuntimeMode): boolean;
+export declare function getStripePromise(mode: RuntimeMode, runtimePublishableKey?: string | null): Promise<Stripe | null> | null;
+type CreatePaymentIntentInput = {
+    planId: string;
+    amountCents: number;
+    externalUserId?: string | null;
+    environment?: RuntimeMode;
+};
+type CreatePaymentIntentResponse = {
+    clientSecret: string;
+    stripePublishableKey?: string;
+    environment?: 'test' | 'live';
+};
+export declare function createStripePaymentIntent(input: CreatePaymentIntentInput): Promise<CreatePaymentIntentResponse>;
+export {};

package/dist/services/stripe.service.js

@@ -0,0 +1,283 @@
+var _a, _b, _c, _d;
+import { loadStripe } from '@stripe/stripe-js';
+import { billingPlanList, } from '../config/billing.config';
+import { buildMainApiUrl, buildSdkHeaders, FUNNEL_ID, FUNNEL_SDK_PUBLISHABLE_KEY, } from '@funnelsgrove/runtime';
+const STRIPE_TEST_PUBLISHABLE_KEY = ((_b = (_a = process.env.NEXT_PUBLIC_STRIPE_TEST_PUBLISHABLE_KEY) !== null && _a !== void 0 ? _a : process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY) !== null && _b !== void 0 ? _b : '').trim();
+const STRIPE_LIVE_PUBLISHABLE_KEY = ((_d = (_c = process.env.NEXT_PUBLIC_STRIPE_LIVE_PUBLISHABLE_KEY) !== null && _c !== void 0 ? _c : process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY) !== null && _d !== void 0 ? _d : '').trim();
+const stripePromiseByKey = new Map();
+const syncedPlansPromiseByMode = new Map();
+const fallbackPaywallPlans = billingPlanList.map((plan) => (Object.assign(Object.assign({}, plan), { source: 'config' })));
+const isRecord = (value) => {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+};
+const asTrimmedStringOrNull = (value) => {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+};
+const asFiniteNumberOrNull = (value) => {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return null;
+    }
+    return value;
+};
+const asPositiveIntOrNull = (value) => {
+    const numeric = asFiniteNumberOrNull(value);
+    if (numeric === null || numeric <= 0) {
+        return null;
+    }
+    return Math.round(numeric);
+};
+const toMinorAmount = (value) => {
+    const numeric = asFiniteNumberOrNull(value);
+    if (numeric === null || numeric <= 0) {
+        return null;
+    }
+    return Math.round(numeric);
+};
+const toCurrencyCode = (value) => {
+    const raw = asTrimmedStringOrNull(value);
+    if (!raw) {
+        return 'USD';
+    }
+    return raw.toUpperCase();
+};
+const formatMoneyFromMinor = (amountMinor, currencyCode) => {
+    return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: currencyCode,
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    }).format(amountMinor / 100);
+};
+const formatMoneyFromMajor = (amountMajor, currencyCode) => {
+    return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: currencyCode,
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    }).format(amountMajor);
+};
+const getIntervalLabel = (interval, intervalCount) => {
+    if (!interval) {
+        return '';
+    }
+    const normalized = interval.toLowerCase();
+    const count = intervalCount && intervalCount > 0 ? intervalCount : 1;
+    if (count === 1) {
+        return normalized;
+    }
+    return `${count} ${normalized}s`;
+};
+const getIntervalDays = (interval, intervalCount) => {
+    if (!interval) {
+        return null;
+    }
+    const normalized = interval.toLowerCase();
+    const count = intervalCount && intervalCount > 0 ? intervalCount : 1;
+    if (normalized === 'day') {
+        return count;
+    }
+    if (normalized === 'week') {
+        return count * 7;
+    }
+    if (normalized === 'month') {
+        return count * 30;
+    }
+    if (normalized === 'year') {
+        return count * 365;
+    }
+    return null;
+};
+const toPlanFromSynced = (rawPlan) => {
+    const planId = asTrimmedStringOrNull(rawPlan.providerPlanId);
+    if (!planId) {
+        return null;
+    }
+    if (rawPlan.isActive === false) {
+        return null;
+    }
+    const amountMinor = toMinorAmount(rawPlan.amountMinor);
+    if (!amountMinor) {
+        return null;
+    }
+    const metadata = isRecord(rawPlan.metadata) ? rawPlan.metadata : {};
+    const currencyCode = toCurrencyCode(rawPlan.currency);
+    const interval = asTrimmedStringOrNull(rawPlan.interval);
+    const intervalCount = asPositiveIntOrNull(rawPlan.intervalCount);
+    const intervalLabel = getIntervalLabel(interval, intervalCount);
+    const intervalDays = getIntervalDays(interval, intervalCount);
+    const title = asTrimmedStringOrNull(rawPlan.displayName) || planId;
+    const priceLabel = intervalLabel
+        ? `${formatMoneyFromMinor(amountMinor, currencyCode)}/${intervalLabel}`
+        : formatMoneyFromMinor(amountMinor, currencyCode);
+    const perDayAmount = intervalDays
+        ? formatMoneyFromMajor(amountMinor / 100 / intervalDays, currencyCode)
+        : formatMoneyFromMinor(amountMinor, currencyCode);
+    return {
+        id: planId,
+        title,
+        description: asTrimmedStringOrNull(metadata.description) || undefined,
+        providerPlanId: planId,
+        priceLabel,
+        oldPriceLabel: asTrimmedStringOrNull(metadata.oldPriceLabel) || undefined,
+        featuredTag: asTrimmedStringOrNull(metadata.featuredTag) || undefined,
+        perDayAmount,
+        perDayLabel: 'per day',
+        amountCents: amountMinor,
+        comparison: intervalDays
+            ? {
+                perDay: `${perDayAmount}/day`,
+                perWeek: `${formatMoneyFromMajor(amountMinor / 100 / intervalDays * 7, currencyCode)}/week`,
+                perMonth: interval === 'month' || interval === 'year'
+                    ? `${formatMoneyFromMajor(interval === 'year'
+                        ? amountMinor / 100 / ((intervalCount || 1) * 12)
+                        : amountMinor / 100 / (intervalCount || 1), currencyCode)}/month`
+                    : `${formatMoneyFromMajor(amountMinor / 100 / intervalDays * 30, currencyCode)}/month`,
+                perYear: interval === 'year'
+                    ? `${formatMoneyFromMinor(amountMinor / (intervalCount || 1), currencyCode)}/year`
+                    : `${formatMoneyFromMajor(amountMinor / 100 / intervalDays * 365, currencyCode)}/year`,
+            }
+            : undefined,
+        checkoutOriginalAmountCents: asPositiveIntOrNull(metadata.checkoutOriginalAmountCents) || undefined,
+        checkoutSummaryLabel: asTrimmedStringOrNull(metadata.checkoutSummaryLabel) || undefined,
+        source: 'stripe',
+    };
+};
+const addFeaturedTagFallback = (plans) => {
+    if (plans.length === 0) {
+        return plans;
+    }
+    if (plans.some((plan) => Boolean(plan.featuredTag))) {
+        return plans;
+    }
+    return plans.map((plan, index) => index === 0
+        ? Object.assign(Object.assign({}, plan), { featuredTag: '🔥 Most Popular Choice' }) : plan);
+};
+const getStripePublishableKeyFromEnv = (mode) => {
+    if (mode === 'live') {
+        return STRIPE_LIVE_PUBLISHABLE_KEY || STRIPE_TEST_PUBLISHABLE_KEY;
+    }
+    return STRIPE_TEST_PUBLISHABLE_KEY || STRIPE_LIVE_PUBLISHABLE_KEY;
+};
+const toFallbackPaywallPlans = (planCatalog) => {
+    const sourcePlans = Array.isArray(planCatalog)
+        ? planCatalog
+        : planCatalog
+            ? Object.values(planCatalog)
+            : billingPlanList;
+    return sourcePlans.map((plan) => (Object.assign(Object.assign({}, plan), { source: 'config' })));
+};
+const parseErrorMessage = async (response, fallbackMessage) => {
+    try {
+        const payload = (await response.json());
+        const apiError = asTrimmedStringOrNull(payload.error);
+        if (apiError) {
+            return apiError;
+        }
+    }
+    catch (_a) {
+        // ignore JSON parsing errors
+    }
+    try {
+        const errorText = await response.text();
+        if (errorText.trim()) {
+            return errorText;
+        }
+    }
+    catch (_b) {
+        // ignore text parsing errors
+    }
+    return fallbackMessage;
+};
+export function getFallbackPlans(planCatalog) {
+    return planCatalog ? toFallbackPaywallPlans(planCatalog) : fallbackPaywallPlans;
+}
+export function getDefaultPlanId(plans) {
+    var _a;
+    if (plans.length === 0) {
+        return null;
+    }
+    return ((_a = plans[0]) === null || _a === void 0 ? void 0 : _a.id) || null;
+}
+export async function getStripeSyncedPlans(mode) {
+    const cacheKey = `${mode}:${FUNNEL_ID || 'no-funnel'}:${FUNNEL_SDK_PUBLISHABLE_KEY}`;
+    const cachedPromise = syncedPlansPromiseByMode.get(cacheKey);
+    if (cachedPromise) {
+        return cachedPromise;
+    }
+    const nextPromise = (async () => {
+        const url = new URL(buildMainApiUrl('/sdk/public/payments/plans'));
+        url.searchParams.set('environment', mode);
+        if (FUNNEL_ID) {
+            url.searchParams.set('funnelId', FUNNEL_ID);
+        }
+        const response = await fetch(url.toString(), {
+            method: 'GET',
+            headers: buildSdkHeaders(),
+        });
+        if (!response.ok) {
+            const errorMessage = await parseErrorMessage(response, 'Unable to load Stripe plans');
+            throw new Error(errorMessage);
+        }
+        const payload = (await response.json());
+        const rawPlans = Array.isArray(payload.plans) ? payload.plans : [];
+        const mappedPlans = rawPlans
+            .map((raw) => (isRecord(raw) ? toPlanFromSynced(raw) : null))
+            .filter((plan) => Boolean(plan))
+            .sort((a, b) => a.amountCents - b.amountCents);
+        return addFeaturedTagFallback(mappedPlans);
+    })();
+    syncedPlansPromiseByMode.set(cacheKey, nextPromise);
+    return nextPromise;
+}
+export async function getPaywallPlans(mode, planCatalog) {
+    try {
+        const syncedPlans = await getStripeSyncedPlans(mode);
+        if (syncedPlans.length > 0) {
+            return syncedPlans;
+        }
+    }
+    catch (_a) {
+        // fall through to config fallback plans
+    }
+    return getFallbackPlans(planCatalog);
+}
+export function isStripeConfigured(mode) {
+    return getStripePublishableKeyFromEnv(mode).length > 0 || FUNNEL_SDK_PUBLISHABLE_KEY.length > 0;
+}
+export function getStripePromise(mode, runtimePublishableKey) {
+    const resolvedPublishableKey = (runtimePublishableKey !== null && runtimePublishableKey !== void 0 ? runtimePublishableKey : getStripePublishableKeyFromEnv(mode)).trim();
+    if (!resolvedPublishableKey) {
+        return null;
+    }
+    let stripePromise = stripePromiseByKey.get(resolvedPublishableKey) || null;
+    if (!stripePromise) {
+        stripePromise = loadStripe(resolvedPublishableKey);
+        stripePromiseByKey.set(resolvedPublishableKey, stripePromise);
+    }
+    return stripePromise;
+}
+export async function createStripePaymentIntent(input) {
+    const response = await fetch(buildMainApiUrl('/sdk/public/payments/intents'), {
+        method: 'POST',
+        headers: buildSdkHeaders({
+            'Content-Type': 'application/json',
+        }),
+        body: JSON.stringify({
+            publishableKey: FUNNEL_SDK_PUBLISHABLE_KEY || undefined,
+            funnelId: FUNNEL_ID || undefined,
+            planId: input.planId,
+            amountCents: input.amountCents,
+            externalUserId: input.externalUserId || undefined,
+            environment: input.environment || undefined,
+        }),
+    });
+    if (!response.ok) {
+        const errorMessage = await parseErrorMessage(response, 'Unable to create payment intent');
+        throw new Error(errorMessage);
+    }
+    return (await response.json());
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@funnelsgrove/payments",
+  "version": "0.1.0",
+  "type": "module",
+  "private": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "lint": "eslint .",
+    "prepublishOnly": "npm run build",
+    "test:run": "vitest run --passWithNoTests"
+  },
+  "dependencies": {
+    "@funnelsgrove/runtime": "0.1.0",
+    "@stripe/react-stripe-js": "^5.6.0",
+    "@stripe/stripe-js": "^8.7.0",
+    "react": "19.2.3",
+    "react-dom": "19.2.3",
+    "stripe": "^20.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "typescript": "^5",
+    "vitest": "^3.2.4"
+  }
+}