@blocklet/payment-react-headless 1.26.0

package/es/checkout/core/exchangeRate.js

@@ -0,0 +1,25 @@
+import api, { API } from "../../shared/api.js";
+export const BASE_INTERVAL = 3e4;
+export const MAX_INTERVAL = 12e4;
+export function checkHasDynamicPricing(items) {
+  return items.some((item) => (item.upsell_price || item.price)?.pricing_type === "dynamic");
+}
+export async function fetchExchangeRate(sessionId, currencyId) {
+  const { data } = await api.get(API.EXCHANGE_RATE(sessionId), {
+    params: currencyId ? { currency_id: currencyId } : void 0
+  });
+  const rateValue = data.rate || data.exchange_rate;
+  if (rateValue) {
+    const providerDisplay = data.provider_display || data.provider_name || data.provider_id || null;
+    return {
+      rate: rateValue,
+      provider: data.provider_name || data.rate_provider_name || null,
+      providerDisplay,
+      fetchedAt: data.fetched_at || data.timestamp_ms || null
+    };
+  }
+  return { rate: null, provider: null, providerDisplay: null, fetchedAt: null };
+}
+export function getBackoffInterval(failCount) {
+  return Math.min(BASE_INTERVAL * 2 ** failCount, MAX_INTERVAL);
+}

package/es/checkout/core/index.d.ts

@@ -0,0 +1,10 @@
+export { parseProduct, parseSubscription, parsePageInfo } from './session';
+export { flattenCurrencies, hasDidWallet, getInitialCurrencyId, findMethodAndCurrency, buildPaymentTypes, } from './paymentMethod';
+export { BASE_INTERVAL, MAX_INTERVAL, checkHasDynamicPricing, fetchExchangeRate, getBackoffInterval, } from './exchangeRate';
+export { calculateAmounts, calculateQuoteMeta, calculateTrial, type CalculatedAmounts, type QuoteMeta, } from './pricing';
+export { extractPromotionCodeFromSession, applyPromotionCode, removePromotionCode, recalculatePromotion, isPromotionActive, hasAppliedDiscounts, } from './promotion';
+export { recalculatePromotionIfNeeded, adjustQuantity, performUpsell, performDownsell, changeDonationAmount, getCrossSellItem, } from './lineItems';
+export { addCrossSellItem, removeCrossSellItem, fetchCrossSellItem } from './crossSell';
+export { parseBillingInterval, type BillingIntervalType, type BillingIntervalOption, type BillingIntervalInfo, } from './billingInterval';
+export { buildFields, createInitialValues, setNestedValue } from './customerForm';
+export { QUOTE_ERROR_CODES, RELAY_SOCKET_PREFIX, getAppId, getRelayChannel, getRelayProtocol, getSocketHost, buildSubmitPayload, isQuoteError, abortStripePayment, submitCheckout, confirmFastCheckout, updateSlippage, } from './submit';

package/es/checkout/core/index.js

@@ -0,0 +1,55 @@
+export { parseProduct, parseSubscription, parsePageInfo } from "./session.js";
+export {
+  flattenCurrencies,
+  hasDidWallet,
+  getInitialCurrencyId,
+  findMethodAndCurrency,
+  buildPaymentTypes
+} from "./paymentMethod.js";
+export {
+  BASE_INTERVAL,
+  MAX_INTERVAL,
+  checkHasDynamicPricing,
+  fetchExchangeRate,
+  getBackoffInterval
+} from "./exchangeRate.js";
+export {
+  calculateAmounts,
+  calculateQuoteMeta,
+  calculateTrial
+} from "./pricing.js";
+export {
+  extractPromotionCodeFromSession,
+  applyPromotionCode,
+  removePromotionCode,
+  recalculatePromotion,
+  isPromotionActive,
+  hasAppliedDiscounts
+} from "./promotion.js";
+export {
+  recalculatePromotionIfNeeded,
+  adjustQuantity,
+  performUpsell,
+  performDownsell,
+  changeDonationAmount,
+  getCrossSellItem
+} from "./lineItems.js";
+export { addCrossSellItem, removeCrossSellItem, fetchCrossSellItem } from "./crossSell.js";
+export {
+  parseBillingInterval
+} from "./billingInterval.js";
+export { buildFields, createInitialValues, setNestedValue } from "./customerForm.js";
+export {
+  QUOTE_ERROR_CODES,
+  RELAY_SOCKET_PREFIX,
+  getAppId,
+  getRelayChannel,
+  getRelayProtocol,
+  getSocketHost,
+  buildSubmitPayload,
+  isQuoteError,
+  abortStripePayment,
+  submitCheckout,
+  confirmFastCheckout,
+  updateSlippage
+} from "./submit.js";

