{"version":3,"sources":["jsdelivr-header.js","/npm/metrics-queue@1.0.5/lib/metrics-queue.js"],"names":[],"mappings":"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","file":"/npm/metrics-queue@1.0.5/lib/metrics-queue.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/metrics-queue@1.0.5/lib/metrics-queue.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar _createClass = require('@babel/runtime/helpers/createClass');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nvar _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);\n\n/**\r\n * Auto Incrementing ID\r\n *\r\n * This module is designed to maintain a global auto incrementing ID\r\n * across each of the event emitters present on the MetricsQueue.\r\n *\r\n * Auto incrementing integer ID's are the fastest known form of unique identification.\r\n * A common usage example can be found in SQL tables. By default, a table's primary\r\n * keys are generated using auto incrementing integers that continue to increment\r\n * for the life of the table.\r\n */\nvar AutoIncrementingID = /*#__PURE__*/function () {\n  function AutoIncrementingID() {}\n\n  AutoIncrementingID.destroy = function destroy() {\n    this.incrementor = 0;\n  };\n\n  _createClass__default[\"default\"](AutoIncrementingID, null, [{\n    key: \"nextID\",\n    get: function get() {\n      return (this.incrementor++).toString();\n    }\n  }]);\n\n  return AutoIncrementingID;\n}();\nAutoIncrementingID.incrementor = 0;\n\n/**\r\n * Metric Indexer\r\n *\r\n * It's pretty much a queue. But it's special. It'll assign and return DB-like\r\n * identifiers to each item that get's added. This allows for O(1) access and removal.\r\n *\r\n * If someone tries to access an entry using a forloop I'm gonna lose it.\r\n */\n\nvar MetricIndexer = /*#__PURE__*/function () {\n  function MetricIndexer() {\n    this.queue = new Map();\n    this.silenceWarnings = false;\n  }\n\n  var _proto = MetricIndexer.prototype;\n\n  /**\r\n   * Add and index an event listener callback\r\n   *\r\n   * @param {Function} listener - a callback\r\n   * @returns {string} ID - an identifier that can be used to remove the listener\r\n   */\n  _proto.add = function add(listener, config) {\n    if (config === void 0) {\n      config = {\n        keepAlive: false,\n        passive: true\n      };\n    }\n\n    var nextID = AutoIncrementingID.nextID.toString();\n    this.queue.set(nextID, {\n      listener: listener,\n      config: Object.assign({\n        keepAlive: false,\n        passive: true\n      }, config)\n    });\n    return nextID;\n  }\n  /**\r\n   * Remove an event listener callback by id\r\n   *\r\n   * @param {Function} id - a callback index returned from MetricIndexer.add\r\n   * @returns {boolean}\r\n   */\n  ;\n\n  _proto.remove = function remove(id) {\n    return this.queue.delete(id);\n  }\n  /**\r\n   * Get a callback indexed at a particular ID\r\n   *\r\n   * @param {string} id - an ID returned from MetricIndexer.add\r\n   * @returns {Function | undefined}\r\n   */\n  ;\n\n  _proto.get = function get(id) {\n    return this.queue.get(id);\n  }\n  /**\r\n   * Empty the queue, execute all event listener callbacks\r\n   *\r\n   * @param {\r\n   *   BustPluginMetric |\r\n   *   BustPerformanceMark |\r\n   *   BustPerformanceMeasure\r\n   * } arguments - Forwarded from Metrics.queue[onMark | onMeasure] or MetricsQueue.plugins[pluginName]\r\n   */\n  ;\n\n  _proto.bust = async function bust() {\n    var _this = this;\n\n    for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {\n      params[_key] = arguments[_key];\n    }\n\n    var promises = [];\n    this.queue.forEach(function (_ref, id) {\n      var listener = _ref.listener,\n          _ref$config = _ref.config,\n          passive = _ref$config.passive,\n          keepAlive = _ref$config.keepAlive;\n\n      if (passive) {\n        promises.push(async function () {\n          await Promise.resolve();\n          listener.apply(void 0, params);\n\n          if (!keepAlive) {\n            _this.queue.delete(id);\n          }\n        }());\n      } else {\n        listener.apply(void 0, params);\n\n        if (!keepAlive) {\n          _this.queue.delete(id);\n        }\n      }\n    });\n\n    if (promises.length) {\n      await Promise.allSettled(promises);\n    }\n  }\n  /**\r\n   * Get the size of the queue\r\n   */\n  ;\n\n  /**\r\n   * Throw an error when emitters get clogged at runtime\r\n   *\r\n   * @param {string} event - The name of an event indexed on MetricsQueue.emitter\r\n   */\n  _proto.chubbinessCheck = function chubbinessCheck(event) {\n    if (!this.silenceWarnings && this.queue.size > 19) {\n      throw new Error(\"\\n        There are currently more than 20 listeners registered to \\\"\" + event + \"\\\".\\n        It may be worth adding a new marker or measure to avoid polluting this event's queue.\\n\\n        To silence this error, set MetricIndexer.silenceWarnings to false.\\n      \");\n    }\n  }\n  /**\r\n   * Destory the MetricIndexer while maintaining the instance\r\n   *  * For use during testing only\r\n   */\n  ;\n\n  _proto.destroy = function destroy() {\n    this.queue = new Map();\n    this.silenceWarnings = false;\n  };\n\n  _createClass__default[\"default\"](MetricIndexer, [{\n    key: \"size\",\n    get: function get() {\n      return this.queue.size;\n    }\n  }]);\n\n  return MetricIndexer;\n}();\n\n/**\r\n * MetricsQueue\r\n *\r\n * Designed to be the backbone event emitter for performance metrics\r\n *\r\n * Use the MetricsQueue to subscribe and act upon your performance marks, measures,\r\n * and externally derived metrics. Use it to defer module loading, conditionally\r\n * render, or create priority task execution based on your products real performance\r\n * metrics.\r\n */\n\nvar MetricsQueue = /*#__PURE__*/function () {\n  function MetricsQueue() {}\n\n  /**\r\n   * Enable the MetricsQueue, do it once and fuggettaboutit\r\n   *\r\n   * @param {Function} onReady - An optional callback to invoke once the MetricsQueue is initialized\r\n   * @param {HashTable<PluginOptions>} plugins - optional support for external performance libraries libraries\r\n   * @param {Boolean} usePerformanceAPI - whether to enable the MetricsQueue for native Performance.mark and measure\r\n   */\n  MetricsQueue.init = function init(_temp) {\n    var _ref = _temp === void 0 ? {} : _temp,\n        onReady = _ref.onReady,\n        plugins = _ref.plugins,\n        _ref$usePerformanceAP = _ref.usePerformanceAPI,\n        usePerformanceAPI = _ref$usePerformanceAP === void 0 ? true : _ref$usePerformanceAP;\n\n    this.enabled = true;\n    this.isDev = process.env.NODE_ENV !== \"production\";\n    this.usePerformanceAPI = usePerformanceAPI;\n\n    if (typeof onReady === \"function\") {\n      onReady(this);\n    }\n\n    if (this.usePerformanceAPI && window.performance) {\n      // Hold a copy of the default behaviors\n      this.mark = performance.mark;\n      this.measure = performance.measure; // Add a middleware to the mark and measure methods\n\n      performance.mark = this.markMiddleware;\n      performance.measure = this.measureMiddlware;\n    }\n\n    if (typeof plugins === \"object\") {\n      this.registerPlugins(plugins);\n    }\n  }\n  /**\r\n   * Create event emitters designed for usage with external libraries\r\n   * * For internal use only\r\n   *\r\n   * @param {HashTable<PluginOptions>} plugins - A list of methods to expose as well as how to handle callback\r\n   *                                             callback executions\r\n   */\n  ;\n\n  MetricsQueue.registerPlugins = function registerPlugins(plugins) {\n    var _this = this;\n\n    for (var plug in plugins) {\n      var processAfterCallStack = plugins[plug].processAfterCallStack;\n\n      if (processAfterCallStack) {\n        // eslint-disable-next-line arrow-body-style\n        this.plugins[plug] = function () {\n          var _this$onPluginEvent;\n\n          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n            args[_key] = arguments[_key];\n          }\n\n          return _this.processAfterCallStack((_this$onPluginEvent = _this.onPluginEvent).bind.apply(_this$onPluginEvent, [_this].concat(args)));\n        };\n      } else {\n        this.plugins[plug] = this.onPluginEvent.bind(this);\n      }\n    }\n  }\n  /**\r\n   * Trigger listeners on performance marks (inherits native performance.mark arguments)\r\n   * * For internal use only\r\n   *\r\n   * @param {string} markName - The native markName for performance.mark\r\n   * @param {PerformanceMarkOptions | undefined} markOptions - the native mark options for performance.mark\r\n   */\n  ;\n\n  MetricsQueue.markMiddleware = function markMiddleware() {\n    var _this2 = this;\n\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    // Execute the default behavior, first, always\n    var performanceMark = null;\n    MetricsQueue.safetyWrap(function () {\n      var _MetricsQueue$mark$ap, _MetricsQueue$mark;\n\n      performanceMark = (_MetricsQueue$mark$ap = (_MetricsQueue$mark = MetricsQueue.mark) == null ? void 0 : _MetricsQueue$mark.apply(_this2, args)) != null ? _MetricsQueue$mark$ap : null;\n    }); // Allow performance.mark to return the mark before any registered\n    // callbacks are called\n\n    void MetricsQueue.processAfterCallStack(function () {\n      // Emit the onMark event for the metric reached\n      MetricsQueue.onMark(performanceMark, args);\n    }); // Return the default PerformanceMark\n\n    return performanceMark;\n  }\n  /**\r\n   * Trigger listeners on performance measures (inherits native performance.measure arguments)\r\n   * * For internal use only\r\n   *\r\n   * @param {string} measureName - The native measure name for performance.measure\r\n   * @param {string | PerformanceMeasureOptions} startOrMeasureOptions - the native measure options for performance.measure\r\n   * @param {string} endMark - The native endMark for performance.measure\r\n   */\n  ;\n\n  MetricsQueue.measureMiddlware = function measureMiddlware() {\n    var _this3 = this;\n\n    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      args[_key3] = arguments[_key3];\n    }\n\n    // Execute the default behavior, first, always\n    var performanceMeasure = null;\n    MetricsQueue.safetyWrap(function () {\n      var _MetricsQueue$measure, _MetricsQueue$measure2;\n\n      performanceMeasure = (_MetricsQueue$measure = (_MetricsQueue$measure2 = MetricsQueue.measure) == null ? void 0 : _MetricsQueue$measure2.apply(_this3, args)) != null ? _MetricsQueue$measure : null;\n    }); // Allow performance.measure to return the measure before any\n    // registered callbacks are called\n\n    void MetricsQueue.processAfterCallStack(function () {\n      // Emit the onMeasure event for the metric reached\n      MetricsQueue.onMeasure(performanceMeasure, args);\n    }); // Return the default PerformanceMeasure\n\n    return performanceMeasure;\n  }\n  /**\r\n   * Execute callbacks on listeners registered to a particular mark\r\n   * * For internal use only\r\n   *\r\n   * @param {object | undefined} options - the options of a performance.mark\r\n   * @param {PerformanceMark} performanceMark - the return value of the performance.mark\r\n   */\n  ;\n\n  MetricsQueue.onMark = async function onMark(performanceMark, performanceMarkParams) {\n    var markName = performanceMarkParams[0];\n\n    if (markName in this.emitter) {\n      var _this$emitter$markNam;\n\n      await (_this$emitter$markNam = this.emitter[markName]).bust.apply(_this$emitter$markNam, [performanceMark].concat(performanceMarkParams));\n      this.checkForEmptyIndexer(markName);\n    }\n  }\n  /**\r\n   * Execute callbacks on listeners registered to a particular measure\r\n   * * For internal use only\r\n   *\r\n   * @param {PerformanceMeasure} performanceMeasure - the return value of the performance.measure\r\n   * @param {performanceMeasureParams} performanceMeasure - the options passed performance.measure\r\n   */\n  ;\n\n  MetricsQueue.onMeasure = async function onMeasure(performanceMeasure, performanceMeasureParams) {\n    var measureName = performanceMeasureParams[0];\n\n    if (measureName in this.emitter) {\n      var _this$emitter$measure;\n\n      await (_this$emitter$measure = this.emitter[measureName]).bust.apply(_this$emitter$measure, [performanceMeasure].concat(performanceMeasureParams));\n      this.checkForEmptyIndexer(measureName);\n    }\n  }\n  /**\r\n   * Execute callbacks on listeners registered on an external performance library\r\n   * * For internal use only\r\n   *\r\n   * @param {string} metric - the name of a custom library's performance metric\r\n   * @param {any[]} args - any parameters to be forward to subscriptions\r\n   */\n  ;\n\n  MetricsQueue.onPluginEvent = async function onPluginEvent(metric) {\n    if (metric in this.emitter) {\n      var _this$emitter$metric;\n\n      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n        args[_key4 - 1] = arguments[_key4];\n      }\n\n      await (_this$emitter$metric = this.emitter[metric]).bust.apply(_this$emitter$metric, args);\n      this.checkForEmptyIndexer(metric);\n    }\n  }\n  /**\r\n   * Clean up empty MetricIndexer's as they bust\r\n   * * For internal use only\r\n   *\r\n   * @param {string} key - an inded on the MetricsQueue's emitter\r\n   */\n  ;\n\n  MetricsQueue.checkForEmptyIndexer = function checkForEmptyIndexer(key) {\n    if (this.emitter[key].size === 0) {\n      delete this.emitter[key];\n    }\n  }\n  /**\r\n   * Register a callback as a microtask to be executed after the current callstack\r\n   * * For internal use only\r\n   *\r\n   * @param {Function} callback - anything but ideally limited to O(n) or less\r\n   */\n  ;\n\n  MetricsQueue.processAfterCallStack = async function processAfterCallStack(callback) {\n    await Promise.resolve();\n    return callback();\n  }\n  /**\r\n   * Register an event listener on a performance mark/measure or an external performance event\r\n   *\r\n   * @param {string} event - The name a performance.mark, measure, or external performance event\r\n   * @param {Function} callback - A callback to run once your mark is reached\r\n   * @param {ListenerConfig} config - The config takes two optional paramenters - \"passive\" and \"keepAlive\" -\r\n   *    \"passive\": tells the MetricsQueue to run the callback after the current callstack has cleared. This\r\n   *             can be ideal when your callbacks don't need to be run within 1ms of your metric being reached.\r\n   *             It is true by default.\r\n   *    \"keepAlive\": tells the MetricsQueue that this event listener should not be removed once called and instead\r\n   *               be called each time the metric is reached. This behavior is mimical of \"click\" events on on the\r\n   *               DOM as opposed to \"onLoad\" events on the window, which fire once.\r\n   *               It is false by default.\r\n   */\n  ;\n\n  MetricsQueue.addEventListener = function addEventListener(event, callback, config) {\n    if (this.isDev) {\n      this.validateListener(event, callback, config);\n    }\n\n    if (event in this.emitter) {\n      if (this.isDev) {\n        this.emitter[event].chubbinessCheck(event);\n      }\n    } else {\n      this.emitter[event] = new MetricIndexer();\n    }\n\n    return this.emitter[event].add(callback, config);\n  }\n  /**\r\n   * Clean up event listeners for events that can't be reached\r\n   *\r\n   * @param {string} event - The name a performance.mark, measure, or external performance event\r\n   * @param {string} callbackID - The ID returned from MetricsQueue.addEventListener\r\n   */\n  ;\n\n  MetricsQueue.removeEventListener = function removeEventListener(event, callbackID) {\n    if (event in this.emitter) {\n      this.emitter[event].remove(callbackID);\n      this.checkForEmptyIndexer(event);\n      return true;\n    }\n\n    return null;\n  }\n  /**\r\n   * When not running in production, provides developer feedback for error-prone arguments.\r\n   * * For internal use only\r\n   *\r\n   * @param {ListenerArguments} args - inherited arguments from addEventListener\r\n   */\n  ;\n\n  MetricsQueue.validateListener = function validateListener() {\n    if (!this.enabled) {\n      throw new Error(\"Please initialize the Metrics Queue before registering performance listeners\");\n    }\n\n    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n      args[_key5] = arguments[_key5];\n    }\n\n    var event = args[0],\n        callback = args[1];\n\n    if (!event) {\n      throw new Error(\"To register an event listener, an event name must be provided. Events correspond to usages of the native Performance API or external performance libraries\");\n    }\n\n    if (typeof callback !== \"function\") {\n      throw new Error(\"To register a listener, please provide a callback function to be executed once your metric is reached\");\n    }\n  }\n  /**\r\n   * Designed to wrap performance api calls for environment safety\r\n   *\r\n   * @param {Function} func - a function to wrap in a try-catch\r\n   * @param {any[]} args - arguments to apply to the function\r\n   * @param {Function} catchFN - an optional handler for caught errors\r\n   */\n  ;\n\n  MetricsQueue.safetyWrap = function safetyWrap(func, args, catchFN) {\n    if (args === void 0) {\n      args = [];\n    }\n\n    try {\n      return func.apply(void 0, args);\n    } catch (e) {\n      // Suppress error when performance API failed.\n      // Note: in MicrosoftEdge version 18 and prior, performance.measure(name, startMark, endMark) API will throw SyntaxError if startMark is undefined.\n      // That's why wrap with try catch statement.\n      if (typeof catchFN === \"function\") {\n        catchFN(e);\n      }\n    }\n\n    return null;\n  }\n  /**\r\n   * Resets the MetricsQueue\r\n   * * For use during testing only\r\n   */\n  ;\n\n  MetricsQueue.destroy = function destroy() {\n    if (this.enabled && this.usePerformanceAPI && window.performance) {\n      performance.mark = this.mark;\n      performance.measure = this.measure;\n    }\n\n    this.enabled = false;\n    this.usePerformanceAPI = true;\n    this.mark = null;\n    this.measure = null;\n    this.emitter = {};\n    this.isDev = process.env.NODE_ENV !== \"production\";\n  };\n\n  return MetricsQueue;\n}();\nMetricsQueue.isDev = false;\nMetricsQueue.enabled = false;\nMetricsQueue.usePerformanceAPI = true;\nMetricsQueue.mark = null;\nMetricsQueue.measure = null;\nMetricsQueue.emitter = {};\nMetricsQueue.plugins = {};\n\nexports.MetricsQueue = MetricsQueue;\n"]}