@hellotext/hellotext 2.4.51 → 2.4.52

package/lib/api/events.cjs

@@ -25,18 +25,28 @@ let EventsAPI = /*#__PURE__*/function () {
     key: "create",
     value: async function create({
       headers,
-      body
+      body,
+      keepalive = false
     }) {
       if (_models.Query.inPreviewMode) {
         return new _response.Response(true, {
           received: true
         });
       }
-      const response = await fetch(this.endpoint, {
+      const fetchOptions = {
         method: 'POST',
         headers,
         body: JSON.stringify(body)
-      });
+      };
+
+      // Do not send `keepalive: false`. The track caller opts in only for payloads
+      // that fit the browser keepalive budget; omitting the key for larger events
+      // preserves normal fetch behavior for rich carts/orders instead of asking
+      // the browser to use an unload-safe transport it may reject.
+      if (keepalive) {
+        fetchOptions.keepalive = true;
+      }
+      const response = await fetch(this.endpoint, fetchOptions);
       return new _response.Response(response.status === 200, await response.json());
     }
   }]);

package/lib/api/events.js

@@ -23,18 +23,28 @@ var EventsAPI = /*#__PURE__*/function () {
       var _create = _asyncToGenerator(function* (_ref) {
         var {
           headers,
-          body
+          body,
+          keepalive = false
         } = _ref;
         if (Query.inPreviewMode) {
           return new Response(true, {
             received: true
           });
         }
-        var response = yield fetch(this.endpoint, {
+        var fetchOptions = {
           method: 'POST',
           headers,
           body: JSON.stringify(body)
-        });
+        };
+
+        // Do not send `keepalive: false`. The track caller opts in only for payloads
+        // that fit the browser keepalive budget; omitting the key for larger events
+        // preserves normal fetch behavior for rich carts/orders instead of asking
+        // the browser to use an unload-safe transport it may reject.
+        if (keepalive) {
+          fetchOptions.keepalive = true;
+        }
+        var response = yield fetch(this.endpoint, fetchOptions);
         return new Response(response.status === 200, yield response.json());
       });
       function create(_x) {

package/lib/api/index.cjs

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "Response", {
   }
 });
 exports.default = void 0;
+exports.keepaliveFor = keepaliveFor;
 var _businesses = _interopRequireDefault(require("./businesses"));
 var _events = _interopRequireDefault(require("./events"));
 var _forms = _interopRequireDefault(require("./forms"));
