@newrelic/browser-agent 1.232.1 → 1.233.0

package/dist/esm/common/session/session-entity.js

@@ -8,19 +8,27 @@ import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, PREFIX } from './constants';
 import { LocalMemory } from '../storage/local-memory';
 import { InteractionTimer } from '../timer/interaction-timer';
 import { wrapEvents } from '../wrap';
-import { Configurable } from '../config/state/configurable';
+import { getModeledObject } from '../config/state/configurable';
 import { handle } from '../event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
 import { FEATURE_NAMES } from '../../loaders/features/features';
+
+// this is what can be stored in local storage (not enforced but probably should be)
+// these values should sync between local storage and the parent class props
 const model = {
   value: '',
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplayActive: false,
+  sessionReplay: 0,
   sessionTraceActive: false,
   custom: {}
 };
+export const SESSION_EVENTS = {
+  PAUSE: 'session-pause',
+  RESET: 'session-reset',
+  RESUME: 'session-resume'
+};
 export class SessionEntity {
   /**
    * Create a self-managing Session Entity. This entity is scoped to the agent identifier which triggered it, allowing for multiple simultaneous session objects to exist.
@@ -42,13 +50,13 @@ export class SessionEntity {
     } = _ref;
     if (!agentIdentifier || !key) throw new Error('Missing Required Fields');
     if (!isBrowserScope) this.storage = new LocalMemory();else this.storage = storageAPI;
+    this.state = {};
     this.sync(model);
     this.agentIdentifier = agentIdentifier;
-
     // key is intended to act as the k=v pair
     this.key = key;
     // value is intended to act as the primary value of the k=v pair
-    this.value = value;
+    this.state.value = value;
     this.expiresMs = expiresMs;
     this.inactiveMs = inactiveMs;
     this.ee = ee.get(agentIdentifier);
@@ -65,7 +73,7 @@ export class SessionEntity {
     // the set-up of the timer used to expire the session "naturally" at a certain time
     // this gets ignored if the value is falsy, allowing for session entities that do not expire
     if (expiresMs) {
-      this.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs);
+      this.state.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs);
       this.expiresTimer = new Timer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
@@ -73,16 +81,16 @@ export class SessionEntity {
           this.collectSM('duration', this);
           this.reset();
         }
-      }, this.expiresAt - Date.now());
+      }, this.state.expiresAt - Date.now());
     } else {
-      this.expiresAt = Infinity;
+      this.state.expiresAt = Infinity;
     }
 
     // the set-up of the timer used to expire the session due to "inactivity" at a certain time
     // this gets ignored if the value is falsy, allowing for session entities that do not expire
     // this gets "refreshed" when "activity" is observed
     if (inactiveMs) {
-      this.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs);
+      this.state.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs);
       this.inactiveTimer = new InteractionTimer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
@@ -92,21 +100,27 @@ export class SessionEntity {
         },
         // When the inactive timer refreshes, it will update the storage values with an update timestamp
         onRefresh: this.refresh.bind(this),
+        onResume: () => {
+          this.ee.emit(SESSION_EVENTS.RESUME);
+        },
         // When the inactive timer pauses, update the storage values with an update timestamp
-        onPause: () => this.write(new Configurable(this.read(), model)),
+        onPause: () => {
+          if (this.initialized) this.ee.emit(SESSION_EVENTS.PAUSE);
+          this.write(getModeledObject(this.state, model));
+        },
         ee: this.ee,
         refreshEvents: ['click', 'keydown', 'scroll']
-      }, this.inactiveAt - Date.now());
+      }, this.state.inactiveAt - Date.now());
     } else {
-      this.inactiveAt = Infinity;
+      this.state.inactiveAt = Infinity;
     }
 
     // The fact that the session is "new" or pre-existing is used in some places in the agent.  Session Replay and Trace
     // can use this info to inform whether to trust a new sampling decision vs continue a previous tracking effort.
-    this.isNew = !Object.keys(initialRead).length;
+    if (this.isNew === undefined) this.isNew = !Object.keys(initialRead).length;
     // if its a "new" session, we write to storage API with the default values.  These values may change over the lifespan of the agent run.
-    // we can use configurable here to help us know and manage what values are being used. -- see "model" above
-    if (this.isNew) this.write(new Configurable(this, model), true);else this.sync(initialRead);
+    // we can use a modeled object here to help us know and manage what values are being used. -- see "model" above
+    if (this.isNew) this.write(getModeledObject(this.state, model), true);else this.sync(initialRead);
     this.initialized = true;
   }
 
@@ -115,7 +129,7 @@ export class SessionEntity {
     return "".concat(PREFIX, "_").concat(this.key);
   }
   sync(data) {
-    Object.assign(this, data);
+    Object.assign(this.state, data);
   }
 
   /**
@@ -162,7 +176,8 @@ export class SessionEntity {
       if (!data || typeof data !== 'object') return;
       // everytime we update, we can update a timestamp for sanity
       data.updatedAt = Date.now();
-      this.sync(data);
+      this.sync(data); // update the parent class "state" properties with the local storage values
+      //
       // TODO - compression would need happen here if we decide to do it
       this.storage.set(this.lookupKey, stringify(data));
       return data;
@@ -178,12 +193,11 @@ export class SessionEntity {
     // * stop recording (stn and sr)...
     // * delete the session and start over
     try {
-      if (this.initialized) this.ee.emit('session-reset');
+      if (this.initialized) this.ee.emit(SESSION_EVENTS.RESET);
       this.storage.remove(this.lookupKey);
       this.inactiveTimer?.abort?.();
       this.expiresTimer?.clear?.();
-      delete this.custom;
-      delete this.value;
+      delete this.isNew;
       this.setup({
         agentIdentifier: this.agentIdentifier,
         key: this.key,
@@ -203,10 +217,9 @@ export class SessionEntity {
   refresh() {
     // read here & invalidate
     const existingData = this.read();
-    this.inactiveAt = this.getFutureTimestamp(this.inactiveMs);
     this.write({
       ...existingData,
-      inactiveAt: this.inactiveAt
+      inactiveAt: this.getFutureTimestamp(this.inactiveMs)
     });
   }
 
@@ -223,7 +236,7 @@ export class SessionEntity {
    * @returns {boolean}
    */
   isInvalid(data) {
-    const requiredKeys = ['value', 'expiresAt', 'inactiveAt'];
+    const requiredKeys = Object.keys(model);
     return !requiredKeys.every(x => Object.keys(data).includes(x));
   }
   collectSM(type, data, useUpdatedAt) {

package/dist/esm/common/session/session-entity.test.js

@@ -36,17 +36,19 @@ describe('constructor', () => {
     expect(session).toMatchObject({
       agentIdentifier: expect.any(String),
       key: expect.any(String),
-      value: expect.any(String),
       expiresMs: expect.any(Number),
-      expiresAt: expect.any(Number),
       expiresTimer: expect.any(Object),
       inactiveMs: expect.any(Number),
-      inactiveAt: expect.any(Number),
       inactiveTimer: expect.any(Object),
       isNew: expect.any(Boolean),
-      sessionReplayActive: expect.any(Boolean),
-      sessionTraceActive: expect.any(Boolean),
-      storage: expect.any(Object)
+      storage: expect.any(Object),
+      state: expect.objectContaining({
+        value: expect.any(String),
+        expiresAt: expect.any(Number),
+        inactiveAt: expect.any(Number),
+        sessionReplay: expect.any(Number),
+        sessionTraceActive: expect.any(Boolean)
+      })
     });
   });
   test('can use sane defaults', () => {
@@ -54,11 +56,12 @@ describe('constructor', () => {
       agentIdentifier,
       key
     });
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -79,7 +82,7 @@ describe('constructor', () => {
       key,
       expiresMs: 100
     });
-    expect(session.expiresAt).toEqual(now + 100);
+    expect(session.state.expiresAt).toEqual(now + 100);
   });
   test('expiresAt is the correct future timestamp - existing session', () => {
     const now = Date.now();
@@ -88,7 +91,11 @@ describe('constructor', () => {
       ["".concat(PREFIX, "_").concat(key)]: {
         value,
         expiresAt: now + 5000,
-        inactiveAt: Infinity
+        inactiveAt: Infinity,
+        updatedAt: now,
+        sessionReplay: 0,
+        sessionTraceActive: false,
+        custom: {}
       }
     });
     const session = new SessionEntity({
@@ -97,7 +104,7 @@ describe('constructor', () => {
       expiresMs: 100,
       storageAPI: existingData
     });
-    expect(session.expiresAt).toEqual(now + 5000);
+    expect(session.state.expiresAt).toEqual(now + 5000);
   });
   test('expiresAt never expires if 0', () => {
     const session = new SessionEntity({
@@ -105,7 +112,7 @@ describe('constructor', () => {
       key,
       expiresMs: 0
     });
-    expect(session.expiresAt).toEqual(Infinity);
+    expect(session.state.expiresAt).toEqual(Infinity);
   });
   test('inactiveAt is the correct future timestamp - new session', () => {
     const now = Date.now();
@@ -115,7 +122,7 @@ describe('constructor', () => {
       key,
       inactiveMs: 100
     });
-    expect(session.inactiveAt).toEqual(now + 100);
+    expect(session.state.inactiveAt).toEqual(now + 100);
   });
   test('inactiveAt is the correct future timestamp - existing session', () => {
     const now = Date.now();
@@ -124,7 +131,11 @@ describe('constructor', () => {
       ["".concat(PREFIX, "_").concat(key)]: {
         value,
         inactiveAt: now + 5000,
-        expiresAt: Infinity
+        expiresAt: Infinity,
+        updatedAt: now,
+        sessionReplay: 0,
+        sessionTraceActive: false,
+        custom: {}
       }
     });
     const session = new SessionEntity({
@@ -133,7 +144,7 @@ describe('constructor', () => {
       inactiveMs: 100,
       storageAPI: existingData
     });
-    expect(session.inactiveAt).toEqual(now + 5000);
+    expect(session.state.inactiveAt).toEqual(now + 5000);
   });
   test('inactiveAt never expires if 0', () => {
     const session = new SessionEntity({
@@ -141,7 +152,7 @@ describe('constructor', () => {
       key,
       inactiveMs: 0
     });
-    expect(session.inactiveAt).toEqual(Infinity);
+    expect(session.state.inactiveAt).toEqual(Infinity);
   });
   test('should handle isNew', () => {
     const newSession = new SessionEntity({
@@ -154,7 +165,11 @@ describe('constructor', () => {
       ["".concat(PREFIX, "_").concat(key)]: {
         value,
         expiresAt: Infinity,
-        inactiveAt: Infinity
+        inactiveAt: Infinity,
+        updatedAt: Date.now(),
+        sessionReplay: 0,
+        sessionTraceActive: false,
+        custom: {}
       }
     });
     const existingSession = new SessionEntity({
@@ -177,11 +192,12 @@ describe('constructor', () => {
       key,
       storageAPI
     });
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -200,11 +216,12 @@ describe('constructor', () => {
       key,
       storageAPI
     });
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -223,11 +240,12 @@ describe('constructor', () => {
       key,
       storageAPI
     });
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -242,10 +260,10 @@ describe('reset()', () => {
       expiresMs: 10
     });
     const sessionVal = session.value;
-    expect(session.value).toBeTruthy();
+    expect(session.state.value).toBeTruthy();
     session.reset();
-    expect(session.value).toBeTruthy();
-    expect(session.value).not.toEqual(sessionVal);
+    expect(session.state.value).toBeTruthy();
+    expect(session.state.value).not.toEqual(sessionVal);
   });
   test('custom data should be wiped on reset', () => {
     const now = Date.now();
@@ -256,12 +274,12 @@ describe('reset()', () => {
       expiresMs: 10
     });
     session.syncCustomAttribute('test', 123);
-    expect(session.custom.test).toEqual(123);
+    expect(session.state.custom.test).toEqual(123);
     expect(session.read().custom.test).toEqual(123);
 
     // simulate a timer expiring
     session.reset();
-    expect(session.custom?.test).toEqual(undefined);
+    expect(session.state.custom?.test).toEqual(undefined);
     expect(session.read()?.custom?.test).toEqual(undefined);
   });
 });
@@ -277,7 +295,7 @@ describe('read()', () => {
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }));
   });
@@ -286,7 +304,11 @@ describe('read()', () => {
       ["".concat(PREFIX, "_").concat(key)]: {
         value,
         expiresAt: Infinity,
-        inactiveAt: Infinity
+        inactiveAt: Infinity,
+        updatedAt: Date.now(),
+        sessionReplay: 0,
+        sessionTraceActive: false,
+        custom: {}
       }
     });
     const session = new SessionEntity({
@@ -308,17 +330,18 @@ describe('write()', () => {
       agentIdentifier,
       key
     });
-    expect(session.value).not.toEqual(value);
-    expect(session.expiresAt).not.toEqual(Infinity);
-    expect(session.inactiveAt).not.toEqual(Infinity);
+    expect(session.state.value).not.toEqual(value);
+    expect(session.state.expiresAt).not.toEqual(Infinity);
+    expect(session.state.inactiveAt).not.toEqual(Infinity);
     session.write({
+      ...session.state,
       value,
       expiresAt: Infinity,
       inactiveAt: Infinity
     });
-    expect(session.value).toEqual(value);
-    expect(session.expiresAt).toEqual(Infinity);
-    expect(session.inactiveAt).toEqual(Infinity);
+    expect(session.state.value).toEqual(value);
+    expect(session.state.expiresAt).toEqual(Infinity);
+    expect(session.state.inactiveAt).toEqual(Infinity);
   });
   test('write() sets data that read() can access', () => {
     const now = Date.now();
@@ -328,6 +351,7 @@ describe('write()', () => {
       key
     });
     session.write({
+      ...session.state,
       value,
       expiresAt: now + 100,
       inactiveAt: now + 100
@@ -363,10 +387,10 @@ describe('refresh()', () => {
       key,
       inactiveMs: 100
     });
-    expect(session.inactiveAt).toEqual(now + 100);
+    expect(session.state.inactiveAt).toEqual(now + 100);
     jest.setSystemTime(now + 1000);
     session.refresh();
-    expect(session.inactiveAt).toEqual(now + 100 + 1000);
+    expect(session.state.inactiveAt).toEqual(now + 100 + 1000);
   });
   test('refresh resets the entity if expiresTimer is invalid', () => {
     const now = Date.now();
@@ -376,13 +400,13 @@ describe('refresh()', () => {
       key,
       value
     });
-    expect(session.value).toEqual(value);
+    expect(session.state.value).toEqual(value);
     session.write({
-      ...session.read(),
+      ...session.state,
       expiresAt: now - 1
     });
     session.refresh();
-    expect(session.value).not.toEqual(value);
+    expect(session.state.value).not.toEqual(value);
   });
   test('refresh resets the entity if inactiveTimer is invalid', () => {
     const now = Date.now();
@@ -392,13 +416,13 @@ describe('refresh()', () => {
       key,
       value
     });
-    expect(session.value).toEqual(value);
+    expect(session.state.value).toEqual(value);
     session.write({
-      ...session.read(),
+      ...session.state,
       inactiveAt: now - 1
     });
     session.refresh();
-    expect(session.value).not.toEqual(value);
+    expect(session.state.value).not.toEqual(value);
   });
 });
 describe('syncCustomAttribute()', () => {
@@ -410,17 +434,17 @@ describe('syncCustomAttribute()', () => {
 
     // if custom has never been set, and a "delete" action is triggered, do nothing
     session.syncCustomAttribute('test', null);
-    expect(session?.custom?.test).toEqual(undefined);
+    expect(session?.state?.custom?.test).toEqual(undefined);
     session.syncCustomAttribute('test', 1);
-    expect(session?.custom?.test).toEqual(1);
+    expect(session?.state?.custom?.test).toEqual(1);
     session.syncCustomAttribute('test', 'string');
-    expect(session?.custom?.test).toEqual('string');
+    expect(session?.state?.custom?.test).toEqual('string');
     session.syncCustomAttribute('test', false);
-    expect(session?.custom?.test).toEqual(false);
+    expect(session?.state?.custom?.test).toEqual(false);
 
     // null specifically deletes the object completely
     session.syncCustomAttribute('test', null);
-    expect(session?.custom?.test).toEqual(undefined);
+    expect(session?.state?.custom?.test).toEqual(undefined);
   });
   test('Only runs in browser scope', () => {
     mockBrowserScope.mockReturnValue(false);

package/dist/esm/common/timer/interaction-timer.js

@@ -5,8 +5,9 @@ import { isBrowserScope } from '../util/global-scope';
 export class InteractionTimer extends Timer {
   constructor(opts, ms) {
     super(opts, ms);
-    this.onRefresh = opts.onRefresh;
-    this.onPause = opts.onPause;
+    this.onPause = typeof opts.onPause === 'function' ? opts.onPause : () => {/* noop */};
+    this.onRefresh = typeof opts.onRefresh === 'function' ? opts.onRefresh : () => {/* noop */};
+    this.onResume = typeof opts.onResume === 'function' ? opts.onResume : () => {/* noop */};
 
     // used by pause/resume
     this.remainingMs = undefined;
@@ -41,7 +42,10 @@ export class InteractionTimer extends Timer {
       subscribeToVisibilityChange(state => {
         if (state === 'hidden') this.pause();
         // vis change --> visible is treated like a new interaction with the page
-        else this.refresh();
+        else {
+          this.onResume();
+          this.refresh();
+        }
       }, false, false, this.abortController?.signal);
     }
   }
@@ -50,7 +54,7 @@ export class InteractionTimer extends Timer {
     this.abortController?.abort();
   }
   pause() {
-    this.onPause?.();
+    this.onPause();
     clearTimeout(this.timer);
     this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp);
   }
@@ -59,13 +63,6 @@ export class InteractionTimer extends Timer {
     this.timer = this.create(cb, ms);
     this.startTimestamp = Date.now();
     this.remainingMs = undefined;
-    this.onRefresh?.();
+    this.onRefresh();
   }
-
-  // NOT CURRENTLY UTILIZED BY ANYTHING
-  // resume () {
-  //   if (!this.remainingMs || !this.isValid()) return
-  //   this.timer = this.create(this.cb, this.remainingMs)
-  //   this.remainingMs = undefined
-  // }
 }

package/dist/esm/common/url/protocol.test.js

@@ -1,4 +1,3 @@
-import { faker } from '@faker-js/faker';
 import { isFileProtocol } from './protocol';
 test('should return true when location url contains file protocol', () => {
   jest.spyOn(window, 'location', 'get').mockReturnValue({

package/dist/esm/common/util/feature-flags.js

@@ -11,7 +11,8 @@ const bucketMap = {
   stn: [FEATURE_NAMES.sessionTrace],
   err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
   ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa]
+  spa: [FEATURE_NAMES.spa],
+  sr: [FEATURE_NAMES.sessionReplay]
 };
 export function activateFeatures(flags, agentIdentifier) {
   var sharedEE = ee.get(agentIdentifier);

package/dist/esm/common/util/submit-data.js

@@ -7,11 +7,17 @@ export const submitData = {};
 
 /**
  * Send via JSONP. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} jsonp
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string} args.jsonp - The string name of the jsonp cb method
+ * @returns {XMLHttpRequest}
  * @returns {Element}
  */
-submitData.jsonp = function jsonp(url, jsonp) {
+submitData.jsonp = function jsonp(_ref) {
+  let {
+    url,
+    jsonp
+  } = _ref;
   try {
     if (isWorkerScope) {
       try {
@@ -19,7 +25,9 @@ submitData.jsonp = function jsonp(url, jsonp) {
       } catch (e) {
         // for now theres no other way to execute the callback from ingest without jsonp, or unsafe eval / new Function calls
         // future work needs to be conducted to allow ingest to return a more traditional JSON API-like experience for the entitlement flags
-        submitData.xhrGet(url + '&jsonp=' + jsonp);
+        submitData.xhrGet({
+          url: url + '&jsonp=' + jsonp
+        });
         return false;
       }
     } else {
@@ -34,19 +42,38 @@ submitData.jsonp = function jsonp(url, jsonp) {
     // do nothing
   }
 };
-submitData.xhrGet = function xhrGet(url) {
-  return submitData.xhr(url, undefined, false, 'GET');
+submitData.xhrGet = function xhrGet(_ref2) {
+  let {
+    url
+  } = _ref2;
+  return submitData.xhr({
+    url,
+    sync: false,
+    method: 'GET'
+  });
 };
 
 /**
  * Send via XHR
- * @param {string} url
- * @param {string} body
- * @param {boolean} sync
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
+ * @param {boolean=} args.sync - Run XHR as Synchronous
+ * @param {string=} [args.method=POST] - The XHR method to use
+ * @param {{key: string, value: string}[]} [args.headers] - The headers to attach
  * @returns {XMLHttpRequest}
  */
-submitData.xhr = function xhr(url, body, sync) {
-  let method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'POST';
+submitData.xhr = function xhr(_ref3) {
+  let {
+    url,
+    body,
+    sync,
+    method = 'POST',
+    headers = [{
+      key: 'content-type',
+      value: 'text/plain'
+    }]
+  } = _ref3;
   var request = new XMLHttpRequest();
   request.open(method, url, !sync);
   try {
@@ -55,7 +82,9 @@ submitData.xhr = function xhr(url, body, sync) {
   } catch (e) {
     // do nothing
   }
-  request.setRequestHeader('content-type', 'text/plain');
+  headers.forEach(header => {
+    request.setRequestHeader(header.key, header.value);
+  });
   request.send(body);
   return request;
 };
@@ -69,10 +98,15 @@ submitData.xhr = function xhr(url, body, sync) {
 
 /**
  * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @returns {Element}
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @returns {HTMLImageElement}
  */
-submitData.img = function img(url) {
+submitData.img = function img(_ref4) {
+  let {
+    url
+  } = _ref4;
+  console.log('img url', url);
   var element = new Image();
   element.src = url;
   return element;
@@ -80,11 +114,16 @@ submitData.img = function img(url) {
 
 /**
  * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} body
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
  * @returns {boolean}
  */
-submitData.beacon = function (url, body) {
+submitData.beacon = function (_ref5) {
+  let {
+    url,
+    body
+  } = _ref5;
   // Navigator has to be bound to ensure it does not error in some browsers
   // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
   const send = window.navigator.sendBeacon.bind(window.navigator);