@agent-cards/sdk 0.23.23 → 0.23.25

package/dist/openpay.generated.js

@@ -0,0 +1,446 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: 9664676e236436f6a52fd0f968ffa6e403c52ee156408ab9a428cc5fd749175b
+// src/openpay.js
+var OPENPAY_PSP = "openpay_bbva";
+var OPENPAY_CAPABILITY = "openpay_tokenizer";
+var OPENPAY_OPERATION = "openpay_bbva.card_request";
+var OPENPAY_API_HOSTS = /* @__PURE__ */ Object.freeze({
+    "api.openpay.mx": "production",
+    "api.openpay.co": "production",
+    "api.openpay.pe": "production",
+    "sandbox-api.openpay.mx": "sandbox",
+    "sandbox-api.openpay.co": "sandbox",
+    "sandbox-api.openpay.pe": "sandbox"
+});
+var OPENPAY_CARD_KEYS = /* @__PURE__ */ Object.freeze(["card_number", "holder_name", "cvv2", "expiration_month", "expiration_year", "address"]);
+var OPENPAY_ADDRESS_KEYS = /* @__PURE__ */ Object.freeze(["line1", "line2", "line3", "state", "city", "postal_code", "country_code"]);
+var OPENPAY_PREPARATION_URLS = /* @__PURE__ */ Object.freeze({
+    production: "https://api.openpay.mx/v1/prepared/tokens",
+    sandbox: "https://sandbox-api.openpay.mx/v1/prepared/tokens"
+});
+var OPENPAY_REFUSAL_CODES = /* @__PURE__ */ Object.freeze([
+    "openpay_url_refused",
+    "openpay_headers_refused",
+    "openpay_body_unsupported",
+    "openpay_merchant_unreviewed",
+    "openpay_account_unreviewed",
+    "openpay_live_row_required"
+]);
+var BODY_LIMIT = 4096;
+var URL_LIMIT = 96;
+var TOKEN_URL = /^https:\/\/((?:sandbox-)?api\.openpay\.(?:mx|co|pe))\/v1\/([a-z0-9]{10,40})\/tokens$/;
+var PUBLIC_KEY = /^pk_[a-z0-9]{16,64}$/;
+var BASIC = /^Basic ([A-Za-z0-9+/]{4,128}={0,2})$/;
+var JSON_TYPE = /^application\/json(?:; ?charset=utf-8)?$/i;
+var ACCEPT = "application/json";
+var NUMBER = /^[0-9]{12,19}$/;
+var SECURITY_CODE = /^[0-9]{3,4}$/;
+var MONTH_TEXT = /^(?:0?[1-9]|1[0-2])$/;
+var YEAR = /^[0-9]{2}$/;
+var COUNTRY = /^[A-Z]{2}$/;
+var LETTERS = "A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u017F";
+var PAGE_NAME = new RegExp(`^[${LETTERS} .'-]{1,64}$`);
+var HAS_LETTER = new RegExp(`[${LETTERS}]`);
+var ADDRESS_VALUE = new RegExp(`^[\\x20-\\x7e\\u00a0-\\u017f]{0,128}$`);
+var PAN_LIKE = new RegExp(`(?:[0-9][^0-9${LETTERS}]*){12,}`);
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+var refuse = (code) => Object.freeze({ verdict: "refuse", code });
+var CARD = /* @__PURE__ */ Object.freeze({ verdict: "card" });
+function openpayTokenTarget(url) {
+    if (typeof url !== "string" || url.length > URL_LIMIT)
+        return null;
+    const match = TOKEN_URL.exec(url);
+    if (!match)
+        return null;
+    return Object.freeze({ environment: OPENPAY_API_HOSTS[match[1]], host: match[1], merchantId: match[2] });
+}
+function isOpenpayTokenUrl(url) {
+    return openpayTokenTarget(url) !== null;
+}
+function openpayTokenEnvironment(url) {
+    const target = openpayTokenTarget(url);
+    return target === null ? null : target.environment;
+}
+function readJson(body) {
+    if (typeof body !== "string" || body === "" || body.length > BODY_LIMIT)
+        return null;
+    try {
+        const value = JSON.parse(body);
+        return record(value) && JSON.stringify(value) === body ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+var soundMonth = (value) => Number.isInteger(value) && value >= 1 && value <= 12 || typeof value === "string" && MONTH_TEXT.test(value);
+function soundAddress(address) {
+    if (!record(address))
+        return false;
+    const keys = Object.keys(address);
+    return keys.length > 0 && keys.every((key) => OPENPAY_ADDRESS_KEYS.includes(key) && typeof address[key] === "string" && ADDRESS_VALUE.test(address[key]) && !PAN_LIKE.test(address[key])) && keys.some((key) => address[key] !== "") && (!hasOwn(address, "country_code") || COUNTRY.test(address.country_code));
+}
+function openpayBodyVerdict(body, url) {
+    if (url !== void 0 && openpayTokenTarget(url) === null)
+        return refuse("openpay_url_refused");
+    const value = readJson(body);
+    if (value === null)
+        return refuse("openpay_body_unsupported");
+    const keys = Object.keys(value);
+    if (!keys.every((key) => OPENPAY_CARD_KEYS.includes(key)) || !["card_number", "holder_name", "cvv2", "expiration_month", "expiration_year"].every((key) => keys.includes(key))) {
+        return refuse("openpay_body_unsupported");
+    }
+    if (typeof value.card_number !== "string" || !NUMBER.test(value.card_number) || typeof value.cvv2 !== "string" || !SECURITY_CODE.test(value.cvv2) || !soundMonth(value.expiration_month) || typeof value.expiration_year !== "string" || !YEAR.test(value.expiration_year) || typeof value.holder_name !== "string" || !PAGE_NAME.test(value.holder_name) || !HAS_LETTER.test(value.holder_name) || keys.includes("address") && !soundAddress(value.address)) {
+        return refuse("openpay_body_unsupported");
+    }
+    return CARD;
+}
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64Text(input) {
+    if (input.length % 4 !== 0)
+        return null;
+    const stripped = input.replace(/={1,2}$/, "");
+    if (stripped.includes("="))
+        return null;
+    let out = "";
+    let bits = 0;
+    let value = 0;
+    for (const character of stripped) {
+        const sextet = BASE64.indexOf(character);
+        if (sextet < 0)
+            return null;
+        value = value << 6 | sextet;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out += String.fromCharCode(value >> bits & 255);
+            value &= (1 << bits) - 1;
+        }
+    }
+    return out;
+}
+function base64Of(text) {
+    let out = "";
+    for (let at = 0; at < text.length; at += 3) {
+        const a = text.charCodeAt(at);
+        const b = at + 1 < text.length ? text.charCodeAt(at + 1) : NaN;
+        const c = at + 2 < text.length ? text.charCodeAt(at + 2) : NaN;
+        out += BASE64[a >> 2] + BASE64[(a & 3) << 4 | (Number.isNaN(b) ? 0 : b >> 4)] + (Number.isNaN(b) ? "=" : BASE64[(b & 15) << 2 | (Number.isNaN(c) ? 0 : c >> 6)]) + (Number.isNaN(c) ? "=" : BASE64[c & 63]);
+    }
+    return out;
+}
+function headerMap(headers) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(record(headers) ? headers : {})) {
+        const lower = name.toLowerCase();
+        if (out.has(lower) || typeof value !== "string")
+            return null;
+        out.set(lower, value);
+    }
+    return out;
+}
+function openpayPublicKey(headers) {
+    const map = headerMap(headers);
+    const auth = map === null ? null : BASIC.exec(map.get("authorization") ?? "");
+    const text = auth ? base64Text(auth[1]) : null;
+    if (text === null || !text.endsWith(":"))
+        return null;
+    const key = text.slice(0, -1);
+    return PUBLIC_KEY.test(key) && base64Of(text) === auth[1] ? key : null;
+}
+function openpayRequestRefusal(request) {
+    if (!record(request) || request.method !== "POST" || openpayTokenTarget(request.url) === null)
+        return "openpay_url_refused";
+    const map = headerMap(request.headers);
+    if (map === null || !JSON_TYPE.test(map.get("content-type") ?? "") || map.get("accept") !== ACCEPT || openpayPublicKey(request.headers) === null)
+        return "openpay_headers_refused";
+    const verdict = openpayBodyVerdict(request.body, request.url);
+    return verdict.verdict === "card" ? null : verdict.code;
+}
+function isPreparedOpenpayRequest(url, method, body, environment, headers) {
+    return (environment === "production" || environment === "sandbox") && openpayTokenEnvironment(url) === environment && openpayRequestRefusal({ url, method, headers, body }) === null;
+}
+var ACCOUNT_UNREVIEWED = "Refusing to pay: this Openpay payment goes to a merchant account Agentcard has not reviewed. Nothing was sent.";
+var REFUSAL_MESSAGES = /* @__PURE__ */ Object.freeze({
+    openpay_url_refused: "Refusing to pay: this Openpay card request does not go to Openpay's token address exactly as openpay.js sends it. Nothing was sent.",
+    openpay_headers_refused: "Refusing to pay: this Openpay card request does not carry the headers openpay.js sends. Nothing was sent.",
+    openpay_body_unsupported: "Refusing to pay: this is not the card request of openpay.js. Nothing was sent.",
+    openpay_merchant_unreviewed: ACCOUNT_UNREVIEWED,
+    openpay_account_unreviewed: ACCOUNT_UNREVIEWED,
+    openpay_live_row_required: "Refusing to pay: Agentcard sends a card to a live Openpay checkout only for a live purchase, and this one is not live. Nothing was sent."
+});
+function openpayRefusalMessage(code) {
+    return hasOwn(REFUSAL_MESSAGES, code) ? REFUSAL_MESSAGES[code] : REFUSAL_MESSAGES.openpay_body_unsupported;
+}
+var PIN_ORIGIN = /^https:\/\/([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+)$/;
+var OPENPAY_DOMAIN = /(?:^|\.)openpay\.(?:mx|co|pe)$/;
+var MERCHANT_ID = /^[a-z0-9]{10,40}$/;
+function openpayPinOriginUsable(origin) {
+    const host = typeof origin === "string" ? PIN_ORIGIN.exec(origin) : null;
+    return !!host && !OPENPAY_DOMAIN.test(host[1]);
+}
+var pin = (fields) => Object.freeze({ ...fields, origins: Object.freeze([...fields.origins]), publicKeys: Object.freeze([...fields.publicKeys]) });
+var OPENPAY_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
+    pin({
+        id: "diario_de_yucatan",
+        merchant: "Diario de Yucatán",
+        origins: ["https://www.yucatan.com.mx"],
+        host: "api.openpay.mx",
+        merchantId: "mqyloyrm8tsvtsgcrj0d",
+        publicKeys: ["pk_260aa43616a445bb98472e6ca51da968"]
+    })
+]);
+var usablePin = (entry) => record(entry) && Array.isArray(entry.origins) && entry.origins.length > 0 && entry.origins.every(openpayPinOriginUsable) && OPENPAY_API_HOSTS[entry.host] === "production" && typeof entry.merchantId === "string" && MERCHANT_ID.test(entry.merchantId) && Array.isArray(entry.publicKeys) && entry.publicKeys.length > 0 && entry.publicKeys.every((key) => typeof key === "string" && PUBLIC_KEY.test(key));
+function openpayOriginPin(merchantOrigin, pins = OPENPAY_MERCHANT_PINS) {
+    if (typeof merchantOrigin !== "string" || !Array.isArray(pins) || !openpayPinOriginUsable(merchantOrigin))
+        return null;
+    const found = pins.filter((entry) => usablePin(entry) && entry.origins.includes(merchantOrigin));
+    return found.length === 1 ? found[0] : null;
+}
+function openpayPreparationRefusal(environment, merchantOrigin, pins = OPENPAY_MERCHANT_PINS) {
+    if (environment === "sandbox")
+        return null;
+    if (environment !== "production")
+        return "unsupported_environment";
+    return openpayOriginPin(merchantOrigin, pins) ? null : "openpay_merchant_unreviewed";
+}
+function openpayMerchantPin(merchantOrigin, request, pins = OPENPAY_MERCHANT_PINS) {
+    const target = record(request) ? openpayTokenTarget(request.url) : null;
+    if (target === null || target.environment !== "production")
+        return null;
+    const found = openpayOriginPin(merchantOrigin, pins);
+    return found && found.host === target.host && found.merchantId === target.merchantId && found.publicKeys.includes(openpayPublicKey(request.headers)) ? found : null;
+}
+function openpayMerchantRefusal(merchantOrigin, request, pins = OPENPAY_MERCHANT_PINS) {
+    const target = record(request) ? openpayTokenTarget(request.url) : null;
+    if (target === null)
+        return "openpay_url_refused";
+    if (target.environment === "sandbox")
+        return null;
+    if (openpayOriginPin(merchantOrigin, pins) === null)
+        return "openpay_merchant_unreviewed";
+    return openpayMerchantPin(merchantOrigin, request, pins) ? null : "openpay_account_unreviewed";
+}
+function openpayDeviceRefusal(request, options) {
+    const refusal = openpayRequestRefusal(request);
+    if (refusal)
+        return refusal;
+    if (openpayTokenEnvironment(request.url) === "sandbox")
+        return null;
+    const settings = record(options) ? options : {};
+    if (typeof settings.merchantOrigin !== "string")
+        return "openpay_merchant_unreviewed";
+    if (settings.sandbox !== false)
+        return "openpay_live_row_required";
+    return openpayMerchantRefusal(settings.merchantOrigin, request);
+}
+var OPENPAY_TEST_PANS = /* @__PURE__ */ Object.freeze([
+    "4111111111111111",
+    "5555555555554444",
+    "5105105105105100",
+    "345678000000007",
+    "341111111111111",
+    "343434343434343",
+    "5062541600005232",
+    "5064050100000063",
+    "5064510000300020",
+    "4222222222222220",
+    "4000000000000069",
+    "4444444444444448",
+    "4000000000000119",
+    "4000000000000044",
+    "5454545454545454",
+    "340000000000009",
+    "373737373737374",
+    "370000000000002"
+]);
+var digits = (value, min, max) => typeof value === "string" && value.length >= min && value.length <= max && !/[^0-9]/.test(value);
+var whole = (value, min, max) => {
+    if (Number.isSafeInteger(value) && value >= 0)
+        return value;
+    return digits(value, min, max) ? Number(value) : NaN;
+};
+var cardYear = (year) => year >= 0 && year <= 99 || year >= 2e3 && year <= 2099;
+var AMEX = /^3[47]/;
+var FILL_REFUSAL = "Could not fill the card fields for Openpay. Nothing was sent.";
+var WHERE = /* @__PURE__ */ Object.freeze(["card_number", "cvv2", "expiration_month", "expiration_year"]);
+function written(page, card) {
+    const value = JSON.parse(page);
+    value.card_number = card.number;
+    value.cvv2 = card.cvc;
+    value.expiration_month = typeof value.expiration_month === "number" ? card.month : value.expiration_month.length === 2 ? String(card.month).padStart(2, "0") : String(card.month);
+    value.expiration_year = String(card.year % 100).padStart(2, "0");
+    return JSON.stringify(value);
+}
+function fillCard(card) {
+    if (!card || typeof card !== "object")
+        return null;
+    const month = whole(card.month, 1, 2);
+    const year = whole(card.year, 2, 4);
+    const amex = typeof card.number === "string" && AMEX.test(card.number);
+    if (!digits(card.number, 12, 19) || !(month >= 1 && month <= 12) || !cardYear(year) || !digits(card.cvc, amex ? 4 : 3, amex ? 4 : 3))
+        return null;
+    return { number: card.number, cvc: card.cvc, month, year };
+}
+function injectOpenpayCard(body, card) {
+    const verdict = openpayBodyVerdict(body);
+    if (verdict.verdict !== "card")
+        throw new Error(openpayRefusalMessage(verdict.code));
+    const values = fillCard(card);
+    if (!values)
+        throw new Error(FILL_REFUSAL);
+    return { body: written(body, values), where: [...WHERE] };
+}
+function isOpenpayDeviceRequest(templateBody, deviceBody) {
+    if (openpayBodyVerdict(templateBody).verdict !== "card" || openpayBodyVerdict(deviceBody).verdict !== "card")
+        return false;
+    const template = JSON.parse(templateBody);
+    const device = JSON.parse(deviceBody);
+    if (device.card_number === template.card_number || typeof device.expiration_month !== typeof template.expiration_month)
+        return false;
+    const values = fillCard({ number: device.card_number, cvc: device.cvv2, month: device.expiration_month, year: device.expiration_year });
+    return values !== null && written(templateBody, values) === deviceBody;
+}
+var ANSWER_LIMIT = 16384;
+var TOKEN_ID = /^[a-z0-9]{16,32}$/;
+var MASKED = /^([0-9]{6})X{2,9}([0-9]{4})$/;
+var BRAND = /^[a-z][a-z_ ]{1,31}$/;
+var ERROR_CODE = /^[1-9][0-9]{3}$/;
+var SERVER_FAILURES = /* @__PURE__ */ Object.freeze(["1000", "1004", "1015", "1017"]);
+function parseAnswer(text) {
+    if (typeof text !== "string" || text === "" || text.length > ANSWER_LIMIT)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return record(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function errorCodeOf(value) {
+    const code = value.error_code;
+    const text = Number.isInteger(code) ? String(code) : typeof code === "string" ? code : null;
+    return text !== null && ERROR_CODE.test(text) ? text : null;
+}
+function isOpenpayRefusalCode(code) {
+    if (typeof code !== "string" || !code.startsWith("openpay_"))
+        return false;
+    const digits2 = code.slice("openpay_".length);
+    return ERROR_CODE.test(digits2) && !SERVER_FAILURES.includes(digits2);
+}
+function readAnswer(status, text) {
+    if (!Number.isInteger(status))
+        return { kind: "unknown", reason: "openpay_unconfirmed" };
+    if (status >= 500)
+        return { kind: "unknown", reason: "server_error" };
+    const value = parseAnswer(text);
+    if (value === null)
+        return { kind: "unknown", reason: "openpay_answer_unreadable" };
+    const code = errorCodeOf(value);
+    const ok = status === 200 || status === 201;
+    const noToken = typeof value.id !== "string" || !TOKEN_ID.test(value.id);
+    if (code !== null && (status >= 400 && status < 500 || ok && noToken)) {
+        return SERVER_FAILURES.includes(code) ? { kind: "unknown", reason: "server_error" } : { kind: "refused", code: `openpay_${code}`, value };
+    }
+    if (!ok)
+        return { kind: "unknown", reason: "openpay_answer_status" };
+    if (code !== null || typeof value.id !== "string" || !TOKEN_ID.test(value.id) || !record(value.card) || typeof value.card.card_number !== "string" || !MASKED.test(value.card.card_number) || value.card.brand !== void 0 && value.card.brand !== null && (typeof value.card.brand !== "string" || !BRAND.test(value.card.brand))) {
+        return { kind: "unknown", reason: "openpay_token_unconfirmed" };
+    }
+    return { kind: "token", token: value, value };
+}
+function cardDigits(card) {
+    const number = card && typeof card.number === "string" ? card.number.replace(/[^0-9]/g, "") : "";
+    return /^[0-9]{12,19}$/.test(number) ? number : "";
+}
+function unescapePercent(value) {
+    let out = value;
+    for (let round = 0; round < 3 && /%[0-9A-Fa-f]{2}/.test(out); round += 1) {
+        out = out.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    }
+    return out;
+}
+function decodedTexts(value) {
+    const texts = [];
+    const walk = (node, depth) => {
+        if (depth > 16 || texts.length > 4096)
+            return;
+        if (typeof node === "string")
+            texts.push(node);
+        else if (typeof node === "number")
+            texts.push(String(node));
+        else if (Array.isArray(node))
+            for (const item of node)
+                walk(item, depth + 1);
+        else if (record(node)) {
+            for (const [key, item] of Object.entries(node)) {
+                texts.push(key);
+                walk(item, depth + 1);
+            }
+        }
+    };
+    walk(value, 0);
+    return texts;
+}
+function holdsCardNumber(value, number) {
+    if (number === "")
+        return false;
+    const spaced = new RegExp(number.split("").join("[^0-9]{0,3}"));
+    const json = JSON.stringify(value);
+    if (spaced.test(json) || spaced.test(unescapePercent(json)))
+        return true;
+    return decodedTexts(value).some((text) => [text, unescapePercent(text)].some((form) => form.replace(/[^0-9]/g, "").includes(number)));
+}
+function numberNetwork(number) {
+    const two = Number(number.slice(0, 2));
+    const four = Number(number.slice(0, 4));
+    if (number.startsWith("4"))
+        return "visa";
+    if (two >= 51 && two <= 55 || four >= 2221 && four <= 2720)
+        return "mastercard";
+    return two === 34 || two === 37 ? "american_express" : null;
+}
+var brandNetwork = (brand) => {
+    const name = typeof brand === "string" ? brand.toLowerCase().replace(/[^a-z]/g, "") : "";
+    if (name === "visa")
+        return "visa";
+    if (name === "mastercard")
+        return "mastercard";
+    return name === "americanexpress" || name === "amex" ? "american_express" : null;
+};
+var rebuild = (token) => JSON.stringify({ id: token.id, card: {
+        card_number: token.card.card_number,
+        ...typeof token.card.brand === "string" ? { brand: token.card.brand } : {},
+        ...typeof token.card.points_card === "boolean" ? { points_card: token.card.points_card } : {}
+    } });
+function openpayAnswerOutcome(status, text, card) {
+    const read = readAnswer(status, text);
+    if (read.kind === "unknown")
+        return { outcome: "unknown", reason: read.reason };
+    const number = cardDigits(card);
+    if (holdsCardNumber(read.value, number))
+        return { outcome: "unknown", reason: "openpay_unsafe_response" };
+    if (read.kind === "refused")
+        return { outcome: "refused", code: read.code };
+    if (number !== "") {
+        const masked = MASKED.exec(read.token.card.card_number);
+        const brand = brandNetwork(read.token.card.brand);
+        const network = numberNetwork(number);
+        if (masked[1] !== number.slice(0, 6) || masked[2] !== number.slice(-4) || masked[0].length !== number.length || brand !== null && network !== null && brand !== network) {
+            return { outcome: "unknown", reason: "openpay_token_mismatch" };
+        }
+    }
+    return { outcome: "approved", body: rebuild(read.token) };
+}
+function openpayRefusalCode(text, status) {
+    if (status !== void 0 && status !== null) {
+        const read = readAnswer(status, text);
+        return read.kind === "refused" ? read.code : null;
+    }
+    const value = parseAnswer(text);
+    const code = value === null ? null : errorCodeOf(value);
+    return code === null || SERVER_FAILURES.includes(code) ? null : `openpay_${code}`;
+}
+export { OPENPAY_ADDRESS_KEYS, OPENPAY_API_HOSTS, OPENPAY_CAPABILITY, OPENPAY_CARD_KEYS, OPENPAY_MERCHANT_PINS, OPENPAY_OPERATION, OPENPAY_PREPARATION_URLS, OPENPAY_PSP, OPENPAY_REFUSAL_CODES, OPENPAY_TEST_PANS, injectOpenpayCard, isOpenpayDeviceRequest, isOpenpayRefusalCode, isOpenpayTokenUrl, isPreparedOpenpayRequest, openpayAnswerOutcome, openpayBodyVerdict, openpayDeviceRefusal, openpayMerchantPin, openpayMerchantRefusal, openpayOriginPin, openpayPinOriginUsable, openpayPreparationRefusal, openpayPublicKey, openpayRefusalCode, openpayRefusalMessage, openpayRequestRefusal, openpayTokenEnvironment, openpayTokenTarget };

package/dist/paddle-checkout-watch.d.ts

@@ -0,0 +1,70 @@
+/** One recorded answer, as the create sends it: the request's method and URL, the status, when it finished, and its projection. */
+export interface PaddleCheckoutAnswer {
+    method: string;
+    url: string;
+    status: number;
+    completedAt: number;
+    body: string;
+}
+/** What a TokenEx pause hands the client: when the /pay paused, and the answers recorded before it, newest last. */
+export interface PaddleCheckoutCapture {
+    pausedAt: number;
+    answers: PaddleCheckoutAnswer[];
+}
+/** How long a /pay's pause waits for the texts of Paddle's answers that finished before it. */
+export declare const PADDLE_CHECKOUT_READ_WAIT_MS = 1000;
+export declare class PaddleCheckoutWatch {
+    private readonly exchanges;
+    /** Each checkout's request keys, oldest sent first; the checkout asked about least recently first. */
+    private readonly checkouts;
+    /** Each checkout's dropped answers, by `${environment}:${checkoutId}`. */
+    private readonly lost;
+    /**
+     * By environment, the latest finish of a create dropped after it finished and before its text was read: it may have
+     * been any checkout's on that host, and a create is its checkout's oldest answer.
+     */
+    private readonly lostCreateFinishedAt;
+    private readonly waiters;
+    private readonly now;
+    private readonly readWaitMs;
+    constructor(options?: {
+        now?: () => number;
+        readWaitMs?: number;
+    });
+    /** Whether the request under `key` is one of Paddle's checkout answers whose text is still to be read. */
+    tracks(key: string): boolean;
+    /** A request left the page: kept when it asks Paddle's checkout service about the checkout. */
+    sent(key: string, request: {
+        method: string;
+        url: string;
+    }): void;
+    /** Drops a kept request, noting what it was about (forget). */
+    private drop;
+    /** Takes a kept request out without a trace, and hands it back. */
+    private remove;
+    /** Notes what a dropped answer was about, so a pause on its checkout knows what it can no longer see. */
+    private forget;
+    /** Its answer's status arrived. */
+    answered(key: string, status: unknown): void;
+    /** It finished loading: stamped the moment the browser says so, before its text is read, so a pause waits for that read. */
+    finished(key: string, completedAt: number): void;
+    /**
+     * Its text was read (`text`, or null when it could not be). Kept cut to the terms; a body that is not a checkout
+     * answer, or whose projection is longer than the API takes, is kept as an empty one, so the reader knows a newer
+     * answer it cannot read came in.
+     */
+    read(key: string, text: string | null, completedAt: number): void;
+    /**
+     * The request failed or was given up. One that never finished gave the page no answer and is forgotten; one that
+     * finished gave the page an answer this watch could not read, and is kept as one that cannot be read.
+     */
+    failed(key: string): void;
+    private settle;
+    /**
+     * The answers for a Billing /pay paused at `pausedAt`, newest last, or undefined when there are none to send: the
+     * card request is not a Billing /pay, nothing was recorded for its checkout, or the terms as of the pause are not
+     * known (see the header). Waits, up to the read bound or until `signal` aborts, for the texts of the checkout's
+     * answers that finished before the pause.
+     */
+    capture(pausedAt: number, cardUrl: string, signal?: AbortSignal): Promise<PaddleCheckoutCapture | undefined>;
+}