@atlaskit/react-ufo 1.0.1 → 2.0.0

package/dist/cjs/interaction-metrics/post-interaction-log.js

@@ -0,0 +1,190 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _config = require("../config");
+var _vcObserver = require("../vc/vc-observer");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var POST_INTERACTION_LOG_SEND_DEFAULT_TIMEOUT = 3000;
+var PostInteractionLog = exports.default = /*#__PURE__*/function () {
+  function PostInteractionLog() {
+    (0, _classCallCheck2.default)(this, PostInteractionLog);
+    /**
+     * Basic info about interaction that has just finished
+     */
+    (0, _defineProperty2.default)(this, "lastInteractionFinish", null);
+    /**
+     * Array of observed react render timings
+     */
+    (0, _defineProperty2.default)(this, "reactProfilerTimings", []);
+    /**
+     * Store the scheduled sink timeout Id so that it can be cancelled when needed
+     */
+    (0, _defineProperty2.default)(this, "sinkTimeoutId", null);
+    /**
+     * independent VC observer, that observes until `custom.post-interaction-logs` event is sent
+     */
+    (0, _defineProperty2.default)(this, "vcObserver", null);
+    (0, _defineProperty2.default)(this, "vcObserverSSRConfig", null);
+    /**
+     * Handler function to process / send the observation data
+     */
+    (0, _defineProperty2.default)(this, "sinkHandlerFn", function () {});
+  }
+  (0, _createClass2.default)(PostInteractionLog, [{
+    key: "initializeVCObserver",
+    value: function initializeVCObserver(options) {
+      if (this.vcObserver === null) {
+        this.vcObserver = new _vcObserver.VCObserver(_objectSpread(_objectSpread({}, options), {}, {
+          isPostInteraction: true
+        }));
+      }
+    }
+  }, {
+    key: "startVCObserver",
+    value: function startVCObserver(_ref) {
+      var _this$vcObserver;
+      var startTime = _ref.startTime;
+      (_this$vcObserver = this.vcObserver) === null || _this$vcObserver === void 0 || _this$vcObserver.start({
+        startTime: startTime
+      });
+    }
+  }, {
+    key: "setVCObserverSSRConfig",
+    value: function setVCObserverSSRConfig(vcObserverSSRConfig) {
+      this.vcObserverSSRConfig = vcObserverSSRConfig;
+    }
+
+    /**
+     * Set the VC result as per the last interaction
+     * Used to compare diffs of VC updates vs post interaction VC observer
+     * @param result - VC result as calculated by UFO create payload
+     */
+  }, {
+    key: "setLastInteractionFinishVCResult",
+    value: function setLastInteractionFinishVCResult(result) {
+      this.lastInteractionFinishVCResult = result;
+    }
+  }, {
+    key: "sinkHandler",
+    value:
+    /**
+     * Set the fn that would be invoked to process / send the observation data
+     */
+    function sinkHandler(sinkHandlerFn) {
+      this.sinkHandlerFn = sinkHandlerFn;
+    }
+
+    /**
+     * Reset state of the log
+     */
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.lastInteractionFinish = null;
+      this.reactProfilerTimings = [];
+      if (this.sinkTimeoutId != null) {
+        clearTimeout(this.sinkTimeoutId);
+        this.sinkTimeoutId = null;
+      }
+      this.setVCObserverSSRConfig(null);
+    }
+
+    /**
+     * Check if there is data in the log
+     */
+  }, {
+    key: "hasData",
+    value: function hasData() {
+      var _this$reactProfilerTi;
+      return ((_this$reactProfilerTi = this.reactProfilerTimings) === null || _this$reactProfilerTi === void 0 ? void 0 : _this$reactProfilerTi.length) > 0;
+    }
+
+    /**
+     * Send the log if there is data
+     */
+  }, {
+    key: "sendPostInteractionLog",
+    value: function sendPostInteractionLog() {
+      var _this$vcObserver2;
+      if (!this.hasData() || !this.lastInteractionFinish || !this.sinkHandlerFn) {
+        this.reset();
+        return;
+      }
+      this.sinkHandlerFn({
+        lastInteractionFinish: this.lastInteractionFinish,
+        reactProfilerTimings: this.reactProfilerTimings,
+        // NOTE: invoking `getVCResult` at latest possible point in time here (not earlier) to get the most accurate result (from performance.now())
+        postInteractionFinishVCResult: (_this$vcObserver2 = this.vcObserver) === null || _this$vcObserver2 === void 0 ? void 0 : _this$vcObserver2.getVCResult(_objectSpread({
+          start: this.lastInteractionFinish.start,
+          stop: performance.now(),
+          tti: -1,
+          // no need for TTI value here
+          prefix: 'ufo'
+        }, this.vcObserverSSRConfig)),
+        lastInteractionFinishVCResult: this.lastInteractionFinishVCResult
+      });
+      this.reset();
+    }
+
+    /**
+     * This fn should be invoked when an interaction has finished
+     * Basic details about the finished interaction will be recorded
+     * A timeout will be setup to send the post interaction observation after some time.
+     */
+  }, {
+    key: "onInteractionComplete",
+    value: function onInteractionComplete(_ref2) {
+      var _getConfig,
+        _this = this;
+      var ufoName = _ref2.ufoName,
+        start = _ref2.start,
+        end = _ref2.end,
+        id = _ref2.id,
+        abortReason = _ref2.abortReason,
+        abortedByInteractionName = _ref2.abortedByInteractionName,
+        routeName = _ref2.routeName,
+        type = _ref2.type;
+      this.lastInteractionFinish = {
+        ufoName: ufoName,
+        start: start,
+        end: end,
+        id: id,
+        abortReason: abortReason,
+        abortedByInteractionName: abortedByInteractionName,
+        routeName: routeName,
+        type: type
+      };
+      var timeout = ((_getConfig = (0, _config.getConfig)()) === null || _getConfig === void 0 ? void 0 : _getConfig.timeWindowForLateMutationsInMilliseconds) || POST_INTERACTION_LOG_SEND_DEFAULT_TIMEOUT;
+      this.sinkTimeoutId = window.setTimeout(function () {
+        _this.sendPostInteractionLog();
+      }, timeout);
+    }
+
+    /**
+     * This fn should be invoked when a React render happens after interaction has finished
+     */
+  }, {
+    key: "addProfilerTimings",
+    value: function addProfilerTimings(labelStack, type, actualDuration, baseDuration, startTime, commitTime) {
+      if (this.lastInteractionFinish != null) {
+        this.reactProfilerTimings.push({
+          type: type,
+          actualDuration: actualDuration,
+          baseDuration: baseDuration,
+          startTime: startTime,
+          commitTime: commitTime,
+          labelStack: labelStack
+        });
+      }
+    }
+  }]);
+  return PostInteractionLog;
+}();

