@cloudcare/browser-core 3.2.3 → 3.2.4

package/cjs/helper/requestIdleCallback.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAX_TASK_TIME = void 0;
+exports.requestIdleCallback = requestIdleCallback;
+exports.requestIdleCallbackShim = requestIdleCallbackShim;
+var _timer = require("./timer");
+var _monitor = require("./monitor");
+var _tools = require("./tools");
+/**
+ * 'requestIdleCallback' with a shim.
+ */
+function requestIdleCallback(callback, opts) {
+  // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.
+  if (window.requestIdleCallback && window.cancelIdleCallback) {
+    var id = window.requestIdleCallback((0, _monitor.monitor)(callback), opts);
+    return function () {
+      return window.cancelIdleCallback(id);
+    };
+  }
+  return requestIdleCallbackShim(callback);
+}
+var MAX_TASK_TIME = 50;
+
+/*
+ * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback
+ * Note: there is no simple way to support the "timeout" option, so we ignore it.
+ */
+exports.MAX_TASK_TIME = MAX_TASK_TIME;
+function requestIdleCallbackShim(callback) {
+  var start = (0, _tools.dateNow)();
+  var timeoutId = (0, _timer.setTimeout)(function () {
+    callback({
+      didTimeout: false,
+      timeRemaining: function timeRemaining() {
+        return Math.max(0, MAX_TASK_TIME - ((0, _tools.dateNow)() - start));
+      }
+    });
+  }, 0);
+  return function () {
+    return (0, _timer.clearTimeout)(timeoutId);
+  };
+}
+//# sourceMappingURL=requestIdleCallback.js.map