@@ -23,6 +24,26 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+// Browsers keep `fetch(..., { keepalive: true })` requests alive during page
+// unload/navigation, which is exactly the failure mode for analytics events
+// fired from checkout redirects, form submissions, tab closes, and pixel
+// lifecycles. The platform also caps keepalive request bodies around 64KB, and
+// browsers can reject or drop oversized requests instead of making delivery
+// more reliable. Keep the limit below that ceiling so the SDK only opts in when
+// the payload is small enough for the keepalive transport contract.
+const KEEPALIVE_BODY_LIMIT = 60000;
+function keepaliveFor(body) {
+  const serializedBody = JSON.stringify(body);
+
+  // Use byte size when the runtime exposes Blob because non-ASCII JSON can be
+  // larger on the wire than its JavaScript string length. The string-length
+  // fallback keeps older/non-browser runtimes conservative without pulling in
+  // another encoder just for this transport hint.
+  if (typeof Blob === 'undefined') {
+    return serializedBody.length < KEEPALIVE_BODY_LIMIT;
+  }
+  return new Blob([serializedBody]).size < KEEPALIVE_BODY_LIMIT;
+}
 let API = /*#__PURE__*/function () {
   function API() {
     _classCallCheck(this, API);

package/lib/api/index.js

@@ -9,6 +9,27 @@ import FormsAPI from './forms';
 import IdentificationsAPI from './identifications';
 import WebchatsAPI from './webchats';
 import AcksAPI from './acks';
+
+// Browsers keep `fetch(..., { keepalive: true })` requests alive during page
+// unload/navigation, which is exactly the failure mode for analytics events
+// fired from checkout redirects, form submissions, tab closes, and pixel
+// lifecycles. The platform also caps keepalive request bodies around 64KB, and
+// browsers can reject or drop oversized requests instead of making delivery
+// more reliable. Keep the limit below that ceiling so the SDK only opts in when
+// the payload is small enough for the keepalive transport contract.
+var KEEPALIVE_BODY_LIMIT = 60000;
+function keepaliveFor(body) {
+  var serializedBody = JSON.stringify(body);
+
+  // Use byte size when the runtime exposes Blob because non-ASCII JSON can be
+  // larger on the wire than its JavaScript string length. The string-length
+  // fallback keeps older/non-browser runtimes conservative without pulling in
+  // another encoder just for this transport hint.
+  if (typeof Blob === 'undefined') {
+    return serializedBody.length < KEEPALIVE_BODY_LIMIT;
+  }
+  return new Blob([serializedBody]).size < KEEPALIVE_BODY_LIMIT;
+}
 var API = /*#__PURE__*/function () {
   function API() {
     _classCallCheck(this, API);
@@ -47,4 +68,5 @@ var API = /*#__PURE__*/function () {
   return API;
 }();
 export { API as default };
-export { Response } from './response';
+export { Response } from './response';
+export { keepaliveFor };

package/lib/hellotext.cjs

@@ -104,7 +104,12 @@ let Hellotext = /*#__PURE__*/function () {
       delete body.headers;
       return await _api.default.events.create({
         headers,
-        body
+        body,
+        // Track is the SDK's unload-sensitive analytics path. Keepalive belongs
+        // here rather than on identify/forms/webchat calls because event tracking
+        // is allowed to be fire-and-navigate, while those other calls have
+        // stronger request/response or interaction contracts.
+        keepalive: (0, _api.keepaliveFor)(body)
       });
     }
 

package/lib/hellotext.js

@@ -9,7 +9,7 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 import { Configuration, Event } from './core';
-import API, { Response } from './api';
+import API, { Response, keepaliveFor } from './api';
 import { Business, Fingerprint, FormCollection, Page, Query, Session, User, Webchat } from './models';
 import { NotInitializedError } from './errors';
 var Hellotext = /*#__PURE__*/function () {
@@ -101,7 +101,12 @@ var Hellotext = /*#__PURE__*/function () {
         delete body.headers;
         return yield API.events.create({
           headers,
-          body
+          body,
+          // Track is the SDK's unload-sensitive analytics path. Keepalive belongs
+          // here rather than on identify/forms/webchat calls because event tracking
+          // is allowed to be fire-and-navigate, while those other calls have
+          // stronger request/response or interaction contracts.
+          keepalive: keepaliveFor(body)
         });
       });
       function track(_x2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellotext/hellotext",
-  "version": "2.4.51",
+  "version": "2.4.52",
   "description": "Hellotext JavaScript Client",
   "source": "src/index.js",
   "main": "lib/index.cjs",

package/src/api/events.js

@@ -8,16 +8,26 @@ export default class EventsAPI {
     return Configuration.endpoint('track/events')
   }
 
-  static async create({ headers, body }) {
+  static async create({ headers, body, keepalive = false }) {
     if (Query.inPreviewMode) {
       return new Response(true, { received: true })
     }
 
-    const response = await fetch(this.endpoint, {
+    const fetchOptions = {
       method: 'POST',
       headers,
       body: JSON.stringify(body),
-    })
+    }
+
+    // Do not send `keepalive: false`. The track caller opts in only for payloads
+    // that fit the browser keepalive budget; omitting the key for larger events
+    // preserves normal fetch behavior for rich carts/orders instead of asking
+    // the browser to use an unload-safe transport it may reject.
+    if (keepalive) {
+      fetchOptions.keepalive = true
+    }
+
+    const response = await fetch(this.endpoint, fetchOptions)
 
     return new Response(response.status === 200, await response.json())
   }

package/src/api/index.js

@@ -5,6 +5,29 @@ import IdentificationsAPI from './identifications'
 import WebchatsAPI from './webchats'
 import AcksAPI from './acks'
 
+// Browsers keep `fetch(..., { keepalive: true })` requests alive during page
+// unload/navigation, which is exactly the failure mode for analytics events
+// fired from checkout redirects, form submissions, tab closes, and pixel
+// lifecycles. The platform also caps keepalive request bodies around 64KB, and
+// browsers can reject or drop oversized requests instead of making delivery
+// more reliable. Keep the limit below that ceiling so the SDK only opts in when
+// the payload is small enough for the keepalive transport contract.
+const KEEPALIVE_BODY_LIMIT = 60000
+
+function keepaliveFor(body) {
+  const serializedBody = JSON.stringify(body)
+
+  // Use byte size when the runtime exposes Blob because non-ASCII JSON can be
+  // larger on the wire than its JavaScript string length. The string-length
+  // fallback keeps older/non-browser runtimes conservative without pulling in
+  // another encoder just for this transport hint.
+  if (typeof Blob === 'undefined') {
+    return serializedBody.length < KEEPALIVE_BODY_LIMIT
+  }
+
+  return new Blob([serializedBody]).size < KEEPALIVE_BODY_LIMIT
+}
+
 export default class API {
   static get businesses() {
     return BusinessesAPI
@@ -32,3 +55,4 @@ export default class API {
 }
 
 export { Response } from './response'
+export { keepaliveFor }

package/src/hellotext.js

@@ -1,6 +1,6 @@
 import { Configuration, Event } from './core'
 
-import API, { Response } from './api'
+import API, { Response, keepaliveFor } from './api'
 import { Business, Fingerprint, FormCollection, Page, Query, Session, User, Webchat } from './models'
 
 import { NotInitializedError } from './errors'
@@ -108,6 +108,11 @@ class Hellotext {
     return await API.events.create({
       headers,
       body,
+      // Track is the SDK's unload-sensitive analytics path. Keepalive belongs
+      // here rather than on identify/forms/webchat calls because event tracking
+      // is allowed to be fire-and-navigate, while those other calls have
+      // stronger request/response or interaction contracts.
+      keepalive: keepaliveFor(body),
     })
   }