@cloudcare/browser-core 1.2.11 → 2.0.1

package/src/helper/readBytesFromStream.js

@@ -0,0 +1,69 @@
+import { noop, each } from './tools'
+
+/**
+ * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
+ * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
+ * has been exceeded if more bytes were available.
+ */
+export function readBytesFromStream(stream, callback, options) {
+  var reader = stream.getReader()
+  var chunks = []
+  var readBytesCount = 0
+
+  readMore()
+
+  function readMore() {
+    reader.read().then(
+      function (result) {
+        if (result.done) {
+          onDone()
+          return
+        }
+
+        if (options.collectStreamBody) {
+          chunks.push(result.value)
+        }
+        readBytesCount += result.value.length
+
+        if (readBytesCount > options.bytesLimit) {
+          onDone()
+        } else {
+          readMore()
+        }
+      },
+      function (error) {
+        callback(error)
+      }
+    )
+  }
+
+  function onDone() {
+    reader.cancel().catch(
+      // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
+      // as an unhandled rejection
+      noop
+    )
+
+    var bytes
+    var limitExceeded
+    if (options.collectStreamBody) {
+      var completeBuffer
+      if (chunks.length === 1) {
+        // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just
+        // use it directly.
+        completeBuffer = chunks[0]
+      } else {
+        // else, we need to copy buffers into a larger buffer to concatenate them.
+        completeBuffer = new Uint8Array(readBytesCount)
+        var offset = 0
+        each(chunks, function (chunk) {
+          completeBuffer.set(chunk, offset)
+          offset += chunk.length
+        })
+      }
+      bytes = completeBuffer.slice(0, options.bytesLimit)
+      limitExceeded = completeBuffer.length > options.bytesLimit
+    }
+    callback(undefined, bytes, limitExceeded)
+  }
+}

package/src/helper/tools.js

@@ -1,3 +1,6 @@
+import { DOM_EVENT } from './enums'
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+
 var ArrayProto = Array.prototype
 var FuncProto = Function.prototype
 var ObjProto = Object.prototype
@@ -260,6 +263,7 @@ export var isObject = function (obj) {
   if (obj === null) return false
   return toString.call(obj) === '[object Object]'
 }