package/cjs/helper/requestIdleCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestIdleCallback.js","names":["_timer","require","_monitor","_tools","requestIdleCallback","callback","opts","window","cancelIdleCallback","id","monitor","requestIdleCallbackShim","MAX_TASK_TIME","exports","start","dateNow","timeoutId","setTimeout","didTimeout","timeRemaining","Math","max","clearTimeout"],"sources":["../../src/helper/requestIdleCallback.js"],"sourcesContent":["import { setTimeout, clearTimeout } from './timer'\nimport { monitor } from './monitor'\nimport { dateNow } from './tools'\n\n/**\n * 'requestIdleCallback' with a shim.\n */\nexport function requestIdleCallback(callback, opts) {\n  // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.\n  if (window.requestIdleCallback && window.cancelIdleCallback) {\n    const id = window.requestIdleCallback(monitor(callback), opts)\n    return function () {\n      return window.cancelIdleCallback(id)\n    }\n  }\n  return requestIdleCallbackShim(callback)\n}\n\nexport const MAX_TASK_TIME = 50\n\n/*\n * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback\n * Note: there is no simple way to support the \"timeout\" option, so we ignore it.\n */\nexport function requestIdleCallbackShim(callback) {\n  const start = dateNow()\n  const timeoutId = setTimeout(function () {\n    callback({\n      didTimeout: false,\n      timeRemaining: function () {\n        return Math.max(0, MAX_TASK_TIME - (dateNow() - start))\n      }\n    })\n  }, 0)\n  return function () {\n    return clearTimeout(timeoutId)\n  }\n}\n"],"mappings":";;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AAEA;AACA;AACA;AACO,SAASG,mBAAmBA,CAACC,QAAQ,EAAEC,IAAI,EAAE;EAClD;EACA,IAAIC,MAAM,CAACH,mBAAmB,IAAIG,MAAM,CAACC,kBAAkB,EAAE;IAC3D,IAAMC,EAAE,GAAGF,MAAM,CAACH,mBAAmB,CAAC,IAAAM,gBAAO,EAACL,QAAQ,CAAC,EAAEC,IAAI,CAAC;IAC9D,OAAO,YAAY;MACjB,OAAOC,MAAM,CAACC,kBAAkB,CAACC,EAAE,CAAC;IACtC,CAAC;EACH;EACA,OAAOE,uBAAuB,CAACN,QAAQ,CAAC;AAC1C;AAEO,IAAMO,aAAa,GAAG,EAAE;;AAE/B;AACA;AACA;AACA;AAHAC,OAAA,CAAAD,aAAA,GAAAA,aAAA;AAIO,SAASD,uBAAuBA,CAACN,QAAQ,EAAE;EAChD,IAAMS,KAAK,GAAG,IAAAC,cAAO,EAAC,CAAC;EACvB,IAAMC,SAAS,GAAG,IAAAC,iBAAU,EAAC,YAAY;IACvCZ,QAAQ,CAAC;MACPa,UAAU,EAAE,KAAK;MACjBC,aAAa,EAAE,SAAAA,cAAA,EAAY;QACzB,OAAOC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAET,aAAa,IAAI,IAAAG,cAAO,EAAC,CAAC,GAAGD,KAAK,CAAC,CAAC;MACzD;IACF,CAAC,CAAC;EACJ,CAAC,EAAE,CAAC,CAAC;EACL,OAAO,YAAY;IACjB,OAAO,IAAAQ,mBAAY,EAACN,SAAS,CAAC;EAChC,CAAC;AACH","ignoreList":[]}

package/cjs/helper/taskQueue.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAX_EXECUTION_TIME_ON_TIMEOUT = void 0;
+exports.createTaskQueue = createTaskQueue;
+var _tools = require("./tools");
+var _requestIdleCallback = require("./requestIdleCallback");
+/**
+ * Maximum delay before starting to execute tasks in the queue. We don't want to wait too long
+ * before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose
+ * the opportunity to send some data). We also don't want to run tasks too often, as it might hurt
+ * performance.
+ */
+var IDLE_CALLBACK_TIMEOUT = _tools.ONE_SECOND;
+
+/**
+ * Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is
+ * reached. We should not run tasks for too long as it will hurt performance, but we should still
+ * run some tasks to avoid postponing them forever.
+ *
+ * Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.
+ */
+var MAX_EXECUTION_TIME_ON_TIMEOUT = 30;
+exports.MAX_EXECUTION_TIME_ON_TIMEOUT = MAX_EXECUTION_TIME_ON_TIMEOUT;
+function createTaskQueue() {
+  var pendingTasks = [];
+  function run(deadline) {
+    var executionTimeRemaining;
+    if (deadline.didTimeout) {
+      var start = performance.now();
+      executionTimeRemaining = function executionTimeRemaining() {
+        return MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start);
+      };
+    } else {
+      executionTimeRemaining = deadline.timeRemaining.bind(deadline);
+    }
+    while (executionTimeRemaining() > 0 && pendingTasks.length) {
+      pendingTasks.shift()();
+    }
+    if (pendingTasks.length) {
+      scheduleNextRun();
+    }
+  }
+  function scheduleNextRun() {
+    (0, _requestIdleCallback.requestIdleCallback)(run, {
+      timeout: IDLE_CALLBACK_TIMEOUT
+    });
+  }
+  return {
+    push: function push(task) {
+      if (pendingTasks.push(task) === 1) {
+        scheduleNextRun();
+      }
+    }
+  };
+}
+//# sourceMappingURL=taskQueue.js.map

