@cloudcare/browser-core 3.2.3 → 3.2.4

package/src/helper/requestIdleCallback.js

@@ -0,0 +1,38 @@
+import { setTimeout, clearTimeout } from './timer'
+import { monitor } from './monitor'
+import { dateNow } from './tools'
+
+/**
+ * 'requestIdleCallback' with a shim.
+ */
+export function requestIdleCallback(callback, opts) {
+  // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.
+  if (window.requestIdleCallback && window.cancelIdleCallback) {
+    const id = window.requestIdleCallback(monitor(callback), opts)
+    return function () {
+      return window.cancelIdleCallback(id)
+    }
+  }
+  return requestIdleCallbackShim(callback)
+}
+
+export const 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.
+ */
+export function requestIdleCallbackShim(callback) {
+  const start = dateNow()
+  const timeoutId = setTimeout(function () {
+    callback({
+      didTimeout: false,
+      timeRemaining: function () {
+        return Math.max(0, MAX_TASK_TIME - (dateNow() - start))
+      }
+    })
+  }, 0)
+  return function () {
+    return clearTimeout(timeoutId)
+  }
+}

package/src/helper/taskQueue.js

@@ -0,0 +1,55 @@
+import { ONE_SECOND } from './tools'
+import { requestIdleCallback } from './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.
+ */
+const IDLE_CALLBACK_TIMEOUT = 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.
+ */
+export const MAX_EXECUTION_TIME_ON_TIMEOUT = 30
+
+export function createTaskQueue() {
+  const pendingTasks = []
+
+  function run(deadline) {
+    let executionTimeRemaining
+    if (deadline.didTimeout) {
+      const start = performance.now()
+      executionTimeRemaining = function () {
+        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() {
+    requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT })
+  }
+
+  return {
+    push(task) {
+      if (pendingTasks.push(task) === 1) {
+        scheduleNextRun()
+      }
+    }
+  }
+}

package/src/helper/tools.js

@@ -1553,7 +1553,12 @@ export 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

package/src/index.js

@@ -22,6 +22,8 @@ export * from './helper/mobileUtil'
 export * from './helper/getZoneJsOriginalValue'
 export * from './helper/timer'
 export * from './helper/readBytesFromStream'
+export * from './helper/requestIdleCallback'
+export * from './helper/taskQueue'
 export * from './tracekit'
 export * from './configuration/configuration'
 export * from './configuration/transportConfiguration'