@formo/analytics 1.25.0 → 1.27.0

package/dist/esm/src/fetch/index.js

@@ -0,0 +1,124 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function fetchWithRetry(input, init) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b, retries, retryDelay, retryOn, fetchInit, _loop_1, attempt, state_1;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _a = init || {}, _b = _a.retries, retries = _b === void 0 ? 0 : _b, retryDelay = _a.retryDelay, retryOn = _a.retryOn, fetchInit = __rest(_a, ["retries", "retryDelay", "retryOn"]);
+                    _loop_1 = function (attempt) {
+                        var isLastAttempt, response, responseError, error_1;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0:
+                                    isLastAttempt = attempt === retries;
+                                    _d.label = 1;
+                                case 1:
+                                    _d.trys.push([1, 6, , 10]);
+                                    return [4 /*yield*/, globalThis.fetch(input, fetchInit)];
+                                case 2:
+                                    response = _d.sent();
+                                    if (response.ok) {
+                                        return [2 /*return*/, { value: response }];
+                                    }
+                                    // On the last attempt, return whatever we got
+                                    if (isLastAttempt) {
+                                        return [2 /*return*/, { value: response }];
+                                    }
+                                    responseError = new Error(response.statusText);
+                                    responseError.response = response;
+                                    if (!(retryOn === null || retryOn === void 0 ? void 0 : retryOn(attempt, responseError, response))) return [3 /*break*/, 5];
+                                    if (!retryDelay) return [3 /*break*/, 4];
+                                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, retryDelay(attempt)); })];
+                                case 3:
+                                    _d.sent();
+                                    _d.label = 4;
+                                case 4: return [2 /*return*/, "continue"];
+                                case 5: return [2 /*return*/, { value: response }];
+                                case 6:
+                                    error_1 = _d.sent();
+                                    // On the last attempt, throw immediately
+                                    if (isLastAttempt) {
+                                        throw error_1;
+                                    }
+                                    if (!(retryOn === null || retryOn === void 0 ? void 0 : retryOn(attempt, error_1, null))) return [3 /*break*/, 9];
+                                    if (!retryDelay) return [3 /*break*/, 8];
+                                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, retryDelay(attempt)); })];
+                                case 7:
+                                    _d.sent();
+                                    _d.label = 8;
+                                case 8: return [2 /*return*/, "continue"];
+                                case 9: throw error_1;
+                                case 10: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    attempt = 0;
+                    _c.label = 1;
+                case 1:
+                    if (!(attempt <= retries)) return [3 /*break*/, 4];
+                    return [5 /*yield**/, _loop_1(attempt)];
+                case 2:
+                    state_1 = _c.sent();
+                    if (typeof state_1 === "object")
+                        return [2 /*return*/, state_1.value];
+                    _c.label = 3;
+                case 3:
+                    attempt++;
+                    return [3 /*break*/, 1];
+                case 4: 
+                // Unreachable — the loop always returns or throws on the last attempt.
+                // Required to satisfy TypeScript's control flow analysis.
+                throw new Error("Unexpected: retry loop exited without returning or throwing");
+            }
+        });
+    });
+}
+export default fetchWithRetry;
+//# sourceMappingURL=index.js.map

package/dist/esm/src/provider/detection.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Provider detection utilities for identifying wallet providers
+ */
+import { EIP1193Provider } from "../types";
+/**
+ * Default icon for providers without custom icons
+ */
+export declare const DEFAULT_PROVIDER_ICON: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIiBmaWxsPSIjRkZGIi8+CjxwYXRoIGQ9Ik0xNiA4TDggMjRoMTZMMTYgOHoiIGZpbGw9IiMzMzMiLz4KPC9zdmc+Cg==";
+/**
+ * Common wallet provider flags used for detection
+ */
+export interface WalletProviderFlags {
+    isMetaMask?: boolean;
+    isCoinbaseWallet?: boolean;
+    isWalletConnect?: boolean;
+    isTrust?: boolean;
+    isBraveWallet?: boolean;
+    isPhantom?: boolean;
+}
+/**
+ * Provider information returned by detection
+ */
+export interface ProviderInfo {
+    name: string;
+    rdns: string;
+    uuid: string;
+    icon: `data:image/${string}`;
+}
+/**
+ * Attempts to detect information about an injected provider by examining
+ * common wallet-specific flags and properties.
+ *
+ * @param provider The injected provider to analyze
+ * @returns Provider information with fallback values if detection fails
+ *
+ * @example
+ * ```typescript
+ * const provider = window.ethereum;
+ * const info = detectInjectedProviderInfo(provider);
+ * console.log(info.name); // "MetaMask" or "Injected Provider"
+ * ```
+ */
+export declare function detectInjectedProviderInfo(provider: EIP1193Provider): ProviderInfo;
+/**
+ * Validates that a provider implements the required EIP-1193 interface
+ *
+ * @param provider The provider to validate
+ * @returns true if the provider has all required methods
+ *
+ * @example
+ * ```typescript
+ * if (isValidProvider(window.ethereum)) {
+ *   // Safe to use provider
+ * }
+ * ```
+ */
+export declare function isValidProvider(provider: EIP1193Provider | undefined | null): provider is EIP1193Provider;
+//# sourceMappingURL=detection.d.ts.map

