@cloudcare/browser-core 3.2.13 → 3.2.16

package/src/helper/limitModification.js

@@ -1,65 +1,60 @@
-import { extend2Lev, each, objectEntries, getType, deepClone } from './tools'
+import { objectEntries, getType, deepClone } from './tools'
 import { sanitize } from './sanitize'
 
-/**
- * Current limitation:
- * - field path do not support array, 'a.b.c' only
- */
 export function limitModification(object, modifiableFieldPaths, modifier) {
-  var clone = deepClone(object)
-  var result = modifier(clone)
-  each(objectEntries(modifiableFieldPaths), function (filedPaths) {
-    var fieldPath = filedPaths[0]
-    var fieldType = filedPaths[1]
-    var newValue = get(clone, fieldPath)
-    var newType = getType(newValue)
-    if (newType === fieldType) {
-      set(object, fieldPath, sanitize(newValue))
-    } else if (
-      fieldType === 'object' &&
-      (newType === 'undefined' || newType === 'null')
-    ) {
-      set(object, fieldPath, {})
-    }
-  })
+  const clone = deepClone(object)
+  const result = modifier(clone)
+
+  objectEntries(modifiableFieldPaths).forEach(([fieldPath, fieldType]) =>
+    // Traverse both object and clone simultaneously up to the path and apply the modification from the clone to the original object when the type is valid
+    setValueAtPath(object, clone, fieldPath.split(/\.|(?=\[\])/), fieldType)
+  )
 
   return result
 }
 