package/cjs/helper/taskQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskQueue.js","names":["_tools","require","_requestIdleCallback","IDLE_CALLBACK_TIMEOUT","ONE_SECOND","MAX_EXECUTION_TIME_ON_TIMEOUT","exports","createTaskQueue","pendingTasks","run","deadline","executionTimeRemaining","didTimeout","start","performance","now","timeRemaining","bind","length","shift","scheduleNextRun","requestIdleCallback","timeout","push","task"],"sources":["../../src/helper/taskQueue.js"],"sourcesContent":["import { ONE_SECOND } from './tools'\nimport { requestIdleCallback } from './requestIdleCallback'\n\n/**\n * Maximum delay before starting to execute tasks in the queue. We don't want to wait too long\n * before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose\n * the opportunity to send some data). We also don't want to run tasks too often, as it might hurt\n * performance.\n */\nconst IDLE_CALLBACK_TIMEOUT = ONE_SECOND\n\n/**\n * Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is\n * reached. We should not run tasks for too long as it will hurt performance, but we should still\n * run some tasks to avoid postponing them forever.\n *\n * Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.\n */\nexport const MAX_EXECUTION_TIME_ON_TIMEOUT = 30\n\nexport function createTaskQueue() {\n  const pendingTasks = []\n\n  function run(deadline) {\n    let executionTimeRemaining\n    if (deadline.didTimeout) {\n      const start = performance.now()\n      executionTimeRemaining = function () {\n        return MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start)\n      }\n    } else {\n      executionTimeRemaining = deadline.timeRemaining.bind(deadline)\n    }\n\n    while (executionTimeRemaining() > 0 && pendingTasks.length) {\n      pendingTasks.shift()()\n    }\n\n    if (pendingTasks.length) {\n      scheduleNextRun()\n    }\n  }\n\n  function scheduleNextRun() {\n    requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT })\n  }\n\n  return {\n    push(task) {\n      if (pendingTasks.push(task) === 1) {\n        scheduleNextRun()\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,oBAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAME,qBAAqB,GAAGC,iBAAU;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMC,6BAA6B,GAAG,EAAE;AAAAC,OAAA,CAAAD,6BAAA,GAAAA,6BAAA;AAExC,SAASE,eAAeA,CAAA,EAAG;EAChC,IAAMC,YAAY,GAAG,EAAE;EAEvB,SAASC,GAAGA,CAACC,QAAQ,EAAE;IACrB,IAAIC,sBAAsB;IAC1B,IAAID,QAAQ,CAACE,UAAU,EAAE;MACvB,IAAMC,KAAK,GAAGC,WAAW,CAACC,GAAG,CAAC,CAAC;MAC/BJ,sBAAsB,GAAG,SAAAA,uBAAA,EAAY;QACnC,OAAON,6BAA6B,IAAIS,WAAW,CAACC,GAAG,CAAC,CAAC,GAAGF,KAAK,CAAC;MACpE,CAAC;IACH,CAAC,MAAM;MACLF,sBAAsB,GAAGD,QAAQ,CAACM,aAAa,CAACC,IAAI,CAACP,QAAQ,CAAC;IAChE;IAEA,OAAOC,sBAAsB,CAAC,CAAC,GAAG,CAAC,IAAIH,YAAY,CAACU,MAAM,EAAE;MAC1DV,YAAY,CAACW,KAAK,CAAC,CAAC,CAAC,CAAC;IACxB;IAEA,IAAIX,YAAY,CAACU,MAAM,EAAE;MACvBE,eAAe,CAAC,CAAC;IACnB;EACF;EAEA,SAASA,eAAeA,CAAA,EAAG;IACzB,IAAAC,wCAAmB,EAACZ,GAAG,EAAE;MAAEa,OAAO,EAAEnB;IAAsB,CAAC,CAAC;EAC9D;EAEA,OAAO;IACLoB,IAAI,WAAAA,KAACC,IAAI,EAAE;MACT,IAAIhB,YAAY,CAACe,IAAI,CAACC,IAAI,CAAC,KAAK,CAAC,EAAE;QACjCJ,eAAe,CAAC,CAAC;MACnB;IACF;EACF,CAAC;AACH","ignoreList":[]}

package/cjs/helper/tools.js

@@ -1545,7 +1545,7 @@ function findByPath(source, path) {
   var pathArr = path.split('.');
   while (pathArr.length) {
     var key = pathArr.shift();
-    if (source && key in source && hasOwnProperty.call(source, key)) {
+    if (source && isObject(source) && key in source && hasOwnProperty.call(source, key)) {
       source = source[key];
     } else {
       return undefined;