@leadping/consent 0.0.0-stage → 1.0.1

package/dist/capture-rejected-error.d.ts

@@ -0,0 +1,3 @@
+/** A permanent server rejection that must not be retried. */
+export declare class CaptureRejectedError extends Error {
+}

package/dist/capture-rejected-error.js

@@ -0,0 +1,3 @@
+/** A permanent server rejection that must not be retried. */
+export class CaptureRejectedError extends Error {
+}

package/dist/capture.d.ts

@@ -0,0 +1,34 @@
+import type { CaptureOptions, CaptureReference, Recipient } from './types.js';
+/** One form recording per document, matching rrweb's document-level recorder. */
+export declare class ConsentCapture {
+    private readonly options;
+    private static active?;
+    private readonly browser;
+    private readonly buffer;
+    private readonly transport;
+    private readonly pending;
+    private head;
+    private queuedBytes;
+    private sending?;
+    private stopRecording?;
+    private interval?;
+    private expiry?;
+    private failure?;
+    private stopped;
+    private finished?;
+    constructor(options: CaptureOptions);
+    /** Invoke before submitting your form; send the returned reference to your trusted backend with the lead. */
+    finish(recipient: Recipient): Promise<CaptureReference>;
+    /** Flush pending capture without stopping the recorder. Never silently discards a failed batch. */
+    flush(): Promise<void>;
+    dispose(): void;
+    private finishCore;
+    private readonly emit;
+    private seal;
+    private send;
+    private readonly consentChanged;
+    private readonly visibilityChanged;
+    private readonly backgroundFlush;
+    private fail;
+    private stop;
+}

package/dist/capture.js