package/dist/esm/src/provider/detection.js

@@ -0,0 +1,98 @@
+/**
+ * Provider detection utilities for identifying wallet providers
+ */
+/**
+ * Default icon for providers without custom icons
+ */
+export var DEFAULT_PROVIDER_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIiBmaWxsPSIjRkZGIi8+CjxwYXRoIGQ9Ik0xNiA4TDggMjRoMTZMMTYgOHoiIGZpbGw9IiMzMzMiLz4KPC9zdmc+Cg==";
+/**
+ * Known wallet providers with their identifying flags and metadata
+ */
+var KNOWN_PROVIDERS = [
+    {
+        flag: 'isMetaMask',
+        name: 'MetaMask',
+        rdns: 'io.metamask',
+    },
+    {
+        flag: 'isCoinbaseWallet',
+        name: 'Coinbase Wallet',
+        rdns: 'com.coinbase.wallet',
+    },
+    {
+        flag: 'isWalletConnect',
+        name: 'WalletConnect',
+        rdns: 'com.walletconnect',
+    },
+    {
+        flag: 'isTrust',
+        name: 'Trust Wallet',
+        rdns: 'com.trustwallet',
+    },
+    {
+        flag: 'isBraveWallet',
+        name: 'Brave Wallet',
+        rdns: 'com.brave.wallet',
+    },
+    {
+        flag: 'isPhantom',
+        name: 'Phantom',
+        rdns: 'app.phantom',
+    },
+];
+/**
+ * Attempts to detect information about an injected provider by examining
+ * common wallet-specific flags and properties.
+ *
+ * @param provider The injected provider to analyze
+ * @returns Provider information with fallback values if detection fails
+ *
+ * @example
+ * ```typescript
+ * const provider = window.ethereum;
+ * const info = detectInjectedProviderInfo(provider);
+ * console.log(info.name); // "MetaMask" or "Injected Provider"
+ * ```
+ */
+export function detectInjectedProviderInfo(provider) {
+    // Default values for unknown providers
+    var name = "Injected Provider";
+    var rdns = "io.injected.provider";
+    // Cast to check for wallet-specific flags
+    var flags = provider;
+    // Check known providers in order of precedence
+    for (var _i = 0, KNOWN_PROVIDERS_1 = KNOWN_PROVIDERS; _i < KNOWN_PROVIDERS_1.length; _i++) {
+        var knownProvider = KNOWN_PROVIDERS_1[_i];
+        if (flags[knownProvider.flag]) {
+            name = knownProvider.name;
+            rdns = knownProvider.rdns;
+            break;
+        }
+    }
+    return {
+        name: name,
+        rdns: rdns,
+        uuid: "injected-".concat(rdns.replace(/[^a-zA-Z0-9]/g, "-")),
+        icon: DEFAULT_PROVIDER_ICON,
+    };
+}
+/**
+ * Validates that a provider implements the required EIP-1193 interface
+ *
+ * @param provider The provider to validate
+ * @returns true if the provider has all required methods
+ *
+ * @example
+ * ```typescript
+ * if (isValidProvider(window.ethereum)) {
+ *   // Safe to use provider
+ * }
+ * ```
+ */
+export function isValidProvider(provider) {
+    return (!!provider &&
+        typeof provider.request === "function" &&
+        typeof provider.on === "function" &&
+        typeof provider.removeListener === "function");
+}
+//# sourceMappingURL=detection.js.map

