@newrelic/browser-agent 0.1.230 → 1.232.0

package/dist/cjs/common/timing/nav-timing.test.js

@@ -0,0 +1,192 @@
+"use strict";
+
+var _navTiming = require("./nav-timing");
+const offset = 123;
+const testValues = {
+  unloadEventStart: 1,
+  redirectStart: 2,
+  unloadEventEnd: 3,
+  redirectEnd: 4,
+  fetchStart: 5,
+  domainLookupStart: 6,
+  domainLookupEnd: 7,
+  connectStart: 8,
+  secureConnectionStart: 9,
+  connectEnd: 10,
+  requestStart: 11,
+  responseStart: 12,
+  responseEnd: 13,
+  domLoading: 14,
+  domInteractive: 15,
+  domContentLoadedEventStart: 16,
+  domContentLoadedEventEnd: 17,
+  domComplete: 18,
+  loadEventStart: 19,
+  loadEventEnd: 20,
+  type: 'reload',
+  redirectCount: 22
+};
+const legacyTestValues = {
+  unloadEventStart: offset + 1,
+  redirectStart: offset + 2,
+  unloadEventEnd: offset + 3,
+  redirectEnd: offset + 4,
+  fetchStart: offset + 5,
+  domainLookupStart: offset + 6,
+  domainLookupEnd: offset + 7,
+  connectStart: offset + 8,
+  secureConnectionStart: offset + 9,
+  connectEnd: offset + 10,
+  requestStart: offset + 11,
+  responseStart: offset + 12,
+  responseEnd: offset + 13,
+  domLoading: offset + 14,
+  domInteractive: offset + 15,
+  domContentLoadedEventStart: offset + 16,
+  domContentLoadedEventEnd: offset + 17,
+  domComplete: offset + 18,
+  loadEventStart: offset + 19,
+  loadEventEnd: offset + 20,
+  type: 'reload',
+  redirectCount: offset + 22
+};
+const expectedPT = {
+  of: offset,
+  n: 0,
+  u: 1,
+  r: 2,
+  ue: 3,
+  re: 4,
+  f: 5,
+  dn: 6,
+  dne: 7,
+  c: 8,
+  s: 9,
+  ce: 10,
+  rq: 11,
+  rp: 12,
+  rpe: 13,
+  dl: 14,
+  di: 15,
+  ds: 16,
+  de: 17,
+  dc: 18,
+  l: 19,
+  le: 20
+};
+const expectedPN = {
+  ty: 1,
+  rc: 22
+};
+describe('addPT()', () => {
+  test('an output object is populated with valid values', () => {
+    const output = (0, _navTiming.addPT)(offset, testValues, {});
+    expect(output).toEqual(expectedPT);
+  });
+  test('an object with invalid values is handled', () => {
+    const output = (0, _navTiming.addPT)(offset, {
+      ...testValues,
+      invalidValue: 'test'
+    }, {});
+    expect(output).toEqual(expectedPT);
+    const output2 = (0, _navTiming.addPT)(offset, {
+      ...testValues,
+      loadEventEnd: -1
+    }, {});
+    let expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output2).toEqual(expected);
+    const output3 = (0, _navTiming.addPT)(offset, {
+      ...testValues,
+      loadEventEnd: 'test'
+    }, {});
+    expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output3).toEqual(expected);
+    const output4 = (0, _navTiming.addPT)(offset, {
+      ...testValues,
+      loadEventEnd: null
+    }, {});
+    expected = {
+      ...expectedPT
+    };
+    delete expected.le;
+    expect(output4).toEqual(expected);
+    const legacyoutput = (0, _navTiming.addPT)(offset, {
+      ...legacyTestValues,
+      invalidValue: 'test'
+    }, {}, true);
+    expect(legacyoutput).toEqual(expectedPT);
+    const legacyoutput2 = (0, _navTiming.addPT)(offset, {
+      ...legacyTestValues,
+      loadEventEnd: -1
+    }, {}, true);
+    let legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput2).toEqual(expected);
+    const legacyoutput3 = (0, _navTiming.addPT)(offset, {
+      ...legacyTestValues,
+      loadEventEnd: 'test'
+    }, {}, true);
+    legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput3).toEqual(legacyexpected);
+    const legacyoutput4 = (0, _navTiming.addPT)(offset, {
+      ...legacyTestValues,
+      loadEventEnd: null
+    }, {}, true);
+    legacyexpected = {
+      ...expectedPT
+    };
+    delete legacyexpected.le;
+    expect(legacyoutput4).toEqual(legacyexpected);
+  });
+  test('rounds values to integers', () => {
+    const output = (0, _navTiming.addPT)(offset, {
+      unloadEventStart: 3.14159
+    }, {});
+    expect(output.u).toEqual(3);
+    const legacyoutput = (0, _navTiming.addPT)(0, {
+      unloadEventStart: 3.14159
+    }, {}, true);
+    expect(legacyoutput.u).toEqual(3);
+  });
+  test('adds entries to navTimingValues', () => {
+    const beforeLength = _navTiming.navTimingValues.length;
+    (0, _navTiming.addPT)(offset, {
+      testValues
+    }, {});
+    const afterLength = _navTiming.navTimingValues.length;
+    expect(afterLength - beforeLength).toEqual(21); // 20 + value of n
+
+    const legacybeforeLength = _navTiming.navTimingValues.length;
+    (0, _navTiming.addPT)(offset, {
+      legacyTestValues
+    }, {}, true);
+    const legacyafterLength = _navTiming.navTimingValues.length;
+    expect(legacyafterLength - legacybeforeLength).toEqual(21); // 20 + value of n
+  });
+});
+
+describe('addPN()', () => {
+  test('an output object is populated with valid values', () => {
+    const output = (0, _navTiming.addPN)(testValues, {});
+    expect(output).toEqual(expectedPN);
+  });
+  test('adds entries to navTimingValues', () => {
+    const beforeLength = _navTiming.navTimingValues.length;
+    (0, _navTiming.addPN)(offset, {
+      testValues
+    }, {});
+    const afterLength = _navTiming.navTimingValues.length;
+    expect(afterLength - beforeLength).toEqual(2);
+  });
+});

