@newrelic/browser-agent 1.235.0 → 1.236.0

package/dist/cjs/common/url/parse-url.test.js

@@ -1,111 +0,0 @@
-"use strict";
-
-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; }
-afterEach(() => {
-  jest.resetModules();
-  jest.clearAllMocks();
-});
-const urlTests = [{
-  input: 'http://example.com/path/name?qs=5&a=b',
-  expected: {
-    hostname: 'example.com',
-    pathname: '/path/name',
-    protocol: 'http',
-    port: '80',
-    sameOrigin: false
-  }
-}, {
-  input: 'http://foo:bar@example.com:8080/path/@name?qs=5&a=b',
-  expected: {
-    hostname: 'example.com',
-    pathname: '/path/@name',
-    protocol: 'http',
-    port: '8080',
-    sameOrigin: false
-  }
-}, {
-  input: 'https://foo:bar@example.com/path/name?qs=5&a=b',
-  expected: {
-    hostname: 'example.com',
-    pathname: '/path/name',
-    protocol: 'https',
-    port: '443',
-    sameOrigin: false
-  }
-}, {
-  input: '/path/name?qs=5&a=b',
-  expected: {
-    hostname: location.hostname,
-    pathname: '/path/name',
-    protocol: location.protocol.split(':')[0],
-    port: '80',
-    sameOrigin: true
-  }
-}, {
-  input: location.protocol + '//' + location.hostname + ':' + location.port + '/path/name?qs=5&a=b',
-  expected: {
-    hostname: location.hostname,
-    pathname: '/path/name',
-    protocol: location.protocol.split(':')[0],
-    port: '80',
-    sameOrigin: true
-  }
-}, {
-  input: 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==',
-  expected: {
-    protocol: 'data'
-  }
-}];
-test.each(urlTests)('verify url parsing inside browser scope', async _ref => {
-  let {
-    input,
-    expected
-  } = _ref;
-  jest.doMock('../util/global-scope', () => ({
-    __esModule: true,
-    isBrowserScope: true,
-    globalScope: global
-  }));
-  const {
-    parseUrl
-  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./parse-url')));
-  expect(parseUrl(input)).toEqual(expected);
-});
-test.each(urlTests)('verify url parsing outside browser scope', async _ref2 => {
-  let {
-    input,
-    expected
-  } = _ref2;
-  jest.doMock('../util/global-scope', () => ({
-    __esModule: true,
-    isBrowserScope: false,
-    globalScope: global
-  }));
-  const {
-    parseUrl
-  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./parse-url')));
-  expect(parseUrl(input)).toEqual(expected);
-});
-test('should cache parsed urls', async () => {
-  jest.doMock('../util/global-scope', () => ({
-    __esModule: true,
-    isBrowserScope: true,
-    globalScope: global
-  }));
-  const input = 'http://example.com/';
-  const expected = {
-    hostname: 'example.com',
-    pathname: '/',
-    protocol: 'http',
-    port: '80',
-    sameOrigin: false
-  };
-  jest.spyOn(document, 'createElement');
-  const {
-    parseUrl
-  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./parse-url')));
-  parseUrl(input);
-  expect(parseUrl(input)).toEqual(expected);
-  expect(document.createElement).toHaveBeenCalledTimes(1);
-});

package/dist/cjs/common/url/protocol.component-test.js

@@ -1,15 +0,0 @@
-"use strict";
-
-var _protocol = require("./protocol");
-test('should return true when location url contains file protocol', () => {
-  jest.spyOn(window, 'location', 'get').mockReturnValue({
-    protocol: 'file:'
-  });
-  expect((0, _protocol.isFileProtocol)()).toEqual(true);
-});
-test('should return false when location url does not contains file protocol', () => {
-  jest.spyOn(window, 'location', 'get').mockReturnValue({
-    protocol: 'http:'
-  });
-  expect((0, _protocol.isFileProtocol)()).toEqual(false);
-});

package/dist/cjs/common/util/console.test.js

@@ -1,30 +0,0 @@
-"use strict";
-
-var _console = require("./console");
-beforeEach(() => {
-  console.warn = jest.fn();
-});
-afterEach(() => {
-  jest.restoreAllMocks();
-});
-describe('warn', () => {
-  test('should not call console.warn if it is not a function', () => {
-    const spy = jest.spyOn(console, 'warn');
-    console.warn = undefined;
-    (0, _console.warn)('test message');
-    expect(spy).not.toHaveBeenCalled();
-  });
-  test('should call console.warn with a prefixed message', () => {
-    (0, _console.warn)('test message');
-    expect(console.warn).toHaveBeenCalledWith('New Relic: test message');
-  });
-  test('should call console.warn with secondary argument if provided', () => {
-    const secondary = 'secondary value';
-    (0, _console.warn)('test message', secondary);
-    expect(console.warn).toHaveBeenCalledWith(secondary);
-  });
-  test('should not call console.warn with secondary argument if not provided', () => {
-    (0, _console.warn)('test message');
-    expect(console.warn).toHaveBeenCalledTimes(1);
-  });
-});

package/dist/cjs/common/util/data-size.test.js

@@ -1,64 +0,0 @@
-"use strict";
-
-var _faker = require("@faker-js/faker");
-var stringifyModule = _interopRequireWildcard(require("./stringify"));
-var _dataSize = require("./data-size");
-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('./stringify');
-describe('dataSize', () => {
-  test('returns length of string', () => {
-    const str = _faker.faker.lorem.sentence();
-    expect((0, _dataSize.dataSize)(str)).toBe(str.length);
-  });
-  test('returns undefined for non-object, number, or empty string', () => {
-    expect((0, _dataSize.dataSize)(Infinity)).toBeUndefined();
-    expect((0, _dataSize.dataSize)(NaN)).toBeUndefined();
-    expect((0, _dataSize.dataSize)(12345)).toBeUndefined();
-    expect((0, _dataSize.dataSize)('')).toBeUndefined();
-  });
-  test('returns byte length of ArrayBuffer object', () => {
-    const buffer = new ArrayBuffer(_faker.faker.datatype.number({
-      min: 10,
-      max: 100
-    }));
-    expect((0, _dataSize.dataSize)(buffer)).toBe(buffer.byteLength);
-  });
-  test('returns size of Blob object', () => {
-    const blob = new Blob([_faker.faker.lorem.sentence()], {
-      type: 'text/plain'
-    });
-    expect((0, _dataSize.dataSize)(blob)).toBe(blob.size);
-  });
-  test('returns undefined for FormData object', () => {
-    const formData = new FormData();
-    expect((0, _dataSize.dataSize)(formData)).toBeUndefined();
-  });
-  test('uses stringify to get the length of an object', () => {
-    const input = {
-      [_faker.faker.datatype.uuid()]: _faker.faker.lorem.sentence()
-    };
-    const expectedSize = _faker.faker.datatype.number({
-      min: 1000,
-      max: 10000
-    });
-    jest.spyOn(stringifyModule, 'stringify').mockReturnValue({
-      length: expectedSize
-    });
-    expect((0, _dataSize.dataSize)(input)).toBe(expectedSize);
-  });
-  test('should not throw an exception if stringify throws an exception', () => {
-    const input = {
-      [_faker.faker.datatype.uuid()]: _faker.faker.lorem.sentence()
-    };
-    const expectedSize = _faker.faker.datatype.number({
-      min: 1000,
-      max: 10000
-    });
-    jest.spyOn(stringifyModule, 'stringify').mockImplementation(() => {
-      throw new Error(_faker.faker.lorem.sentence());
-    });
-    expect(() => (0, _dataSize.dataSize)(input)).not.toThrow();
-    expect((0, _dataSize.dataSize)(input)).toBeUndefined();
-  });
-});

package/dist/cjs/common/util/feature-flags.test.js

@@ -1,84 +0,0 @@
-"use strict";
-
-var _faker = require("@faker-js/faker");
-var eventEmitterModule = _interopRequireWildcard(require("../event-emitter/contextual-ee"));
-var handleModule = _interopRequireWildcard(require("../event-emitter/handle"));
-var drainModule = _interopRequireWildcard(require("../drain/drain"));
-var _featureFlags = require("./feature-flags");
-var _features = require("../../loaders/features/features");
-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('../event-emitter/handle');
-jest.mock('../drain/drain');
-jest.mock('../event-emitter/contextual-ee', () => ({
-  __esModule: true,
-  ee: {
-    get: jest.fn(() => ({
-      foo: "bar_".concat(Math.random())
-    }))
-  }
-}));
-let agentIdentifier;
-beforeEach(() => {
-  agentIdentifier = _faker.faker.datatype.uuid();
-});
-afterEach(() => {
-  Object.keys(_featureFlags.activatedFeatures).forEach(key => delete _featureFlags.activatedFeatures[key]);
-});
-test.each([null, undefined])('should not do anything when flags is %s', input => {
-  (0, _featureFlags.activateFeatures)(input, agentIdentifier);
-  expect(handleModule.handle).not.toHaveBeenCalled();
-  expect(drainModule.drain).not.toHaveBeenCalled();
-  expect(_featureFlags.activatedFeatures).toEqual({});
-});
-const bucketMap = {
-  stn: [_features.FEATURE_NAMES.sessionTrace],
-  err: [_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAMES.metrics],
-  ins: [_features.FEATURE_NAMES.pageAction],
-  spa: [_features.FEATURE_NAMES.spa],
-  sr: [_features.FEATURE_NAMES.sessionReplay, _features.FEATURE_NAMES.sessionTrace]
-};
-test('emits the right events when feature flag = 1', () => {
-  const flags = {};
-  Object.keys(bucketMap).forEach(flag => flags[flag] = 1);
-  (0, _featureFlags.activateFeatures)(flags, agentIdentifier);
-  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
-
-  // each flag gets emitted to each of its mapped features, and a feat- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
-  expect(handleModule.handle).toHaveBeenCalledTimes(14);
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, _features.FEATURE_NAMES.sessionTrace, sharedEE);
-  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [true], undefined, _features.FEATURE_NAMES.sessionTrace, sharedEE);
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
-  Object.keys(flags).forEach(flag => flags[flag] = true);
-  expect(_featureFlags.activatedFeatures).toEqual(flags);
-});
-test('emits the right events when feature flag = 0', () => {
-  const flags = {};
-  Object.keys(bucketMap).forEach(flag => flags[flag] = 0);
-  (0, _featureFlags.activateFeatures)(flags, agentIdentifier);
-  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
-
-  // each flag gets emitted to each of its mapped features, and a block- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
-  expect(handleModule.handle).toHaveBeenCalledTimes(14);
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'block-stn', [], undefined, _features.FEATURE_NAMES.sessionTrace, sharedEE);
-  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [false], undefined, _features.FEATURE_NAMES.sessionTrace, sharedEE);
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
-  Object.keys(flags).forEach(flag => flags[flag] = false);
-  expect(_featureFlags.activatedFeatures).toEqual(flags);
-});
-test('only the first activate of the same feature is respected', () => {
-  const flags = {
-    stn: 1
-  };
-  (0, _featureFlags.activateFeatures)(flags, agentIdentifier);
-  flags.stn = 0;
-  (0, _featureFlags.activateFeatures)(flags, agentIdentifier);
-  const sharedEE1 = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
-  const sharedEE2 = jest.mocked(eventEmitterModule.ee.get).mock.results[1].value;
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE1);
-  expect(handleModule.handle).toHaveBeenNthCalledWith(2, 'rumresp-stn', [true], undefined, 'session_trace', sharedEE1);
-  expect(handleModule.handle).not.toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE2);
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
-  expect(drainModule.drain).toHaveBeenCalledTimes(2);
-  expect(_featureFlags.activatedFeatures.stn).toBeTruthy();
-});