+
 export var isEmptyObject = function (obj) {
   if (isObject(obj)) {
     for (var key in obj) {
@@ -364,45 +368,42 @@ export var now =
     return new Date().getTime()
   }
 
-export var throttle = function (func, wait, options) {
-  var timeout, context, args, result
-  var previous = 0
-  if (!options) options = {}
-
-  var later = function () {
-    previous = options.leading === false ? 0 : new Date().getTime()
-    timeout = null
-    result = func.apply(context, args)
-    if (!timeout) context = args = null
-  }
-
-  var throttled = function () {
-    args = arguments
-    var now = new Date().getTime()
-    if (!previous && options.leading === false) previous = now
-    //下次触发 func 剩余的时间
-    var remaining = wait - (now - previous)
-    context = this
-    // 如果没有剩余的时间了或者你改了系统时间
-    if (remaining <= 0 || remaining > wait) {
-      if (timeout) {
-        clearTimeout(timeout)
-        timeout = null
+export var throttle = function (fn, wait, options) {
+  var needLeadingExecution =
+    options && options.leading !== undefined ? options.leading : true
+  var needTrailingExecution =
+    options && options.trailing !== undefined ? options.trailing : true
+  let inWaitPeriod = false
+  let pendingExecutionWithParameters
+  let pendingTimeoutId
+  var context = this
+  return {
+    throttled: function () {
+      if (inWaitPeriod) {
+        pendingExecutionWithParameters = arguments
+        return
       }
-      previous = now
-      result = func.apply(context, args)
-      if (!timeout) context = args = null
-    } else if (!timeout && options.trailing !== false) {
-      timeout = setTimeout(later, remaining)
+
+      if (needLeadingExecution) {
+        fn.apply(context, arguments)
+      } else {
+        pendingExecutionWithParameters = arguments
+      }
+      inWaitPeriod = true
+      pendingTimeoutId = setTimeout(function () {
+        if (needTrailingExecution && pendingExecutionWithParameters) {
+          fn.apply(context, pendingExecutionWithParameters)
+        }
+        inWaitPeriod = false
+        pendingExecutionWithParameters = undefined
+      }, wait)
+    },
+    cancel: function () {
+      clearTimeout(pendingTimeoutId)
+      inWaitPeriod = false
+      pendingExecutionWithParameters = undefined
     }
-    return result
-  }
-  throttled.cancel = function () {
-    clearTimeout(timeout)
-    previous = 0
-    timeout = null
   }
-  return throttled
 }
 export var hashCode = function (str) {
   if (typeof str !== 'string') {
@@ -1632,7 +1633,9 @@ export function currentDrift() {
   // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
   return Math.round(dateNow() - (getNavigationStart() + performance.now()))
 }
-
+export function addDuration(a, b) {
+  return a + b
+}
 function getCorrectedTimeStamp(relativeTime) {
   var correctedOrigin = dateNow() - performance.now()
   // apply correction only for positive drift
@@ -1676,8 +1679,8 @@ export function safeTruncate(candidate, length) {
   return candidate.slice(0, length)
 }
 
-export function addEventListener(emitter, event, listener, options) {
-  return addEventListeners(emitter, [event], listener, options)
+export function addEventListener(eventTarget, event, listener, options) {
+  return addEventListeners(eventTarget, [event], listener, options)
 }
 
 /**
@@ -1695,8 +1698,9 @@ export function addEventListener(emitter, event, listener, options) {
  * * with `once: true`, the listener will be called at most once, even if different events are
  *   listened
  */
-export function addEventListeners(emitter, events, listener, options) {
-  var wrapedListener =
+
+export function addEventListeners(eventTarget, events, listener, options) {
+  var wrappedListener =
     options && options.once
       ? function (event) {
           stop()
@@ -1708,12 +1712,15 @@ export function addEventListeners(emitter, events, listener, options) {
     options && options.passive
       ? { capture: options.capture, passive: options.passive }
       : options && options.capture
+  var add = getZoneJsOriginalValue(eventTarget, 'addEventListener')
+
   each(events, function (event) {
-    emitter.addEventListener(event, wrapedListener, options)
+    add.call(eventTarget, event, wrappedListener, options)
   })
   var stop = function () {
+    var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener')
     each(events, function (event) {
-      emitter.removeEventListener(event, wrapedListener, options)
+      remove.call(eventTarget, event, wrappedListener, options)
     })
   }
   return {
@@ -1909,3 +1916,65 @@ export function isNullUndefinedDefaultValue(data, defaultValue) {
     return defaultValue
   }
 }
+
+export function runOnReadyState(expectedReadyState, callback) {
+  if (
+    document.readyState === expectedReadyState ||
+    document.readyState === 'complete'
+  ) {
+    callback()
+  } else {
+    var eventName =
+      expectedReadyState === 'complete'
+        ? DOM_EVENT.LOAD
+        : DOM_EVENT.DOM_CONTENT_LOADED
+    addEventListener(window, eventName, callback, { once: true })
+  }
+}
+
+export function requestIdleCallback(callback, opts) {
+  // Use 'requestIdleCallback' when available: it will throttle the mutation processing if the
+  // browser is busy rendering frames (ex: when frames are below 60fps). When not available, the
+  // fallback on 'requestAnimationFrame' will still ensure the mutations are processed after any
+  // browser rendering process (Layout, Recalculate Style, etc.), so we can serialize DOM nodes
+  // efficiently.
+  if (window.requestIdleCallback) {
+    var id = window.requestIdleCallback(callback, opts)
+    return function () {
+      return window.cancelIdleCallback(id)
+    }
+  }
+  var id = window.requestAnimationFrame(callback)
+  return function () {
+    return window.cancelAnimationFrame(id)
+  }
+}
+export function objectHasValue(object, value) {
+  return some(keys(object), function (key) {
+    return object[key] === value
+  })
+}
+export function startsWith(candidate, search) {
+  return candidate.slice(0, search.length) === search
+}
+
+export function endsWith(candidate, search) {
+  return candidate.slice(-search.length) === search
+}
+
+export function tryToClone(response) {
+  try {
+    return response.clone()
+  } catch (e) {
+    // clone can throw if the response has already been used by another instrumentation or is disturbed
+    return
+  }
+}
+export function isHashAnAnchor(hash) {
+  var correspondingId = hash.substr(1)
+  return !!document.getElementById(correspondingId)
+}
+export function getPathFromHash(hash) {
+  var index = hash.indexOf('?')
+  return index < 0 ? hash : hash.slice(0, index)
+}

package/src/index.js

@@ -16,12 +16,16 @@ export * from './helper/observable'
 export * from './helper/tools'
 export * from './helper/urlPolyfill'
 export * from './helper/mobileUtil'
+export * from './helper/getZoneJsOriginalValue'
+export * from './helper/readBytesFromStream'
 export * from './tracekit'
 export * from './configuration/configuration'
 export * from './configuration/transportConfiguration'
 export * from './browser/cookie'
 export * from './browser/fetchObservable'
 export * from './browser/xhrObservable'
+export * from './browser/pageExitObservable'
+export * from './browser/htmlDomUtils'
 export * from './dataMap'
 export * from './init'
 export * from './session/sessionManagement'
@@ -30,4 +34,3 @@ export * from './session/sessionCookieStore'
 export * from './session/sessionStore'
 export * from './transport'
 export * from './synthetics/syntheticsWorkerValues'
-

package/src/session/sessionStore.js

@@ -10,11 +10,7 @@ import { retrieveSession, withCookieLockAccess } from './sessionCookieStore'
  * - not tracked, the session does not have an id but it is updated along the user navigation
  * - inactive, no session in store or session expired, waiting for a renew session
  */
-export function startSessionStore(
-  options,
-  productKey,
-  computeSessionState
-) {
+export function startSessionStore(options, productKey, computeSessionState) {
   var renewObservable = new Observable()
   var expireObservable = new Observable()
 
@@ -25,26 +21,28 @@ export function startSessionStore(
     var isTracked
     withCookieLockAccess({
       options: options,
-      process: function(cookieSession){
+      process: function (cookieSession) {
         var synchronizedSession = synchronizeSession(cookieSession)
         isTracked = expandOrRenewCookie(synchronizedSession)
         return synchronizedSession
       },
-      after: function(cookieSession) {
+      after: function (cookieSession) {
         if (isTracked && !hasSessionInCache()) {
           renewSession(cookieSession)
         }
         sessionCache = cookieSession
-      },
+      }
     })
   }
 
   function expandSession() {
     withCookieLockAccess({
       options: options,
-      process: function(cookieSession) {
-        return (hasSessionInCache() ? synchronizeSession(cookieSession) : undefined)
-      },
+      process: function (cookieSession) {
+        return hasSessionInCache()
+          ? synchronizeSession(cookieSession)
+          : undefined
+      }
     })
   }
 
@@ -55,11 +53,11 @@ export function startSessionStore(
    */
   function watchSession() {
     withCookieLockAccess({
-      options:options,
-      process: function(cookieSession) {
-        return (!isActiveSession(cookieSession) ? {} : undefined)
+      options: options,
+      process: function (cookieSession) {
+        return !isActiveSession(cookieSession) ? {} : undefined
       },
-      after: synchronizeSession,
+      after: synchronizeSession
     })
   }
 
@@ -78,7 +76,7 @@ export function startSessionStore(
   }
 
   function expandOrRenewCookie(cookieSession) {
-    var sessionState= computeSessionState(cookieSession[productKey])
+    var sessionState = computeSessionState(cookieSession[productKey])
     var trackingType = sessionState.trackingType
     var isTracked = sessionState.isTracked
     cookieSession[productKey] = trackingType
@@ -94,7 +92,10 @@ export function startSessionStore(
   }
 
   function isSessionInCacheOutdated(cookieSession) {
-    return sessionCache.id !== cookieSession.id || sessionCache[productKey] !== cookieSession[productKey]
+    return (
+      sessionCache.id !== cookieSession.id ||
+      sessionCache[productKey] !== cookieSession[productKey]
+    )
   }
 
   function expireSession() {
@@ -119,21 +120,23 @@ export function startSessionStore(
     // created and expire can be undefined for versions which was not storing them
     // these checks could be removed when older versions will not be available/live anymore
     return (
-      (session.created === undefined || dateNow() - Number(session.created) < SESSION_TIME_OUT_DELAY) &&
+      (session.created === undefined ||
+        dateNow() - Number(session.created) < SESSION_TIME_OUT_DELAY) &&
       (session.expire === undefined || dateNow() < Number(session.expire))
     )
   }
 
   return {
-    expandOrRenewSession: throttle(expandOrRenewSession, COOKIE_ACCESS_DELAY),
+    expandOrRenewSession: throttle(expandOrRenewSession, COOKIE_ACCESS_DELAY)
+      .throttled,
     expandSession: expandSession,
-    getSession: function() {
+    getSession: function () {
       return sessionCache
     },
-    renewObservable:renewObservable,
-    expireObservable:expireObservable,
-    stop: function() {
+    renewObservable: renewObservable,
+    expireObservable: expireObservable,
+    stop: function () {
       clearInterval(watchSessionTimeoutId)
-    },
+    }
   }
 }

package/src/synthetics/syntheticsWorkerValues.js

@@ -1,22 +1,26 @@
 import { getCookie } from '../browser/cookie'
 
-export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'guance-synthetics-public-id'
-export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'guance-synthetics-result-id'
-export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'guance-synthetics-injects-rum'
-
+export var SYNTHETICS_TEST_ID_COOKIE_NAME = 'guance-synthetics-public-id'
+export var SYNTHETICS_RESULT_ID_COOKIE_NAME = 'guance-synthetics-result-id'
+export var SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'guance-synthetics-injects-rum'
 
 export function willSyntheticsInjectRum() {
   return Boolean(
-    window._GUANCE_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+    window._GUANCE_SYNTHETICS_INJECTS_RUM ||
+      getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
   )
 }
 
 export function getSyntheticsTestId() {
-  var value = window._GUANCE_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
+  var value =
+    window._GUANCE_SYNTHETICS_PUBLIC_ID ||
+    getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
   return typeof value === 'string' ? value : undefined
 }
 
 export function getSyntheticsResultId() {
-  const value = window._GUANCE_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
+  var value =
+    window._GUANCE_SYNTHETICS_RESULT_ID ||
+    getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
   return typeof value === 'string' ? value : undefined
 }