@delopay/sdk 0.180.0 → 0.182.0

package/dist/index.cjs

@@ -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" }
       }
     );
   }