package/dist/cjs/common/util/get-or-set.test.js

@@ -1,47 +0,0 @@
-"use strict";
-
-var _getOrSet = require("./get-or-set");
-test('should return the current value of an existing property', () => {
-  const obj = {
-    foo: 'bar'
-  };
-  const prop = 'foo';
-  const getVal = jest.fn();
-  const result = (0, _getOrSet.getOrSet)(obj, prop, getVal);
-  expect(result).toBe('bar');
-  expect(getVal).not.toHaveBeenCalled();
-});
-test('should set and return the value from getVal if the property does not exist', () => {
-  const obj = {};
-  const prop = 'foo';
-  const getVal = jest.fn().mockReturnValue('baz');
-  const result = (0, _getOrSet.getOrSet)(obj, prop, getVal);
-  expect(result).toBe('baz');
-  expect(getVal).toHaveBeenCalled();
-  expect(obj.foo).toBe('baz');
-});
-test('should set the property as non-enumerable if Object.defineProperty is supported', () => {
-  const obj = {};
-  const prop = 'foo';
-  const getVal = jest.fn().mockReturnValue('baz');
-  jest.spyOn(Object, 'defineProperty');
-  const result = (0, _getOrSet.getOrSet)(obj, prop, getVal);
-  expect(result).toBe('baz');
-  expect(Object.defineProperty).toHaveBeenCalledWith(obj, prop, {
-    value: 'baz',
-    writable: true,
-    enumerable: false
-  });
-});
-test('should set the property from getVal if Object.defineProperty and Object.keys are not supported', () => {
-  const obj = {};
-  const prop = 'foo';
-  const getVal = jest.fn(() => 'baz');
-  const originalFn = Object.defineProperty;
-  Object.defineProperty = null;
-  const result = (0, _getOrSet.getOrSet)(obj, prop, getVal);
-  expect(result).toBe('baz');
-  expect(obj.foo).toBe('baz');
-  expect(Object.prototype.propertyIsEnumerable.call(obj, 'foo')).toBe(true);
-  Object.defineProperty = originalFn;
-});