package/dist/esm/src/provider/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provider-related exports
+ */
+export { detectInjectedProviderInfo, isValidProvider, DEFAULT_PROVIDER_ICON, } from './detection';
+export type { WalletProviderFlags, ProviderInfo, } from './detection';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/provider/index.js

@@ -0,0 +1,5 @@
+/**
+ * Provider-related exports
+ */
+export { detectInjectedProviderInfo, isValidProvider, DEFAULT_PROVIDER_ICON, } from './detection';
+//# sourceMappingURL=index.js.map

package/dist/esm/src/queue/EventQueue.d.ts

@@ -0,0 +1,56 @@
+import { IFormoEvent, IFormoEventPayload } from "../types";
+import { IEventQueue } from "./type";
+type IFormoEventFlushPayload = IFormoEventPayload & {
+    sent_at: string;
+};
+type Options = {
+    apiHost: string;
+    flushAt?: number;
+    flushInterval?: number;
+    host?: string;
+    retryCount?: number;
+    errorHandler?: any;
+    maxQueueSize?: number;
+};
+export declare class EventQueue implements IEventQueue {
+    private writeKey;
+    private apiHost;
+    private queue;
+    private timer;
+    private flushAt;
+    private flushIntervalMs;
+    private flushed;
+    private maxQueueSize;
+    private errorHandler;
+    private retryCount;
+    private pendingFlush;
+    private payloadHashes;
+    constructor(writeKey: string, options: Options);
+    private generateMessageId;
+    enqueue(event: IFormoEvent, callback?: (...args: any) => void): Promise<void>;
+    flush(callback?: (...args: any) => void): Promise<void | IFormoEventFlushPayload[]>;
+    /**
+     * Returns the UTF-8 byte length of a string. The browser's keepalive limit
+     * is enforced on the wire (UTF-8 bytes), not on JS string length (UTF-16
+     * code units). Non-ASCII characters (CJK, emoji) can be 2–4x larger in
+     * UTF-8 than their string .length suggests.
+     */
+    private static byteLength;
+    /**
+     * Splits events into batches that respect the browser's 64KB keepalive
+     * payload size limit. Each batch pairs its serialized data with the
+     * original queue items (for per-item callback reporting) and a flag
+     * indicating whether keepalive is safe to use.
+     */
+    private splitIntoBatches;
+    /**
+     * Sends batches sequentially, notifying per-item callbacks on success/failure.
+     * Returns the first error encountered (if any) so the caller can report it.
+     */
+    private sendBatches;
+    private isErrorRetryable;
+    private isDuplicate;
+    private onPageLeave;
+}
+export {};
+//# sourceMappingURL=EventQueue.d.ts.map

package/dist/esm/src/{lib/queue → queue}/EventQueue.js

@@ -45,12 +45,22 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import { isNetworkError } from "../../validators";
-import { clampNumber, getActionDescriptor, hash, millisecondsToSecond, toDateHourMinute, } from "../../utils";
+import { isNetworkError } from "../validators";
+import { clampNumber, getActionDescriptor, hash, millisecondsToSecond, toDateHourMinute, } from "../utils";
 import { logger } from "../logger";
-import { EVENTS_API_REQUEST_HEADER } from "../../constants";
+import { EVENTS_API_REQUEST_HEADER } from "../constants";
 import fetch from "../fetch";
 var noop = function () { };
+var safeCall = function (fn) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    try {
+        fn.apply(void 0, args);
+    }
+    catch ( /* swallow */_a) { /* swallow */ }
+};
 var DEFAULT_RETRY = 3;
 var MAX_RETRY = 5;
 var MIN_RETRY = 1;
@@ -60,6 +70,10 @@ var MIN_FLUSH_AT = 1;
 var DEFAULT_QUEUE_SIZE = 1024 * 500; // 500kB
 var MAX_QUEUE_SIZE = 1024 * 500; // 500kB
 var MIN_QUEUE_SIZE = 200; // 200 bytes
+// Browsers enforce a 64KB limit on the total body size of in-flight
+// keepalive fetch requests. Payloads exceeding this are silently cancelled,
+// producing a TypeError: Failed to fetch that cannot be resolved by retrying.
+var KEEPALIVE_PAYLOAD_LIMIT = 64 * 1024; // 64kB
 var DEFAULT_FLUSH_INTERVAL = 1000 * 30; // 1 MINUTE
 var MAX_FLUSH_INTERVAL = 1000 * 300; // 5 MINUTES
 var MIN_FLUSH_INTERVAL = 1000 * 10; // 10 SECONDS
