@kubesense/kubesense-browser-rum-core 1.8.0 → 2.0.0-beta.1

package/esm/domain/getComposedPathSelector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getComposedPathSelector.mjs","names":[],"sources":["../../src/domain/getComposedPathSelector.ts"],"sourcesContent":["import { safeTruncate, ONE_KIBI_BYTE } from '@kubesense/kubesense-browser-core'\nimport type { MatchOption } from '@kubesense/kubesense-browser-core'\nimport {\n  STABLE_ATTRIBUTES,\n  isGeneratedValue,\n  getIDSelector,\n  getTagNameSelector,\n  getNthOfTypeSelector,\n  getAttributeValueSelector,\n} from './getSelectorFromElement'\n\nconst FILTERED_TAGNAMES = ['HTML', 'BODY']\n\n/**\n * arbitrary value, we want to truncate the selector if it exceeds the limit\n */\nexport const CHARACTER_LIMIT = 2 * ONE_KIBI_BYTE\n\n/**\n * Safe attributes that can be collected without PII concerns.\n * These are commonly used for testing, accessibility, and UI identification.\n */\nexport const SAFE_ATTRIBUTES = STABLE_ATTRIBUTES.concat([\n  'role',\n  'type',\n  'disabled',\n  'readonly',\n  'tabindex',\n  'draggable',\n  'target',\n  'rel',\n  'download',\n  'method',\n  'action',\n  'enctype',\n  'autocomplete',\n])\n\n/**\n * Extracts a selector string from a MouseEvent composedPath.\n *\n * This function:\n * 1. Filters out non-Element items (Document, Window, ShadowRoot)\n * 2. Extracts a selector string from each element\n * 3. Truncates the selector string if it exceeds the character limit\n * 4. Returns the selector string\n *\n * @param composedPath - The composedPath from a MouseEvent\n * @returns A selector string\n */\nexport function getComposedPathSelector(composedPath: EventTarget[], actionNameAttribute: string | undefined): string {\n  // Filter to only include Element nodes\n  const elements = composedPath.filter(\n    (el): el is Element => el instanceof Element && !FILTERED_TAGNAMES.includes(el.tagName)\n  )\n\n  if (elements.length === 0) {\n    return ''\n  }\n\n  const allowedAttributes = actionNameAttribute ? [actionNameAttribute].concat(SAFE_ATTRIBUTES) : SAFE_ATTRIBUTES\n\n  let result = ''\n  for (const element of elements) {\n    const part = getSelectorStringFromElement(element, allowedAttributes)\n    result += part\n    if (result.length >= CHARACTER_LIMIT) {\n      return safeTruncate(result, CHARACTER_LIMIT)\n    }\n  }\n  return result\n}\n\n/**\n * Extracts a selector string from an element.\n */\nfunction getSelectorStringFromElement(element: Element, allowedAttributes: MatchOption[]): string {\n  const tagName = getTagNameSelector(element)\n  const id = getIDSelector(element)\n  const classes = getElementClassesString(element)\n  const attributes = extractSafeAttributesString(element, allowedAttributes)\n  const positionData = computePositionDataString(element)\n\n  return `${tagName}${id || ''}${attributes}${classes}${positionData};`\n}\n\nfunction getElementClassesString(element: Element): string {\n  return Array.from(element.classList)\n    .filter((c) => !isGeneratedValue(c))\n    .sort()\n    .map((c) => `.${CSS.escape(c)}`)\n    .join('')\n}\n\n/**\n * Computes the nthChild and nthOfType positions for an element.\n *\n * @param element - The element to compute the position data for\n * @returns A string of the form \":nth-child(1):nth-of-type(1)\"\n */\nfunction computePositionDataString(element: Element): string {\n  const siblings = Array.from(element.parentNode!.children)\n\n  if (siblings.length <= 1) {\n    return ''\n  }\n\n  const sameTypeSiblings = siblings.filter((sibling) => sibling.tagName === element.tagName)\n\n  const nthChild = siblings.indexOf(element)\n\n  const nthOfType = getNthOfTypeSelector(element)\n\n  return `:nth-child(${nthChild + 1})${sameTypeSiblings.length > 1 ? `:nth-of-type(${nthOfType})` : ''}`\n}\n\n/**\n * Extracts only the safe (allowlisted) attributes from an element.\n * The attributes are sorted alphabetically by name.\n */\nfunction extractSafeAttributesString(element: Element, allowedAttributes: MatchOption[]): string {\n  const result: string[] = []\n  const attributes = Array.from(element.attributes)\n  for (const attribute of attributes) {\n    if (allowedAttributes.includes(attribute.name)) {\n      result.push(getAttributeValueSelector(attribute.name, attribute.value))\n    }\n  }\n  return result.sort().join('')\n}\n"],"mappings":";;;AAWA,MAAM,oBAAoB,CAAC,QAAQ,MAAM;;;;AAKzC,MAAa,kBAAkB,IAAI;;;;;AAMnC,MAAa,kBAAkB,kBAAkB,OAAO;CACtD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;;;;;;;AAcD,SAAgB,wBAAwB,cAA6B,qBAAiD;CAEpH,MAAM,WAAW,aAAa,QAC3B,OAAsB,cAAc,WAAW,CAAC,kBAAkB,SAAS,GAAG,OAAO,CACxF;CAEA,IAAI,SAAS,WAAW,GACtB,OAAO;CAGT,MAAM,oBAAoB,sBAAsB,CAAC,mBAAmB,CAAC,CAAC,OAAO,eAAe,IAAI;CAEhG,IAAI,SAAS;CACb,KAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,OAAO,6BAA6B,SAAS,iBAAiB;EACpE,UAAU;EACV,IAAI,OAAO,UAAU,iBACnB,OAAO,aAAa,QAAQ,eAAe;CAE/C;CACA,OAAO;AACT;;;;AAKA,SAAS,6BAA6B,SAAkB,mBAA0C;CAChG,MAAM,UAAU,mBAAmB,OAAO;CAC1C,MAAM,KAAK,cAAc,OAAO;CAChC,MAAM,UAAU,wBAAwB,OAAO;CAC/C,MAAM,aAAa,4BAA4B,SAAS,iBAAiB;CACzE,MAAM,eAAe,0BAA0B,OAAO;CAEtD,OAAO,GAAG,UAAU,MAAM,KAAK,aAAa,UAAU,aAAa;AACrE;AAEA,SAAS,wBAAwB,SAA0B;CACzD,OAAO,MAAM,KAAK,QAAQ,SAAS,CAAC,CACjC,QAAQ,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,CACnC,KAAK,CAAC,CACN,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,CAC/B,KAAK,EAAE;AACZ;;;;;;;AAQA,SAAS,0BAA0B,SAA0B;CAC3D,MAAM,WAAW,MAAM,KAAK,QAAQ,WAAY,QAAQ;CAExD,IAAI,SAAS,UAAU,GACrB,OAAO;CAGT,MAAM,mBAAmB,SAAS,QAAQ,YAAY,QAAQ,YAAY,QAAQ,OAAO;CAEzF,MAAM,WAAW,SAAS,QAAQ,OAAO;CAEzC,MAAM,YAAY,qBAAqB,OAAO;CAE9C,OAAO,cAAc,WAAW,EAAE,GAAG,iBAAiB,SAAS,IAAI,gBAAgB,UAAU,KAAK;AACpG;;;;;AAMA,SAAS,4BAA4B,SAAkB,mBAA0C;CAC/F,MAAM,SAAmB,CAAC;CAC1B,MAAM,aAAa,MAAM,KAAK,QAAQ,UAAU;CAChD,KAAK,MAAM,aAAa,YACtB,IAAI,kBAAkB,SAAS,UAAU,IAAI,GAC3C,OAAO,KAAK,0BAA0B,UAAU,MAAM,UAAU,KAAK,CAAC;CAG1E,OAAO,OAAO,KAAK,CAAC,CAAC,KAAK,EAAE;AAC9B"}

package/esm/domain/getSelectorFromElement.mjs

@@ -0,0 +1,218 @@
+import { isNodeShadowRoot } from "../browser/htmlDomUtils.mjs";
+import { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from "./action/actionNameConstants.mjs";
+//#region src/domain/getSelectorFromElement.ts
+/**
+* Marker used to indicate shadow DOM boundaries in selectors.
+* Named after the deprecated Shadow DOM v0 '::shadow' pseudo-element which served the same
+* purpose of marking entry into a shadow root.
+* Note: This is NOT a valid CSS selector, it's an internal marker that requires custom
+* parsing logic.
+*/
+const SHADOW_DOM_MARKER = "::shadow ";
+/**
+* Stable attributes are attributes that are commonly used to identify parts of a UI (ex:
+* component). Those attribute values should not be generated randomly (hardcoded most of the time)
+* and stay the same across deploys. They are not necessarily unique across the document.
+*/
+const STABLE_ATTRIBUTES = [
+	DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,
+	"data-testid",
+	"data-test",
+	"data-qa",
+	"data-cy",
+	"data-test-id",
+	"data-qa-id",
+	"data-testing",
+	"data-component",
+	"data-element",
+	"data-source-file"
+];
+const GLOBALLY_UNIQUE_SELECTOR_GETTERS = [getStableAttributeSelector, getIDSelector];
+const UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS = [
+	getStableAttributeSelector,
+	getClassSelector,
+	getTagNameSelector
+];
+function getSelectorFromElement(targetElement, actionNameAttribute) {
+	if (!targetElement.isConnected) return;
+	const subtrees = getAllSubtreeTargets(targetElement);
+	const selectorParts = [];
+	for (const { rootNode, target } of subtrees) {
+		const selector = getSelectorFromElementWithinSubtree(target, rootNode, actionNameAttribute);
+		if (!selector) return;
+		selectorParts.push(selector);
+	}
+	return selectorParts.join(SHADOW_DOM_MARKER);
+}
+/**
+* Returns all (rootNode, target) pairs from the document down to the element.
+*/
+function getAllSubtreeTargets(element) {
+	const result = [];
+	let currentTarget = element;
+	while (currentTarget) {
+		const rootNode = currentTarget.getRootNode();
+		result.push({
+			rootNode,
+			target: currentTarget
+		});
+		if (isNodeShadowRoot(rootNode)) currentTarget = rootNode.host;
+		else break;
+	}
+	return result.reverse();
+}
+/**
+* Computes a CSS selector for an element within a specific subtree (document or shadow root).
+*/
+function getSelectorFromElementWithinSubtree(targetElement, rootNode, actionNameAttribute) {
+	let currentSelector;
+	let currentElement = targetElement;
+	while (currentElement && currentElement.nodeName !== "HTML") {
+		const globallyUniqueSelector = findSelector(currentElement, rootNode, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueWithinRoot, actionNameAttribute, currentSelector);
+		if (globallyUniqueSelector) return combineSelector(globallyUniqueSelector, currentSelector);
+		currentSelector = combineSelector(findSelector(currentElement, rootNode, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, currentSelector) || getPositionSelector(currentElement), currentSelector);
+		currentElement = currentElement.parentElement;
+	}
+	return currentSelector;
+}
+function isGeneratedValue(value) {
+	return /[0-9]/.test(value);
+}
+function getIDSelector(element) {
+	if (element.id && !isGeneratedValue(element.id)) return `#${CSS.escape(element.id)}`;
+}
+function getClassSelector(element) {
+	if (element.tagName === "BODY") return;
+	const classList = element.classList;
+	for (let i = 0; i < classList.length; i += 1) {
+		const className = classList[i];
+		if (isGeneratedValue(className)) continue;
+		return `${CSS.escape(element.tagName)}.${CSS.escape(className)}`;
+	}
+}
+function getTagNameSelector(element) {
+	return CSS.escape(element.tagName);
+}
+function getStableAttributeSelector(element, actionNameAttribute) {
+	if (actionNameAttribute) {
+		const selector = getAttributeSelector(actionNameAttribute);
+		if (selector) return selector;
+	}
+	for (const attributeName of STABLE_ATTRIBUTES) {
+		const selector = getAttributeSelector(attributeName);
+		if (selector) return selector;
+	}
+	function getAttributeSelector(attributeName) {
+		if (element.hasAttribute(attributeName)) return `${CSS.escape(element.tagName)}${getAttributeValueSelector(attributeName, element.getAttribute(attributeName))}`;
+	}
+}
+function getAttributeValueSelector(attributeName, attributeValue) {
+	return `[${attributeName}="${CSS.escape(attributeValue)}"]`;
+}
+function getPositionSelector(element) {
+	const nthOfType = getNthOfTypeSelector(element);
+	return `${CSS.escape(element.tagName)}:nth-of-type(${nthOfType})`;
+}
+function getNthOfTypeSelector(element) {
+	let sibling = element.parentNode.firstElementChild;
+	let nthOfType = 1;
+	while (sibling && sibling !== element) {
+		if (sibling.tagName === element.tagName) nthOfType += 1;
+		sibling = sibling.nextElementSibling;
+	}
+	return nthOfType;
+}
+function findSelector(element, rootNode, selectorGetters, predicate, actionNameAttribute, childSelector) {
+	for (const selectorGetter of selectorGetters) {
+		const elementSelector = selectorGetter(element, actionNameAttribute);
+		if (!elementSelector) continue;
+		if (predicate(element, rootNode, elementSelector, childSelector)) return elementSelector;
+	}
+}
+/**
+* Check whether the selector is unique within the root node (document or shadow root).
+*/
+function isSelectorUniqueWithinRoot(_element, rootNode, elementSelector, childSelector) {
+	return rootNode.querySelectorAll(combineSelector(elementSelector, childSelector)).length === 1;
+}
+/**
+* Check whether the selector is unique among the element siblings. In other words, it returns true
+* if "ELEMENT_PARENT > CHILD_SELECTOR" returns a single element.
+*
+* @param currentElement - the element being considered while iterating over the target
+* element ancestors.
+* @param _rootNode - the root node (document or shadow root) - unused but required for predicate signature.
+* @param currentElementSelector - a selector that matches the current element. That
+* selector is not a composed selector (i.e. it might be a single tag name, class name...).
+* @param childSelector - child selector is a selector that targets a descendant
+* of the current element. When undefined, the current element is the target element.
+*
+* # Scope selector usage
+*
+* When composed together, the final selector will be joined with `>` operators to make sure we
+* target direct descendants at each level. In this function, we'll use `querySelector` to check if
+* a selector matches descendants of the current element. But by default, the query selector match
+* elements at any level. Example:
+*
+* ```html
+* <main>
+*   <div>
+*     <span></span>
+*   </div>
+*   <marquee>
+*     <div>
+*       <span></span>
+*     </div>
+*   </marquee>
+* </main>
+* ```
+*
+* `sibling.querySelector('DIV > SPAN')` will match both span elements, so we would consider the
+* selector to be not unique, even if it is unique when we'll compose it with the parent with a `>`
+* operator (`MAIN > DIV > SPAN`).
+*
+* To avoid this, we can use the `:scope` selector to make sure the selector starts from the current
+* sibling (i.e. `sibling.querySelector('DIV:scope > SPAN')` will only match the first span).
+*
+* [1]: https://developer.mozilla.org/fr/docs/Web/CSS/:scope
+*
+* # Performance considerations
+*
+* We compute selectors in performance-critical operations (ex: during a click), so we need to make
+* sure the function is as fast as possible. We observed that naively using `querySelectorAll` to
+* check if the selector matches more than 1 element is quite expensive, so we want to avoid it.
+*
+* Because we are iterating the DOM upward and we use that function at every level, we know the
+* child selector is already unique among the current element children, so we don't need to check
+* for the current element subtree.
+*
+* Instead, we can focus on the current element siblings. If we find a single element matching the
+* selector within a sibling, we know that it's not unique. This allows us to use `querySelector`
+* (or `matches`, when the current element is the target element) instead of `querySelectorAll`.
+*/
+function isSelectorUniqueAmongSiblings(currentElement, _rootNode, currentElementSelector, childSelector) {
+	let isSiblingMatching;
+	if (childSelector === void 0) isSiblingMatching = (sibling) => sibling.matches(currentElementSelector);
+	else {
+		const scopedSelector = combineSelector(`${currentElementSelector}:scope`, childSelector);
+		isSiblingMatching = (sibling) => sibling.querySelector(scopedSelector) !== null;
+	}
+	let sibling = currentElement.previousElementSibling;
+	while (sibling) {
+		if (isSiblingMatching(sibling)) return false;
+		sibling = sibling.previousElementSibling;
+	}
+	sibling = currentElement.nextElementSibling;
+	while (sibling) {
+		if (isSiblingMatching(sibling)) return false;
+		sibling = sibling.nextElementSibling;
+	}
+	return true;
+}
+function combineSelector(parent, child) {
+	return child ? `${parent}>${child}` : parent;
+}
+//#endregion
+export { SHADOW_DOM_MARKER, STABLE_ATTRIBUTES, getAttributeValueSelector, getIDSelector, getNthOfTypeSelector, getSelectorFromElement, getTagNameSelector, isGeneratedValue, isSelectorUniqueAmongSiblings };
+
+//# sourceMappingURL=getSelectorFromElement.mjs.map

package/esm/domain/getSelectorFromElement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSelectorFromElement.mjs","names":[],"sources":["../../src/domain/getSelectorFromElement.ts"],"sourcesContent":["import { isNodeShadowRoot } from '../browser/htmlDomUtils'\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './action/actionNameConstants'\n\n/**\n * Marker used to indicate shadow DOM boundaries in selectors.\n * Named after the deprecated Shadow DOM v0 '::shadow' pseudo-element which served the same\n * purpose of marking entry into a shadow root.\n * Note: This is NOT a valid CSS selector, it's an internal marker that requires custom\n * parsing logic.\n */\nexport const SHADOW_DOM_MARKER = '::shadow '\n\n/**\n * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:\n * component). Those attribute values should not be generated randomly (hardcoded most of the time)\n * and stay the same across deploys. They are not necessarily unique across the document.\n */\nexport const STABLE_ATTRIBUTES = [\n  DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,\n  // Common test attributes (list provided by google recorder)\n  'data-testid',\n  'data-test',\n  'data-qa',\n  'data-cy',\n  'data-test-id',\n  'data-qa-id',\n  'data-testing',\n  // FullStory decorator attributes:\n  'data-component',\n  'data-element',\n  'data-source-file',\n]\n\ntype SelectorGetter = (element: Element, actionNameAttribute: string | undefined) => string | undefined\n\n// Selectors to use if they target a single element on the whole document. Those selectors are\n// considered as \"stable\" and uniquely identify an element regardless of the page state. If we find\n// one, we should consider the selector \"complete\" and stop iterating over ancestors.\nconst GLOBALLY_UNIQUE_SELECTOR_GETTERS: SelectorGetter[] = [getStableAttributeSelector, getIDSelector]\n\n// Selectors to use if they target a single element among an element descendants. Those selectors\n// are more brittle than \"globally unique\" selectors and should be combined with ancestor selectors\n// to improve specificity.\nconst UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS: SelectorGetter[] = [\n  getStableAttributeSelector,\n  getClassSelector,\n  getTagNameSelector,\n]\n\ninterface SubtreeTarget {\n  rootNode: Document | ShadowRoot\n  target: Element\n}\n\nexport function getSelectorFromElement(\n  targetElement: Element,\n  actionNameAttribute: string | undefined\n): string | undefined {\n  if (!targetElement.isConnected) {\n    // We cannot compute a selector for a detached element, as we don't have access to all of its\n    // parents, and we cannot determine if it's unique in the document.\n    return\n  }\n\n  const subtrees = getAllSubtreeTargets(targetElement)\n  const selectorParts: string[] = []\n\n  for (const { rootNode, target } of subtrees) {\n    const selector = getSelectorFromElementWithinSubtree(target, rootNode, actionNameAttribute)\n    if (!selector) {\n      return undefined\n    }\n    selectorParts.push(selector)\n  }\n\n  return selectorParts.join(SHADOW_DOM_MARKER)\n}\n\n/**\n * Returns all (rootNode, target) pairs from the document down to the element.\n */\nfunction getAllSubtreeTargets(element: Element): SubtreeTarget[] {\n  const result: SubtreeTarget[] = []\n  let currentTarget: Element | undefined = element\n\n  while (currentTarget) {\n    const rootNode = currentTarget.getRootNode() as Document | ShadowRoot\n    result.push({ rootNode, target: currentTarget })\n\n    if (isNodeShadowRoot(rootNode)) {\n      currentTarget = rootNode.host\n    } else {\n      break\n    }\n  }\n\n  return result.reverse()\n}\n\n/**\n * Computes a CSS selector for an element within a specific subtree (document or shadow root).\n */\nfunction getSelectorFromElementWithinSubtree(\n  targetElement: Element,\n  rootNode: Document | ShadowRoot,\n  actionNameAttribute: string | undefined\n): string | undefined {\n  let currentSelector: string | undefined\n  let currentElement: Element | null = targetElement\n\n  while (currentElement && currentElement.nodeName !== 'HTML') {\n    const globallyUniqueSelector = findSelector(\n      currentElement,\n      rootNode,\n      GLOBALLY_UNIQUE_SELECTOR_GETTERS,\n      isSelectorUniqueWithinRoot,\n      actionNameAttribute,\n      currentSelector\n    )\n    if (globallyUniqueSelector) {\n      return combineSelector(globallyUniqueSelector, currentSelector)\n    }\n\n    const uniqueSelectorAmongChildren = findSelector(\n      currentElement,\n      rootNode,\n      UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS,\n      isSelectorUniqueAmongSiblings,\n      actionNameAttribute,\n      currentSelector\n    )\n\n    const elementSelector = uniqueSelectorAmongChildren || getPositionSelector(currentElement)\n    currentSelector = combineSelector(elementSelector, currentSelector)\n\n    currentElement = currentElement.parentElement\n  }\n\n  return currentSelector\n}\n\nexport function isGeneratedValue(value: string) {\n  // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n  // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n  // present.\n  //\n  // Here, we use the same strategy: if the value contains a digit, we consider it generated. This\n  // strategy might be a bit naive and fail in some cases, but there are many fallbacks to generate\n  // CSS selectors so it should be fine most of the time.\n  return /[0-9]/.test(value)\n}\n\nexport function getIDSelector(element: Element): string | undefined {\n  if (element.id && !isGeneratedValue(element.id)) {\n    return `#${CSS.escape(element.id)}`\n  }\n}\n\nfunction getClassSelector(element: Element): string | undefined {\n  if (element.tagName === 'BODY') {\n    return\n  }\n  const classList = element.classList\n  for (let i = 0; i < classList.length; i += 1) {\n    const className = classList[i]\n    if (isGeneratedValue(className)) {\n      continue\n    }\n\n    return `${CSS.escape(element.tagName)}.${CSS.escape(className)}`\n  }\n}\n\nexport function getTagNameSelector(element: Element): string {\n  return CSS.escape(element.tagName)\n}\n\nfunction getStableAttributeSelector(element: Element, actionNameAttribute: string | undefined): string | undefined {\n  if (actionNameAttribute) {\n    const selector = getAttributeSelector(actionNameAttribute)\n    if (selector) {\n      return selector\n    }\n  }\n\n  for (const attributeName of STABLE_ATTRIBUTES) {\n    const selector = getAttributeSelector(attributeName)\n    if (selector) {\n      return selector\n    }\n  }\n\n  function getAttributeSelector(attributeName: string) {\n    if (element.hasAttribute(attributeName)) {\n      return `${CSS.escape(element.tagName)}${getAttributeValueSelector(attributeName, element.getAttribute(attributeName)!)}`\n    }\n  }\n}\n\nexport function getAttributeValueSelector(attributeName: string, attributeValue: string) {\n  return `[${attributeName}=\"${CSS.escape(attributeValue)}\"]`\n}\n\nfunction getPositionSelector(element: Element): string {\n  const nthOfType = getNthOfTypeSelector(element)\n\n  return `${CSS.escape(element.tagName)}:nth-of-type(${nthOfType})`\n}\n\nexport function getNthOfTypeSelector(element: Element): number {\n  const parent = element.parentNode!\n\n  let sibling = parent.firstElementChild\n\n  let nthOfType = 1\n\n  while (sibling && sibling !== element) {\n    if (sibling.tagName === element.tagName) {\n      nthOfType += 1\n    }\n    sibling = sibling.nextElementSibling\n  }\n\n  return nthOfType\n}\n\nfunction findSelector(\n  element: Element,\n  rootNode: Document | ShadowRoot,\n  selectorGetters: SelectorGetter[],\n  predicate: (\n    element: Element,\n    rootNode: Document | ShadowRoot,\n    elementSelector: string,\n    childSelector: string | undefined\n  ) => boolean,\n  actionNameAttribute: string | undefined,\n  childSelector: string | undefined\n) {\n  for (const selectorGetter of selectorGetters) {\n    const elementSelector = selectorGetter(element, actionNameAttribute)\n    if (!elementSelector) {\n      continue\n    }\n    if (predicate(element, rootNode, elementSelector, childSelector)) {\n      return elementSelector\n    }\n  }\n}\n\n/**\n * Check whether the selector is unique within the root node (document or shadow root).\n */\nfunction isSelectorUniqueWithinRoot(\n  _element: Element,\n  rootNode: Document | ShadowRoot,\n  elementSelector: string,\n  childSelector: string | undefined\n): boolean {\n  return rootNode.querySelectorAll(combineSelector(elementSelector, childSelector)).length === 1\n}\n\n/**\n * Check whether the selector is unique among the element siblings. In other words, it returns true\n * if \"ELEMENT_PARENT > CHILD_SELECTOR\" returns a single element.\n *\n * @param currentElement - the element being considered while iterating over the target\n * element ancestors.\n * @param _rootNode - the root node (document or shadow root) - unused but required for predicate signature.\n * @param currentElementSelector - a selector that matches the current element. That\n * selector is not a composed selector (i.e. it might be a single tag name, class name...).\n * @param childSelector - child selector is a selector that targets a descendant\n * of the current element. When undefined, the current element is the target element.\n *\n * # Scope selector usage\n *\n * When composed together, the final selector will be joined with `>` operators to make sure we\n * target direct descendants at each level. In this function, we'll use `querySelector` to check if\n * a selector matches descendants of the current element. But by default, the query selector match\n * elements at any level. Example:\n *\n * ```html\n * <main>\n *   <div>\n *     <span></span>\n *   </div>\n *   <marquee>\n *     <div>\n *       <span></span>\n *     </div>\n *   </marquee>\n * </main>\n * ```\n *\n * `sibling.querySelector('DIV > SPAN')` will match both span elements, so we would consider the\n * selector to be not unique, even if it is unique when we'll compose it with the parent with a `>`\n * operator (`MAIN > DIV > SPAN`).\n *\n * To avoid this, we can use the `:scope` selector to make sure the selector starts from the current\n * sibling (i.e. `sibling.querySelector('DIV:scope > SPAN')` will only match the first span).\n *\n * [1]: https://developer.mozilla.org/fr/docs/Web/CSS/:scope\n *\n * # Performance considerations\n *\n * We compute selectors in performance-critical operations (ex: during a click), so we need to make\n * sure the function is as fast as possible. We observed that naively using `querySelectorAll` to\n * check if the selector matches more than 1 element is quite expensive, so we want to avoid it.\n *\n * Because we are iterating the DOM upward and we use that function at every level, we know the\n * child selector is already unique among the current element children, so we don't need to check\n * for the current element subtree.\n *\n * Instead, we can focus on the current element siblings. If we find a single element matching the\n * selector within a sibling, we know that it's not unique. This allows us to use `querySelector`\n * (or `matches`, when the current element is the target element) instead of `querySelectorAll`.\n */\nexport function isSelectorUniqueAmongSiblings(\n  currentElement: Element,\n  _rootNode: Document | ShadowRoot,\n  currentElementSelector: string,\n  childSelector: string | undefined\n): boolean {\n  let isSiblingMatching: (sibling: Element) => boolean\n\n  if (childSelector === undefined) {\n    // If the child selector is undefined (meaning `currentElement` is the target element, not one\n    // of its ancestor), we need to use `matches` to check if the sibling is matching the selector,\n    // as `querySelector` only returns a descendant of the element.\n    isSiblingMatching = (sibling) => sibling.matches(currentElementSelector)\n  } else {\n    const scopedSelector = combineSelector(`${currentElementSelector}:scope`, childSelector)\n    isSiblingMatching = (sibling) => sibling.querySelector(scopedSelector) !== null\n  }\n\n  // Check siblings by iterating directly through previousElementSibling and nextElementSibling.\n  // This works even when parentElement is null (e.g., when parent is a DocumentFragment).\n\n  // Check previous siblings\n  let sibling = currentElement.previousElementSibling\n  while (sibling) {\n    if (isSiblingMatching(sibling)) {\n      return false\n    }\n    sibling = sibling.previousElementSibling\n  }\n\n  // Check next siblings\n  sibling = currentElement.nextElementSibling\n  while (sibling) {\n    if (isSiblingMatching(sibling)) {\n      return false\n    }\n    sibling = sibling.nextElementSibling\n  }\n\n  return true\n}\n\nfunction combineSelector(parent: string, child: string | undefined): string {\n  return child ? `${parent}>${child}` : parent\n}\n"],"mappings":"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"}

package/esm/domain/getSessionReplayUrl.mjs

@@ -0,0 +1,20 @@
+//#region src/domain/getSessionReplayUrl.ts
+function getSessionReplayUrl(configuration, { session, viewContext, errorType }) {
+	const sessionId = session ? session.id : "no-session-id";
+	const parameters = [];
+	if (errorType !== void 0) parameters.push(`error-type=${errorType}`);
+	if (viewContext) {
+		parameters.push(`seed=${viewContext.id}`);
+		parameters.push(`from=${viewContext.startClocks.timeStamp}`);
+	}
+	return `${getKubeSenseSiteUrl(configuration)}${`/rum/replay/sessions/${sessionId}`}?${parameters.join("&")}`;
+}
+function getKubeSenseSiteUrl(rumConfiguration) {
+	const site = rumConfiguration.kubesenseRumEndpoint;
+	const subdomain = rumConfiguration.subdomain;
+	return `https://${subdomain ? `${subdomain}.` : ""}${site}`;
+}
+//#endregion
+export { getKubeSenseSiteUrl, getSessionReplayUrl };
+
+//# sourceMappingURL=getSessionReplayUrl.mjs.map

package/esm/domain/getSessionReplayUrl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSessionReplayUrl.mjs","names":[],"sources":["../../src/domain/getSessionReplayUrl.ts"],"sourcesContent":["import type { SessionContext } from '@kubesense/kubesense-browser-core'\nimport type { RumConfiguration } from './configuration'\nimport type { ViewHistoryEntry } from './contexts/viewHistory'\n\nexport function getSessionReplayUrl(\n  configuration: RumConfiguration,\n  {\n    session,\n    viewContext,\n    errorType,\n  }: {\n    session?: SessionContext\n    viewContext?: ViewHistoryEntry\n    errorType?: string\n  }\n): string {\n  const sessionId = session ? session.id : 'no-session-id'\n  const parameters: string[] = []\n  if (errorType !== undefined) {\n    parameters.push(`error-type=${errorType}`)\n  }\n  if (viewContext) {\n    parameters.push(`seed=${viewContext.id}`)\n    parameters.push(`from=${viewContext.startClocks.timeStamp}`)\n  }\n\n  const origin = getKubeSenseSiteUrl(configuration)\n  const path = `/rum/replay/sessions/${sessionId}`\n  return `${origin}${path}?${parameters.join('&')}`\n}\n\nexport function getKubeSenseSiteUrl(rumConfiguration: RumConfiguration) {\n  // KubeSense installations address the collector host directly, so there is no per-site default\n  // subdomain to derive: only an explicitly configured `subdomain` is prepended.\n  const site = rumConfiguration.kubesenseRumEndpoint\n  const subdomain = rumConfiguration.subdomain\n  return `https://${subdomain ? `${subdomain}.` : ''}${site}`\n}\n"],"mappings":";AAIA,SAAgB,oBACd,eACA,EACE,SACA,aACA,aAMM;CACR,MAAM,YAAY,UAAU,QAAQ,KAAK;CACzC,MAAM,aAAuB,CAAC;CAC9B,IAAI,cAAc,KAAA,GAChB,WAAW,KAAK,cAAc,WAAW;CAE3C,IAAI,aAAa;EACf,WAAW,KAAK,QAAQ,YAAY,IAAI;EACxC,WAAW,KAAK,QAAQ,YAAY,YAAY,WAAW;CAC7D;CAIA,OAAO,GAFQ,oBAAoB,aAEpB,IAAI,wBADkB,YACb,GAAG,WAAW,KAAK,GAAG;AAChD;AAEA,SAAgB,oBAAoB,kBAAoC;CAGtE,MAAM,OAAO,iBAAiB;CAC9B,MAAM,YAAY,iBAAiB;CACnC,OAAO,WAAW,YAAY,GAAG,UAAU,KAAK,KAAK;AACvD"}

package/esm/domain/hooks.mjs

@@ -0,0 +1,13 @@
+import { createHook } from "@kubesense/kubesense-js-core/assembly";
+//#region src/domain/hooks.ts
+function createHooks() {
+	return {
+		assembleEventDefaults: createHook(),
+		assembleTelemetry: createHook(),
+		assembleEvent: createHook()
+	};
+}
+//#endregion
+export { createHooks };
+
+//# sourceMappingURL=hooks.mjs.map

package/esm/domain/hooks.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.mjs","names":[],"sources":["../../src/domain/hooks.ts"],"sourcesContent":["import type { Duration, RelativeTime } from '@kubesense/kubesense-js-core/time'\nimport type { TelemetryEvent } from '@kubesense/kubesense-browser-core'\nimport { createHook } from '@kubesense/kubesense-js-core/assembly'\nimport type { Hook } from '@kubesense/kubesense-js-core/assembly'\nimport type { RecursivePartial } from '@kubesense/kubesense-js-core/util'\nimport type { RumEvent } from '../rumEvent.types'\nimport type { RawRumEvent } from '../rawRumEvent.types'\nimport type { RumEventDomainContext } from '../domainContext.types'\n\n// Define a partial RUM event type.\n// Ensuring the `type` field is always present improves type checking, especially in conditional logic in hooks (e.g., `if (eventType === 'view')`).\nexport type DefaultRumEventAttributes = RecursivePartial<RumEvent> & { type: RumEvent['type'] }\nexport type DefaultTelemetryEventAttributes = RecursivePartial<TelemetryEvent>\n\ntype DeepReadonly<T> = {\n  readonly [K in keyof T]: DeepReadonly<T[K]>\n}\n\n// Use readonly and DeepReadonly to prevents assemble hook callbacks from mutating the inputs.\n// DeepReadonly is only applied to objects rather than the entire AssembleHookParams to avoid casts for primitives.\nexport interface AssembleHookParams {\n  readonly eventType: RumEvent['type']\n  rawRumEvent: DeepReadonly<RawRumEvent>\n  domainContext: DeepReadonly<RumEventDomainContext<RawRumEvent['type']>>\n  readonly startTime: RelativeTime\n  readonly duration?: Duration | undefined\n}\n\nexport type AssembleHook = Hook<AssembleHookParams, DefaultRumEventAttributes>\nexport type AssembleTelemetryHook = Hook<{ startTime: RelativeTime }, DefaultTelemetryEventAttributes>\n\nexport interface Hooks {\n  assembleEventDefaults: AssembleHook\n  assembleTelemetry: AssembleTelemetryHook\n  assembleEvent: AssembleHook\n}\n\nexport function createHooks(): Hooks {\n  return {\n    assembleEventDefaults: createHook(),\n    assembleTelemetry: createHook(),\n    assembleEvent: createHook(),\n  }\n}\n"],"mappings":";;AAqCA,SAAgB,cAAqB;CACnC,OAAO;EACL,uBAAuB,WAAW;EAClC,mBAAmB,WAAW;EAC9B,eAAe,WAAW;CAC5B;AACF"}

package/esm/domain/lifeCycle.mjs

@@ -0,0 +1,28 @@
+import { AbstractLifeCycle } from "@kubesense/kubesense-browser-core";
+//#region src/domain/lifeCycle.ts
+let LifeCycleEventType = /* @__PURE__ */ function(LifeCycleEventType) {
+	LifeCycleEventType[LifeCycleEventType["AUTO_ACTION_COMPLETED"] = 0] = "AUTO_ACTION_COMPLETED";
+	LifeCycleEventType[LifeCycleEventType["BEFORE_VIEW_CREATED"] = 1] = "BEFORE_VIEW_CREATED";
+	LifeCycleEventType[LifeCycleEventType["VIEW_CREATED"] = 2] = "VIEW_CREATED";
+	LifeCycleEventType[LifeCycleEventType["BEFORE_VIEW_UPDATED"] = 3] = "BEFORE_VIEW_UPDATED";
+	LifeCycleEventType[LifeCycleEventType["VIEW_UPDATED"] = 4] = "VIEW_UPDATED";
+	LifeCycleEventType[LifeCycleEventType["VIEW_ENDED"] = 5] = "VIEW_ENDED";
+	LifeCycleEventType[LifeCycleEventType["AFTER_VIEW_ENDED"] = 6] = "AFTER_VIEW_ENDED";
+	LifeCycleEventType[LifeCycleEventType["REQUEST_STARTED"] = 7] = "REQUEST_STARTED";
+	LifeCycleEventType[LifeCycleEventType["REQUEST_COMPLETED"] = 8] = "REQUEST_COMPLETED";
+	LifeCycleEventType[LifeCycleEventType["WEBSOCKET_COMPLETED"] = 9] = "WEBSOCKET_COMPLETED";
+	LifeCycleEventType[LifeCycleEventType["SESSION_EXPIRED"] = 10] = "SESSION_EXPIRED";
+	LifeCycleEventType[LifeCycleEventType["SESSION_RENEWED"] = 11] = "SESSION_RENEWED";
+	LifeCycleEventType[LifeCycleEventType["PREPARE_URGENT_FLUSH"] = 12] = "PREPARE_URGENT_FLUSH";
+	LifeCycleEventType[LifeCycleEventType["RAW_RUM_EVENT_COLLECTED"] = 13] = "RAW_RUM_EVENT_COLLECTED";
+	LifeCycleEventType[LifeCycleEventType["RUM_EVENT_COLLECTED"] = 14] = "RUM_EVENT_COLLECTED";
+	LifeCycleEventType[LifeCycleEventType["RAW_ERROR_COLLECTED"] = 15] = "RAW_ERROR_COLLECTED";
+	LifeCycleEventType[LifeCycleEventType["ACTION_STARTED"] = 16] = "ACTION_STARTED";
+	LifeCycleEventType[LifeCycleEventType["DURATION_VITAL_STARTED"] = 17] = "DURATION_VITAL_STARTED";
+	return LifeCycleEventType;
+}({});
+const LifeCycle = AbstractLifeCycle;
+//#endregion
+export { LifeCycle, LifeCycleEventType };
+
+//# sourceMappingURL=lifeCycle.mjs.map

package/esm/domain/lifeCycle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeCycle.mjs","names":[],"sources":["../../src/domain/lifeCycle.ts"],"sourcesContent":["import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time'\nimport type { Context, RawError, UrgentFlushReason } from '@kubesense/kubesense-browser-core'\nimport { AbstractLifeCycle } from '@kubesense/kubesense-browser-core'\nimport type { RumEventDomainContext } from '../domainContext.types'\nimport type { RawRumEvent, AssembledRumEvent } from '../rawRumEvent.types'\nimport type { RequestCompleteEvent, RequestStartEvent } from './requestCollection'\nimport type { WebSocketCompleteEvent } from './resource/webSocketCollection'\nimport type { AutoAction } from './action/actionCollection'\nimport type { ViewEvent, ViewCreatedEvent, ViewEndedEvent, BeforeViewUpdateEvent } from './view/trackViews'\nimport type { DurationVitalStart } from './vital/vitalCollection'\nimport type { TrackedEventData } from './eventTracker'\nimport type { ActionEventData } from './action/trackManualActions'\nimport type { SessionExpiredEvent } from './session/session.types'\n\nexport const enum LifeCycleEventType {\n  // Contexts (like viewHistory) should be opened using prefixed BEFORE_XXX events and closed using prefixed AFTER_XXX events\n  // It ensures the context is available during the non prefixed event callbacks\n  AUTO_ACTION_COMPLETED,\n  BEFORE_VIEW_CREATED,\n  VIEW_CREATED,\n  BEFORE_VIEW_UPDATED,\n  VIEW_UPDATED,\n  VIEW_ENDED,\n  AFTER_VIEW_ENDED,\n  REQUEST_STARTED,\n  REQUEST_COMPLETED,\n  WEBSOCKET_COMPLETED,\n\n  // The SESSION_EXPIRED lifecycle event has been introduced to represent when a session has expired\n  // and trigger cleanup tasks related to this, prior to renewing the session. Its implementation is\n  // slightly naive: it is not triggered as soon as the session is expired, but rather just before\n  // notifying that the session is renewed. Thus, the session id is already set to the newly renewed\n  // session.\n  //\n  // This implementation is \"good enough\" for our use-cases. Improving this is not trivial,\n  // primarily because multiple instances of the SDK may be managing the same session cookie at\n  // the same time, for example when using Logs and RUM on the same page, or opening multiple tabs\n  // on the same domain.\n  SESSION_EXPIRED,\n  SESSION_RENEWED,\n  PREPARE_URGENT_FLUSH,\n  RAW_RUM_EVENT_COLLECTED,\n  RUM_EVENT_COLLECTED,\n  RAW_ERROR_COLLECTED,\n  ACTION_STARTED,\n  DURATION_VITAL_STARTED,\n}\n\n// This is a workaround for an issue occurring when the Browser SDK is included in a TypeScript\n// project configured with `isolatedModules: true`. Even if the const enum is declared in this\n// module, we cannot use it directly to define the EventMap interface keys (TS error: \"Cannot access\n// ambient const enums when the '--isolatedModules' flag is provided.\").\n//\n// Using a plain enum would fix the issue, but would also add 2KB to the minified bundle. By using\n// this workaround, we can keep using a const enum without impacting the bundle size (since it is a\n// \"declare\" statement, it will only be used during typecheck and completely ignored when building\n// JavaScript).\n//\n// See issues:\n// * https://github.com/microsoft/TypeScript/issues/54152\ndeclare const LifeCycleEventTypeAsConst: {\n  ACTION_STARTED: LifeCycleEventType.ACTION_STARTED\n  AUTO_ACTION_COMPLETED: LifeCycleEventType.AUTO_ACTION_COMPLETED\n  BEFORE_VIEW_CREATED: LifeCycleEventType.BEFORE_VIEW_CREATED\n  VIEW_CREATED: LifeCycleEventType.VIEW_CREATED\n  BEFORE_VIEW_UPDATED: LifeCycleEventType.BEFORE_VIEW_UPDATED\n  VIEW_UPDATED: LifeCycleEventType.VIEW_UPDATED\n  VIEW_ENDED: LifeCycleEventType.VIEW_ENDED\n  AFTER_VIEW_ENDED: LifeCycleEventType.AFTER_VIEW_ENDED\n  REQUEST_STARTED: LifeCycleEventType.REQUEST_STARTED\n  REQUEST_COMPLETED: LifeCycleEventType.REQUEST_COMPLETED\n  WEBSOCKET_COMPLETED: LifeCycleEventType.WEBSOCKET_COMPLETED\n  SESSION_EXPIRED: LifeCycleEventType.SESSION_EXPIRED\n  SESSION_RENEWED: LifeCycleEventType.SESSION_RENEWED\n  PREPARE_URGENT_FLUSH: LifeCycleEventType.PREPARE_URGENT_FLUSH\n  RAW_RUM_EVENT_COLLECTED: LifeCycleEventType.RAW_RUM_EVENT_COLLECTED\n  RUM_EVENT_COLLECTED: LifeCycleEventType.RUM_EVENT_COLLECTED\n  RAW_ERROR_COLLECTED: LifeCycleEventType.RAW_ERROR_COLLECTED\n  DURATION_VITAL_STARTED: LifeCycleEventType.DURATION_VITAL_STARTED\n}\n\n// Note: this interface needs to be exported even if it is not used outside of this module, else TS\n// fails to build the rum-core package with error TS4058\nexport interface LifeCycleEventMap {\n  [LifeCycleEventTypeAsConst.ACTION_STARTED]: TrackedEventData<ActionEventData>\n  [LifeCycleEventTypeAsConst.AUTO_ACTION_COMPLETED]: AutoAction\n  [LifeCycleEventTypeAsConst.BEFORE_VIEW_CREATED]: ViewCreatedEvent\n  [LifeCycleEventTypeAsConst.VIEW_CREATED]: ViewCreatedEvent\n  [LifeCycleEventTypeAsConst.BEFORE_VIEW_UPDATED]: BeforeViewUpdateEvent\n  [LifeCycleEventTypeAsConst.VIEW_UPDATED]: ViewEvent\n  [LifeCycleEventTypeAsConst.VIEW_ENDED]: ViewEndedEvent\n  [LifeCycleEventTypeAsConst.AFTER_VIEW_ENDED]: ViewEndedEvent\n  [LifeCycleEventTypeAsConst.REQUEST_STARTED]: RequestStartEvent\n  [LifeCycleEventTypeAsConst.REQUEST_COMPLETED]: RequestCompleteEvent\n  [LifeCycleEventTypeAsConst.WEBSOCKET_COMPLETED]: WebSocketCompleteEvent\n  [LifeCycleEventTypeAsConst.SESSION_EXPIRED]: SessionExpiredEvent\n  [LifeCycleEventTypeAsConst.SESSION_RENEWED]: void\n  [LifeCycleEventTypeAsConst.PREPARE_URGENT_FLUSH]: UrgentFlushReason\n  [LifeCycleEventTypeAsConst.RAW_RUM_EVENT_COLLECTED]: RawRumEventCollectedData\n  [LifeCycleEventTypeAsConst.RUM_EVENT_COLLECTED]: AssembledRumEvent\n  [LifeCycleEventTypeAsConst.RAW_ERROR_COLLECTED]: {\n    error: RawError\n    customerContext?: Context\n  }\n  [LifeCycleEventTypeAsConst.DURATION_VITAL_STARTED]: DurationVitalStart\n}\n\nexport interface RawRumEventCollectedData<E extends RawRumEvent = RawRumEvent> {\n  startClocks: ClocksState\n  duration?: Duration\n  rawRumEvent: E\n  domainContext: RumEventDomainContext<E['type']>\n}\n\nexport const LifeCycle = AbstractLifeCycle<LifeCycleEventMap>\nexport type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>\n"],"mappings":";;AAcA,IAAkB,qBAAX,yBAAA,oBAAA;CAGL,mBAAA,mBAAA,2BAAA,KAAA;CACA,mBAAA,mBAAA,yBAAA,KAAA;CACA,mBAAA,mBAAA,kBAAA,KAAA;CACA,mBAAA,mBAAA,yBAAA,KAAA;CACA,mBAAA,mBAAA,kBAAA,KAAA;CACA,mBAAA,mBAAA,gBAAA,KAAA;CACA,mBAAA,mBAAA,sBAAA,KAAA;CACA,mBAAA,mBAAA,qBAAA,KAAA;CACA,mBAAA,mBAAA,uBAAA,KAAA;CACA,mBAAA,mBAAA,yBAAA,KAAA;CAYA,mBAAA,mBAAA,qBAAA,MAAA;CACA,mBAAA,mBAAA,qBAAA,MAAA;CACA,mBAAA,mBAAA,0BAAA,MAAA;CACA,mBAAA,mBAAA,6BAAA,MAAA;CACA,mBAAA,mBAAA,yBAAA,MAAA;CACA,mBAAA,mBAAA,yBAAA,MAAA;CACA,mBAAA,mBAAA,oBAAA,MAAA;CACA,mBAAA,mBAAA,4BAAA,MAAA;;AACF,EAAA,CAAA,CAAA;AAoEA,MAAa,YAAY"}

package/esm/domain/limitModification.mjs

@@ -0,0 +1,42 @@
+import { deepClone, getType } from "@kubesense/kubesense-js-core/util";
+import { objectEntries, sanitize } from "@kubesense/kubesense-browser-core";
+//#region src/domain/limitModification.ts
+/**
+* Allows declaring and enforcing modifications to specific fields of an object.
+* Only supports modifying properties of an object (even if nested in an array).
+* Does not support array manipulation (adding/removing items).
+*
+* Modifications of the object are sanitized only if the field was actually changed by the modifier function (i.e., value is different).
+* This ensures consistent SDK behavior regardless of whether limitModification is called.
+* Only string fields are handled this way, object fields are sanitized regardless of whether the modifier function was called or not.
+*/
+function limitModification(object, modifiableFieldPaths, modifier) {
+	const clone = deepClone(object);
+	const result = modifier(clone);
+	objectEntries(modifiableFieldPaths).forEach(([fieldPath, fieldType]) => setValueAtPath(object, clone, fieldPath.split(/\.|(?=\[\])/), fieldType));
+	return result;
+}
+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));
+		return;
+	}
+	if (!isValidObject(object) || !isValidObject(clone)) return;
+	if (restPathSegments.length > 0) return setValueAtPath(object[field], clone[field], restPathSegments, fieldType);
+	setNestedValue(object, field, clone[field], fieldType);
+}
+function setNestedValue(object, field, value, fieldType) {
+	if (object[field] === value) return;
+	const newType = getType(value);
+	if (newType === fieldType) object[field] = sanitize(value);
+	else if (fieldType === "object" && (newType === "undefined" || newType === "null")) object[field] = {};
+	else if (fieldType === "array" && (newType === "undefined" || newType === "null")) object[field] = [];
+}
+function isValidObject(object) {
+	return getType(object) === "object";
+}
+//#endregion
+export { limitModification };
+
+//# sourceMappingURL=limitModification.mjs.map