package/dist/cjs/common/util/global-scope.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isWorkerScope = exports.isBrowserScope = exports.initialLocation = exports.globalScope = void 0;
-/* global globalThis, WorkerGlobalScope, WorkerNavigator */
-
-const isBrowserScope = Boolean(typeof window !== 'undefined' && window.document);
-exports.isBrowserScope = isBrowserScope;
-const isWorkerScope = Boolean(typeof WorkerGlobalScope !== 'undefined' && self.navigator instanceof WorkerNavigator);
-exports.isWorkerScope = isWorkerScope;
-let globalScope = (() => {
-  if (isBrowserScope) {
-    return window;
-  } else if (isWorkerScope) {
-    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
-      return globalThis;
-    } else if (self instanceof WorkerGlobalScope) {
-      return self;
-    }
-  }
-  throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".');
-})();
-exports.globalScope = globalScope;
-const initialLocation = '' + globalScope.location;
-exports.initialLocation = initialLocation;

package/dist/cjs/common/util/global-scope.test.js

@@ -1,72 +0,0 @@
-"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; } /*
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     The global-scope module contains exports that are defined once at the time
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     of importing the module. For this reason, the module must be dynamically
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     imported in each test case.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     A scope must always exist or importing the module will throw an error. Use
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     `enableWorkerScope` to enable the worker scope. Be sure to call `disableWorkerScope`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     before any calls to `expect` or the test will fail with an error from Jest.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */
-afterEach(() => {
-  jest.restoreAllMocks();
-  jest.resetModules();
-});
-test('should indicate a browser scope', async () => {
-  jest.spyOn(global, 'window', 'get').mockReturnValue({
-    document: {}
-  });
-  const globalScopeModule = await Promise.resolve().then(() => _interopRequireWildcard(require('./global-scope')));
-  expect(globalScopeModule.isBrowserScope).toBe(true);
-  expect(globalScopeModule.isWorkerScope).toBe(false);
-  expect(globalScopeModule.globalScope).toBe(global.window);
-});
-test('should indicate a worker scope', async () => {
-  enableWorkerScope();
-  const globalScopeModule = await Promise.resolve().then(() => _interopRequireWildcard(require('./global-scope')));
-  const mockedGlobalThis = global.globalThis;
-  disableWorkerScope();
-  expect(globalScopeModule.isBrowserScope).toBe(false);
-  expect(globalScopeModule.isWorkerScope).toBe(true);
-  expect(globalScopeModule.globalScope).toBe(mockedGlobalThis);
-});
-test('should return the self global', async () => {
-  enableWorkerScope();
-  jest.replaceProperty(global, 'globalThis', null);
-  jest.spyOn(global, 'self', 'get').mockReturnValue(new global.WorkerGlobalScope());
-  const globalScopeModule = await Promise.resolve().then(() => _interopRequireWildcard(require('./global-scope')));
-  const mockedGlobalSelf = global.self;
-  disableWorkerScope();
-  expect(globalScopeModule.isBrowserScope).toBe(false);
-  expect(globalScopeModule.isWorkerScope).toBe(true);
-  expect(globalScopeModule.globalScope).toBe(mockedGlobalSelf);
-});
-test('should throw an error when a scope cannot be defined', async () => {
-  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined);
-  await expect(() => Promise.resolve().then(() => _interopRequireWildcard(require('./global-scope')))).rejects.toThrow();
-});
-test('should immediately store the current location', async () => {
-  const url = _faker.faker.internet.url();
-  jest.spyOn(window, 'location', 'get').mockReturnValue(url);
-  const globalScopeModule = await Promise.resolve().then(() => _interopRequireWildcard(require('./global-scope')));
-  expect(globalScopeModule.initialLocation).toBe(url);
-});
-function enableWorkerScope() {
-  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined);
-  class WorkerNavigator {}
-  class WorkerGlobalScope {
-    navigator = new WorkerNavigator();
-  }
-  global.WorkerGlobalScope = WorkerGlobalScope;
-  global.WorkerNavigator = WorkerNavigator;
-  jest.spyOn(global, 'navigator', 'get').mockReturnValue(new global.WorkerNavigator());
-  jest.replaceProperty(global, 'globalThis', new WorkerGlobalScope());
-}
-function disableWorkerScope() {
-  delete global.WorkerGlobalScope;
-  delete global.WorkerNavigator;
-  jest.restoreAllMocks();
-}

