@delopay/sdk 0.179.0 → 0.181.0

package/dist/index.cjs

@@ -4649,15 +4649,15 @@ var Analytics = class {
   }
   /**
    * Every analytics exclusion of the merchant, with the payments each one
-   * matched in the lookback window (todos#184).
+   * matched in the lookback window.
    *
    * These rules change what the merchant's own dashboards count. Financial
    * records and transaction lists are never filtered by them.
    *
-   * ⚠️ `matched_payments` **overlaps between rules and must not be summed**:
-   * a payment matched by three rules is counted once by each. The envelope's
-   * `best_effort` and `lookback_days` qualify every row — matching runs on
-   * client signals that may be absent or expired, within that window.
+   * `matched_payments` counts overlap between rules: a payment matched by
+   * three rules is counted once by each, so the values are not additive. The
+   * envelope's `best_effort` and `lookback_days` apply to every row — matching
+   * runs on client signals that may be absent or expired, within that window.
    * `GET /analytics/exclusions`
    */
   async listExclusions() {
@@ -7921,7 +7921,7 @@ var DEFAULT_BRANDING_BASE = {
 var DEFAULT_BRANDING = {
   ...DEFAULT_BRANDING_BASE,
   ...LIGHT_PALETTE,
-  // No badges by default since todos#218 — notices took their place.
+  // No badges by default any more — notices took their place.
   // `DEFAULT_BADGES` stays exported because `isDefaultBadgeSet` still has to
   // recognise the pair on shops saved before.
   trustBadges: [],
@@ -9460,6 +9460,18 @@ function withoutHeader(headers, name) {
   }
   return out;
 }
+async function gzipJson(value) {
+  const ctor = globalThis.CompressionStream;
+  if (typeof ctor !== "function") return null;
+  try {
+    const bytes = new TextEncoder().encode(JSON.stringify(value));
+    return await new Response(
+      new Blob([bytes]).stream().pipeThrough(new ctor("gzip"))
+    ).arrayBuffer();
+  } catch {
+    return null;
+  }
+}
 var CheckoutSession = class {
   constructor(options) {
     this.merchantId = options.merchantId;
@@ -9611,18 +9623,38 @@ var CheckoutSession = class {
    * away (a redirect rail); browsers refuse keepalive bodies over ~64 KiB, so
    * only a small final slice should carry it.
    *
+   * Pass `compress: true` to send the slice gzipped. Recorded page events
+   * compress heavily, so this is mostly a saving on the buyer's connection. It
+   * is opt-in and degrades silently: a runtime without `CompressionStream`
+   * sends the same slice uncompressed rather than failing, so a caller never
+   * has to feature-test before asking for it.
+   *
+   * ⚠️ `keepalive` overrides it. Compressing means awaiting a stream read
+   * before the request is made, and `keepalive` protects a request only once
+   * it has been initiated — so a page torn down mid-compression would drop the
+   * final slice altogether. A slice sent with `keepalive` therefore always
+   * travels uncompressed, whatever `compress` says. Passing both is allowed and
+   * is what a recorder should do: every ordinary slice compresses, and the last
+   * one is sent the way that actually arrives.
+   *
    * `POST /payments/{paymentId}/replay/slice` (publishable key)
    */
   async storeReplaySlice(params, options) {
-    const { keepalive, ...extras } = options ?? {};
+    const { keepalive, compress, ...extras } = options ?? {};
+    const body = { ...params, client_secret: this.requireClientSecret() };
+    const headers = this.pkHeaders(extras.headers);
+    const gzipped = compress === true && keepalive !== true ? await gzipJson(body) : null;
     return this.client.request(
       "POST",
       `/payments/${encodeURIComponent(this.paymentId)}/replay/slice`,
       {
-        body: { ...params, client_secret: this.requireClientSecret() },
+        body: gzipped ?? body,
         ...keepalive !== void 0 ? { keepalive } : {},
         ...extras,
-        headers: this.pkHeaders(extras.headers)
+        // `Content-Type` has to be stated for the compressed body: the client
+        // only sets it for a body it serialises itself, and the bytes are
+        // still JSON — gzip is how they travel, not what they are.
+        headers: gzipped === null ? headers : { ...headers, "Content-Type": "application/json", "Content-Encoding": "gzip" }
       }
     );
   }