onerway-analytics 1.3.0 → 1.5.0

package/dist/core/analytics.js

@@ -1,7 +1,6 @@
 import { API_KEY_MAP, DEFAULT_CONFIG, STORAGE_KEYS, } from '../types';
 import { SessionManager } from './session-manager';
-import { Sender } from './sender';
-import { StorageQueue } from './storage';
+import { DeliveryQueue } from './delivery-queue';
 import { collectContext, collectMarketing } from './context-collector';
 import { initAutoTrack } from './auto-track';
 import { initErrorMonitor } from './error-monitor';
@@ -17,8 +16,8 @@ export class Analytics {
         this.userId = null;
         this.userProps = {};
         this.initialized = false;
-        this.retrying = 0;
         this.unloadHandler = null;
+        this.visibilityHandler = null;
         this.gtm = new GTMManager();
         this.config = {
             debug: false,
@@ -37,9 +36,13 @@ export class Analytics {
         this.batchPageId = this.generateBatchPageId();
         this.sessionManager = new SessionManager(this.config.sessionTimeout);
         this.sampled = this.resolveSampling();
-        if (isBrowser()) {
-            this.recoverFailedEvents();
-        }
+        this.delivery = new DeliveryQueue({
+            serverUrl: this.config.serverUrl,
+            apiKey: this.resolveApiKey(),
+            appKey,
+            maxRetries: this.config.maxRetryCount,
+            persistKeyEvents: this.config.persistKeyEvents === true && this.sampled && !this.config.disableServer,
+        });
         this.registerBeforeUnload();
         if (this.config.autoTrack && isBrowser()) {
             initAutoTrack(this, this.config.autoTrackSelector);
@@ -131,6 +134,7 @@ export class Analytics {
         this.userId = null;
         this.userProps = {};
         this.buffer = [];
+        this.delivery.clear();
         if (this.bufferTimer) {
             clearTimeout(this.bufferTimer);
             this.bufferTimer = null;
@@ -242,11 +246,6 @@ export class Analytics {
         }
         if (this.buffer.length === 0)
             return;
-        // Wait for inflight retries to settle before sending a new batch
-        if (this.retrying > 0) {
-            this.scheduleBufferFlush();
-            return;
-        }
         const events = this.buffer.splice(0, this.buffer.length);
         events.forEach((e, i) => {
             e.batch_event_index = i;
@@ -260,52 +259,14 @@ export class Analytics {
         this.log('Flushing key event:', event.event_name);
         this.sendBatch([event], 0);
     }
-    async sendBatch(events, retryCount) {
-        if (events.length === 0)
-            return;
-        const apiKey = this.resolveApiKey();
-        if (!apiKey) {
-            this.log('No API key configured, dropping events (retry disabled)');
-            // HOTFIX (production): localStorage persistence disabled. Original:
-            //      for (const event of events) {
-            //        StorageQueue.enqueue(event);
-            //      }
+    sendBatch(events, _retryCount) {
+        if (!events.length || this.config.disableServer)
             return;
-        }
-        const payload = this.buildPayload(events);
         try {
-            await Sender.send(payload, this.config.serverUrl, apiKey);
-            this.log(`Batch sent successfully: ${events.length} events`);
+            this.delivery.enqueue(this.buildPayload(events));
         }
         catch (error) {
-            this.log(`Batch send failed (attempt ${retryCount + 1}/${this.config.maxRetryCount + 1}):`, error);
-            // ====================================================================
-            // HOTFIX (production): retry / localStorage persistence DISABLED.
-            // Reason: retry loop + parallel recoverFailedEvents + fire-and-forget
-            // setTimeout caused 70+ concurrent in-flight requests on network errors.
-            // DO NOT DELETE the block below — the original implementation must be
-            // restored once the retry mechanism is rewritten (track via ticket).
-            // ====================================================================
-            const retryEnabled = Analytics.RETRY_ENABLED;
-            if (retryEnabled && retryCount < this.config.maxRetryCount) {
-                const delay = 1000 * Math.pow(2, retryCount);
-                this.log(`Retrying in ${delay}ms...`);
-                this.retrying += 1;
-                setTimeout(() => {
-                    this.retrying -= 1;
-                    this.sendBatch(events, retryCount + 1);
-                    if (this.buffer.length > 0) {
-                        this.scheduleBufferFlush();
-                    }
-                }, delay);
-            }
-            else {
-                this.log('Max retries reached / retry disabled, dropping events');
-                // HOTFIX (production): localStorage persistence disabled. Original:
-                //      for (const event of events) {
-                //        StorageQueue.enqueue(event);
-                //      }
-            }
+            this.log('Unable to prepare analytics payload:', error);
         }
     }
     buildPayload(events) {
@@ -319,38 +280,15 @@ export class Analytics {
             events,
         };
     }
-    recoverFailedEvents() {
-        if (this.config.disableServer)
-            return;
-        if (!this.sampled)
-            return;
-        if (!Analytics.RETRY_ENABLED) {
-            // HOTFIX (production): storage recovery disabled. Clean any stale items
-            // so they don't accumulate forever.
-            StorageQueue.clear();
-            return;
-        }
-        const failedEvents = StorageQueue.recover();
-        if (failedEvents.length > 0) {
-            this.log(`Recovered ${failedEvents.length} failed events from storage`);
-            for (const event of failedEvents) {
-                event.batch_ordering_id = this.generateBatchOrderingId();
-                event.batch_page_id = this.batchPageId;
-                event.batch_event_index = 0;
-            }
-            const batchSize = this.config.bufferMaxSize;
-            for (let i = 0; i < failedEvents.length; i += batchSize) {
-                const batch = failedEvents.slice(i, i + batchSize);
-                batch.forEach((e, idx) => {
-                    e.batch_event_index = idx;
-                });
-                this.sendBatch(batch, 0);
-            }
-        }
-    }
     destroy() {
+        this.flushBuffer();
+        this.delivery.destroy();
+        if (this.visibilityHandler) {
+            document.removeEventListener('visibilitychange', this.visibilityHandler);
+            window.removeEventListener('pageshow', this.visibilityHandler);
+            this.visibilityHandler = null;
+        }
         if (this.unloadHandler) {
-            window.removeEventListener('beforeunload', this.unloadHandler);
             window.removeEventListener('pagehide', this.unloadHandler);
             this.unloadHandler = null;
         }
@@ -362,51 +300,22 @@ export class Analytics {
     registerBeforeUnload() {
         if (!isBrowser() || this.config.disableServer)
             return;
-        const handler = () => {
-            if (this.buffer.length === 0)
-                return;
-            const events = this.buffer.splice(0, this.buffer.length);
-            events.forEach((e, i) => {
-                e.batch_event_index = i;
-            });
-            const apiKey = this.resolveApiKey();
-            if (!apiKey)
-                return;
-            const payload = this.buildPayload(events);
-            try {
-                if (typeof navigator !== 'undefined' && navigator.sendBeacon) {
-                    const url = `${this.config.serverUrl}${this.config.serverUrl.includes('?') ? '&' : '?'}apiKey=${encodeURIComponent(apiKey)}`;
-                    const blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
-                    const success = navigator.sendBeacon(url, blob);
-                    if (!success)
-                        throw new Error('sendBeacon rejected');
-                }
-                else {
-                    // XHR sync as fallback — tries to send but doesn't block page unload
-                    try {
-                        const xhr = new XMLHttpRequest();
-                        xhr.open('POST', this.config.serverUrl, false);
-                        xhr.setRequestHeader('Content-Type', 'application/json');
-                        xhr.setRequestHeader('apiKey', apiKey);
-                        xhr.timeout = 2000;
-                        xhr.send(JSON.stringify(payload));
-                    }
-                    catch {
-                        // XHR failed during unload
-                    }
-                }
-            }
-            catch {
-                // HOTFIX (production): localStorage persistence disabled. Original:
-                //      for (const event of events) {
-                //        StorageQueue.enqueue(event);
-                //      }
-                this.log('Failed to flush buffer on unload, dropping events (retry disabled)');
+        this.unloadHandler = () => {
+            this.delivery.setHidden(true);
+            this.flushBuffer();
+            this.delivery.flushHidden();
+        };
+        this.visibilityHandler = () => {
+            const hidden = document.visibilityState === 'hidden';
+            this.delivery.setHidden(hidden);
+            if (hidden) {
+                this.flushBuffer();
+                this.delivery.flushHidden();
             }
         };
-        this.unloadHandler = handler;
-        window.addEventListener('beforeunload', handler);
-        window.addEventListener('pagehide', handler);
+        window.addEventListener('pagehide', this.unloadHandler);
+        document.addEventListener('visibilitychange', this.visibilityHandler);
+        window.addEventListener('pageshow', this.visibilityHandler);
     }
     trackPageView() {
         if (!isBrowser())
@@ -419,12 +328,6 @@ export class Analytics {
         });
     }
 }
-// HOTFIX (production): retry / recovery / localStorage persistence DISABLED.
-// Reason: retry loop + parallel recoverFailedEvents + fire-and-forget
-// setTimeout caused 70+ concurrent in-flight requests on network errors.
-// Flip this flag to true (and uncomment the StorageQueue.enqueue blocks)
-// to restore the original behavior once the retry mechanism is rewritten.
-Analytics.RETRY_ENABLED = false;
 export function createAnalytics(config) {
     return new Analytics(config);
 }

package/dist/core/delivery-queue.d.ts

@@ -0,0 +1,41 @@
+import { AnalyticsPayload } from '../types';
+interface Options {
+    serverUrl: string;
+    apiKey: string;
+    appKey: string;
+    maxRetries: number;
+    persistKeyEvents: boolean;
+}
+/** First attempts are immediate. Only retries/recovery share a two-request pool. */
+export declare class DeliveryQueue {
+    private options;
+    private jobs;
+    private activeRetries;
+    private hidden;
+    private timer;
+    private stopped;
+    private storagePrefix;
+    private maxAttempts;
+    private hiddenSent;
+    private hiddenSpent;
+    private keepaliveBytes;
+    constructor(options: Options);
+    enqueue(payload: AnalyticsPayload): void;
+    setHidden(hidden: boolean): void;
+    /** Submit the whole affordable rescue set synchronously; do not wait for ACKs. */
+    flushHidden(): void;
+    private bytes;
+    private batches;
+    private prune;
+    private pumpRetries;
+    private start;
+    private deliver;
+    private key;
+    private persist;
+    private remove;
+    private recover;
+    clear(): void;
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=delivery-queue.d.ts.map

package/dist/core/delivery-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-queue.d.ts","sourceRoot":"","sources":["../../src/core/delivery-queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAgB5C,UAAU,OAAO;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,oFAAoF;AACpF,qBAAa,aAAa;IAYZ,OAAO,CAAC,OAAO;IAX3B,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,MAAM,CAA4E;IAC1F,OAAO,CAAC,KAAK,CAA8C;IAC3D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,cAAc,CAAK;gBAEP,OAAO,EAAE,OAAO;IAOpC,OAAO,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAqBxC,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAWhC,kFAAkF;IAClF,WAAW,IAAI,IAAI;IAmBnB,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,OAAO;IA6Bf,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,KAAK;YAaC,OAAO;IAyBrB,OAAO,CAAC,GAAG;IAEX,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,MAAM;IAOd,OAAO,CAAC,OAAO;IAoBf,KAAK,IAAI,IAAI;IAKb,OAAO,IAAI,IAAI;CAIhB"}

package/dist/core/delivery-queue.js

@@ -0,0 +1,248 @@
+import { Sender, DeliveryError } from './sender';
+import { safeLocalStorageGet, safeLocalStorageSet, safeLocalStorageRemove } from '../utils';
+const MAX_BYTES = 48 * 1024;
+const MAX_EVENTS = 500;
+const MAX_AGE = 24 * 60 * 60 * 1000;
+/** First attempts are immediate. Only retries/recovery share a two-request pool. */
+export class DeliveryQueue {
+    constructor(options) {
+        this.options = options;
+        this.jobs = [];
+        this.activeRetries = 0;
+        this.hidden = typeof document !== 'undefined' && document.visibilityState === 'hidden';
+        this.timer = null;
+        this.stopped = false;
+        this.hiddenSent = new Set();
+        this.hiddenSpent = 0;
+        this.keepaliveBytes = 0;
+        this.maxAttempts = 1 + Math.min(5, Math.max(0, options.maxRetries || 0));
+        this.storagePrefix = `__analytics_delivery_v1__:${encodeURIComponent(options.appKey)}:${encodeURIComponent(options.serverUrl)}:`;
+        if (options.persistKeyEvents && options.apiKey)
+            this.recover();
+        this.pumpRetries();
+    }
+    enqueue(payload) {
+        if (this.stopped || !this.options.apiKey)
+            return;
+        const accepted = [];
+        for (const event of payload.events) {
+            if (this.jobs.length >= MAX_EVENTS)
+                break;
+            const single = { ...payload, events: [event] };
+            if (this.bytes(single) > MAX_BYTES)
+                continue;
+            const job = { payload: single, attempts: 0, createdAt: Date.now(), nextAt: 0,
+                active: 0, hiddenActive: false, terminal: false };
+            this.jobs.push(job);
+            this.persist(job);
+            accepted.push(job);
+        }
+        if (this.hidden) {
+            this.flushHidden();
+        }
+        else {
+            // Preserve normal batch delivery, but never queue a first attempt behind retries.
+            for (const batch of this.batches(accepted, MAX_BYTES))
+                this.start(batch.payload, batch.jobs, false, false);
+        }
+    }
+    setHidden(hidden) {
+        if (hidden && !this.hidden) {
+            this.hiddenSent.clear();
+            this.hiddenSpent = 0;
+        }
+        this.hidden = hidden;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (!hidden)
+            this.pumpRetries();
+        // Caller flushes the SDK buffer before flushHidden, so critical jobs take priority.
+    }
+    /** Submit the whole affordable rescue set synchronously; do not wait for ACKs. */
+    flushHidden() {
+        if (this.stopped || !this.hidden)
+            return;
+        const available = Math.min(MAX_BYTES - this.hiddenSpent, MAX_BYTES - this.keepaliveBytes);
+        if (available <= 0)
+            return;
+        this.prune();
+        const candidates = this.jobs.filter(job => !job.terminal && !job.hiddenActive &&
+            !this.hiddenSent.has(job) && job.attempts < this.maxAttempts)
+            .sort((a, b) => Number(b.payload.events[0].key_event) - Number(a.payload.events[0].key_event));
+        let remaining = available;
+        for (const batch of this.batches(candidates, available, true)) {
+            const bytes = this.bytes(batch.payload);
+            if (bytes > remaining)
+                continue;
+            remaining -= bytes;
+            this.hiddenSpent += bytes;
+            for (const job of batch.jobs)
+                this.hiddenSent.add(job);
+            this.start(batch.payload, batch.jobs, true, false);
+        }
+    }
+    bytes(payload) {
+        return new Blob([JSON.stringify(payload)]).size;
+    }
+    batches(jobs, budget, totalBudget = false) {
+        const result = [];
+        let remaining = budget;
+        // Context/client/session/marketing/user fields must match before events can share a request.
+        const groups = new Map();
+        for (const job of jobs) {
+            const { events, ...envelope } = job.payload;
+            const key = JSON.stringify(envelope);
+            let group = groups.get(key);
+            const proposed = { ...envelope, events: [...(group?.payload.events || []), ...events]
+                    .map((event, index) => ({ ...event, batch_event_index: index })) };
+            const delta = this.bytes(proposed) - (group ? this.bytes(group.payload) : 0);
+            if (totalBudget && delta > remaining)
+                continue;
+            if (this.bytes(proposed) > budget) {
+                group = undefined;
+            }
+            if (!group) {
+                group = { payload: { ...envelope, events: events.map((event, index) => ({ ...event, batch_event_index: index })) }, jobs: [] };
+                groups.set(key, group);
+                result.push(group);
+            }
+            else {
+                group.payload = proposed;
+            }
+            group.jobs.push(job);
+            if (totalBudget)
+                remaining -= delta;
+        }
+        return result;
+    }
+    prune() {
+        for (const job of [...this.jobs]) {
+            if (!job.active && (job.terminal || Date.now() - job.createdAt >= MAX_AGE || job.attempts >= this.maxAttempts))
+                this.remove(job);
+        }
+    }
+    pumpRetries() {
+        if (this.stopped || this.hidden)
+            return;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.prune();
+        while (this.activeRetries < 2) {
+            const job = this.jobs.find(item => !item.active && item.nextAt <= Date.now());
+            if (!job)
+                break;
+            this.start(job.payload, [job], false, true);
+        }
+        const waiting = this.jobs.filter(job => !job.active);
+        if (waiting.length && this.activeRetries < 2) {
+            const delay = Math.max(1, Math.min(...waiting.map(job => job.nextAt)) - Date.now());
+            this.timer = setTimeout(() => this.pumpRetries(), delay);
+        }
+    }
+    start(payload, jobs, keepalive, retry) {
+        const bytes = keepalive ? this.bytes(payload) : 0;
+        this.keepaliveBytes += bytes;
+        if (retry)
+            this.activeRetries++;
+        for (const job of jobs) {
+            job.active++;
+            job.attempts++;
+            if (keepalive)
+                job.hiddenActive = true;
+            this.persist(job);
+        }
+        void this.deliver(payload, jobs, keepalive, retry, bytes);
+    }
+    async deliver(payload, jobs, keepalive, retry, bytes) {
+        try {
+            await Sender.send(payload, this.options.serverUrl, this.options.apiKey, keepalive);
+            for (const job of jobs)
+                this.remove(job);
+        }
+        catch (error) {
+            for (const job of jobs) {
+                if (!this.jobs.includes(job))
+                    continue; // A concurrent rescue/normal request may have ACKed already.
+                if (error instanceof DeliveryError && !error.retryable)
+                    job.terminal = true;
+                job.nextAt = Date.now() + Math.min(30000, 1000 * 2 ** (job.attempts - 1)) + Math.floor(Math.random() * 250);
+            }
+        }
+        finally {
+            for (const job of jobs) {
+                job.active--;
+                if (keepalive)
+                    job.hiddenActive = false;
+                if (!this.jobs.includes(job))
+                    continue;
+                // Wait for both original and rescue outcomes before retiring a failed event.
+                if (!job.active && (job.terminal || job.attempts >= this.maxAttempts))
+                    this.remove(job);
+                else
+                    this.persist(job);
+            }
+            this.keepaliveBytes -= bytes;
+            if (retry)
+                this.activeRetries--;
+            this.pumpRetries();
+        }
+    }
+    key(eventId) { return this.storagePrefix + eventId; }
+    persist(job) {
+        if (!this.options.persistKeyEvents || !job.payload.events[0].key_event)
+            return;
+        safeLocalStorageSet(this.key(job.payload.events[0].event_id), JSON.stringify({
+            payload: job.payload, attempts: job.attempts, createdAt: job.createdAt, nextAt: job.nextAt,
+        }));
+    }
+    remove(job) {
+        if (!this.jobs.includes(job))
+            return;
+        this.jobs = this.jobs.filter(item => item !== job);
+        this.hiddenSent.delete(job);
+        if (this.options.persistKeyEvents)
+            safeLocalStorageRemove(this.key(job.payload.events[0].event_id));
+    }
+    recover() {
+        try {
+            const keys = Object.keys(localStorage).filter(key => key.startsWith(this.storagePrefix));
+            for (const key of keys) {
+                try {
+                    const job = JSON.parse(safeLocalStorageGet(key) || 'null');
+                    if (!job || !Number.isFinite(job.createdAt) || !Number.isInteger(job.attempts) || job.attempts < 0 ||
+                        !Number.isFinite(job.nextAt) || Date.now() - job.createdAt >= MAX_AGE || job.attempts >= this.maxAttempts ||
+                        !Array.isArray(job.payload?.events) || job.payload.events.length !== 1 ||
+                        !job.payload.events[0].key_event || this.key(job.payload.events[0].event_id) !== key ||
+                        this.bytes(job.payload) > MAX_BYTES || this.jobs.length >= MAX_EVENTS) {
+                        safeLocalStorageRemove(key);
+                        continue;
+                    }
+                    this.jobs.push({ ...job, active: 0, hiddenActive: false, terminal: false });
+                }
+                catch {
+                    safeLocalStorageRemove(key);
+                }
+            }
+        }
+        catch { /* Storage unavailable: delivery continues in memory. */ }
+    }
+    clear() {
+        for (const job of [...this.jobs])
+            this.remove(job);
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    destroy() {
+        this.stopped = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}

package/dist/core/sender.d.ts

@@ -1,10 +1,14 @@
 import { AnalyticsPayload } from '../types';
+export declare class DeliveryError extends Error {
+    retryable: boolean;
+    constructor(message: string, retryable: boolean);
+}
 export declare class Sender {
-    static send(payload: AnalyticsPayload, serverUrl: string, apiKey: string): Promise<void>;
+    static send(payload: AnalyticsPayload, serverUrl: string, apiKey: string, keepalive?: boolean): Promise<void>;
     static sendBeacon(payload: AnalyticsPayload, serverUrl: string, apiKey: string): Promise<void>;
-    static fetchSend(payload: AnalyticsPayload, serverUrl: string, apiKey: string): Promise<void>;
+    static fetchSend(payload: AnalyticsPayload, serverUrl: string, apiKey: string, keepalive?: boolean): Promise<void>;
+    private static httpError;
     static xhrSend(payload: AnalyticsPayload, serverUrl: string, apiKey: string): Promise<void>;
     private static supportsKeepalive;
-    private static buildBeaconUrl;
 }
 //# sourceMappingURL=sender.d.ts.map

package/dist/core/sender.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sender.d.ts","sourceRoot":"","sources":["../../src/core/sender.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C,qBAAa,MAAM;WACJ,IAAI,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAOjF,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAcvF,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAgBtF,OAAO,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBjG,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAQhC,OAAO,CAAC,MAAM,CAAC,cAAc;CAI9B"}
+{"version":3,"file":"sender.d.ts","sourceRoot":"","sources":["../../src/core/sender.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C,qBAAa,aAAc,SAAQ,KAAK;IACF,SAAS,EAAE,OAAO;gBAA1C,OAAO,EAAE,MAAM,EAAS,SAAS,EAAE,OAAO;CACvD;AAED,qBAAa,MAAM;WACJ,IAAI,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAIjF,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBtH,OAAO,CAAC,MAAM,CAAC,SAAS;IAIxB,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAe3F,OAAO,CAAC,MAAM,CAAC,iBAAiB;CAGjC"}

package/dist/core/sender.js

@@ -1,65 +1,61 @@
+export class DeliveryError extends Error {
+    constructor(message, retryable) {
+        super(message);
+        this.retryable = retryable;
+    }
+}
 export class Sender {
-    static async send(payload, serverUrl, apiKey) {
-        if (Sender.supportsKeepalive()) {
-            return Sender.fetchSend(payload, serverUrl, apiKey);
+    static async send(payload, serverUrl, apiKey, keepalive = false) {
+        if (typeof fetch === 'function' && typeof AbortController !== 'undefined') {
+            if (keepalive && !Sender.supportsKeepalive()) {
+                throw new DeliveryError('Keepalive unavailable', true);
+            }
+            return Sender.fetchSend(payload, serverUrl, apiKey, keepalive);
         }
+        if (keepalive)
+            throw new DeliveryError('Unload transport unavailable', true);
         return Sender.xhrSend(payload, serverUrl, apiKey);
     }
-    static async sendBeacon(payload, serverUrl, apiKey) {
-        if (typeof navigator === 'undefined' || !navigator.sendBeacon) {
-            throw new Error('sendBeacon not available');
+    // Compatibility entry point: authenticated delivery must support custom headers.
+    static sendBeacon(payload, serverUrl, apiKey) {
+        return Sender.send(payload, serverUrl, apiKey, true);
+    }
+    static async fetchSend(payload, serverUrl, apiKey, keepalive = false) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 10000);
+        try {
+            const response = await fetch(serverUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', apiKey },
+                body: JSON.stringify(payload),
+                keepalive,
+                signal: controller.signal,
+            });
+            if (!response.ok)
+                throw Sender.httpError(response.status);
         }
-        const url = Sender.buildBeaconUrl(serverUrl, apiKey);
-        const blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
-        const success = navigator.sendBeacon(url, blob);
-        if (!success) {
-            throw new Error('sendBeacon rejected payload');
+        finally {
+            clearTimeout(timer);
         }
     }
-    static async fetchSend(payload, serverUrl, apiKey) {
-        const response = await fetch(serverUrl, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                apiKey,
-            },
-            body: JSON.stringify(payload),
-            keepalive: true,
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
+    static httpError(status) {
+        return new DeliveryError(`HTTP ${status}`, status === 408 || status === 429 || status >= 500);
     }
-    static async xhrSend(payload, serverUrl, apiKey) {
+    static xhrSend(payload, serverUrl, apiKey) {
         return new Promise((resolve, reject) => {
             const xhr = new XMLHttpRequest();
-            xhr.open('POST', serverUrl);
+            xhr.open('POST', serverUrl, true);
             xhr.setRequestHeader('Content-Type', 'application/json');
             xhr.setRequestHeader('apiKey', apiKey);
             xhr.timeout = 10000;
-            xhr.onload = () => {
-                if (xhr.status >= 200 && xhr.status < 300) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`HTTP ${xhr.status}: ${xhr.statusText}`));
-                }
-            };
-            xhr.onerror = () => reject(new Error('XHR network error'));
-            xhr.ontimeout = () => reject(new Error('XHR timeout'));
+            xhr.onload = () => xhr.status >= 200 && xhr.status < 300 ? resolve() : reject(Sender.httpError(xhr.status));
+            xhr.onerror = () => reject(new DeliveryError('XHR network error', true));
+            xhr.ontimeout = () => reject(new DeliveryError('XHR timeout', true));
+            xhr.onabort = () => reject(new DeliveryError('XHR aborted', true));
             xhr.send(JSON.stringify(payload));
         });
     }
     static supportsKeepalive() {
-        try {
-            return typeof Request !== 'undefined' && 'keepalive' in Request.prototype;
-        }
-        catch {
-            return false;
-        }
-    }
-    static buildBeaconUrl(serverUrl, apiKey) {
-        const separator = serverUrl.includes('?') ? '&' : '?';
-        return `${serverUrl}${separator}apiKey=${encodeURIComponent(apiKey)}`;
+        return typeof Request !== 'undefined' && 'keepalive' in Request.prototype;
     }
 }