@newrelic/browser-agent 1.234.0 → 1.236.0

package/dist/esm/features/utils/handler-cache.js

@@ -8,49 +8,54 @@ export class HandlerCache {
   #cache = [];
   /** @private @type {Timeout} */
   #settleTimer = setTimeout(() => this.#close(), 5000);
+  #noMoreChanges = false;
 
   /**
-     * tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
-     * and execute all the storage callbacks saved up in the handlerCache
-     * @private
-     */
+   * tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
+   * and execute all the storage callbacks saved up in the handlerCache
+   * @private
+   */
   #drain() {
     this.#cache.forEach(h => h());
-    this.#cache = [];
-    clearTimeout(this.#settleTimer);
+    this.#close();
   }
 
   /**
-     * tell the handlerCache not to execute any of the storage callbacks
-     * and wipe out all the storage callbacks saved up in the handlerCache
-     * @private
-     */
+   * tell the handlerCache not to execute any of the storage callbacks
+   * and wipe out all the storage callbacks saved up in the handlerCache
+   * @private
+   */
   #close() {
-    this.#decision = false; // settle() & decide() cannot be used after close
     this.#cache = [];
+    clearTimeout(this.#settleTimer);
   }
 
   /**
-     * Wrap callback functions with this method to defer their execution until a decision has been reached
-     * @param {Function} handler
-     * @returns {void}
-     */
+   * Wrap callback functions with this method to defer their execution until a decision has been reached
+   * @param {Function} handler
+   * @returns {void}
+   */
   settle(handler) {
     if (this.#decision === false) return;else if (this.#decision === undefined) this.#cache.push(handler);else handler();
   }
 
   /**
-     * Make a decision about what to do with the cache of callbacks.
-     * --- if true: tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
-     * and execute all the storage callbacks saved up in the handlerCache ---
-     * --- if false: tell the handlerCache not to execute any of the storage callbacks
-     * and wipe out all the storage callbacks saved up in the handlerCache
-     * @param {boolean} decision
-     */
+   * Make a decision about what to do with the cache of callbacks.
+   * --- if true: tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
+   * and execute all the storage callbacks saved up in the handlerCache ---
+   * --- if false: tell the handlerCache not to execute any of the storage callbacks
+   * and wipe out all the storage callbacks saved up in the handlerCache
+   * @param {boolean} decision
+   */
   decide(decision) {
-    if (this.#decision !== undefined) return; // a decision can only be made once
+    if (this.#noMoreChanges) return;
     this.#decision = decision;
     if (decision === false) this.#close();
     if (decision === true) this.#drain();
   }
+  permanentlyDecide(decision) {
+    if (this.#noMoreChanges) return;
+    this.decide(decision);
+    this.#noMoreChanges = true;
+  }
 }

package/dist/esm/features/utils/instrument-base.js

@@ -7,7 +7,7 @@
 import { drain, registerDrain } from '../../common/drain/drain';
 import { FeatureBase } from './feature-base';
 import { onWindowLoad } from '../../common/window/load';
-import { isWorkerScope } from '../../common/util/global-scope';
+import { isBrowserScope } from '../../common/constants/runtime';
 import { warn } from '../../common/util/console';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 import { getConfigurationValue } from '../../common/config/config';
@@ -29,11 +29,20 @@ export class InstrumentBase extends FeatureBase {
   constructor(agentIdentifier, aggregator, featureName) {
     let auto = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
     super(agentIdentifier, aggregator, featureName);
-    this.hasAggregator = false;
     this.auto = auto;
 
     /** @type {Function | undefined} This should be set by any derived Instrument class if it has things to do when feature fails or is killed. */
     this.abortHandler;
+    /**
+     * @type {Class} Holds the reference to the feature's aggregate module counterpart, if and after it has been initialized. This may not be assigned until after page loads!
+     * The only purpose of this for now is to expose it to the NREUM interface, as the feature's instrument instance is already exposed.
+    */
+    this.featAggregate;
+    /**
+     * @type {Promise} Assigned immediately after @see importAggregator runs. Serves as a signal for when the inner async fn finishes execution. Useful for features to await
+     * one another if there are inter-features dependencies.
+    */
+    this.onAggregateImported;
     if (auto) registerDrain(agentIdentifier, featureName);
   }
 
@@ -43,65 +52,74 @@ export class InstrumentBase extends FeatureBase {
    * @param {Object} [argsObjFromInstrument] - any values or references to pass down to aggregate
    * @returns void
    */
-  importAggregator(argsObjFromInstrument) {
-    if (this.hasAggregator || !this.auto) return;
-    this.hasAggregator = true;
-    let session, agentSessionImport;
-    if (getConfigurationValue(this.agentIdentifier, 'privacy.cookies_enabled') === true && !isWorkerScope) {
-      agentSessionImport = import( /* webpackChunkName: "session-manager" */'./agent-session').catch(err => {
-        warn('failed to import the session manager', err);
-      });
-    }
+  importAggregator() {
+    let argsObjFromInstrument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (this.featAggregate || !this.auto) return;
+    const enableSessionTracking = isBrowserScope && getConfigurationValue(this.agentIdentifier, 'privacy.cookies_enabled') === true;
+    let loadedSuccessfully, loadFailed;
+    this.onAggregateImported = new Promise(resolve => {
+      loadedSuccessfully = resolve;
+    });
     const importLater = async () => {
-      /**
-       * Note this try-catch differs from the one in Agent.start() in that it's placed later in a page's lifecycle and
-       * it's only responsible for aborting its one specific feature, rather than all.
-       */
+      let session;
       try {
-        // The session entity needs to be attached to the config internals before the aggregator chunk runs
-        if (agentSessionImport && !session) {
+        if (enableSessionTracking) {
+          // would require some setup before certain features start
           const {
             setupAgentSession
-          } = await agentSessionImport;
+          } = await import( /* webpackChunkName: "session-manager" */'./agent-session');
           session = setupAgentSession(this.agentIdentifier);
         }
-        if (!shouldImportAgg(this.featureName, session)) {
+      } catch (e) {
+        warn('A problem occurred when starting up session manager. This page will not start or extend any session.', e);
+      }
+
+      /**
+       * Note this try-catch differs from the one in Agent.start() in that it's placed later in a page's lifecycle and
+       * it's only responsible for aborting its one specific feature, rather than all.
+       */
+      try {
+        if (!this.shouldImportAgg(this.featureName, session)) {
           drain(this.agentIdentifier, this.featureName);
           return;
         }
-
-        // import and instantiate the aggregator chunk
         const {
           lazyFeatureLoader
         } = await import( /* webpackChunkName: "lazy-feature-loader" */'./lazy-feature-loader');
         const {
           Aggregate
         } = await lazyFeatureLoader(this.featureName, 'aggregate');
-        new Aggregate(this.agentIdentifier, this.aggregator, argsObjFromInstrument);
+        this.featAggregate = new Aggregate(this.agentIdentifier, this.aggregator, argsObjFromInstrument);
+        loadedSuccessfully(true);
       } catch (e) {
-        warn("Downloading ".concat(this.featureName, " failed..."), e);
+        warn("Downloading and initializing ".concat(this.featureName, " failed..."), e);
         this.abortHandler?.(); // undo any important alterations made to the page
         // not supported yet but nice to do: "abort" this agent's EE for this feature specifically
+        loadedSuccessfully(false);
       }
     };
 
     // For regular web pages, we want to wait and lazy-load the aggregator only after all page resources are loaded.
     // Non-browser scopes (i.e. workers) have no `window.load` event, so the aggregator can be lazy-loaded immediately.
-    if (isWorkerScope) importLater();else onWindowLoad(() => importLater(), true);
+    if (!isBrowserScope) importLater();else onWindowLoad(() => importLater(), true);
+  }
+
+  /**
+  * Make a determination if an aggregate class should even be imported
+  * @param {string} featureName
+  * @param {SessionEntity} session
+  * @returns
+  */
+  shouldImportAgg(featureName, session) {
+    // if this isnt the FIRST load of a session AND
+    // we are not actively recording SR... DO NOT run the aggregator
+    // session replay samples can only be decided on the first load of a session
+    // session replays can continue if in progress
+    if (featureName === FEATURE_NAMES.sessionReplay) {
+      if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false;
+      return !!session?.isNew || !!session?.state.sessionReplay;
+    }
+    // todo -- add case like above for session trace
+    return true;
   }
-}
-/**
- * Make a determination if an aggregate class should even be imported
- * @param {string} featureName
- * @param {SessionEntity} session
- * @returns
- */
-function shouldImportAgg(featureName, session) {
-  // if this isnt the FIRST load of a session AND
-  // we are not actively recording SR... DO NOT run the aggregator
-  // session replay samples can only be decided on the first load of a session
-  // session replays can continue if in progress
-  if (featureName === FEATURE_NAMES.sessionReplay) return !!session?.isNew || !!session?.state.sessionReplayActive;
-  // todo -- add case like above for session trace
-  return true;
 }

package/dist/esm/index.js

@@ -1,10 +1,7 @@
 export { Agent } from './loaders/agent';
 export { BrowserAgent } from './loaders/browser-agent';
 export { WorkerAgent } from './loaders/worker-agent';
-
-/** IN-PROGRESS -- DOES NOT CURRENTLY WORK CORRECTLY */
-// export { MicroAgent } from './loaders/micro-agent'
-
+export { MicroAgent } from './loaders/micro-agent';
 export { Ajax } from './features/ajax';
 export { JSErrors } from './features/jserrors';
 export { Metrics } from './features/metrics';

package/dist/esm/loaders/agent.js

@@ -12,6 +12,7 @@ import { generateRandomHexString } from '../common/ids/unique-id';
 import { getConfiguration, getInfo, getLoaderConfig, getRuntime } from '../common/config/config';
 import { warn } from '../common/util/console';
 import { stringify } from '../common/util/stringify';
+import { globalScope } from '../common/constants/runtime';
 
 /**
  * A flexible class that may be used to compose an agent from a select subset of feature modules. In applications
@@ -20,13 +21,18 @@ import { stringify } from '../common/util/stringify';
 export class Agent {
   constructor(options) {
     let agentIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : generateRandomHexString(16);
+    if (!globalScope) {
+      // We could not determine the runtime environment. Short-circuite the agent here
+      // to avoid possible exceptions later that may cause issues with customer's application.
+      warn('Failed to initial the agent. Could not determine the runtime environment.');
+      return;
+    }
     this.agentIdentifier = agentIdentifier;
     this.sharedAggregator = new Aggregator({
       agentIdentifier: this.agentIdentifier
     });
     this.features = {};
     this.desiredFeatures = new Set(options.features || []); // expected to be a list of static Instrument/InstrumentBase classes, see "spa.js" for example
-
     // For Now... ALL agents must make the rum call whether the page_view_event feature was enabled or not.
     // NR1 creates an index on the rum call, and if not seen for a few days, will remove the browser app!
     // Future work is being planned to evaluate removing this behavior from the backend, but for now we must ensure this call is made

package/dist/esm/loaders/api/api.js

@@ -9,7 +9,7 @@ import { ee } from '../../common/event-emitter/contextual-ee';
 import { now } from '../../common/timing/now';
 import { drain, registerDrain } from '../../common/drain/drain';
 import { onWindowLoad } from '../../common/window/load';
-import { isWorkerScope } from '../../common/util/global-scope';
+import { isBrowserScope } from '../../common/constants/runtime';
 import { warn } from '../../common/util/console';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
 import { gosCDN } from '../../common/window/nreum';
@@ -149,7 +149,7 @@ export function setAPI(agentIdentifier, forceDrain) {
   };
 
   // theres no window.load event on non-browser scopes, lazy load immediately
-  if (isWorkerScope) lazyLoad();
+  if (!isBrowserScope) lazyLoad();
   // try to stay out of the way of the window.load event, lazy load once that has finished.
   else onWindowLoad(() => lazyLoad(), true);
   function lazyLoad() {

package/dist/esm/loaders/api/apiAsync.js

@@ -4,8 +4,8 @@ import { ee } from '../../common/event-emitter/contextual-ee';
 import { handle } from '../../common/event-emitter/handle';
 import { registerHandler } from '../../common/event-emitter/register-handler';
 import { single } from '../../common/util/invoke';
-import { submitData } from '../../common/util/submit-data';
-import { isBrowserScope } from '../../common/util/global-scope';
+import * as submitData from '../../common/util/submit-data';
+import { isBrowserScope } from '../../common/constants/runtime';
 import { CUSTOM_METRIC_CHANNEL } from '../../features/metrics/constants';
 export function setAPI(agentIdentifier) {
   var instanceEE = ee.get(agentIdentifier);
@@ -76,7 +76,7 @@ export function setAPI(agentIdentifier) {
     url += 'dc=' + ~~dom_time + '&';
     url += 'fe=' + ~~fe_time + '&';
     url += 'c=' + cycle;
-    submitData.img({
+    submitData.xhr({
       url
     });
   }

package/dist/esm/loaders/configure/configure.js

@@ -2,7 +2,7 @@ import { setAPI, setTopLevelCallers } from '../api/api';
 import { addToNREUM, gosCDN, gosNREUMInitializedAgents } from '../../common/window/nreum';
 import { setConfiguration, setInfo, setLoaderConfig, setRuntime } from '../../common/config/config';
 import { activateFeatures, activatedFeatures } from '../../common/util/feature-flags';
-import { isWorkerScope } from '../../common/util/global-scope';
+import { isWorkerScope } from '../../common/constants/runtime';
 export function configure(agentIdentifier) {
   let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   let loaderType = arguments.length > 2 ? arguments[2] : undefined;

package/dist/esm/loaders/features/featureDependencies.js

@@ -5,6 +5,8 @@ export function getFeatureDependencyNames(feature) {
       return [FEATURE_NAMES.jserrors];
     case FEATURE_NAMES.sessionTrace:
       return [FEATURE_NAMES.ajax, FEATURE_NAMES.pageViewEvent];
+    case FEATURE_NAMES.sessionReplay:
+      return [FEATURE_NAMES.sessionTrace];
     case FEATURE_NAMES.pageViewTiming:
       return [FEATURE_NAMES.pageViewEvent];
     // this could change if we disconnect window load timings

package/dist/esm/loaders/micro-agent.js

@@ -1,4 +1,5 @@
 // loader files
+import { Instrument as PVE } from '../features/page_view_event/instrument';
 import { getEnabledFeatures } from './features/enabled-features';
 import { configure } from './configure/configure';
 // core files
@@ -8,14 +9,13 @@ import { generateRandomHexString } from '../common/ids/unique-id';
 import { getConfiguration, getInfo, getLoaderConfig, getRuntime } from '../common/config/config';
 import { FEATURE_NAMES } from './features/features';
 import { warn } from '../common/util/console';
-const nonAutoFeatures = [FEATURE_NAMES.jserrors, FEATURE_NAMES.pageAction];
-const autoFeatures = [FEATURE_NAMES.metrics];
+import { onWindowLoad } from '../common/window/load';
+const nonAutoFeatures = [FEATURE_NAMES.jserrors, FEATURE_NAMES.pageAction, FEATURE_NAMES.metrics];
 
 /**
- * A minimal agent class designed to be loaded multiple times on the same page, each instance narrowly scoped to the
- * concerns of a particular component, as with the micro-frontend architectural pattern. This class does not
- * automatically instrument. Instead, each MicroAgent instance may be configured to lazy-load specific
- * instrumentations at runtime, and to report desired data, events, and errors programatically.
+ * A minimal agent class designed to only respond to manual user input. As such, this class does not
+ * automatically instrument. Instead, each MicroAgent instance will lazy load the required features and can support loading multiple instances on one page.
+ * Out of the box, it can manually handle and report Page View, Page Action, and Error events.
  */
 export class MicroAgent {
   /**
@@ -48,38 +48,29 @@ export class MicroAgent {
   start() {
     try {
       const enabledFeatures = getEnabledFeatures(this.agentIdentifier);
-      autoFeatures.forEach(f => {
-        if (enabledFeatures[f]) {
-          // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
-          import( /* webpackChunkName: "lazy-feature-loader" */'../features/utils/lazy-feature-loader').then(_ref => {
-            let {
-              lazyFeatureLoader
-            } = _ref;
-            return lazyFeatureLoader(f, 'instrument');
-          }).then(_ref2 => {
-            let {
-              Instrument
-            } = _ref2;
-            this.features[f] = new Instrument(this.agentIdentifier, this.sharedAggregator);
-          }).catch(err => warn('Something prevented the agent from being downloaded.'));
-        }
-      });
-      nonAutoFeatures.forEach(f => {
-        if (enabledFeatures[f]) {
-          // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
-          // Parts of the lazy-loader were removed because webpack was transpiling them into the worker build, errantly inflating the build size.
-          import( /* webpackChunkName: "lazy-feature-loader" */'../features/utils/lazy-feature-loader').then(_ref3 => {
-            let {
-              lazyFeatureLoader
-            } = _ref3;
-            return lazyFeatureLoader(f, 'aggregate');
-          }).then(_ref4 => {
-            let {
-              Aggregate
-            } = _ref4;
-            this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator);
-          }).catch(err => warn('Something prevented the agent from being downloaded.'));
-        }
+      try {
+        // a biproduct of doing this is that the "session manager" is automatically handled through importing this feature
+        this.features.page_view_event = new PVE(this.agentIdentifier, this.sharedAggregator);
+      } catch (err) {
+        warn('Something prevented the agent from instrumenting.', err);
+      }
+      onWindowLoad(() => {
+        // these features do not import an "instrument" file, meaning they are only hooked up to the API.
+        nonAutoFeatures.forEach(f => {
+          if (enabledFeatures[f]) {
+            import( /* webpackChunkName: "lazy-feature-loader" */'../features/utils/lazy-feature-loader').then(_ref => {
+              let {
+                lazyFeatureLoader
+              } = _ref;
+              return lazyFeatureLoader(f, 'aggregate');
+            }).then(_ref2 => {
+              let {
+                Aggregate
+              } = _ref2;
+              this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator);
+            }).catch(err => warn('Something prevented the agent from being downloaded.', err));
+          }
+        });
       });
       gosNREUMInitializedAgents(this.agentIdentifier, this.features, 'features');
       return this;

package/dist/types/common/config/state/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/init.js"],"names":[],"mappings":"AAoEA,+CAIC;AAED,0DAIC;AAED,+DAYC"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/init.js"],"names":[],"mappings":"AAqEA,+CAIC;AAED,0DAIC;AAED,+DAYC"}

package/dist/types/common/constants/runtime.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file Contains constants about the environment the agent is running
+ * within. These values are derived at the time the agent is first loaded.
+ * @copyright 2023 New Relic Corporation. All rights reserved.
+ * @license Apache-2.0
+ */
+/**
+ * Indicates if the agent is running within a normal browser window context.
+ */
+export const isBrowserScope: boolean;
+/**
+ * Indicates if the agent is running within a worker context.
+ */
+export const isWorkerScope: boolean;
+export const globalScope: false | typeof globalThis;
+export const initialLocation: string;
+export const isiOS: boolean;
+/**
+ * Shared Web Workers introduced in iOS 16.0+ and n/a in 15.6-
+ *
+ * It was discovered in Safari 14 (https://bugs.webkit.org/show_bug.cgi?id=225305) that the buffered flag in PerformanceObserver
+ * did not work. This affects our onFCP metric in particular since web-vitals uses that flag to retrieve paint timing entries.
+ * This was fixed in v16+.
+ */
+export const iOS_below16: boolean;
+export const ffVersion: number;
+export const isIE: boolean;
+export const supportsSendBeacon: true;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/types/common/constants/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/runtime.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,qCAEqB;AAErB;;GAEG;AACH,oCAeK;AAEL,oDAUI;AAEJ,qCAAyD;AAEzD,4BAAiE;AAEjE;;;;;;GAMG;AACH,kCAAyE;AAEzE,+BAOI;AAEJ,2BAA2E;AAE3E,sCAAwD"}

package/dist/types/common/constants/shared-channel.d.ts

@@ -0,0 +1,5 @@
+export const sharedChannel: Readonly<{
+    onReplayReady: undefined;
+    sessionReplayInitialized: Promise<any>;
+}>;
+//# sourceMappingURL=shared-channel.d.ts.map

package/dist/types/common/constants/shared-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-channel.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/shared-channel.js"],"names":[],"mappings":"AASA;;;GAGE"}

package/dist/types/common/harvest/harvest-scheduler.d.ts

@@ -29,9 +29,13 @@ export class HarvestScheduler extends SharedContext {
         customUrl: string;
     };
     started: boolean;
-    timeoutHandle: NodeJS.Timeout | null;
+    timeoutHandle: any;
     aborted: boolean;
     harvest: Harvest;
+    /**
+     * This function is only meant for the last outgoing harvest cycle of a page. It trickles down to using sendBeacon, which should not be used
+     * to send payloads while the page is still active, due to limitations on how much data can be buffered in the API at any one time.
+     */
     unload(): void;
     startTimer(interval: any, initialDelay: any): void;
     interval: any;

package/dist/types/common/harvest/harvest-scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harvest-scheduler.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest-scheduler.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IACE;;;;;;;;;;SAUK;IACL,sBATa,MAAM;QAES,UAAU;QACV,UAAU;QACZ,UAAU,EAAvB,MAAM;QACQ,GAAG,EAAjB,OAAO;QACM,SAAS,EAAtB,MAAM;oBAkBlB;IAbC,iBAAwB;IACxB;;;oBARW,MAAM;aACN,OAAO;mBACP,MAAM;MAMK;IACtB,iBAAoB;IACpB,qCAAyB;IACzB,iBAAoB;IAEpB,iBAA8C;IAShD,eAKC;IAED,mDAIC;IAHC,cAAwB;IAK1B,uCAMC;IAED,6CAWC;IAED,yCA0DC;IAED,gDAiBC;CACF;8BArJ6B,2BAA2B;wBAChB,WAAW"}
+{"version":3,"file":"harvest-scheduler.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest-scheduler.js"],"names":[],"mappings":"AAYA;;GAEG;AACH;IACE;;;;;;;;;;SAUK;IACL,sBATa,MAAM;QAES,UAAU;QACV,UAAU;QACZ,UAAU,EAAvB,MAAM;QACQ,GAAG,EAAjB,OAAO;QACM,SAAS,EAAtB,MAAM;oBAoBlB;IAfC,iBAAwB;IACxB;;;oBARW,MAAM;aACN,OAAO;mBACP,MAAM;MAMK;IACtB,iBAAoB;IACpB,mBAAyB;IACzB,iBAAoB;IAEpB,iBAA8C;IAWhD;;;OAGG;IACH,eAKC;IAED,mDAIC;IAHC,cAAwB;IAK1B,uCAMC;IAED,6CAUC;IAED,yCAgEC;IAED,gDAiBC;CACF;8BAjK6B,2BAA2B;wBACjC,WAAW"}

package/dist/types/common/harvest/harvest.d.ts

@@ -1,21 +1,10 @@
-export function getSubmitMethod(endpoint: any, opts: any): {
-    method: (({ url, body, sync, method, headers }: {
-        url: string;
-        body?: string | undefined;
-        sync?: boolean | undefined;
-        method?: string | undefined;
-        headers?: {
-            key: string;
-            value: string;
-        }[] | undefined;
-    }) => XMLHttpRequest) | (({ url }: {
-        url: string;
-    }) => HTMLImageElement) | (({ url, body }: {
-        url: string;
-        body?: string | undefined;
-    }) => boolean);
-    useBody: boolean;
-};
+/**
+ * @typedef {import('./types.js').NetworkSendSpec} NetworkSendSpec
+ * @typedef {import('./types.js').HarvestEndpointIdentifier} HarvestEndpointIdentifier
+ * @typedef {import('./types.js').HarvestPayload} HarvestPayload
+ * @typedef {import('./types.js').FeatureHarvestCallback} FeatureHarvestCallback
+ * @typedef {import('./types.js').FeatureHarvestCallbackOptions} FeatureHarvestCallbackOptions
+ */
 export class Harvest extends SharedContext {
     tooManyRequestsDelay: any;
     obfuscator: Obfuscator;
@@ -24,38 +13,60 @@ export class Harvest extends SharedContext {
     /**
      * Initiate a harvest from multiple sources. An event that corresponds to the endpoint
      * name is emitted, which gives any listeners the opportunity to provide payload data.
+     * Note: Used by page_action
      * @param {NetworkSendSpec} spec Specification for sending data
      */
-    sendX(spec: NetworkSendSpec): any;
+    sendX(spec?: NetworkSendSpec): boolean;
     /**
      * Initiate a harvest call.
      * @param {NetworkSendSpec} spec Specification for sending data
      */
-    send(spec: NetworkSendSpec): any;
+    send(spec?: NetworkSendSpec): boolean;
     /**
      * Apply obfuscation rules to the payload and then initial the harvest network call.
      * @param {NetworkSendSpec} spec Specification for sending data
      */
-    obfuscateAndSend(spec: NetworkSendSpec): any;
-    _send({ endpoint, payload, opts, submitMethod, cbFinished, customUrl, raw, includeBaseParams }: {
-        endpoint: any;
-        payload?: {} | undefined;
-        opts?: {} | undefined;
-        submitMethod: any;
-        cbFinished: any;
-        customUrl: any;
-        raw: any;
-        includeBaseParams?: boolean | undefined;
-    }): any;
+    obfuscateAndSend(spec?: NetworkSendSpec): boolean;
+    /**
+     * Initiate a harvest call. Typically used by `sendX` and `send` methods or called directly
+     * for raw network calls.
+     * @param {NetworkSendSpec} param0 Specification for sending data
+     * @returns {boolean} True if the network call succeeded. For final harvest calls, the return
+     * value should not be relied upon because network calls will be made asynchronously.
+     */
+    _send({ endpoint, payload, opts, submitMethod, cbFinished, customUrl, raw, includeBaseParams }: NetworkSendSpec): boolean;
     baseQueryString(): string;
-    createPayload(type: any, options: any): {
-        body: {} | undefined;
-        qs: {} | undefined;
-    };
-    on(type: any, listener: any): void;
-    resetListeners(): void;
+    /**
+     * Calls and accumulates data from registered harvesting functions based on
+     * the endpoint being harvested.
+     * @param {HarvestEndpointIdentifier} endpoint BAM endpoint identifier.
+     * @param {FeatureHarvestCallbackOptions} options Options to be passed to the
+     * feature harvest listener callback.
+     * @returns {HarvestPayload} Payload object to transmit to the bam endpoint.
+     */
+    createPayload(endpoint: HarvestEndpointIdentifier, options: FeatureHarvestCallbackOptions): HarvestPayload;
+    /**
+     * Cleans and returns a payload object containing a body and qs
+     * object with key/value pairs. KV pairs where the value is null,
+     * undefined, or an empty string are removed to save on transmission
+     * size.
+     * @param {HarvestPayload} payload Payload to be sent to the endpoint.
+     * @returns {HarvestPayload} Cleaned payload payload to be sent to the endpoint.
+     */
+    cleanPayload(payload?: HarvestPayload): HarvestPayload;
+    /**
+     * Registers a function to be called when harvesting is triggered for a specific
+     * endpoint.
+     * @param {HarvestEndpointIdentifier} endpoint
+     * @param {FeatureHarvestCallback} listener
+     */
+    on(endpoint: HarvestEndpointIdentifier, listener: FeatureHarvestCallback): void;
 }
-export type NetworkSendSpec = object;
+export type NetworkSendSpec = import('./types.js').NetworkSendSpec;
+export type HarvestEndpointIdentifier = import('./types.js').HarvestEndpointIdentifier;
+export type HarvestPayload = import('./types.js').HarvestPayload;
+export type FeatureHarvestCallback = import('./types.js').FeatureHarvestCallback;
+export type FeatureHarvestCallbackOptions = import('./types.js').FeatureHarvestCallbackOptions;
 import { SharedContext } from '../context/shared-context';
 import { Obfuscator } from '../util/obfuscate';
 //# sourceMappingURL=harvest.d.ts.map

package/dist/types/common/harvest/harvest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harvest.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest.js"],"names":[],"mappings":"AAkOA;;;;;;;;;;;;;;;;;EAmBC;AA9MD;IAII,0BAA2H;IAC3H,uBAAoD;IACpD,kCAAsH;IAEtH,YAAiB;IAGnB;;;;OAIG;IACH,YAFW,eAAe,OAYzB;IAED;;;OAGG;IACH,WAFW,eAAe,OAazB;IAED;;;OAGG;IACH,uBAFW,eAAe,OAMzB;IAED;;;;;;;;;YAiFC;IAGD,0BAmBC;IAED;;;MAaC;IAED,mCAGC;IAED,uBAIC;CACF;8BA3MY,MAAM;8BALW,2BAA2B;2BAF9B,mBAAmB"}
+{"version":3,"file":"harvest.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest.js"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AAEH;IAII,0BAA2H;IAC3H,uBAAoD;IACpD,kCAAsH;IAEtH,YAAiB;IAGnB;;;;;OAKG;IACH,aAFW,eAAe,WAUzB;IAED;;;OAGG;IACH,YAFW,eAAe,WAMzB;IAED;;;OAGG;IACH,wBAFW,eAAe,WAMzB;IAED;;;;;;OAMG;IACH,gGAJW,eAAe,GACb,OAAO,CA8FnB;IAGD,0BAmBC;IAED;;;;;;;OAOG;IACH,wBALW,yBAAyB,WACzB,6BAA6B,GAE3B,cAAc,CA2B1B;IAED;;;;;;;OAOG;IACH,uBAHW,cAAc,GACZ,cAAc,CAwB1B;IAED;;;;;OAKG;IACH,aAHW,yBAAyB,YACzB,sBAAsB,QAQhC;CACF;8BAhQY,OAAO,YAAY,EAAE,eAAe;wCACpC,OAAO,YAAY,EAAE,yBAAyB;6BAC9C,OAAO,YAAY,EAAE,cAAc;qCACnC,OAAO,YAAY,EAAE,sBAAsB;4CAC3C,OAAO,YAAY,EAAE,6BAA6B;8BATjC,2BAA2B;2BAF9B,mBAAmB"}