@newrelic/browser-agent 0.1.231 → 1.232.1

package/dist/cjs/common/timer/interaction-timer.test.js

@@ -0,0 +1,216 @@
+"use strict";
+
+var _interactionTimer = require("./interaction-timer");
+jest.useFakeTimers();
+let now;
+beforeEach(() => {
+  now = Date.now();
+  jest.setSystemTime(now);
+});
+afterEach(() => {
+  jest.clearAllMocks();
+});
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
+  });
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    const requiredKeys = ['onEnd', 'refresh', 'initialMs', 'startTimestamp', 'timer'];
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
+  });
+  test('required keys are enforced', () => {
+    try {
+      new _interactionTimer.InteractionTimer({}, 100);
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'));
+    }
+    try {
+      new _interactionTimer.InteractionTimer({
+        onEnd: jest.fn()
+      });
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'));
+    }
+  });
+  test('refresh type timers set event listeners', () => {
+    // eslint-disable-next-line
+    let ee = {
+      on: jest.fn().mockImplementation((evt, cb) => {
+        cb([{
+          type: 'click'
+        }]);
+      })
+    };
+    let it = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn(),
+      ee
+    }, 100);
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1);
+    expect(it.onRefresh).toHaveBeenCalledTimes(1);
+
+    // eslint-disable-next-line
+    ee = {
+      on: jest.fn().mockImplementation((evt, cb) => {
+        cb([{
+          type: 'scroll'
+        }]);
+      })
+    };
+    it = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn(),
+      ee
+    }, 100);
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1);
+    expect(it.onRefresh).toHaveBeenCalledTimes(1);
+
+    // eslint-disable-next-line
+    ee = {
+      on: jest.fn().mockImplementation((evt, cb) => {
+        cb([{
+          type: 'keydown'
+        }]);
+      })
+    };
+    it = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn(),
+      ee
+    }, 100);
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1);
+    expect(it.onRefresh).toHaveBeenCalledTimes(1);
+    const aelSpy = jest.spyOn(document, 'addEventListener');
+    // eslint-disable-next-line
+    ee = {
+      on: jest.fn().mockImplementation((evt, cb) => {
+        cb([{
+          type: 'keydown'
+        }]);
+      })
+    };
+    it = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn(),
+      ee
+    }, 100);
+    // visibility change
+    expect(aelSpy).toHaveBeenCalledTimes(1);
+  });
+});
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.timer).toBeTruthy();
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    jest.runOnlyPendingTimers();
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+  });
+  test('Create can fallback to use defaults', () => {
+    let called = 0;
+    const timer1 = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    timer1.create();
+    const timer2 = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    timer2.create(timer2.onEnd);
+    const timer3 = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    timer3.create(undefined, 100);
+    jest.runAllTimers(200);
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1);
+  });
+});
+describe('refresh()', () => {
+  test('refresh prevents the callback from firing', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    jest.advanceTimersByTime(75);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.refresh();
+    jest.advanceTimersByTime(75);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    jest.advanceTimersByTime(100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+  });
+  test('refresh executes a callback for consumers', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn(),
+      onRefresh: jest.fn()
+    }, 100);
+    timer.refresh();
+    expect(timer.onRefresh).toHaveBeenCalledTimes(1);
+  });
+});
+describe('pause()', () => {
+  test('pause prevents the callback from firing', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.pause();
+    jest.advanceTimersByTime(150);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+  });
+  test('pause sets remainingMs timestamp', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.remainingMs).toEqual(undefined);
+    timer.pause();
+    expect(timer.remainingMs).toEqual(timer.initialMs - (now - timer.startTimestamp));
+  });
+});
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.clear();
+    jest.advanceTimersByTime(150);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    expect(timer.timer).toEqual(null);
+  });
+});
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.end();
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer.timer).toEqual(null);
+  });
+});
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new _interactionTimer.InteractionTimer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.isValid()).toEqual(true);
+    timer.startTimestamp -= 100;
+    expect(timer.isValid()).toEqual(false);
+  });
+});

package/dist/cjs/common/timer/timer.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Timer = void 0;
+class Timer {
+  constructor(opts, ms) {
+    if (!opts.onEnd) throw new Error('onEnd handler is required');
+    if (!ms) throw new Error('ms duration is required');
+    this.onEnd = opts.onEnd;
+    this.initialMs = ms;
+    this.startTimestamp = Date.now();
+    this.timer = this.create(this.onEnd, ms);
+  }
+  create(cb, ms) {
+    if (this.timer) this.clear();
+    return setTimeout(() => cb ? cb() : this.onEnd(), ms || this.initialMs);
+  }
+  clear() {
+    clearTimeout(this.timer);
+    this.timer = null;
+  }
+  end() {
+    this.clear();
+    this.onEnd();
+  }
+  isValid() {
+    return this.initialMs - (Date.now() - this.startTimestamp) > 0;
+  }
+}
+exports.Timer = Timer;

