@cloudcare/browser-core 1.1.2 → 1.2.0

package/esm/helper/tools.js

@@ -196,6 +196,77 @@ export var map = function map(arr, fn, self) {
 
   return ret;
 };
+export var some = function some(arr, fn, self) {
+  if (arr.some) {
+    return arr.some(fn);
+  }
+
+  var flag = false;
+
+  for (var i = 0; i < arr.length; i++) {
+    if (!hasOwnProperty.call(arr, i)) {
+      continue;
+    }
+
+    var val = arr[i];
+
+    if (fn.call(self, val, i, arr)) {
+      flag = true;
+      break;
+    }
+  }
+
+  return flag;
+};
+export var every = function every(arr, fn, self) {
+  if (arr.every) {
+    return arr.every(fn);
+  }
+
+  var flag = true;
+
+  for (var i = 0; i < arr.length; i++) {
+    if (!hasOwnProperty.call(arr, i)) {
+      continue;
+    }
+
+    var val = arr[i];
+
+    if (!fn.call(self, val, i, arr)) {
+      flag = false;
+      break;
+    }
+  }
+
+  return flag;
+};
+export var matchList = function matchList(list, value) {
+  return some(list, function (item) {
+    return item === value || item instanceof RegExp && item.test(value);
+  });
+}; // https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js
+
+export var cssEscape = function cssEscape(str) {
+  if (window.CSS && window.CSS.escape) {
+    return window.CSS.escape(str);
+  } // eslint-disable-next-line no-control-regex
+
+
+  return str.replace(/([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g, function (ch, asCodePoint) {
+    if (asCodePoint) {
+      // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+      if (ch === '\0') {
+        return '\uFFFD';
+      } // Control characters and (dependent upon position) numbers get escaped as code points
+
+
+      return ch.slice(0, -1) + '\\' + ch.charCodeAt(ch.length - 1).toString(16) + ' ';
+    } // Other potentially-special ASCII characters get backslash-escaped
+
+
+    return '\\' + ch;
+  });
+};
 export var inherit = function inherit(subclass, superclass) {
   var F = function F() {};
 
@@ -671,6 +742,18 @@ export var urlParse = function urlParse(para) {
 
   return new URLParser(para);
 };
+export function elementMatches(element, selector) {
+  if (element.matches) {
+    return element.matches(selector);
+  } // IE11 support
+
+
+  if (element.msMatchesSelector) {
+    return element.msMatchesSelector(selector);
+  }
+
+  return false;
+}
 export var addEvent = function addEvent() {
   function fixEvent(event) {
     if (event) {
@@ -1487,7 +1570,10 @@ export function noop() {}
 export var ONE_SECOND = 1000;
 export var ONE_MINUTE = 60 * ONE_SECOND;
 export var ONE_HOUR = 60 * ONE_MINUTE;
-export var ONE_KILO_BYTE = 1024;
+export var ONE_DAY = 24 * ONE_HOUR;
+export var ONE_YEAR = 365 * ONE_DAY;
+export var ONE_KIBI_BYTE = 1024;
+export var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;
 /**
  * Return true if the draw is successful
  * @param threshold between 0 and 100
@@ -1527,7 +1613,7 @@ export function preferredNow() {
   return relativeNow();
 }
 export function getTimestamp(relativeTime) {
-  return Math.floor(getNavigationStart() + relativeTime);
+  return Math.round(getNavigationStart() + relativeTime);
 }
 export function relativeNow() {
   return performance.now();
@@ -1539,6 +1625,17 @@ export function clocksNow() {
   };
 }
 export function timeStampNow() {
+  return dateNow();
+}
+export function looksLikeRelativeTime(time) {
+  return time < ONE_YEAR;
+}
+export function dateNow() {
+  // Do not use `Date.now` because sometimes websites are wrongly "polyfilling" it. For example, we
+  // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date
+  // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this
+  // case ourselves.
+  // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16
   return new Date().getTime();
 }
 export function elapsed(start, end) {
@@ -1559,13 +1656,28 @@ export function preferredTimeStamp(clocks) {
 export function relativeToClocks(relative) {
   return {
     relative: relative,
-    timeStamp: getTimestamp(relative)
+    timeStamp: getCorrectedTimeStamp(relative)
   };
 }
+export function currentDrift() {
+  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+  return Math.round(dateNow() - (getNavigationStart() + performance.now()));
+}
+
+function getCorrectedTimeStamp(relativeTime) {
+  var correctedOrigin = dateNow() - performance.now(); // apply correction only for positive drift
+
+  if (correctedOrigin > getNavigationStart()) {
+    return Math.round(correctedOrigin + relativeTime);
+  }
+
+  return getTimestamp(relativeTime);
+}
 /**
  * Navigation start slightly change on some rare cases
  */
 
+
 var navigationStart;
 export function getNavigationStart() {
   if (navigationStart === undefined) {
@@ -1670,6 +1782,21 @@ export function createContextManager() {
       } else {
         console.error('content 需要传递对象类型数据');
       }
+    },
+    getContext: function getContext() {
+      return deepClone(context);
+    },
+    setContext: function setContext(newContext) {
+      context = deepClone(newContext);
+    },
+    setContextProperty: function setContextProperty(key, property) {
+      context[key] = deepClone(property);
+    },
+    removeContextProperty: function removeContextProperty(key) {
+      delete context[key];
+    },
+    clearContext: function clearContext() {
+      context = {};
     }
   };
 }
@@ -1684,12 +1811,48 @@ export function find(array, predicate) {
 
   return undefined;
 }
+export function arrayFrom(arrayLike) {
+  if (Array.from) {
+    return Array.from(arrayLike);
+  }
+
+  var array = [];
+
+  if (arrayLike instanceof Set) {
+    arrayLike.forEach(function (item) {
+      array.push(item);
+    });
+  } else {
+    for (var i = 0; i < arrayLike.length; i++) {
+      array.push(arrayLike[i]);
+    }
+  }
+
+  return array;
+}
+export function findLast(array, predicate) {
+  for (var i = array.length - 1; i >= 0; i -= 1) {
+    var item = array[i];
+
+    if (predicate(item, i, array)) {
+      return item;
+    }
+  }
+
+  return undefined;
+}
 export function isPercentage(value) {
   return isNumber(value) && value >= 0 && value <= 100;
 }
 export function getLocationOrigin() {
   return getLinkElementOrigin(window.location);
 }
+export function isIE() {
+  return Boolean(document.documentMode);
+}
+export function isChromium() {
+  return !!window.chrome || /HeadlessChrome/.test(window.navigator.userAgent);
+}
 /**
  * IE fallback
  * https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin
@@ -1758,4 +1921,11 @@ export function escapeRowField(value) {
   } else {
     return value;
   }
+}
+export function isNullUndefinedDefaultValue(data, defaultValue) {
+  if (data !== null && data !== void 0) {
+    return data;
+  } else {
+    return defaultValue;
+  }
 }

package/esm/index.js

@@ -1,22 +1,32 @@
 export * from './helper/boundedBuffer';
+export * from './helper/contextHistory';
 export * from './helper/deviceInfo';
 export * from './helper/enums';
-export * from './helper/errorFilter';
+export * from './helper/instrumentMethod';
 export * from './helper/errorTools';
+export * from './error/trackRuntimeError';
+export * from './console/consoleObservable';
+export * from './report/reportObservable';
+export * from './helper/display';
 export * from './helper/eventEmitter';
 export * from './helper/lifeCycle';
 export * from './helper/limitModification';
+export * from './helper/createEventRateLimiter';
 export * from './helper/observable';
 export * from './helper/tools';
 export * from './helper/urlPolyfill';
 export * from './helper/mobileUtil';
 export * from './tracekit';
-export * from './configuration';
-export * from './cookie';
+export * from './configuration/configuration';
+export * from './configuration/transportConfiguration';
+export * from './browser/cookie';
+export * from './browser/fetchObservable';
+export * from './browser/xhrObservable';
 export * from './dataMap';
-export * from './errorCollection';
-export * from './fetchProxy';
 export * from './init';
-export * from './sessionManagement';
+export * from './session/sessionManagement';
+export * from './session/sessionConstants';
+export * from './session/sessionCookieStore';
+export * from './session/sessionStore';
 export * from './transport';
-export * from './xhrProxy';
+export * from './synthetics/syntheticsWorkerValues';

package/esm/init.js

@@ -1,5 +1,4 @@
 import { extend, each } from './helper/tools';
-import { areCookiesAuthorized } from './cookie';
 export function makeGlobal(stub) {
   var global = extend({}, stub, {
     onReady: function onReady(callback) {
@@ -63,24 +62,20 @@ export function getGlobalObject() {
   }
 
   return globalObject;
-}
-export function checkCookiesAuthorized(options) {
-  if (!areCookiesAuthorized(options)) {
-    console.warn('Cookies are not authorized, we will not send any data.');
-    return false;
-  }
-
-  return true;
-}
-export function checkIsNotLocalFile() {
-  if (isLocalFile()) {
-    console.error('Execution is not allowed in the current context.');
-    return false;
-  }
-
-  return true;
-}
-
-function isLocalFile() {
-  return window.location.protocol === 'file:';
-}
+} // export function checkCookiesAuthorized(options) {
+//   if (!areCookiesAuthorized(options)) {
+//     console.warn('Cookies are not authorized, we will not send any data.')
+//     return false
+//   }
+//   return true
+// }
+// export function checkIsNotLocalFile() {
+//   if (isLocalFile()) {
+//     console.error('Execution is not allowed in the current context.')
+//     return false
+//   }
+//   return true
+// }
+// function isLocalFile() {
+//   return window.location.protocol === 'file:'
+// }

package/esm/report/reportObservable.js

@@ -0,0 +1,98 @@
+import { toStackTraceString } from '../helper/errorTools';
+import { mergeObservables, Observable } from '../helper/observable';
+import { includes, addEventListener, safeTruncate, filter, each } from '../helper/tools';
+import { DOM_EVENT } from '../helper/enums';
+export var RawReportType = {
+  intervention: 'intervention',
+  deprecation: 'deprecation',
+  cspViolation: 'csp_violation'
+};
+export function initReportObservable(apis) {
+  var observables = [];
+
+  if (includes(apis, RawReportType.cspViolation)) {
+    observables.push(createCspViolationReportObservable());
+  }
+
+  var reportTypes = filter(apis, function (api) {
+    return api !== RawReportType.cspViolation;
+  });
+
+  if (reportTypes.length) {
+    observables.push(createReportObservable(reportTypes));
+  }
+
+  return mergeObservables.apply(this, observables);
+}
+
+function createReportObservable(reportTypes) {
+  var observable = new Observable(function () {
+    if (!window.ReportingObserver) {
+      return;
+    }
+
+    var handleReports = function handleReports(reports) {
+      each(reports, function (report) {
+        observable.notify(buildRawReportFromReport(report));
+      });
+    };
+
+    var observer = new window.ReportingObserver(handleReports, {
+      types: reportTypes,
+      buffered: true
+    });
+    observer.observe();
+    return function () {
+      observer.disconnect();
+    };
+  });
+  return observable;
+}
+
+function createCspViolationReportObservable() {
+  var observable = new Observable(function () {
+    var handleCspViolation = function handleCspViolation(event) {
+      observable.notify(buildRawReportFromCspViolation(event));
+    };
+
+    var _addEventListener = addEventListener(document, DOM_EVENT.SECURITY_POLICY_VIOLATION, handleCspViolation);
+
+    return _addEventListener.stop;
+  });
+  return observable;
+}
+
+function buildRawReportFromReport(report) {
+  var body = report.body;
+  var type = report.type;
+  return {
+    type: type,
+    subtype: body.id,
+    message: type + ': ' + body.message,
+    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber)
+  };
+}
+
+function buildRawReportFromCspViolation(event) {
+  var type = RawReportType.cspViolation;
+  var message = '\'' + event.blockedURI + '\' blocked by \'' + event.effectiveDirective + '\' directive';
+  return {
+    type: RawReportType.cspViolation,
+    subtype: event.effectiveDirective,
+    message: type + ': ' + message,
+    stack: buildStack(event.effectiveDirective, message + ' of the policy "' + safeTruncate(event.originalPolicy, 100, '...') + '"', event.sourceFile, event.lineNumber, event.columnNumber)
+  };
+}
+
+function buildStack(name, message, sourceFile, lineNumber, columnNumber) {
+  return sourceFile && toStackTraceString({
+    name: name,
+    message: message,
+    stack: [{
+      func: '?',
+      url: sourceFile,
+      line: lineNumber,
+      column: columnNumber
+    }]
+  });
+}

package/esm/session/sessionConstants.js

@@ -0,0 +1,3 @@
+import { ONE_HOUR, ONE_MINUTE } from '../helper/tools';
+export var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;
+export var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;

package/esm/session/sessionCookieStore.js

@@ -0,0 +1,168 @@
+import { getCookie, setCookie } from '../browser/cookie';
+import { isChromium, dateNow, isEmptyObject, UUID, objectEntries, map, each } from '../helper/tools';
+import { SESSION_EXPIRATION_DELAY } from './sessionConstants';
+var SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/;
+var SESSION_ENTRY_SEPARATOR = '&';
+export var SESSION_COOKIE_NAME = '_dataflux_s'; // arbitrary values
+
+export var LOCK_RETRY_DELAY = 10;
+export var MAX_NUMBER_OF_LOCK_RETRIES = 100;
+var bufferedOperations = [];
+var ongoingOperations;
+export function withCookieLockAccess(operations, numberOfRetries) {
+  if (typeof numberOfRetries === 'undefined') {
+    numberOfRetries = 0;
+  }
+
+  if (!ongoingOperations) {
+    ongoingOperations = operations;
+  }
+
+  if (operations !== ongoingOperations) {
+    bufferedOperations.push(operations);
+    return;
+  }
+
+  if (numberOfRetries >= MAX_NUMBER_OF_LOCK_RETRIES) {
+    next();
+    return;
+  }
+
+  var currentLock;
+  var currentSession = retrieveSession();
+
+  if (isCookieLockEnabled()) {
+    // if someone has lock, retry later
+    if (currentSession.lock) {
+      retryLater(operations, numberOfRetries);
+      return;
+    } // acquire lock
+
+
+    currentLock = UUID();
+    currentSession.lock = currentLock;
+    setSession(currentSession, operations.options); // if lock is not acquired, retry later
+
+    currentSession = retrieveSession();
+
+    if (currentSession.lock !== currentLock) {
+      retryLater(operations, numberOfRetries);
+      return;
+    }
+  }
+
+  var processedSession = operations.process(currentSession);
+
+  if (isCookieLockEnabled()) {
+    // if lock corrupted after process, retry later
+    currentSession = retrieveSession();
+
+    if (currentSession.lock !== currentLock) {
+      retryLater(operations, numberOfRetries);
+      return;
+    }
+  }
+
+  if (processedSession) {
+    persistSession(processedSession, operations.options);
+  }
+
+  if (isCookieLockEnabled()) {
+    // correctly handle lock around expiration would require to handle this case properly at several levels
+    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
+    if (!(processedSession && isExpiredState(processedSession))) {
+      // if lock corrupted after persist, retry later
+      currentSession = retrieveSession();
+
+      if (currentSession.lock !== currentLock) {
+        retryLater(operations, numberOfRetries);
+        return;
+      }
+
+      delete currentSession.lock;
+      setSession(currentSession, operations.options);
+      processedSession = currentSession;
+    }
+  } // call after even if session is not persisted in order to perform operations on
+  // up-to-date cookie value, the value could have been modified by another tab
+
+
+  if (operations.after) {
+    operations.after(processedSession || currentSession);
+  }
+
+  next();
+}
+/**
+ * Cookie lock strategy allows mitigating issues due to concurrent access to cookie.
+ * This issue concerns only chromium browsers and enabling this on firefox increase cookie write failures.
+ */
+
+function isCookieLockEnabled() {
+  return isChromium();
+}
+
+function retryLater(operations, currentNumberOfRetries) {
+  setTimeout(function () {
+    withCookieLockAccess(operations, currentNumberOfRetries + 1);
+  }, LOCK_RETRY_DELAY);
+}
+
+function next() {
+  ongoingOperations = undefined;
+  var nextOperations = bufferedOperations.shift();
+
+  if (nextOperations) {
+    withCookieLockAccess(nextOperations);
+  }
+}
+
+export function persistSession(session, options) {
+  if (isExpiredState(session)) {
+    clearSession(options);
+    return;
+  }
+
+  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);
+  setSession(session, options);
+}
+
+function setSession(session, options) {
+  setCookie(SESSION_COOKIE_NAME, toSessionString(session), SESSION_EXPIRATION_DELAY, options);
+}
+
+export function toSessionString(session) {
+  return map(objectEntries(session), function (item) {
+    return item[0] + '=' + item[1];
+  }).join(SESSION_ENTRY_SEPARATOR);
+}
+export function retrieveSession() {
+  var sessionString = getCookie(SESSION_COOKIE_NAME);
+  var session = {};
+
+  if (isValidSessionString(sessionString)) {
+    each(sessionString.split(SESSION_ENTRY_SEPARATOR), function (entry) {
+      var matches = SESSION_ENTRY_REGEXP.exec(entry);
+
+      if (matches !== null) {
+        var key = matches[1];
+        var value = matches[2];
+        session[key] = value;
+      }
+    });
+  }
+
+  return session;
+}
+
+function isValidSessionString(sessionString) {
+  return sessionString !== undefined && (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString));
+}
+
+function isExpiredState(session) {
+  return isEmptyObject(session);
+}
+
+function clearSession(options) {
+  setCookie(SESSION_COOKIE_NAME, '', 0, options);
+}

package/esm/session/sessionManagement.js

@@ -0,0 +1,78 @@
+import { relativeNow, clocksOrigin, ONE_MINUTE, each, addEventListeners, addEventListener } from '../helper/tools';
+import { ContextHistory } from '../helper/contextHistory';
+import { startSessionStore } from './sessionStore';
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants';
+import { DOM_EVENT } from '../helper/enums';
+export var VISIBILITY_CHECK_DELAY = ONE_MINUTE;
+var SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;
+var stopCallbacks = [];
+export var startSessionManager = function startSessionManager(options, productKey, computeSessionState) {
+  var sessionStore = startSessionStore(options, productKey, computeSessionState);
+  stopCallbacks.push(function () {
+    return sessionStore.stop();
+  });
+  var sessionContextHistory = new ContextHistory(SESSION_CONTEXT_TIMEOUT_DELAY);
+  stopCallbacks.push(function () {
+    return sessionContextHistory.stop();
+  });
+  sessionStore.renewObservable.subscribe(function () {
+    sessionContextHistory.add(buildSessionContext(), relativeNow());
+  });
+  sessionStore.expireObservable.subscribe(function () {
+    sessionContextHistory.closeActive(relativeNow());
+  });
+  sessionStore.expandOrRenewSession();
+  sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative);
+  trackActivity(function () {
+    return sessionStore.expandOrRenewSession();
+  });
+  trackVisibility(function () {
+    return sessionStore.expandSession();
+  });
+
+  function buildSessionContext() {
+    return {
+      id: sessionStore.getSession().id,
+      trackingType: sessionStore.getSession()[productKey]
+    };
+  }
+
+  return {
+    findActiveSession: function findActiveSession(startTime) {
+      return sessionContextHistory.find(startTime);
+    },
+    renewObservable: sessionStore.renewObservable,
+    expireObservable: sessionStore.expireObservable
+  };
+};
+export function stopSessionManager() {
+  each(stopCallbacks, function (e) {
+    return e();
+  });
+  stopCallbacks = [];
+}
+
+function trackActivity(expandOrRenewSession) {
+  var _addEventListeners = addEventListeners(window, [DOM_EVENT.CLICK, DOM_EVENT.TOUCH_START, DOM_EVENT.KEY_DOWN, DOM_EVENT.SCROLL], expandOrRenewSession, {
+    capture: true,
+    passive: true
+  });
+
+  stopCallbacks.push(_addEventListeners.stop);
+}
+
+function trackVisibility(expandSession) {
+  var expandSessionWhenVisible = function expandSessionWhenVisible() {
+    if (document.visibilityState === 'visible') {
+      expandSession();
+    }
+  };
+
+  var _addEventListener = addEventListener(document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible);
+
+  stopCallbacks.push(_addEventListener.stop);
+  var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);
+  stopCallbacks.push(function () {
+    clearInterval(visibilityCheckInterval);
+  });
+}