package/dist/cjs/interaction-metrics-init/index.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _scheduler = require("scheduler");
+var _additionalPayload = require("../additional-payload");
+var _config = require("../config");
+var _hiddenTiming = require("../hidden-timing");
+var _interactionMetrics = require("../interaction-metrics");
+var _vc = require("../vc");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != (0, _typeof2.default)(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var initialized = false;
+function sinkInteraction(instance, payloadPackage) {
+  (0, _interactionMetrics.sinkInteractionHandler)(function (interactionId, interaction) {
+    (0, _scheduler.unstable_scheduleCallback)(_scheduler.unstable_IdlePriority, function () {
+      var payloads = payloadPackage.createPayloads(interactionId, interaction);
+      payloads === null || payloads === void 0 || payloads.forEach(function (payload) {
+        instance.sendOperationalEvent(payload);
+      });
+    });
+  });
+}
+function sinkPostInteractionLog(instance, createPostInteractionLogPayload) {
+  (0, _interactionMetrics.sinkPostInteractionLogHandler)(function (logOutput) {
+    (0, _scheduler.unstable_scheduleCallback)(_scheduler.unstable_IdlePriority, function () {
+      var payload = createPostInteractionLogPayload(logOutput);
+      if (payload) {
+        instance.sendOperationalEvent(payload);
+      }
+    });
+  });
+}
+var init = exports.init = function init(analyticsWebClientAsync, config) {
+  var _config$vc;
+  if (initialized) {
+    return;
+  }
+  (0, _config.setUFOConfig)(config);
+  if ((_config$vc = config.vc) !== null && _config$vc !== void 0 && _config$vc.enabled) {
+    var vcOptions = {
+      heatmapSize: config.vc.heatmapSize,
+      oldDomUpdates: config.vc.oldDomUpdates,
+      devToolsEnabled: config.vc.devToolsEnabled,
+      selectorConfig: config.vc.selectorConfig
+    };
+    (0, _vc.getVCObserver)(vcOptions).start({
+      startTime: 0
+    });
+    _interactionMetrics.postInteractionLog.initializeVCObserver(vcOptions);
+    _interactionMetrics.postInteractionLog.startVCObserver({
+      startTime: 0
+    });
+  }
+  (0, _hiddenTiming.setupHiddenTimingCapture)();
+  (0, _additionalPayload.startLighthouseObserver)();
+  initialized = true;
+  Promise.all([analyticsWebClientAsync, // eslint-disable-next-line import/dynamic-import-chunkname
+  Promise.resolve().then(function () {
+    return _interopRequireWildcard(require( /* webpackChunkName: "create-payloads" */'../create-payload'));
+  }), // eslint-disable-next-line import/dynamic-import-chunkname
+  Promise.resolve().then(function () {
+    return _interopRequireWildcard(require( /* webpackChunkName: "create-post-intreaction-log-payload" */'../create-post-interaction-log-payload'));
+  })]).then(function (_ref) {
+    var _ref2 = (0, _slicedToArray2.default)(_ref, 3),
+      awc = _ref2[0],
+      payloadPackage = _ref2[1],
+      createPostInteractionLogPayloadPackage = _ref2[2];
+    if (awc.getAnalyticsWebClientPromise) {
+      awc.getAnalyticsWebClientPromise().then(function (client) {
+        var instance = client.getInstance();
+        sinkInteraction(instance, payloadPackage);
+        if (config.captureLateReRenders) {
+          sinkPostInteractionLog(instance, createPostInteractionLogPayloadPackage.default);
+        }
+      });
+    } else if (awc.sendOperationalEvent) {
+      sinkInteraction(awc, payloadPackage);
+      if (config.captureLateReRenders) {
+        sinkPostInteractionLog(awc, createPostInteractionLogPayloadPackage.default);
+      }
+    }
+  });
+};

package/dist/cjs/label/UFOLabel.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = UFOLabel;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+var _interactionContext = _interopRequireWildcard(require("../interaction-context"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Annotate part of the react tree with a product name
+ * ```
+ * <UFOLabel name="card">
+ *   <Card card={data} />
+ * </UFOLabel>
+ * ```
+ */
+function UFOLabel(_ref) {
+  var name = _ref.name,
+    children = _ref.children;
+  var context = (0, _interactionContext.useInteractionContext)();
+  var newContext = (0, _react.useMemo)(function () {
+    if (context) {
+      return _objectSpread(_objectSpread({}, context), {}, {
+        labelStack: context.labelStack == null ? [{
+          name: name
+        }] : [].concat((0, _toConsumableArray2.default)(context.labelStack), [{
+          name: name
+        }])
+      });
+    } else {
+      return context;
+    }
+  }, [context, name]);
+  return context ? /*#__PURE__*/_react.default.createElement(_interactionContext.default.Provider, {
+    value: newContext
+  }, children) : /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, children);
+}

package/dist/cjs/label/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _UFOLabel = _interopRequireDefault(require("./UFOLabel"));
+var _default = exports.default = _UFOLabel.default;

package/dist/cjs/load-hold/UFOLoadHold.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = UFOLoadHold;
+var _react = _interopRequireWildcard(require("react"));
+var _interactionContext = _interopRequireDefault(require("../interaction-context"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var useLayoutEffectSAFE = typeof window === 'undefined' ? _react.useEffect : _react.useLayoutEffect;
+
+/**
+ * Render this whenever you're loading.
+ *
+ * Wrap loading elements
+ * ```js
+ * if (isLoading){
+ *   return (
+ *     <UFOLoadHold name="card">
+ *       <Skeleton />
+ *     </UFOLoadHold>
+ *   )
+ * }
+ * ```
+ *
+ * Or render it as a sibling
+ * ```
+ * if (isLoading){
+ *   return (
+ *     <>
+ *       <Skeleton />
+ *       <UFOLoadHold name="card">
+ *     </UFOLoadHold>
+ *   )
+ * }
+ * ```
+ *
+ * Or wrap your content conditionally
+ * ```
+ * return (
+ *   <UFOLoadHold name="card" hold={isLoading}>
+ *     <Card />
+ *   </UFOLoadHold>
+ * )
+ * ```
+ *
+ * Or render as a sibling conditionally
+ * ```
+ * return (
+ *   <>
+ *     <Card />
+ *     <UFOLoadHold name="card" hold={isLoading} />
+ *   </>
+ * )
+ * ```
+ */
+
+function UFOLoadHold(_ref) {
+  var children = _ref.children,
+    name = _ref.name,
+    _ref$hold = _ref.hold,
+    hold = _ref$hold === void 0 ? true : _ref$hold;
+  // react-18: useId instead
+  var context = (0, _react.useContext)(_interactionContext.default);
+  useLayoutEffectSAFE(function () {
+    if (hold && context != null) {
+      return context.hold(name);
+    }
+  }, [hold, context, name]);
+
+  // react-18: can return children directly
+  return children != null ? /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, children) : null;
+}

package/dist/cjs/load-hold/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _UFOLoadHold = _interopRequireDefault(require("./UFOLoadHold"));
+var _default = exports.default = _UFOLoadHold.default;

package/dist/cjs/placeholder/Placeholder.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Placeholder;
+var _react = _interopRequireWildcard(require("react"));
+var _loadHold = _interopRequireDefault(require("../load-hold"));
+var _looselyLazy = require("./loosely-lazy");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Provides a placeholder for lazily loaded content, improving perceived performance.
+ *
+ * Named placeholders are especially useful for analyzing page load breakdowns
+ * in performance monitoring tools like Performance Portal.
+ */
+function Placeholder(_ref) {
+  var name = _ref.name,
+    children = _ref.children,
+    _ref$fallback = _ref.fallback,
+    fallback = _ref$fallback === void 0 ? null : _ref$fallback;
+  var waitContext = (0, _react.useContext)(_looselyLazy.WaitContext);
+  var shouldHold = !waitContext || !!waitContext.currentValue();
+  return /*#__PURE__*/_react.default.createElement(_looselyLazy.LazySuspense, {
+    fallback: /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, fallback, /*#__PURE__*/_react.default.createElement(_loadHold.default, {
+      name: name,
+      hold: shouldHold
+    })),
+    name: name
+  }, children);
+}

package/dist/cjs/placeholder/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Placeholder = _interopRequireDefault(require("./Placeholder"));
+var _default = exports.default = _Placeholder.default;

package/dist/cjs/placeholder/loosely-lazy/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "LazySuspense", {
+  enumerable: true,
+  get: function get() {
+    return _lazySuspense.LazySuspense;
+  }
+});
+Object.defineProperty(exports, "WaitContext", {
+  enumerable: true,
+  get: function get() {
+    return _waitContext.WaitContext;
+  }
+});
+var _waitContext = require("./wait-context");
+var _lazySuspense = require("./lazy-suspense");

package/dist/cjs/placeholder/loosely-lazy/lazy-suspense.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LazySuspense = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var isNodeEnvironment = function isNodeEnvironment() {
+  return typeof window === 'undefined' || window.name === 'nodejs';
+};
+var LazySuspenseContext = /*#__PURE__*/(0, _react.createContext)({
+  fallback: /*#__PURE__*/_react.default.createElement(_react.Fragment, null),
+  setFallback: function setFallback() {
+    // eslint-disable-next-line no-console
+    console.warn('Missing <LooselySuspense /> boundary');
+  },
+  name: ''
+});
+var DynamicFallback = function DynamicFallback(_ref) {
+  var children = _ref.children,
+    outsideSuspense = _ref.outsideSuspense;
+  var _React$useContext = _react.default.useContext(LazySuspenseContext),
+    fallback = _React$useContext.fallback,
+    setFallback = _React$useContext.setFallback;
+  (0, _react.useLayoutEffect)(function () {
+    return function () {
+      if (!outsideSuspense) {
+        setFallback(null);
+      }
+    };
+  }, [outsideSuspense, setFallback]);
+  return children(outsideSuspense ? null : fallback);
+};
+DynamicFallback.displayName = 'DynamicFallback';
+var LazySuspense = exports.LazySuspense = function LazySuspense(_ref2) {
+  var fallback = _ref2.fallback,
+    children = _ref2.children,
+    name = _ref2.name;
+  var _useState = (0, _react.useState)(null),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    hydrationFallback = _useState2[0],
+    setHydrationFallback = _useState2[1];
+  var mountedRef = (0, _react.useRef)(false);
+  (0, _react.useLayoutEffect)(function () {
+    mountedRef.current = true;
+    return function () {
+      mountedRef.current = false;
+    };
+  }, []);
+  var contextValue = (0, _react.useMemo)(function () {
+    return {
+      fallback: fallback,
+      setFallback: function setFallback(newFallback) {
+        if (hydrationFallback === newFallback) {
+          return;
+        }
+        setHydrationFallback(newFallback);
+      },
+      name: name
+    };
+  }, [fallback, hydrationFallback, name]);
+  var renderFallback = function renderFallback(outsideSuspense) {
+    return /*#__PURE__*/_react.default.createElement(DynamicFallback, {
+      outsideSuspense: outsideSuspense
+    }, function (resolvedFallback) {
+      return outsideSuspense && hydrationFallback ? hydrationFallback : resolvedFallback;
+    });
+  };
+  return /*#__PURE__*/_react.default.createElement(LazySuspenseContext.Provider, {
+    value: contextValue
+  }, isNodeEnvironment() ? children : /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_react.Suspense, {
+    fallback: renderFallback(false)
+  }, children), (!mountedRef.current || hydrationFallback) && renderFallback(true)));
+};
+LazySuspense.displayName = 'LazySuspense';