package/dist/cjs/common/timer/timer.test.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var _timer = require("./timer");
+jest.useFakeTimers();
+let now;
+beforeEach(() => {
+  now = Date.now();
+  jest.setSystemTime(now);
+});
+afterEach(() => {
+  jest.clearAllMocks();
+});
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
+  });
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
+  });
+  test('required keys are enforced', () => {
+    try {
+      new _timer.Timer({}, 100);
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'));
+    }
+    try {
+      new _timer.Timer({
+        onEnd: jest.fn()
+      });
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'));
+    }
+  });
+});
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.timer).toBeTruthy();
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    jest.runOnlyPendingTimers();
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+  });
+  test('Create can fallback to use defaults', () => {
+    let called = 0;
+    const timer1 = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    timer1.create();
+    const timer2 = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    timer2.create(timer2.onEnd);
+    const timer3 = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    timer3.create(undefined, 100);
+    jest.runAllTimers(200);
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1);
+  });
+});
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.clear();
+    jest.advanceTimersByTime(150);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    expect(timer.timer).toEqual(null);
+  });
+});
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.onEnd).toHaveBeenCalledTimes(0);
+    timer.end();
+    expect(timer.onEnd).toHaveBeenCalledTimes(1);
+    expect(timer.timer).toEqual(null);
+  });
+});
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new _timer.Timer({
+      onEnd: jest.fn()
+    }, 100);
+    expect(timer.isValid()).toEqual(true);
+    timer.startTimestamp -= 100;
+    expect(timer.isValid()).toEqual(false);
+  });
+});

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/canonicalize-url.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canonicalizeUrl = canonicalizeUrl;
+var _globalScope = require("../util/global-scope");
+var _cleanUrl = require("./clean-url");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Converts a URL to its basic form without a query string or fragment. If the resulting URL is the same as the
+ * loader's origin URL, returns '<inline>'.
+ * @param {string} url - The URL to be canonicalized.
+ * @param {string} loaderOriginUrl - The origin URL of the agent loader, used for inline detection.
+ * @returns {string} The canonicalized URL, or '<inline>' if the URL matches the loader origin URL.
+ */
+function canonicalizeUrl(url) {
+  if (typeof url !== 'string') return '';
+  const cleanedUrl = (0, _cleanUrl.cleanURL)(url);
+  const cleanedGlobalScopeUrl = (0, _cleanUrl.cleanURL)(_globalScope.initialLocation);
+
+  // If the URL matches the origin URL of the loader, we assume it originated within an inline script.
+  if (cleanedUrl === cleanedGlobalScopeUrl) {
+    return '<inline>';
+  } else {
+    return cleanedUrl;
+  }
+}

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

@@ -0,0 +1,42 @@
+"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();
+});
+test.each([null, undefined, 34])('returns empty string when url argument is %s', async url => {
+  const {
+    canonicalizeUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./canonicalize-url')));
+  expect(canonicalizeUrl(url)).toEqual('');
+});
+test('strips URLs of query strings and fragments', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://different-domain.com/'
+  }));
+  const {
+    canonicalizeUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./canonicalize-url')));
+  expect(canonicalizeUrl('http://example.com/path?query=string#fragment')).toBe('http://example.com/path');
+  expect(canonicalizeUrl('https://www.example.com/path/to/file.html?param=value')).toBe('https://www.example.com/path/to/file.html');
+  expect(canonicalizeUrl('https://www.example.com/?param=value#fragment')).toBe('https://www.example.com/');
+});
+test('returns <inline> when matching the page URL of the loader', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://example.com/'
+  }));
+  const {
+    canonicalizeUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./canonicalize-url')));
+  expect(canonicalizeUrl('http://example.com/')).toEqual('<inline>');
+});
+test('does not identify sub-paths of the loader origin as <inline>', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://example.com/'
+  }));
+  const {
+    canonicalizeUrl
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('./canonicalize-url')));
+  expect(canonicalizeUrl('http://example.com/path/to/script.js')).not.toEqual('<inline>');
+});

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

@@ -9,8 +9,15 @@ exports.cleanURL = cleanURL;
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var withHash = /([^?#]*)[^#]*(#[^?]*|$).*/;
-var withoutHash = /([^?#]*)().*/;
+var patternWithHash = /([^?#]*)[^#]*(#[^?]*|$).*/;
+var patternWithoutHash = /([^?#]*)().*/;
+
+/**
+ * Cleans a URL by removing the query string and fragment (hash portion).
+ * @param {string} url - The original URL to be cleaned.
+ * @param {boolean} [keepHash=false] - Whether to preserve the hash portion of the URL.
+ * @returns {string} The cleaned URL.
+ */
 function cleanURL(url, keepHash) {
-  return url.replace(keepHash ? withHash : withoutHash, '$1$2');
+  return url.replace(keepHash ? patternWithHash : patternWithoutHash, '$1$2');
 }

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/global-scope.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getGlobalScope = getGlobalScope;
-exports.isWorkerScope = exports.isBrowserScope = exports.globalScope = void 0;
+exports.isWorkerScope = exports.isBrowserScope = exports.initialLocation = exports.globalScope = void 0;
 exports.resetScope = resetScope;
 exports.setScope = setScope;
 /* global globalThis, WorkerGlobalScope, WorkerNavigator */
@@ -25,6 +25,8 @@ let globalScope = (() => {
   }
   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;
 
 /**
  * The below methods are only used for testing and should be removed once the
@@ -32,7 +34,7 @@ let globalScope = (() => {
  * tests/browser/protocol.browser.js
  * tests/browser/obfuscate.browser.js
  */
-exports.globalScope = globalScope;
+exports.initialLocation = initialLocation;
 function setScope(obj) {
   exports.globalScope = globalScope = {
     ...obj

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();
+  }
+}