@newrelic/browser-agent 0.1.229 → 0.1.231

package/README.md

@@ -1,4 +1,4 @@
-[![Community Plus header](https://github.com/newrelic/opensource-website/raw/main/src/images/categories/Community_Plus.png)](https://opensource.newrelic.com/oss-category/#community-plus)
+<a href="https://opensource.newrelic.com/oss-category/#community-plus"><picture><source media="(prefers-color-scheme: dark)" srcset="https://github.com/newrelic/opensource-website/raw/main/src/images/categories/dark/Community_Plus.png"><source media="(prefers-color-scheme: light)" srcset="https://github.com/newrelic/opensource-website/raw/main/src/images/categories/Community_Plus.png"><img alt="New Relic Open Source community plus project banner." src="https://github.com/newrelic/opensource-website/raw/main/src/images/categories/Community_Plus.png"></picture></a>
 
 # New Relic Browser Agent
 
@@ -131,8 +131,71 @@ import { SessionTrace } from '@newrelic/browser-agent/features/session_trace';
 import { Spa } from '@newrelic/browser-agent/features/spa';
 ```
 
+## Supported Browsers
+
+Our supported browser list can be accessed [here](https://docs.newrelic.com/docs/browser/new-relic-browser/getting-started/compatibility-requirements-browser-monitoring/#browser-types).
+
+If you desire more control over how the agent is built, our package also includes the source code. The source code is written to target the latest ECMAScript standards (ES2022). Please note that if you import the browser agent source code instead of the transpiled distribution code, you may need to alter your project's build system to apply transformations to the browser agent source code. Without these transforms, the code produced by your project's build system may not be compatible with your desired target browsers. Below is an example of how to import the source code.
+
+```javascript
+// Note the /src/ in the import paths below
+import { Agent } from '@newrelic/browser-agent/src/loaders/agent'
+import { Metrics } from '@newrelic/browser-agent/src/features/metrics'
+import { PageViewEvent } from '@newrelic/browser-agent/src/features/page_view_event'
+import { PageViewTiming } from '@newrelic/browser-agent/src/features/page_view_timing'
+
+const options = {
+  info: { ... },
+  loader_config: { ... },
+  init: { ... }
+}
+
+new Agent({
+  ...options,
+  features: [
+    Metrics,
+    PageViewEvent,
+    PageViewTiming
+  ]
+})
+```
+
+Neither the browser agent development team nor the New Relic support teams can support the numerous build systems that exist in the JavaScript ecosystem. If you run into issues, you may be asked to revert to importing from the transpiled distribution code.
+
+**DON'T** mix imports between the browser agent source code and transpiled distribution code. The below will break.
+
+```javascript
+// THIS IS BAD - do not do this
+import { Agent } from '@newrelic/browser-agent/loaders/agent'
+import { Metrics } from '@newrelic/browser-agent/src/features/metrics'
+```
+
+## Support
+
+New Relic hosts and moderates an online forum where customers can interact with New Relic employees as well as other customers to get help and share best practices. Like all official New Relic open source projects, there's a related Community topic in the New Relic Explorers Hub. You can find this project's topic/threads here:
+
+https://discuss.newrelic.com/c/full-stack-observability/browser
+
+## Contribute
+
+We encourage your contributions to improve the Browser agent! Keep in mind that when you submit your pull request, you'll need to sign the CLA via the click-through using CLA-Assistant. You only have to sign the CLA one time per project.
+
+If you have any questions, or to execute our corporate CLA (which is required if your contribution is on behalf of a company), drop us an email at opensource@newrelic.com.
+
+For more details on how best to contribute, see [CONTRIBUTING.md](CONTRIBUTING.md)
+
+**A note about vulnerabilities**
+
+As noted in our [security policy](https://github.com/newrelic/newrelic-browser-agent/security/policy), New Relic is committed to the privacy and security of our customers and their data. We believe that providing coordinated disclosure by security researchers and engaging with the security community are important means to achieve our security goals.
+
+If you believe you have found a security vulnerability in this project or any of New Relic's products or websites, we welcome and greatly appreciate you reporting it to New Relic through [HackerOne](https://hackerone.com/newrelic).
+
+If you would like to contribute to this project, review [these guidelines](./CONTRIBUTING.md).
+
+To all contributors, we thank you! Without your contribution, this project would not be what it is today. We also host [a community project page dedicated to the Browser agent](https://opensource.newrelic.com/projects/newrelic/newrelic-browser-agent).
+
 ## License
 
 The Browser agent is licensed under the [Apache 2.0](http://apache.org/licenses/LICENSE-2.0.txt) License.
 
-The Browser agent also uses source code from third-party libraries. Full details on which libraries are used and the terms under which they are licensed can be found in the [third-party notices document](THIRD_PARTY_NOTICES.md).
+The Browser agent also uses source code from third-party libraries. Full details on which libraries are used and the terms under which they are licensed can be found in the [third-party notices document](THIRD_PARTY_NOTICES.md).

package/dist/cjs/common/browser-version/ios-version.js

@@ -11,8 +11,9 @@ const isiOS = /(iPad|iPhone|iPod)/g.test(navigator.userAgent);
 // Shared Web Workers introduced in iOS 16.0+ and n/a in 15.6-
 exports.isiOS = isiOS;
 const iOS_below16 = isiOS && Boolean(typeof SharedWorker === 'undefined');
-/* ^ 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+.
+/*
+  ^ 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+.
 */
 exports.iOS_below16 = iOS_below16;

package/dist/cjs/common/config/state/configurable.js

@@ -12,12 +12,13 @@ class Configurable {
       if (!obj || typeof obj !== 'object') return (0, _console.warn)('New setting a Configurable requires an object as input');
       if (!model || typeof model !== 'object') return (0, _console.warn)('Setting a Configurable requires a model to set its initial properties');
       Object.assign(this, model);
-      Object.entries(obj).forEach(([key, value]) => {
+      Object.entries(obj).forEach(_ref => {
+        let [key, value] = _ref;
         const frozenAttrs = (0, _featureDependencies.getFrozenAttributes)(key);
         if (frozenAttrs.length && value && typeof value === 'object') {
           frozenAttrs.forEach(attr => {
             if (attr in value) {
-              (0, _console.warn)(`"${attr}" is a protected attribute and can not be changed in feature ${key}.  It will have no effect.`);
+              (0, _console.warn)("\"".concat(attr, "\" is a protected attribute and can not be changed in feature ").concat(key, ".  It will have no effect."));
               delete value[attr];
             }
           });

package/dist/cjs/common/config/state/info.js

@@ -40,7 +40,7 @@ function isValid(id) {
 }
 function getInfo(id) {
   if (!id) throw new Error('All info objects require an agent identifier!');
-  if (!_cache[id]) throw new Error(`Info for ${id} was never set`);
+  if (!_cache[id]) throw new Error("Info for ".concat(id, " was never set"));
   return _cache[id];
 }
 function setInfo(id, obj) {

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

@@ -60,7 +60,7 @@ const model = {
 const _cache = {};
 function getConfiguration(id) {
   if (!id) throw new Error('All configuration objects require an agent identifier!');
-  if (!_cache[id]) throw new Error(`Configuration for ${id} was never set`);
+  if (!_cache[id]) throw new Error("Configuration for ".concat(id, " was never set"));
   return _cache[id];
 }
 function setConfiguration(id, obj) {

package/dist/cjs/common/config/state/loader-config.js

@@ -18,7 +18,7 @@ const model = {
 const _cache = {};
 function getLoaderConfig(id) {
   if (!id) throw new Error('All loader-config objects require an agent identifier!');
-  if (!_cache[id]) throw new Error(`LoaderConfig for ${id} was never set`);
+  if (!_cache[id]) throw new Error("LoaderConfig for ".concat(id, " was never set"));
   return _cache[id];
 }
 function setLoaderConfig(id, obj) {

package/dist/cjs/common/config/state/runtime.js

@@ -11,15 +11,16 @@ var _nreum = require("../../window/nreum");
 var _sessionStorage = require("../../window/session-storage");
 var _config = require("../config");
 var _globalScope = require("../../util/global-scope");
-var _environmentVariables = require("../../constants/environment-variables");
+var _env = require("../../constants/env.npm");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 const model = agentId => {
   return {
-    buildEnv: _environmentVariables.BUILD_ENV,
+    buildEnv: _env.BUILD_ENV,
+    bytesSent: {},
     customTransaction: undefined,
     disabled: false,
-    distMethod: _environmentVariables.DIST_METHOD,
+    distMethod: _env.DIST_METHOD,
     isolatedBacklog: false,
     loaderType: undefined,
     maxBytes: 30000,
@@ -34,13 +35,13 @@ const model = agentId => {
     // if cookies (now session tracking) is turned off or can't get session ID, this is null
     xhrWrappable: typeof _globalScope.globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
     userAgent,
-    version: _environmentVariables.VERSION
+    version: _env.VERSION
   };
 };
 const _cache = {};
 function getRuntime(id) {
   if (!id) throw new Error('All runtime objects require an agent identifier!');
-  if (!_cache[id]) throw new Error(`Runtime for ${id} was never set`);
+  if (!_cache[id]) throw new Error("Runtime for ".concat(id, " was never set"));
   return _cache[id];
 }
 function setRuntime(id, obj) {

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
+/**
+ * @file This file exposes CDN build environment variables. These variables will
+ * be overridden with babel.
+ */
+
+/**
+ * Exposes the version of the agent
+ */
+const VERSION = "1.231.0";
+
+/**
+ * Exposes the build type of the agent
+ * Valid values are LOCAL, PROD, DEV
+ */
+exports.VERSION = VERSION;
+const BUILD_ENV = undefined;
+
+/**
+ * Exposes the distribution method of the agent
+ */
+exports.BUILD_ENV = BUILD_ENV;
+const DIST_METHOD = 'CDN';
+exports.DIST_METHOD = DIST_METHOD;

package/dist/cjs/common/constants/env.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
+var _package = _interopRequireDefault(require("../../../package.json"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * @file This file exposes build time environment variables that will be included in the
+ * build output of the agent. This file specifically contains the normal environment variables
+ * for the NPM agent build and will be overridden by webpack/babel during the build based on the
+ * type of build being performed.
+ */
+
+/**
+ * Exposes the version of the agent
+ */
+const VERSION = _package.default.version;
+
+/**
+ * Exposes the build type of the agent
+ */
+exports.VERSION = VERSION;
+const BUILD_ENV = 'NPM';
+
+/**
+ * Exposes the distribution method of the agent
+ */
+exports.BUILD_ENV = BUILD_ENV;
+const DIST_METHOD = 'NPM';
+exports.DIST_METHOD = DIST_METHOD;

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
+/**
+ * @file This file exposes NPM build environment variables. These variables will
+ * be overridden with babel.
+ */
+
+/**
+ * Exposes the version of the agent
+ */
+const VERSION = "1.231.0";
+
+/**
+ * Exposes the build type of the agent
+ * Valid values are LOCAL, PROD, DEV
+ */
+exports.VERSION = VERSION;
+const BUILD_ENV = 'NPM';
+
+/**
+ * Exposes the distribution method of the agent
+ * Valid valuse are CDN, NPM
+ */
+exports.BUILD_ENV = BUILD_ENV;
+const DIST_METHOD = 'NPM';
+exports.DIST_METHOD = DIST_METHOD;

package/dist/cjs/common/context/shared-context.js

@@ -14,7 +14,8 @@ class SharedContext {
       if (typeof context !== 'object') return (0, _console.warn)('shared context requires an object as input');
       this.sharedContext = {};
       Object.assign(this.sharedContext, model);
-      Object.entries(context).forEach(([key, value]) => {
+      Object.entries(context).forEach(_ref => {
+        let [key, value] = _ref;
         if (Object.keys(model).includes(key)) this.sharedContext[key] = value;
       });
     } catch (err) {

package/dist/cjs/common/drain/drain.js

@@ -51,7 +51,9 @@ function curateRegistry(agentIdentifier) {
  * @param {string} agentIdentifier - A unique 16 character ID corresponding to an instantiated agent.
  * @param {string} featureName - A named group into which the feature's buffered events are bucketed.
  */
-function drain(agentIdentifier = '', featureName = 'feature') {
+function drain() {
+  let agentIdentifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let featureName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'feature';
   curateRegistry(agentIdentifier);
 
   // If the feature for the specified agent is not in the registry, that means the instrument file was bypassed.
@@ -65,9 +67,13 @@ function drain(agentIdentifier = '', featureName = 'feature') {
   // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
   const items = Array.from(registry[agentIdentifier]);
-  if (items.every(([key, values]) => values.staged)) {
+  if (items.every(_ref => {
+    let [key, values] = _ref;
+    return values.staged;
+  })) {
     items.sort((a, b) => a[1].priority - b[1].priority);
-    items.forEach(([group]) => {
+    items.forEach(_ref2 => {
+      let [group] = _ref2;
       drainGroup(group);
     });
   }

package/dist/cjs/common/event-emitter/contextual-ee.test.js

@@ -0,0 +1,282 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+let mockNREUM;
+let runtime;
+beforeEach(() => {
+  mockNREUM = {};
+  runtime = {};
+  jest.doMock('../window/nreum', () => ({
+    __esModule: true,
+    gosNREUM: jest.fn(() => mockNREUM)
+  }));
+  jest.doMock('../config/config', () => ({
+    __esModule: true,
+    getRuntime: jest.fn(() => runtime)
+  }));
+});
+afterEach(() => {
+  jest.resetModules();
+  jest.resetAllMocks();
+});
+describe('global event-emitter', () => {
+  test('it returns the event-emitter defined on window.NREUM', async () => {
+    const mockEE = {};
+    mockNREUM.ee = mockEE;
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    expect(ee).toEqual(mockEE);
+  });
+  test('it sets the global event-emitter on window.NREUM', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    expect(ee).toEqual(mockNREUM.ee);
+  });
+});
+describe('scoping event-emitter', () => {
+  test('it creates a new child event-emitter', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const childName = _faker.faker.datatype.uuid();
+    const result = ee.get(childName);
+    expect(result).not.toEqual(mockNREUM.ee);
+    expect(result).toEqual(ee.get(childName)); // Should always return the same event-emitter
+    expect(result.debugId).toEqual(childName);
+  });
+  test('it creates a child event-emitter with an isolated backlog', async () => {
+    const childName = _faker.faker.random.alphaNumeric(16);
+    jest.doMock('../config/config', () => ({
+      __esModule: true,
+      getRuntime: jest.fn(id => {
+        if (id === childName) {
+          return {
+            isolatedBacklog: true
+          };
+        }
+        return runtime;
+      })
+    }));
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const result = ee.get(childName);
+    expect(ee.backlog).not.toBe(result.backlog);
+  });
+});
+describe('event-emitter context', () => {
+  test('it returns a new context', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const result = ee.context();
+    expect(result).toEqual({});
+  });
+  test('it returns the same context', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const result = ee.context();
+    expect(result).toEqual(ee.context(result));
+  });
+  test('it adds the context to the provided object', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const obj = {};
+    const result = ee.context(obj);
+    expect(result).toEqual(obj['nr@context']);
+  });
+});
+describe('event-emitter buffer', () => {
+  it('it should create a new buffer for the given group', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const eventType = _faker.faker.datatype.uuid();
+    const group = _faker.faker.datatype.uuid();
+    ee.buffer([eventType], group);
+    expect(ee.backlog).toEqual(expect.objectContaining({
+      [group]: []
+    }));
+    expect(ee.isBuffering(eventType)).toEqual(true);
+  });
+  it('it should default group to "feature"', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const eventType = _faker.faker.datatype.uuid();
+    ee.buffer([eventType]);
+    expect(ee.backlog).toEqual(expect.objectContaining({
+      feature: []
+    }));
+    expect(ee.isBuffering(eventType)).toEqual(true);
+  });
+  it('it should not create buffer if event-emitter is aborted', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const eventType = _faker.faker.datatype.uuid();
+    const group = _faker.faker.datatype.uuid();
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    ee.buffer([eventType], group);
+    expect(ee.backlog).toEqual({});
+    expect(ee.isBuffering(eventType)).toEqual(false);
+  });
+});
+describe('event-emitter abort', () => {
+  test('it aborts if there is an API backlog', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    expect(ee.aborted).toEqual(true);
+    expect(ee.backlog).toEqual({});
+  });
+  test('it aborts if there is a feature backlog', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    ee.backlog = {
+      feature: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    expect(ee.aborted).toEqual(true);
+    expect(ee.backlog).toEqual({});
+  });
+});
+describe('event-emitter emit', () => {
+  it('should execute the listener', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const mockListener = jest.fn();
+    const eventType = _faker.faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    ee.emit(eventType, eventArgs);
+    expect(mockListener).toHaveBeenCalledWith(eventArgs[0], eventArgs[1], eventArgs[2]);
+  });
+  it('should not execute the listener after removal', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const mockListener = jest.fn();
+    const eventType = _faker.faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    ee.emit(eventType, eventArgs);
+    ee.removeEventListener(eventType, mockListener);
+    ee.emit(eventType, eventArgs);
+    expect(mockListener).toHaveBeenCalledTimes(1);
+  });
+  it('should return early if global event-emitter is aborted', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const mockListener = jest.fn();
+    const eventType = _faker.faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    ee.on(eventType, mockListener);
+    ee.emit(eventType, eventArgs);
+    expect(mockListener).toHaveBeenCalledTimes(0);
+  });
+  it('should still emit if global event-emitter is aborted but force flag is true', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const scopeEE = ee.get(_faker.faker.datatype.uuid());
+    const mockScopeListener = jest.fn();
+    const eventType = _faker.faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    };
+    ee.abort();
+    scopeEE.on(eventType, mockScopeListener);
+    scopeEE.emit(eventType, eventArgs, {}, true);
+    expect(mockScopeListener).toHaveBeenCalledTimes(1);
+  });
+  it('should bubble the event if bubble flag is true', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const scopeEE = ee.get(_faker.faker.datatype.uuid());
+    const mockListener = jest.fn();
+    const mockScopeListener = jest.fn();
+    const eventType = _faker.faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    scopeEE.on(eventType, mockScopeListener);
+    scopeEE.emit(eventType, eventArgs, {}, false, true);
+    expect(mockScopeListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).toHaveBeenCalledTimes(1);
+  });
+  it('should not bubble the event if bubble flag is false', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const scopeEE = ee.get(_faker.faker.datatype.uuid());
+    const mockListener = jest.fn();
+    const mockScopeListener = jest.fn();
+    const eventType = _faker.faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    scopeEE.on(eventType, mockScopeListener);
+    scopeEE.emit(eventType, eventArgs, {}, false, false);
+    expect(mockScopeListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).not.toHaveBeenCalled();
+  });
+  it('should buffer the event on the scoped event-emitter', async () => {
+    const {
+      ee
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const scopeEE = ee.get(_faker.faker.datatype.uuid());
+    const mockListener = jest.fn();
+    const mockScopeListener = jest.fn();
+    const eventType = _faker.faker.datatype.uuid();
+    const eventArgs = ['a', 'b', 'c'];
+    ee.on(eventType, mockListener);
+    ee.buffer([eventType]);
+    scopeEE.on(eventType, mockScopeListener);
+    scopeEE.buffer([eventType]);
+    scopeEE.emit(eventType, eventArgs, {}, false, false);
+    expect(mockScopeListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).not.toHaveBeenCalled();
+    expect(scopeEE.backlog['feature']).toEqual(expect.arrayContaining([expect.arrayContaining([scopeEE, eventType, eventArgs, {}])]));
+    expect(ee.backlog['feature']).toEqual(scopeEE.backlog['feature']);
+  });
+});
+describe('getOrSetContext', () => {
+  test('it returns a new context', async () => {
+    const {
+      getOrSetContext
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const obj = {};
+    const result = getOrSetContext(obj);
+    expect(result).toEqual({});
+    expect(result).toEqual(obj['nr@context']);
+  });
+  test('it returns the same context', async () => {
+    const {
+      getOrSetContext
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+    const obj = {};
+    const result = getOrSetContext(obj);
+    expect(getOrSetContext(obj)).toEqual(result);
+  });
+});

package/dist/cjs/common/event-emitter/handle.test.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+jest.mock('./contextual-ee', () => ({
+  __esModule: true,
+  ee: {
+    buffer: jest.fn(),
+    emit: jest.fn(),
+    get: jest.fn(() => ({
+      buffer: jest.fn(),
+      emit: jest.fn()
+    }))
+  }
+}));
+afterEach(() => {
+  jest.resetModules();
+  jest.resetAllMocks();
+});
+test('it should create and use a default event-emitter', async () => {
+  const {
+    ee
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+  const {
+    handle
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./handle')));
+  const handleEE = jest.mocked(ee.get).mock.results[0].value;
+  const eventType = _faker.faker.datatype.uuid();
+  const eventArgs = ['a', 'b', 'c'];
+  const eventContext = {};
+  const eventGroup = _faker.faker.datatype.uuid();
+  handle(eventType, eventArgs, eventContext, eventGroup);
+  expect(handleEE.buffer).toHaveBeenCalledWith([eventType], eventGroup);
+  expect(handleEE.emit).toHaveBeenCalledWith(eventType, eventArgs, eventContext);
+});
+test('it should use the provided scoped event-emitter', async () => {
+  const {
+    ee
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
+  const {
+    handle
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./handle')));
+  const scopedEE = {
+    buffer: jest.fn(),
+    emit: jest.fn()
+  };
+  const handleEE = jest.mocked(ee.get).mock.results[0].value;
+  const eventType = _faker.faker.datatype.uuid();
+  const eventArgs = ['a', 'b', 'c'];
+  const eventContext = {};
+  const eventGroup = _faker.faker.datatype.uuid();
+  handle(eventType, eventArgs, eventContext, eventGroup, scopedEE);
+  expect(handleEE.buffer).not.toHaveBeenCalled();
+  expect(handleEE.emit).not.toHaveBeenCalled();
+  expect(scopedEE.buffer).toHaveBeenCalledWith([eventType], eventGroup);
+  expect(scopedEE.emit).toHaveBeenCalledWith(eventType, eventArgs, eventContext);
+});