package/dist/cjs/common/unload/eol.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.subscribeToEOL = subscribeToEOL;
 var _firefoxVersion = require("../browser-version/firefox-version");
 var _eventListenerOpts = require("../event-listener/event-listener-opts");
-var _single = require("../util/single");
+var _invoke = require("../util/invoke");
 var _globalScope = require("../util/global-scope");
 var _pageVisibility = require("../window/page-visibility");
 /*
@@ -40,7 +40,7 @@ function subscribeToEOL(cb, allowBFCache) {
       (0, _eventListenerOpts.windowAddEventListener)('pagehide', cb); // when user navigates away, and because safari iOS v14.4- doesn't fully support vis change
       // --this ought to be removed once support for version below 14.5 phases out
     } else {
-      var oneCall = (0, _single.single)(cb);
+      var oneCall = (0, _invoke.single)(cb);
 
       // Firefox has a bug wherein a slow-loading resource loaded from the 'pagehide'
       // or 'unload' event will delay the 'load' event firing on the next page load.

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

@@ -0,0 +1,9 @@
+"use strict";
+
+var _cleanUrl = require("./clean-url");
+test.each([['http://domain.com/path?query=5', 'http://domain.com/path'], ['http://domain.com/path#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path']])('cleanURL should remove hash', (input, expected) => {
+  expect((0, _cleanUrl.cleanURL)(input)).toEqual(expected);
+});
+test.each([['http://domain.com/path?query=5', 'http://domain.com/path'], ['http://domain.com/path#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path#fragment#dumb'], ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path#fragment#dumb'], ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path#fragment/silly/dumber#dumbest']])('cleanURL should retain hash if second argument is true', (input, expected) => {
+  expect((0, _cleanUrl.cleanURL)(input, true)).toEqual(expected);
+});

package/dist/cjs/common/url/encode.test.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var encode = _interopRequireWildcard(require("./encode"));
+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; }
+describe('query string encoding', () => {
+  test('escapes string components except safe characters', () => {
+    const input = 'Asdf:, :, /@$;';
+    const expected = 'Asdf:,%20:,%20/@$;';
+    expect(encode.qs(input)).toEqual(expected);
+  });
+  test('null and undefined value returns \'null\'', () => {
+    expect(encode.qs(null)).toEqual('null');
+    expect(encode.qs(undefined)).toEqual('null');
+  });
+});
+describe('fromArray encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = ['a', 'b', 'c'];
+    const expected = 'ab';
+    expect(encode.fromArray(input, 2)).toEqual(expected);
+  });
+  test('fall back to largest whole chunk', () => {
+    const input = ['aa', 'bb', 'cc'];
+    const expected = 'aabb';
+    expect(encode.fromArray(input, 5)).toEqual(expected);
+  });
+});
+describe('object encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = {
+      foo: [1, 2, 3]
+    };
+    const expected = '&foo=%5B1,2%5D';
+    expect(encode.obj(input, 12)).toEqual(expected);
+  });
+  test('fall back to largest whole chunk', () => {
+    const input = {
+      bar: ['a', 'b', 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%22b%22%5D';
+    expect(encode.obj(input, 30)).toEqual(expected);
+  });
+  test('handles circular objects', () => {
+    const circular = {};
+    circular.circular = circular;
+    const input = {
+      bar: ['a', circular, 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%7B%7D,%22c%22%5D';
+    expect(encode.obj(input, 1000)).toEqual(expected);
+  });
+  test('handles circular arrays', () => {
+    const circular = [];
+    circular.push(circular);
+    const input = {
+      bar: ['a', circular, 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%5Bnull%5D,%22c%22%5D';
+    expect(encode.obj(input, 1000)).toEqual(expected);
+  });
+});
+describe('encode key value pairs as query params', () => {
+  test('ignores input when value is null or undefined', () => {
+    expect(encode.param('foo', null)).toEqual('');
+    expect(encode.param('foo', undefined)).toEqual('');
+  });
+  test('encodes key value pair correctly', () => {
+    expect(encode.param('foo', 'bar')).toEqual('&foo=bar');
+  });
+  test('ignores input when value is not a string', () => {
+    expect(encode.param('foo', {})).toEqual('');
+  });
+});

package/dist/cjs/common/url/location.js

@@ -9,6 +9,10 @@ exports.getLocation = getLocation;
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * This method only exists to support testing in JIL and can be removed once tests are migrated to WDIO.
+ * @returns global scope location
+ */
 function getLocation() {
   return '' + location;
 }