package/esm/domain/limitModification.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitModification.mjs","names":[],"sources":["../../src/domain/limitModification.ts"],"sourcesContent":["import { sanitize, objectEntries } from '@kubesense/kubesense-browser-core'\nimport type { Context } from '@kubesense/kubesense-browser-core'\nimport { deepClone, getType } from '@kubesense/kubesense-js-core/util'\n\nexport type ModifiableFieldPaths = Record<string, 'string' | 'object' | 'array'>\n\n/**\n * Allows declaring and enforcing modifications to specific fields of an object.\n * Only supports modifying properties of an object (even if nested in an array).\n * Does not support array manipulation (adding/removing items).\n *\n * Modifications of the object are sanitized only if the field was actually changed by the modifier function (i.e., value is different).\n * This ensures consistent SDK behavior regardless of whether limitModification is called.\n * Only string fields are handled this way, object fields are sanitized regardless of whether the modifier function was called or not.\n */\nexport function limitModification<T extends Context, Result>(\n  object: T,\n  modifiableFieldPaths: ModifiableFieldPaths,\n  modifier: (object: T) => Result\n): Result | undefined {\n  const clone = deepClone(object)\n  const result = modifier(clone)\n\n  objectEntries(modifiableFieldPaths).forEach(([fieldPath, fieldType]) =>\n    // 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\n    setValueAtPath(object, clone, fieldPath.split(/\\.|(?=\\[\\])/), fieldType)\n  )\n\n  return result\n}\n\nfunction setValueAtPath(\n  object: unknown,\n  clone: unknown,\n  pathSegments: string[],\n  fieldType: 'string' | 'object' | 'array'\n) {\n  const [field, ...restPathSegments] = pathSegments\n\n  if (field === '[]') {\n    if (Array.isArray(object) && Array.isArray(clone)) {\n      object.forEach((item, i) => setValueAtPath(item, clone[i], restPathSegments, fieldType))\n    }\n\n    return\n  }\n\n  if (!isValidObject(object) || !isValidObject(clone)) {\n    return\n  }\n\n  if (restPathSegments.length > 0) {\n    return setValueAtPath(object[field], clone[field], restPathSegments, fieldType)\n  }\n\n  setNestedValue(object, field, clone[field], fieldType)\n}\n\nfunction setNestedValue(\n  object: Record<string, unknown>,\n  field: string,\n  value: unknown,\n  fieldType: 'string' | 'object' | 'array'\n) {\n  if (object[field] === value) {\n    return\n  }\n\n  const newType = getType(value)\n\n  if (newType === fieldType) {\n    object[field] = sanitize(value)\n  } else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {\n    object[field] = {}\n  } else if (fieldType === 'array' && (newType === 'undefined' || newType === 'null')) {\n    object[field] = []\n  }\n}\n\nfunction isValidObject(object: unknown): object is Record<string, unknown> {\n  return getType(object) === 'object'\n}\n"],"mappings":";;;;;;;;;;;;AAeA,SAAgB,kBACd,QACA,sBACA,UACoB;CACpB,MAAM,QAAQ,UAAU,MAAM;CAC9B,MAAM,SAAS,SAAS,KAAK;CAE7B,cAAc,oBAAoB,CAAC,CAAC,SAAS,CAAC,WAAW,eAEvD,eAAe,QAAQ,OAAO,UAAU,MAAM,aAAa,GAAG,SAAS,CACzE;CAEA,OAAO;AACT;AAEA,SAAS,eACP,QACA,OACA,cACA,WACA;CACA,MAAM,CAAC,OAAO,GAAG,oBAAoB;CAErC,IAAI,UAAU,MAAM;EAClB,IAAI,MAAM,QAAQ,MAAM,KAAK,MAAM,QAAQ,KAAK,GAC9C,OAAO,SAAS,MAAM,MAAM,eAAe,MAAM,MAAM,IAAI,kBAAkB,SAAS,CAAC;EAGzF;CACF;CAEA,IAAI,CAAC,cAAc,MAAM,KAAK,CAAC,cAAc,KAAK,GAChD;CAGF,IAAI,iBAAiB,SAAS,GAC5B,OAAO,eAAe,OAAO,QAAQ,MAAM,QAAQ,kBAAkB,SAAS;CAGhF,eAAe,QAAQ,OAAO,MAAM,QAAQ,SAAS;AACvD;AAEA,SAAS,eACP,QACA,OACA,OACA,WACA;CACA,IAAI,OAAO,WAAW,OACpB;CAGF,MAAM,UAAU,QAAQ,KAAK;CAE7B,IAAI,YAAY,WACd,OAAO,SAAS,SAAS,KAAK;MACzB,IAAI,cAAc,aAAa,YAAY,eAAe,YAAY,SAC3E,OAAO,SAAS,CAAC;MACZ,IAAI,cAAc,YAAY,YAAY,eAAe,YAAY,SAC1E,OAAO,SAAS,CAAC;AAErB;AAEA,SAAS,cAAc,QAAoD;CACzE,OAAO,QAAQ,MAAM,MAAM;AAC7B"}

package/esm/domain/longTask/longTaskCollection.mjs

@@ -0,0 +1,79 @@
+import { RumEventType, RumLongTaskEntryType } from "../../rawRumEvent.types.mjs";
+import "../lifeCycle.mjs";
+import { createPerformanceObservable, supportPerformanceTimingEvent } from "../../browser/performanceObservable.mjs";
+import { relativeToClocks, toServerDuration } from "@kubesense/kubesense-js-core/time";
+import { buildDebugIdByUrl, generateUUID } from "@kubesense/kubesense-browser-core";
+//#region src/domain/longTask/longTaskCollection.ts
+function startLongTaskCollection(lifeCycle, configuration) {
+	const entryType = supportPerformanceTimingEvent("long-animation-frame") ? "long-animation-frame" : "longtask";
+	const subscription = createPerformanceObservable({
+		type: entryType,
+		buffered: true
+	}).subscribe((entries) => {
+		for (const entry of entries) {
+			if (!configuration.trackLongTasks) break;
+			const startClocks = relativeToClocks(entry.startTime);
+			const rawRumEvent = processEntry(entry, startClocks);
+			lifeCycle.notify(13, {
+				rawRumEvent,
+				startClocks,
+				duration: entry.duration,
+				domainContext: { performanceEntry: entry }
+			});
+		}
+	});
+	return { stop: () => subscription.unsubscribe() };
+}
+function processEntry(entry, startClocks) {
+	const id = generateUUID();
+	const duration = toServerDuration(entry.duration);
+	const baseEvent = {
+		date: startClocks.timeStamp,
+		type: RumEventType.LONG_TASK,
+		_kubesense: { discarded: false }
+	};
+	if (entry.entryType === "longtask") return {
+		...baseEvent,
+		long_task: {
+			id,
+			entry_type: RumLongTaskEntryType.LONG_TASK,
+			duration
+		}
+	};
+	const scriptUrls = entry.scripts.map((script) => script.sourceURL).filter((url) => !!url);
+	const debugIdByUrl = buildDebugIdByUrl(scriptUrls);
+	return {
+		...baseEvent,
+		_kubesense: {
+			discarded: false,
+			debug_ids: debugIdByUrl
+		},
+		long_task: {
+			id,
+			entry_type: RumLongTaskEntryType.LONG_ANIMATION_FRAME,
+			duration,
+			blocking_duration: toServerDuration(entry.blockingDuration),
+			first_ui_event_timestamp: toServerDuration(entry.firstUIEventTimestamp),
+			render_start: toServerDuration(entry.renderStart),
+			style_and_layout_start: toServerDuration(entry.styleAndLayoutStart),
+			start_time: toServerDuration(entry.startTime),
+			scripts: entry.scripts.map((script) => ({
+				duration: toServerDuration(script.duration),
+				pause_duration: toServerDuration(script.pauseDuration),
+				forced_style_and_layout_duration: toServerDuration(script.forcedStyleAndLayoutDuration),
+				start_time: toServerDuration(script.startTime),
+				execution_start: toServerDuration(script.executionStart),
+				source_url: script.sourceURL,
+				source_function_name: script.sourceFunctionName,
+				source_char_position: script.sourceCharPosition,
+				invoker: script.invoker,
+				invoker_type: script.invokerType,
+				window_attribution: script.windowAttribution
+			}))
+		}
+	};
+}
+//#endregion
+export { startLongTaskCollection };
+
+//# sourceMappingURL=longTaskCollection.mjs.map

package/esm/domain/longTask/longTaskCollection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"longTaskCollection.mjs","names":[],"sources":["../../../src/domain/longTask/longTaskCollection.ts"],"sourcesContent":["import type { ClocksState } from '@kubesense/kubesense-js-core/time'\nimport { toServerDuration, relativeToClocks } from '@kubesense/kubesense-js-core/time'\nimport { generateUUID, buildDebugIdByUrl } from '@kubesense/kubesense-browser-core'\nimport type { RawRumLongTaskEvent, RawRumLongAnimationFrameEvent } from '../../rawRumEvent.types'\nimport { RumEventType, RumLongTaskEntryType } from '../../rawRumEvent.types'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport {\n  createPerformanceObservable,\n  RumPerformanceEntryType,\n  supportPerformanceTimingEvent,\n} from '../../browser/performanceObservable'\nimport type {\n  RumPerformanceLongAnimationFrameTiming,\n  RumPerformanceLongTaskTiming,\n  RumPerformanceScriptTiming,\n} from '../../browser/performanceObservable'\nimport type { RumConfiguration } from '../configuration'\n\nexport function startLongTaskCollection(lifeCycle: LifeCycle, configuration: RumConfiguration) {\n  const entryType = supportPerformanceTimingEvent(RumPerformanceEntryType.LONG_ANIMATION_FRAME)\n    ? RumPerformanceEntryType.LONG_ANIMATION_FRAME\n    : RumPerformanceEntryType.LONG_TASK\n\n  const subscription = createPerformanceObservable({\n    type: entryType,\n    buffered: true,\n  }).subscribe((entries) => {\n    for (const entry of entries) {\n      if (!configuration.trackLongTasks) {\n        break\n      }\n\n      const startClocks = relativeToClocks(entry.startTime)\n      const rawRumEvent = processEntry(entry, startClocks)\n\n      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {\n        rawRumEvent,\n        startClocks,\n        duration: entry.duration,\n        domainContext: { performanceEntry: entry },\n      })\n    }\n  })\n\n  return {\n    stop: () => subscription.unsubscribe(),\n  }\n}\n\nfunction processEntry(\n  entry: RumPerformanceLongTaskTiming | RumPerformanceLongAnimationFrameTiming,\n  startClocks: ClocksState\n): RawRumLongTaskEvent | RawRumLongAnimationFrameEvent {\n  const id = generateUUID()\n  const duration = toServerDuration(entry.duration)\n\n  const baseEvent = {\n    date: startClocks.timeStamp,\n    type: RumEventType.LONG_TASK,\n    _kubesense: { discarded: false },\n  }\n\n  if (entry.entryType === RumPerformanceEntryType.LONG_TASK) {\n    return {\n      ...baseEvent,\n      long_task: {\n        id,\n        entry_type: RumLongTaskEntryType.LONG_TASK,\n        duration,\n      },\n    }\n  }\n  const scriptUrls = entry.scripts.map((script) => script.sourceURL).filter((url): url is string => !!url)\n  const debugIdByUrl = buildDebugIdByUrl(scriptUrls)\n\n  return {\n    ...baseEvent,\n    _kubesense: { discarded: false, debug_ids: debugIdByUrl },\n    long_task: {\n      id,\n      entry_type: RumLongTaskEntryType.LONG_ANIMATION_FRAME,\n      duration,\n      blocking_duration: toServerDuration(entry.blockingDuration),\n      first_ui_event_timestamp: toServerDuration(entry.firstUIEventTimestamp),\n      render_start: toServerDuration(entry.renderStart),\n      style_and_layout_start: toServerDuration(entry.styleAndLayoutStart),\n      start_time: toServerDuration(entry.startTime),\n      scripts: entry.scripts.map((script: RumPerformanceScriptTiming) => ({\n        duration: toServerDuration(script.duration),\n        pause_duration: toServerDuration(script.pauseDuration),\n        forced_style_and_layout_duration: toServerDuration(script.forcedStyleAndLayoutDuration),\n        start_time: toServerDuration(script.startTime),\n        execution_start: toServerDuration(script.executionStart),\n        source_url: script.sourceURL,\n        source_function_name: script.sourceFunctionName,\n        source_char_position: script.sourceCharPosition,\n        invoker: script.invoker,\n        invoker_type: script.invokerType,\n        window_attribution: script.windowAttribution,\n      })),\n    },\n  }\n}\n"],"mappings":";;;;;;AAmBA,SAAgB,wBAAwB,WAAsB,eAAiC;CAC7F,MAAM,YAAY,8BAAA,sBAA0E,IAAA,yBAAA;CAI5F,MAAM,eAAe,4BAA4B;EAC/C,MAAM;EACN,UAAU;CACZ,CAAC,CAAC,CAAC,WAAW,YAAY;EACxB,KAAK,MAAM,SAAS,SAAS;GAC3B,IAAI,CAAC,cAAc,gBACjB;GAGF,MAAM,cAAc,iBAAiB,MAAM,SAAS;GACpD,MAAM,cAAc,aAAa,OAAO,WAAW;GAEnD,UAAU,OAAA,IAAmD;IAC3D;IACA;IACA,UAAU,MAAM;IAChB,eAAe,EAAE,kBAAkB,MAAM;GAC3C,CAAC;EACH;CACF,CAAC;CAED,OAAO,EACL,YAAY,aAAa,YAAY,EACvC;AACF;AAEA,SAAS,aACP,OACA,aACqD;CACrD,MAAM,KAAK,aAAa;CACxB,MAAM,WAAW,iBAAiB,MAAM,QAAQ;CAEhD,MAAM,YAAY;EAChB,MAAM,YAAY;EAClB,MAAM,aAAa;EACnB,YAAY,EAAE,WAAW,MAAM;CACjC;CAEA,IAAI,MAAM,cAAA,YACR,OAAO;EACL,GAAG;EACH,WAAW;GACT;GACA,YAAY,qBAAqB;GACjC;EACF;CACF;CAEF,MAAM,aAAa,MAAM,QAAQ,KAAK,WAAW,OAAO,SAAS,CAAC,CAAC,QAAQ,QAAuB,CAAC,CAAC,GAAG;CACvG,MAAM,eAAe,kBAAkB,UAAU;CAEjD,OAAO;EACL,GAAG;EACH,YAAY;GAAE,WAAW;GAAO,WAAW;EAAa;EACxD,WAAW;GACT;GACA,YAAY,qBAAqB;GACjC;GACA,mBAAmB,iBAAiB,MAAM,gBAAgB;GAC1D,0BAA0B,iBAAiB,MAAM,qBAAqB;GACtE,cAAc,iBAAiB,MAAM,WAAW;GAChD,wBAAwB,iBAAiB,MAAM,mBAAmB;GAClE,YAAY,iBAAiB,MAAM,SAAS;GAC5C,SAAS,MAAM,QAAQ,KAAK,YAAwC;IAClE,UAAU,iBAAiB,OAAO,QAAQ;IAC1C,gBAAgB,iBAAiB,OAAO,aAAa;IACrD,kCAAkC,iBAAiB,OAAO,4BAA4B;IACtF,YAAY,iBAAiB,OAAO,SAAS;IAC7C,iBAAiB,iBAAiB,OAAO,cAAc;IACvD,YAAY,OAAO;IACnB,sBAAsB,OAAO;IAC7B,sBAAsB,OAAO;IAC7B,SAAS,OAAO;IAChB,cAAc,OAAO;IACrB,oBAAoB,OAAO;GAC7B,EAAE;EACJ;CACF;AACF"}

package/esm/domain/plugins.mjs

@@ -0,0 +1,23 @@
+import { isThenable } from "@kubesense/kubesense-browser-core";
+//#region src/domain/plugins.ts
+/**
+* Calls every plugin's `onInit` method concurrently, without waiting for one to resolve before
+* calling the next. Stays synchronous as long as no plugin returns a thenable.
+* Returns `false` if any plugin returned (or resolved to) `false`, `true` otherwise.
+*/
+function callPluginsOnInit(plugins, parameter) {
+	if (!plugins) return true;
+	const results = plugins.map((plugin) => plugin.onInit?.(parameter));
+	if (results.some(isThenable)) return Promise.all(results).then((results) => !results.includes(false));
+	return !results.includes(false);
+}
+/**
+* Calls each plugin's `onRumStart` method in order.
+*/
+function callPluginsOnRumStart(plugins, options) {
+	for (const plugin of plugins ?? []) plugin.onRumStart?.(options);
+}
+//#endregion
+export { callPluginsOnInit, callPluginsOnRumStart };
+
+//# sourceMappingURL=plugins.mjs.map

package/esm/domain/plugins.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.mjs","names":[],"sources":["../../src/domain/plugins.ts"],"sourcesContent":["import { isThenable } from '@kubesense/kubesense-browser-core'\nimport type { RumPublicApi } from '../boot/rumPublicApi'\nimport type { StartRumResult } from '../boot/startRum'\nimport type { RumInitConfiguration } from './configuration'\nimport type { AssembleHook } from './hooks'\n\n/**\n * onInit plugin API options.\n *\n * @experimental\n */\nexport interface RumPluginOnInitOptions {\n  initConfiguration: RumInitConfiguration\n  publicApi: RumPublicApi\n  /**\n   * Register a callback invoked when a RUM event is assembled, so plugins can enrich or override\n   * event fields before they are sent. Callbacks registered in `onInit` run before any event is\n   * assembled, including events buffered during the pre-start phase.\n   */\n  registerAssembleEventHook: AssembleHook['register']\n}\n\n/**\n * onRumStart plugin API options.\n *\n * @experimental\n */\nexport interface OnRumStartOptions {\n  /**\n   * Add an event to the RUM browser SDK.\n   */\n  addEvent?: StartRumResult['addEvent']\n  /**\n   * Add a custom error to the RUM browser SDK.\n   */\n  addError?: StartRumResult['addError']\n}\n\n/**\n * Plugin interface of the RUM browser SDK.\n *\n * The plugins API is unstable and experimental, and may change without\n * notice. Please use only plugins provided by KubeSense matching the version of the SDK you are\n * using.\n *\n * `onInit` may abort the SDK initialization by returning (or resolving to) `false`. All plugins'\n * `onInit` are called concurrently and independently; a Promise defers the actual initialization\n * until it resolves, but does not delay any other plugin's `onInit` call.\n *\n * @experimental\n */\nexport interface RumPlugin {\n  name: string\n  getConfigurationTelemetry?(): Record<string, unknown>\n  onInit?(options: RumPluginOnInitOptions): false | void | Promise<false | void>\n  onRumStart?(options: OnRumStartOptions): void\n}\n\n/**\n * Calls every plugin's `onInit` method concurrently, without waiting for one to resolve before\n * calling the next. Stays synchronous as long as no plugin returns a thenable.\n * Returns `false` if any plugin returned (or resolved to) `false`, `true` otherwise.\n */\nexport function callPluginsOnInit(\n  plugins: RumPlugin[] | undefined,\n  parameter: RumPluginOnInitOptions\n): boolean | Promise<boolean> {\n  if (!plugins) {\n    return true\n  }\n\n  const results = plugins.map((plugin) => plugin.onInit?.(parameter))\n\n  if (results.some(isThenable)) {\n    return Promise.all(results as Array<Promise<false | void>>).then((results) => !results.includes(false))\n  }\n\n  return !results.includes(false)\n}\n\n/**\n * Calls each plugin's `onRumStart` method in order.\n */\nexport function callPluginsOnRumStart(plugins: RumPlugin[] | undefined, options: OnRumStartOptions): void {\n  for (const plugin of plugins ?? []) {\n    plugin.onRumStart?.(options)\n  }\n}\n"],"mappings":";;;;;;;AA+DA,SAAgB,kBACd,SACA,WAC4B;CAC5B,IAAI,CAAC,SACH,OAAO;CAGT,MAAM,UAAU,QAAQ,KAAK,WAAW,OAAO,SAAS,SAAS,CAAC;CAElE,IAAI,QAAQ,KAAK,UAAU,GACzB,OAAO,QAAQ,IAAI,OAAuC,CAAC,CAAC,MAAM,YAAY,CAAC,QAAQ,SAAS,KAAK,CAAC;CAGxG,OAAO,CAAC,QAAQ,SAAS,KAAK;AAChC;;;;AAKA,SAAgB,sBAAsB,SAAkC,SAAkC;CACxG,KAAK,MAAM,UAAU,WAAW,CAAC,GAC/B,OAAO,aAAa,OAAO;AAE/B"}