@@ -144,7 +158,6 @@ var EventQueue = /** @class */ (function () {
             });
         }); });
     }
-    //#region Public functions
     EventQueue.prototype.generateMessageId = function (event) {
         return __awaiter(this, void 0, void 0, function () {
             var formattedTimestamp, eventForHashing, eventString;
@@ -200,7 +213,7 @@ var EventQueue = /** @class */ (function () {
     };
     EventQueue.prototype.flush = function (callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var err_1, items, sentAt, data, done;
+            var items, sentAt, data, batches;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -214,75 +227,171 @@ var EventQueue = /** @class */ (function () {
                             callback();
                             return [2 /*return*/, Promise.resolve()];
                         }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 4, , 5]);
-                        if (!this.pendingFlush) return [3 /*break*/, 3];
+                        if (!this.pendingFlush) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.pendingFlush];
-                    case 2:
+                    case 1:
                         _a.sent();
-                        _a.label = 3;
-                    case 3: return [3 /*break*/, 5];
-                    case 4:
-                        err_1 = _a.sent();
-                        this.pendingFlush = null;
-                        throw err_1;
-                    case 5:
+                        _a.label = 2;
+                    case 2:
                         items = this.queue.splice(0, this.flushAt);
                         this.payloadHashes.clear();
                         sentAt = new Date().toISOString();
                         data = items.map(function (item) { return (__assign(__assign({}, item.message), { sent_at: sentAt })); });
-                        done = function (err) {
-                            items.forEach(function (_a) {
-                                var message = _a.message, callback = _a.callback;
-                                return callback(err, message, data);
-                            });
-                            callback(err, data);
-                        };
-                        return [2 /*return*/, (this.pendingFlush = fetch("".concat(this.apiHost), {
-                                headers: EVENTS_API_REQUEST_HEADER(this.writeKey),
-                                method: "POST",
-                                body: JSON.stringify(data),
-                                keepalive: true,
-                                retries: this.retryCount,
-                                retryDelay: function (attempt) { return Math.pow(2, attempt) * 1000; }, // exponential backoff
-                                retryOn: function (_, error) { return _this.isErrorRetryable(error); },
-                            })
-                                .then(function () {
-                                done();
+                        batches = this.splitIntoBatches(items, data);
+                        return [2 /*return*/, (this.pendingFlush = this.sendBatches(batches, data)
+                                .then(function (firstError) {
+                                if (firstError) {
+                                    safeCall(callback, firstError, data);
+                                    if (typeof _this.errorHandler === "function") {
+                                        safeCall(_this.errorHandler, firstError);
+                                    }
+                                }
+                                else {
+                                    safeCall(callback, undefined, data);
+                                }
                                 return Promise.resolve(data);
                             })
                                 .catch(function (err) {
+                                // Defensive: should not be reachable since sendBatches catches
+                                // all errors internally, but guard against unexpected failures.
+                                safeCall(callback, err, data);
                                 if (typeof _this.errorHandler === "function") {
-                                    done(err);
-                                    return _this.errorHandler(err);
-                                }
-                                if (err.response) {
-                                    var error = new Error(err.response.statusText);
-                                    done(error);
-                                    throw error;
+                                    safeCall(_this.errorHandler, err);
                                 }
-                                done(err);
-                                throw err;
+                                // Do NOT re-throw — analytics errors should never
+                                // propagate as unhandled rejections to the host app
                             }))];
                 }
             });
         });
     };
-    //#region Utility functions
-    EventQueue.prototype.isErrorRetryable = function (error) {
-        var _a, _b, _c;
+    /**
+     * Returns the UTF-8 byte length of a string. The browser's keepalive limit
+     * is enforced on the wire (UTF-8 bytes), not on JS string length (UTF-16
+     * code units). Non-ASCII characters (CJK, emoji) can be 2–4x larger in
+     * UTF-8 than their string .length suggests.
+     */
+    EventQueue.byteLength = function (str) {
+        return new TextEncoder().encode(str).byteLength;
+    };
+    /**
+     * Splits events into batches that respect the browser's 64KB keepalive
+     * payload size limit. Each batch pairs its serialized data with the
+     * original queue items (for per-item callback reporting) and a flag
+     * indicating whether keepalive is safe to use.
+     */
+    EventQueue.prototype.splitIntoBatches = function (items, data) {
+        var serialized = JSON.stringify(data);
+        if (EventQueue.byteLength(serialized) <= KEEPALIVE_PAYLOAD_LIMIT) {
+            return [{ data: data, items: items, keepalive: true }];
+        }
+        var batches = [];
+        var currentData = [];
+        var currentItems = [];
+        var currentSize = 2; // account for JSON array brackets "[]"
+        for (var i = 0; i < data.length; i++) {
+            var event_1 = data[i];
+            var eventSize = EventQueue.byteLength(JSON.stringify(event_1));
+            var sizeWithEvent = currentSize + (currentData.length > 0 ? 1 : 0) + eventSize;
+            if (sizeWithEvent > KEEPALIVE_PAYLOAD_LIMIT) {
+                if (currentData.length > 0) {
+                    batches.push({ data: currentData, items: currentItems, keepalive: true });
+                }
+                // If a single event exceeds the limit, send it without keepalive
+                if (eventSize + 2 > KEEPALIVE_PAYLOAD_LIMIT) {
+                    batches.push({ data: [event_1], items: [items[i]], keepalive: false });
+                    currentData = [];
+                    currentItems = [];
+                    currentSize = 2;
+                }
+                else {
+                    currentData = [event_1];
+                    currentItems = [items[i]];
+                    currentSize = 2 + eventSize;
+                }
+            }
+            else {
+                currentData.push(event_1);
+                currentItems.push(items[i]);
+                currentSize = sizeWithEvent;
+            }
+        }
+        if (currentData.length > 0) {
+            batches.push({ data: currentData, items: currentItems, keepalive: true });
+        }
+        return batches;
+    };
+    /**
+     * Sends batches sequentially, notifying per-item callbacks on success/failure.
+     * Returns the first error encountered (if any) so the caller can report it.
+     */
+    EventQueue.prototype.sendBatches = function (batches, allData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var firstError, _i, batches_1, batch, body, response, error, err_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _i = 0, batches_1 = batches;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < batches_1.length)) return [3 /*break*/, 6];
+                        batch = batches_1[_i];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        body = JSON.stringify(batch.data);
+                        return [4 /*yield*/, fetch("".concat(this.apiHost), {
+                                headers: EVENTS_API_REQUEST_HEADER(this.writeKey),
+                                method: "POST",
+                                body: body,
+                                keepalive: batch.keepalive,
+                                retries: this.retryCount,
+                                retryDelay: function (attempt) { return Math.pow(2, attempt) * 1000; },
+                                retryOn: function (_, error, response) { return _this.isErrorRetryable(error, response); },
+                            })];
+                    case 3:
+                        response = _a.sent();
+                        if (!response.ok) {
+                            error = new Error(response.statusText || "HTTP ".concat(response.status));
+                            error.response = response;
+                            throw error;
+                        }
+                        batch.items.forEach(function (_a) {
+                            var message = _a.message, cb = _a.callback;
+                            return safeCall(cb, undefined, message, allData);
+                        });
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        firstError = firstError || err_1;
+                        batch.items.forEach(function (_a) {
+                            var message = _a.message, cb = _a.callback;
+                            return safeCall(cb, err_1, message, allData);
+                        });
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/, firstError];
+                }
+            });
+        });
+    };
+    EventQueue.prototype.isErrorRetryable = function (error, response) {
+        var _a, _b;
         // Retry Network Errors.
-        if (isNetworkError(error))
+        if (error && isNetworkError(error))
             return true;
-        // Cannot determine if the request can be retried
-        if (!(error === null || error === void 0 ? void 0 : error.response))
+        // Check response status if available
+        var status = (_a = response === null || response === void 0 ? void 0 : response.status) !== null && _a !== void 0 ? _a : (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status;
+        if (!status)
             return false;
         // Retry Server Errors (5xx).
-        if (((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status) >= 500 && ((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status) <= 599)
+        if (status >= 500 && status <= 599)
             return true;
         // Retry if rate limited.
-        if (((_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.status) === 429)
+        if (status === 429)
             return true;
         return false;
     };

package/dist/{cjs/src/lib → esm/src}/queue/type.d.ts

@@ -1,4 +1,4 @@
-import { IFormoEvent } from "../../types";
+import { IFormoEvent } from "../types";
 export interface IEventQueue {
     enqueue(event: IFormoEvent, callback?: (...args: any) => void): Promise<void>;
     flush(callback?: (...args: any) => void): Promise<any>;