package/dist/cjs/common/url/location.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _location = require("./location");
+test('should always return a string', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({});
+  expect(typeof (0, _location.getLocation)()).toEqual('string');
+});
+test('should return window location', () => {
+  const expected = _faker.faker.internet.url();
+  jest.spyOn(window, 'location', 'get').mockReturnValue(expected);
+  expect((0, _location.getLocation)()).toEqual(expected);
+});

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

@@ -0,0 +1,111 @@
+"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.js

@@ -3,23 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.protocol = void 0;
+exports.isFileProtocol = isFileProtocol;
 var _globalScope = require("../util/global-scope");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const protocol = {
-  isFileProtocol: isFileProtocol,
-  supportabilityMetricSent: false
-};
-exports.protocol = protocol;
 function isFileProtocol() {
-  let isFile = Boolean((0, _globalScope.getGlobalScope)()?.location?.protocol === 'file:');
-  if (isFile) {
-    //metrics.recordSupportability('Generic/FileProtocol/Detected') -- may be implemented later? Probably make sure it's once per window
-    protocol.supportabilityMetricSent = true;
-  }
-  return isFile;
+  return Boolean(_globalScope.globalScope?.location?.protocol === 'file:');
 }

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

@@ -0,0 +1,16 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+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.js

@@ -12,6 +12,6 @@ exports.warn = warn;
  */
 function warn(message, secondary) {
   if (typeof console.warn !== 'function') return;
-  console.warn(`New Relic: ${message}`);
+  console.warn("New Relic: ".concat(message));
   if (secondary) console.warn(secondary);
 }

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

