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

package/esm/tools/experimentalFeatures.mjs

@@ -0,0 +1,35 @@
+import { objectHasValue } from "./utils/objectUtils.mjs";
+//#region src/tools/experimentalFeatures.ts
+/**
+* LIMITATION:
+* For NPM setup, this feature flag singleton is shared between RUM and Logs product.
+* This means that an experimental flag set on the RUM product will be set on the Logs product.
+* So keep in mind that in certain configurations, your experimental feature flag may affect other products.
+*
+* FORMAT:
+* All feature flags should be snake_cased
+*/
+let ExperimentalFeature = /* @__PURE__ */ function(ExperimentalFeature) {
+	ExperimentalFeature["TRACK_INTAKE_REQUESTS"] = "track_intake_requests";
+	ExperimentalFeature["PARTIAL_VIEW_UPDATES"] = "partial_view_updates";
+	return ExperimentalFeature;
+}({});
+const enabledExperimentalFeatures = /* @__PURE__ */ new Set();
+function initFeatureFlags(enableExperimentalFeatures) {
+	if (Array.isArray(enableExperimentalFeatures)) addExperimentalFeatures(enableExperimentalFeatures.filter((flag) => objectHasValue(ExperimentalFeature, flag)));
+}
+function addExperimentalFeatures(enabledFeatures) {
+	enabledFeatures.forEach((flag) => {
+		enabledExperimentalFeatures.add(flag);
+	});
+}
+function isExperimentalFeatureEnabled(featureName) {
+	return enabledExperimentalFeatures.has(featureName);
+}
+function getExperimentalFeatures() {
+	return enabledExperimentalFeatures;
+}
+//#endregion
+export { ExperimentalFeature, addExperimentalFeatures, getExperimentalFeatures, initFeatureFlags, isExperimentalFeatureEnabled };
+
+//# sourceMappingURL=experimentalFeatures.mjs.map

package/esm/tools/experimentalFeatures.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"experimentalFeatures.mjs","names":[],"sources":["../../src/tools/experimentalFeatures.ts"],"sourcesContent":["/**\n * LIMITATION:\n * For NPM setup, this feature flag singleton is shared between RUM and Logs product.\n * This means that an experimental flag set on the RUM product will be set on the Logs product.\n * So keep in mind that in certain configurations, your experimental feature flag may affect other products.\n *\n * FORMAT:\n * All feature flags should be snake_cased\n */\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected feature flag\n\nimport { objectHasValue } from './utils/objectUtils'\n\n// eslint-disable-next-line no-restricted-syntax\nexport enum ExperimentalFeature {\n  TRACK_INTAKE_REQUESTS = 'track_intake_requests',\n  PARTIAL_VIEW_UPDATES = 'partial_view_updates',\n}\n\nconst enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()\n\nexport function initFeatureFlags(enableExperimentalFeatures: string[] | undefined) {\n  if (Array.isArray(enableExperimentalFeatures)) {\n    addExperimentalFeatures(\n      enableExperimentalFeatures.filter((flag): flag is ExperimentalFeature =>\n        objectHasValue(ExperimentalFeature, flag)\n      )\n    )\n  }\n}\n\nexport function addExperimentalFeatures(enabledFeatures: ExperimentalFeature[]): void {\n  enabledFeatures.forEach((flag) => {\n    enabledExperimentalFeatures.add(flag)\n  })\n}\n\nexport function isExperimentalFeatureEnabled(featureName: ExperimentalFeature): boolean {\n  return enabledExperimentalFeatures.has(featureName)\n}\n\nexport function resetExperimentalFeatures(): void {\n  enabledExperimentalFeatures.clear()\n}\n\nexport function getExperimentalFeatures(): Set<ExperimentalFeature> {\n  return enabledExperimentalFeatures\n}\n"],"mappings":";;;;;;;;;;;AAeA,IAAY,sBAAL,yBAAA,qBAAA;CACL,oBAAA,2BAAA;CACA,oBAAA,0BAAA;;AACF,EAAA,CAAA,CAAA;AAEA,MAAM,8CAAwD,IAAI,IAAI;AAEtE,SAAgB,iBAAiB,4BAAkD;CACjF,IAAI,MAAM,QAAQ,0BAA0B,GAC1C,wBACE,2BAA2B,QAAQ,SACjC,eAAe,qBAAqB,IAAI,CAC1C,CACF;AAEJ;AAEA,SAAgB,wBAAwB,iBAA8C;CACpF,gBAAgB,SAAS,SAAS;EAChC,4BAA4B,IAAI,IAAI;CACtC,CAAC;AACH;AAEA,SAAgB,6BAA6B,aAA2C;CACtF,OAAO,4BAA4B,IAAI,WAAW;AACpD;AAMA,SAAgB,0BAAoD;CAClE,OAAO;AACT"}

package/esm/tools/getZoneJsOriginalValue.mjs

@@ -0,0 +1,26 @@
+import { globalObject } from "./globalObject.mjs";
+//#region src/tools/getZoneJsOriginalValue.ts
+/**
+* Gets the original value for a DOM API that was potentially patched by Zone.js.
+*
+* Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original
+* value of the patched functions/constructors/methods in a hidden property prefixed by
+* __zone_symbol__.
+*
+* In multiple occasions, we observed that Zone.js is the culprit of important issues leading to
+* browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to
+* use the original DOM API instead of the one patched by Zone.js.
+*
+* [1]: https://github.com/angular/angular/tree/main/packages/zone.js
+*/
+function getZoneJsOriginalValue(target, name) {
+	const browserWindow = globalObject;
+	let original;
+	if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === "function") original = target[browserWindow.Zone.__symbol__(name)];
+	if (!original) original = target[name];
+	return original;
+}
+//#endregion
+export { getZoneJsOriginalValue };
+
+//# sourceMappingURL=getZoneJsOriginalValue.mjs.map

