@fire-spark/payments-deuna-widget 0.0.0-stage → 0.11.0

package/dist/index.d.ts

@@ -0,0 +1,298 @@
+import { PaymentAdapter, PaymentEnvironment, PaymentErrorCode, PaymentIntentStatus, PaymentPolicy, StandardPaymentError } from "@fire-spark/payments";
+//#region src/constants.d.ts
+declare const DEUNA_PROVIDER = "deuna";
+/**
+ * Widget `paymentMethods` by `payments.config.processor` (same keys as
+ * `DEUNA_PROCESSORS_BY_METHOD` of `@repo/validations`). Nequi, Mercado Pago
+ * and Deuna App Wallet come from their DEUNA widget pages; PSE uses the
+ * processor of the PSE API page and the card entry opens the card form
+ * (both to verify in sandbox).
+ */
+declare const DEUNA_PROCESSORS: {
+  readonly card: {
+    readonly method: "CARD";
+    readonly paymentMethod: "credit_card";
+    readonly processors: readonly [];
+  };
+  readonly nequi: {
+    readonly method: "WALLET";
+    readonly paymentMethod: "voucher";
+    readonly processors: readonly ["nequi_push_voucher"];
+  };
+  readonly mercadopago: {
+    readonly method: "WALLET";
+    readonly paymentMethod: "wallet";
+    readonly processors: readonly ["mercadopago_wallet"];
+  };
+  readonly deuna_wallet: {
+    readonly method: "WALLET";
+    readonly paymentMethod: "voucher";
+    readonly processors: readonly ["deuna_wallet"];
+  };
+  readonly pse: {
+    readonly method: "BANK_TRANSFER";
+    readonly paymentMethod: "bank_transfer";
+    readonly processors: readonly ["payu_pse"];
+  };
+};
+type DeunaProcessor = keyof typeof DEUNA_PROCESSORS;
+declare const DEUNA_PROCESSOR_KEYS: DeunaProcessor[];
+/**
+ * `start` covers the whole widget session (push approval, bank redirect),
+ * so the provider timeout is the longest validity DEUNA documents for a
+ * customer step (15 min QR). Dashboard `runtime` still wins.
+ */
+declare const DEUNA_WIDGET_POLICY: Partial<PaymentPolicy>;
+/** `ctx.storage` key that keeps the DEUNA order token of an attempt. */
+declare const orderTokenKey: (attemptReference: string) => string;
+//#endregion
+//#region src/types.d.ts
+/** Methods this package charges through the DEUNA Payment Widget. */
+type DeunaWidgetMethod = "CARD" | "WALLET" | "BANK_TRANSFER";
+/** `paymentMethods` entry of `initPaymentWidget` (the engine takes one). */
+type DeunaWidgetPaymentMethod = {
+  paymentMethod: string;
+  /** Omitted for cards: DEUNA routes them to the merchant's processor. */
+  processors?: string[];
+};
+type DeunaWidgetLanguage = "es" | "en" | "pt";
+type DeunaWidgetOpenInput = {
+  publicApiKey: string;
+  environment: PaymentEnvironment;
+  orderToken: string;
+  paymentMethods: DeunaWidgetPaymentMethod[];
+  language: DeunaWidgetLanguage;
+  /** Aborted on timeout or cancel: close the widget, resolve `closed`. */
+  signal: AbortSignal;
+};
+/** How the widget ended, one variant per DEUNA SDK callback. */
+type DeunaWidgetOutcome =
+/** `onSuccess`: the payment went through (confirmed with `query`). */
+{
+  type: "success";
+  order?: Record<string, unknown>;
+} |
+/** `onPending`: the customer still has to approve (push, bank, app). */
+{
+  type: "pending";
+  order?: Record<string, unknown>;
+} |
+/** `onExpired`: the code, QR or push expired. */
+{
+  type: "expired";
+} |
+/** `onError`: `code` from the error payload, `errorType` from the SDK. */
+{
+  type: "error";
+  code?: string | null;
+  errorType?: string | null;
+  message?: string | null;
+} |
+/** `onClosed`: dismissed by the customer or by `close()`. */
+{
+  type: "closed";
+  by: "user" | "system";
+};
+/**
+ * Implemented once per template with the DEUNA SDK
+ * (`@deuna/react-native-sdk` or the Web SDK). It opens the widget with the
+ * given order token and resolves with the first final callback.
+ */
+type DeunaWidgetBridge = {
+  open(input: DeunaWidgetOpenInput): Promise<DeunaWidgetOutcome>;
+};
+/** `payment.data.status` of a DEUNA order (docs: payment-workflow-statuses). */
+type DeunaPaymentStatus = "pending" | "pending_3ds" | "processing" | "processed" | "authorizing" | "authorized" | "capturing" | "partial_capturing" | "partial_captured" | "captured" | "voiding" | "voided" | "refunding" | "partial_refunding" | "partial_refunded" | "refunded" | "manual_review" | "denied" | "cancelled" | "expired";
+/** Where DEUNA sends the customer back (Mercado Pago, PSE); deep links ok. */
+type DeunaCallbackUrls = Partial<Record<"on_success" | "on_pending" | "on_failed" | "on_canceled" | "on_reject", string>>;
+type DeunaTokenizeInput = {
+  paymentId: string;
+  orderId: string;
+  attemptReference: string;
+  callbackUrls?: DeunaCallbackUrls;
+};
+/** `order_id` is the attempt reference (our DEUNA `order.order_id`). */
+type DeunaTokenizeOutput = {
+  order_token: string;
+  order_id: string;
+};
+/** Payment status of a DEUNA order, normalized by the Spark API. */
+type DeunaOrderState = {
+  order_token: string;
+  status: DeunaPaymentStatus | (string & {});
+  transaction_id?: string | null;
+  /** DEUNA `error.code` (core, `DP-`, `EMA-`…) when the payment failed. */
+  error?: {
+    code: string | null;
+    message: string | null;
+  } | null;
+};
+/**
+ * Spark DEUNA endpoints (`/storefront/v1/payments/deuna/:payment_id/...`).
+ * `createDeunaWidgetApi` of `@fire-spark/storefront` implements it; the
+ * private key never leaves the API.
+ */
+type DeunaWidgetApi = {
+  /** `POST .../tokenize`: DEUNA order for the tender attempt. */
+  tokenize(input: DeunaTokenizeInput): Promise<DeunaTokenizeOutput>;
+  /** `GET .../orders/:order_token`: payment status. */
+  order(input: {
+    paymentId: string;
+    orderToken: string;
+  }): Promise<DeunaOrderState>;
+};
+//#endregion
+//#region src/adapter.d.ts
+type DeunaWidgetOptions = {
+  method: DeunaWidgetMethod;
+  /** Template implementation of the DEUNA Payment Widget. */
+  bridge: DeunaWidgetBridge;
+  /** Spark DEUNA endpoints: `createDeunaWidgetApi` of the storefront SDK. */
+  api: DeunaWidgetApi;
+  language?: DeunaWidgetLanguage;
+  /** Return URLs or deep links for redirect methods (Mercado Pago, PSE). */
+  callbackUrls?: DeunaCallbackUrls;
+};
+/** Processors this method can charge with. */
+declare const deunaProcessorsFor: (method: DeunaWidgetMethod) => ("card" | "deuna_wallet" | "mercadopago" | "nequi" | "pse")[];
+/** `payments.config.processor`; optional when the method has only one. */
+declare const resolveDeunaProcessor: (method: DeunaWidgetMethod, config: Record<string, unknown>) => DeunaProcessor;
+/** `paymentMethods` of `initPaymentWidget` for a processor. */
+declare const deunaWidgetPaymentMethods: (processor: DeunaProcessor) => DeunaWidgetPaymentMethod[];
+/**
+ * DEUNA Payment Widget for every method (card, Nequi, Mercado Pago, Deuna
+ * App Wallet, PSE). Spark tokenizes the DEUNA order with the private key
+ * (`api.tokenize`), the template opens the widget with the public key, and
+ * the order status read back from Spark (`api.order`) is the one that
+ * counts. Refunds go through the DEUNA Admin (manual reversal).
+ */
+declare const deunaWidgetPayments: (options: DeunaWidgetOptions) => PaymentAdapter;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * DEUNA codes as returned: core API errors, widget/SDK error types and the
+ * `DP-` processor codes a wallet or bank payment can hit.
+ */
+declare const deunaErrors: Readonly<Record<string, import("@fire-spark/payments").PaymentErrorEntry>> & {
+  PAYMENT_DECLINED: {
+    code: "WALLET_REJECTED";
+    source: string;
+    since: string;
+  };
+  PAYMENT_FAILED: {
+    code: "WALLET_REJECTED";
+    source: string;
+    since: string;
+  };
+  PAYMENT_ERROR: {
+    code: "WALLET_REJECTED";
+    source: string;
+    since: string;
+  };
+  INITIALIZATION_FAILED: {
+    code: "PROVIDER_UNAVAILABLE";
+    retryable: true;
+    source: string;
+    since: string;
+  };
+  CARD_EXPIRED: {
+    code: "EXPIRED_CARD";
+    source: string;
+    since: string;
+  };
+  INVALID_REQUEST: {
+    code: "INVALID_REQUEST";
+    source: string;
+    since: string;
+  };
+  AUTHENTICATION_FAILED: {
+    code: "INVALID_CREDENTIALS";
+    source: string;
+    since: string;
+  };
+  RESOURCE_NOT_FOUND: {
+    code: "INVALID_REQUEST";
+    source: string;
+    since: string;
+  };
+  IDEMPOTENCY_CONFLICT: {
+    code: "AMBIGUOUS";
+    source: string;
+    since: string;
+  };
+  RATE_LIMIT_EXCEEDED: {
+    code: "PROVIDER_UNAVAILABLE";
+    retryable: true;
+    source: string;
+    since: string;
+  };
+  PROVIDER_UNAVAILABLE: {
+    code: "PROVIDER_UNAVAILABLE";
+    retryable: true;
+    source: string;
+    since: string;
+  };
+  "DP-4200": {
+    code: "PROVIDER_UNAVAILABLE";
+    retryable: true;
+    source: string;
+    since: string;
+  };
+  "DP-4504": {
+    code: "PROVIDER_UNAVAILABLE";
+    retryable: true;
+    source: string;
+    since: string;
+  };
+  "DP-4507": {
+    code: "INVALID_PIN";
+    source: string;
+    since: string;
+  };
+  "DP-4520": {
+    code: "WALLET_REJECTED";
+    source: string;
+    since: string;
+  };
+  "DP-4562": {
+    code: "WALLET_EXPIRED";
+    source: string;
+    since: string;
+  };
+  "DP-9000": {
+    code: "INSUFFICIENT_FUNDS";
+    source: string;
+    since: string;
+  };
+  "DP-9001": {
+    code: "LIMIT_EXCEEDED";
+    source: string;
+    since: string;
+  };
+  "DP-9999": {
+    code: "UNKNOWN";
+    source: string;
+    since: string;
+  };
+};
+//#endregion
+//#region src/status.d.ts
+/** What a DEUNA payment status means for the tender. */
+type DeunaStatusMapping = {
+  status: PaymentIntentStatus;
+  /** Spark code of a FAILED status. */
+  error?: PaymentErrorCode;
+};
+/** Spark code of a rejected payment of `method`. */
+declare const deunaDeclinedCode: (method: DeunaWidgetMethod) => PaymentErrorCode;
+/** `payment.data.status` (case-sensitive) to the tender status. */
+declare const mapDeunaStatus: (status: string, method: DeunaWidgetMethod) => DeunaStatusMapping;
+/** Error of a FAILED state: the DEUNA code wins over the status default. */
+declare const deunaStateError: (input: {
+  method: DeunaWidgetMethod;
+  state: DeunaOrderState;
+  fallback: PaymentErrorCode;
+  attempt: number;
+}) => StandardPaymentError;
+//#endregion
+export { DEUNA_PROCESSORS, DEUNA_PROCESSOR_KEYS, DEUNA_PROVIDER, DEUNA_WIDGET_POLICY, type DeunaCallbackUrls, type DeunaOrderState, type DeunaPaymentStatus, DeunaProcessor, DeunaStatusMapping, type DeunaTokenizeInput, type DeunaTokenizeOutput, type DeunaWidgetApi, type DeunaWidgetBridge, type DeunaWidgetLanguage, type DeunaWidgetMethod, type DeunaWidgetOpenInput, DeunaWidgetOptions, type DeunaWidgetOutcome, type DeunaWidgetPaymentMethod, deunaDeclinedCode, deunaErrors, deunaProcessorsFor, deunaStateError, deunaWidgetPaymentMethods, deunaWidgetPayments, mapDeunaStatus, orderTokenKey, resolveDeunaProcessor };