package/dist/cjs/common/util/invoke.test.js

@@ -1,49 +0,0 @@
-"use strict";
-
-var _invoke = require("./invoke");
-jest.useFakeTimers();
-describe('debounce', () => {
-  test('should run the supplied function after 100ms', () => {
-    let mockCallback = jest.fn();
-    let debouncedMethod = (0, _invoke.debounce)(mockCallback, 100);
-    execFnTimes(debouncedMethod, 100);
-    expect(mockCallback).not.toHaveBeenCalled();
-    jest.advanceTimersByTime(1000);
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-  });
-  test('should rerun the supplied function when called again after 100ms', () => {
-    let mockCallback = jest.fn();
-    let debouncedMethod = (0, _invoke.debounce)(mockCallback, 100);
-    execFnTimes(debouncedMethod, 100);
-    jest.advanceTimersByTime(200);
-    execFnTimes(debouncedMethod, 100);
-    jest.advanceTimersByTime(2000);
-    expect(mockCallback).toHaveBeenCalledTimes(2);
-  });
-  test('should run the supplied function on the first event and debounce subsequent events', () => {
-    let mockCallback = jest.fn();
-    let debouncedMethod = (0, _invoke.debounce)(mockCallback, 100, {
-      leading: true
-    });
-    execFnTimes(debouncedMethod, 100);
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-    jest.advanceTimersByTime(200);
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-    execFnTimes(debouncedMethod, 100);
-    jest.advanceTimersByTime(200);
-    expect(mockCallback).toHaveBeenCalledTimes(2);
-  });
-});
-describe('single', () => {
-  test('should run the supplied function only once', () => {
-    let mockCallback = jest.fn();
-    let singleMethod = (0, _invoke.single)(mockCallback, 100);
-    execFnTimes(singleMethod, 100);
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-  });
-});
-function execFnTimes(fn, count) {
-  for (let i = 0; i < count; i++) {
-    fn();
-  }
-}