@@ -10,6 +10,12 @@ var _stringify = require("./stringify");
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * Returns the size of the provided data. Designed for measuring XHR responses.
+ *
+ * @param {*} data - The data to be measured.
+ * @returns {(number|undefined)} - The size of the data or undefined if size cannot be determined.
+ */
 function dataSize(data) {
   if (typeof data === 'string' && data.length) return data.length;
   if (typeof data !== 'object') return undefined;

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

@@ -0,0 +1,47 @@
+"use strict";
+
+var _dataSize = require("./data-size");
+describe('dataSize', () => {
+  test('returns length of string', () => {
+    const str = 'Hello, world!';
+    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)(12345)).toBeUndefined(); // might not actually be by design, but this is how it works today
+    expect((0, _dataSize.dataSize)('')).toBeUndefined();
+  });
+  test('returns byte length of ArrayBuffer object', () => {
+    const buffer = new ArrayBuffer(8);
+    expect((0, _dataSize.dataSize)(buffer)).toBe(8);
+  });
+  test('returns size of Blob object', () => {
+    const blob = new Blob(['Hello, world!'], {
+      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('returns length of JSON string representation of object', () => {
+    const obj = {
+      str: 'Hello, world!',
+      num: 12345,
+      nestedObj: {
+        arr: [1, 2, 3]
+      }
+    };
+    const expectedSize = JSON.stringify(obj).length;
+    expect((0, _dataSize.dataSize)(obj)).toBe(expectedSize);
+  });
+  test('returns undefined for object with toJSON method that throws an error', () => {
+    const obj = {
+      toJSON: () => {
+        throw new Error('Error in toJSON');
+      }
+    };
+    expect((0, _dataSize.dataSize)(obj)).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debounce = debounce;
+exports.single = single;
+/**
+ * Reduce the invocation of the supplied function so that it is only invoked
+ * once within a given timeout.
+ *
+ * If `wait` is `0`, the function will be invoked during the next tick.
+ * If `options.leading` is false or not provided, the function will be invoked
+ * N milliseconds after the last invocation of the returned function where
+ * N is the `timeout` value.
+ * If `options.leading` is true, the function will be invoked immediately upon
+ * the first invocation of the returned function and not again for N milliseconds
+ * where N is the `timeout` value.
+ * @param {function} func Function whose invocation should be limited so it is only invoked
+ * once within a given timeout period.
+ * @param {number} timeout Time in milliseconds that the function should only be invoked
+ * once within.
+ * @param {object} options Debounce options
+ * @param {boolean} options.leading Forces the function to be invoked on the first
+ * invocation of the returned function instead of N milliseconds after the last
+ * invocation.
+ * @returns {function} A wrapping function that will ensure the provided function
+ * is invoked only once within the given timeout.
+ */
+function debounce(func) {
+  var _this = this;
+  let timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const leading = options?.leading || false;
+  let timer;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (leading && timer === undefined) {
+      func.apply(_this, args);
+      timer = setTimeout(() => timer = clearTimeout(timer), timeout);
+    }
+    if (!leading) {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        func.apply(_this, args);
+      }, timeout);
+    }
+  };
+}
+
+/**
+ * Reduce the invocation of the supplied function so that it is only invoked
+ * once.
+ * @param {function} func Function whose invocation should be limited so it is only invoked
+ * once.
+ * @returns {function} A wrapping function that will ensure the provided function
+ * is invoked only once.
+ */
+function single(func) {
+  var _this2 = this;
+  let called = false;
+  return function () {
+    if (!called) {
+      called = true;
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      func.apply(_this2, args);
+    }
+  };
+}

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

@@ -0,0 +1,49 @@
+"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();
+  }
+}