@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/esm/browser/cookie.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookie.mjs","names":[],"sources":["../../src/browser/cookie.ts"],"sourcesContent":["import { ONE_SECOND } from '@kubesense/kubesense-js-core/time'\nimport { buildUrl, globalObject } from '@kubesense/kubesense-js-core/util'\nimport {\n  findAllCommaSeparatedValues,\n  findCommaSeparatedValue,\n  findCommaSeparatedValues,\n  generateUUID,\n} from '../tools/utils/stringUtils'\nimport type { Configuration } from '../domain/configuration'\n\nexport interface CookieOptions {\n  secure?: boolean\n  crossSite?: boolean\n  partitioned?: boolean\n  domain?: string\n}\n\nexport function setCookie(name: string, value: string, expireDelay: number = 0, options?: CookieOptions) {\n  const date = new Date()\n  date.setTime(date.getTime() + expireDelay)\n  const expires = `expires=${date.toUTCString()}`\n  const sameSite = options?.crossSite ? 'none' : 'strict'\n  const domain = options?.domain ? `;domain=${options.domain}` : ''\n  const secure = options?.secure ? ';secure' : ''\n  const partitioned = options?.partitioned ? ';partitioned' : ''\n  document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`\n}\n\n/**\n * Returns the value of the cookie with the given name\n * If there are multiple cookies with the same name, returns the first one\n */\nexport function getCookie(name: string) {\n  const value = findCommaSeparatedValue(document.cookie, name)\n\n  if (value === '') {\n    return\n  }\n\n  return value\n}\n\n/**\n * Returns all the values of the cookies with the given name\n */\nexport function getCookies(name: string): string[] {\n  return findAllCommaSeparatedValues(document.cookie).get(name) || []\n}\n\nlet initCookieParsed: Map<string, string> | undefined\n\n/**\n * Returns a cached value of the cookie. Use this during SDK initialization (and whenever possible)\n * to avoid accessing document.cookie multiple times.\n *\n * ⚠️ If there are multiple cookies with the same name, returns the LAST one (unlike `getCookie()`)\n */\nexport function getInitCookie(name: string) {\n  if (!initCookieParsed) {\n    initCookieParsed = findCommaSeparatedValues(document.cookie)\n  }\n  return initCookieParsed.get(name)\n}\n\nexport function resetInitCookies() {\n  initCookieParsed = undefined\n}\n\nexport function deleteCookie(name: string, options?: CookieOptions) {\n  setCookie(name, '', 0, options)\n}\n\n/**\n * No API to retrieve it, number of levels for subdomain and suffix are unknown\n * strategy: find the minimal domain on which cookies are allowed to be set\n * https://web.dev/same-site-same-origin/#site\n */\nlet getCurrentSiteCache: string | undefined\nexport function getCurrentSite(\n  hostname = globalObject.location?.hostname ?? '',\n  referrer = typeof document !== 'undefined' ? document.referrer : ''\n): string | undefined {\n  // Cookie probing requires document.cookie, which is not available in Web Workers or Node.js\n  if (typeof document === 'undefined') {\n    return undefined\n  }\n  if (getCurrentSiteCache === undefined) {\n    const defaultHostName = getCookieDefaultHostName(hostname, referrer)\n    if (defaultHostName) {\n      // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n      // the test cookie lifetime\n      const testCookieName = `kubesense_site_test_${generateUUID()}`\n      const testCookieValue = 'test'\n\n      const domainLevels = defaultHostName.split('.')\n      let candidateDomain = domainLevels.pop()!\n      while (domainLevels.length && !getCookie(testCookieName)) {\n        candidateDomain = `${domainLevels.pop()!}.${candidateDomain}`\n        setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain })\n      }\n      deleteCookie(testCookieName, { domain: candidateDomain })\n      getCurrentSiteCache = candidateDomain\n    }\n  }\n\n  return getCurrentSiteCache\n}\n\nfunction getCookieDefaultHostName(hostname: string, referrer: string) {\n  try {\n    return hostname || buildUrl(referrer).hostname\n  } catch {\n    // Ignore\n  }\n}\n\nexport function resetGetCurrentSite() {\n  getCurrentSiteCache = undefined\n}\n\nexport function buildCookieOptions(configuration: Configuration): CookieOptions | undefined {\n  const cookieOptions: CookieOptions = {}\n\n  cookieOptions.secure = configuration.useSecureSessionCookie || configuration.usePartitionedCrossSiteSessionCookie\n  cookieOptions.crossSite = configuration.usePartitionedCrossSiteSessionCookie\n  cookieOptions.partitioned = configuration.usePartitionedCrossSiteSessionCookie\n\n  if (configuration.trackSessionAcrossSubdomains) {\n    const currentSite = getCurrentSite()\n    if (!currentSite) {\n      return\n    }\n    cookieOptions.domain = currentSite\n  }\n\n  return cookieOptions\n}\n"],"mappings":";;;;AAiBA,SAAgB,UAAU,MAAc,OAAe,cAAsB,GAAG,SAAyB;CACvG,MAAM,uBAAO,IAAI,KAAK;CACtB,KAAK,QAAQ,KAAK,QAAQ,IAAI,WAAW;CACzC,MAAM,UAAU,WAAW,KAAK,YAAY;CAC5C,MAAM,WAAW,SAAS,YAAY,SAAS;CAC/C,MAAM,SAAS,SAAS,SAAS,WAAW,QAAQ,WAAW;CAC/D,MAAM,SAAS,SAAS,SAAS,YAAY;CAC7C,MAAM,cAAc,SAAS,cAAc,iBAAiB;CAC5D,SAAS,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,mBAAmB,WAAW,SAAS,SAAS;AAChG;;;;;AAMA,SAAgB,UAAU,MAAc;CACtC,MAAM,QAAQ,wBAAwB,SAAS,QAAQ,IAAI;CAE3D,IAAI,UAAU,IACZ;CAGF,OAAO;AACT;;;;AAKA,SAAgB,WAAW,MAAwB;CACjD,OAAO,4BAA4B,SAAS,MAAM,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC;AACpE;AAEA,IAAI;;;;;;;AAQJ,SAAgB,cAAc,MAAc;CAC1C,IAAI,CAAC,kBACH,mBAAmB,yBAAyB,SAAS,MAAM;CAE7D,OAAO,iBAAiB,IAAI,IAAI;AAClC;AAEA,SAAgB,mBAAmB;CACjC,mBAAmB,KAAA;AACrB;AAEA,SAAgB,aAAa,MAAc,SAAyB;CAClE,UAAU,MAAM,IAAI,GAAG,OAAO;AAChC;;;;;;AAOA,IAAI;AACJ,SAAgB,eACd,WAAW,aAAa,UAAU,YAAY,IAC9C,WAAW,OAAO,aAAa,cAAc,SAAS,WAAW,IAC7C;CAEpB,IAAI,OAAO,aAAa,aACtB;CAEF,IAAI,wBAAwB,KAAA,GAAW;EACrC,MAAM,kBAAkB,yBAAyB,UAAU,QAAQ;EACnE,IAAI,iBAAiB;GAGnB,MAAM,iBAAiB,uBAAuB,aAAa;GAC3D,MAAM,kBAAkB;GAExB,MAAM,eAAe,gBAAgB,MAAM,GAAG;GAC9C,IAAI,kBAAkB,aAAa,IAAI;GACvC,OAAO,aAAa,UAAU,CAAC,UAAU,cAAc,GAAG;IACxD,kBAAkB,GAAG,aAAa,IAAI,EAAG,GAAG;IAC5C,UAAU,gBAAgB,iBAAiB,YAAY,EAAE,QAAQ,gBAAgB,CAAC;GACpF;GACA,aAAa,gBAAgB,EAAE,QAAQ,gBAAgB,CAAC;GACxD,sBAAsB;EACxB;CACF;CAEA,OAAO;AACT;AAEA,SAAS,yBAAyB,UAAkB,UAAkB;CACpE,IAAI;EACF,OAAO,YAAY,SAAS,QAAQ,CAAC,CAAC;CACxC,QAAQ,CAER;AACF;AAMA,SAAgB,mBAAmB,eAAyD;CAC1F,MAAM,gBAA+B,CAAC;CAEtC,cAAc,SAAS,cAAc,0BAA0B,cAAc;CAC7E,cAAc,YAAY,cAAc;CACxC,cAAc,cAAc,cAAc;CAE1C,IAAI,cAAc,8BAA8B;EAC9C,MAAM,cAAc,eAAe;EACnC,IAAI,CAAC,aACH;EAEF,cAAc,SAAS;CACzB;CAEA,OAAO;AACT"}

package/esm/browser/cookieAccess.mjs

@@ -0,0 +1,124 @@
+import { Observable } from "../tools/observable.mjs";
+import { generateUUID } from "../tools/utils/stringUtils.mjs";
+import { display } from "../tools/display.mjs";
+import { deleteCookie, getCookies, setCookie } from "./cookie.mjs";
+import { mockable } from "../tools/mockable.mjs";
+import { clearInterval, setInterval } from "../tools/timer.mjs";
+import { addEventListener, isEventSupported } from "./addEventListener.mjs";
+import { addTelemetryDebug } from "../domain/telemetry/telemetry.mjs";
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+import { ONE_MINUTE, ONE_SECOND, dateNow } from "@kubesense/kubesense-js-core/time";
+//#region src/browser/cookieAccess.ts
+const TEST_COOKIE_NAME_PREFIX = "kubesense_cookie_test_";
+async function areCookiesAuthorized(createAccess, cookieOptions) {
+	const testCookieName = `${TEST_COOKIE_NAME_PREFIX}${generateUUID()}`;
+	const testCookieValue = "test";
+	const access = createAccess(testCookieName, cookieOptions);
+	try {
+		await access.getAllAndSet(() => ({
+			value: testCookieValue,
+			expireDelay: ONE_MINUTE
+		}));
+		return (await access.getAll()).includes(testCookieValue);
+	} catch (error) {
+		display.error(error);
+		return false;
+	} finally {
+		try {
+			await access.delete();
+		} catch {}
+	}
+}
+function createCookieStoreAccess(cookieName, cookieOptions) {
+	const cookieStore = mockable(globalObject.cookieStore);
+	const observable = new Observable(() => {
+		return addEventListener(cookieStore, "change", (event) => {
+			if (event.changed.some((event) => event.name === cookieName) || event.deleted.some((event) => event.name === cookieName)) observable.notify();
+		}).stop;
+	});
+	return {
+		async getAll() {
+			return (await cookieStore.getAll(cookieName)).map((item) => item.value);
+		},
+		delete() {
+			return cookieStore.delete({
+				name: cookieName,
+				domain: cookieOptions.domain,
+				path: "/",
+				partitioned: cookieOptions.partitioned
+			});
+		},
+		async getAllAndSet(cb) {
+			const items = await cookieStore.getAll(cookieName);
+			const { value, expireDelay } = cb(items.map((item) => item.value));
+			try {
+				await cookieStore.set({
+					name: cookieName,
+					value,
+					expires: dateNow() + expireDelay,
+					path: "/",
+					sameSite: cookieOptions.crossSite ? "none" : "strict",
+					domain: cookieOptions.domain,
+					secure: cookieOptions.secure,
+					partitioned: cookieOptions.partitioned
+				});
+			} catch (error) {
+				if (!cookieName.startsWith("kubesense_cookie_test_")) {
+					const documentCookies = getCookies(cookieName);
+					addTelemetryDebug("Failed to set cookie using Cookie Store API", {
+						"error.message": error.message,
+						newValue: value,
+						cookieOptions: { ...cookieOptions },
+						cookies: items.map((item) => ({ ...item })),
+						cookieCount: items.length,
+						documentCookies
+					});
+				}
+			}
+		},
+		observable
+	};
+}
+const WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND;
+function createDocumentCookieAccess(cookieName, cookieOptions) {
+	let previousCookieValues = getCookies(cookieName);
+	const observable = new Observable(() => {
+		const watchCookieIntervalId = setInterval(() => {
+			notifyCookieValueIfChanged(getCookies(cookieName));
+		}, WATCH_COOKIE_INTERVAL_DELAY);
+		return () => {
+			clearInterval(watchCookieIntervalId);
+		};
+	});
+	function notifyCookieValueIfChanged(cookieValues) {
+		if (String(cookieValues) !== String(previousCookieValues)) {
+			previousCookieValues = cookieValues;
+			observable.notify();
+		}
+	}
+	return {
+		getAll() {
+			return Promise.resolve(getCookies(cookieName));
+		},
+		async getAllAndSet(cb) {
+			const { value, expireDelay } = cb(getCookies(cookieName));
+			setCookie(cookieName, value, expireDelay, cookieOptions);
+			await Promise.resolve();
+			notifyCookieValueIfChanged([value]);
+		},
+		async delete() {
+			deleteCookie(cookieName, cookieOptions);
+			await Promise.resolve();
+			notifyCookieValueIfChanged([]);
+		},
+		observable
+	};
+}
+function isCookieStoreSupported() {
+	const cookieStore = mockable(globalObject.cookieStore);
+	return Boolean(cookieStore && isEventSupported(cookieStore, "change"));
+}
+//#endregion
+export { TEST_COOKIE_NAME_PREFIX, WATCH_COOKIE_INTERVAL_DELAY, areCookiesAuthorized, createCookieStoreAccess, createDocumentCookieAccess, isCookieStoreSupported };
+
+//# sourceMappingURL=cookieAccess.mjs.map

package/esm/browser/cookieAccess.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookieAccess.mjs","names":[],"sources":["../../src/browser/cookieAccess.ts"],"sourcesContent":["import { ONE_MINUTE, ONE_SECOND, dateNow } from '@kubesense/kubesense-js-core/time'\nimport { globalObject } from '@kubesense/kubesense-js-core/util'\nimport { setInterval, clearInterval } from '../tools/timer'\nimport { Observable } from '../tools/observable'\nimport { mockable } from '../tools/mockable'\nimport { display } from '../tools/display'\nimport { generateUUID } from '../tools/utils/stringUtils'\nimport { addTelemetryDebug } from '../domain/telemetry'\nimport { addEventListener, DOM_EVENT, isEventSupported } from './addEventListener'\nimport { deleteCookie, getCookies, setCookie } from './cookie'\nimport type { CookieOptions } from './cookie'\n\nexport interface CookieAccess {\n  getAll(): Promise<string[]>\n  getAllAndSet(cb: (value: string[]) => { value: string; expireDelay: number }): Promise<void>\n  delete(): Promise<void>\n  observable: Observable<void>\n}\n\nexport type CookieAccessFactory = (cookieName: string, cookieOptions: CookieOptions) => CookieAccess\n\n// Used to identify capability-probe cookies so their write failures aren't reported as telemetry:\n// failing to write them is an expected outcome (it triggers the document.cookie fallback), not a bug.\nexport const TEST_COOKIE_NAME_PREFIX = 'kubesense_cookie_test_'\n\nexport async function areCookiesAuthorized(\n  createAccess: CookieAccessFactory,\n  cookieOptions: CookieOptions\n): Promise<boolean> {\n  // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n  // the test cookie lifetime\n  const testCookieName = `${TEST_COOKIE_NAME_PREFIX}${generateUUID()}`\n  const testCookieValue = 'test'\n  const access = createAccess(testCookieName, cookieOptions)\n  try {\n    await access.getAllAndSet(() => ({ value: testCookieValue, expireDelay: ONE_MINUTE }))\n    const values = await access.getAll()\n    return values.includes(testCookieValue)\n  } catch (error) {\n    display.error(error)\n    return false\n  } finally {\n    try {\n      await access.delete()\n    } catch {\n      // Best-effort cleanup\n    }\n  }\n}\n\nexport function createCookieStoreAccess(cookieName: string, cookieOptions: CookieOptions): CookieAccess {\n  const cookieStore = mockable(globalObject.cookieStore)!\n  const observable = new Observable<void>(() => {\n    const listener = addEventListener(cookieStore, DOM_EVENT.CHANGE, (event) => {\n      // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.\n      // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226\n      const changeEvent =\n        event.changed.some((event) => event.name === cookieName) ||\n        event.deleted.some((event) => event.name === cookieName)\n      if (changeEvent) {\n        observable.notify()\n      }\n    })\n    return listener.stop\n  })\n\n  return {\n    async getAll() {\n      const items = await cookieStore.getAll(cookieName)\n      return items.map((item) => item.value)\n    },\n\n    delete() {\n      return cookieStore.delete({\n        name: cookieName,\n        domain: cookieOptions.domain,\n        path: '/',\n        partitioned: cookieOptions.partitioned,\n      })\n    },\n\n    async getAllAndSet(cb: (value: string[]) => { value: string; expireDelay: number }) {\n      const items = await cookieStore.getAll(cookieName)\n\n      const currentValues = items.map((item) => item.value)\n      const { value, expireDelay } = cb(currentValues)\n\n      try {\n        await cookieStore.set({\n          name: cookieName,\n          value,\n          expires: dateNow() + expireDelay,\n          path: '/',\n          sameSite: cookieOptions.crossSite ? 'none' : 'strict',\n          domain: cookieOptions.domain,\n          secure: cookieOptions.secure,\n          partitioned: cookieOptions.partitioned,\n        })\n      } catch (error) {\n        if (!cookieName.startsWith(TEST_COOKIE_NAME_PREFIX)) {\n          const documentCookies = getCookies(cookieName)\n          // monitor-until: 2026-10-01\n          addTelemetryDebug('Failed to set cookie using Cookie Store API', {\n            'error.message': (error as Error).message,\n            newValue: value,\n            cookieOptions: {\n              ...cookieOptions,\n            },\n            cookies: items.map((item) => ({\n              ...item,\n            })),\n            cookieCount: items.length,\n            documentCookies,\n          })\n        }\n      }\n    },\n\n    observable,\n  }\n}\n\nexport const WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND\nexport function createDocumentCookieAccess(cookieName: string, cookieOptions: CookieOptions): CookieAccess {\n  let previousCookieValues = getCookies(cookieName)\n\n  const observable = new Observable<void>(() => {\n    const watchCookieIntervalId = setInterval(() => {\n      const cookieValues = getCookies(cookieName)\n      notifyCookieValueIfChanged(cookieValues)\n    }, WATCH_COOKIE_INTERVAL_DELAY)\n\n    return () => {\n      clearInterval(watchCookieIntervalId)\n    }\n  })\n\n  function notifyCookieValueIfChanged(cookieValues: string[]) {\n    if (String(cookieValues) !== String(previousCookieValues)) {\n      previousCookieValues = cookieValues\n      observable.notify()\n    }\n  }\n\n  return {\n    getAll() {\n      return Promise.resolve(getCookies(cookieName))\n    },\n\n    async getAllAndSet(cb: (value: string[]) => { value: string; expireDelay: number }) {\n      const currentValue = getCookies(cookieName)\n      const { value, expireDelay } = cb(currentValue)\n      setCookie(cookieName, value, expireDelay, cookieOptions)\n      await Promise.resolve()\n      notifyCookieValueIfChanged([value])\n    },\n\n    async delete() {\n      deleteCookie(cookieName, cookieOptions)\n      await Promise.resolve()\n      notifyCookieValueIfChanged([])\n    },\n\n    observable,\n  }\n}\n\n// Salesforce LWS does not support the change event of CookieStore objects. https://developer.salesforce.com/tools/lws-distortion-viewer\nexport function isCookieStoreSupported(): boolean {\n  const cookieStore = mockable(globalObject.cookieStore)\n  return Boolean(cookieStore && isEventSupported(cookieStore, DOM_EVENT.CHANGE))\n}\n"],"mappings":";;;;;;;;;;;AAuBA,MAAa,0BAA0B;AAEvC,eAAsB,qBACpB,cACA,eACkB;CAGlB,MAAM,iBAAiB,GAAG,0BAA0B,aAAa;CACjE,MAAM,kBAAkB;CACxB,MAAM,SAAS,aAAa,gBAAgB,aAAa;CACzD,IAAI;EACF,MAAM,OAAO,oBAAoB;GAAE,OAAO;GAAiB,aAAa;EAAW,EAAE;EAErF,QAAO,MADc,OAAO,OAAO,EAAA,CACrB,SAAS,eAAe;CACxC,SAAS,OAAO;EACd,QAAQ,MAAM,KAAK;EACnB,OAAO;CACT,UAAU;EACR,IAAI;GACF,MAAM,OAAO,OAAO;EACtB,QAAQ,CAER;CACF;AACF;AAEA,SAAgB,wBAAwB,YAAoB,eAA4C;CACtG,MAAM,cAAc,SAAS,aAAa,WAAW;CACrD,MAAM,aAAa,IAAI,iBAAuB;EAW5C,OAViB,iBAAiB,aAAA,WAAgC,UAAU;GAM1E,IAFE,MAAM,QAAQ,MAAM,UAAU,MAAM,SAAS,UAAU,KACvD,MAAM,QAAQ,MAAM,UAAU,MAAM,SAAS,UAAU,GAEvD,WAAW,OAAO;EAEtB,CACc,CAAC,CAAC;CAClB,CAAC;CAED,OAAO;EACL,MAAM,SAAS;GAEb,QAAO,MADa,YAAY,OAAO,UAAU,EAAA,CACpC,KAAK,SAAS,KAAK,KAAK;EACvC;EAEA,SAAS;GACP,OAAO,YAAY,OAAO;IACxB,MAAM;IACN,QAAQ,cAAc;IACtB,MAAM;IACN,aAAa,cAAc;GAC7B,CAAC;EACH;EAEA,MAAM,aAAa,IAAiE;GAClF,MAAM,QAAQ,MAAM,YAAY,OAAO,UAAU;GAGjD,MAAM,EAAE,OAAO,gBAAgB,GADT,MAAM,KAAK,SAAS,KAAK,KACD,CAAC;GAE/C,IAAI;IACF,MAAM,YAAY,IAAI;KACpB,MAAM;KACN;KACA,SAAS,QAAQ,IAAI;KACrB,MAAM;KACN,UAAU,cAAc,YAAY,SAAS;KAC7C,QAAQ,cAAc;KACtB,QAAQ,cAAc;KACtB,aAAa,cAAc;IAC7B,CAAC;GACH,SAAS,OAAO;IACd,IAAI,CAAC,WAAW,WAAA,wBAAkC,GAAG;KACnD,MAAM,kBAAkB,WAAW,UAAU;KAE7C,kBAAkB,+CAA+C;MAC/D,iBAAkB,MAAgB;MAClC,UAAU;MACV,eAAe,EACb,GAAG,cACL;MACA,SAAS,MAAM,KAAK,UAAU,EAC5B,GAAG,KACL,EAAE;MACF,aAAa,MAAM;MACnB;KACF,CAAC;IACH;GACF;EACF;EAEA;CACF;AACF;AAEA,MAAa,8BAA8B;AAC3C,SAAgB,2BAA2B,YAAoB,eAA4C;CACzG,IAAI,uBAAuB,WAAW,UAAU;CAEhD,MAAM,aAAa,IAAI,iBAAuB;EAC5C,MAAM,wBAAwB,kBAAkB;GAE9C,2BADqB,WAAW,UACM,CAAC;EACzC,GAAG,2BAA2B;EAE9B,aAAa;GACX,cAAc,qBAAqB;EACrC;CACF,CAAC;CAED,SAAS,2BAA2B,cAAwB;EAC1D,IAAI,OAAO,YAAY,MAAM,OAAO,oBAAoB,GAAG;GACzD,uBAAuB;GACvB,WAAW,OAAO;EACpB;CACF;CAEA,OAAO;EACL,SAAS;GACP,OAAO,QAAQ,QAAQ,WAAW,UAAU,CAAC;EAC/C;EAEA,MAAM,aAAa,IAAiE;GAElF,MAAM,EAAE,OAAO,gBAAgB,GADV,WAAW,UACa,CAAC;GAC9C,UAAU,YAAY,OAAO,aAAa,aAAa;GACvD,MAAM,QAAQ,QAAQ;GACtB,2BAA2B,CAAC,KAAK,CAAC;EACpC;EAEA,MAAM,SAAS;GACb,aAAa,YAAY,aAAa;GACtC,MAAM,QAAQ,QAAQ;GACtB,2BAA2B,CAAC,CAAC;EAC/B;EAEA;CACF;AACF;AAGA,SAAgB,yBAAkC;CAChD,MAAM,cAAc,SAAS,aAAa,WAAW;CACrD,OAAO,QAAQ,eAAe,iBAAiB,aAAA,QAA6B,CAAC;AAC/E"}

package/esm/browser/fetch.mjs

@@ -0,0 +1,18 @@
+import { getZoneJsOriginalValue } from "../tools/getZoneJsOriginalValue.mjs";
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+//#region src/browser/fetch.ts
+/**
+* Make a fetch request using the native implementation, bypassing Zone.js patching.
+* This prevents unnecessary Angular change detection cycles.
+*
+* @param input - The resource to fetch (URL or Request object)
+* @param init - Optional fetch options
+* @returns A Promise that resolves to the Response
+*/
+function fetch(input, init) {
+	return getZoneJsOriginalValue(globalObject, "fetch")(input, init);
+}
+//#endregion
+export { fetch };
+
+//# sourceMappingURL=fetch.mjs.map

package/esm/browser/fetch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.mjs","names":[],"sources":["../../src/browser/fetch.ts"],"sourcesContent":["import { globalObject } from '@kubesense/kubesense-js-core/util'\nimport { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'\n\n/**\n * Make a fetch request using the native implementation, bypassing Zone.js patching.\n * This prevents unnecessary Angular change detection cycles.\n *\n * @param input - The resource to fetch (URL or Request object)\n * @param init - Optional fetch options\n * @returns A Promise that resolves to the Response\n */\nexport function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {\n  return getZoneJsOriginalValue(globalObject, 'fetch')(input, init)\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,MAAM,OAA0B,MAAuC;CACrF,OAAO,uBAAuB,cAAc,OAAO,CAAC,CAAC,OAAO,IAAI;AAClE"}

package/esm/browser/fetchObservable.mjs

@@ -0,0 +1,89 @@
+import { Observable } from "../tools/observable.mjs";
+import { instrumentMethod } from "../tools/instrumentMethod.mjs";
+import { tryToClone } from "../tools/utils/responseUtils.mjs";
+import { readBytesFromStream } from "../tools/readBytesFromStream.mjs";
+import { globalObject, normalizeUrl } from "@kubesense/kubesense-js-core/util";
+import { monitorError } from "@kubesense/kubesense-js-core/monitor";
+import { clocksNow } from "@kubesense/kubesense-js-core/time";
+//#region src/browser/fetchObservable.ts
+/**
+* Action to take with the response body of a fetch request.
+* Values are ordered by priority: higher values take precedence when multiple actions are requested.
+*/
+let ResponseBodyAction = /* @__PURE__ */ function(ResponseBodyAction) {
+	ResponseBodyAction[ResponseBodyAction["IGNORE"] = 0] = "IGNORE";
+	ResponseBodyAction[ResponseBodyAction["COLLECT"] = 1] = "COLLECT";
+	return ResponseBodyAction;
+}({});
+let fetchObservable;
+const responseBodyActionGetters = [];
+function initFetchObservable({ responseBodyAction } = {}) {
+	if (responseBodyAction) responseBodyActionGetters.push(responseBodyAction);
+	if (!fetchObservable) fetchObservable = createFetchObservable();
+	return fetchObservable;
+}
+function createFetchObservable() {
+	return new Observable((observable) => {
+		if (!globalObject.fetch) return;
+		const { stop } = instrumentMethod(globalObject, "fetch", (call) => beforeSend(call, observable), { computeHandlingStack: true });
+		return stop;
+	});
+}
+function beforeSend({ parameters, onPostCall, handlingStack }, observable) {
+	const [input, init] = parameters;
+	let methodFromParams = init?.method;
+	if (methodFromParams === void 0 && input instanceof Request) methodFromParams = input.method;
+	const method = methodFromParams !== void 0 ? String(methodFromParams).toUpperCase() : "GET";
+	const url = input instanceof Request ? input.url : normalizeUrl(String(input));
+	const context = {
+		state: "start",
+		init,
+		input,
+		method,
+		startClocks: clocksNow(),
+		url,
+		handlingStack,
+		isAbortedOnStart: input instanceof Request && input.signal?.aborted || init?.signal?.aborted || false
+	};
+	observable.notify(context);
+	parameters[0] = context.input;
+	parameters[1] = context.init;
+	onPostCall((responsePromise) => {
+		afterSend(observable, responsePromise, context).catch(monitorError);
+	});
+}
+async function afterSend(observable, responsePromise, startContext) {
+	const context = startContext;
+	let response;
+	try {
+		response = await responsePromise;
+	} catch (error) {
+		observable.notify({
+			...context,
+			state: "resolve",
+			status: 0,
+			isAborted: context.init?.signal?.aborted || error instanceof DOMException && error.code === DOMException.ABORT_ERR,
+			error
+		});
+		return;
+	}
+	context.response = response;
+	context.status = response.status;
+	context.responseType = response.type;
+	context.isAborted = false;
+	if (responseBodyActionGetters.reduce((action, getter) => Math.max(action, getter(context)), 0) === 1) {
+		const clonedResponse = tryToClone(response);
+		if (clonedResponse?.body) try {
+			const bytes = await readBytesFromStream(clonedResponse.body);
+			context.responseBody = new TextDecoder().decode(bytes);
+		} catch {}
+	}
+	observable.notify({
+		...context,
+		state: "resolve"
+	});
+}
+//#endregion
+export { ResponseBodyAction, initFetchObservable };
+
+//# sourceMappingURL=fetchObservable.mjs.map

package/esm/browser/fetchObservable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchObservable.mjs","names":[],"sources":["../../src/browser/fetchObservable.ts"],"sourcesContent":["import type { ClocksState } from '@kubesense/kubesense-js-core/time'\nimport { clocksNow } from '@kubesense/kubesense-js-core/time'\nimport { normalizeUrl, globalObject } from '@kubesense/kubesense-js-core/util'\nimport type { GlobalObject } from '@kubesense/kubesense-js-core/util'\nimport { monitorError } from '@kubesense/kubesense-js-core/monitor'\nimport type { InstrumentedMethodCall } from '../tools/instrumentMethod'\nimport { instrumentMethod } from '../tools/instrumentMethod'\nimport { Observable } from '../tools/observable'\nimport { readBytesFromStream } from '../tools/readBytesFromStream'\nimport { tryToClone } from '../tools/utils/responseUtils'\n\ninterface FetchContextBase {\n  method: string\n  startClocks: ClocksState\n  input: unknown\n  init?: RequestInit\n  url: string\n  handlingStack?: string\n  isAbortedOnStart: boolean\n}\n\nexport interface FetchStartContext extends FetchContextBase {\n  state: 'start'\n}\n\nexport interface FetchResolveContext extends FetchContextBase {\n  state: 'resolve'\n  status: number\n  response?: Response\n  responseBody?: string\n  responseType?: string\n  isAborted: boolean\n  error?: Error\n}\n\nexport type FetchContext = FetchStartContext | FetchResolveContext\n\ntype ResponseBodyActionGetter = (context: FetchResolveContext) => ResponseBodyAction\n\n/**\n * Action to take with the response body of a fetch request.\n * Values are ordered by priority: higher values take precedence when multiple actions are requested.\n */\nexport const enum ResponseBodyAction {\n  IGNORE = 0,\n  COLLECT = 1,\n}\n\nlet fetchObservable: Observable<FetchContext> | undefined\nconst responseBodyActionGetters: ResponseBodyActionGetter[] = []\n\nexport function initFetchObservable({ responseBodyAction }: { responseBodyAction?: ResponseBodyActionGetter } = {}) {\n  if (responseBodyAction) {\n    responseBodyActionGetters.push(responseBodyAction)\n  }\n  if (!fetchObservable) {\n    fetchObservable = createFetchObservable()\n  }\n  return fetchObservable\n}\n\nexport function resetFetchObservable() {\n  fetchObservable = undefined\n  responseBodyActionGetters.length = 0\n}\n\nfunction createFetchObservable() {\n  return new Observable<FetchContext>((observable) => {\n    // eslint-disable-next-line local-rules/disallow-zone-js-patched-values\n    if (!globalObject.fetch) {\n      return\n    }\n\n    const { stop } = instrumentMethod(globalObject, 'fetch', (call) => beforeSend(call, observable), {\n      computeHandlingStack: true,\n    })\n\n    return stop\n  })\n}\n\nfunction beforeSend(\n  { parameters, onPostCall, handlingStack }: InstrumentedMethodCall<GlobalObject, 'fetch'>,\n  observable: Observable<FetchContext>\n) {\n  const [input, init] = parameters\n  let methodFromParams = init?.method\n\n  if (methodFromParams === undefined && input instanceof Request) {\n    methodFromParams = input.method\n  }\n\n  const method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET'\n  const url = input instanceof Request ? input.url : normalizeUrl(String(input))\n  const startClocks = clocksNow()\n\n  const context: FetchStartContext = {\n    state: 'start',\n    init,\n    input,\n    method,\n    startClocks,\n    url,\n    handlingStack,\n    isAbortedOnStart: (input instanceof Request && input.signal?.aborted) || init?.signal?.aborted || false,\n  }\n\n  observable.notify(context)\n\n  // Those properties can be changed by observable subscribers\n  parameters[0] = context.input as RequestInfo | URL\n  parameters[1] = context.init\n\n  onPostCall((responsePromise) => {\n    afterSend(observable, responsePromise, context).catch(monitorError)\n  })\n}\n\nasync function afterSend(\n  observable: Observable<FetchContext>,\n  responsePromise: Promise<Response>,\n  startContext: FetchStartContext\n) {\n  const context = startContext as unknown as FetchResolveContext\n\n  let response: Response\n\n  try {\n    response = await responsePromise\n  } catch (error) {\n    observable.notify({\n      ...context,\n      state: 'resolve',\n      status: 0,\n      isAborted:\n        context.init?.signal?.aborted || (error instanceof DOMException && error.code === DOMException.ABORT_ERR),\n      error: error as Error,\n    })\n    return\n  }\n\n  context.response = response\n  context.status = response.status\n  context.responseType = response.type\n  context.isAborted = false\n\n  const responseBodyCondition: ResponseBodyAction = responseBodyActionGetters.reduce<number>(\n    (action, getter) => Math.max(action, getter(context)),\n    ResponseBodyAction.IGNORE\n  )\n\n  if (responseBodyCondition === ResponseBodyAction.COLLECT) {\n    const clonedResponse = tryToClone(response)\n    if (clonedResponse?.body) {\n      try {\n        const bytes = await readBytesFromStream(clonedResponse.body)\n        context.responseBody = new TextDecoder().decode(bytes)\n      } catch {\n        // Ignore errors when reading the response body (e.g., stream aborted, network errors)\n        // This is not critical and should not be reported as an SDK error\n      }\n    }\n  }\n\n  observable.notify({ ...context, state: 'resolve' })\n}\n"],"mappings":";;;;;;;;;;;;AA2CA,IAAkB,qBAAX,yBAAA,oBAAA;CACL,mBAAA,mBAAA,YAAA,KAAA;CACA,mBAAA,mBAAA,aAAA,KAAA;;AACF,EAAA,CAAA,CAAA;AAEA,IAAI;AACJ,MAAM,4BAAwD,CAAC;AAE/D,SAAgB,oBAAoB,EAAE,uBAA0E,CAAC,GAAG;CAClH,IAAI,oBACF,0BAA0B,KAAK,kBAAkB;CAEnD,IAAI,CAAC,iBACH,kBAAkB,sBAAsB;CAE1C,OAAO;AACT;AAOA,SAAS,wBAAwB;CAC/B,OAAO,IAAI,YAA0B,eAAe;EAElD,IAAI,CAAC,aAAa,OAChB;EAGF,MAAM,EAAE,SAAS,iBAAiB,cAAc,UAAU,SAAS,WAAW,MAAM,UAAU,GAAG,EAC/F,sBAAsB,KACxB,CAAC;EAED,OAAO;CACT,CAAC;AACH;AAEA,SAAS,WACP,EAAE,YAAY,YAAY,iBAC1B,YACA;CACA,MAAM,CAAC,OAAO,QAAQ;CACtB,IAAI,mBAAmB,MAAM;CAE7B,IAAI,qBAAqB,KAAA,KAAa,iBAAiB,SACrD,mBAAmB,MAAM;CAG3B,MAAM,SAAS,qBAAqB,KAAA,IAAY,OAAO,gBAAgB,CAAC,CAAC,YAAY,IAAI;CACzF,MAAM,MAAM,iBAAiB,UAAU,MAAM,MAAM,aAAa,OAAO,KAAK,CAAC;CAG7E,MAAM,UAA6B;EACjC,OAAO;EACP;EACA;EACA;EACA,aAPkB,UAOR;EACV;EACA;EACA,kBAAmB,iBAAiB,WAAW,MAAM,QAAQ,WAAY,MAAM,QAAQ,WAAW;CACpG;CAEA,WAAW,OAAO,OAAO;CAGzB,WAAW,KAAK,QAAQ;CACxB,WAAW,KAAK,QAAQ;CAExB,YAAY,oBAAoB;EAC9B,UAAU,YAAY,iBAAiB,OAAO,CAAC,CAAC,MAAM,YAAY;CACpE,CAAC;AACH;AAEA,eAAe,UACb,YACA,iBACA,cACA;CACA,MAAM,UAAU;CAEhB,IAAI;CAEJ,IAAI;EACF,WAAW,MAAM;CACnB,SAAS,OAAO;EACd,WAAW,OAAO;GAChB,GAAG;GACH,OAAO;GACP,QAAQ;GACR,WACE,QAAQ,MAAM,QAAQ,WAAY,iBAAiB,gBAAgB,MAAM,SAAS,aAAa;GAC1F;EACT,CAAC;EACD;CACF;CAEA,QAAQ,WAAW;CACnB,QAAQ,SAAS,SAAS;CAC1B,QAAQ,eAAe,SAAS;CAChC,QAAQ,YAAY;CAOpB,IALkD,0BAA0B,QACzE,QAAQ,WAAW,KAAK,IAAI,QAAQ,OAAO,OAAO,CAAC,GAAA,CAI9B,MAAA,GAAkC;EACxD,MAAM,iBAAiB,WAAW,QAAQ;EAC1C,IAAI,gBAAgB,MAClB,IAAI;GACF,MAAM,QAAQ,MAAM,oBAAoB,eAAe,IAAI;GAC3D,QAAQ,eAAe,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK;EACvD,QAAQ,CAGR;CAEJ;CAEA,WAAW,OAAO;EAAE,GAAG;EAAS,OAAO;CAAU,CAAC;AACpD"}

package/esm/browser/pageMayExitObservable.mjs

@@ -0,0 +1,56 @@
+import { Observable } from "../tools/observable.mjs";
+import { addEventListener, addEventListeners } from "./addEventListener.mjs";
+import { objectValues } from "../tools/utils/polyfills.mjs";
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+//#region src/browser/pageMayExitObservable.ts
+const PageExitReason = {
+	HIDDEN: "visibility_hidden",
+	UNLOADING: "before_unload",
+	PAGEHIDE: "page_hide",
+	FROZEN: "page_frozen"
+};
+function createPageMayExitObservable() {
+	return new Observable((observable) => {
+		const window = globalObject.window;
+		if (!window) return;
+		const { stop: stopListeners } = addEventListeners(window, ["visibilitychange", "freeze"], (event) => {
+			if (event.type === "visibilitychange" && document.visibilityState === "hidden")
+ /**
+			* Only event that guarantee to fire on mobile devices when the page transitions to background state
+			* (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
+			*/
+			observable.notify({ reason: PageExitReason.HIDDEN });
+			else if (event.type === "freeze")
+ /**
+			* After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)
+			* Allow to collect events happening between hidden and frozen state.
+			*/
+			observable.notify({ reason: PageExitReason.FROZEN });
+		}, { capture: true });
+		const stopBeforeUnloadListener = addEventListener(window, "beforeunload", () => {
+			observable.notify({ reason: PageExitReason.UNLOADING });
+		}).stop;
+		/**
+		* Fires when the page is actually going away — a closed tab, a navigation,
+		* or a move into the bfcache — and unlike beforeunload it is not skipped on
+		* mobile or when the browser discards the tab. It does not fire on a plain
+		* tab switch, so it says "this page is done" in a way visibilitychange
+		* cannot.
+		*/
+		const stopPageHideListener = addEventListener(window, "pagehide", () => {
+			observable.notify({ reason: PageExitReason.PAGEHIDE });
+		}).stop;
+		return () => {
+			stopListeners();
+			stopBeforeUnloadListener();
+			stopPageHideListener();
+		};
+	});
+}
+function isPageExitReason(reason) {
+	return objectValues(PageExitReason).includes(reason);
+}
+//#endregion
+export { PageExitReason, createPageMayExitObservable, isPageExitReason };
+
+//# sourceMappingURL=pageMayExitObservable.mjs.map

package/esm/browser/pageMayExitObservable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageMayExitObservable.mjs","names":[],"sources":["../../src/browser/pageMayExitObservable.ts"],"sourcesContent":["import { globalObject } from '@kubesense/kubesense-js-core/util'\nimport { Observable } from '../tools/observable'\nimport { objectValues } from '../tools/utils/polyfills'\nimport { addEventListeners, addEventListener, DOM_EVENT } from './addEventListener'\n\nexport const PageExitReason = {\n  HIDDEN: 'visibility_hidden',\n  UNLOADING: 'before_unload',\n  PAGEHIDE: 'page_hide',\n  FROZEN: 'page_frozen',\n} as const\n\nexport type PageExitReason = (typeof PageExitReason)[keyof typeof PageExitReason]\n\nexport interface PageMayExitEvent {\n  reason: PageExitReason\n}\n\nexport function createPageMayExitObservable(): Observable<PageMayExitEvent> {\n  return new Observable<PageMayExitEvent>((observable) => {\n    const window = globalObject.window\n    if (!window) {\n      // Page exit is not observable in non-browser environments\n      return\n    }\n    const { stop: stopListeners } = addEventListeners(\n      window,\n      [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE],\n      (event) => {\n        if (event.type === DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {\n          /**\n           * Only event that guarantee to fire on mobile devices when the page transitions to background state\n           * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.\n           */\n          observable.notify({ reason: PageExitReason.HIDDEN })\n        } else if (event.type === DOM_EVENT.FREEZE) {\n          /**\n           * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)\n           * Allow to collect events happening between hidden and frozen state.\n           */\n          observable.notify({ reason: PageExitReason.FROZEN })\n        }\n      },\n      { capture: true }\n    )\n\n    const stopBeforeUnloadListener = addEventListener(window, DOM_EVENT.BEFORE_UNLOAD, () => {\n      observable.notify({ reason: PageExitReason.UNLOADING })\n    }).stop\n\n    /**\n     * Fires when the page is actually going away — a closed tab, a navigation,\n     * or a move into the bfcache — and unlike beforeunload it is not skipped on\n     * mobile or when the browser discards the tab. It does not fire on a plain\n     * tab switch, so it says \"this page is done\" in a way visibilitychange\n     * cannot.\n     */\n    const stopPageHideListener = addEventListener(window, DOM_EVENT.PAGE_HIDE, () => {\n      observable.notify({ reason: PageExitReason.PAGEHIDE })\n    }).stop\n\n    return () => {\n      stopListeners()\n      stopBeforeUnloadListener()\n      stopPageHideListener()\n    }\n  })\n}\n\nexport function isPageExitReason(reason: string): reason is PageExitReason {\n  return objectValues(PageExitReason).includes(reason as PageExitReason)\n}\n"],"mappings":";;;;;AAKA,MAAa,iBAAiB;CAC5B,QAAQ;CACR,WAAW;CACX,UAAU;CACV,QAAQ;AACV;AAQA,SAAgB,8BAA4D;CAC1E,OAAO,IAAI,YAA8B,eAAe;EACtD,MAAM,SAAS,aAAa;EAC5B,IAAI,CAAC,QAEH;EAEF,MAAM,EAAE,MAAM,kBAAkB,kBAC9B,QACA,CAAA,oBAAA,QAA8C,IAC7C,UAAU;GACT,IAAI,MAAM,SAAA,sBAAwC,SAAS,oBAAoB;;;;;GAK7E,WAAW,OAAO,EAAE,QAAQ,eAAe,OAAO,CAAC;QAC9C,IAAI,MAAM,SAAA;;;;;GAKf,WAAW,OAAO,EAAE,QAAQ,eAAe,OAAO,CAAC;EAEvD,GACA,EAAE,SAAS,KAAK,CAClB;EAEA,MAAM,2BAA2B,iBAAiB,QAAA,sBAAuC;GACvF,WAAW,OAAO,EAAE,QAAQ,eAAe,UAAU,CAAC;EACxD,CAAC,CAAC,CAAC;;;;;;;;EASH,MAAM,uBAAuB,iBAAiB,QAAA,kBAAmC;GAC/E,WAAW,OAAO,EAAE,QAAQ,eAAe,SAAS,CAAC;EACvD,CAAC,CAAC,CAAC;EAEH,aAAa;GACX,cAAc;GACd,yBAAyB;GACzB,qBAAqB;EACvB;CACF,CAAC;AACH;AAEA,SAAgB,iBAAiB,QAA0C;CACzE,OAAO,aAAa,cAAc,CAAC,CAAC,SAAS,MAAwB;AACvE"}

package/esm/browser/runOnReadyState.mjs

@@ -0,0 +1,19 @@
+import { noop } from "../tools/utils/functionUtils.mjs";
+import { addEventListener } from "./addEventListener.mjs";
+//#region src/browser/runOnReadyState.ts
+function runOnReadyState(expectedReadyState, callback) {
+	if (document.readyState === expectedReadyState || document.readyState === "complete") {
+		callback();
+		return { stop: noop };
+	}
+	return addEventListener(window, expectedReadyState === "complete" ? "load" : "DOMContentLoaded", callback, { once: true });
+}
+function asyncRunOnReadyState(expectedReadyState) {
+	return new Promise((resolve) => {
+		runOnReadyState(expectedReadyState, resolve);
+	});
+}
+//#endregion
+export { asyncRunOnReadyState, runOnReadyState };
+
+//# sourceMappingURL=runOnReadyState.mjs.map

package/esm/browser/runOnReadyState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runOnReadyState.mjs","names":[],"sources":["../../src/browser/runOnReadyState.ts"],"sourcesContent":["import { noop } from '../tools/utils/functionUtils'\nimport { DOM_EVENT, addEventListener } from './addEventListener'\n\nexport function runOnReadyState(\n  expectedReadyState: 'complete' | 'interactive',\n  callback: () => void\n): { stop: () => void } {\n  if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n    callback()\n    return { stop: noop }\n  }\n  const eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED\n  return addEventListener(window, eventName, callback, { once: true })\n}\n\nexport function asyncRunOnReadyState(expectedReadyState: 'complete' | 'interactive'): Promise<void> {\n  return new Promise((resolve) => {\n    runOnReadyState(expectedReadyState, resolve)\n  })\n}\n"],"mappings":";;;AAGA,SAAgB,gBACd,oBACA,UACsB;CACtB,IAAI,SAAS,eAAe,sBAAsB,SAAS,eAAe,YAAY;EACpF,SAAS;EACT,OAAO,EAAE,MAAM,KAAK;CACtB;CAEA,OAAO,iBAAiB,QADN,uBAAuB,aAAA,SAAA,oBACE,UAAU,EAAE,MAAM,KAAK,CAAC;AACrE;AAEA,SAAgB,qBAAqB,oBAA+D;CAClG,OAAO,IAAI,SAAS,YAAY;EAC9B,gBAAgB,oBAAoB,OAAO;CAC7C,CAAC;AACH"}

package/esm/browser/webSocketObservable.mjs

@@ -0,0 +1,92 @@
+import { Observable } from "../tools/observable.mjs";
+import { instrumentConstructor, instrumentMethod } from "../tools/instrumentMethod.mjs";
+import { addEventListener } from "./addEventListener.mjs";
+import { computeBytesCount } from "../tools/utils/byteUtils.mjs";
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+import { clocksNow } from "@kubesense/kubesense-js-core/time";
+//#region src/browser/webSocketObservable.ts
+function isGlobalWithWebSocket(global) {
+	return typeof global.WebSocket === "function";
+}
+let webSocketObservable;
+function initWebSocketObservable() {
+	if (!webSocketObservable) webSocketObservable = createWebSocketObservable();
+	return webSocketObservable;
+}
+function createWebSocketObservable() {
+	return new Observable((observable) => {
+		if (!isGlobalWithWebSocket(globalObject)) return;
+		const { stop: stopInstrumentingConstructor } = instrumentConstructor(globalObject, "WebSocket", ({ parameters, onPostCall }) => {
+			const protocols = Array.isArray(parameters[1]) ? [].concat(parameters[1]) : parameters[1];
+			const startClocks = clocksNow();
+			onPostCall((instance) => {
+				observable.notify({
+					state: "connecting",
+					instance,
+					url: instance.url,
+					protocols,
+					startClocks
+				});
+				attachInstanceListeners(instance, observable);
+			});
+		});
+		const { stop: stopInstrumentingSend } = instrumentMethod(globalObject.WebSocket.prototype, "send", ({ target: instance, parameters: [data], onPostCall }) => {
+			const size = computePayloadSize(data);
+			const bufferedAmountPreSend = instance.bufferedAmount;
+			onPostCall(() => {
+				observable.notify({
+					state: "message-out",
+					instance,
+					size,
+					bufferedAmountPreSend,
+					at: clocksNow()
+				});
+			});
+		});
+		return () => {
+			stopInstrumentingConstructor();
+			stopInstrumentingSend();
+		};
+	});
+}
+function attachInstanceListeners(instance, observable) {
+	const { stop: stopOpen } = addEventListener(instance, "open", () => {
+		observable.notify({
+			state: "open",
+			instance,
+			openClocks: clocksNow(),
+			protocol: instance.protocol || ""
+		});
+		stopOpen();
+	});
+	const { stop: stopMessage } = addEventListener(instance, "message", (event) => {
+		observable.notify({
+			state: "message-in",
+			instance,
+			size: computePayloadSize(event.data),
+			at: clocksNow()
+		});
+	});
+	const { stop: stopClose } = addEventListener(instance, "close", (event) => {
+		observable.notify({
+			state: "closed",
+			instance,
+			code: event.code,
+			reason: event.reason,
+			wasClean: event.wasClean,
+			at: clocksNow()
+		});
+		stopMessage();
+		stopClose();
+	});
+}
+function computePayloadSize(data) {
+	if (typeof data === "string") return computeBytesCount(data);
+	if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) return data.byteLength;
+	if (typeof Blob !== "undefined" && data instanceof Blob) return data.size;
+	return 0;
+}
+//#endregion
+export { initWebSocketObservable };
+
+//# sourceMappingURL=webSocketObservable.mjs.map

package/esm/browser/webSocketObservable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webSocketObservable.mjs","names":[],"sources":["../../src/browser/webSocketObservable.ts"],"sourcesContent":["import type { ClocksState } from '@kubesense/kubesense-js-core/time'\nimport { clocksNow } from '@kubesense/kubesense-js-core/time'\nimport type { GlobalObject } from '@kubesense/kubesense-js-core/util'\nimport { globalObject } from '@kubesense/kubesense-js-core/util'\nimport { instrumentConstructor, instrumentMethod } from '../tools/instrumentMethod'\nimport { Observable } from '../tools/observable'\nimport { computeBytesCount } from '../tools/utils/byteUtils'\nimport { addEventListener } from './addEventListener'\n\ntype GlobalWithWebSocket = GlobalObject & { WebSocket: typeof WebSocket }\n\nfunction isGlobalWithWebSocket(global: GlobalObject): global is GlobalWithWebSocket {\n  return typeof (global as { WebSocket?: unknown }).WebSocket === 'function'\n}\n\nexport interface WebSocketConnectingContext {\n  state: 'connecting'\n  instance: WebSocket\n  url: string\n  protocols?: string | string[]\n  startClocks: ClocksState\n}\n\nexport interface WebSocketOpenContext {\n  state: 'open'\n  instance: WebSocket\n  openClocks: ClocksState\n  protocol: string\n}\n\nexport interface WebSocketMessageInContext {\n  state: 'message-in'\n  instance: WebSocket\n  size: number\n  at: ClocksState\n}\n\nexport interface WebSocketMessageOutContext {\n  state: 'message-out'\n  instance: WebSocket\n  size: number\n  bufferedAmountPreSend: number\n  at: ClocksState\n}\n\nexport interface WebSocketClosedContext {\n  state: 'closed'\n  instance: WebSocket\n  code: number\n  reason: string\n  wasClean: boolean\n  at: ClocksState\n}\n\nexport type WebSocketContext =\n  | WebSocketConnectingContext\n  | WebSocketOpenContext\n  | WebSocketMessageInContext\n  | WebSocketMessageOutContext\n  | WebSocketClosedContext\n\nlet webSocketObservable: Observable<WebSocketContext> | undefined\n\nexport function initWebSocketObservable(): Observable<WebSocketContext> {\n  if (!webSocketObservable) {\n    webSocketObservable = createWebSocketObservable()\n  }\n\n  return webSocketObservable\n}\n\nfunction createWebSocketObservable() {\n  return new Observable<WebSocketContext>((observable) => {\n    if (!isGlobalWithWebSocket(globalObject)) {\n      return undefined\n    }\n\n    const { stop: stopInstrumentingConstructor } = instrumentConstructor(\n      globalObject,\n      'WebSocket',\n      ({ parameters, onPostCall }) => {\n        const protocols = Array.isArray(parameters[1]) ? ([] as string[]).concat(parameters[1]) : parameters[1]\n        const startClocks = clocksNow()\n\n        onPostCall((instance) => {\n          observable.notify({\n            state: 'connecting',\n            instance,\n            url: instance.url,\n            protocols,\n            startClocks,\n          })\n\n          attachInstanceListeners(instance, observable)\n        })\n      }\n    )\n\n    const { stop: stopInstrumentingSend } = instrumentMethod(\n      globalObject.WebSocket.prototype,\n      'send',\n      ({ target: instance, parameters: [data], onPostCall }) => {\n        const size = computePayloadSize(data)\n        const bufferedAmountPreSend = instance.bufferedAmount\n\n        onPostCall(() => {\n          observable.notify({\n            state: 'message-out',\n            instance,\n            size,\n            bufferedAmountPreSend,\n            at: clocksNow(),\n          })\n        })\n      }\n    )\n\n    return () => {\n      stopInstrumentingConstructor()\n      stopInstrumentingSend()\n    }\n  })\n}\n\nfunction attachInstanceListeners(instance: WebSocket, observable: Observable<WebSocketContext>) {\n  const { stop: stopOpen } = addEventListener(instance, 'open', () => {\n    observable.notify({\n      state: 'open',\n      instance,\n      openClocks: clocksNow(),\n      protocol: instance.protocol || '',\n    })\n\n    stopOpen()\n  })\n\n  const { stop: stopMessage } = addEventListener(instance, 'message', (event) => {\n    observable.notify({\n      state: 'message-in',\n      instance,\n      size: computePayloadSize(event.data),\n      at: clocksNow(),\n    })\n  })\n\n  const { stop: stopClose } = addEventListener(instance, 'close', (event) => {\n    observable.notify({\n      state: 'closed',\n      instance,\n      code: event.code,\n      reason: event.reason,\n      wasClean: event.wasClean,\n      at: clocksNow(),\n    })\n\n    stopMessage()\n    stopClose()\n  })\n}\n\nfunction computePayloadSize(data: unknown): number {\n  if (typeof data === 'string') {\n    return computeBytesCount(data)\n  }\n  if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {\n    return data.byteLength\n  }\n  if (typeof Blob !== 'undefined' && data instanceof Blob) {\n    return data.size\n  }\n  return 0\n}\n\n/**\n * Reset the WebSocket observable global state. Test-only.\n *\n * @internal\n */\nexport function resetWebSocketObservable() {\n  webSocketObservable = undefined\n}\n"],"mappings":";;;;;;;AAWA,SAAS,sBAAsB,QAAqD;CAClF,OAAO,OAAQ,OAAmC,cAAc;AAClE;AAgDA,IAAI;AAEJ,SAAgB,0BAAwD;CACtE,IAAI,CAAC,qBACH,sBAAsB,0BAA0B;CAGlD,OAAO;AACT;AAEA,SAAS,4BAA4B;CACnC,OAAO,IAAI,YAA8B,eAAe;EACtD,IAAI,CAAC,sBAAsB,YAAY,GACrC;EAGF,MAAM,EAAE,MAAM,iCAAiC,sBAC7C,cACA,cACC,EAAE,YAAY,iBAAiB;GAC9B,MAAM,YAAY,MAAM,QAAQ,WAAW,EAAE,IAAK,CAAC,CAAC,CAAc,OAAO,WAAW,EAAE,IAAI,WAAW;GACrG,MAAM,cAAc,UAAU;GAE9B,YAAY,aAAa;IACvB,WAAW,OAAO;KAChB,OAAO;KACP;KACA,KAAK,SAAS;KACd;KACA;IACF,CAAC;IAED,wBAAwB,UAAU,UAAU;GAC9C,CAAC;EACH,CACF;EAEA,MAAM,EAAE,MAAM,0BAA0B,iBACtC,aAAa,UAAU,WACvB,SACC,EAAE,QAAQ,UAAU,YAAY,CAAC,OAAO,iBAAiB;GACxD,MAAM,OAAO,mBAAmB,IAAI;GACpC,MAAM,wBAAwB,SAAS;GAEvC,iBAAiB;IACf,WAAW,OAAO;KAChB,OAAO;KACP;KACA;KACA;KACA,IAAI,UAAU;IAChB,CAAC;GACH,CAAC;EACH,CACF;EAEA,aAAa;GACX,6BAA6B;GAC7B,sBAAsB;EACxB;CACF,CAAC;AACH;AAEA,SAAS,wBAAwB,UAAqB,YAA0C;CAC9F,MAAM,EAAE,MAAM,aAAa,iBAAiB,UAAU,cAAc;EAClE,WAAW,OAAO;GAChB,OAAO;GACP;GACA,YAAY,UAAU;GACtB,UAAU,SAAS,YAAY;EACjC,CAAC;EAED,SAAS;CACX,CAAC;CAED,MAAM,EAAE,MAAM,gBAAgB,iBAAiB,UAAU,YAAY,UAAU;EAC7E,WAAW,OAAO;GAChB,OAAO;GACP;GACA,MAAM,mBAAmB,MAAM,IAAI;GACnC,IAAI,UAAU;EAChB,CAAC;CACH,CAAC;CAED,MAAM,EAAE,MAAM,cAAc,iBAAiB,UAAU,UAAU,UAAU;EACzE,WAAW,OAAO;GAChB,OAAO;GACP;GACA,MAAM,MAAM;GACZ,QAAQ,MAAM;GACd,UAAU,MAAM;GAChB,IAAI,UAAU;EAChB,CAAC;EAED,YAAY;EACZ,UAAU;CACZ,CAAC;AACH;AAEA,SAAS,mBAAmB,MAAuB;CACjD,IAAI,OAAO,SAAS,UAClB,OAAO,kBAAkB,IAAI;CAE/B,IAAI,gBAAgB,eAAe,YAAY,OAAO,IAAI,GACxD,OAAO,KAAK;CAEd,IAAI,OAAO,SAAS,eAAe,gBAAgB,MACjD,OAAO,KAAK;CAEd,OAAO;AACT"}

package/esm/browser/xhrObservable.mjs

@@ -0,0 +1,73 @@
+import { Observable } from "../tools/observable.mjs";
+import { instrumentMethod } from "../tools/instrumentMethod.mjs";
+import { addEventListener } from "./addEventListener.mjs";
+import { globalObject, normalizeUrl } from "@kubesense/kubesense-js-core/util";
+import { clocksNow, elapsed, timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/browser/xhrObservable.ts
+let xhrObservable;
+const xhrContexts = /* @__PURE__ */ new WeakMap();
+function initXhrObservable() {
+	if (!xhrObservable) xhrObservable = createXhrObservable();
+	return xhrObservable;
+}
+function createXhrObservable() {
+	if (!("XMLHttpRequest" in globalObject)) return new Observable();
+	return new Observable((observable) => {
+		const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, "open", openXhr);
+		const { stop: stopInstrumentingSend } = instrumentMethod(XMLHttpRequest.prototype, "send", (call) => {
+			sendXhr(call, observable);
+		}, { computeHandlingStack: true });
+		const { stop: stopInstrumentingAbort } = instrumentMethod(XMLHttpRequest.prototype, "abort", abortXhr);
+		return () => {
+			stopInstrumentingStart();
+			stopInstrumentingSend();
+			stopInstrumentingAbort();
+		};
+	});
+}
+function openXhr({ target: xhr, parameters: [method, url] }) {
+	xhrContexts.set(xhr, {
+		state: "open",
+		method: String(method).toUpperCase(),
+		url: normalizeUrl(String(url))
+	});
+}
+function sendXhr({ target: xhr, parameters: [body], handlingStack }, observable) {
+	const context = xhrContexts.get(xhr);
+	if (!context) return;
+	const startContext = context;
+	startContext.state = "start";
+	startContext.startClocks = clocksNow();
+	startContext.isAborted = false;
+	startContext.xhr = xhr;
+	startContext.handlingStack = handlingStack;
+	startContext.requestBody = body;
+	let hasBeenReported = false;
+	const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethod(xhr, "onreadystatechange", () => {
+		if (xhr.readyState === XMLHttpRequest.DONE) onEnd();
+	});
+	const onEnd = () => {
+		unsubscribeLoadEndListener();
+		stopInstrumentingOnReadyStateChange();
+		if (hasBeenReported) return;
+		hasBeenReported = true;
+		const completeContext = context;
+		completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());
+		completeContext.status = xhr.status;
+		if (typeof xhr.response === "string") completeContext.responseBody = xhr.response;
+		observable.notify({
+			...completeContext,
+			state: "complete"
+		});
+	};
+	const { stop: unsubscribeLoadEndListener } = addEventListener(xhr, "loadend", onEnd);
+	observable.notify(startContext);
+}
+function abortXhr({ target: xhr }) {
+	const context = xhrContexts.get(xhr);
+	if (context) context.isAborted = true;
+}
+//#endregion
+export { initXhrObservable };
+
+//# sourceMappingURL=xhrObservable.mjs.map

package/esm/browser/xhrObservable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"xhrObservable.mjs","names":[],"sources":["../../src/browser/xhrObservable.ts"],"sourcesContent":["import { elapsed, timeStampNow, clocksNow } from '@kubesense/kubesense-js-core/time'\nimport type { Duration, ClocksState } from '@kubesense/kubesense-js-core/time'\nimport { normalizeUrl, globalObject } from '@kubesense/kubesense-js-core/util'\nimport type { InstrumentedMethodCall } from '../tools/instrumentMethod'\nimport { instrumentMethod } from '../tools/instrumentMethod'\nimport { Observable } from '../tools/observable'\nimport { addEventListener } from './addEventListener'\n\nexport interface XhrOpenContext {\n  state: 'open'\n  method: string\n  url: string\n}\n\nexport interface XhrStartContext extends Omit<XhrOpenContext, 'state'> {\n  state: 'start'\n  startClocks: ClocksState\n  isAborted: boolean\n  xhr: XMLHttpRequest\n  handlingStack?: string\n  requestBody?: unknown\n}\n\nexport interface XhrCompleteContext extends Omit<XhrStartContext, 'state'> {\n  state: 'complete'\n  duration: Duration\n  status: number\n  responseBody?: string\n}\n\nexport type XhrContext = XhrOpenContext | XhrStartContext | XhrCompleteContext\n\nlet xhrObservable: Observable<XhrContext> | undefined\nconst xhrContexts = new WeakMap<XMLHttpRequest, XhrContext>()\n\nexport function initXhrObservable() {\n  if (!xhrObservable) {\n    xhrObservable = createXhrObservable()\n  }\n  return xhrObservable\n}\n\nfunction createXhrObservable() {\n  if (!('XMLHttpRequest' in globalObject)) {\n    return new Observable<XhrContext>()\n  }\n\n  return new Observable<XhrContext>((observable) => {\n    const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr)\n\n    const { stop: stopInstrumentingSend } = instrumentMethod(\n      XMLHttpRequest.prototype,\n      'send',\n      (call) => {\n        sendXhr(call, observable)\n      },\n      { computeHandlingStack: true }\n    )\n\n    const { stop: stopInstrumentingAbort } = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr)\n\n    return () => {\n      stopInstrumentingStart()\n      stopInstrumentingSend()\n      stopInstrumentingAbort()\n    }\n  })\n}\n\nfunction openXhr({ target: xhr, parameters: [method, url] }: InstrumentedMethodCall<XMLHttpRequest, 'open'>) {\n  xhrContexts.set(xhr, {\n    state: 'open',\n    method: String(method).toUpperCase(),\n    url: normalizeUrl(String(url)),\n  })\n}\n\nfunction sendXhr(\n  { target: xhr, parameters: [body], handlingStack }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,\n  observable: Observable<XhrContext>\n) {\n  const context = xhrContexts.get(xhr)\n  if (!context) {\n    return\n  }\n\n  const startContext = context as XhrStartContext\n  startContext.state = 'start'\n  startContext.startClocks = clocksNow()\n  startContext.isAborted = false\n  startContext.xhr = xhr\n  startContext.handlingStack = handlingStack\n  startContext.requestBody = body\n\n  let hasBeenReported = false\n\n  const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethod(xhr, 'onreadystatechange', () => {\n    if (xhr.readyState === XMLHttpRequest.DONE) {\n      // Try to report the XHR as soon as possible, because the XHR may be mutated by the\n      // application during a future event. For example, Angular is calling .abort() on\n      // completed requests during an onreadystatechange event, so the status becomes '0'\n      // before the request is collected.\n      onEnd()\n    }\n  })\n\n  const onEnd = () => {\n    unsubscribeLoadEndListener()\n    stopInstrumentingOnReadyStateChange()\n    if (hasBeenReported) {\n      return\n    }\n    hasBeenReported = true\n\n    const completeContext = context as XhrCompleteContext\n    completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())\n    completeContext.status = xhr.status\n    if (typeof xhr.response === 'string') {\n      completeContext.responseBody = xhr.response\n    }\n    observable.notify({ ...completeContext, state: 'complete' })\n  }\n\n  const { stop: unsubscribeLoadEndListener } = addEventListener(xhr, 'loadend', onEnd)\n\n  observable.notify(startContext)\n}\n\nfunction abortXhr({ target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'abort'>) {\n  const context = xhrContexts.get(xhr) as XhrStartContext | undefined\n  if (context) {\n    context.isAborted = true\n  }\n}\n\n/**\n * Reset the XHR observable global state. This is useful for testing to ensure clean state between tests.\n *\n * @internal\n */\nexport function resetXhrObservable() {\n  xhrObservable = undefined\n}\n"],"mappings":";;;;;;AAgCA,IAAI;AACJ,MAAM,8BAAc,IAAI,QAAoC;AAE5D,SAAgB,oBAAoB;CAClC,IAAI,CAAC,eACH,gBAAgB,oBAAoB;CAEtC,OAAO;AACT;AAEA,SAAS,sBAAsB;CAC7B,IAAI,EAAE,oBAAoB,eACxB,OAAO,IAAI,WAAuB;CAGpC,OAAO,IAAI,YAAwB,eAAe;EAChD,MAAM,EAAE,MAAM,2BAA2B,iBAAiB,eAAe,WAAW,QAAQ,OAAO;EAEnG,MAAM,EAAE,MAAM,0BAA0B,iBACtC,eAAe,WACf,SACC,SAAS;GACR,QAAQ,MAAM,UAAU;EAC1B,GACA,EAAE,sBAAsB,KAAK,CAC/B;EAEA,MAAM,EAAE,MAAM,2BAA2B,iBAAiB,eAAe,WAAW,SAAS,QAAQ;EAErG,aAAa;GACX,uBAAuB;GACvB,sBAAsB;GACtB,uBAAuB;EACzB;CACF,CAAC;AACH;AAEA,SAAS,QAAQ,EAAE,QAAQ,KAAK,YAAY,CAAC,QAAQ,QAAwD;CAC3G,YAAY,IAAI,KAAK;EACnB,OAAO;EACP,QAAQ,OAAO,MAAM,CAAC,CAAC,YAAY;EACnC,KAAK,aAAa,OAAO,GAAG,CAAC;CAC/B,CAAC;AACH;AAEA,SAAS,QACP,EAAE,QAAQ,KAAK,YAAY,CAAC,OAAO,iBACnC,YACA;CACA,MAAM,UAAU,YAAY,IAAI,GAAG;CACnC,IAAI,CAAC,SACH;CAGF,MAAM,eAAe;CACrB,aAAa,QAAQ;CACrB,aAAa,cAAc,UAAU;CACrC,aAAa,YAAY;CACzB,aAAa,MAAM;CACnB,aAAa,gBAAgB;CAC7B,aAAa,cAAc;CAE3B,IAAI,kBAAkB;CAEtB,MAAM,EAAE,MAAM,wCAAwC,iBAAiB,KAAK,4BAA4B;EACtG,IAAI,IAAI,eAAe,eAAe,MAKpC,MAAM;CAEV,CAAC;CAED,MAAM,cAAc;EAClB,2BAA2B;EAC3B,oCAAoC;EACpC,IAAI,iBACF;EAEF,kBAAkB;EAElB,MAAM,kBAAkB;EACxB,gBAAgB,WAAW,QAAQ,aAAa,YAAY,WAAW,aAAa,CAAC;EACrF,gBAAgB,SAAS,IAAI;EAC7B,IAAI,OAAO,IAAI,aAAa,UAC1B,gBAAgB,eAAe,IAAI;EAErC,WAAW,OAAO;GAAE,GAAG;GAAiB,OAAO;EAAW,CAAC;CAC7D;CAEA,MAAM,EAAE,MAAM,+BAA+B,iBAAiB,KAAK,WAAW,KAAK;CAEnF,WAAW,OAAO,YAAY;AAChC;AAEA,SAAS,SAAS,EAAE,QAAQ,OAAwD;CAClF,MAAM,UAAU,YAAY,IAAI,GAAG;CACnC,IAAI,SACF,QAAQ,YAAY;AAExB"}

package/esm/domain/allowedTrackingOrigins.mjs

@@ -0,0 +1,27 @@
+import { display } from "../tools/display.mjs";
+import { matchList } from "../tools/matchOption.mjs";
+import { mockable } from "../tools/mockable.mjs";
+import { isUnsupportedExtensionEnvironment } from "./extension/extensionUtils.mjs";
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+//#region src/domain/allowedTrackingOrigins.ts
+const ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN = "Running the Browser SDK in a Web extension content script is forbidden unless the `allowedTrackingOrigins` option is provided.";
+const ERROR_NOT_ALLOWED_TRACKING_ORIGIN = "SDK initialized on a non-allowed domain.";
+function isAllowedTrackingOrigins(configuration, errorStack) {
+	const location = mockable(globalObject.location);
+	const windowOrigin = location ? location.origin : "";
+	const allowedTrackingOrigins = configuration.allowedTrackingOrigins;
+	if (!allowedTrackingOrigins) {
+		if (isUnsupportedExtensionEnvironment(windowOrigin, errorStack)) {
+			display.error(ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN);
+			return false;
+		}
+		return true;
+	}
+	const isAllowed = matchList(allowedTrackingOrigins, windowOrigin);
+	if (!isAllowed) display.error(ERROR_NOT_ALLOWED_TRACKING_ORIGIN);
+	return isAllowed;
+}
+//#endregion
+export { ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN, ERROR_NOT_ALLOWED_TRACKING_ORIGIN, isAllowedTrackingOrigins };
+
+//# sourceMappingURL=allowedTrackingOrigins.mjs.map

package/esm/domain/allowedTrackingOrigins.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowedTrackingOrigins.mjs","names":[],"sources":["../../src/domain/allowedTrackingOrigins.ts"],"sourcesContent":["import { globalObject } from '@kubesense/kubesense-js-core/util'\nimport { display } from '../tools/display'\nimport { matchList } from '../tools/matchOption'\nimport { mockable } from '../tools/mockable'\nimport type { Configuration } from './configuration'\nimport { isUnsupportedExtensionEnvironment } from './extension/extensionUtils'\n\nexport const ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN =\n  'Running the Browser SDK in a Web extension content script is forbidden unless the `allowedTrackingOrigins` option is provided.'\nexport const ERROR_NOT_ALLOWED_TRACKING_ORIGIN = 'SDK initialized on a non-allowed domain.'\n\nexport function isAllowedTrackingOrigins(configuration: Configuration, errorStack: string): boolean {\n  const location = mockable(globalObject.location)\n  const windowOrigin = location ? location.origin : ''\n  const allowedTrackingOrigins = configuration.allowedTrackingOrigins\n  if (!allowedTrackingOrigins) {\n    if (isUnsupportedExtensionEnvironment(windowOrigin, errorStack)) {\n      display.error(ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN)\n\n      return false\n    }\n    return true\n  }\n\n  const isAllowed = matchList(allowedTrackingOrigins, windowOrigin)\n  if (!isAllowed) {\n    display.error(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)\n  }\n  return isAllowed\n}\n"],"mappings":";;;;;;AAOA,MAAa,8CACX;AACF,MAAa,oCAAoC;AAEjD,SAAgB,yBAAyB,eAA8B,YAA6B;CAClG,MAAM,WAAW,SAAS,aAAa,QAAQ;CAC/C,MAAM,eAAe,WAAW,SAAS,SAAS;CAClD,MAAM,yBAAyB,cAAc;CAC7C,IAAI,CAAC,wBAAwB;EAC3B,IAAI,kCAAkC,cAAc,UAAU,GAAG;GAC/D,QAAQ,MAAM,2CAA2C;GAEzD,OAAO;EACT;EACA,OAAO;CACT;CAEA,MAAM,YAAY,UAAU,wBAAwB,YAAY;CAChE,IAAI,CAAC,WACH,QAAQ,MAAM,iCAAiC;CAEjD,OAAO;AACT"}