@newrelic/browser-agent 1.244.0 → 1.246.0

package/dist/esm/common/config/state/init.js

@@ -29,6 +29,7 @@ const model = () => {
   };
 
   return {
+    feature_flags: [],
     proxy: {
       assets: undefined,
       // if this value is set, it will be used to overwrite the webpack asset path used to fetch assets

package/dist/esm/common/constants/env.cdn.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.244.0";
+export const VERSION = "1.246.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/env.npm.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.244.0";
+export const VERSION = "1.246.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -24,9 +24,10 @@ const model = {
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplay: MODE.OFF,
+  sessionReplayMode: MODE.OFF,
   sessionReplaySentFirstChunk: false,
   sessionTraceMode: MODE.OFF,
+  traceHarvestStarted: false,
   custom: {}
 };
 export const SESSION_EVENTS = {
@@ -143,7 +144,7 @@ export class SessionEntity {
 
     // 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.
-    if (this.isNew === undefined) this.isNew = !Object.keys(initialRead).length;
+    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 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);

package/dist/esm/common/url/parse-url.js

@@ -3,58 +3,35 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { globalScope, isBrowserScope } from '../constants/runtime';
-var stringsToParsedUrls = {};
+import { globalScope } from '../constants/runtime';
 export function parseUrl(url) {
-  if (url in stringsToParsedUrls) {
-    return stringsToParsedUrls[url];
-  }
-
   // Return if URL is a data URL, parseUrl assumes urls are http/https
   if ((url || '').indexOf('data:') === 0) {
     return {
       protocol: 'data'
     };
   }
-  let urlEl;
-  var location = globalScope?.location;
-  var ret = {};
-  if (isBrowserScope) {
-    // Use an anchor dom element to resolve the url natively.
-    urlEl = document.createElement('a');
-    urlEl.href = url;
-  } else {
-    try {
-      urlEl = new URL(url, location.href);
-    } catch (err) {
-      return ret;
+  try {
+    const parsedUrl = new URL(url, location.href);
+    const returnVal = {
+      port: parsedUrl.port,
+      hostname: parsedUrl.hostname,
+      pathname: parsedUrl.pathname,
+      search: parsedUrl.search,
+      protocol: parsedUrl.protocol.slice(0, parsedUrl.protocol.indexOf(':')),
+      sameOrigin: parsedUrl.protocol === globalScope?.location?.protocol && parsedUrl.host === globalScope?.location?.host
+    };
+    if (!returnVal.port || returnVal.port === '') {
+      if (parsedUrl.protocol === 'http:') returnVal.port = '80';
+      if (parsedUrl.protocol === 'https:') returnVal.port = '443';
     }
+    if (!returnVal.pathname || returnVal.pathname === '') {
+      returnVal.pathname = '/';
+    } else if (!returnVal.pathname.startsWith('/')) {
+      returnVal.pathname = "/".concat(returnVal.pathname);
+    }
+    return returnVal;
+  } catch (err) {
+    return {};
   }
-  ret.port = urlEl.port;
-  var firstSplit = urlEl.href.split('://');
-  if (!ret.port && firstSplit[1]) {
-    ret.port = firstSplit[1].split('/')[0].split('@').pop().split(':')[1];
-  }
-  if (!ret.port || ret.port === '0') ret.port = firstSplit[0] === 'https' ? '443' : '80';
-
-  // Host not provided in IE for relative urls
-  ret.hostname = urlEl.hostname || location.hostname;
-  ret.pathname = urlEl.pathname;
-  ret.protocol = firstSplit[0];
-
-  // Pathname sometimes doesn't have leading slash (IE 8 and 9)
-  if (ret.pathname.charAt(0) !== '/') ret.pathname = '/' + ret.pathname;
-
-  // urlEl.protocol is ':' in old ie when protocol is not specified
-  var sameProtocol = !urlEl.protocol || urlEl.protocol === ':' || urlEl.protocol === location.protocol;
-  var sameDomain = urlEl.hostname === location.hostname && urlEl.port === location.port;
-
-  // urlEl.hostname is not provided by IE for relative urls, but relative urls are also same-origin
-  ret.sameOrigin = sameProtocol && (!urlEl.hostname || sameDomain);
-
-  // Only cache if url doesn't have a path
-  if (ret.pathname === '/') {
-    stringsToParsedUrls[url] = ret;
-  }
-  return ret;
 }

package/dist/esm/common/util/type-check.js

@@ -0,0 +1,8 @@
+/**
+ * Tests a passed object to see if it is a pure object or not. All non-primatives in JS
+ * are technically objects and would pass a `typeof` check.
+ * @param {*} obj Input object to be tested
+**/
+export function isPureObject(obj) {
+  return obj?.constructor === {}.constructor;
+}

package/dist/esm/common/vitals/first-input-delay.js

@@ -18,8 +18,7 @@ if (isBrowserScope) {
       attrs: {
         type: entries[0].name,
         fid: Math.round(value)
-      },
-      shouldAddConnectionAttributes: true
+      }
     });
   });
 }