package/es/checkout/core/lineItems.d.ts

@@ -0,0 +1,7 @@
+import type { TCheckoutSessionExpanded, TLineItemExpanded, TPrice } from '@blocklet/payment-types';
+export declare function recalculatePromotionIfNeeded(session: TCheckoutSessionExpanded | undefined | null, sessionId: string, currencyId: string | null | undefined): Promise<void>;
+export declare function adjustQuantity(sessionId: string, itemId: string, qty: number, currencyId: string | null | undefined, session: TCheckoutSessionExpanded | undefined | null, refresh: (force?: boolean) => Promise<void>): Promise<void>;
+export declare function performUpsell(sessionId: string, fromId: string, toId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
+export declare function performDownsell(sessionId: string, priceId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
+export declare function changeDonationAmount(sessionId: string, priceId: string, amount: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
+export declare function getCrossSellItem(items: TLineItemExpanded[]): TPrice | null;

package/es/checkout/core/lineItems.js

@@ -0,0 +1,59 @@
+import api, { API } from "../../shared/api.js";
+import { recalculatePromotion, hasAppliedDiscounts } from "./promotion.js";
+export async function recalculatePromotionIfNeeded(session, sessionId, currencyId) {
+  if (!hasAppliedDiscounts(session)) return;
+  try {
+    await recalculatePromotion(sessionId, currencyId);
+  } catch {
+  }
+}
+export async function adjustQuantity(sessionId, itemId, qty, currencyId, session, refresh) {
+  await api.put(API.ADJUST_QUANTITY(sessionId), {
+    itemId,
+    quantity: qty,
+    currency_id: currencyId
+  });
+  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+  await refresh(true);
+}
+export async function performUpsell(sessionId, fromId, toId, session, currencyId, refresh) {
+  if ((session?.line_items?.length || 0) > 1) {
+    try {
+      await api.delete(API.CROSS_SELL(sessionId));
+    } catch {
+    }
+  }
+  await api.put(API.UPSELL(sessionId), { from: fromId, to: toId });
+  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+  await refresh(true);
+}
+export async function performDownsell(sessionId, priceId, session, currencyId, refresh) {
+  if ((session?.line_items?.length || 0) > 1) {
+    try {
+      await api.delete(API.CROSS_SELL(sessionId));
+    } catch {
+    }
+  }
+  await api.put(API.DOWNSELL(sessionId), { from: priceId });
+  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+  await refresh(true);
+}
+export async function changeDonationAmount(sessionId, priceId, amount, session, currencyId, refresh) {
+  const { data } = await api.put(API.CHANGE_AMOUNT(sessionId), {
+    priceId,
+    amount
+  });
+  if (data?.discounts?.length) {
+    await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+  }
+  await refresh(true);
+}
+export function getCrossSellItem(items) {
+  for (const item of items) {
+    const crossSell = item.price?.cross_sell;
+    if (crossSell?.cross_sells_to) {
+      return crossSell.cross_sells_to;
+    }
+  }
+  return null;
+}

package/es/checkout/core/paymentMethod.d.ts

@@ -0,0 +1,23 @@
+import type { TPaymentMethodExpanded, TPaymentCurrency, TCheckoutSessionExpanded } from '@blocklet/payment-types';
+import type { CheckoutSessionUser } from '../../types/checkout-augmented';
+export type CurrencyWithMethod = TPaymentCurrency & {
+    method?: {
+        id: string;
+        name: string;
+        type: string;
+    };
+};
+export declare function flattenCurrencies(methods: TPaymentMethodExpanded[]): CurrencyWithMethod[];
+export declare function hasDidWallet(user: CheckoutSessionUser | undefined): boolean;
+export declare function getCurrencyStorageKey(did?: string): string;
+export declare function getInitialCurrencyId(session: TCheckoutSessionExpanded | undefined | null, methods: TPaymentMethodExpanded[]): string | null;
+export declare function findMethodAndCurrency(methods: TPaymentMethodExpanded[], currencyId: string | null): {
+    method: TPaymentMethodExpanded | null;
+    currency: TPaymentCurrency | null;
+};
+export declare function buildPaymentTypes(methods: TPaymentMethodExpanded[], currentMethod: TPaymentMethodExpanded | null): {
+    type: "stripe" | "crypto";
+    label: string;
+    currencies: CurrencyWithMethod[];
+    active: boolean;
+}[];

package/es/checkout/core/paymentMethod.js

@@ -0,0 +1,85 @@
+export function flattenCurrencies(methods) {
+  const out = [];
+  methods.forEach((method) => {
+    const currencies = method.payment_currencies || [];
+    currencies.forEach((currency) => {
+      const enriched = {
+        ...currency,
+        method: { id: method.id, name: method.name, type: method.type }
+      };
+      out.push(enriched);
+    });
+  });
+  return out;
+}
+export function hasDidWallet(user) {
+  const connected = user?.connectedAccounts || user?.extraConfigs?.connectedAccounts || [];
+  return connected.some((x) => x.provider === "wallet");
+}
+const CURRENCY_PREFERENCE_KEY = "payment-currency-preference";
+export function getCurrencyStorageKey(did) {
+  return did ? `${CURRENCY_PREFERENCE_KEY}:${did}` : CURRENCY_PREFERENCE_KEY;
+}
+export function getInitialCurrencyId(session, methods) {
+  if (typeof window !== "undefined") {
+    try {
+      const params = new URLSearchParams(window.location.search);
+      const urlCurrency = params.get("currencyId") || params.get("currency_id");
+      if (urlCurrency) return urlCurrency;
+    } catch {
+    }
+    const user = session?.user;
+    if (user && !hasDidWallet(user)) {
+      const stripeMethod = methods.find((m) => m.type === "stripe");
+      const stripeCurrency = stripeMethod?.payment_currencies?.[0];
+      if (stripeCurrency) return stripeCurrency.id;
+    }
+    try {
+      const did = session?.user?.did;
+      const stored = localStorage.getItem(getCurrencyStorageKey(did));
+      if (stored) return stored;
+    } catch {
+    }
+  }
+  return session?.currency_id || null;
+}
+export function findMethodAndCurrency(methods, currencyId) {
+  if (!currencyId) {
+    const first2 = methods[0];
+    const firstCurrency = first2?.payment_currencies?.[0] || null;
+    return { method: first2 || null, currency: firstCurrency };
+  }
+  for (const method of methods) {
+    for (const currency of method.payment_currencies || []) {
+      if (currency.id === currencyId) {
+        return { method, currency };
+      }
+    }
+  }
+  const first = methods[0];
+  return { method: first || null, currency: first?.payment_currencies?.[0] || null };
+}
+export function buildPaymentTypes(methods, currentMethod) {
+  const typeMap = /* @__PURE__ */ new Map();
+  methods.forEach((method) => {
+    const type = method.type === "stripe" ? "stripe" : "crypto";
+    if (!typeMap.has(type)) {
+      typeMap.set(type, { currencies: [], active: false });
+    }
+    const entry = typeMap.get(type);
+    const enriched = (method.payment_currencies || []).map((cur) => ({
+      ...cur,
+      method: { id: method.id, name: method.name, type: method.type }
+    }));
+    entry.currencies.push(...enriched);
+    if (method === currentMethod) {
+      entry.active = true;
+    }
+  });
+  return Array.from(typeMap.entries()).map(([type, data]) => ({
+    type,
+    label: type === "stripe" ? "Card" : "Crypto",
+    currencies: data.currencies,
+    active: data.active
+  }));
+}

package/es/checkout/core/pricing.d.ts

@@ -0,0 +1,32 @@
+import type { TCheckoutSessionExpanded, TPaymentCurrency, TLineItemExpanded } from '@blocklet/payment-types';
+import type { SessionData } from '../hooks/useCheckoutSession';
+export interface CalculatedAmounts {
+    subtotal: string;
+    paymentAmount: string;
+    total: string;
+    discount: string | null;
+    tax: {
+        amount: string;
+        rate: number;
+        inclusive: boolean;
+    } | null;
+    staking: string | null;
+    usdEquivalent: string | null;
+    subtotalUsdEquivalent?: string | null;
+}
+export declare function calculateAmounts(items: TLineItemExpanded[], currency: TPaymentCurrency | null, session: TCheckoutSessionExpanded | undefined | null, exchangeRate: string | null, hasDynamicPricing: boolean, paymentMethodType?: string | null): CalculatedAmounts;
+export interface QuoteMeta {
+    locked: boolean;
+    lockedAt: number | null;
+    expiresAt: number | null;
+    expired: boolean;
+    baseCurrency: string | null;
+    slippagePercent: number | null;
+}
+export declare function calculateQuoteMeta(items: TLineItemExpanded[], hasDynamicPricing: boolean, sessionData: SessionData | null): QuoteMeta;
+export declare function calculateTrial(session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, items: TLineItemExpanded[], currency: TPaymentCurrency | null, hasDynamicPricing: boolean, exchangeRate: string | null): {
+    active: boolean;
+    days: number;
+    afterTrialPrice: string | null;
+    afterTrialInterval: string | null;
+};

package/es/checkout/core/pricing.js

@@ -0,0 +1,221 @@
+import { BN, fromUnitToToken, fromTokenToUnit } from "@ocap/util";
+import {
+  formatDynamicPrice,
+  formatUsdAmount,
+  getUsdAmountFromTokenUnits,
+  getCheckoutAmount,
+  getPriceUnitAmountByCurrency
+} from "../../shared/format.js";
+function getStakingSetup(items, currency, billingThreshold = 0) {
+  const staking = { licensed: new BN(0), metered: new BN(0) };
+  const recurringItems = items.map((x) => x.upsell_price || x.price).filter((x) => x?.type === "recurring" && x?.recurring);
+  if (recurringItems.length > 0) {
+    if (+billingThreshold) {
+      return fromTokenToUnit(billingThreshold, currency.decimal).toString();
+    }
+    items.forEach((x) => {
+      const price = x.upsell_price || x.price;
+      const unit = getPriceUnitAmountByCurrency(price, currency);
+      const amount = new BN(unit).mul(new BN(x.quantity));
+      if (price?.type === "recurring" && price?.recurring) {
+        if (price.recurring.usage_type === "licensed") {
+          staking.licensed = staking.licensed.add(amount);
+        }
+        if (price.recurring.usage_type === "metered") {
+          staking.metered = staking.metered.add(amount);
+        }
+      }
+    });
+    return staking.licensed.add(staking.metered).toString();
+  }
+  return "0";
+}
+function calculateCouponDiscount(items, currency, session, hasDynamicPricing, exchangeRate, trialing, recurringOnly) {
+  const discounts = session?.discounts || [];
+  if (discounts.length === 0) return new BN(0);
+  const coupon = discounts[0].coupon_details || {};
+  if (recurringOnly && coupon.duration === "once") return new BN(0);
+  const discountableItems = items.filter((item) => {
+    if (item.discountable === false) return false;
+    const price = item.upsell_price || item.price;
+    if (price?.recurring?.usage_type === "metered") return false;
+    return true;
+  });
+  const discountableResult = getCheckoutAmount(discountableItems, currency, trialing, true, {
+    exchangeRate: hasDynamicPricing ? exchangeRate : null
+  });
+  const discountableSubtotalBN = new BN(discountableResult.total);
+  if (discountableSubtotalBN.lte(new BN(0))) return new BN(0);
+  if (coupon.percent_off && coupon.percent_off > 0) {
+    return discountableSubtotalBN.mul(new BN(coupon.percent_off)).div(new BN(100));
+  }
+  if (coupon.amount_off && coupon.amount_off !== "0") {
+    const amountOff = coupon.currency_options?.[currency.id]?.amount_off || coupon.amount_off;
+    if (amountOff && amountOff !== "0") {
+      const amountOffBN = new BN(amountOff);
+      return amountOffBN.lt(discountableSubtotalBN) ? amountOffBN : discountableSubtotalBN;
+    }
+  }
+  return new BN(0);
+}
+export function calculateAmounts(items, currency, session, exchangeRate, hasDynamicPricing, paymentMethodType) {
+  if (!currency || items.length === 0) {
+    return {
+      subtotal: "0",
+      paymentAmount: "0",
+      total: "0",
+      discount: null,
+      tax: null,
+      staking: null,
+      usdEquivalent: null
+    };
+  }
+  const subData = session?.subscription_data;
+  const trialDays = Number(subData?.trial_period_days || 0);
+  const trialing = trialDays > 0;
+  const result = getCheckoutAmount(items, currency, trialing, true, {
+    exchangeRate: hasDynamicPricing ? exchangeRate : null
+  });
+  const subtotalBN = new BN(result.total);
+  const subtotalFormatted = formatDynamicPrice(fromUnitToToken(subtotalBN, currency.decimal), hasDynamicPricing);
+  const discountBN = calculateCouponDiscount(items, currency, session, hasDynamicPricing, exchangeRate, trialing, false);
+  const discount = discountBN.gt(new BN(0)) ? formatDynamicPrice(fromUnitToToken(discountBN.toString(), currency.decimal), hasDynamicPricing) : null;
+  const taxAmount = session?.total_details?.amount_tax;
+  const taxBN = new BN(taxAmount || "0");
+  const totalDetails = session?.total_details;
+  const tax = taxAmount && taxAmount !== "0" ? {
+    amount: fromUnitToToken(taxAmount, currency.decimal),
+    rate: totalDetails?.tax_rate || 0,
+    inclusive: totalDetails?.tax_inclusive || false
+  } : null;
+  const noStake = subData?.no_stake || false;
+  const billingThreshold = Math.max(
+    Number(subData?.billing_threshold_amount || 0),
+    Number(subData?.min_stake_amount || 0)
+  );
+  const shouldShowStaking = paymentMethodType === "arcblock" && currency.type !== "credit" && !noStake;
+  const stakingUnitStr = shouldShowStaking ? getStakingSetup(items, currency, billingThreshold) : "0";
+  const stakingBN = new BN(stakingUnitStr);
+  const subtotalWithStakingBN = subtotalBN.add(stakingBN);
+  let totalBN = subtotalWithStakingBN.sub(discountBN);
+  if (taxBN.gt(new BN(0)) && !tax?.inclusive) {
+    totalBN = totalBN.add(taxBN);
+  }
+  if (totalBN.isNeg()) {
+    totalBN = new BN(0);
+  }
+  const totalFormatted = formatDynamicPrice(fromUnitToToken(totalBN, currency.decimal), hasDynamicPricing);
+  const displaySubtotalBN = subtotalWithStakingBN;
+  const displaySubtotalFormatted = formatDynamicPrice(
+    fromUnitToToken(displaySubtotalBN, currency.decimal),
+    hasDynamicPricing
+  );
+  let usdEquivalent = null;
+  let subtotalUsdEquivalent = null;
+  if (hasDynamicPricing && exchangeRate && currency) {
+    const totalUsd = getUsdAmountFromTokenUnits(totalBN.toString(), currency.decimal, exchangeRate);
+    if (totalUsd) {
+      usdEquivalent = formatUsdAmount(totalUsd) || null;
+    }
+    const subtotalUsd = getUsdAmountFromTokenUnits(displaySubtotalBN.toString(), currency.decimal, exchangeRate);
+    if (subtotalUsd) {
+      subtotalUsdEquivalent = formatUsdAmount(subtotalUsd) || null;
+    }
+  }
+  const stakingFormatted = stakingBN.gt(new BN(0)) ? `${formatDynamicPrice(fromUnitToToken(stakingBN.toString(), currency.decimal), hasDynamicPricing)} ${currency.symbol}` : null;
+  return {
+    subtotal: `${displaySubtotalFormatted} ${currency.symbol}`,
+    paymentAmount: `${subtotalFormatted} ${currency.symbol}`,
+    total: `${totalFormatted} ${currency.symbol}`,
+    discount: discount ? `${discount} ${currency.symbol}` : null,
+    tax,
+    staking: stakingFormatted,
+    usdEquivalent: usdEquivalent ? `$${usdEquivalent}` : null,
+    subtotalUsdEquivalent: subtotalUsdEquivalent ? `$${subtotalUsdEquivalent}` : null
+  };
+}
+export function calculateQuoteMeta(items, hasDynamicPricing, sessionData) {
+  if (!items.length || !hasDynamicPricing) {
+    return {
+      locked: false,
+      lockedAt: null,
+      expiresAt: null,
+      expired: false,
+      baseCurrency: null,
+      slippagePercent: null
+    };
+  }
+  const session = sessionData?.checkoutSession;
+  let baseCurrency = null;
+  let expiresAt = null;
+  let slippagePercent = null;
+  items.forEach((item) => {
+    const price = item.upsell_price || item.price;
+    if (!baseCurrency && price?.base_currency) baseCurrency = price.base_currency;
+    const expires = item.expires_at;
+    if (expires) {
+      expiresAt = expiresAt === null ? expires : Math.min(expiresAt, expires);
+    }
+    const itemSlippage = item.slippage_percent;
+    if (slippagePercent === null && Number.isFinite(Number(itemSlippage))) {
+      slippagePercent = Number(itemSlippage);
+    }
+  });
+  const piCreated = sessionData?.paymentIntent?.created_at ? new Date(sessionData.paymentIntent.created_at).getTime() : null;
+  const sessionLock = session?.quote_locked_at;
+  const lockedAt = piCreated || sessionLock || null;
+  const locked = !!lockedAt;
+  const now = Date.now();
+  const expired = expiresAt ? now > expiresAt : false;
+  return { locked, lockedAt, expiresAt, expired, baseCurrency, slippagePercent };
+}
+export function calculateTrial(session, currencyId, items, currency, hasDynamicPricing, exchangeRate) {
+  const subData = session?.subscription_data;
+  let trialDays = Number(subData?.trial_period_days || 0);
+  if (trialDays > 0 && currencyId) {
+    const trialCurrencyIds = (subData?.trial_currency || "").split(",").map((s) => s.trim()).filter(Boolean);
+    if (trialCurrencyIds.length > 0 && !trialCurrencyIds.includes(currencyId)) {
+      trialDays = 0;
+    }
+  }
+  const trialActive = trialDays > 0;
+  let afterTrialPrice = null;
+  let afterTrialInterval = null;
+  if (trialActive && currency && items.length > 0) {
+    const noTrialResult = getCheckoutAmount(items, currency, false, true, {
+      exchangeRate: hasDynamicPricing ? exchangeRate : null
+    });
+    let afterTrialBN = new BN(noTrialResult.total);
+    const recurringDiscount = calculateCouponDiscount(
+      items,
+      currency,
+      session,
+      hasDynamicPricing,
+      exchangeRate,
+      false,
+      true
+    );
+    if (recurringDiscount.gt(new BN(0))) {
+      afterTrialBN = afterTrialBN.sub(recurringDiscount);
+      if (afterTrialBN.isNeg()) afterTrialBN = new BN(0);
+    }
+    afterTrialPrice = `${formatDynamicPrice(
+      fromUnitToToken(afterTrialBN, currency.decimal),
+      hasDynamicPricing
+    )} ${currency.symbol}`;
+    const recurringItem = items.find((item) => {
+      const price = item.upsell_price || item.price;
+      return price?.type === "recurring" && price?.recurring;
+    });
+    if (recurringItem) {
+      const price = recurringItem.upsell_price || recurringItem.price;
+      afterTrialInterval = price?.recurring?.interval || null;
+    }
+  }
+  return {
+    active: trialActive,
+    days: trialDays,
+    afterTrialPrice,
+    afterTrialInterval
+  };
+}

package/es/checkout/core/promotion.d.ts

@@ -0,0 +1,10 @@
+import type { TCheckoutSessionExpanded } from '@blocklet/payment-types';
+export declare function extractPromotionCodeFromSession(session: TCheckoutSessionExpanded | undefined | null): string | null;
+export declare function applyPromotionCode(sessionId: string, code: string, currencyId: string | null | undefined): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export declare function removePromotionCode(sessionId: string): Promise<void>;
+export declare function recalculatePromotion(sessionId: string, currencyId: string | null | undefined): Promise<void>;
+export declare function isPromotionActive(session: TCheckoutSessionExpanded | undefined | null): boolean;
+export declare function hasAppliedDiscounts(session: TCheckoutSessionExpanded | undefined | null): boolean;

package/es/checkout/core/promotion.js

@@ -0,0 +1,39 @@
+import api, { API } from "../../shared/api.js";
+import { getErrorMessage } from "../../types/checkout-augmented.js";
+export function extractPromotionCodeFromSession(session) {
+  const discounts = session?.discounts || [];
+  if (discounts.length === 0) return null;
+  const firstDiscount = discounts[0];
+  const details = firstDiscount.promotion_code_details;
+  const verification = firstDiscount.verification_data;
+  return details?.code || verification?.code || firstDiscount.promotion_code || firstDiscount.coupon || null;
+}
+export async function applyPromotionCode(sessionId, code, currencyId) {
+  try {
+    const { data } = await api.post(API.APPLY_PROMOTION(sessionId), {
+      promotion_code: code,
+      currency_id: currencyId
+    });
+    if (data.error) {
+      return { success: false, error: data.error };
+    }
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: getErrorMessage(err) || "Invalid promotion code" };
+  }
+}
+export async function removePromotionCode(sessionId) {
+  await api.delete(API.REMOVE_PROMOTION(sessionId));
+}
+export async function recalculatePromotion(sessionId, currencyId) {
+  await api.post(API.RECALCULATE_PROMOTION_SESSION(sessionId), {
+    currency_id: currencyId
+  });
+}
+export function isPromotionActive(session) {
+  return session?.allow_promotion_codes !== false;
+}
+export function hasAppliedDiscounts(session) {
+  const discounts = session?.discounts || [];
+  return discounts.length > 0;
+}

package/es/checkout/core/session.d.ts

@@ -0,0 +1,26 @@
+import type { TCheckoutSessionExpanded } from '@blocklet/payment-types';
+export declare function parseProduct(session: TCheckoutSessionExpanded): {
+    name: string;
+    description: string;
+    images: any[];
+    features: {
+        name: string;
+        icon: string | undefined;
+    }[];
+    billing: {
+        mode: "payment" | "subscription";
+        interval: "month" | "year" | "week" | "day" | null;
+        intervalCount: number;
+        displayInterval: string;
+    };
+    metadata: Record<string, any>;
+} | null;
+export declare function parseSubscription(session: TCheckoutSessionExpanded): {
+    mode: "payment" | "subscription" | "setup";
+    showStake: boolean;
+    confirmMessage: string;
+} | null;
+export declare function parsePageInfo(session: TCheckoutSessionExpanded): {
+    formPurposeDescription: any;
+    showProductFeatures: boolean;
+};

package/es/checkout/core/session.js

@@ -0,0 +1,50 @@
+export function parseProduct(session) {
+  const items = session.line_items || [];
+  if (items.length === 0) return null;
+  const firstItem = items[0];
+  const price = firstItem.upsell_price || firstItem.price;
+  const product = price?.product;
+  if (!product) return null;
+  const recurring = price?.recurring;
+  const mode = session.mode === "subscription" ? "subscription" : "payment";
+  const intervalMap = {
+    day: "daily",
+    week: "weekly",
+    month: "monthly",
+    year: "yearly"
+  };
+  return {
+    name: product.name || "",
+    description: product.description || "",
+    images: product.images || [],
+    features: (product.features || []).map((f) => ({
+      name: f.name || "",
+      icon: f.icon
+    })),
+    billing: {
+      mode,
+      interval: recurring?.interval || null,
+      intervalCount: recurring?.interval_count || 1,
+      displayInterval: recurring ? intervalMap[recurring.interval] || recurring.interval : ""
+    },
+    metadata: product.metadata || {}
+  };
+}
+export function parseSubscription(session) {
+  const subData = session.subscription_data;
+  if (!subData && session.mode === "payment") return null;
+  return {
+    mode: session.mode || "payment",
+    showStake: !subData?.no_stake,
+    confirmMessage: ""
+  };
+}
+export function parsePageInfo(session) {
+  const metadata = session.metadata;
+  const pageInfo = metadata?.page_info;
+  const showRaw = metadata?.show_product_features ?? pageInfo?.show_product_features;
+  return {
+    formPurposeDescription: pageInfo?.form_purpose_description,
+    showProductFeatures: `${showRaw}` === "true"
+  };
+}