package/dist/index.js

@@ -0,0 +1,465 @@
+import { PaymentError, createPaymentError, definePaymentErrors, toPaymentError } from "@fire-spark/payments";
+//#region src/constants.ts
+const DEUNA_PROVIDER = "deuna";
+/**
+* Widget `paymentMethods` by `payments.config.processor` (same keys as
+* `DEUNA_PROCESSORS_BY_METHOD` of `@repo/validations`). Nequi, Mercado Pago
+* and Deuna App Wallet come from their DEUNA widget pages; PSE uses the
+* processor of the PSE API page and the card entry opens the card form
+* (both to verify in sandbox).
+*/
+const DEUNA_PROCESSORS = {
+	card: {
+		method: "CARD",
+		paymentMethod: "credit_card",
+		processors: []
+	},
+	nequi: {
+		method: "WALLET",
+		paymentMethod: "voucher",
+		processors: ["nequi_push_voucher"]
+	},
+	mercadopago: {
+		method: "WALLET",
+		paymentMethod: "wallet",
+		processors: ["mercadopago_wallet"]
+	},
+	deuna_wallet: {
+		method: "WALLET",
+		paymentMethod: "voucher",
+		processors: ["deuna_wallet"]
+	},
+	pse: {
+		method: "BANK_TRANSFER",
+		paymentMethod: "bank_transfer",
+		processors: ["payu_pse"]
+	}
+};
+const DEUNA_PROCESSOR_KEYS = Object.keys(DEUNA_PROCESSORS);
+/**
+* `start` covers the whole widget session (push approval, bank redirect),
+* so the provider timeout is the longest validity DEUNA documents for a
+* customer step (15 min QR). Dashboard `runtime` still wins.
+*/
+const DEUNA_WIDGET_POLICY = {
+	timeout_ms: 9e5,
+	poll_interval_ms: 3e3,
+	qr_ttl_ms: 18e4
+};
+/** `ctx.storage` key that keeps the DEUNA order token of an attempt. */
+const orderTokenKey = (attemptReference) => {
+	return `deuna:order_token:${attemptReference}`;
+};
+//#endregion
+//#region src/errors.ts
+const source = "docs/payments/deuna/widget.md#11-errores";
+/**
+* DEUNA codes as returned: core API errors, widget/SDK error types and the
+* `DP-` processor codes a wallet or bank payment can hit.
+*/
+const deunaErrors = definePaymentErrors({
+	PAYMENT_DECLINED: {
+		code: "WALLET_REJECTED",
+		source,
+		since: "v2"
+	},
+	PAYMENT_FAILED: {
+		code: "WALLET_REJECTED",
+		source,
+		since: "v2"
+	},
+	PAYMENT_ERROR: {
+		code: "WALLET_REJECTED",
+		source,
+		since: "v2"
+	},
+	INITIALIZATION_FAILED: {
+		code: "PROVIDER_UNAVAILABLE",
+		retryable: true,
+		source,
+		since: "v2"
+	},
+	CARD_EXPIRED: {
+		code: "EXPIRED_CARD",
+		source,
+		since: "v2"
+	},
+	INVALID_REQUEST: {
+		code: "INVALID_REQUEST",
+		source,
+		since: "v2"
+	},
+	AUTHENTICATION_FAILED: {
+		code: "INVALID_CREDENTIALS",
+		source,
+		since: "v2"
+	},
+	RESOURCE_NOT_FOUND: {
+		code: "INVALID_REQUEST",
+		source,
+		since: "v2"
+	},
+	IDEMPOTENCY_CONFLICT: {
+		code: "AMBIGUOUS",
+		source,
+		since: "v2"
+	},
+	RATE_LIMIT_EXCEEDED: {
+		code: "PROVIDER_UNAVAILABLE",
+		retryable: true,
+		source,
+		since: "v2"
+	},
+	PROVIDER_UNAVAILABLE: {
+		code: "PROVIDER_UNAVAILABLE",
+		retryable: true,
+		source,
+		since: "v2"
+	},
+	"DP-4200": {
+		code: "PROVIDER_UNAVAILABLE",
+		retryable: true,
+		source,
+		since: "v2"
+	},
+	"DP-4504": {
+		code: "PROVIDER_UNAVAILABLE",
+		retryable: true,
+		source,
+		since: "v2"
+	},
+	"DP-4507": {
+		code: "INVALID_PIN",
+		source,
+		since: "v2"
+	},
+	"DP-4520": {
+		code: "WALLET_REJECTED",
+		source,
+		since: "v2"
+	},
+	"DP-4562": {
+		code: "WALLET_EXPIRED",
+		source,
+		since: "v2"
+	},
+	"DP-9000": {
+		code: "INSUFFICIENT_FUNDS",
+		source,
+		since: "v2"
+	},
+	"DP-9001": {
+		code: "LIMIT_EXCEEDED",
+		source,
+		since: "v2"
+	},
+	"DP-9999": {
+		code: "UNKNOWN",
+		source,
+		since: "v2"
+	}
+});
+//#endregion
+//#region src/status.ts
+const PAID = [
+	"processed",
+	"authorized",
+	"captured",
+	"partial_captured"
+];
+const PENDING = [
+	"pending",
+	"pending_3ds",
+	"processing",
+	"authorizing",
+	"capturing",
+	"partial_capturing",
+	"manual_review"
+];
+const CANCELLED = [
+	"cancelled",
+	"voiding",
+	"voided"
+];
+const REFUNDED = ["refunding", "refunded"];
+const PARTIALLY_REFUNDED = ["partial_refunding", "partial_refunded"];
+/** Spark code of a rejected payment of `method`. */
+const deunaDeclinedCode = (method) => {
+	return method === "CARD" ? "CARD_DECLINED" : "WALLET_REJECTED";
+};
+/** `payment.data.status` (case-sensitive) to the tender status. */
+const mapDeunaStatus = (status, method) => {
+	if (PAID.includes(status)) return { status: "PAID" };
+	if (PENDING.includes(status)) return { status: "PENDING" };
+	if (CANCELLED.includes(status)) return { status: "CANCELLED" };
+	if (REFUNDED.includes(status)) return { status: "REFUNDED" };
+	if (PARTIALLY_REFUNDED.includes(status)) return { status: "PAID" };
+	const failed = (error) => {
+		return {
+			status: "FAILED",
+			error
+		};
+	};
+	if (status === "denied") return failed(deunaDeclinedCode(method));
+	if (status === "expired") return failed("WALLET_EXPIRED");
+	return failed("AMBIGUOUS");
+};
+const BANK_TRANSFER_DECLINED = "Bank transfer rejected";
+/** Error of a FAILED state: the DEUNA code wins over the status default. */
+const deunaStateError = (input) => {
+	const { method, state, fallback, attempt } = input;
+	const providerError = state.error ?? null;
+	if (providerError?.code) return toPaymentError(deunaErrors, {
+		code: providerError.code,
+		fallback,
+		attempt,
+		message: providerError.message
+	});
+	const extra = {
+		attempt,
+		provider_code: state.status
+	};
+	if (method !== "BANK_TRANSFER" || fallback !== "WALLET_REJECTED") return createPaymentError(fallback, extra);
+	const message = BANK_TRANSFER_DECLINED;
+	return createPaymentError(fallback, {
+		...extra,
+		message
+	});
+};
+//#endregion
+//#region src/adapter.ts
+const record = (value) => {
+	if (!value || typeof value !== "object") return {};
+	return value;
+};
+const fail = (code, message) => {
+	return new PaymentError(createPaymentError(code, { provider_message: message }));
+};
+/** Processors this method can charge with. */
+const deunaProcessorsFor = (method) => {
+	return DEUNA_PROCESSOR_KEYS.filter((key) => {
+		return DEUNA_PROCESSORS[key].method === method;
+	});
+};
+/** `payments.config.processor`; optional when the method has only one. */
+const resolveDeunaProcessor = (method, config) => {
+	const allowed = deunaProcessorsFor(method);
+	const value = config.processor;
+	const known = allowed.find((key) => key === value);
+	if (known) return known;
+	const only = allowed.length === 1 ? allowed[0] : void 0;
+	if (value == null && only) return only;
+	const message = `Unsupported DEUNA processor for ${method}: ${String(value)}`;
+	throw fail("INVALID_REQUEST", message);
+};
+/** `paymentMethods` of `initPaymentWidget` for a processor. */
+const deunaWidgetPaymentMethods = (processor) => {
+	const entry = DEUNA_PROCESSORS[processor];
+	const base = { paymentMethod: entry.paymentMethod };
+	if (!entry.processors.length) return [base];
+	return [{
+		...base,
+		processors: [...entry.processors]
+	}];
+};
+const publicKeyOf = (config) => {
+	const key = config.public_key;
+	if (typeof key === "string" && key.trim()) return key.trim();
+	throw fail("INVALID_CREDENTIALS", "Missing DEUNA public_key");
+};
+/** Card brand and last 4 are not exposed by the widget: no card details. */
+const detailsOf = (charge, reference) => {
+	if (charge.method === "CARD") return null;
+	if (charge.method === "BANK_TRANSFER") return {
+		method: "BANK_TRANSFER",
+		reference
+	};
+	return {
+		method: "WALLET",
+		wallet: charge.processor,
+		reference
+	};
+};
+/** Tender result for a DEUNA order state. */
+const toResult = (ctx, charge, state, base) => {
+	const mapped = mapDeunaStatus(state.status, charge.method);
+	const transactionId = state.transaction_id ?? null;
+	const previous = record(base?.metadata.provider);
+	const p1 = {
+		order_token: state.order_token,
+		processor: charge.processor
+	};
+	const p2 = {
+		status: state.status,
+		transaction_id: transactionId
+	};
+	const provider = {
+		...previous,
+		...p1,
+		...p2
+	};
+	const reference = transactionId ?? state.order_token;
+	const payment = {
+		provider_transaction_id: transactionId,
+		reference
+	};
+	const metadata = {
+		attempt_reference: ctx.attemptReference,
+		payment,
+		provider
+	};
+	const amount = base?.amount ?? ctx.amount.value;
+	const details = detailsOf(charge, reference);
+	if (mapped.status !== "FAILED") return {
+		status: mapped.status,
+		amount,
+		metadata,
+		details
+	};
+	const fallback = mapped.error ?? "UNKNOWN";
+	const error = deunaStateError({
+		method: charge.method,
+		state,
+		fallback,
+		attempt: ctx.attempt
+	});
+	if (fallback === "AMBIGUOUS") metadata.needs_review = true;
+	metadata.error = error;
+	return {
+		status: "FAILED",
+		amount,
+		metadata,
+		error,
+		details
+	};
+};
+const failedResult = (pending, error) => {
+	const metadata = {
+		...pending.metadata,
+		error
+	};
+	return {
+		...pending,
+		status: "FAILED",
+		metadata,
+		error
+	};
+};
+/** Order token of the attempt: result metadata, else the device storage. */
+const orderTokenOf = async (ctx, result) => {
+	const token = record(result.metadata.provider).order_token;
+	if (typeof token === "string" && token) return token;
+	return ctx.storage.get(orderTokenKey(ctx.attemptReference));
+};
+/**
+* DEUNA Payment Widget for every method (card, Nequi, Mercado Pago, Deuna
+* App Wallet, PSE). Spark tokenizes the DEUNA order with the private key
+* (`api.tokenize`), the template opens the widget with the public key, and
+* the order status read back from Spark (`api.order`) is the one that
+* counts. Refunds go through the DEUNA Admin (manual reversal).
+*/
+const deunaWidgetPayments = (options) => {
+	const { method, bridge, api } = options;
+	const language = options.language ?? "es";
+	const chargeOf = (ctx) => {
+		return {
+			method,
+			processor: resolveDeunaProcessor(method, ctx.config)
+		};
+	};
+	const orderState = (ctx, orderToken) => {
+		return api.order({
+			paymentId: ctx.paymentId,
+			orderToken
+		});
+	};
+	/** Spark state after the widget closed; `null` if it can't be read. */
+	const confirmed = async (ctx, charge, pending, orderToken) => {
+		const state = await orderState(ctx, orderToken).catch(() => null);
+		if (!state) return null;
+		return toResult(ctx, charge, state, pending);
+	};
+	const settle = async (ctx, charge, outcome, orderToken) => {
+		const pending = toResult(ctx, charge, {
+			order_token: orderToken,
+			status: "pending"
+		});
+		const attempt = ctx.attempt;
+		if (outcome.type === "pending") return pending;
+		if (outcome.type === "expired") {
+			const error = createPaymentError("WALLET_EXPIRED", { attempt });
+			return failedResult(pending, error);
+		}
+		if (outcome.type === "error") {
+			const raw = {
+				code: outcome.code ?? outcome.errorType ?? null,
+				message: outcome.message ?? null,
+				attempt,
+				fallback: deunaDeclinedCode(charge.method)
+			};
+			return failedResult(pending, toPaymentError(deunaErrors, raw));
+		}
+		const result = await confirmed(ctx, charge, pending, orderToken);
+		if (outcome.type === "success") return result ?? pending;
+		if (result && result.status !== "PENDING") return result;
+		if (outcome.by === "system") return result ?? pending;
+		const error = createPaymentError("CANCELLED_BY_USER", { attempt });
+		return failedResult(result ?? pending, error);
+	};
+	const start = async (ctx) => {
+		const publicApiKey = publicKeyOf(ctx.config);
+		const charge = chargeOf(ctx);
+		const t1 = {
+			paymentId: ctx.paymentId,
+			orderId: ctx.order.id
+		};
+		const t2 = { attemptReference: ctx.attemptReference };
+		const t3 = options.callbackUrls ? { callbackUrls: options.callbackUrls } : {};
+		const orderToken = (await api.tokenize({
+			...t1,
+			...t2,
+			...t3
+		})).order_token;
+		await ctx.storage.set(orderTokenKey(ctx.attemptReference), orderToken);
+		const paymentMethods = deunaWidgetPaymentMethods(charge.processor);
+		const o1 = {
+			publicApiKey,
+			environment: ctx.environment,
+			orderToken
+		};
+		const o2 = {
+			paymentMethods,
+			language,
+			signal: ctx.signal
+		};
+		const outcome = await bridge.open({
+			...o1,
+			...o2
+		});
+		return settle(ctx, charge, outcome, orderToken);
+	};
+	const query = async (ctx, result) => {
+		const orderToken = await orderTokenOf(ctx, result);
+		if (!orderToken) throw fail("AMBIGUOUS", "No DEUNA order for this attempt");
+		const state = await orderState(ctx, orderToken);
+		return toResult(ctx, chargeOf(ctx), state, result);
+	};
+	/** The widget order is left to expire; nothing was charged. */
+	const cancel = async (_ctx, result) => {
+		return {
+			...result,
+			status: "CANCELLED"
+		};
+	};
+	return {
+		provider: DEUNA_PROVIDER,
+		method,
+		errors: deunaErrors,
+		policy: DEUNA_WIDGET_POLICY,
+		start,
+		query,
+		cancel
+	};
+};
+//#endregion
+export { DEUNA_PROCESSORS, DEUNA_PROCESSOR_KEYS, DEUNA_PROVIDER, DEUNA_WIDGET_POLICY, deunaDeclinedCode, deunaErrors, deunaProcessorsFor, deunaStateError, deunaWidgetPaymentMethods, deunaWidgetPayments, mapDeunaStatus, orderTokenKey, resolveDeunaProcessor };

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@fire-spark/payments-deuna-widget",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.11.0",
+  "description": "Fire Spark DEUNA Payment Widget adapter: cards, Nequi, Mercado Pago and Deuna App Wallet, and PSE through the DEUNA checkout",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@fire-spark/payments": "^0.11.0",
+    "@fire-spark/types": "^0.11.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^2.1.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "tsdown": {
+    "entry": [
+      "src/index.ts"
+    ],
+    "format": [
+      "esm"
+    ],
+    "platform": "neutral",
+    "dts": {
+      "tsconfig": "tsconfig.build.json"
+    },
+    "clean": true,
+    "deps": {
+      "neverBundle": [
+        "@fire-spark/payments",
+        "@fire-spark/types"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "check-types": "tsc --noEmit",
+    "test:utils": "vitest run",
+    "lint": "oxlint ./src --max-warnings=0",
+    "format": "oxfmt ./src",
+    "check-format": "oxfmt --check ./src"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.