package/dist/esm/common/vitals/largest-contentful-paint.js

@@ -27,8 +27,7 @@ if (isBrowserScope) {
             elTag: lcpEntry.element.tagName
           })
         }
-      }),
-      shouldAddConnectionAttributes: true
+      })
     });
   });
 }

package/dist/esm/common/vitals/vital-metric.js

@@ -10,8 +10,7 @@ export class VitalMetric {
     let {
       value,
       entries = [],
-      attrs = {},
-      shouldAddConnectionAttributes = false
+      attrs = {}
     } = _ref;
     if (value < 0) return;
     const state = {
@@ -20,7 +19,6 @@ export class VitalMetric {
       entries,
       attrs
     };
-    if (shouldAddConnectionAttributes) addConnectionAttributes(state.attrs);
     this.history.push(state);
     this.#subscribers.forEach(cb => {
       try {
@@ -53,12 +51,4 @@ export class VitalMetric {
       this.#subscribers.delete(callback);
     };
   }
-}
-function addConnectionAttributes(obj) {
-  var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection; // to date, both window & worker shares the same support for connection
-  if (!connection) return;
-  if (connection.type) obj['net-type'] = connection.type;
-  if (connection.effectiveType) obj['net-etype'] = connection.effectiveType;
-  if (connection.rtt) obj['net-rtt'] = connection.rtt;
-  if (connection.downlink) obj['net-dlink'] = connection.downlink;
 }

package/dist/esm/features/ajax/aggregate/gql.js

@@ -0,0 +1,89 @@
+import { isPureObject } from '../../../common/util/type-check';
+
+/**
+ * @typedef {object} GQLMetadata
+ * @property {string} operationName Name of the operation
+ * @property {string} operationType Type of the operation
+ * @property {string} operationFramework Framework responsible for the operation
+ */
+
+/**
+ * Parses and returns the graphql metadata from a network request. If the network
+ * request is not a graphql call, undefined will be returned.
+ * @param {object|string} body Ajax request body
+ * @param {string} query Ajax request query param string
+ * @returns {GQLMetadata | undefined}
+ */
+export function parseGQL() {
+  let {
+    body,
+    query
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!body && !query) return;
+  try {
+    const gqlBody = parseBatchGQL(parseGQLContents(body));
+    if (gqlBody) return gqlBody;
+    const gqlQuery = parseSingleGQL(parseGQLQueryString(query));
+    if (gqlQuery) return gqlQuery;
+  } catch (err) {
+    // parsing failed, return undefined
+  }
+}
+
+/**
+ * @param {string|Object} gql The GraphQL object body sent to a GQL server
+ * @returns {GQLMetadata}
+ */
+function parseSingleGQL(contents) {
+  if (typeof contents !== 'object' || !contents.query || typeof contents.query !== 'string') return;
+
+  /** parses gql query string and returns [fullmatch, type match, name match] */
+  const matches = contents.query.trim().match(/^(query|mutation|subscription)\s?(\w*)/);
+  const operationType = matches?.[1];
+  if (!operationType) return;
+  const operationName = contents.operationName || matches?.[2] || 'Anonymous';
+  return {
+    operationName,
+    // the operation name of the indiv query
+    operationType,
+    // query, mutation, or subscription,
+    operationFramework: 'GraphQL'
+  };
+}
+function parseBatchGQL(contents) {
+  if (!contents) return;
+  if (!Array.isArray(contents)) contents = [contents];
+  const opNames = [];
+  const opTypes = [];
+  for (let content of contents) {
+    const operation = parseSingleGQL(content);
+    if (!operation) continue;
+    opNames.push(operation.operationName);
+    opTypes.push(operation.operationType);
+  }
+  if (!opTypes.length) return;
+  return {
+    operationName: opNames.join(','),
+    // the operation name of the indiv query -- joined by ',' for batched results
+    operationType: opTypes.join(','),
+    // query, mutation, or subscription -- joined by ',' for batched results
+    operationFramework: 'GraphQL'
+  };
+}
+function parseGQLContents(gqlContents) {
+  let contents;
+  if (!gqlContents || typeof gqlContents !== 'string' && typeof gqlContents !== 'object') return;else if (typeof gqlContents === 'string') contents = JSON.parse(gqlContents);else contents = gqlContents;
+  if (!isPureObject(contents) && !Array.isArray(contents)) return;
+  let isValid = false;
+  if (Array.isArray(contents)) isValid = contents.some(x => validateGQLObject(x));else isValid = validateGQLObject(contents);
+  if (!isValid) return;
+  return contents;
+}
+function parseGQLQueryString(gqlQueryString) {
+  if (!gqlQueryString || typeof gqlQueryString !== 'string') return;
+  const params = new URLSearchParams(gqlQueryString);
+  return parseGQLContents(Object.fromEntries(params));
+}
+function validateGQLObject(obj) {
+  return !(typeof obj !== 'object' || !obj.query || typeof obj.query !== 'string');
+}

package/dist/esm/features/ajax/aggregate/index.js

@@ -13,6 +13,7 @@ import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { parseGQL } from './gql';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -109,6 +110,13 @@ export class Aggregate extends AggregateBase {
         event.spanTimestamp = xhrContext.dt.timestamp;
       }
 
+      // parsed from the AJAX body, looking for operationName param & parsing query for operationType
+      event.gql = params.gql = parseGQL({
+        body: this.body,
+        query: this?.parsedOrigin?.search
+      });
+      if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, ee);
+
       // if the ajax happened inside an interaction, hold it until the interaction finishes
       if (this.spaNode) {
         var interactionId = this.spaNode.interaction.id;
@@ -198,7 +206,11 @@ export class Aggregate extends AggregateBase {
         var insert = '2,';
 
         // add custom attributes
-        var attrParts = addCustomAttributes(getInfo(agentIdentifier).jsAttributes || {}, this.addString);
+        // gql decorators are added as custom attributes to alleviate need for new BEL schema
+        var attrParts = addCustomAttributes({
+          ...(getInfo(agentIdentifier).jsAttributes || {}),
+          ...(event.gql || {})
+        }, this.addString);
         fields.unshift(numeric(attrParts.length));
         insert += fields.join(',');
         if (attrParts && attrParts.length > 0) {

package/dist/esm/features/ajax/instrument/index.js

@@ -153,6 +153,7 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
       if (size) metrics.txSize = size;
     }
     this.startTime = now();
+    this.body = data;
     this.listener = function (evt) {
       try {
         if (evt.type === 'abort' && !context.loadCaptureCalled) {
@@ -300,6 +301,7 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
     addUrl(this, url);
     var method = ('' + (target && target instanceof origRequest && target.method || opts.method || 'GET')).toUpperCase();
     this.params.method = method;
+    this.body = opts.body;
     this.txSize = dataSize(opts.body) || 0;
   }
 

package/dist/esm/features/jserrors/aggregate/index.js

@@ -182,7 +182,7 @@ export class Aggregate extends AggregateBase {
       params.pageview = 1;
       this.pageviewReported[bucketHash] = true;
     }
-    if (agentRuntime?.session?.state?.sessionReplay) params.hasReplay = true;
+    if (agentRuntime?.session?.state?.sessionReplayMode) params.hasReplay = true;
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash];
     var type = internal ? 'ierr' : 'err';
     var newMetrics = {

package/dist/esm/features/page_view_event/aggregate/index.js

@@ -76,6 +76,8 @@ export class Aggregate extends AggregateBase {
       ua: info.userAttributes,
       at: info.atts
     };
+    if (agentRuntime.session) queryParameters.fsh = Number(agentRuntime.session.isNew); // "first session harvest" aka RUM request or PageView event of a session
+
     let body;
     if (typeof info.jsAttributes === 'object' && Object.keys(info.jsAttributes).length > 0) {
       body = {

package/dist/esm/features/page_view_timing/aggregate/index.js

@@ -100,6 +100,7 @@ export class Aggregate extends AggregateBase {
   }
   addTiming(name, value, attrs) {
     attrs = attrs || {};
+    addConnectionAttributes(attrs); // network conditions may differ from the actual for VitalMetrics when they were captured
 
     // If cls was set to another value by `onCLS`, then it's supported and is attached onto any timing but is omitted until such time.
     /*
@@ -170,4 +171,12 @@ export class Aggregate extends AggregateBase {
     }
     return payload;
   }
+}
+function addConnectionAttributes(obj) {
+  var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection; // to date, both window & worker shares the same support for connection
+  if (!connection) return;
+  if (connection.type) obj['net-type'] = connection.type;
+  if (connection.effectiveType) obj['net-etype'] = connection.effectiveType;
+  if (connection.rtt) obj['net-rtt'] = connection.rtt;
+  if (connection.downlink) obj['net-dlink'] = connection.downlink;
 }

package/dist/esm/features/session_replay/aggregate/index.js

@@ -131,13 +131,13 @@ export class Aggregate extends AggregateBase {
         const {
           session
         } = getRuntime(this.agentIdentifier);
-        this.mode = session.state.sessionReplay;
+        this.mode = session.state.sessionReplayMode;
         if (!this.initialized || this.mode === MODE.OFF) return;
         this.startRecording();
       });
       this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
         if (!this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
-        if (this.mode !== MODE.OFF && data.sessionReplay === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);
+        if (this.mode !== MODE.OFF && data.sessionReplayMode === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);
         this.mode = data.sessionReplay;
       });
 
@@ -163,7 +163,7 @@ export class Aggregate extends AggregateBase {
             this.startRecording();
             this.scheduler.startTimer(this.harvestTimeSeconds);
             this.syncWithSessionManager({
-              sessionReplay: this.mode
+              sessionReplayMode: this.mode
             });
           }
         }
@@ -198,7 +198,7 @@ export class Aggregate extends AggregateBase {
     // session replays can continue if already in progress
     if (!session.isNew) {
       // inherit the mode of the existing session
-      this.mode = session.state.sessionReplay;
+      this.mode = session.state.sessionReplayMode;
     } else {
       // The session is new... determine the mode the new session should start in
       if (fullSample) this.mode = MODE.FULL; // full mode has precedence over error mode
@@ -239,7 +239,7 @@ export class Aggregate extends AggregateBase {
     }
     this.startRecording();
     this.syncWithSessionManager({
-      sessionReplay: this.mode
+      sessionReplayMode: this.mode
     });
   }
   prepareHarvest() {
@@ -448,7 +448,7 @@ export class Aggregate extends AggregateBase {
     this.mode = MODE.OFF;
     this.stopRecording();
     this.syncWithSessionManager({
-      sessionReplay: this.mode
+      sessionReplayMode: this.mode
     });
     this.clearTimestamps();
     this.ee.emit('REPLAY_ABORTED');

package/dist/esm/features/session_trace/aggregate/index.js

@@ -141,7 +141,7 @@ export class Aggregate extends AggregateBase {
           });
           if (!sessionEntity.isNew) {
             // inherit the same mode as existing session's Trace
-            if (sessionEntity.state.sessionReplay === MODE.OFF) this.isStandalone = true;
+            if (sessionEntity.state.sessionReplayMode === MODE.OFF) this.isStandalone = true;
             controlTraceOp(mostRecentModeKnown = sessionEntity.state.sessionTraceMode);
           } else {
             // for new sessions, see the truth table associated with NEWRELIC-8662 wrt the new Trace behavior under session management
@@ -503,6 +503,16 @@ export class Aggregate extends AggregateBase {
     }
     this.trace = {};
     this.nodeCount = 0;
+    let firstHarvestOfSession;
+    if (this.agentRuntime.session) {
+      const isFirstPayload = !this.agentRuntime.session.state.traceHarvestStarted;
+      firstHarvestOfSession = {
+        fsh: Number(isFirstPayload)
+      }; // converted to '0' | '1'
+      if (isFirstPayload) this.agentRuntime.session.write({
+        traceHarvestStarted: true
+      });
+    }
     return {
       qs: {
         st: this.agentRuntime.offset,
@@ -513,9 +523,10 @@ export class Aggregate extends AggregateBase {
          * so that blob parsing doesn't need to happen to support UI/API functions  */
         fts: this.agentRuntime.offset + earliestTimeStamp,
         /** n === "nodeCount" in NR1, a count of nodes in the ST payload, so that blob parsing doesn't need to happen to support UI/API functions */
-        n: stns.length // node count
+        n: stns.length,
+        // node count
+        ...firstHarvestOfSession
       },
-
       body: {
         res: stns
       }

package/dist/esm/features/spa/aggregate/index.js

@@ -58,7 +58,9 @@ export class Aggregate extends AggregateBase {
       depth: 0,
       harvestTimeSeconds: getConfigurationValue(agentIdentifier, 'spa.harvestTimeSeconds') || 10,
       interactionsToHarvest: [],
-      interactionsSent: []
+      interactionsSent: [],
+      // The below feature flag is used to disable the SPA ajax fix for specific customers, see https://new-relic.atlassian.net/browse/NR-172169
+      disableSpaFix: (getConfigurationValue(agentIdentifier, 'feature_flags') || []).indexOf('disable-spa-fix') > -1
     };
     this.serializer = new Serializer(this);
     const {
@@ -278,7 +280,7 @@ export class Aggregate extends AggregateBase {
     // context is stored on the xhr and is shared with all callbacks associated
     // with the new xhr
     register('new-xhr', function () {
-      if (!state.currentNode && state.prevInteraction && !state.prevInteraction.ignored) {
+      if (!state.disableSpaFix && !state.currentNode && state.prevInteraction && !state.prevInteraction.ignored) {
         /*
          * The previous interaction was discarded before a route change. Restore the interaction
          * in case this XHR is associated with a route change.
@@ -369,7 +371,7 @@ export class Aggregate extends AggregateBase {
     }, this.featureName, jsonpEE);
     register(FETCH_START, function (fetchArguments, dtPayload) {
       if (fetchArguments) {
-        if (!state.currentNode && state.prevInteraction && !state.prevInteraction.ignored) {
+        if (!state.disableSpaFix && !state.currentNode && state.prevInteraction && !state.prevInteraction.ignored) {
           /*
            * The previous interaction was discarded before a route change. Restore the interaction
            * in case this XHR is associated with a route change.

package/dist/esm/features/spa/aggregate/serializer.js

@@ -84,6 +84,13 @@ export class Serializer extends SharedContext {
           break;
         case 2:
           fields.push(addString(params.method), numeric(params.status), addString(params.host), addString(params.pathname), numeric(metrics.txSize), numeric(metrics.rxSize), attrs.isFetch ? 1 : attrs.isJSONP ? 2 : '', addString(node.id), nullable(node.dt && node.dt.spanId, addString, true) + nullable(node.dt && node.dt.traceId, addString, true) + nullable(node.dt && node.dt.timestamp, numeric, false));
+
+          // add params.gql here
+          if (Object.keys(params?.gql || {}).length) {
+            var ajaxAttrParts = addCustomAttributes(params.gql, addString);
+            children = children.concat(ajaxAttrParts);
+            attrCount = ajaxAttrParts.length;
+          }
           break;
         case 4:
           var tracedTime = attrs.tracedTime;

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

@@ -134,7 +134,7 @@ export class InstrumentBase extends FeatureBase {
     if (featureName === FEATURE_NAMES.sessionReplay) {
       if (!originals.MO) return false; // Session Replay cannot work without Mutation Observer
       if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false; // Session Replay as of now is tightly coupled with Session Trace in the UI
-      return !!session?.isNew || !!session?.state.sessionReplay; // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
+      return !!session?.isNew || !!session?.state.sessionReplayMode; // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
     }
 
     return true;

package/dist/esm/index.js

@@ -1,6 +1,5 @@
 export { Agent } from './loaders/agent';
 export { BrowserAgent } from './loaders/browser-agent';
-export { WorkerAgent } from './loaders/worker-agent';
 export { MicroAgent } from './loaders/micro-agent';
 export { Ajax } from './features/ajax';
 export { JSErrors } from './features/jserrors';

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

@@ -90,8 +90,8 @@ export function setAPI(agentIdentifier, forceDrain) {
       warn("Failed to execute setCustomAttribute.\nName must be a string type, but a type of <".concat(typeof name, "> was provided."));
       return;
     }
-    if (!(['string', 'number'].includes(typeof value) || value === null)) {
-      warn("Failed to execute setCustomAttribute.\nNon-null value must be a string or number type, but a type of <".concat(typeof value, "> was provided."));
+    if (!(['string', 'number', 'boolean'].includes(typeof value) || value === null)) {
+      warn("Failed to execute setCustomAttribute.\nNon-null value must be a string, number or boolean type, but a type of <".concat(typeof value, "> was provided."));
       return;
     }
     return appendJsAttribute(name, value, 'setCustomAttribute', persistAttribute);

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

@@ -1 +1 @@
-{"version":3,"file":"configurable.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/configurable.js"],"names":[],"mappings":"AAEA,4DAwBC"}
+{"version":3,"file":"configurable.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/configurable.js"],"names":[],"mappings":"AAEA,4DAyBC"}

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":"AA0GA,+CAIC;AAED,0DAIC;AAED,+DAYC"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/init.js"],"names":[],"mappings":"AA2GA,+CAIC;AAED,0DAIC;AAED,+DAYC"}

package/dist/types/common/session/session-entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":";;;;;;;;;;;;;;;AA4CA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aAsEC;IA/DC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAiBsC;IAOV,2BAA6C;IAM3E,iCAAuB;IAIzB,wBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CA6BlB;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,MAAM,CAkBlB;IAED,gBAuBC;IAED;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAED,yDAYC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBA7SqB,gBAAgB;iCAGL,4BAA4B"}
+{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":";;;;;;;;;;;;;;;AA6CA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aAsEC;IA/DC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAiBsC;IAOxC,2BAA6C;IAM7C,iCAAuB;IAIzB,wBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CA6BlB;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,MAAM,CAkBlB;IAED,gBAuBC;IAED;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAED,yDAYC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBA9SqB,gBAAgB;iCAGL,4BAA4B"}

package/dist/types/common/url/parse-url.d.ts

@@ -1,2 +1,13 @@
-export function parseUrl(url: any): any;
+export function parseUrl(url: any): {
+    port: string;
+    hostname: string;
+    pathname: string;
+    search: string;
+    protocol: string;
+    sameOrigin: boolean;
+} | {
+    protocol: string;
+} | {
+    protocol?: undefined;
+};
 //# sourceMappingURL=parse-url.d.ts.map

package/dist/types/common/url/parse-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-url.d.ts","sourceRoot":"","sources":["../../../../src/common/url/parse-url.js"],"names":[],"mappings":"AASA,wCA4DC"}
+{"version":3,"file":"parse-url.d.ts","sourceRoot":"","sources":["../../../../src/common/url/parse-url.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;EAkCC"}

package/dist/types/common/util/type-check.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests a passed object to see if it is a pure object or not. All non-primatives in JS
+ * are technically objects and would pass a `typeof` check.
+ * @param {*} obj Input object to be tested
+**/
+export function isPureObject(obj: any): boolean;
+//# sourceMappingURL=type-check.d.ts.map

package/dist/types/common/util/type-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-check.d.ts","sourceRoot":"","sources":["../../../../src/common/util/type-check.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,gDAEC"}

package/dist/types/common/vitals/vital-metric.d.ts

@@ -4,11 +4,10 @@ export class VitalMetric {
     name: any;
     attrs: {};
     roundingMethod: any;
-    update({ value, entries, attrs, shouldAddConnectionAttributes }: {
+    update({ value, entries, attrs }: {
         value: any;
         entries?: any[] | undefined;
         attrs?: {} | undefined;
-        shouldAddConnectionAttributes?: boolean | undefined;
     }): void;
     get current(): any;
     get isValid(): boolean;

package/dist/types/common/vitals/vital-metric.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vital-metric.d.ts","sourceRoot":"","sources":["../../../../src/common/vitals/vital-metric.js"],"names":[],"mappings":"AAAA;IAIE,4CAIC;IAND,eAAY;IAGV,UAAgB;IAChB,UAAe;IACf,oBAAwF;IAG1F;;;;;aAiBC;IAED,mBAOC;IAED,uBAEC;IAED,uEAMC;;CACF"}
+{"version":3,"file":"vital-metric.d.ts","sourceRoot":"","sources":["../../../../src/common/vitals/vital-metric.js"],"names":[],"mappings":"AAAA;IAIE,4CAIC;IAND,eAAY;IAGV,UAAgB;IAChB,UAAe;IACf,oBAAwF;IAG1F;;;;aAiBC;IAED,mBAOC;IAED,uBAEC;IAED,uEAMC;;CACF"}

package/dist/types/features/ajax/aggregate/gql.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {object} GQLMetadata
+ * @property {string} operationName Name of the operation
+ * @property {string} operationType Type of the operation
+ * @property {string} operationFramework Framework responsible for the operation
+ */
+/**
+ * Parses and returns the graphql metadata from a network request. If the network
+ * request is not a graphql call, undefined will be returned.
+ * @param {object|string} body Ajax request body
+ * @param {string} query Ajax request query param string
+ * @returns {GQLMetadata | undefined}
+ */
+export function parseGQL({ body, query }?: object | string): GQLMetadata | undefined;
+export type GQLMetadata = {
+    /**
+     * Name of the operation
+     */
+    operationName: string;
+    /**
+     * Type of the operation
+     */
+    operationType: string;
+    /**
+     * Framework responsible for the operation
+     */
+    operationFramework: string;
+};
+//# sourceMappingURL=gql.d.ts.map

package/dist/types/features/ajax/aggregate/gql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gql.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/gql.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,2CAJW,MAAM,GAAC,MAAM,GAEX,WAAW,GAAG,SAAS,CAYnC;;;;;mBAtBa,MAAM;;;;mBACN,MAAM;;;;wBACN,MAAM"}