package/esm/tools/getZoneJsOriginalValue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getZoneJsOriginalValue.mjs","names":[],"sources":["../../src/tools/getZoneJsOriginalValue.ts"],"sourcesContent":["import { globalObject } from './globalObject'\n\nexport interface BrowserWindowWithZoneJs {\n  Zone?: {\n    // All Zone.js versions expose the __symbol__ method, but we observed that some website have a\n    // 'Zone' global variable unrelated to Zone.js, so let's consider this method optional\n    // nonetheless.\n    __symbol__?: (name: string) => string\n  }\n}\n\n/**\n * Gets the original value for a DOM API that was potentially patched by Zone.js.\n *\n * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original\n * value of the patched functions/constructors/methods in a hidden property prefixed by\n * __zone_symbol__.\n *\n * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to\n * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to\n * use the original DOM API instead of the one patched by Zone.js.\n *\n * [1]: https://github.com/angular/angular/tree/main/packages/zone.js\n */\nexport function getZoneJsOriginalValue<Target, Name extends keyof Target & string>(\n  target: Target,\n  name: Name\n): Target[Name] {\n  const browserWindow = globalObject as BrowserWindowWithZoneJs\n  let original: Target[Name] | undefined\n  if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {\n    original = (target as any)[browserWindow.Zone.__symbol__(name)]\n  }\n  if (!original) {\n    original = target[name]\n  }\n  return original\n}\n"],"mappings":";;;;;;;;;;;;;;;AAwBA,SAAgB,uBACd,QACA,MACc;CACd,MAAM,gBAAgB;CACtB,IAAI;CACJ,IAAI,cAAc,QAAQ,OAAO,cAAc,KAAK,eAAe,YACjE,WAAY,OAAe,cAAc,KAAK,WAAW,IAAI;CAE/D,IAAI,CAAC,UACH,WAAW,OAAO;CAEpB,OAAO;AACT"}

package/esm/tools/globalObject.mjs

@@ -0,0 +1,7 @@
+//#region src/tools/globalObject.ts
+const globalObject = globalThis;
+const isWorkerEnvironment = "WorkerGlobalScope" in globalObject;
+//#endregion
+export { globalObject, isWorkerEnvironment };
+
+//# sourceMappingURL=globalObject.mjs.map

package/esm/tools/globalObject.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalObject.mjs","names":[],"sources":["../../src/tools/globalObject.ts"],"sourcesContent":["// eslint-disable-next-line no-restricted-imports\nimport type { BrowserNavigator, CookieStore, ProfilerConstructor } from '../browser/browser.types'\n\n/**\n * Reflects values available in the global object (e.g. window or self). We use our own type to\n * adjust the expectations across the codebase when the native types offered by TypeScript aren't\n * sufficient.\n *\n * For example, we can mark a property as optional when it is not available in all browsers, or add\n * new browser APIs that are not yet typed properly in the typescript lib.\n *\n * Feel free to add more properties as needed, or mark some properties as optional when they are.\n */\nexport interface GlobalObject extends Omit<\n  // eslint-disable-next-line no-restricted-syntax\n  typeof globalThis,\n  'queueMicrotask' | 'cookieStore' | 'Profiler' | 'window'\n> {\n  navigator: BrowserNavigator\n\n  // cookieStore is not available in all browsers yet\n  cookieStore?: CookieStore\n\n  // queueMicrotask is not available in all browsers yet\n  queueMicrotask?: typeof queueMicrotask\n\n  // Profiler is not available in all browsers yet\n  Profiler?: ProfilerConstructor\n\n  // window is not available in SSR environments\n  window?: Window\n}\n\n// eslint-disable-next-line no-restricted-syntax\nexport const globalObject = globalThis as GlobalObject\n\nexport const isWorkerEnvironment = 'WorkerGlobalScope' in globalObject\n"],"mappings":";AAkCA,MAAa,eAAe;AAE5B,MAAa,sBAAsB,uBAAuB"}

package/esm/tools/instrumentMethod.mjs

@@ -0,0 +1,178 @@
+import { callMonitored } from "./monitor.mjs";
+import { setTimeout } from "./timer.mjs";
+import { noop } from "./utils/functionUtils.mjs";
+import { createHandlingStack } from "./stackTrace/handlingStack.mjs";
+//#region src/tools/instrumentMethod.ts
+/**
+* Instruments a method on a object, calling the given callback before the original method is
+* invoked. The callback receives an object with information about the method call.
+*
+* This function makes sure that we are "good citizens" regarding third party instrumentations: when
+* removing the instrumentation, the original method is usually restored, but if a third party
+* instrumentation was set after ours, we keep it in place and just replace our instrumentation with
+* a noop.
+*
+* Note: it is generally better to instrument methods that are "owned" by the object instead of ones
+* that are inherited from the prototype chain. Example:
+* * do:    `instrumentMethod(Array.prototype, 'push', ...)`
+* * don't: `instrumentMethod([], 'push', ...)`
+*
+* This method is also used to set event handler properties (ex: window.onerror = ...), as it has
+* the same requirements as instrumenting a method:
+* * if the event handler is already set by a third party, we need to call it and not just blindly
+* override it.
+* * if the event handler is set by a third party after us, we need to keep it in place when
+* removing ours.
+*
+* To instrument a constructor @see {@link instrumentConstructor}.
+*
+* @example
+*
+*  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {
+*    console.log('Before calling fetch on', target, 'with parameters', parameters)
+*
+*    onPostCall((result) => {
+*      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)
+*    })
+*  })
+*/
+function instrumentMethod(targetPrototype, method, onPreCall, { computeHandlingStack } = {}) {
+	let original = targetPrototype[method];
+	if (typeof original !== "function") if (method in targetPrototype && typeof method === "string" && method.startsWith("on")) original = noop;
+	else return { stop: noop };
+	let stopped = false;
+	const instrumentation = function() {
+		if (stopped) return original.apply(this, arguments);
+		const parameters = Array.from(arguments);
+		return notifyInstrumentation(onPreCall, {
+			target: this,
+			parameters,
+			handlingStack: computeHandlingStack ? createHandlingStack("instrumented method") : void 0
+		}, () => original.apply(this, parameters));
+	};
+	const { stop: restoreOriginal } = replaceWithInstrumentation(targetPrototype, method, original, instrumentation);
+	return { stop: () => {
+		stopped = true;
+		restoreOriginal();
+	} };
+}
+/**
+* Instruments a constructor on an object (typically a global, e.g. `window.WebSocket`), calling the
+* given callback before the original constructor is invoked. The callback receives an object with
+* information about the constructor call, and can register an `onPostCall` callback to be notified
+* with the constructed instance.
+*
+* Like `instrumentMethod`, this is a "good citizen" regarding third party instrumentations: stopping
+* restores the original constructor unless a third party replaced it afterwards.
+*
+* The wrapper preserves the original prototype (so `instanceof` keeps working), the original
+* `new.target` (so constructors that inspect it behave as if not instrumented), the original
+* static members (e.g. `WebSocket.OPEN`), and `instance.constructor ===` so checks like
+* `new WebSocket(url).constructor === WebSocket` stay true.
+*
+* @see {@link preserveConstructorShape} for limitations on static members preservation.
+* @example
+*
+*  instrumentConstructor(window, 'WebSocket', ({ parameters, onPostCall }) => {
+*    console.log('Before constructing WebSocket with parameters', parameters)
+*
+*    onPostCall((instance) => {
+*      console.log('Constructed WebSocket instance', instance)
+*    })
+*  })
+*/
+function instrumentConstructor(container, constructor, onPreCall, { computeHandlingStack } = {}) {
+	const original = container[constructor];
+	if (typeof original !== "function") return { stop: noop };
+	let stopped = false;
+	const instrumentation = function() {
+		if (!new.target) return Reflect.apply(original, this, Array.from(arguments));
+		const newTarget = new.target === instrumentation ? original : new.target;
+		if (stopped) return Reflect.construct(original, arguments, newTarget);
+		const parameters = Array.from(arguments);
+		return notifyInstrumentation(onPreCall, {
+			parameters,
+			handlingStack: computeHandlingStack ? createHandlingStack("instrumented constructor") : void 0
+		}, () => Reflect.construct(original, parameters, newTarget));
+	};
+	const restorePrototypeConstructor = preserveConstructorShape(instrumentation, original);
+	const { stop: restoreOriginal } = replaceWithInstrumentation(container, constructor, original, instrumentation);
+	return { stop: () => {
+		stopped = true;
+		restorePrototypeConstructor();
+		restoreOriginal();
+	} };
+}
+/**
+* Replaces `targetPrototype[method]` with the provided instrumentation and
+* returns a `stop` function restoring the original (unless a third party replaced us afterwards).
+*/
+function replaceWithInstrumentation(targetPrototype, method, original, instrumentation) {
+	targetPrototype[method] = instrumentation;
+	return { stop: () => {
+		if (targetPrototype[method] === instrumentation) targetPrototype[method] = original;
+	} };
+}
+/**
+* Runs the pre-call callback (injecting the `onPostCall` registration), invokes the original
+* method/constructor, then runs the registered post-call callback with the result.
+*
+* Note: the handling stack must be computed by the caller (at the topmost position of the call
+* stack), so it is part of `baseCallInfo` rather than computed here.
+*/
+function notifyInstrumentation(onPreCall, baseCallInfo, invokeOriginal) {
+	let postCallCallback;
+	callMonitored(onPreCall, null, [{
+		...baseCallInfo,
+		onPostCall: (callback) => {
+			postCallCallback = callback;
+		}
+	}]);
+	const result = invokeOriginal();
+	if (postCallCallback) callMonitored(postCallCallback, null, [result]);
+	return result;
+}
+/**
+* Copies the original constructor prototype and other static members onto the instrumentation, so that
+* `instanceof` checks keep working and statics such as `WebSocket.OPEN` remain available while
+* instrumented.
+*
+* Returns a function that restores `prototype.constructor` to its prior descriptor; call it
+* before restoring the global property in `stop()`.
+*/
+function preserveConstructorShape(instrumentation, original) {
+	/**
+	* Limitation: Only the original's *own* static members are copied. Statics inherited through the
+	* constructor's prototype chain (e.g. `class Child extends Parent` where `Parent` defines statics)
+	* are not preserved, since the instrumentation still inherits from `Function.prototype`. This is
+	* acceptable for the globals we instrument (e.g. `WebSocket`, whose own statics are the only ones
+	* that matter), but we would need to delegate the static prototype chain to support subclassed
+	* constructors with meaningful inherited statics.
+	*/
+	for (const key of [].concat(Object.getOwnPropertyNames(original), Object.getOwnPropertySymbols(original))) Object.defineProperty(instrumentation, key, Object.getOwnPropertyDescriptor(original, key));
+	const { stop: restoreOriginalConstructor } = replaceWithInstrumentation(original.prototype, "constructor", original.prototype.constructor, instrumentation);
+	return restoreOriginalConstructor;
+}
+function instrumentSetter(targetPrototype, property, after) {
+	const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property);
+	if (!originalDescriptor?.set || !originalDescriptor.configurable) return { stop: noop };
+	const stoppedInstrumentation = noop;
+	let instrumentation = (target, value) => {
+		setTimeout(() => {
+			if (instrumentation !== stoppedInstrumentation) after(target, value);
+		}, 0);
+	};
+	const instrumentationWrapper = function(value) {
+		originalDescriptor.set.call(this, value);
+		instrumentation(this, value);
+	};
+	Object.defineProperty(targetPrototype, property, { set: instrumentationWrapper });
+	return { stop: () => {
+		if (Object.getOwnPropertyDescriptor(targetPrototype, property)?.set === instrumentationWrapper) Object.defineProperty(targetPrototype, property, originalDescriptor);
+		instrumentation = stoppedInstrumentation;
+	} };
+}
+//#endregion
+export { instrumentConstructor, instrumentMethod, instrumentSetter };
+
+//# sourceMappingURL=instrumentMethod.mjs.map

package/esm/tools/instrumentMethod.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentMethod.mjs","names":[],"sources":["../../src/tools/instrumentMethod.ts"],"sourcesContent":["import { setTimeout } from './timer'\nimport { callMonitored } from './monitor'\nimport { noop } from './utils/functionUtils'\nimport { createHandlingStack } from './stackTrace/handlingStack'\n\n/**\n * Object passed to the callback of an instrumented method call. See `instrumentMethod` for more\n * info.\n */\nexport interface InstrumentedMethodCall<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> {\n  /**\n   * The target object on which the method was called.\n   */\n  target: TARGET\n\n  /**\n   * The parameters with which the method was called.\n   *\n   * Note: if needed, parameters can be mutated by the instrumentation\n   */\n  parameters: Parameters<TARGET[METHOD]>\n\n  /**\n   * Registers a callback that will be called after the original method is called, with the method\n   * result passed as argument.\n   */\n  onPostCall: (callback: PostCallCallback<TARGET, METHOD>) => void\n\n  /**\n   * The stack trace of the method call.\n   */\n  handlingStack?: string\n}\n\ntype PostCallCallback<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> = (\n  result: ReturnType<TARGET[METHOD]>\n) => void\n\ntype ConstructorParametersOf<CONSTRUCTOR> = CONSTRUCTOR extends new (...args: infer P) => any ? P : never\ntype ConstructorInstanceOf<CONSTRUCTOR> = CONSTRUCTOR extends new (...args: any[]) => infer R ? R : never\n\ntype AnyConstructor = abstract new (...args: any[]) => any\n\n/**\n * Object passed to the callback of an instrumented constructor call. See `instrumentConstructor`\n * for more info.\n */\nexport interface InstrumentedConstructorCall<CONSTRUCTOR> {\n  /**\n   * The parameters with which the constructor was called.\n   *\n   * Note: if needed, parameters can be mutated by the instrumentation\n   */\n  parameters: ConstructorParametersOf<CONSTRUCTOR>\n\n  /**\n   * Registers a callback that will be called after the original constructor is called, with the\n   * constructed instance passed as argument.\n   */\n  onPostCall: (callback: (result: ConstructorInstanceOf<CONSTRUCTOR>) => void) => void\n\n  /**\n   * The stack trace of the constructor call.\n   */\n  handlingStack?: string\n}\n\n/**\n * Instruments a method on a object, calling the given callback before the original method is\n * invoked. The callback receives an object with information about the method call.\n *\n * This function makes sure that we are \"good citizens\" regarding third party instrumentations: when\n * removing the instrumentation, the original method is usually restored, but if a third party\n * instrumentation was set after ours, we keep it in place and just replace our instrumentation with\n * a noop.\n *\n * Note: it is generally better to instrument methods that are \"owned\" by the object instead of ones\n * that are inherited from the prototype chain. Example:\n * * do:    `instrumentMethod(Array.prototype, 'push', ...)`\n * * don't: `instrumentMethod([], 'push', ...)`\n *\n * This method is also used to set event handler properties (ex: window.onerror = ...), as it has\n * the same requirements as instrumenting a method:\n * * if the event handler is already set by a third party, we need to call it and not just blindly\n * override it.\n * * if the event handler is set by a third party after us, we need to keep it in place when\n * removing ours.\n *\n * To instrument a constructor @see {@link instrumentConstructor}.\n *\n * @example\n *\n *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {\n *    console.log('Before calling fetch on', target, 'with parameters', parameters)\n *\n *    onPostCall((result) => {\n *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)\n *    })\n *  })\n */\nexport function instrumentMethod<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET>(\n  targetPrototype: TARGET,\n  method: METHOD,\n  onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void,\n  { computeHandlingStack }: { computeHandlingStack?: boolean } = {}\n) {\n  let original = targetPrototype[method]\n\n  if (typeof original !== 'function') {\n    if (method in targetPrototype && typeof method === 'string' && method.startsWith('on')) {\n      original = noop as TARGET[METHOD]\n    } else {\n      return { stop: noop }\n    }\n  }\n\n  let stopped = false\n\n  const instrumentation = function (this: TARGET): ReturnType<TARGET[METHOD]> {\n    if (stopped) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call\n      return original.apply(this, arguments)\n    }\n\n    const parameters = Array.from(arguments) as Parameters<TARGET[METHOD]>\n\n    return notifyInstrumentation<InstrumentedMethodCall<TARGET, METHOD>, ReturnType<TARGET[METHOD]>>(\n      onPreCall,\n      {\n        target: this,\n        parameters,\n        handlingStack: computeHandlingStack ? createHandlingStack('instrumented method') : undefined,\n      },\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call -- TARGET[METHOD] is any under the index signature; value is verified as a function above\n      () => original.apply(this, parameters)\n    )\n  } as TARGET[METHOD]\n\n  const { stop: restoreOriginal } = replaceWithInstrumentation(targetPrototype, method, original, instrumentation)\n\n  return {\n    stop: () => {\n      stopped = true\n      restoreOriginal()\n    },\n  }\n}\n\n/**\n * Instruments a constructor on an object (typically a global, e.g. `window.WebSocket`), calling the\n * given callback before the original constructor is invoked. The callback receives an object with\n * information about the constructor call, and can register an `onPostCall` callback to be notified\n * with the constructed instance.\n *\n * Like `instrumentMethod`, this is a \"good citizen\" regarding third party instrumentations: stopping\n * restores the original constructor unless a third party replaced it afterwards.\n *\n * The wrapper preserves the original prototype (so `instanceof` keeps working), the original\n * `new.target` (so constructors that inspect it behave as if not instrumented), the original\n * static members (e.g. `WebSocket.OPEN`), and `instance.constructor ===` so checks like\n * `new WebSocket(url).constructor === WebSocket` stay true.\n *\n * @see {@link preserveConstructorShape} for limitations on static members preservation.\n * @example\n *\n *  instrumentConstructor(window, 'WebSocket', ({ parameters, onPostCall }) => {\n *    console.log('Before constructing WebSocket with parameters', parameters)\n *\n *    onPostCall((instance) => {\n *      console.log('Constructed WebSocket instance', instance)\n *    })\n *  })\n */\nexport function instrumentConstructor<CONTAINER extends { [key: string]: any }, CONSTRUCTOR extends keyof CONTAINER>(\n  container: CONTAINER,\n  constructor: CONSTRUCTOR,\n  onPreCall: (this: null, callInfos: InstrumentedConstructorCall<CONTAINER[CONSTRUCTOR]>) => void,\n  { computeHandlingStack }: { computeHandlingStack?: boolean } = {}\n) {\n  const original = container[constructor]\n\n  if (typeof original !== 'function') {\n    return { stop: noop }\n  }\n\n  let stopped = false\n\n  const instrumentation = function (this: unknown): ConstructorInstanceOf<CONTAINER[CONSTRUCTOR]> {\n    // Bare `[[Call]]` (no `new`): delegate through `[[Call]]` and skip `onPreCall`. Otherwise we\n    // would notify instrumentation before the original rejects or returns, unlike the native\n    // constructor (e.g. `WebSocket(url)` or `class {}()` without `new`).\n    if (!new.target) {\n      return Reflect.apply(original, this, Array.from(arguments)) as ConstructorInstanceOf<CONTAINER[CONSTRUCTOR]>\n    }\n\n    // When `new` is used on this instrumented property, `new.target` is this wrapper. Passing\n    // it through to Reflect.construct would expose the wrong new.target inside the original\n    // body. If a subclass extends the wrapper, or a third party wraps us and their class is\n    // instantiated, `new.target` is that outer constructor and must be preserved.\n    const newTarget = new.target === instrumentation ? original : new.target\n\n    if (stopped) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      return Reflect.construct(\n        original,\n        arguments as unknown as ConstructorParametersOf<CONTAINER[CONSTRUCTOR]>,\n        newTarget\n      )\n    }\n\n    const parameters = Array.from(arguments) as ConstructorParametersOf<CONTAINER[CONSTRUCTOR]>\n\n    return notifyInstrumentation<\n      InstrumentedConstructorCall<CONTAINER[CONSTRUCTOR]>,\n      ConstructorInstanceOf<CONTAINER[CONSTRUCTOR]>\n    >(\n      onPreCall,\n      {\n        parameters,\n        handlingStack: computeHandlingStack ? createHandlingStack('instrumented constructor') : undefined,\n      },\n      () =>\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        Reflect.construct(original, parameters, newTarget)\n    )\n  } as CONTAINER[CONSTRUCTOR]\n\n  const restorePrototypeConstructor = preserveConstructorShape(instrumentation, original)\n  const { stop: restoreOriginal } = replaceWithInstrumentation(container, constructor, original, instrumentation)\n\n  return {\n    stop: () => {\n      stopped = true\n      restorePrototypeConstructor()\n      restoreOriginal()\n    },\n  }\n}\n\n/**\n * Replaces `targetPrototype[method]` with the provided instrumentation and\n * returns a `stop` function restoring the original (unless a third party replaced us afterwards).\n */\nfunction replaceWithInstrumentation<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET>(\n  targetPrototype: TARGET,\n  method: METHOD,\n  original: TARGET[METHOD],\n  instrumentation: TARGET[METHOD]\n) {\n  targetPrototype[method] = instrumentation\n\n  return {\n    stop: () => {\n      // If the instrumentation has been removed by a third party, keep the last one\n      if (targetPrototype[method] === instrumentation) {\n        targetPrototype[method] = original\n      }\n    },\n  }\n}\n\n/**\n * Runs the pre-call callback (injecting the `onPostCall` registration), invokes the original\n * method/constructor, then runs the registered post-call callback with the result.\n *\n * Note: the handling stack must be computed by the caller (at the topmost position of the call\n * stack), so it is part of `baseCallInfo` rather than computed here.\n */\nfunction notifyInstrumentation<CALL_INFO extends InstrumentationCallbacks<RESULT>, RESULT>(\n  onPreCall: (this: null, callInfo: CALL_INFO) => void,\n  baseCallInfo: Omit<CALL_INFO, 'onPostCall'>,\n  invokeOriginal: () => RESULT\n): RESULT {\n  let postCallCallback: ((result: RESULT) => void) | undefined\n\n  callMonitored(onPreCall, null, [\n    {\n      ...baseCallInfo,\n      onPostCall: (callback: (result: RESULT) => void) => {\n        postCallCallback = callback\n      },\n    } as CALL_INFO,\n  ])\n\n  const result = invokeOriginal()\n\n  if (postCallCallback) {\n    callMonitored(postCallCallback, null, [result])\n  }\n\n  return result\n}\n\ninterface InstrumentationCallbacks<RESULT> {\n  onPostCall: (callback: (result: RESULT) => void) => void\n  handlingStack?: string\n}\n\n/**\n * Copies the original constructor prototype and other static members onto the instrumentation, so that\n * `instanceof` checks keep working and statics such as `WebSocket.OPEN` remain available while\n * instrumented.\n *\n * Returns a function that restores `prototype.constructor` to its prior descriptor; call it\n * before restoring the global property in `stop()`.\n */\nfunction preserveConstructorShape(instrumentation: AnyConstructor, original: AnyConstructor): () => void {\n  /**\n   * Limitation: Only the original's *own* static members are copied. Statics inherited through the\n   * constructor's prototype chain (e.g. `class Child extends Parent` where `Parent` defines statics)\n   * are not preserved, since the instrumentation still inherits from `Function.prototype`. This is\n   * acceptable for the globals we instrument (e.g. `WebSocket`, whose own statics are the only ones\n   * that matter), but we would need to delegate the static prototype chain to support subclassed\n   * constructors with meaningful inherited statics.\n   */\n  for (const key of ([] as PropertyKey[]).concat(\n    Object.getOwnPropertyNames(original),\n    Object.getOwnPropertySymbols(original)\n  )) {\n    const descriptor = Object.getOwnPropertyDescriptor(original, key) as PropertyDescriptor\n    Object.defineProperty(instrumentation, key, descriptor)\n  }\n\n  /*\n   * Limitation: Repointing `constructor` on this shared prototype affects every instance whose\n   * `[[Prototype]]` is this object, including instances created before instrumentation, because\n   * `constructor` is inherited rather than snapshotted per instance. Code that held `original` (or\n   * whatever was in `prototype.constructor` before) as the canonical constructor and expects reference\n   * equality to that value for the lifetime of the page can observe a behavior change while RUM is\n   * active; restoring on `stop()` fixes this. In practice the SDK initializes as early as possible,\n   * which narrows the window where pre-instrument instances exist.\n   */\n  const { stop: restoreOriginalConstructor } = replaceWithInstrumentation(\n    original.prototype,\n    'constructor',\n    original.prototype.constructor,\n    instrumentation\n  )\n\n  return restoreOriginalConstructor\n}\n\nexport function instrumentSetter<TARGET extends { [key: string]: any }, PROPERTY extends keyof TARGET>(\n  targetPrototype: TARGET,\n  property: PROPERTY,\n  after: (target: TARGET, value: TARGET[PROPERTY]) => void\n) {\n  const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property)\n  if (!originalDescriptor?.set || !originalDescriptor.configurable) {\n    return { stop: noop }\n  }\n\n  const stoppedInstrumentation = noop\n  let instrumentation = (target: TARGET, value: TARGET[PROPERTY]) => {\n    // put hooked setter into event loop to avoid of set latency\n    setTimeout(() => {\n      if (instrumentation !== stoppedInstrumentation) {\n        after(target, value)\n      }\n    }, 0)\n  }\n\n  const instrumentationWrapper = function (this: TARGET, value: TARGET[PROPERTY]) {\n    originalDescriptor.set!.call(this, value)\n    instrumentation(this, value)\n  }\n\n  Object.defineProperty(targetPrototype, property, {\n    set: instrumentationWrapper,\n  })\n\n  return {\n    stop: () => {\n      if (Object.getOwnPropertyDescriptor(targetPrototype, property)?.set === instrumentationWrapper) {\n        Object.defineProperty(targetPrototype, property, originalDescriptor)\n      }\n      instrumentation = stoppedInstrumentation\n    },\n  }\n}\n"],"mappings":"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"}

package/esm/tools/matchOption.mjs

@@ -0,0 +1,30 @@
+import { display } from "./display.mjs";
+import { getType } from "@openobserve/js-core/util";
+//#region src/tools/matchOption.ts
+function isMatchOption(item) {
+	const itemType = getType(item);
+	return itemType === "string" || itemType === "function" || item instanceof RegExp;
+}
+/**
+* Returns true if value can be matched by at least one of the provided MatchOptions.
+* When comparing strings, setting useStartsWith to true will compare the value with the start of
+* the option, instead of requiring an exact match.
+*/
+function matchList(list, value, useStartsWith = false) {
+	return list.some((item) => {
+		try {
+			if (typeof item === "function") return item(value);
+			else if (item instanceof RegExp) {
+				item.lastIndex = 0;
+				return item.test(value);
+			} else if (typeof item === "string") return useStartsWith ? value.startsWith(item) : item === value;
+		} catch (e) {
+			display.error(e);
+		}
+		return false;
+	});
+}
+//#endregion
+export { isMatchOption, matchList };
+
+//# sourceMappingURL=matchOption.mjs.map

package/esm/tools/matchOption.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchOption.mjs","names":[],"sources":["../../src/tools/matchOption.ts"],"sourcesContent":["import { getType } from '@openobserve/js-core/util'\nimport { display } from './display'\n\nexport type MatchOption = string | RegExp | ((value: string) => boolean)\n\nexport function isMatchOption(item: unknown): item is MatchOption {\n  const itemType = getType(item)\n  return itemType === 'string' || itemType === 'function' || item instanceof RegExp\n}\n\n/**\n * Returns true if value can be matched by at least one of the provided MatchOptions.\n * When comparing strings, setting useStartsWith to true will compare the value with the start of\n * the option, instead of requiring an exact match.\n */\nexport function matchList(list: MatchOption[], value: string, useStartsWith = false): boolean {\n  return list.some((item) => {\n    try {\n      if (typeof item === 'function') {\n        return item(value)\n      } else if (item instanceof RegExp) {\n        // Prevent stateful matching\n        item.lastIndex = 0\n        return item.test(value)\n      } else if (typeof item === 'string') {\n        return useStartsWith ? value.startsWith(item) : item === value\n      }\n    } catch (e) {\n      display.error(e)\n    }\n    return false\n  })\n}\n"],"mappings":";;;AAKA,SAAgB,cAAc,MAAoC;CAChE,MAAM,WAAW,QAAQ,IAAI;CAC7B,OAAO,aAAa,YAAY,aAAa,cAAc,gBAAgB;AAC7E;;;;;;AAOA,SAAgB,UAAU,MAAqB,OAAe,gBAAgB,OAAgB;CAC5F,OAAO,KAAK,MAAM,SAAS;EACzB,IAAI;GACF,IAAI,OAAO,SAAS,YAClB,OAAO,KAAK,KAAK;QACZ,IAAI,gBAAgB,QAAQ;IAEjC,KAAK,YAAY;IACjB,OAAO,KAAK,KAAK,KAAK;GACxB,OAAO,IAAI,OAAO,SAAS,UACzB,OAAO,gBAAgB,MAAM,WAAW,IAAI,IAAI,SAAS;EAE7D,SAAS,GAAG;GACV,QAAQ,MAAM,CAAC;EACjB;EACA,OAAO;CACT,CAAC;AACH"}

package/esm/tools/mockable.mjs

@@ -0,0 +1,28 @@
+//#region src/tools/mockable.ts
+/**
+* Wraps a value to make it mockable in tests. In production builds, this is a no-op
+* that returns the value as-is. In test builds, it checks if a mock replacement has
+* been registered and returns that instead.
+*
+* @example
+* // In source file:
+* import { mockable } from '../tools/mockable'
+* export function formatNavigationEntry(): string {
+*   const navigationEntry = mockable(getNavigationEntry)()
+*   ...
+* }
+*
+* // In test file:
+* import { replaceMockable } from '@openobserve/browser-core/test'
+* it('...', () => {
+*   replaceMockable(getNavigationEntry, () => FAKE_NAVIGATION_ENTRY)
+*   expect(formatNavigationEntry()).toEqual(...)
+* })
+*/
+function mockable(value) {
+	return value;
+}
+//#endregion
+export { mockable };
+
+//# sourceMappingURL=mockable.mjs.map

package/esm/tools/mockable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockable.mjs","names":[],"sources":["../../src/tools/mockable.ts"],"sourcesContent":["declare const __BUILD_ENV__SDK_VERSION__: string\n\nexport const mockableReplacements = new Map<unknown, unknown>()\n\n/**\n * Wraps a value to make it mockable in tests. In production builds, this is a no-op\n * that returns the value as-is. In test builds, it checks if a mock replacement has\n * been registered and returns that instead.\n *\n * @example\n * // In source file:\n * import { mockable } from '../tools/mockable'\n * export function formatNavigationEntry(): string {\n *   const navigationEntry = mockable(getNavigationEntry)()\n *   ...\n * }\n *\n * // In test file:\n * import { replaceMockable } from '@openobserve/browser-core/test'\n * it('...', () => {\n *   replaceMockable(getNavigationEntry, () => FAKE_NAVIGATION_ENTRY)\n *   expect(formatNavigationEntry()).toEqual(...)\n * })\n */\nexport function mockable<T>(value: T): T {\n  // In test builds, return a wrapper that checks for mocks at call time\n  if (__BUILD_ENV__SDK_VERSION__ === 'test' && mockableReplacements.has(value)) {\n    return mockableReplacements.get(value)! as T\n  }\n  // In production, return the value as-is\n  return value\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,SAAY,OAAa;CAMvC,OAAO;AACT"}

package/esm/tools/monitor.mjs

@@ -0,0 +1,13 @@
+import { display } from "./display.mjs";
+import "@openobserve/js-core/util";
+import { createMonitor } from "@openobserve/js-core/monitor";
+//#region src/tools/monitor.ts
+let onMonitorErrorCollected;
+const { monitored, monitor, callMonitored, monitorError } = createMonitor(display, (error) => onMonitorErrorCollected?.(error));
+function startMonitorErrorCollection(newOnMonitorErrorCollected) {
+	onMonitorErrorCollected = newOnMonitorErrorCollected;
+}
+//#endregion
+export { callMonitored, monitor, monitorError, monitored, startMonitorErrorCollection };
+
+//# sourceMappingURL=monitor.mjs.map

package/esm/tools/monitor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitor.mjs","names":[],"sources":["../../src/tools/monitor.ts"],"sourcesContent":["/* eslint-disable local-rules/disallow-side-effects */\nimport { createMonitor } from '@openobserve/js-core/monitor'\nimport { setDebugMode } from '@openobserve/js-core/util'\nimport { display } from './display'\n\n// The error-collection callback is wired lazily (via `startMonitorErrorCollection`, during telemetry\n// init), so we pass a stable forwarding function to `createMonitor` and keep the real callback in a\n// mutable holder.\nlet onMonitorErrorCollected: ((error: unknown) => void) | undefined\n\nconst { monitored, monitor, callMonitored, monitorError } = createMonitor(display, (error) =>\n  onMonitorErrorCollected?.(error)\n)\n\nexport { monitored, monitor, callMonitored, monitorError }\n\nexport function startMonitorErrorCollection(newOnMonitorErrorCollected: (error: unknown) => void) {\n  onMonitorErrorCollected = newOnMonitorErrorCollected\n}\n\nexport function resetMonitor() {\n  onMonitorErrorCollected = undefined\n  setDebugMode(false)\n}\n"],"mappings":";;;;AAQA,IAAI;AAEJ,MAAM,EAAE,WAAW,SAAS,eAAe,iBAAiB,cAAc,UAAU,UAClF,0BAA0B,KAAK,CACjC;AAIA,SAAgB,4BAA4B,4BAAsD;CAChG,0BAA0B;AAC5B"}

package/esm/tools/observable.mjs

@@ -0,0 +1,77 @@
+import { queueMicrotask } from "./queueMicrotask.mjs";
+//#region src/tools/observable.ts
+var Observable = class {
+	constructor(onFirstSubscribe) {
+		this.onFirstSubscribe = onFirstSubscribe;
+		this.observers = [];
+	}
+	subscribe(observer) {
+		this.addObserver(observer);
+		return { unsubscribe: () => this.removeObserver(observer) };
+	}
+	notify(data) {
+		this.observers.forEach((observer) => observer(data));
+	}
+	addObserver(observer) {
+		this.observers.push(observer);
+		if (this.observers.length === 1 && this.onFirstSubscribe) this.onLastUnsubscribe = this.onFirstSubscribe(this) || void 0;
+	}
+	removeObserver(observer) {
+		this.observers = this.observers.filter((other) => observer !== other);
+		if (!this.observers.length && this.onLastUnsubscribe) this.onLastUnsubscribe();
+	}
+};
+function mergeObservables(...observables) {
+	return new Observable((globalObservable) => {
+		const subscriptions = observables.map((observable) => observable.subscribe((data) => globalObservable.notify(data)));
+		return () => subscriptions.forEach((subscription) => subscription.unsubscribe());
+	});
+}
+var BufferedObservable = class extends Observable {
+	constructor(maxBufferSize, onDrop) {
+		super();
+		this.maxBufferSize = maxBufferSize;
+		this.onDrop = onDrop;
+		this.buffer = [];
+		this.droppedCount = 0;
+	}
+	notify(data) {
+		this.buffer.push(data);
+		if (this.buffer.length > this.maxBufferSize) {
+			this.buffer.shift();
+			this.droppedCount++;
+		}
+		super.notify(data);
+	}
+	subscribe(observer) {
+		let closed = false;
+		const subscription = { unsubscribe: () => {
+			closed = true;
+			this.removeObserver(observer);
+		} };
+		queueMicrotask(() => {
+			for (const data of this.buffer) {
+				if (closed) return;
+				observer(data);
+			}
+			if (!closed) this.addObserver(observer);
+		});
+		return subscription;
+	}
+	/**
+	* Drop buffered data and don't buffer future data. This is to avoid leaking memory when it's not
+	* needed anymore. This can be seen as a performance optimization, and things will work probably
+	* even if this method isn't called, but still useful to clarify our intent and lowering our
+	* memory impact.
+	*/
+	unbuffer() {
+		queueMicrotask(() => {
+			if (this.droppedCount > 0 && this.onDrop) this.onDrop(this.droppedCount);
+			this.maxBufferSize = this.buffer.length = 0;
+		});
+	}
+};
+//#endregion
+export { BufferedObservable, Observable, mergeObservables };
+
+//# sourceMappingURL=observable.mjs.map

package/esm/tools/observable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.mjs","names":[],"sources":["../../src/tools/observable.ts"],"sourcesContent":["import { queueMicrotask } from './queueMicrotask'\n\nexport interface Subscription {\n  unsubscribe: () => void\n}\n\ntype Observer<T> = (data: T) => void\n\n// eslint-disable-next-line no-restricted-syntax\nexport class Observable<T> {\n  protected observers: Array<Observer<T>> = []\n  private onLastUnsubscribe?: () => void\n\n  constructor(private onFirstSubscribe?: (observable: Observable<T>) => (() => void) | void) {}\n\n  subscribe(observer: Observer<T>): Subscription {\n    this.addObserver(observer)\n    return {\n      unsubscribe: () => this.removeObserver(observer),\n    }\n  }\n\n  notify(data: T) {\n    this.observers.forEach((observer) => observer(data))\n  }\n\n  protected addObserver(observer: Observer<T>) {\n    this.observers.push(observer)\n    if (this.observers.length === 1 && this.onFirstSubscribe) {\n      this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined\n    }\n  }\n\n  protected removeObserver(observer: Observer<T>) {\n    this.observers = this.observers.filter((other) => observer !== other)\n    if (!this.observers.length && this.onLastUnsubscribe) {\n      this.onLastUnsubscribe()\n    }\n  }\n}\n\nexport function mergeObservables<T>(...observables: Array<Observable<T>>) {\n  return new Observable<T>((globalObservable) => {\n    const subscriptions: Subscription[] = observables.map((observable) =>\n      observable.subscribe((data) => globalObservable.notify(data))\n    )\n    return () => subscriptions.forEach((subscription) => subscription.unsubscribe())\n  })\n}\n\n// eslint-disable-next-line no-restricted-syntax\nexport class BufferedObservable<T> extends Observable<T> {\n  private buffer: T[] = []\n  private droppedCount = 0\n\n  constructor(\n    private maxBufferSize: number,\n    private onDrop?: (count: number) => void\n  ) {\n    super()\n  }\n\n  notify(data: T) {\n    this.buffer.push(data)\n    if (this.buffer.length > this.maxBufferSize) {\n      this.buffer.shift()\n      this.droppedCount++\n    }\n    super.notify(data)\n  }\n\n  subscribe(observer: Observer<T>): Subscription {\n    let closed = false\n\n    const subscription = {\n      unsubscribe: () => {\n        closed = true\n        this.removeObserver(observer)\n      },\n    }\n\n    queueMicrotask(() => {\n      for (const data of this.buffer) {\n        if (closed) {\n          return\n        }\n        observer(data)\n      }\n\n      if (!closed) {\n        this.addObserver(observer)\n      }\n    })\n\n    return subscription\n  }\n\n  /**\n   * Drop buffered data and don't buffer future data. This is to avoid leaking memory when it's not\n   * needed anymore. This can be seen as a performance optimization, and things will work probably\n   * even if this method isn't called, but still useful to clarify our intent and lowering our\n   * memory impact.\n   */\n  unbuffer() {\n    queueMicrotask(() => {\n      if (this.droppedCount > 0 && this.onDrop) {\n        this.onDrop(this.droppedCount)\n      }\n      this.maxBufferSize = this.buffer.length = 0\n    })\n  }\n}\n"],"mappings":";;AASA,IAAa,aAAb,MAA2B;CAIzB,YAAY,kBAA+E;EAAvE,KAAA,mBAAA;mBAHsB,CAAC;CAGiD;CAE5F,UAAU,UAAqC;EAC7C,KAAK,YAAY,QAAQ;EACzB,OAAO,EACL,mBAAmB,KAAK,eAAe,QAAQ,EACjD;CACF;CAEA,OAAO,MAAS;EACd,KAAK,UAAU,SAAS,aAAa,SAAS,IAAI,CAAC;CACrD;CAEA,YAAsB,UAAuB;EAC3C,KAAK,UAAU,KAAK,QAAQ;EAC5B,IAAI,KAAK,UAAU,WAAW,KAAK,KAAK,kBACtC,KAAK,oBAAoB,KAAK,iBAAiB,IAAI,KAAK,KAAA;CAE5D;CAEA,eAAyB,UAAuB;EAC9C,KAAK,YAAY,KAAK,UAAU,QAAQ,UAAU,aAAa,KAAK;EACpE,IAAI,CAAC,KAAK,UAAU,UAAU,KAAK,mBACjC,KAAK,kBAAkB;CAE3B;AACF;AAEA,SAAgB,iBAAoB,GAAG,aAAmC;CACxE,OAAO,IAAI,YAAe,qBAAqB;EAC7C,MAAM,gBAAgC,YAAY,KAAK,eACrD,WAAW,WAAW,SAAS,iBAAiB,OAAO,IAAI,CAAC,CAC9D;EACA,aAAa,cAAc,SAAS,iBAAiB,aAAa,YAAY,CAAC;CACjF,CAAC;AACH;AAGA,IAAa,qBAAb,cAA2C,WAAc;CAIvD,YACE,eACA,QACA;EACA,MAAM;EAHE,KAAA,gBAAA;EACA,KAAA,SAAA;gBALY,CAAC;sBACA;CAOvB;CAEA,OAAO,MAAS;EACd,KAAK,OAAO,KAAK,IAAI;EACrB,IAAI,KAAK,OAAO,SAAS,KAAK,eAAe;GAC3C,KAAK,OAAO,MAAM;GAClB,KAAK;EACP;EACA,MAAM,OAAO,IAAI;CACnB;CAEA,UAAU,UAAqC;EAC7C,IAAI,SAAS;EAEb,MAAM,eAAe,EACnB,mBAAmB;GACjB,SAAS;GACT,KAAK,eAAe,QAAQ;EAC9B,EACF;EAEA,qBAAqB;GACnB,KAAK,MAAM,QAAQ,KAAK,QAAQ;IAC9B,IAAI,QACF;IAEF,SAAS,IAAI;GACf;GAEA,IAAI,CAAC,QACH,KAAK,YAAY,QAAQ;EAE7B,CAAC;EAED,OAAO;CACT;;;;;;;CAQA,WAAW;EACT,qBAAqB;GACnB,IAAI,KAAK,eAAe,KAAK,KAAK,QAChC,KAAK,OAAO,KAAK,YAAY;GAE/B,KAAK,gBAAgB,KAAK,OAAO,SAAS;EAC5C,CAAC;CACH;AACF"}

package/esm/tools/queueMicrotask.mjs

@@ -0,0 +1,12 @@
+import { globalObject } from "./globalObject.mjs";
+import { monitor } from "./monitor.mjs";
+//#region src/tools/queueMicrotask.ts
+function queueMicrotask(callback) {
+	const nativeImplementation = globalObject.queueMicrotask;
+	if (typeof nativeImplementation === "function") nativeImplementation(monitor(callback));
+	else Promise.resolve().then(monitor(callback));
+}
+//#endregion
+export { queueMicrotask };
+
+//# sourceMappingURL=queueMicrotask.mjs.map

package/esm/tools/queueMicrotask.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"queueMicrotask.mjs","names":[],"sources":["../../src/tools/queueMicrotask.ts"],"sourcesContent":["import { monitor } from './monitor'\nimport { globalObject } from './globalObject'\n\nexport function queueMicrotask(callback: () => void) {\n  // Intentionally avoid .bind(globalObject): in some environments (e.g. Selenium GeckoDriver's\n  // executeScript), globalThis is not a proper global object, so calling the bound function throws\n  // 'queueMicrotask called on an object that does not implement interface Window'. Calling it as an\n  // unbound method is fine, as the proper global object will be used implicitly.\n  // See https://github.com/mozilla/geckodriver/issues/1798\n  const nativeImplementation = globalObject.queueMicrotask\n\n  if (typeof nativeImplementation === 'function') {\n    nativeImplementation(monitor(callback))\n  } else {\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- the callback is monitored, so it'll never throw\n    Promise.resolve().then(monitor(callback))\n  }\n}\n"],"mappings":";;;AAGA,SAAgB,eAAe,UAAsB;CAMnD,MAAM,uBAAuB,aAAa;CAE1C,IAAI,OAAO,yBAAyB,YAClC,qBAAqB,QAAQ,QAAQ,CAAC;MAGtC,QAAQ,QAAQ,CAAC,CAAC,KAAK,QAAQ,QAAQ,CAAC;AAE5C"}

package/esm/tools/readBytesFromStream.mjs

@@ -0,0 +1,21 @@
+import { noop } from "./utils/functionUtils.mjs";
+import { concatBuffers } from "./utils/byteUtils.mjs";
+//#region src/tools/readBytesFromStream.ts
+/**
+* Read bytes from a ReadableStream until the end of the stream.
+*/
+async function readBytesFromStream(stream) {
+	const reader = stream.getReader();
+	const chunks = [];
+	while (true) {
+		const result = await reader.read();
+		if (result.done) break;
+		chunks.push(result.value);
+	}
+	reader.cancel().catch(noop);
+	return concatBuffers(chunks);
+}
+//#endregion
+export { readBytesFromStream };
+
+//# sourceMappingURL=readBytesFromStream.mjs.map

package/esm/tools/readBytesFromStream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"readBytesFromStream.mjs","names":[],"sources":["../../src/tools/readBytesFromStream.ts"],"sourcesContent":["import type { Uint8ArrayBuffer } from './utils/byteUtils'\nimport { concatBuffers } from './utils/byteUtils'\nimport { noop } from './utils/functionUtils'\n\n/**\n * Read bytes from a ReadableStream until the end of the stream.\n */\nexport async function readBytesFromStream(stream: ReadableStream<Uint8ArrayBuffer>) {\n  const reader = stream.getReader()\n  const chunks: Uint8ArrayBuffer[] = []\n\n  while (true) {\n    const result = await reader.read()\n    if (result.done) {\n      break\n    }\n\n    chunks.push(result.value)\n  }\n\n  reader.cancel().catch(\n    // we don't care if cancel fails, but we still need to catch the error to avoid reporting it\n    // as an unhandled rejection\n    noop\n  )\n\n  return concatBuffers(chunks)\n}\n"],"mappings":";;;;;;AAOA,eAAsB,oBAAoB,QAA0C;CAClF,MAAM,SAAS,OAAO,UAAU;CAChC,MAAM,SAA6B,CAAC;CAEpC,OAAO,MAAM;EACX,MAAM,SAAS,MAAM,OAAO,KAAK;EACjC,IAAI,OAAO,MACT;EAGF,OAAO,KAAK,OAAO,KAAK;CAC1B;CAEA,OAAO,OAAO,CAAC,CAAC,MAGd,IACF;CAEA,OAAO,cAAc,MAAM;AAC7B"}

package/esm/tools/requestIdleCallback.mjs

@@ -0,0 +1,28 @@
+import { monitor } from "./monitor.mjs";
+import { clearTimeout, setTimeout } from "./timer.mjs";
+import { dateNow } from "@openobserve/js-core/time";
+//#region src/tools/requestIdleCallback.ts
+/**
+* 'requestIdleCallback' with a shim.
+*/
+function requestIdleCallback(callback, opts) {
+	if (window.requestIdleCallback && window.cancelIdleCallback) {
+		const id = window.requestIdleCallback(monitor(callback), opts);
+		return () => window.cancelIdleCallback(id);
+	}
+	return requestIdleCallbackShim(callback);
+}
+function requestIdleCallbackShim(callback) {
+	const start = dateNow();
+	const timeoutId = setTimeout(() => {
+		callback({
+			didTimeout: false,
+			timeRemaining: () => Math.max(0, 50 - (dateNow() - start))
+		});
+	}, 0);
+	return () => clearTimeout(timeoutId);
+}
+//#endregion
+export { requestIdleCallback };
+
+//# sourceMappingURL=requestIdleCallback.mjs.map

package/esm/tools/requestIdleCallback.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestIdleCallback.mjs","names":[],"sources":["../../src/tools/requestIdleCallback.ts"],"sourcesContent":["import { dateNow } from '@openobserve/js-core/time'\nimport { setTimeout, clearTimeout } from './timer'\nimport { monitor } from './monitor'\n\n// This type is not yet supported in TS 3.8. Imported from the TS source until we upgrade the\n// minimum supported TS version.\n// https://github.com/microsoft/TypeScript/blob/13c374a868c926f6a907666a5599992c1351b773/src/lib/dom.generated.d.ts#L9513-L9516\nexport interface IdleDeadline {\n  readonly didTimeout: boolean\n  timeRemaining(): DOMHighResTimeStamp\n}\n\n/**\n * 'requestIdleCallback' with a shim.\n */\nexport function requestIdleCallback(callback: (deadline: IdleDeadline) => void, opts?: { timeout?: number }) {\n  // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.\n  if (window.requestIdleCallback && window.cancelIdleCallback) {\n    const id = window.requestIdleCallback(monitor(callback), opts)\n    return () => window.cancelIdleCallback(id)\n  }\n  return requestIdleCallbackShim(callback)\n}\n\nexport const MAX_TASK_TIME = 50\n\n/*\n * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback\n * Note: there is no simple way to support the \"timeout\" option, so we ignore it.\n */\nexport function requestIdleCallbackShim(callback: (deadline: IdleDeadline) => void) {\n  const start = dateNow()\n  const timeoutId = setTimeout(() => {\n    callback({\n      didTimeout: false,\n      timeRemaining: () => Math.max(0, MAX_TASK_TIME - (dateNow() - start)),\n    })\n  }, 0)\n  return () => clearTimeout(timeoutId)\n}\n"],"mappings":";;;;;;;AAeA,SAAgB,oBAAoB,UAA4C,MAA6B;CAE3G,IAAI,OAAO,uBAAuB,OAAO,oBAAoB;EAC3D,MAAM,KAAK,OAAO,oBAAoB,QAAQ,QAAQ,GAAG,IAAI;EAC7D,aAAa,OAAO,mBAAmB,EAAE;CAC3C;CACA,OAAO,wBAAwB,QAAQ;AACzC;AAQA,SAAgB,wBAAwB,UAA4C;CAClF,MAAM,QAAQ,QAAQ;CACtB,MAAM,YAAY,iBAAiB;EACjC,SAAS;GACP,YAAY;GACZ,qBAAqB,KAAK,IAAI,GAAA,MAAoB,QAAQ,IAAI,MAAM;EACtE,CAAC;CACH,GAAG,CAAC;CACJ,aAAa,aAAa,SAAS;AACrC"}

package/esm/tools/sendToExtension.mjs

@@ -0,0 +1,13 @@
+import { globalObject } from "./globalObject.mjs";
+//#region src/tools/sendToExtension.ts
+function sendToExtension(type, payload) {
+	const callback = globalObject.__ooBrowserSdkExtensionCallback;
+	if (callback) callback({
+		type,
+		payload
+	});
+}
+//#endregion
+export { sendToExtension };
+
+//# sourceMappingURL=sendToExtension.mjs.map

package/esm/tools/sendToExtension.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendToExtension.mjs","names":[],"sources":["../../src/tools/sendToExtension.ts"],"sourcesContent":["import { globalObject } from './globalObject'\n\ninterface BrowserWindow {\n  __ooBrowserSdkExtensionCallback?: (message: unknown) => void\n}\n\ntype ExtensionMessageType = 'logs' | 'record' | 'rum' | 'telemetry'\n\nexport function sendToExtension(type: ExtensionMessageType, payload: unknown) {\n  const callback = (globalObject as BrowserWindow).__ooBrowserSdkExtensionCallback\n  if (callback) {\n    callback({ type, payload })\n  }\n}\n"],"mappings":";;AAQA,SAAgB,gBAAgB,MAA4B,SAAkB;CAC5E,MAAM,WAAY,aAA+B;CACjD,IAAI,UACF,SAAS;EAAE;EAAM;CAAQ,CAAC;AAE9B"}

package/esm/tools/serialisation/jsonStringify.mjs

@@ -0,0 +1,42 @@
+import { noop } from "../utils/functionUtils.mjs";
+//#region src/tools/serialisation/jsonStringify.ts
+/**
+* Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that
+* because some sites badly override toJSON on certain objects. Removing all toJSON methods from
+* nested values would be too costly, so we just detach them from the root value, and native classes
+* used to build JSON values (Array and Object).
+*
+* Note: this still assumes that JSON.stringify is correct.
+*/
+function jsonStringify(value, replacer, space) {
+	if (typeof value !== "object" || value === null) return JSON.stringify(value);
+	const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);
+	const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);
+	const restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));
+	const restoreValueToJson = detachToJsonMethod(value);
+	try {
+		return JSON.stringify(value, replacer, space);
+	} catch {
+		return "<error: unable to serialize object>";
+	} finally {
+		restoreObjectPrototypeToJson();
+		restoreArrayPrototypeToJson();
+		restoreValuePrototypeToJson();
+		restoreValueToJson();
+	}
+}
+function detachToJsonMethod(value) {
+	const object = value;
+	const objectToJson = object.toJSON;
+	if (objectToJson) {
+		delete object.toJSON;
+		return () => {
+			object.toJSON = objectToJson;
+		};
+	}
+	return noop;
+}
+//#endregion
+export { detachToJsonMethod, jsonStringify };
+
+//# sourceMappingURL=jsonStringify.mjs.map