@openobserve/browser-core 0.3.4 → 0.4.0-beta.2

package/esm/browser/cookieAccess.mjs

@@ -0,0 +1,111 @@
+import { display } from "../tools/display.mjs";
+import { generateUUID } from "../tools/utils/stringUtils.mjs";
+import { globalObject } from "../tools/globalObject.mjs";
+import { getCookies, setCookie } from "./cookie.mjs";
+import { Observable } from "../tools/observable.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 { ONE_MINUTE, ONE_SECOND, dateNow } from "@openobserve/js-core/time";
+//#region src/browser/cookieAccess.ts
+async function areCookiesAuthorized(createAccess, cookieOptions) {
+	const testCookieName = `oo_cookie_test_${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.getAllAndSet(() => ({
+				value: "",
+				expireDelay: 0
+			}));
+		} 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);
+		},
+		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) {
+				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]);
+		},
+		observable
+	};
+}
+function isCookieStoreSupported() {
+	const cookieStore = mockable(globalObject.cookieStore);
+	return Boolean(cookieStore && isEventSupported(cookieStore, "change"));
+}
+//#endregion
+export { 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 '@openobserve/js-core/time'\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 { globalObject } from '../tools/globalObject'\nimport { addEventListener, DOM_EVENT, isEventSupported } from './addEventListener'\nimport { 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  observable: Observable<void>\n}\n\nexport type CookieAccessFactory = (cookieName: string, cookieOptions: CookieOptions) => CookieAccess\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 = `oo_cookie_test_${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.getAllAndSet(() => ({ value: '', expireDelay: 0 }))\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    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        const documentCookies = getCookies(cookieName)\n        // monitor-until: 2026-07-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    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    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":";;;;;;;;;;;AAoBA,eAAsB,qBACpB,cACA,eACkB;CAGlB,MAAM,iBAAiB,kBAAkB,aAAa;CACtD,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,oBAAoB;IAAE,OAAO;IAAI,aAAa;GAAE,EAAE;EACjE,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,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,MAAM,kBAAkB,WAAW,UAAU;IAE7C,kBAAkB,+CAA+C;KAC/D,iBAAkB,MAAgB;KAClC,UAAU;KACV,eAAe,EACb,GAAG,cACL;KACA,SAAS,MAAM,KAAK,UAAU,EAC5B,GAAG,KACL,EAAE;KACF,aAAa,MAAM;KACnB;IACF,CAAC;GACH;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;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 { globalObject } from "../tools/globalObject.mjs";
+import { getZoneJsOriginalValue } from "../tools/getZoneJsOriginalValue.mjs";
+//#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 { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'\nimport { globalObject } from '../tools/globalObject'\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,90 @@
+import { globalObject } from "../tools/globalObject.mjs";
+import { normalizeUrl } from "../tools/utils/urlPolyfill.mjs";
+import { monitorError } from "../tools/monitor.mjs";
+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 { clocksNow } from "@openobserve/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 '@openobserve/js-core/time'\nimport { clocksNow } from '@openobserve/js-core/time'\nimport type { InstrumentedMethodCall } from '../tools/instrumentMethod'\nimport { instrumentMethod } from '../tools/instrumentMethod'\nimport { monitorError } from '../tools/monitor'\nimport { Observable } from '../tools/observable'\nimport { normalizeUrl } from '../tools/utils/urlPolyfill'\nimport type { GlobalObject } from '../tools/globalObject'\nimport { globalObject } from '../tools/globalObject'\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":";;;;;;;;;;;;;AA4CA,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,44 @@
+import { isWorkerEnvironment } from "../tools/globalObject.mjs";
+import { Observable } from "../tools/observable.mjs";
+import { addEventListener, addEventListeners } from "./addEventListener.mjs";
+import { objectValues } from "../tools/utils/polyfills.mjs";
+//#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) => {
+		if (isWorkerEnvironment) 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;
+		return () => {
+			stopListeners();
+			stopBeforeUnloadListener();
+		};
+	});
+}
+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 { Observable } from '../tools/observable'\nimport { objectValues } from '../tools/utils/polyfills'\nimport { isWorkerEnvironment } from '../tools/globalObject'\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    if (isWorkerEnvironment) {\n      // Page exit is not observable in worker environments (no window/document events)\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    return () => {\n      stopListeners()\n      stopBeforeUnloadListener()\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,IAAI,qBAEF;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;EAEH,aAAa;GACX,cAAc;GACd,yBAAyB;EAC3B;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/xhrObservable.mjs

@@ -0,0 +1,74 @@
+import { globalObject } from "../tools/globalObject.mjs";
+import { normalizeUrl } from "../tools/utils/urlPolyfill.mjs";
+import { Observable } from "../tools/observable.mjs";
+import { instrumentMethod } from "../tools/instrumentMethod.mjs";
+import { addEventListener } from "./addEventListener.mjs";
+import { clocksNow, elapsed, timeStampNow } from "@openobserve/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 '@openobserve/js-core/time'\nimport type { Duration, ClocksState } from '@openobserve/js-core/time'\nimport type { InstrumentedMethodCall } from '../tools/instrumentMethod'\nimport { instrumentMethod } from '../tools/instrumentMethod'\nimport { Observable } from '../tools/observable'\nimport { normalizeUrl } from '../tools/utils/urlPolyfill'\nimport { globalObject } from '../tools/globalObject'\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":";;;;;;;AAiCA,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 { globalObject } from "../tools/globalObject.mjs";
+import { matchList } from "../tools/matchOption.mjs";
+import { mockable } from "../tools/mockable.mjs";
+import { isUnsupportedExtensionEnvironment } from "./extension/extensionUtils.mjs";
+//#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 { 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 { display } from '../tools/display'\nimport { globalObject } from '../tools/globalObject'\nimport { matchList } from '../tools/matchOption'\nimport { mockable } from '../tools/mockable'\nimport type { InitConfiguration } 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: InitConfiguration, 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,eAAkC,YAA6B;CACtG,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"}

package/esm/domain/bufferedData.mjs

@@ -0,0 +1,43 @@
+import { BufferedObservable } from "../tools/observable.mjs";
+import { mockable } from "../tools/mockable.mjs";
+import { trackRuntimeError } from "./error/trackRuntimeError.mjs";
+import { addTelemetryDebug } from "./telemetry/telemetry.mjs";
+import { initXhrObservable } from "../browser/xhrObservable.mjs";
+import { initFetchObservable } from "../browser/fetchObservable.mjs";
+import { initConsoleObservable } from "./console/consoleObservable.mjs";
+import { ConsoleApiName } from "@openobserve/js-core/util";
+//#region src/domain/bufferedData.ts
+const BUFFER_LIMIT = 500;
+let BufferedDataType = /* @__PURE__ */ function(BufferedDataType) {
+	BufferedDataType[BufferedDataType["RUNTIME_ERROR"] = 0] = "RUNTIME_ERROR";
+	BufferedDataType[BufferedDataType["FETCH"] = 1] = "FETCH";
+	BufferedDataType[BufferedDataType["XHR"] = 2] = "XHR";
+	BufferedDataType[BufferedDataType["CONSOLE"] = 3] = "CONSOLE";
+	return BufferedDataType;
+}({});
+function startBufferingData() {
+	const observable = new BufferedObservable(BUFFER_LIMIT, (count) => {
+		addTelemetryDebug("Early data collection dropped data on unbuffer", { count });
+	});
+	const subscriptions = [];
+	function subscribe(type, source) {
+		subscriptions.push(source.subscribe((data) => {
+			observable.notify({
+				type,
+				data
+			});
+		}));
+	}
+	subscribe(0, mockable(trackRuntimeError)());
+	subscribe(1, initFetchObservable());
+	subscribe(2, initXhrObservable());
+	subscribe(3, initConsoleObservable(Object.values(ConsoleApiName)));
+	return {
+		observable,
+		stop: () => subscriptions.forEach((subscription) => subscription.unsubscribe())
+	};
+}
+//#endregion
+export { BufferedDataType, startBufferingData };
+
+//# sourceMappingURL=bufferedData.mjs.map

package/esm/domain/bufferedData.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferedData.mjs","names":[],"sources":["../../src/domain/bufferedData.ts"],"sourcesContent":["import { ConsoleApiName } from '@openobserve/js-core/util'\nimport type { Observable, Subscription } from '../tools/observable'\nimport { BufferedObservable } from '../tools/observable'\nimport { mockable } from '../tools/mockable'\nimport type { FetchContext } from '../browser/fetchObservable'\nimport { initFetchObservable } from '../browser/fetchObservable'\nimport type { XhrContext } from '../browser/xhrObservable'\nimport { initXhrObservable } from '../browser/xhrObservable'\nimport { addTelemetryDebug } from './telemetry'\nimport type { RawError } from './error/error.types'\nimport { trackRuntimeError } from './error/trackRuntimeError'\nimport type { ConsoleLog } from './console/consoleObservable'\nimport { initConsoleObservable } from './console/consoleObservable'\n\nconst BUFFER_LIMIT = 500\n\nexport const enum BufferedDataType {\n  RUNTIME_ERROR,\n  FETCH,\n  XHR,\n  CONSOLE,\n}\n\nexport type BufferedData =\n  | { type: BufferedDataType.RUNTIME_ERROR; data: RawError }\n  | { type: BufferedDataType.FETCH; data: FetchContext }\n  | { type: BufferedDataType.XHR; data: XhrContext }\n  | { type: BufferedDataType.CONSOLE; data: ConsoleLog }\n\nexport function startBufferingData() {\n  const observable = new BufferedObservable<BufferedData>(BUFFER_LIMIT, (count) => {\n    // monitor-until: 2026-10-14\n    addTelemetryDebug('Early data collection dropped data on unbuffer', {\n      count,\n    })\n  })\n  const subscriptions: Subscription[] = []\n\n  function subscribe<T extends BufferedDataType>(\n    type: T,\n    source: Observable<Extract<BufferedData, { type: T }>['data']>\n  ) {\n    subscriptions.push(\n      source.subscribe((data) => {\n        observable.notify({ type, data } as BufferedData)\n      })\n    )\n  }\n\n  subscribe(BufferedDataType.RUNTIME_ERROR, mockable(trackRuntimeError)())\n  subscribe(BufferedDataType.FETCH, initFetchObservable())\n  subscribe(BufferedDataType.XHR, initXhrObservable())\n  subscribe(BufferedDataType.CONSOLE, initConsoleObservable(Object.values(ConsoleApiName)))\n\n  return {\n    observable,\n    stop: () => subscriptions.forEach((subscription) => subscription.unsubscribe()),\n  }\n}\n"],"mappings":";;;;;;;;;AAcA,MAAM,eAAe;AAErB,IAAkB,mBAAX,yBAAA,kBAAA;CACL,iBAAA,iBAAA,mBAAA,KAAA;CACA,iBAAA,iBAAA,WAAA,KAAA;CACA,iBAAA,iBAAA,SAAA,KAAA;CACA,iBAAA,iBAAA,aAAA,KAAA;;AACF,EAAA,CAAA,CAAA;AAQA,SAAgB,qBAAqB;CACnC,MAAM,aAAa,IAAI,mBAAiC,eAAe,UAAU;EAE/E,kBAAkB,kDAAkD,EAClE,MACF,CAAC;CACH,CAAC;CACD,MAAM,gBAAgC,CAAC;CAEvC,SAAS,UACP,MACA,QACA;EACA,cAAc,KACZ,OAAO,WAAW,SAAS;GACzB,WAAW,OAAO;IAAE;IAAM;GAAK,CAAiB;EAClD,CAAC,CACH;CACF;CAEA,UAAA,GAA0C,SAAS,iBAAiB,CAAC,CAAC,CAAC;CACvE,UAAA,GAAkC,oBAAoB,CAAC;CACvD,UAAA,GAAgC,kBAAkB,CAAC;CACnD,UAAA,GAAoC,sBAAsB,OAAO,OAAO,cAAc,CAAC,CAAC;CAExF,OAAO;EACL;EACA,YAAY,cAAc,SAAS,iBAAiB,aAAa,YAAY,CAAC;CAChF;AACF"}