@leadping/consent 1.0.3 → 1.0.5

package/dist/leadping-consent.js

@@ -22,9 +22,14 @@ var LeadpingConsent = (() => {
   var embed_exports = {};
   __export(embed_exports, {
     ConsentCapture: () => ConsentCapture,
+    ReplayLimitExceededError: () => ReplayLimitExceededError,
     attach: () => attach
   });
 
+  // src/capture-rejected-error.ts
+  var CaptureRejectedError = class extends Error {
+  };
+
   // node_modules/rrweb/dist/rrweb.js
   var __defProp2 = Object.defineProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -12759,7 +12764,7 @@ var LeadpingConsent = (() => {
     }
     seal() {
       if (this.events.length === 0) return;
-      if (this.nextBatch >= 256) throw new Error("Recording exceeded the session batch limit.");
+      if (this.nextBatch >= 1024) throw new Error("Recording exceeded the session batch limit.");
       const first = this.nextEvent - this.events.length;
       const body = `{"firstEventNumber":${first},"events":[${this.events.join(",")}]}`;
       this.events.length = 0;
@@ -12768,8 +12773,13 @@ var LeadpingConsent = (() => {
     }
   };
 
-  // src/capture-rejected-error.ts
-  var CaptureRejectedError = class extends Error {
+  // src/replay-limit-exceeded-error.ts
+  var ReplayLimitExceededError = class extends Error {
+    code = "replay_limit_exceeded";
+    constructor() {
+      super("The recording time limit was reached. This submission wasn't captured. Start a new recording and submit again.");
+      this.name = "ReplayLimitExceededError";
+    }
   };
 
   // src/transport.ts
@@ -12802,10 +12812,11 @@ var LeadpingConsent = (() => {
             signal: AbortSignal.any([this.abort.signal, AbortSignal.timeout(15e3)])
           });
           if (response.ok) return;
+          if (response.status === 410) throw new ReplayLimitExceededError();
           if (response.status < 500 && response.status !== 408 && response.status !== 429)
             throw new CaptureRejectedError(`Capture rejected (${response.status}).`);
         } catch (error) {
-          if (error instanceof CaptureRejectedError || this.abort.signal.aborted) throw error;
+          if (error instanceof CaptureRejectedError || error instanceof ReplayLimitExceededError || this.abort.signal.aborted) throw error;
         }
         if (attempt === 4) break;
         await this.delay(Math.min(8e3, 500 * 2 ** attempt) + Math.random() * 250);
@@ -12831,6 +12842,32 @@ var LeadpingConsent = (() => {
     }
   };
 
+  // src/replay-deadline.ts
+  var ReplayDeadline = class {
+    startedAt = Date.now();
+    startedTick = performance.now();
+    expiresAt = Infinity;
+    maximumMs = 18e5;
+    configure(expiresAt, maxReplaySeconds) {
+      const deadline = Date.parse(expiresAt);
+      if (!Number.isFinite(deadline) || !Number.isInteger(maxReplaySeconds) || maxReplaySeconds < 1 || maxReplaySeconds > 1800)
+        throw new Error("Invalid recording time limit.");
+      this.expiresAt = deadline;
+      this.maximumMs = maxReplaySeconds * 1e3;
+      this.assertWithinLimit();
+    }
+    get remainingMilliseconds() {
+      return Math.min(
+        this.expiresAt - Date.now(),
+        this.maximumMs - (Date.now() - this.startedAt),
+        this.maximumMs - (performance.now() - this.startedTick)
+      );
+    }
+    assertWithinLimit() {
+      if (this.remainingMilliseconds <= 0) throw new ReplayLimitExceededError();
+    }
+  };
+
   // src/capture.ts
   var ConsentCapture = class _ConsentCapture {
     constructor(options) {
@@ -12839,12 +12876,19 @@ var LeadpingConsent = (() => {
       const url = new URL(options.apiUrl);
       if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash)
         throw new Error("Capture API requires an HTTPS URL without credentials.");
-      if (!/^[0-9a-f-]{36}$/i.test(options.session.sessionId) || options.session.form.origin !== location.origin || !options.form.contains(options.checkbox) || !options.form.contains(options.disclosure) || options.checkbox.type !== "checkbox" || options.checkbox.checked || options.checkbox.defaultChecked || options.disclosure.textContent !== options.session.form.disclosure)
-        throw new Error("Form does not match the approved disclosure and unchecked consent control.");
-      const remaining = Date.parse(options.session.expiresAt) - Date.now();
-      if (!Number.isFinite(remaining) || remaining <= 0 || remaining > 60 * 60 * 1e3)
-        throw new Error("Invalid or expired capture session.");
-      this.transport = new CaptureTransport(url.href.replace(/\/$/, "") + "/consent/sessions/" + options.session.sessionId, options.session.uploadToken);
+      if (!options.form.contains(options.checkbox) || !options.form.contains(options.disclosure) || options.checkbox.type !== "checkbox" || options.checkbox.checked || options.checkbox.defaultChecked)
+        throw new Error("Form requires an unchecked consent control and disclosure.");
+      this.observedDisclosure = options.disclosure.textContent ?? "";
+      this.ready = Promise.resolve().then(() => typeof options.session === "function" ? options.session() : options.session).then((session) => {
+        if (this.disposed || this.failure) throw this.failure ?? new Error("Recorder is disposed.");
+        if (!/^[0-9a-f-]{36}$/i.test(session.sessionId) || session.form.origin !== location.origin || session.form.disclosure !== this.observedDisclosure)
+          throw new Error("Form does not match the approved disclosure.");
+        this.deadline.configure(session.expiresAt, session.maxReplaySeconds);
+        this.session = session;
+        this.transport = new CaptureTransport(url.href.replace(/\/$/, "") + "/consent/sessions/" + session.sessionId, session.uploadToken);
+        if (!this.stopped) this.expiry = setTimeout(() => this.fail(new ReplayLimitExceededError()), this.deadline.remainingMilliseconds);
+      });
+      void this.ready.then(this.backgroundFlush).catch((error) => this.fail(error));
       _ConsentCapture.active = this;
       try {
         this.stopRecording = record({
@@ -12871,10 +12915,9 @@ var LeadpingConsent = (() => {
         options.checkbox.addEventListener("change", this.consentChanged);
         document.addEventListener("visibilitychange", this.visibilityChanged);
         this.interval = setInterval(this.backgroundFlush, 3e3);
-        this.expiry = setTimeout(() => this.fail(new Error("Capture session expired.")), remaining);
-        record.addCustomEvent("leadping.disclosure", { formId: options.session.form.id });
+        record.addCustomEvent("leadping.disclosure", { disclosure: this.observedDisclosure });
       } catch (error) {
-        this.stop();
+        this.dispose();
         throw error;
       }
     }
@@ -12893,7 +12936,21 @@ var LeadpingConsent = (() => {
       maxTouchPoints: navigator.maxTouchPoints
     };
     buffer = new EventBuffer();
+    deadline = new ReplayDeadline();
     transport;
+    /** Resolves when the service session is available and validated. Recording starts before this. */
+    ready;
+    /** Allocated as soon as the session is ready; this does not assert that submission is saved. */
+    get sessionId() {
+      return this.session?.sessionId;
+    }
+    /** The server-selected duration limit, available after ready resolves. */
+    get maxReplaySeconds() {
+      return this.session?.maxReplaySeconds;
+    }
+    session;
+    observedDisclosure;
+    disposed = false;
     pending = [];
     head = 0;
     queuedBytes = 0;
@@ -12912,6 +12969,8 @@ var LeadpingConsent = (() => {
     async flush() {
       if (this.failure) throw this.failure;
       this.seal();
+      await this.ready;
+      if (this.failure || this.disposed) throw this.failure ?? new Error("Recorder is disposed.");
       while (this.head < this.pending.length || this.sending) {
         this.sending ??= this.send();
         await this.sending;
@@ -12919,19 +12978,29 @@ var LeadpingConsent = (() => {
       if (this.failure) throw this.failure;
     }
     dispose() {
+      this.disposed = true;
       this.stop();
-      this.transport.dispose();
+      this.transport?.dispose();
     }
     async finishCore(recipient) {
       if (this.stopped || this.failure) throw this.failure ?? new Error("Recorder is stopped.");
+      try {
+        this.deadline.assertWithinLimit();
+      } catch (error) {
+        this.fail(error);
+        throw error;
+      }
       const observedDisclosure = this.options.disclosure.textContent ?? "";
-      if (observedDisclosure !== this.options.session.form.disclosure)
+      if (observedDisclosure !== this.observedDisclosure)
         throw new Error("The disclosure changed during capture. Start a new approved form session.");
       const accepted = this.options.checkbox.checked;
       record.addCustomEvent("leadping.submit", { accepted });
       this.stop();
+      this.options.onProgress?.("uploading");
       await this.flush();
-      await this.transport.put("/submission", JSON.stringify({
+      this.deadline.assertWithinLimit();
+      this.options.onProgress?.("submitting");
+      await this.transport.put(this.options.issueCertificate ? "/submission/certificate" : "/submission", JSON.stringify({
         lastBatchNumber: this.buffer.lastBatchNumber,
         lastEventNumber: this.buffer.lastEventNumber,
         accepted,
@@ -12939,7 +13008,7 @@ var LeadpingConsent = (() => {
         recipient,
         browser: this.browser
       }));
-      return { sessionId: this.options.session.sessionId, uploadToken: this.options.session.uploadToken };
+      return { sessionId: this.session.sessionId, uploadToken: this.session.uploadToken };
     }
     emit = (event) => {
       if (this.stopped || this.failure) return;
@@ -12963,25 +13032,31 @@ var LeadpingConsent = (() => {
     async send() {
       await Promise.resolve();
       try {
-        while (this.head < this.pending.length) {
-          const batch = this.pending[this.head];
-          await this.transport.put("/batches/" + batch.number, batch.body);
-          this.queuedBytes -= batch.body.length * 2;
-          this.pending[this.head] = void 0;
-          this.head++;
-          if (this.head === this.pending.length) {
-            this.pending.length = 0;
-            this.head = 0;
-          }
+        await Promise.all(Array.from({ length: 3 }, async () => {
+          while (!this.failure && !this.disposed && this.head < this.pending.length) {
+            const index2 = this.head++;
+            const batch = this.pending[index2];
+            await this.transport.put("/batches/" + batch.number, batch.body);
+            this.queuedBytes -= batch.body.length * 2;
+            this.pending[index2] = void 0;
+          }
+        }));
+        if (this.head === this.pending.length) {
+          this.pending.length = 0;
+          this.head = 0;
         }
       } catch (error) {
+        this.transport?.dispose();
         this.fail(error instanceof Error ? error : new Error("Capture upload failed."));
         throw this.failure;
       } finally {
         this.sending = void 0;
       }
     }
-    consentChanged = () => record.addCustomEvent("leadping.consent", { accepted: this.options.checkbox.checked });
+    consentChanged = () => {
+      record.addCustomEvent("leadping.consent", { accepted: this.options.checkbox.checked });
+      if (this.options.checkbox.checked) this.backgroundFlush();
+    };
     visibilityChanged = () => {
       if (document.visibilityState === "hidden") this.backgroundFlush();
     };
@@ -13020,11 +13095,9 @@ var LeadpingConsent = (() => {
     status.setAttribute("role", "status");
     form.append(status);
     let capture;
-    let ready = false;
     let submitted = false;
     const fail = (error) => {
-      ready = false;
-      status.textContent = "Unable to complete consent capture. Please reload to start again.";
+      status.textContent = error instanceof ReplayLimitExceededError ? error.message : "Unable to complete consent capture. Please reload to start again.";
       form.dispatchEvent(new CustomEvent("leadping:error", { detail: error }));
     };
     const origin = new URL(script2.dataset.apiUrl ?? "https://consent.leadping.ai");
@@ -13034,27 +13107,40 @@ var LeadpingConsent = (() => {
     if (portal.protocol !== "https:" || portal.username || portal.password || portal.search || portal.hash || portal.pathname !== "/")
       throw new Error("Leadping requires an HTTPS portal origin.");
     const endpoint = `${origin.origin}/api/consent`;
+    const progress = (stage) => {
+      form.dispatchEvent(new CustomEvent("leadping:progress", { detail: { stage } }));
+    };
     const post = async (path, body) => {
-      const response = await fetch(endpoint + path, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        credentials: "omit",
-        redirect: "error",
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (!response.ok) throw new Error(`Leadping request failed (${response.status}).`);
-      return response;
+      const attempts = path.endsWith("/sessions") ? 5 : 1;
+      for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+          const response = await fetch(endpoint + path, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            credentials: "omit",
+            redirect: "error",
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(attempts > 1 ? 15e3 : 3e4)
+          });
+          if (response.ok) return response;
+          if (response.status < 500 && response.status !== 408 && response.status !== 429)
+            throw new CaptureRejectedError(`Leadping request failed (${response.status}).`);
+          throw new Error(`Leadping request failed (${response.status}).`);
+        } catch (error) {
+          if (error instanceof CaptureRejectedError || attempt === attempts - 1) throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500 * 2 ** attempt));
+      }
+      throw new Error("Leadping session could not be started.");
     };
     form.addEventListener("submit", async (event) => {
       event.preventDefault();
-      if (!ready || submitted || !capture || !form.reportValidity()) return;
+      if (submitted || !capture || !form.reportValidity()) return;
       if (!(checkbox instanceof HTMLInputElement) || !checkbox.checked) {
         status.textContent = "Please check the consent box before submitting.";
         return;
       }
       submitted = true;
-      ready = false;
       status.textContent = "Submitting\u2026";
       const values = new FormData(form);
       const recipient = {};
@@ -13062,14 +13148,11 @@ var LeadpingConsent = (() => {
         const value = values.get(key);
         if (typeof value === "string" && value) recipient[key] = value;
       }
-      let issuingCertificate = false;
       try {
         const consentCapture = await capture.finish(recipient);
-        issuingCertificate = true;
-        const certificate = await (await post("/certificates", consentCapture)).json();
-        if (!/^[0-9a-f-]{36}$/i.test(certificate.certificateId)) throw new Error("Invalid certificate response.");
+        const certificate = { certificateId: consentCapture.sessionId };
         const certificateUrl = `${portal.origin}/${certificate.certificateId}`;
-        status.textContent = `Certificate received: ${certificate.certificateId}. `;
+        status.textContent = `Submission saved. Certificate: ${certificate.certificateId}. `;
         const link = document.createElement("a");
         link.href = certificateUrl;
         link.textContent = "View certificate and replay";
@@ -13079,7 +13162,8 @@ var LeadpingConsent = (() => {
         form.dispatchEvent(new CustomEvent("leadping:success", { detail: { certificateId: certificate.certificateId, certificateUrl } }));
       } catch (error) {
         fail(error);
-        if (issuingCertificate) status.textContent = "Certificate issuance could not be confirmed. Please check before starting another recording.";
+        if (!(error instanceof ReplayLimitExceededError))
+          status.textContent = "Submission could not be confirmed. Keep the certificate ID and check before starting another recording.";
       } finally {
         capture.dispose();
       }
@@ -13088,16 +13172,40 @@ var LeadpingConsent = (() => {
     try {
       if (!(disclosure instanceof HTMLElement) || !(checkbox instanceof HTMLInputElement))
         throw new Error("Add data-leadping-disclosure and data-leadping-consent inside the form.");
-      const session = await (await post(`/domains/${encodeURIComponent(domainId)}/sessions`, { pageUrl: location.href, disclosure: disclosure.textContent ?? "" })).json();
-      checkbox.checked = false;
-      capture = new ConsentCapture({ apiUrl: origin.origin + "/api", session, form, disclosure, checkbox, onError: fail });
+      const pageUrl = location.href;
+      const observedDisclosure = disclosure.textContent ?? "";
+      capture = new ConsentCapture({
+        apiUrl: origin.origin + "/api",
+        session: async () => (await post(`/domains/${encodeURIComponent(domainId)}/sessions`, { pageUrl, disclosure: observedDisclosure })).json(),
+        form,
+        disclosure,
+        checkbox,
+        issueCertificate: true,
+        onError: fail,
+        onProgress: (stage) => {
+          status.textContent = stage === "uploading" ? "Saving recording\u2026" : "Saving submission and requesting certificate\u2026";
+          progress(stage);
+        }
+      });
       window.addEventListener("pagehide", () => {
-        ready = false;
         capture?.dispose();
       }, { once: true });
-      ready = true;
-      status.textContent = "";
-      form.dispatchEvent(new CustomEvent("leadping:ready"));
+      await capture.ready;
+      const certificateId = capture.sessionId;
+      const certificateUrl = `${portal.origin}/${certificateId}`;
+      for (const [name, value] of Object.entries({ leadping_certificate_id: certificateId, leadping_certificate_url: certificateUrl })) {
+        const input2 = document.createElement("input");
+        input2.type = "hidden";
+        input2.name = name;
+        input2.value = value;
+        form.append(input2);
+      }
+      if (!submitted) status.textContent = "";
+      form.dispatchEvent(new CustomEvent("leadping:ready", { detail: {
+        certificateId,
+        certificateUrl,
+        maxReplaySeconds: capture.maxReplaySeconds
+      } }));
     } catch (error) {
       capture?.dispose();
       fail(error);