@blocklet/payment-react-headless 1.26.0

package/lib/shared/api.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = exports.API = void 0;
+exports.getLocale = getLocale;
+exports.getPrefix = getPrefix;
+var _jsSdk = require("@blocklet/js-sdk");
+var _isNull = _interopRequireDefault(require("lodash/isNull"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const PAYMENT_KIT_DID = "z2qaCNvKMv5GjouKdcDWexv6WqtHbpNPQDnAk";
+function getPrefix() {
+  const prefix = window.blocklet?.prefix || "/";
+  const baseUrl = window.location?.origin;
+  if (window.__PAYMENT_KIT_BASE_URL) {
+    try {
+      const tmp = new URL(window.__PAYMENT_KIT_BASE_URL);
+      if (tmp.origin !== window.location.origin) {
+        return window.__PAYMENT_KIT_BASE_URL;
+      }
+    } catch {}
+  }
+  const componentId = (window.blocklet?.componentId || "").split("/").pop();
+  if (componentId === PAYMENT_KIT_DID) {
+    return `${baseUrl}${prefix}`;
+  }
+  const component = (window.blocklet?.componentMountPoints || []).find(x => x?.did === PAYMENT_KIT_DID);
+  if (component) {
+    return `${baseUrl}${component.mountPoint}`;
+  }
+  return `${baseUrl}${prefix}`;
+}
+function getLocale(languages) {
+  if (typeof window === "undefined") return "en";
+  try {
+    const stored = localStorage.getItem("locale");
+    if (stored) return stored;
+  } catch {}
+  if (languages && languages.length > 0) return languages[0];
+  return navigator.language?.split("-")[0] || "en";
+}
+function createApi() {
+  const api2 = (0, _jsSdk.createAxios)();
+  api2.interceptors.request.use(config => {
+    const prefix = getPrefix();
+    config.baseURL = prefix || "";
+    const locale = getLocale(window.blocklet?.languages);
+    const query = new URLSearchParams(config.url?.split("?").pop());
+    config.params = {
+      ...(config.params || {}),
+      locale
+    };
+    const authToken = window.__PAYMENT_KIT_AUTH_TOKEN;
+    if (authToken && typeof config.params.authToken === "undefined" && !query.has("authToken")) {
+      config.params.authToken = authToken;
+    }
+    if (typeof config.params.livemode === "undefined" && query.has("livemode") === false) {
+      const livemode = localStorage.getItem("livemode");
+      config.params.livemode = (0, _isNull.default)(livemode) ? true : JSON.parse(livemode);
+    }
+    return config;
+  }, err => Promise.reject(err));
+  return api2;
+}
+const api = createApi();
+module.exports = api;
+const API = exports.API = {
+  START_PAYMENT_LINK: id => `/api/checkout-sessions/start/${id}`,
+  RETRIEVE_SESSION: id => `/api/checkout-sessions/retrieve/${id}`,
+  SWITCH_CURRENCY: id => `/api/checkout-sessions/${id}/switch-currency`,
+  SUBMIT: id => `/api/checkout-sessions/${id}/submit`,
+  DONATE_SUBMIT: id => `/api/checkout-sessions/${id}/donate-submit`,
+  FAST_CHECKOUT_CONFIRM: id => `/api/checkout-sessions/${id}/fast-checkout-confirm`,
+  EXCHANGE_RATE: id => `/api/checkout-sessions/${id}/exchange-rate`,
+  ADJUST_QUANTITY: id => `/api/checkout-sessions/${id}/adjust-quantity`,
+  UPSELL: id => `/api/checkout-sessions/${id}/upsell`,
+  DOWNSELL: id => `/api/checkout-sessions/${id}/downsell`,
+  CROSS_SELL: id => `/api/checkout-sessions/${id}/cross-sell`,
+  CHANGE_AMOUNT: id => `/api/checkout-sessions/${id}/amount`,
+  SLIPPAGE: id => `/api/checkout-sessions/${id}/slippage`,
+  ABORT_STRIPE: id => `/api/checkout-sessions/${id}/abort-stripe`,
+  RECALCULATE_PROMOTION_SESSION: id => `/api/checkout-sessions/${id}/recalculate-promotion`,
+  APPLY_PROMOTION: id => `/api/checkout-sessions/${id}/apply-promotion`,
+  REMOVE_PROMOTION: id => `/api/checkout-sessions/${id}/remove-promotion`,
+  CUSTOMER_ME: "/api/customers/me",
+  VENDOR_ORDER_STATUS: id => `/api/vendors/order/${id}/status`
+};

package/lib/shared/format.d.ts

@@ -0,0 +1,38 @@
+import { BN } from '@ocap/util';
+import type { TPaymentCurrency, TPrice, TLineItemExpanded } from '@blocklet/payment-types';
+export declare function formatNumber(n: number | string, precision?: number, trim?: boolean, thousandSeparated?: boolean): string;
+export declare function formatBNStr(str?: string, decimals?: number, precision?: number, trim?: boolean, thousandSeparated?: boolean): string;
+export declare function formatDynamicPrice(n: number | string, isDynamic: boolean, precision?: number, trim?: boolean, thousandSeparated?: boolean): string;
+export declare function getUsdAmountFromTokenUnits(tokenAmount: BN | string, tokenDecimals: number, exchangeRate?: string | null): string | null;
+export declare function formatUsdAmount(amount: string | null, locale?: string): string | null;
+export declare function formatExchangeRate(amount: string | null): string | null;
+export declare function formatExchangeRateDisplay(rate: string | number | null | undefined, currency?: string, decimals?: number): string | null;
+export declare function formatAmount(amount: string, decimals: number, precision?: number): string;
+export declare function getPriceCurrencyOptions(price: TPrice): Array<{
+    currency_id: string;
+    unit_amount: string;
+    custom_unit_amount: {
+        preset?: string;
+        presets: string[];
+    } | null;
+    tiers: unknown;
+}>;
+export declare function getPriceUnitAmountByCurrency(price: TPrice, currency: TPaymentCurrency): string;
+export declare function getLineItemAmounts(item: TLineItemExpanded, currency: TPaymentCurrency, { useUpsell, exchangeRate }?: {
+    useUpsell?: boolean;
+    exchangeRate?: string | null;
+}): {
+    unitAmount: BN;
+    totalAmount: BN;
+    isDynamicQuote: boolean;
+};
+export declare function getCheckoutAmount(items: TLineItemExpanded[], currency: TPaymentCurrency, trialing?: boolean, upsell?: boolean, { exchangeRate }?: {
+    exchangeRate?: string | null;
+}): {
+    subtotal: string;
+    total: string;
+    renew: string;
+    discount: string;
+    shipping: string;
+    tax: string;
+};

package/lib/shared/format.js

@@ -0,0 +1,262 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatAmount = formatAmount;
+exports.formatBNStr = formatBNStr;
+exports.formatDynamicPrice = formatDynamicPrice;
+exports.formatExchangeRate = formatExchangeRate;
+exports.formatExchangeRateDisplay = formatExchangeRateDisplay;
+exports.formatNumber = formatNumber;
+exports.formatUsdAmount = formatUsdAmount;
+exports.getCheckoutAmount = getCheckoutAmount;
+exports.getLineItemAmounts = getLineItemAmounts;
+exports.getPriceCurrencyOptions = getPriceCurrencyOptions;
+exports.getPriceUnitAmountByCurrency = getPriceUnitAmountByCurrency;
+exports.getUsdAmountFromTokenUnits = getUsdAmountFromTokenUnits;
+var _util = require("@ocap/util");
+function formatNumber(n, precision = 6, trim = true, thousandSeparated = true) {
+  if (!n || n === "0") {
+    return "0";
+  }
+  const num = Number(n);
+  if (!Number.isFinite(num)) {
+    return "0";
+  }
+  let result;
+  if (thousandSeparated) {
+    result = num.toLocaleString("en-US", {
+      minimumFractionDigits: precision,
+      maximumFractionDigits: precision
+    });
+  } else {
+    result = num.toFixed(precision);
+  }
+  if (!trim) {
+    return result;
+  }
+  const [left, right] = result.split(".");
+  if (!right) return left;
+  const trimmed = right.replace(/0+$/, "");
+  return trimmed ? `${left}.${trimmed}` : left;
+}
+function formatBNStr(str = "", decimals = 18, precision = 6, trim = true, thousandSeparated = true) {
+  if (!str) {
+    return "0";
+  }
+  return formatNumber((0, _util.fromUnitToToken)(str, decimals), precision, trim, thousandSeparated);
+}
+function formatDynamicPrice(n, isDynamic, precision = 6, trim = true, thousandSeparated = true) {
+  if (!isDynamic) {
+    return formatNumber(n, precision, trim, thousandSeparated);
+  }
+  const num = Number(n);
+  if (!Number.isFinite(num)) {
+    return formatNumber(n, precision, trim, thousandSeparated);
+  }
+  const abs = Math.abs(num);
+  const targetPrecision = abs > 0 && abs < 0.01 ? precision : 2;
+  return formatNumber(n, targetPrecision, trim, thousandSeparated);
+}
+const USD_DECIMALS = 8;
+function getUsdAmountFromTokenUnits(tokenAmount, tokenDecimals, exchangeRate) {
+  if (!exchangeRate && exchangeRate !== "0") {
+    return null;
+  }
+  if (tokenDecimals === void 0 || tokenDecimals === null) {
+    return null;
+  }
+  try {
+    const amountBN = tokenAmount instanceof _util.BN ? tokenAmount : new _util.BN(tokenAmount || "0");
+    const tokenScale = new _util.BN(10).pow(new _util.BN(tokenDecimals));
+    if (tokenScale.isZero()) {
+      return null;
+    }
+    const rateBN = new _util.BN(exchangeRate.replace(".", ""));
+    const rateDecimalPlaces = exchangeRate.includes(".") ? exchangeRate.split(".")[1]?.length || 0 : 0;
+    const rateScale = new _util.BN(10).pow(new _util.BN(rateDecimalPlaces));
+    const usdPrecisionScale = new _util.BN(10).pow(new _util.BN(USD_DECIMALS));
+    const usdUnit = amountBN.mul(rateBN).mul(usdPrecisionScale).div(tokenScale.mul(rateScale));
+    return (0, _util.fromUnitToToken)(usdUnit.toString(), USD_DECIMALS);
+  } catch {
+    return null;
+  }
+}
+function formatUsdAmount(amount, locale = "en") {
+  if (!amount && amount !== "0") {
+    return null;
+  }
+  const num = Number(amount);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).format(num);
+}
+function formatExchangeRate(amount) {
+  if (!amount && amount !== "0") {
+    return null;
+  }
+  const value = String(amount);
+  const num = Number(value);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  return value;
+}
+function formatExchangeRateDisplay(rate, currency = "USD", decimals = 2) {
+  if (rate === null || rate === void 0) {
+    return null;
+  }
+  const num = Number(rate);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  const formattedValue = num.toFixed(decimals);
+  if (currency === "USD") {
+    return `$${formattedValue}`;
+  }
+  return `${formattedValue} ${currency}`;
+}
+function formatAmount(amount, decimals, precision = 2) {
+  const tokenAmount = (0, _util.fromUnitToToken)(amount, decimals);
+  const numericValue = Number(tokenAmount);
+  if (!Number.isFinite(numericValue)) {
+    return formatBNStr(amount, decimals, precision, true, false);
+  }
+  const abs = Math.abs(numericValue);
+  const targetPrecision = abs > 0 && abs < 0.01 ? decimals : 2;
+  return formatNumber(tokenAmount, targetPrecision, true, false);
+}
+function getPriceCurrencyOptions(price) {
+  if (Array.isArray(price.currency_options)) {
+    return price.currency_options;
+  }
+  return [{
+    currency_id: price.currency_id,
+    unit_amount: price.unit_amount,
+    custom_unit_amount: price.custom_unit_amount || null,
+    tiers: null
+  }];
+}
+function getPriceUnitAmountByCurrency(price, currency) {
+  const options = getPriceCurrencyOptions(price);
+  const option = options.find(x => x.currency_id === currency?.id);
+  if (option) {
+    if (option.custom_unit_amount) {
+      return option.custom_unit_amount.preset || option.custom_unit_amount.presets[0];
+    }
+    return option.unit_amount;
+  }
+  if (price.currency_id === currency?.id) {
+    if (price.custom_unit_amount) {
+      return price.custom_unit_amount.preset || price.custom_unit_amount.presets[0];
+    }
+    return price.unit_amount;
+  }
+  return "0";
+}
+function getLineItemAmounts(item, currency, {
+  useUpsell = true,
+  exchangeRate = null
+} = {}) {
+  if (!currency) {
+    return {
+      unitAmount: new _util.BN(0),
+      totalAmount: new _util.BN(0),
+      isDynamicQuote: false
+    };
+  }
+  const price = useUpsell ? item.upsell_price || item.price : item.price;
+  const quantity = new _util.BN(item.quantity || 0);
+  const quoteAmount = item.quoted_amount;
+  const quoteCurrencyId = item.quote_currency_id;
+  const isDynamicPrice = price?.pricing_type === "dynamic";
+  const isQuoteValidForCurrency = isDynamicPrice && quoteAmount && quoteCurrencyId === currency.id;
+  if (isQuoteValidForCurrency) {
+    const totalAmount = new _util.BN(quoteAmount || "0");
+    const unitAmount2 = quantity.gt(new _util.BN(0)) ? totalAmount.add(quantity).sub(new _util.BN(1)).div(quantity) : new _util.BN(0);
+    return {
+      unitAmount: unitAmount2,
+      totalAmount,
+      isDynamicQuote: true
+    };
+  }
+  if (isDynamicPrice && exchangeRate && price?.base_amount) {
+    const rate = Number(exchangeRate);
+    if (rate > 0 && Number.isFinite(rate)) {
+      const baseAmountUsd = Number(price.base_amount);
+      if (baseAmountUsd > 0 && Number.isFinite(baseAmountUsd)) {
+        const tokenAmount = baseAmountUsd / rate;
+        const unitAmount2 = (0, _util.fromTokenToUnit)(tokenAmount.toFixed(currency.decimal || 8), currency.decimal || 8);
+        return {
+          unitAmount: unitAmount2,
+          totalAmount: unitAmount2.mul(quantity),
+          isDynamicQuote: false
+        };
+      }
+    }
+  }
+  if (!exchangeRate && price?.base_amount != null) {
+    const baseAmountUsd = Number(price.base_amount);
+    if (baseAmountUsd >= 0 && Number.isFinite(baseAmountUsd)) {
+      const dec = currency.decimal || 2;
+      const unitAmountBN = (0, _util.fromTokenToUnit)(baseAmountUsd.toFixed(dec), dec);
+      return {
+        unitAmount: unitAmountBN,
+        totalAmount: unitAmountBN.mul(quantity),
+        isDynamicQuote: false
+      };
+    }
+  }
+  const unitAmount = new _util.BN(getPriceUnitAmountByCurrency(price, currency));
+  return {
+    unitAmount,
+    totalAmount: unitAmount.mul(quantity),
+    isDynamicQuote: false
+  };
+}
+function getCheckoutAmount(items, currency, trialing = false, upsell = true, {
+  exchangeRate = null
+} = {}) {
+  let renew = new _util.BN(0);
+  const total = items.filter(x => {
+    const price = upsell ? x.upsell_price || x.price : x.price;
+    return price != null;
+  }).reduce((acc, x) => {
+    const quoteCurrencyId = x.quote_currency_id;
+    let totalAmount;
+    if (x.custom_amount && quoteCurrencyId && quoteCurrencyId === currency.id) {
+      totalAmount = new _util.BN(x.custom_amount);
+    } else {
+      ({
+        totalAmount
+      } = getLineItemAmounts(x, currency, {
+        useUpsell: upsell,
+        exchangeRate
+      }));
+    }
+    const price = upsell ? x.upsell_price || x.price : x.price;
+    if (price?.type === "recurring") {
+      renew = renew.add(totalAmount);
+      if (trialing) {
+        return acc;
+      }
+      if (price.recurring?.usage_type === "metered") {
+        return acc;
+      }
+    }
+    return acc.add(totalAmount);
+  }, new _util.BN(0)).toString();
+  return {
+    subtotal: total,
+    total,
+    renew: formatDynamicPrice(renew.toString(), !!exchangeRate),
+    discount: "0",
+    shipping: "0",
+    tax: "0"
+  };
+}

package/lib/shared/polling.d.ts

@@ -0,0 +1,15 @@
+import type { CheckoutResult } from '../checkout/types';
+/**
+ * Poll for checkout session completion.
+ * Extracted from react/src/payment/form/index.tsx:72-99
+ *
+ * Uses p-wait-for with 2s interval and 3 minute timeout.
+ * Completion condition: session.status === 'complete' && payment_status in ['paid', 'no_payment_required']
+ * Throws if paymentIntent has last_payment_error.
+ */
+export declare function waitForCheckoutComplete(sessionId: string): Promise<CheckoutResult>;
+/**
+ * Generate unique idempotency key for submit (Final Freeze Architecture).
+ * Format: ${sessionId}-${currencyId}-${timestamp}-${random}
+ */
+export declare function generateIdempotencyKey(sessionId: string, currencyId: string): string;

package/lib/shared/polling.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateIdempotencyKey = generateIdempotencyKey;
+exports.waitForCheckoutComplete = waitForCheckoutComplete;
+var _pWaitFor = _interopRequireDefault(require("p-wait-for"));
+var _api = _interopRequireWildcard(require("./api"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function waitForCheckoutComplete(sessionId) {
+  let result;
+  await (0, _pWaitFor.default)(async () => {
+    const {
+      data
+    } = await _api.default.get(_api.API.RETRIEVE_SESSION(sessionId));
+    if (data.paymentIntent && data.paymentIntent.status === "requires_action" && data.paymentIntent.last_payment_error) {
+      throw new Error(data.paymentIntent.last_payment_error.message);
+    }
+    result = data;
+    return data.checkoutSession?.status === "complete" && ["paid", "no_payment_required"].includes(data.checkoutSession?.payment_status);
+  }, {
+    interval: 2e3,
+    timeout: 3 * 60 * 1e3
+  });
+  return result;
+}
+function generateIdempotencyKey(sessionId, currencyId) {
+  return `${sessionId}-${currencyId}-${Date.now()}-${Math.random().toString(36).substring(2, 10)}`;
+}

package/lib/shared/types.d.ts

@@ -0,0 +1,10 @@
+export interface ApiConfig {
+    baseUrl?: string;
+    authToken?: string;
+    locale?: string;
+    livemode?: boolean;
+}
+export interface LoadingState {
+    isLoading: boolean;
+    error: string | null;
+}

package/lib/shared/types.js

@@ -0,0 +1 @@
+"use strict";

package/lib/shared/validation.d.ts

@@ -0,0 +1,38 @@
+import type { CheckoutFormData } from '../checkout/types';
+export declare const postalCodePatterns: Record<string, RegExp>;
+export declare function validatePostalCode(postalCode: string, country?: string): boolean;
+export declare function getFieldValidation(fieldName: string, validations?: Record<string, {
+    pattern?: string;
+    pattern_message?: Record<string, string>;
+}>, locale?: string): {
+    pattern?: {
+        value: RegExp;
+        message: string;
+    };
+};
+export declare function validatePhone(phone: string): Promise<boolean>;
+export declare function validateEmail(email: string): boolean;
+export interface ValidateFormOptions {
+    phoneEnabled: boolean;
+    addressMode: 'auto' | 'required' | null;
+    fieldValidation?: Record<string, {
+        pattern?: string;
+        pattern_message?: Record<string, string>;
+    }>;
+    locale?: string;
+}
+export interface FormErrors {
+    customer_name?: string;
+    customer_email?: string;
+    customer_phone?: string;
+    'billing_address.country'?: string;
+    'billing_address.state'?: string;
+    'billing_address.line1'?: string;
+    'billing_address.city'?: string;
+    'billing_address.postal_code'?: string;
+    [key: string]: string | undefined;
+}
+export declare function validateForm(values: CheckoutFormData | null, options: ValidateFormOptions): Promise<{
+    valid: boolean;
+    errors: FormErrors;
+}>;