@@ -0,0 +1,184 @@
+import { record } from 'rrweb';
+import { EventBuffer } from './event-buffer.js';
+import { CaptureTransport } from './transport.js';
+/** One form recording per document, matching rrweb's document-level recorder. */
+export class ConsentCapture {
+    options;
+    static active;
+    browser = {
+        userAgent: navigator.userAgent,
+        platform: navigator.platform,
+        language: navigator.language,
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screenWidth: screen.width,
+        screenHeight: screen.height,
+        colorDepth: screen.colorDepth,
+        pixelRatio: window.devicePixelRatio,
+        hardwareConcurrency: navigator.hardwareConcurrency,
+        maxTouchPoints: navigator.maxTouchPoints,
+    };
+    buffer = new EventBuffer();
+    transport;
+    pending = [];
+    head = 0;
+    queuedBytes = 0;
+    sending;
+    stopRecording;
+    interval;
+    expiry;
+    failure;
+    stopped = false;
+    finished;
+    constructor(options) {
+        this.options = options;
+        if (ConsentCapture.active)
+            throw new Error('Only one consent recorder may run in a document.');
+        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 * 1000)
+            throw new Error('Invalid or expired capture session.');
+        this.transport = new CaptureTransport(url.href.replace(/\/$/, '') + '/consent/sessions/' + options.session.sessionId, options.session.uploadToken);
+        ConsentCapture.active = this;
+        try {
+            this.stopRecording = record({
+                emit: this.emit,
+                // Override rrweb defaults as well as Leadping selectors: preserve original values.
+                maskAllInputs: false,
+                maskInputOptions: {},
+                maskTextClass: /$^/,
+                blockClass: /$^/,
+                ignoreClass: '',
+                slimDOMOptions: {},
+                inlineStylesheet: true,
+                inlineImages: true,
+                recordCanvas: false,
+                recordCrossOriginIframes: false,
+                collectFonts: false,
+                sampling: { mousemove: 100, mouseInteraction: true, scroll: 150, input: 'all', media: 1000 },
+                errorHandler: () => { this.fail(new Error('The page could not be fully recorded.')); return true; },
+            });
+            if (!this.stopRecording || this.failure)
+                throw this.failure ?? new Error('Recorder failed to start.');
+            options.checkbox.addEventListener('change', this.consentChanged);
+            document.addEventListener('visibilitychange', this.visibilityChanged);
+            this.interval = setInterval(this.backgroundFlush, 3000);
+            this.expiry = setTimeout(() => this.fail(new Error('Capture session expired.')), remaining);
+            record.addCustomEvent('leadping.disclosure', { formId: options.session.form.id });
+        }
+        catch (error) {
+            this.stop();
+            throw error;
+        }
+    }
+    /** Invoke before submitting your form; send the returned reference to your trusted backend with the lead. */
+    finish(recipient) {
+        return this.finished ??= this.finishCore(recipient);
+    }
+    /** Flush pending capture without stopping the recorder. Never silently discards a failed batch. */
+    async flush() {
+        if (this.failure)
+            throw this.failure;
+        this.seal();
+        while (this.head < this.pending.length || this.sending) {
+            this.sending ??= this.send();
+            await this.sending;
+        }
+        if (this.failure)
+            throw this.failure;
+    }
+    dispose() { this.stop(); this.transport.dispose(); }
+    async finishCore(recipient) {
+        if (this.stopped || this.failure)
+            throw this.failure ?? new Error('Recorder is stopped.');
+        const observedDisclosure = this.options.disclosure.textContent ?? '';
+        if (observedDisclosure !== this.options.session.form.disclosure)
+            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();
+        await this.flush();
+        await this.transport.put('/submission', JSON.stringify({
+            lastBatchNumber: this.buffer.lastBatchNumber, lastEventNumber: this.buffer.lastEventNumber,
+            accepted, observedDisclosure, recipient, browser: this.browser,
+        }));
+        return { sessionId: this.options.session.sessionId, uploadToken: this.options.session.uploadToken };
+    }
+    emit = (event) => {
+        if (this.stopped || this.failure)
+            return;
+        try {
+            const serialized = JSON.stringify(event);
+            if (!this.buffer.canAppend(serialized))
+                this.seal();
+            this.buffer.append(serialized);
+            if (this.buffer.byteLength >= 64 * 1024)
+                this.backgroundFlush();
+        }
+        catch {
+            this.fail(new Error('Recording exceeded its memory or event size limit.'));
+        }
+    };
+    seal() {
+        const batch = this.buffer.seal();
+        if (!batch)
+            return;
+        // UTF-16 string budget including queued/retrying batches. One in-flight compressed copy is additional.
+        if (this.queuedBytes + batch.body.length * 2 > 2 * 1024 * 1024)
+            throw new Error('Recording upload backlog exceeded 2 MiB.');
+        this.pending.push(batch);
+        this.queuedBytes += batch.body.length * 2;
+    }
+    async send() {
+        // Defer so this.sending is assigned before this function can finish.
+        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] = undefined;
+                this.head++;
+                if (this.head === this.pending.length) {
+                    this.pending.length = 0;
+                    this.head = 0;
+                }
+            }
+        }
+        catch (error) {
+            this.fail(error instanceof Error ? error : new Error('Capture upload failed.'));
+            throw this.failure;
+        }
+        finally {
+            this.sending = undefined;
+        }
+    }
+    consentChanged = () => record.addCustomEvent('leadping.consent', { accepted: this.options.checkbox.checked });
+    visibilityChanged = () => { if (document.visibilityState === 'hidden')
+        this.backgroundFlush(); };
+    backgroundFlush = () => { void this.flush().catch(error => this.fail(error)); };
+    fail(error) {
+        if (this.failure)
+            return;
+        this.failure = error;
+        this.stop();
+        this.options.onError?.(error);
+    }
+    stop() {
+        this.stopped = true;
+        this.stopRecording?.();
+        this.stopRecording = undefined;
+        clearInterval(this.interval);
+        clearTimeout(this.expiry);
+        this.options.checkbox.removeEventListener('change', this.consentChanged);
+        document.removeEventListener('visibilitychange', this.visibilityChanged);
+        if (ConsentCapture.active === this)
+            ConsentCapture.active = undefined;
+    }
+}

package/dist/embed.d.ts

@@ -0,0 +1,3 @@
+export { ConsentCapture } from './capture.js';
+/** Attach the Leadping-hosted capture and submission flow to a form. */
+export declare function attach(script: HTMLScriptElement): Promise<void>;

package/dist/embed.js