package/dist/cjs/placeholder/loosely-lazy/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/placeholder/loosely-lazy/wait-context.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WaitContext = void 0;
+var _react = require("react");
+var WaitContext = exports.WaitContext = /*#__PURE__*/(0, _react.createContext)({
+  subscribe: function subscribe() {
+    return function () {};
+  },
+  currentValue: function currentValue() {
+    return 1;
+  }
+});

package/dist/cjs/resource-timing/common/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/resource-timing/common/utils/config.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configure = configure;
+exports.getConfig = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _config = require("../../../config");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var defaultAllowedParams = ['operationName', 'operation', 'q'];
+var getAllowedParams = function getAllowedParams() {
+  var config = (0, _config.getConfig)();
+  return (config === null || config === void 0 ? void 0 : config.allowedResourcesParams) || defaultAllowedParams;
+};
+var handleQueryParams = function handleQueryParams(urlString) {
+  try {
+    if (typeof urlString !== 'string') {
+      return urlString;
+    }
+    var url = new URL(urlString);
+    var params = new URLSearchParams(url.search);
+    var allowedParams = getAllowedParams();
+    var _iterator = _createForOfIteratorHelper(params),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = (0, _slicedToArray2.default)(_step.value, 1),
+          key = _step$value[0];
+        if (!allowedParams.includes(key)) {
+          url.searchParams.delete(key);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return url.toString();
+  } catch (e) {
+    return urlString;
+  }
+};
+var config = {
+  mapResources: function mapResources(url) {
+    return url;
+  },
+  sanitiseEndpoints: function sanitiseEndpoints(url) {
+    return handleQueryParams(url);
+  }
+};
+function configure(resourceTimingConfig) {
+  var newConfig = {
+    mapResources: resourceTimingConfig.mapResources,
+    sanitiseEndpoints: function sanitiseEndpoints(url) {
+      var sanitised = resourceTimingConfig.sanitiseEndpoints(url);
+      if (sanitised) {
+        return handleQueryParams(sanitised);
+      }
+      return sanitised;
+    }
+  };
+  config = newConfig;
+}
+var getConfig = exports.getConfig = function getConfig() {
+  return config;
+};