-function get(object, path) {
-  var current = object
-  for (var _i = 0, _a = path.split('.'); _i < _a.length; _i++) {
-    var field = _a[_i]
-    if (!isValidObjectContaining(current, field)) {
-      return
+function setValueAtPath(object, clone, pathSegments, fieldType) {
+  const [field, ...restPathSegments] = pathSegments
+
+  if (field === '[]') {
+    if (Array.isArray(object) && Array.isArray(clone)) {
+      object.forEach((item, i) =>
+        setValueAtPath(item, clone[i], restPathSegments, fieldType)
+      )
     }
-    current = current[field]
+
+    return
+  }
+
+  if (!isValidObject(object) || !isValidObject(clone)) {
+    return
+  }
+
+  if (restPathSegments.length > 0) {
+    return setValueAtPath(
+      object[field],
+      clone[field],
+      restPathSegments,
+      fieldType
+    )
   }
-  return current
+
+  setNestedValue(object, field, clone[field], fieldType)
 }
 
-function set(object, path, value) {
-  var current = object
-  var fields = path.split('.')
-  for (var i = 0; i < fields.length; i += 1) {
-    var field = fields[i]
-    if (!isValidObject(current)) {
-      return
-    }
-    if (i !== fields.length - 1) {
-      current = current[field]
-    } else {
-      current[field] = value
-    }
+function setNestedValue(object, field, value, fieldType) {
+  const newType = getType(value)
+
+  if (newType === fieldType) {
+    object[field] = sanitize(value)
+  } else if (
+    fieldType === 'object' &&
+    (newType === 'undefined' || newType === 'null')
+  ) {
+    object[field] = {}
   }
 }
 
 function isValidObject(object) {
   return getType(object) === 'object'
 }
-
-function isValidObjectContaining(object, field) {
-  return (
-    isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field)
-  )
-}

package/src/helper/serialisation/const.js

@@ -0,0 +1,10 @@
+// RUM and logs batch bytes limit is 16KB
+// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
+// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
+
+export var CustomerDataType = {
+  FeatureFlag: 'feature flag evaluation',
+  User: 'user',
+  GlobalContext: 'global context',
+  View: 'view'
+}

package/src/helper/serialisation/contextManager.js

@@ -1,94 +1,71 @@
-import { computeBytesCount } from '../byteUtils'
-import { deepClone, throttle, getType } from '../tools'
+import { deepClone, getType } from '../tools'
 import { sanitize } from '../sanitize'
-import { jsonStringify } from './jsonStringify'
 import { Observable } from '../observable'
-import { warnIfCustomerDataLimitReached } from './heavyCustomerDataWarning'
+import { display } from '../display'
 
-export var BYTES_COMPUTATION_THROTTLING_DELAY = 200
+function ensureProperties(context, propertiesConfig, name) {
+  const newContext = { ...context }
 
-export function createContextManager(customerDataType, computeBytesCountImpl) {
-  if (typeof computeBytesCountImpl === 'undefined') {
-    computeBytesCountImpl = computeBytesCount
-  }
-  var context = {}
-  var bytesCountCache
-  var alreadyWarned = false
-  var changeObservable = new Observable()
-  // Throttle the bytes computation to minimize the impact on performance.
-  // Especially useful if the user call context APIs synchronously multiple times in a row
-  var computeBytesCountThrottled = throttle(function (context) {
-    bytesCountCache = computeBytesCountImpl(jsonStringify(context))
-    if (!alreadyWarned) {
-      alreadyWarned = warnIfCustomerDataLimitReached(
-        bytesCountCache,
-        customerDataType
-      )
+  for (const [key, { required, type }] of Object.entries(propertiesConfig)) {
+    /**
+     * Ensure specified properties are strings as defined here:
+     */
+    if (type === 'string' && key in newContext) {
+      newContext[key] = String(newContext[key])
     }
-  }, BYTES_COMPUTATION_THROTTLING_DELAY).throttled
-
-  var contextManager = {
-    getBytesCount: function () {
-      return bytesCountCache
-    },
-    /** @deprecated use getContext instead */
-    get: function () {
-      return context
-    },
 
-    /** @deprecated use setContextProperty instead */
-    add: function (key, value) {
-      context[key] = value
-      computeBytesCountThrottled(context)
-      changeObservable.notify()
-    },
+    if (required && !(key in context)) {
+      display.warn(
+        `The property ${key} of ${name} context is required; context will not be sent to the intake.`
+      )
+    }
+  }
 
-    /** @deprecated renamed to removeContextProperty */
-    remove: function (key) {
-      delete context[key]
-      computeBytesCountThrottled(context)
-      changeObservable.notify()
-    },
+  return newContext
+}
 
-    /** @deprecated use setContext instead */
-    set: function (newContext) {
-      context = newContext
-      computeBytesCountThrottled(context)
-      changeObservable.notify()
-    },
+export function createContextManager(
+  name = '',
+  { customerDataTracker, propertiesConfig = {} } = {}
+) {
+  let context = {}
+  const changeObservable = new Observable()
 
-    getContext: function () {
-      return deepClone(context)
-    },
+  const contextManager = {
+    getContext: () => deepClone(context),
 
-    setContext: function (newContext) {
+    setContext: (newContext) => {
       if (getType(newContext) === 'object') {
-        context = sanitize(newContext)
-        computeBytesCountThrottled(context)
+        context = sanitize(ensureProperties(newContext, propertiesConfig, name))
+        customerDataTracker?.updateCustomerData(context)
       } else {
         contextManager.clearContext()
       }
       changeObservable.notify()
     },
 
-    setContextProperty: function (key, property) {
-      context[key] = deepClone(property)
-      computeBytesCountThrottled(context)
+    setContextProperty: (key, property) => {
+      context[key] = sanitize(
+        ensureProperties({ [key]: property }, propertiesConfig, name)[key]
+      )
+      customerDataTracker?.updateCustomerData(context)
       changeObservable.notify()
     },
 
-    removeContextProperty: function (key) {
+    removeContextProperty: (key) => {
       delete context[key]
-      computeBytesCountThrottled(context)
+      customerDataTracker?.updateCustomerData(context)
+      ensureProperties(context, propertiesConfig, name)
       changeObservable.notify()
     },
 
-    clearContext: function () {
+    clearContext: () => {
       context = {}
-      bytesCountCache = 0
+      customerDataTracker?.resetCustomerData()
       changeObservable.notify()
     },
-    changeObservable: changeObservable
+
+    changeObservable
   }
   return contextManager
 }

package/src/helper/serialisation/customerDataTracker.js

@@ -0,0 +1,139 @@
+import { ONE_KIBI_BYTE, computeBytesCount } from '../byteUtils'
+import { throttle, isEmptyObject } from '../tools'
+import { jsonStringify } from './jsonStringify'
+import { display } from '../display'
+
+// RUM and logs batch bytes limit is 16KB
+// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
+// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
+export const CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE
+
+// We observed that the compression ratio is around 8 in general, but we also want to keep a margin
+// because some data might not be compressed (ex: last view update on page exit). We chose 16KiB
+// because it is also the limit of the 'batchBytesCount' that we use for RUM and Logs data, but this
+// is a bit arbitrary.
+export const CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE
+
+export const BYTES_COMPUTATION_THROTTLING_DELAY = 200
+
+export const CustomerDataCompressionStatus = {
+  Unknown: 0,
+  Enabled: 1,
+  Disabled: 2
+}
+
+export function createCustomerDataTrackerManager(
+  compressionStatus = CustomerDataCompressionStatus.Disabled
+) {
+  const customerDataTrackers = new Map()
+
+  let alreadyWarned = false
+  function checkCustomerDataLimit(initialBytesCount = 0) {
+    if (
+      alreadyWarned ||
+      compressionStatus === CustomerDataCompressionStatus.Unknown
+    ) {
+      return
+    }
+
+    const bytesCountLimit =
+      compressionStatus === CustomerDataCompressionStatus.Disabled
+        ? CUSTOMER_DATA_BYTES_LIMIT
+        : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT
+
+    let bytesCount = initialBytesCount
+    customerDataTrackers.forEach((tracker) => {
+      bytesCount += tracker.getBytesCount()
+    })
+
+    if (bytesCount > bytesCountLimit) {
+      displayCustomerDataLimitReachedWarning(bytesCountLimit)
+      alreadyWarned = true
+    }
+  }
+
+  return {
+    /**
+     * Creates a detached tracker. The manager will not store a reference to that tracker, and the
+     * bytes count will be counted independently from other detached trackers.
+     *
+     * This is particularly useful when we don't know when the tracker will be unused, so we don't
+     * leak memory (ex: when used in Logger instances).
+     */
+    createDetachedTracker: () => {
+      const tracker = createCustomerDataTracker(() =>
+        checkCustomerDataLimit(tracker.getBytesCount())
+      )
+      return tracker
+    },
+
+    /**
+     * Creates a tracker if it doesn't exist, and returns it.
+     */
+    getOrCreateTracker: (type) => {
+      if (!customerDataTrackers.has(type)) {
+        customerDataTrackers.set(
+          type,
+          createCustomerDataTracker(checkCustomerDataLimit)
+        )
+      }
+      return customerDataTrackers.get(type)
+    },
+
+    setCompressionStatus: (newCompressionStatus) => {
+      if (compressionStatus === CustomerDataCompressionStatus.Unknown) {
+        compressionStatus = newCompressionStatus
+        checkCustomerDataLimit()
+      }
+    },
+
+    getCompressionStatus: () => compressionStatus,
+
+    stop: () => {
+      customerDataTrackers.forEach((tracker) => tracker.stop())
+      customerDataTrackers.clear()
+    }
+  }
+}
+
+export function createCustomerDataTracker(checkCustomerDataLimit) {
+  let bytesCountCache = 0
+
+  // Throttle the bytes computation to minimize the impact on performance.
+  // Especially useful if the user call context APIs synchronously multiple times in a row
+  const {
+    throttled: computeBytesCountThrottled,
+    cancel: cancelComputeBytesCount
+  } = throttle((context) => {
+    bytesCountCache = computeBytesCount(jsonStringify(context))
+    checkCustomerDataLimit()
+  }, BYTES_COMPUTATION_THROTTLING_DELAY)
+
+  const resetBytesCount = () => {
+    cancelComputeBytesCount()
+    bytesCountCache = 0
+  }
+
+  return {
+    updateCustomerData: (context) => {
+      if (isEmptyObject(context)) {
+        resetBytesCount()
+      } else {
+        computeBytesCountThrottled(context)
+      }
+    },
+    resetCustomerData: resetBytesCount,
+    getBytesCount: () => bytesCountCache,
+    stop: () => {
+      cancelComputeBytesCount()
+    }
+  }
+}
+
+function displayCustomerDataLimitReachedWarning(bytesCountLimit) {
+  display.warn(
+    `Customer data exceeds the recommended ${
+      bytesCountLimit / ONE_KIBI_BYTE
+    }KiB threshold.`
+  )
+}

package/src/helper/tools.js

@@ -330,15 +330,7 @@ export var safeJSONParse = function (str) {
   }
   return val
 }
-export var decodeURIComponent = function (val) {
-  var result = val
-  try {
-    result = decodeURIComponent(val)
-  } catch (error) {
-    result = val
-  }
-  return result
-}
+
 export var encodeDates = function (obj) {
   each(obj, function (v, k) {
     if (isDate(v)) {
@@ -635,21 +627,7 @@ export function replaceNumberCharByPath(path) {
   }
   return pathGroup || '/'
 }
-export var getQueryParam = function (url, param) {
-  param = param.replace(/[\[]/, '\\[').replace(/[\]]/, '\\]')
-  url = decodeURIComponent(url)
-  var regexS = '[\\?&]' + param + '=([^&#]*)',
-    regex = new RegExp(regexS),
-    results = regex.exec(url)
-  if (
-    results === null ||
-    (results && typeof results[1] !== 'string' && results[1].length)
-  ) {
-    return ''
-  } else {
-    return decodeURIComponent(results[1])
-  }
-}
+
 export var urlParse = function (para) {
   var URLParser = function (a) {
     this._fields = {
@@ -748,55 +726,6 @@ export function elementMatches(element, selector) {
   return false
 }
 
-export var cookie = {
-  get: function (name) {
-    var nameEQ = name + '='
-    var ca = document.cookie.split(';')
-    for (var i = 0; i < ca.length; i++) {
-      var c = ca[i]
-      while (c.charAt(0) == ' ') {
-        c = c.substring(1, c.length)
-      }
-      if (c.indexOf(nameEQ) == 0) {
-        return decodeURIComponent(c.substring(nameEQ.length, c.length))
-      }
-    }
-    return null
-  },
-  set: function (name, value, days, is_secure) {
-    var cdomain = '',
-      expires = '',
-      secure = ''
-    days = days == null ? 73000 : days
-    if (days !== 0) {
-      var date = new Date()
-      if (String(days).slice(-1) === 's') {
-        date.setTime(date.getTime() + Number(String(days).slice(0, -1)) * 1000)
-      } else {
-        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000)
-      }
-
-      expires = '; expires=' + date.toGMTString()
-    }
-
-    if (is_secure) {
-      secure = '; secure'
-    }
-
-    document.cookie =
-      name +
-      '=' +
-      encodeURIComponent(value) +
-      expires +
-      '; path=/' +
-      cdomain +
-      secure
-  },
-
-  remove: function (name) {
-    cookie.set(name, '', -1)
-  }
-}
 export var localStorage = {
   get: function (name) {
     return window.localStorage.getItem(name)
@@ -1171,71 +1100,6 @@ export function mergeInto(destination, source, circularReferenceChecker) {
 export function deepClone(value) {
   return mergeInto(undefined, value)
 }
-export var _URL = function (url) {
-  var result = {}
-  var basicProps = [
-    'hash',
-    'host',
-    'hostname',
-    'href',
-    'origin',
-    'password',
-    'pathname',
-    'port',
-    'protocol',
-    'search',
-    'username'
-  ]
-  var isURLAPIWorking = function () {
-    var url
-    try {
-      url = new URL('http://modernizr.com/')
-      return url.href === 'http://modernizr.com/'
-    } catch (e) {
-      return false
-    }
-  }
-  if (typeof window.URL === 'function' && isURLAPIWorking()) {
-    result = new URL(url)
-    if (!result.searchParams) {
-      result.searchParams = (function () {
-        var params = getURLSearchParams(result.search)
-        return {
-          get: function (searchParam) {
-            return params[searchParam]
-          }
-        }
-      })()
-    }
-  } else {
-    var _regex = /^https?:\/\/.+/
-    if (_regex.test(url) === false) {
-      throw 'Invalid URL'
-    }
-    var link = document.createElement('a')
-    link.href = url
-    for (var i = basicProps.length - 1; i >= 0; i--) {
-      var prop = basicProps[i]
-      result[prop] = link[prop]
-    }
-    if (
-      result.hostname &&
-      typeof result.pathname === 'string' &&
-      result.pathname.indexOf('/') !== 0
-    ) {
-      result.pathname = '/' + result.pathname
-    }
-    result.searchParams = (function () {
-      var params = getURLSearchParams(result.search)
-      return {
-        get: function (searchParam) {
-          return params[searchParam]
-        }
-      }
-    })()
-  }
-  return result
-}
 
 export var getCurrentDomain = function (url) {
   var cookieTopLevelDomain = getCookieTopLevelDomain()

package/src/index.js

@@ -51,10 +51,11 @@ export * from './transport'
 export * from './synthetics/syntheticsWorkerValues'
 
 export * from './helper/serialisation/contextManager'
-export * from './helper/serialisation/heavyCustomerDataWarning'
+export * from './helper/serialisation/const'
 export * from './helper/serialisation/jsonStringify'
 export * from './helper/serialisation/rowData'
 export * from './helper/serialisation/storedContextManager'
+export * from './helper/serialisation/customerDataTracker'
 export * from './helper/encoder'
 export * from './user'
 export * from './helper/polyfills'

package/cjs/helper/serialisation/heavyCustomerDataWarning.js

@@ -1,29 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CustomerDataType = exports.CUSTOMER_DATA_BYTES_LIMIT = void 0;
-exports.warnIfCustomerDataLimitReached = warnIfCustomerDataLimitReached;
-var _byteUtils = require("../byteUtils");
-var _display = require("../display");
-// RUM and logs batch bytes limit is 16KB
-// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
-// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
-var CUSTOMER_DATA_BYTES_LIMIT = 3 * _byteUtils.ONE_KIBI_BYTE;
-exports.CUSTOMER_DATA_BYTES_LIMIT = CUSTOMER_DATA_BYTES_LIMIT;
-var CustomerDataType = {
-  FeatureFlag: 'feature flag evaluation',
-  User: 'user',
-  GlobalContext: 'global context',
-  LoggerContext: 'logger context'
-};
-exports.CustomerDataType = CustomerDataType;
-function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {
-  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {
-    _display.display.warn('The ' + customerDataType + 'data is over ' + CUSTOMER_DATA_BYTES_LIMIT / _byteUtils.ONE_KIBI_BYTE + " KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.");
-    return true;
-  }
-  return false;
-}
-//# sourceMappingURL=heavyCustomerDataWarning.js.map

package/cjs/helper/serialisation/heavyCustomerDataWarning.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"heavyCustomerDataWarning.js","names":["_byteUtils","require","_display","CUSTOMER_DATA_BYTES_LIMIT","ONE_KIBI_BYTE","exports","CustomerDataType","FeatureFlag","User","GlobalContext","LoggerContext","warnIfCustomerDataLimitReached","bytesCount","customerDataType","display","warn"],"sources":["../../../src/helper/serialisation/heavyCustomerDataWarning.js"],"sourcesContent":["import { ONE_KIBI_BYTE } from '../byteUtils'\nimport { display } from '../display'\n\n// RUM and logs batch bytes limit is 16KB\n// ensure that we leave room for other event attributes and maintain a decent amount of event per batch\n// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB\nexport var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE\n\nexport var CustomerDataType = {\n  FeatureFlag: 'feature flag evaluation',\n  User: 'user',\n  GlobalContext: 'global context',\n  LoggerContext: 'logger context'\n}\n\nexport function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {\n  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {\n    display.warn(\n      'The ' +\n        customerDataType +\n        'data is over ' +\n        CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE +\n        \" KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.\"\n    )\n    return true\n  }\n  return false\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACO,IAAIE,yBAAyB,GAAG,CAAC,GAAGC,wBAAa;AAAAC,OAAA,CAAAF,yBAAA,GAAAA,yBAAA;AAEjD,IAAIG,gBAAgB,GAAG;EAC5BC,WAAW,EAAE,yBAAyB;EACtCC,IAAI,EAAE,MAAM;EACZC,aAAa,EAAE,gBAAgB;EAC/BC,aAAa,EAAE;AACjB,CAAC;AAAAL,OAAA,CAAAC,gBAAA,GAAAA,gBAAA;AAEM,SAASK,8BAA8BA,CAACC,UAAU,EAAEC,gBAAgB,EAAE;EAC3E,IAAID,UAAU,GAAGT,yBAAyB,EAAE;IAC1CW,gBAAO,CAACC,IAAI,CACV,MAAM,GACJF,gBAAgB,GAChB,eAAe,GACfV,yBAAyB,GAAGC,wBAAa,GACzC,8FACJ,CAAC;IACD,OAAO,IAAI;EACb;EACA,OAAO,KAAK;AACd","ignoreList":[]}

package/esm/helper/serialisation/heavyCustomerDataWarning.js

@@ -1,21 +0,0 @@
-import { ONE_KIBI_BYTE } from '../byteUtils';
-import { display } from '../display';
-
-// RUM and logs batch bytes limit is 16KB
-// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
-// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
-export var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE;
-export var CustomerDataType = {
-  FeatureFlag: 'feature flag evaluation',
-  User: 'user',
-  GlobalContext: 'global context',
-  LoggerContext: 'logger context'
-};
-export function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {
-  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {
-    display.warn('The ' + customerDataType + 'data is over ' + CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE + " KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.");
-    return true;
-  }
-  return false;
-}
-//# sourceMappingURL=heavyCustomerDataWarning.js.map

package/esm/helper/serialisation/heavyCustomerDataWarning.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"heavyCustomerDataWarning.js","names":["ONE_KIBI_BYTE","display","CUSTOMER_DATA_BYTES_LIMIT","CustomerDataType","FeatureFlag","User","GlobalContext","LoggerContext","warnIfCustomerDataLimitReached","bytesCount","customerDataType","warn"],"sources":["../../../src/helper/serialisation/heavyCustomerDataWarning.js"],"sourcesContent":["import { ONE_KIBI_BYTE } from '../byteUtils'\nimport { display } from '../display'\n\n// RUM and logs batch bytes limit is 16KB\n// ensure that we leave room for other event attributes and maintain a decent amount of event per batch\n// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB\nexport var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE\n\nexport var CustomerDataType = {\n  FeatureFlag: 'feature flag evaluation',\n  User: 'user',\n  GlobalContext: 'global context',\n  LoggerContext: 'logger context'\n}\n\nexport function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {\n  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {\n    display.warn(\n      'The ' +\n        customerDataType +\n        'data is over ' +\n        CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE +\n        \" KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.\"\n    )\n    return true\n  }\n  return false\n}\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,cAAc;AAC5C,SAASC,OAAO,QAAQ,YAAY;;AAEpC;AACA;AACA;AACA,OAAO,IAAIC,yBAAyB,GAAG,CAAC,GAAGF,aAAa;AAExD,OAAO,IAAIG,gBAAgB,GAAG;EAC5BC,WAAW,EAAE,yBAAyB;EACtCC,IAAI,EAAE,MAAM;EACZC,aAAa,EAAE,gBAAgB;EAC/BC,aAAa,EAAE;AACjB,CAAC;AAED,OAAO,SAASC,8BAA8BA,CAACC,UAAU,EAAEC,gBAAgB,EAAE;EAC3E,IAAID,UAAU,GAAGP,yBAAyB,EAAE;IAC1CD,OAAO,CAACU,IAAI,CACV,MAAM,GACJD,gBAAgB,GAChB,eAAe,GACfR,yBAAyB,GAAGF,aAAa,GACzC,8FACJ,CAAC;IACD,OAAO,IAAI;EACb;EACA,OAAO,KAAK;AACd","ignoreList":[]}

package/src/helper/serialisation/heavyCustomerDataWarning.js

@@ -1,28 +0,0 @@
-import { ONE_KIBI_BYTE } from '../byteUtils'
-import { display } from '../display'
-
-// RUM and logs batch bytes limit is 16KB
-// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
-// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
-export var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE
-
-export var CustomerDataType = {
-  FeatureFlag: 'feature flag evaluation',
-  User: 'user',
-  GlobalContext: 'global context',
-  LoggerContext: 'logger context'
-}
-
-export function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {
-  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {
-    display.warn(
-      'The ' +
-        customerDataType +
-        'data is over ' +
-        CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE +
-        " KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth."
-    )
-    return true
-  }
-  return false
-}