@@ -0,0 +1,114 @@
+import { ConsentCapture } from './capture.js';
+export { ConsentCapture } from './capture.js';
+/** Attach the Leadping-hosted capture and submission flow to a form. */
+export async function attach(script) {
+    const domainId = script.dataset.domainId;
+    if (!domainId)
+        throw new Error('data-domain-id is required.');
+    const form = document.querySelector(script.dataset.form ?? '#lead-form');
+    if (!(form instanceof HTMLFormElement))
+        throw new Error('Leadping form was not found.');
+    if (form.dataset.leadpingAttached)
+        throw new Error('Leadping is already attached to this form.');
+    form.dataset.leadpingAttached = 'true';
+    const disclosure = form.querySelector('[data-leadping-disclosure]');
+    const checkbox = form.querySelector('[data-leadping-consent]');
+    const status = document.createElement('p');
+    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.';
+        form.dispatchEvent(new CustomEvent('leadping:error', { detail: error }));
+    };
+    const origin = new URL(script.dataset.apiUrl ?? 'https://consent.leadping.ai');
+    if (origin.protocol !== 'https:' || origin.username || origin.password || origin.search || origin.hash || origin.pathname !== '/')
+        throw new Error('Leadping requires an HTTPS API origin.');
+    const portal = new URL(script.dataset.portalUrl ?? (origin.hostname === 'consent-local.leadping.ai'
+        ? 'https://certificate-local.leadping.ai' : 'https://certificate.leadping.ai'));
+    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 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(30000),
+        });
+        if (!response.ok)
+            throw new Error(`Leadping request failed (${response.status}).`);
+        return response;
+    };
+    form.addEventListener('submit', async (event) => {
+        event.preventDefault();
+        if (!ready || 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…';
+        const values = new FormData(form);
+        const recipient = {};
+        for (const key of ['firstName', 'lastName', 'email', 'phone']) {
+            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 certificateUrl = `${portal.origin}/${certificate.certificateId}`;
+            status.textContent = `Certificate received: ${certificate.certificateId}. `;
+            const link = document.createElement('a');
+            link.href = certificateUrl;
+            link.textContent = 'View certificate and replay';
+            link.target = '_blank';
+            link.rel = 'noopener noreferrer';
+            status.append(link);
+            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.';
+        }
+        finally {
+            capture.dispose();
+        }
+    });
+    status.textContent = 'Loading consent…';
+    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 });
+        window.addEventListener('pagehide', () => { ready = false; capture?.dispose(); }, { once: true });
+        ready = true;
+        status.textContent = '';
+        form.dispatchEvent(new CustomEvent('leadping:ready'));
+    }
+    catch (error) {
+        capture?.dispose();
+        fail(error);
+        throw error;
+    }
+}
+const script = document.currentScript;
+if (script instanceof HTMLScriptElement && script.dataset.domainId) {
+    const start = () => { void attach(script).catch(error => console.error('Leadping consent initialization failed:', error)); };
+    if (document.readyState === 'loading')
+        document.addEventListener('DOMContentLoaded', start, { once: true });
+    else
+        start();
+}

package/dist/event-buffer.d.ts

@@ -0,0 +1,18 @@
+import type { SealedBatch } from './types.js';
+/** UTF-8 size without allocating an encoded copy of each event. */
+export declare function utf8Length(value: string): number;
+/** Bounded append buffer. Serialize once, clear references after each batch, never shift event arrays. */
+export declare class EventBuffer {
+    private readonly events;
+    private bytes;
+    private nextEvent;
+    private nextBatch;
+    readonly maxBytes: number;
+    get byteLength(): number;
+    get count(): number;
+    get lastEventNumber(): number;
+    get lastBatchNumber(): number;
+    canAppend(serialized: string): boolean;
+    append(serialized: string): void;
+    seal(): SealedBatch | undefined;
+}

package/dist/event-buffer.js

@@ -0,0 +1,53 @@
+/** UTF-8 size without allocating an encoded copy of each event. */
+export function utf8Length(value) {
+    let bytes = value.length;
+    for (let i = 0; i < value.length; i++) {
+        const c = value.charCodeAt(i);
+        if (c < 0x80)
+            continue;
+        if (c < 0x800)
+            bytes++;
+        else if (c >= 0xd800 && c <= 0xdbff && i + 1 < value.length &&
+            value.charCodeAt(i + 1) >= 0xdc00 && value.charCodeAt(i + 1) <= 0xdfff) {
+            bytes += 2;
+            i++;
+        }
+        else
+            bytes += 2;
+    }
+    return bytes;
+}
+/** Bounded append buffer. Serialize once, clear references after each batch, never shift event arrays. */
+export class EventBuffer {
+    events = [];
+    bytes = 0;
+    nextEvent = 0;
+    nextBatch = 0;
+    maxBytes = 256 * 1024 - 128;
+    get byteLength() { return this.bytes; }
+    get count() { return this.events.length; }
+    get lastEventNumber() { return this.nextEvent - 1; }
+    get lastBatchNumber() { return this.nextBatch - 1; }
+    canAppend(serialized) {
+        return this.events.length < 4096 && this.bytes + utf8Length(serialized) + 1 <= this.maxBytes;
+    }
+    append(serialized) {
+        const size = utf8Length(serialized) + 1;
+        if (size > this.maxBytes || this.bytes + size > this.maxBytes || this.events.length >= 4096)
+            throw new Error('Recording event exceeds the capture buffer limit.');
+        this.events.push(serialized);
+        this.bytes += size;
+        this.nextEvent++;
+    }
+    seal() {
+        if (this.events.length === 0)
+            return;
+        if (this.nextBatch >= 256)
+            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;
+        this.bytes = 0;
+        return { number: this.nextBatch++, firstEventNumber: first, lastEventNumber: this.nextEvent - 1, body };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { ConsentCapture } from './capture.js';
+export type { CaptureOptions, CaptureReference, CaptureSession, ConsentForm, Recipient } from './types.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { ConsentCapture } from './capture.js';