package/dist/cjs/common/util/map-own.test.js

@@ -1,49 +0,0 @@
-"use strict";
-
-var _mapOwn = require("./map-own");
-test('enumerates the object properties', () => {
-  const callback = jest.fn();
-  const input = {
-    foo: 'bar'
-  };
-  (0, _mapOwn.mapOwn)(input, callback);
-  expect(callback).toHaveBeenCalledWith('foo', 'bar');
-});
-test('return array of results from callback invocation', () => {
-  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
-  const input = {
-    foo: 'bar',
-    biz: 'baz'
-  };
-  const result = (0, _mapOwn.mapOwn)(input, callback);
-  expect(result.length).toEqual(2);
-  expect(result).toContain('foo:bar');
-  expect(result).toContain('biz:baz');
-});
-test('does not iterate symbol properties', () => {
-  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
-  const input = {
-    foo: 'bar',
-    [Symbol.for('biz')]: 'baz'
-  };
-  const result = (0, _mapOwn.mapOwn)(input, callback);
-  expect(result.length).toEqual(1);
-});
-test('does not iterate inherited properties', () => {
-  function F() {}
-  F.prototype = {
-    biz: 'baz'
-  };
-  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
-  const input = new F();
-  input.foo = 'bar';
-  const result = (0, _mapOwn.mapOwn)(input, callback);
-  expect(result.length).toEqual(1);
-});
-test.each([null, undefined])('returns empty array when passed object is null or undefined', input => {
-  const callback = jest.fn();
-  const result = (0, _mapOwn.mapOwn)(input, callback);
-  expect(Array.isArray(result)).toEqual(true);
-  expect(result.length).toEqual(0);
-  expect(callback).toHaveBeenCalledTimes(0);
-});