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

package/cjs/domain/error/error.js.map

@@ -1 +1 @@
-{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../src/domain/error/error.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"error.js","names":["isError","toStackTraceString","NO_ERROR_STACK_PRESENT_MESSAGE","buildDebugIdByUrl","computeStackTrace","jsonStringify","sanitize","isIndexableObject"],"sources":["../../../src/domain/error/error.ts"],"sourcesContent":["import type { ClocksState } from '@kubesense/kubesense-js-core/time'\nimport { isIndexableObject } from '@kubesense/kubesense-js-core/util'\nimport { sanitize } from '../../tools/serialisation/sanitize'\nimport type { Context } from '../../tools/serialisation/context'\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify'\nimport type { StackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack'\nimport { buildDebugIdByUrl } from '../sourceCodeContext'\nimport type { ErrorSource, ErrorHandling, RawError, ErrorWithCause, NonErrorPrefix } from './error.types'\nimport { isError, NO_ERROR_STACK_PRESENT_MESSAGE } from './isError'\n\nexport { isError, NO_ERROR_STACK_PRESENT_MESSAGE }\n\n/**\n * Used when `error.type` cannot be derived from the collected error. Sending a default rather than\n * nothing keeps those errors groupable and searchable alongside the rest.\n */\nexport const DEFAULT_ERROR_TYPE = 'Error'\n\ninterface RawErrorParams {\n  stackTrace?: StackTrace\n  originalError: unknown\n  handlingStack?: string\n  componentStack?: string\n  startClocks: ClocksState\n  nonErrorPrefix: NonErrorPrefix\n  useFallbackStack?: boolean\n  source: ErrorSource\n  handling: ErrorHandling\n}\n\nfunction computeErrorBase({\n  originalError,\n  stackTrace,\n  source,\n  useFallbackStack = true,\n  nonErrorPrefix,\n}: {\n  originalError: unknown\n  stackTrace?: StackTrace\n  source: ErrorSource\n  useFallbackStack?: boolean\n  nonErrorPrefix?: NonErrorPrefix\n}) {\n  const isErrorInstance = isError(originalError)\n  return {\n    source,\n    type: computeType(stackTrace, originalError),\n    message: computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError),\n    stack: stackTrace ? toStackTraceString(stackTrace) : useFallbackStack ? NO_ERROR_STACK_PRESENT_MESSAGE : undefined,\n  }\n}\n\n/**\n * `error.type` is normally the error class name (`TypeError`, `RangeError`...), read from the `name`\n * property of the collected error. It is unavailable in two cases.\n *\n * No `Error` instance ever reached the SDK, because the application threw, rejected or logged\n * something else: `console.error('message')`, `Promise.reject('reason')`, `addError('message')`. The\n * runtime type of that value is used instead, which also surfaces that a non-`Error` was thrown in\n * the first place.\n *\n * Or a stack trace was collected but tracekit could not extract a name from it, typically the opaque\n * cross-origin `\"Script error.\"`. A real error was raised here, so only its name is missing.\n */\nfunction computeType(stackTrace: StackTrace | undefined, originalError: unknown): string {\n  if (stackTrace) {\n    return stackTrace.name || DEFAULT_ERROR_TYPE\n  }\n  // `[object String]` -> `String`\n  return /\\[object (\\w+)\\]/.exec(Object.prototype.toString.call(originalError))?.[1] ?? DEFAULT_ERROR_TYPE\n}\n\nexport function getStackTraceUrls(stackTrace: StackTrace | undefined): string[] {\n  return stackTrace?.stack.map((frame) => frame.url).filter((url): url is string => !!url) ?? []\n}\n\nfunction getErrorDebugIds(\n  stackTrace: StackTrace | undefined,\n  errorCauses: Array<{ stackTrace: StackTrace | undefined }>\n) {\n  const errorCausesUrls = errorCauses.flatMap(({ stackTrace }) => getStackTraceUrls(stackTrace))\n  return buildDebugIdByUrl(getStackTraceUrls(stackTrace).concat(errorCausesUrls))\n}\n\nexport function flattenErrorCauses(\n  error: ErrorWithCause\n): Array<{ originalError: unknown; stackTrace: StackTrace | undefined }> {\n  const chain: Array<{ originalError: unknown; stackTrace: StackTrace | undefined }> = []\n  let current: unknown = error.cause\n\n  while (current !== undefined && current !== null && chain.length < 10) {\n    const isCurrentError = isError(current)\n    const stackTrace = isCurrentError ? computeStackTrace(current) : undefined\n    chain.push({ originalError: current, stackTrace })\n    current = isCurrentError ? (current as ErrorWithCause).cause : undefined\n  }\n\n  return chain\n}\n\nexport function computeRawError({\n  stackTrace,\n  originalError,\n  handlingStack,\n  componentStack,\n  startClocks,\n  nonErrorPrefix,\n  useFallbackStack = true,\n  source,\n  handling,\n}: RawErrorParams): RawError {\n  const errorStackTrace = stackTrace ?? (isError(originalError) ? computeStackTrace(originalError) : undefined)\n\n  const errorCauses = isError(originalError) ? flattenErrorCauses(originalError) : []\n\n  const errorBase = computeErrorBase({\n    originalError,\n    stackTrace: errorStackTrace,\n    source,\n    useFallbackStack,\n    nonErrorPrefix,\n  })\n\n  const rawErrorCauses = errorCauses.map(({ originalError, stackTrace }) =>\n    computeErrorBase({ originalError, stackTrace, source, useFallbackStack: false })\n  )\n\n  return {\n    startClocks,\n    handling,\n    handlingStack,\n    componentStack,\n    originalError,\n    ...errorBase,\n    debugIds: getErrorDebugIds(errorStackTrace, errorCauses),\n    causes: rawErrorCauses.length ? rawErrorCauses : undefined,\n    fingerprint: tryToGetFingerprint(originalError),\n    context: tryToGetErrorContext(originalError),\n  }\n}\n\nfunction computeMessage(\n  stackTrace: StackTrace | undefined,\n  isErrorInstance: boolean,\n  nonErrorPrefix: NonErrorPrefix | undefined,\n  originalError: unknown\n) {\n  // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)\n  // TODO rework tracekit integration to avoid scattering error building logic\n  return stackTrace?.message && stackTrace?.name\n    ? stackTrace.message\n    : !isErrorInstance\n      ? nonErrorPrefix\n        ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))!}`\n        : jsonStringify(sanitize(originalError))!\n      : 'Empty message'\n}\n\nexport function tryToGetFingerprint(originalError: unknown) {\n  return isError(originalError) && 'kubesense_fingerprint' in originalError\n    ? String(originalError.kubesense_fingerprint)\n    : undefined\n}\n\nexport function tryToGetErrorContext(originalError: unknown) {\n  if (isIndexableObject(originalError)) {\n    return originalError.kubesense_context as Context | undefined\n  }\n}\n\nexport function getFileFromStackTraceString(stack: string) {\n  return /@ (.+)/.exec(stack)?.[1]\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,MAAa,qBAAqB;AAclC,SAAS,iBAAiB,EACxB,eACA,YACA,QACA,mBAAmB,MACnB,kBAOC;CACD,MAAM,kBAAkBA,gBAAAA,QAAQ,aAAa;CAC7C,OAAO;EACL;EACA,MAAM,YAAY,YAAY,aAAa;EAC3C,SAAS,eAAe,YAAY,iBAAiB,gBAAgB,aAAa;EAClF,OAAO,aAAaC,sBAAAA,mBAAmB,UAAU,IAAI,mBAAmBC,gBAAAA,iCAAiC,KAAA;CAC3G;AACF;;;;;;;;;;;;;AAcA,SAAS,YAAY,YAAoC,eAAgC;CACvF,IAAI,YACF,OAAO,WAAW,QAAA;CAGpB,OAAO,mBAAmB,KAAK,OAAO,UAAU,SAAS,KAAK,aAAa,CAAC,CAAC,GAAG,MAAA;AAClF;AAEA,SAAgB,kBAAkB,YAA8C;CAC9E,OAAO,YAAY,MAAM,KAAK,UAAU,MAAM,GAAG,CAAC,CAAC,QAAQ,QAAuB,CAAC,CAAC,GAAG,KAAK,CAAC;AAC/F;AAEA,SAAS,iBACP,YACA,aACA;CACA,MAAM,kBAAkB,YAAY,SAAS,EAAE,iBAAiB,kBAAkB,UAAU,CAAC;CAC7F,OAAOC,0BAAAA,kBAAkB,kBAAkB,UAAU,CAAC,CAAC,OAAO,eAAe,CAAC;AAChF;AAEA,SAAgB,mBACd,OACuE;CACvE,MAAM,QAA+E,CAAC;CACtF,IAAI,UAAmB,MAAM;CAE7B,OAAO,YAAY,KAAA,KAAa,YAAY,QAAQ,MAAM,SAAS,IAAI;EACrE,MAAM,iBAAiBH,gBAAAA,QAAQ,OAAO;EACtC,MAAM,aAAa,iBAAiBI,0BAAAA,kBAAkB,OAAO,IAAI,KAAA;EACjE,MAAM,KAAK;GAAE,eAAe;GAAS;EAAW,CAAC;EACjD,UAAU,iBAAkB,QAA2B,QAAQ,KAAA;CACjE;CAEA,OAAO;AACT;AAEA,SAAgB,gBAAgB,EAC9B,YACA,eACA,eACA,gBACA,aACA,gBACA,mBAAmB,MACnB,QACA,YAC2B;CAC3B,MAAM,kBAAkB,eAAeJ,gBAAAA,QAAQ,aAAa,IAAII,0BAAAA,kBAAkB,aAAa,IAAI,KAAA;CAEnG,MAAM,cAAcJ,gBAAAA,QAAQ,aAAa,IAAI,mBAAmB,aAAa,IAAI,CAAC;CAElF,MAAM,YAAY,iBAAiB;EACjC;EACA,YAAY;EACZ;EACA;EACA;CACF,CAAC;CAED,MAAM,iBAAiB,YAAY,KAAK,EAAE,eAAe,iBACvD,iBAAiB;EAAE;EAAe;EAAY;EAAQ,kBAAkB;CAAM,CAAC,CACjF;CAEA,OAAO;EACL;EACA;EACA;EACA;EACA;EACA,GAAG;EACH,UAAU,iBAAiB,iBAAiB,WAAW;EACvD,QAAQ,eAAe,SAAS,iBAAiB,KAAA;EACjD,aAAa,oBAAoB,aAAa;EAC9C,SAAS,qBAAqB,aAAa;CAC7C;AACF;AAEA,SAAS,eACP,YACA,iBACA,gBACA,eACA;CAGA,OAAO,YAAY,WAAW,YAAY,OACtC,WAAW,UACX,CAAC,kBACC,iBACE,GAAG,eAAe,GAAGK,sBAAAA,cAAcC,iBAAAA,SAAS,aAAa,CAAC,MAC1DD,sBAAAA,cAAcC,iBAAAA,SAAS,aAAa,CAAC,IACvC;AACR;AAEA,SAAgB,oBAAoB,eAAwB;CAC1D,OAAON,gBAAAA,QAAQ,aAAa,KAAK,2BAA2B,gBACxD,OAAO,cAAc,qBAAqB,IAC1C,KAAA;AACN;AAEA,SAAgB,qBAAqB,eAAwB;CAC3D,KAAA,GAAIO,kCAAAA,kBAAAA,CAAkB,aAAa,GACjC,OAAO,cAAc;AAEzB;AAEA,SAAgB,4BAA4B,OAAe;CACzD,OAAO,SAAS,KAAK,KAAK,CAAC,GAAG;AAChC"}

package/cjs/domain/error/error.types.d.ts

@@ -1,12 +1,13 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time';
 import type { Context } from '../../tools/serialisation/context';
-import type { ClocksState } from '../../tools/utils/timeUtils';
+import type { DebugIdEntry } from '../sourceCodeContext';
 export interface ErrorWithCause extends Omit<Error, 'cause'> {
     cause?: unknown;
 }
 export interface RawErrorCause {
     message: string;
-    source: string;
-    type?: string;
+    source: ErrorSource;
+    type: string;
     stack?: string;
 }
 export interface Csp {
@@ -15,7 +16,7 @@ export interface Csp {
 export interface RawError {
     startClocks: ClocksState;
     message: string;
-    type?: string;
+    type: string;
     stack?: string;
     source: ErrorSource;
     originalError?: unknown;
@@ -26,6 +27,7 @@ export interface RawError {
     fingerprint?: string;
     csp?: Csp;
     context?: Context;
+    debugIds?: DebugIdEntry[];
 }
 export declare const ErrorSource: {
     readonly AGENT: "agent";

package/cjs/domain/error/error.types.js

@@ -1,13 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorSource = void 0;
-exports.ErrorSource = {
-    AGENT: 'agent',
-    CONSOLE: 'console',
-    CUSTOM: 'custom',
-    LOGGER: 'logger',
-    NETWORK: 'network',
-    SOURCE: 'source',
-    REPORT: 'report',
+//#region src/domain/error/error.types.ts
+const ErrorSource = {
+	AGENT: "agent",
+	CONSOLE: "console",
+	CUSTOM: "custom",
+	LOGGER: "logger",
+	NETWORK: "network",
+	SOURCE: "source",
+	REPORT: "report"
 };
+let NonErrorPrefix = /* @__PURE__ */ function(NonErrorPrefix) {
+	NonErrorPrefix["UNCAUGHT"] = "Uncaught";
+	NonErrorPrefix["PROVIDED"] = "Provided";
+	return NonErrorPrefix;
+}({});
+let ErrorHandling = /* @__PURE__ */ function(ErrorHandling) {
+	ErrorHandling["HANDLED"] = "handled";
+	ErrorHandling["UNHANDLED"] = "unhandled";
+	return ErrorHandling;
+}({});
+//#endregion
+exports.ErrorHandling = ErrorHandling;
+exports.ErrorSource = ErrorSource;
+exports.NonErrorPrefix = NonErrorPrefix;
+
 //# sourceMappingURL=error.types.js.map

package/cjs/domain/error/error.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"error.types.js","sourceRoot":"","sources":["../../../src/domain/error/error.types.ts"],"names":[],"mappings":";;;AA2Ca,QAAA,WAAW,GAAG;IACzB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;CACR,CAAA"}
+{"version":3,"file":"error.types.js","names":[],"sources":["../../../src/domain/error/error.types.ts"],"sourcesContent":["import type { ClocksState } from '@kubesense/kubesense-js-core/time'\nimport type { Context } from '../../tools/serialisation/context'\nimport type { DebugIdEntry } from '../sourceCodeContext'\n\n// TS v4.6 introduced Error.cause[1] typed as `Error`. TS v4.8 changed Error.cause to be\n// `unknown`[2].\n//\n// Because we still support TS 3.8, we need to declare our own type. We can remove it once we drop\n// support for TS v4.7 and before. The 'cause' property defined by TS needs to be omitted because\n// we define it with a type `unknown` which is incompatible with TS 4.6 and 4.7.\n//\n// [1]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-6/#target-es2022\n// [2]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-8/#lib-d-ts-updates\nexport interface ErrorWithCause extends Omit<Error, 'cause'> {\n  cause?: unknown\n}\n\nexport interface RawErrorCause {\n  message: string\n  source: ErrorSource\n  type: string\n  stack?: string\n}\n\nexport interface Csp {\n  disposition: 'enforce' | 'report'\n}\n\nexport interface RawError {\n  startClocks: ClocksState\n  message: string\n  type: string\n  stack?: string\n  source: ErrorSource\n  originalError?: unknown\n  handling?: ErrorHandling\n  handlingStack?: string\n  componentStack?: string\n  causes?: RawErrorCause[]\n  fingerprint?: string\n  csp?: Csp\n  context?: Context\n  debugIds?: DebugIdEntry[]\n}\n\nexport const ErrorSource = {\n  AGENT: 'agent',\n  CONSOLE: 'console',\n  CUSTOM: 'custom',\n  LOGGER: 'logger',\n  NETWORK: 'network',\n  SOURCE: 'source',\n  REPORT: 'report',\n} as const\n\nexport const enum NonErrorPrefix {\n  UNCAUGHT = 'Uncaught',\n  PROVIDED = 'Provided',\n}\n\nexport const enum ErrorHandling {\n  HANDLED = 'handled',\n  UNHANDLED = 'unhandled',\n}\n\nexport type ErrorSource = (typeof ErrorSource)[keyof typeof ErrorSource]\n"],"mappings":";AA6CA,MAAa,cAAc;CACzB,OAAO;CACP,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,QAAQ;AACV;AAEA,IAAkB,iBAAX,yBAAA,gBAAA;CACL,eAAA,cAAA;CACA,eAAA,cAAA;;AACF,EAAA,CAAA,CAAA;AAEA,IAAkB,gBAAX,yBAAA,eAAA;CACL,cAAA,aAAA;CACA,cAAA,eAAA;;AACF,EAAA,CAAA,CAAA"}

package/cjs/domain/error/isError.d.ts

@@ -0,0 +1,2 @@
+export declare const NO_ERROR_STACK_PRESENT_MESSAGE = "No stack, consider using an instance of Error";
+export declare function isError(error: unknown): error is Error;

package/cjs/domain/error/isError.js

@@ -0,0 +1,14 @@
+//#region src/domain/error/isError.ts
+const NO_ERROR_STACK_PRESENT_MESSAGE = "No stack, consider using an instance of Error";
+function isError(error) {
+	try {
+		return error instanceof Error || Object.prototype.toString.call(error) === "[object Error]";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+exports.NO_ERROR_STACK_PRESENT_MESSAGE = NO_ERROR_STACK_PRESENT_MESSAGE;
+exports.isError = isError;
+
+//# sourceMappingURL=isError.js.map

package/cjs/domain/error/isError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isError.js","names":[],"sources":["../../../src/domain/error/isError.ts"],"sourcesContent":["// Leaf module for error primitives with no further dependencies, so cross-cutting\n// modules (e.g. telemetry) can use them without pulling in the whole error module\n// and creating import cycles.\n\nexport const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error'\n\nexport function isError(error: unknown): error is Error {\n  try {\n    return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]'\n  } catch {\n    return false\n  }\n}\n"],"mappings":";AAIA,MAAa,iCAAiC;AAE9C,SAAgB,QAAQ,OAAgC;CACtD,IAAI;EACF,OAAO,iBAAiB,SAAS,OAAO,UAAU,SAAS,KAAK,KAAK,MAAM;CAC7E,QAAQ;EACN,OAAO;CACT;AACF"}

package/cjs/domain/error/trackRuntimeError.d.ts

@@ -1,11 +1,12 @@
 import { Observable } from '../../tools/observable';
 import type { StackTrace } from '../../tools/stackTrace/computeStackTrace';
+import { noop } from '../../tools/utils/functionUtils';
 import type { RawError } from './error.types';
 export type UnhandledErrorCallback = (originalError: unknown, stackTrace?: StackTrace) => any;
 export declare function trackRuntimeError(): Observable<RawError>;
 export declare function instrumentOnError(callback: UnhandledErrorCallback): {
-    stop: typeof import("../..").noop;
+    stop: typeof noop;
 };
 export declare function instrumentUnhandledRejection(callback: UnhandledErrorCallback): {
-    stop: typeof import("../..").noop;
+    stop: typeof noop;
 };

package/cjs/domain/error/trackRuntimeError.js

@@ -1,48 +1,51 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackRuntimeError = trackRuntimeError;
-exports.instrumentOnError = instrumentOnError;
-exports.instrumentUnhandledRejection = instrumentUnhandledRejection;
-const instrumentMethod_1 = require("../../tools/instrumentMethod");
-const observable_1 = require("../../tools/observable");
-const timeUtils_1 = require("../../tools/utils/timeUtils");
-const computeStackTrace_1 = require("../../tools/stackTrace/computeStackTrace");
-const globalObject_1 = require("../../tools/globalObject");
-const error_1 = require("./error");
-const error_types_1 = require("./error.types");
+const require_observable = require("../../tools/observable.js");
+const require_functionUtils = require("../../tools/utils/functionUtils.js");
+const require_computeStackTrace = require("../../tools/stackTrace/computeStackTrace.js");
+const require_instrumentMethod = require("../../tools/instrumentMethod.js");
+const require_addEventListener = require("../../browser/addEventListener.js");
+const require_isError = require("./isError.js");
+const require_error_types = require("./error.types.js");
+const require_error = require("./error.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/error/trackRuntimeError.ts
 function trackRuntimeError() {
-    return new observable_1.Observable((observer) => {
-        const handleRuntimeError = (originalError, stackTrace) => {
-            const rawError = (0, error_1.computeRawError)({
-                stackTrace,
-                originalError,
-                startClocks: (0, timeUtils_1.clocksNow)(),
-                nonErrorPrefix: "Uncaught" /* NonErrorPrefix.UNCAUGHT */,
-                source: error_types_1.ErrorSource.SOURCE,
-                handling: "unhandled" /* ErrorHandling.UNHANDLED */,
-            });
-            observer.notify(rawError);
-        };
-        const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError);
-        const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError);
-        return () => {
-            stopInstrumentingOnError();
-            stopInstrumentingOnUnhandledRejection();
-        };
-    });
+	return new require_observable.Observable((observer) => {
+		const handleRuntimeError = (originalError, stackTrace) => {
+			const rawError = require_error.computeRawError({
+				stackTrace,
+				originalError,
+				startClocks: (0, _kubesense_kubesense_js_core_time.clocksNow)(),
+				nonErrorPrefix: "Uncaught",
+				source: require_error_types.ErrorSource.SOURCE,
+				handling: "unhandled"
+			});
+			observer.notify(rawError);
+		};
+		const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError);
+		const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError);
+		return () => {
+			stopInstrumentingOnError();
+			stopInstrumentingOnUnhandledRejection();
+		};
+	});
 }
 function instrumentOnError(callback) {
-    return (0, instrumentMethod_1.instrumentMethod)((0, globalObject_1.getGlobalObject)(), 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
-        let stackTrace;
-        if (!(0, error_1.isError)(errorObj)) {
-            stackTrace = (0, computeStackTrace_1.computeStackTraceFromOnErrorMessage)(messageObj, url, line, column);
-        }
-        callback(errorObj !== null && errorObj !== void 0 ? errorObj : messageObj, stackTrace);
-    });
+	return require_instrumentMethod.instrumentMethod(_kubesense_kubesense_js_core_util.globalObject, "onerror", ({ parameters: [messageObj, url, line, column, errorObj] }) => {
+		let stackTrace;
+		if (!require_isError.isError(errorObj)) stackTrace = require_computeStackTrace.computeStackTraceFromOnErrorMessage(messageObj, url, line, column);
+		callback(errorObj ?? messageObj, stackTrace);
+	});
 }
 function instrumentUnhandledRejection(callback) {
-    return (0, instrumentMethod_1.instrumentMethod)((0, globalObject_1.getGlobalObject)(), 'onunhandledrejection', ({ parameters: [e] }) => {
-        callback(e.reason || 'Empty reason');
-    });
+	if (!require_addEventListener.isEventSupported(_kubesense_kubesense_js_core_util.globalObject.window, "unhandledrejection")) return { stop: require_functionUtils.noop };
+	return require_instrumentMethod.instrumentMethod(_kubesense_kubesense_js_core_util.globalObject, "onunhandledrejection", ({ parameters: [e] }) => {
+		callback(e.reason || "Empty reason");
+	});
 }
+//#endregion
+exports.instrumentOnError = instrumentOnError;
+exports.instrumentUnhandledRejection = instrumentUnhandledRejection;
+exports.trackRuntimeError = trackRuntimeError;
+
 //# sourceMappingURL=trackRuntimeError.js.map

package/cjs/domain/error/trackRuntimeError.js.map

@@ -1 +1 @@
-{"version":3,"file":"trackRuntimeError.js","sourceRoot":"","sources":["../../../src/domain/error/trackRuntimeError.ts"],"names":[],"mappings":";;AAYA,8CAqBC;AAED,8CAQC;AAED,oEAIC;AAjDD,mEAA+D;AAC/D,uDAAmD;AACnD,2DAAuD;AAEvD,gFAA8F;AAC9F,2DAA0D;AAC1D,mCAAkD;AAElD,+CAA0E;AAI1E,SAAgB,iBAAiB;IAC/B,OAAO,IAAI,uBAAU,CAAW,CAAC,QAAQ,EAAE,EAAE;QAC3C,MAAM,kBAAkB,GAAG,CAAC,aAAsB,EAAE,UAAuB,EAAE,EAAE;YAC7E,MAAM,QAAQ,GAAG,IAAA,uBAAe,EAAC;gBAC/B,UAAU;gBACV,aAAa;gBACb,WAAW,EAAE,IAAA,qBAAS,GAAE;gBACxB,cAAc,0CAAyB;gBACvC,MAAM,EAAE,yBAAW,CAAC,MAAM;gBAC1B,QAAQ,2CAAyB;aAClC,CAAC,CAAA;YACF,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QAC3B,CAAC,CAAA;QACD,MAAM,EAAE,IAAI,EAAE,wBAAwB,EAAE,GAAG,iBAAiB,CAAC,kBAAkB,CAAC,CAAA;QAChF,MAAM,EAAE,IAAI,EAAE,qCAAqC,EAAE,GAAG,4BAA4B,CAAC,kBAAkB,CAAC,CAAA;QAExG,OAAO,GAAG,EAAE;YACV,wBAAwB,EAAE,CAAA;YAC1B,qCAAqC,EAAE,CAAA;QACzC,CAAC,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,SAAgB,iBAAiB,CAAC,QAAgC;IAChE,OAAO,IAAA,mCAAgB,EAAC,IAAA,8BAAe,GAAE,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE,EAAE;QAClH,IAAI,UAAU,CAAA;QACd,IAAI,CAAC,IAAA,eAAO,EAAC,QAAQ,CAAC,EAAE,CAAC;YACvB,UAAU,GAAG,IAAA,uDAAmC,EAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAA;QACjF,CAAC;QACD,QAAQ,CAAC,QAAQ,aAAR,QAAQ,cAAR,QAAQ,GAAI,UAAU,EAAE,UAAU,CAAC,CAAA;IAC9C,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,SAAgB,4BAA4B,CAAC,QAAgC;IAC3E,OAAO,IAAA,mCAAgB,EAAC,IAAA,8BAAe,GAAE,EAAE,sBAAsB,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE;QACzF,QAAQ,CAAC,CAAC,CAAC,MAAM,IAAI,cAAc,CAAC,CAAA;IACtC,CAAC,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"trackRuntimeError.js","names":["Observable","computeRawError","clocksNow","ErrorSource","instrumentMethod","globalObject","isError","computeStackTraceFromOnErrorMessage","isEventSupported","noop"],"sources":["../../../src/domain/error/trackRuntimeError.ts"],"sourcesContent":["import { clocksNow } from '@kubesense/kubesense-js-core/time'\nimport { globalObject } from '@kubesense/kubesense-js-core/util'\nimport { instrumentMethod } from '../../tools/instrumentMethod'\nimport { Observable } from '../../tools/observable'\nimport type { StackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace'\nimport { DOM_EVENT, isEventSupported } from '../../browser/addEventListener'\nimport { noop } from '../../tools/utils/functionUtils'\nimport { computeRawError, isError } from './error'\nimport type { RawError } from './error.types'\nimport { ErrorHandling, ErrorSource, NonErrorPrefix } from './error.types'\n\nexport type UnhandledErrorCallback = (originalError: unknown, stackTrace?: StackTrace) => any\n\nexport function trackRuntimeError() {\n  return new Observable<RawError>((observer) => {\n    const handleRuntimeError = (originalError: unknown, stackTrace?: StackTrace) => {\n      const rawError = computeRawError({\n        stackTrace,\n        originalError,\n        startClocks: clocksNow(),\n        nonErrorPrefix: NonErrorPrefix.UNCAUGHT,\n        source: ErrorSource.SOURCE,\n        handling: ErrorHandling.UNHANDLED,\n      })\n      observer.notify(rawError)\n    }\n    const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError)\n    const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError)\n\n    return () => {\n      stopInstrumentingOnError()\n      stopInstrumentingOnUnhandledRejection()\n    }\n  })\n}\n\nexport function instrumentOnError(callback: UnhandledErrorCallback) {\n  return instrumentMethod(globalObject, 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {\n    let stackTrace\n    if (!isError(errorObj)) {\n      stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column)\n    }\n    callback(errorObj ?? messageObj, stackTrace)\n  })\n}\n\nexport function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {\n  // Salesforce LWS does not support the unhandledrejection event. https://developer.salesforce.com/tools/lws-distortion-viewer\n  if (!isEventSupported(globalObject.window, DOM_EVENT.UNHANDLED_REJECTION)) {\n    return { stop: noop }\n  }\n\n  return instrumentMethod(globalObject, 'onunhandledrejection', ({ parameters: [e] }) => {\n    callback(e.reason || 'Empty reason')\n  })\n}\n"],"mappings":";;;;;;;;;;;AAcA,SAAgB,oBAAoB;CAClC,OAAO,IAAIA,mBAAAA,YAAsB,aAAa;EAC5C,MAAM,sBAAsB,eAAwB,eAA4B;GAC9E,MAAM,WAAWC,cAAAA,gBAAgB;IAC/B;IACA;IACA,cAAA,GAAaC,kCAAAA,UAAAA,CAAU;IACvB,gBAAA;IACA,QAAQC,oBAAAA,YAAY;IACpB,UAAA;GACF,CAAC;GACD,SAAS,OAAO,QAAQ;EAC1B;EACA,MAAM,EAAE,MAAM,6BAA6B,kBAAkB,kBAAkB;EAC/E,MAAM,EAAE,MAAM,0CAA0C,6BAA6B,kBAAkB;EAEvG,aAAa;GACX,yBAAyB;GACzB,sCAAsC;EACxC;CACF,CAAC;AACH;AAEA,SAAgB,kBAAkB,UAAkC;CAClE,OAAOC,yBAAAA,iBAAiBC,kCAAAA,cAAc,YAAY,EAAE,YAAY,CAAC,YAAY,KAAK,MAAM,QAAQ,gBAAgB;EAC9G,IAAI;EACJ,IAAI,CAACC,gBAAAA,QAAQ,QAAQ,GACnB,aAAaC,0BAAAA,oCAAoC,YAAY,KAAK,MAAM,MAAM;EAEhF,SAAS,YAAY,YAAY,UAAU;CAC7C,CAAC;AACH;AAEA,SAAgB,6BAA6B,UAAkC;CAE7E,IAAI,CAACC,yBAAAA,iBAAiBH,kCAAAA,aAAa,QAAA,oBAAqC,GACtE,OAAO,EAAE,MAAMI,sBAAAA,KAAK;CAGtB,OAAOL,yBAAAA,iBAAiBC,kCAAAA,cAAc,yBAAyB,EAAE,YAAY,CAAC,SAAS;EACrF,SAAS,EAAE,UAAU,cAAc;CACrC,CAAC;AACH"}

package/cjs/domain/eventRateLimiter/createEventRateLimiter.d.ts

@@ -1,5 +1,4 @@
-import type { RawError } from '../error/error.types';
 export type EventRateLimiter = ReturnType<typeof createEventRateLimiter>;
-export declare function createEventRateLimiter(eventType: string, onLimitReached: (limitError: RawError) => void, limit?: number): {
+export declare function createEventRateLimiter(eventType: string, onLimitReached: (message: string) => void, limit?: number): {
     isLimitReached(): boolean;
 };

package/cjs/domain/eventRateLimiter/createEventRateLimiter.js

@@ -1,41 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEventRateLimiter = createEventRateLimiter;
-const timer_1 = require("../../tools/timer");
-const timeUtils_1 = require("../../tools/utils/timeUtils");
-const error_types_1 = require("../error/error.types");
-// Limit the maximum number of actions, errors and logs per minutes
-const EVENT_RATE_LIMIT = 3000;
+const require_timer = require("../../tools/timer.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/eventRateLimiter/createEventRateLimiter.ts
+const EVENT_RATE_LIMIT = 3e3;
 function createEventRateLimiter(eventType, onLimitReached, limit = EVENT_RATE_LIMIT) {
-    let eventCount = 0;
-    let allowNextEvent = false;
-    return {
-        isLimitReached() {
-            if (eventCount === 0) {
-                (0, timer_1.setTimeout)(() => {
-                    eventCount = 0;
-                }, timeUtils_1.ONE_MINUTE);
-            }
-            eventCount += 1;
-            if (eventCount <= limit || allowNextEvent) {
-                allowNextEvent = false;
-                return false;
-            }
-            if (eventCount === limit + 1) {
-                allowNextEvent = true;
-                try {
-                    onLimitReached({
-                        message: `Reached max number of ${eventType}s by minute: ${limit}`,
-                        source: error_types_1.ErrorSource.AGENT,
-                        startClocks: (0, timeUtils_1.clocksNow)(),
-                    });
-                }
-                finally {
-                    allowNextEvent = false;
-                }
-            }
-            return true;
-        },
-    };
+	let eventCount = 0;
+	let allowNextEvent = false;
+	return { isLimitReached() {
+		if (eventCount === 0) require_timer.setTimeout(() => {
+			eventCount = 0;
+		}, _kubesense_kubesense_js_core_time.ONE_MINUTE);
+		eventCount += 1;
+		if (eventCount <= limit || allowNextEvent) {
+			allowNextEvent = false;
+			return false;
+		}
+		if (eventCount === limit + 1) {
+			allowNextEvent = true;
+			try {
+				onLimitReached(`Reached max number of ${eventType}s by minute: ${limit}`);
+			} finally {
+				allowNextEvent = false;
+			}
+		}
+		return true;
+	} };
 }
+//#endregion
+exports.createEventRateLimiter = createEventRateLimiter;
+
 //# sourceMappingURL=createEventRateLimiter.js.map

package/cjs/domain/eventRateLimiter/createEventRateLimiter.js.map

@@ -1 +1 @@
-{"version":3,"file":"createEventRateLimiter.js","sourceRoot":"","sources":["../../../src/domain/eventRateLimiter/createEventRateLimiter.ts"],"names":[],"mappings":";;AAUA,wDAsCC;AAhDD,6CAA8C;AAC9C,2DAAmE;AAEnE,sDAAkD;AAIlD,mEAAmE;AACnE,MAAM,gBAAgB,GAAG,IAAI,CAAA;AAE7B,SAAgB,sBAAsB,CACpC,SAAiB,EACjB,cAA8C,EAC9C,KAAK,GAAG,gBAAgB;IAExB,IAAI,UAAU,GAAG,CAAC,CAAA;IAClB,IAAI,cAAc,GAAG,KAAK,CAAA;IAE1B,OAAO;QACL,cAAc;YACZ,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;gBACrB,IAAA,kBAAU,EAAC,GAAG,EAAE;oBACd,UAAU,GAAG,CAAC,CAAA;gBAChB,CAAC,EAAE,sBAAU,CAAC,CAAA;YAChB,CAAC;YAED,UAAU,IAAI,CAAC,CAAA;YACf,IAAI,UAAU,IAAI,KAAK,IAAI,cAAc,EAAE,CAAC;gBAC1C,cAAc,GAAG,KAAK,CAAA;gBACtB,OAAO,KAAK,CAAA;YACd,CAAC;YAED,IAAI,UAAU,KAAK,KAAK,GAAG,CAAC,EAAE,CAAC;gBAC7B,cAAc,GAAG,IAAI,CAAA;gBACrB,IAAI,CAAC;oBACH,cAAc,CAAC;wBACb,OAAO,EAAE,yBAAyB,SAAS,gBAAgB,KAAK,EAAE;wBAClE,MAAM,EAAE,yBAAW,CAAC,KAAK;wBACzB,WAAW,EAAE,IAAA,qBAAS,GAAE;qBACzB,CAAC,CAAA;gBACJ,CAAC;wBAAS,CAAC;oBACT,cAAc,GAAG,KAAK,CAAA;gBACxB,CAAC;YACH,CAAC;YAED,OAAO,IAAI,CAAA;QACb,CAAC;KACF,CAAA;AACH,CAAC"}
+{"version":3,"file":"createEventRateLimiter.js","names":["ONE_MINUTE"],"sources":["../../../src/domain/eventRateLimiter/createEventRateLimiter.ts"],"sourcesContent":["import { ONE_MINUTE } from '@kubesense/kubesense-js-core/time'\nimport { setTimeout } from '../../tools/timer'\n\nexport type EventRateLimiter = ReturnType<typeof createEventRateLimiter>\n\n// Limit the maximum number of actions, errors and logs per minutes\nconst EVENT_RATE_LIMIT = 3000\n\nexport function createEventRateLimiter(\n  eventType: string,\n  onLimitReached: (message: string) => void,\n  limit = EVENT_RATE_LIMIT\n) {\n  let eventCount = 0\n  let allowNextEvent = false\n\n  return {\n    isLimitReached() {\n      if (eventCount === 0) {\n        setTimeout(() => {\n          eventCount = 0\n        }, ONE_MINUTE)\n      }\n\n      eventCount += 1\n      if (eventCount <= limit || allowNextEvent) {\n        allowNextEvent = false\n        return false\n      }\n\n      if (eventCount === limit + 1) {\n        allowNextEvent = true\n        try {\n          onLimitReached(`Reached max number of ${eventType}s by minute: ${limit}`)\n        } finally {\n          allowNextEvent = false\n        }\n      }\n\n      return true\n    },\n  }\n}\n"],"mappings":";;;AAMA,MAAM,mBAAmB;AAEzB,SAAgB,uBACd,WACA,gBACA,QAAQ,kBACR;CACA,IAAI,aAAa;CACjB,IAAI,iBAAiB;CAErB,OAAO,EACL,iBAAiB;EACf,IAAI,eAAe,GACjB,cAAA,iBAAiB;GACf,aAAa;EACf,GAAGA,kCAAAA,UAAU;EAGf,cAAc;EACd,IAAI,cAAc,SAAS,gBAAgB;GACzC,iBAAiB;GACjB,OAAO;EACT;EAEA,IAAI,eAAe,QAAQ,GAAG;GAC5B,iBAAiB;GACjB,IAAI;IACF,eAAe,yBAAyB,UAAU,eAAe,OAAO;GAC1E,UAAU;IACR,iBAAiB;GACnB;EACF;EAEA,OAAO;CACT,EACF;AACF"}

package/cjs/domain/extension/extensionUtils.js

@@ -1,30 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXTENSION_PREFIXES = void 0;
-exports.containsExtensionUrl = containsExtensionUrl;
-exports.isUnsupportedExtensionEnvironment = isUnsupportedExtensionEnvironment;
-exports.EXTENSION_PREFIXES = ['chrome-extension://', 'moz-extension://'];
+//#region src/domain/extension/extensionUtils.ts
+const EXTENSION_PREFIXES = ["chrome-extension://", "moz-extension://"];
 function containsExtensionUrl(str) {
-    return exports.EXTENSION_PREFIXES.some((prefix) => str.includes(prefix));
+	return EXTENSION_PREFIXES.some((prefix) => str.includes(prefix));
 }
 /**
- * Utility function to detect if the SDK is being initialized in an unsupported browser extension environment.
- *
- * @param windowLocation - The current window location to check
- * @param stack - The error stack to check for extension URLs
- * @returns true if running in an unsupported browser extension environment
- */
-function isUnsupportedExtensionEnvironment(windowLocation, stack = '') {
-    // If the page itself is an extension page.
-    if (containsExtensionUrl(windowLocation)) {
-        return false;
-    }
-    // Since we generate the error on the init, we check the 2nd frame line.
-    const frameLines = stack.split('\n').filter((line) => {
-        const trimmedLine = line.trim();
-        return trimmedLine.length && /^at\s+|@/.test(trimmedLine);
-    });
-    const target = frameLines[1] || '';
-    return containsExtensionUrl(target);
+* Utility function to detect if the SDK is being initialized in an unsupported browser extension environment.
+*
+* @param windowLocation - The current window location to check
+* @param stack - The error stack to check for extension URLs
+* @returns true if running in an unsupported browser extension environment
+*/
+function isUnsupportedExtensionEnvironment(windowLocation, stack = "") {
+	if (containsExtensionUrl(windowLocation)) return false;
+	return containsExtensionUrl(stack.split("\n").filter((line) => {
+		const trimmedLine = line.trim();
+		return trimmedLine.length && /^at\s+|@/.test(trimmedLine);
+	})[1] || "");
 }
+//#endregion
+exports.EXTENSION_PREFIXES = EXTENSION_PREFIXES;
+exports.containsExtensionUrl = containsExtensionUrl;
+exports.isUnsupportedExtensionEnvironment = isUnsupportedExtensionEnvironment;
+
 //# sourceMappingURL=extensionUtils.js.map

package/cjs/domain/extension/extensionUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"extensionUtils.js","sourceRoot":"","sources":["../../../src/domain/extension/extensionUtils.ts"],"names":[],"mappings":";;;AAEA,oDAEC;AASD,8EAcC;AA3BY,QAAA,kBAAkB,GAAG,CAAC,qBAAqB,EAAE,kBAAkB,CAAC,CAAA;AAE7E,SAAgB,oBAAoB,CAAC,GAAW;IAC9C,OAAO,0BAAkB,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAA;AAClE,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,iCAAiC,CAAC,cAAsB,EAAE,QAAgB,EAAE;IAC1F,2CAA2C;IAC3C,IAAI,oBAAoB,CAAC,cAAc,CAAC,EAAE,CAAC;QACzC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,wEAAwE;IACxE,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;QACnD,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,EAAE,CAAA;QAC/B,OAAO,WAAW,CAAC,MAAM,IAAI,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;IAC3D,CAAC,CAAC,CAAA;IACF,MAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;IAElC,OAAO,oBAAoB,CAAC,MAAM,CAAC,CAAA;AACrC,CAAC"}
+{"version":3,"file":"extensionUtils.js","names":[],"sources":["../../../src/domain/extension/extensionUtils.ts"],"sourcesContent":["export const EXTENSION_PREFIXES = ['chrome-extension://', 'moz-extension://']\n\nexport function containsExtensionUrl(str: string): boolean {\n  return EXTENSION_PREFIXES.some((prefix) => str.includes(prefix))\n}\n\n/**\n * Utility function to detect if the SDK is being initialized in an unsupported browser extension environment.\n *\n * @param windowLocation - The current window location to check\n * @param stack - The error stack to check for extension URLs\n * @returns true if running in an unsupported browser extension environment\n */\nexport function isUnsupportedExtensionEnvironment(windowLocation: string, stack: string = '') {\n  // If the page itself is an extension page.\n  if (containsExtensionUrl(windowLocation)) {\n    return false\n  }\n\n  // Since we generate the error on the init, we check the 2nd frame line.\n  const frameLines = stack.split('\\n').filter((line) => {\n    const trimmedLine = line.trim()\n    return trimmedLine.length && /^at\\s+|@/.test(trimmedLine)\n  })\n  const target = frameLines[1] || ''\n\n  return containsExtensionUrl(target)\n}\n"],"mappings":";AAAA,MAAa,qBAAqB,CAAC,uBAAuB,kBAAkB;AAE5E,SAAgB,qBAAqB,KAAsB;CACzD,OAAO,mBAAmB,MAAM,WAAW,IAAI,SAAS,MAAM,CAAC;AACjE;;;;;;;;AASA,SAAgB,kCAAkC,gBAAwB,QAAgB,IAAI;CAE5F,IAAI,qBAAqB,cAAc,GACrC,OAAO;CAUT,OAAO,qBANY,MAAM,MAAM,IAAI,CAAC,CAAC,QAAQ,SAAS;EACpD,MAAM,cAAc,KAAK,KAAK;EAC9B,OAAO,YAAY,UAAU,WAAW,KAAK,WAAW;CAC1D,CACwB,CAAC,CAAC,MAAM,EAEE;AACpC"}

package/cjs/domain/geo/geocoding.js

@@ -0,0 +1,64 @@
+const require_fetch = require("../../browser/fetch.js");
+//#region src/domain/geo/geocoding.ts
+const NOMINATIM_BASE_URL = "https://nominatim.openstreetmap.org";
+function reverseGeocode(latitude, longitude, onSuccess, onError, options) {
+	const baseUrl = options?.baseUrl ?? NOMINATIM_BASE_URL;
+	const userAgent = options?.userAgent ?? "KubesenseBrowserSDK/1.0";
+	const url = `${baseUrl}/reverse?lat=${latitude}&lon=${longitude}&format=json&addressdetails=1&timezone=1`;
+	require_fetch.fetch(url, { headers: {
+		"User-Agent": userAgent,
+		Accept: "application/json"
+	} }).then((response) => {
+		if (!response.ok) throw new Error(`Geocoding failed: ${response.status}`);
+		return response.json();
+	}).then((data) => {
+		onSuccess(parseGeocodingResponse(data));
+	}).catch((error) => {
+		onError?.({
+			code: -1,
+			message: error.message || "Failed to reverse geocode"
+		});
+	});
+}
+function reverseGeocodeWithPosition(position, onSuccess, onError, options) {
+	reverseGeocode(position.latitude, position.longitude, onSuccess, onError, options);
+}
+function parseGeocodingResponse(data) {
+	const address = data.address || {};
+	return {
+		city: address.city ?? address.town ?? address.village ?? address.municipality,
+		state: address.state,
+		stateCode: address.state_code,
+		country: address.country,
+		countryCode: address.country_code?.toUpperCase(),
+		continent: address.continent,
+		timezone: data.timezone,
+		locality: address.locality ?? address.suburb ?? address.neighborhood,
+		postalCode: address.postcode,
+		raw: data
+	};
+}
+function getLocationName(result) {
+	const parts = [];
+	if (result.locality) parts.push(result.locality);
+	if (result.city) parts.push(result.city);
+	if (result.state) parts.push(result.state);
+	if (result.country) parts.push(result.country);
+	return parts.join(", ");
+}
+function reverseGeocodeAsync(latitude, longitude, options) {
+	return new Promise((resolve, reject) => {
+		reverseGeocode(latitude, longitude, resolve, (error) => reject(new Error(error.message)), options);
+	});
+}
+function reverseGeocodeWithPositionAsync(position, options) {
+	return reverseGeocodeAsync(position.latitude, position.longitude, options);
+}
+//#endregion
+exports.getLocationName = getLocationName;
+exports.reverseGeocode = reverseGeocode;
+exports.reverseGeocodeAsync = reverseGeocodeAsync;
+exports.reverseGeocodeWithPosition = reverseGeocodeWithPosition;
+exports.reverseGeocodeWithPositionAsync = reverseGeocodeWithPositionAsync;
+
+//# sourceMappingURL=geocoding.js.map

package/cjs/domain/geo/geocoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geocoding.js","names":[],"sources":["../../../src/domain/geo/geocoding.ts"],"sourcesContent":["import { fetch } from '../../browser/fetch'\nimport type { GeoPosition } from './geolocation'\n\nexport interface GeoLocation {\n  latitude: number\n  longitude: number\n  accuracy?: number\n}\n\nexport interface GeoLocationResult {\n  city?: string\n  state?: string\n  stateCode?: string\n  country?: string\n  countryCode?: string\n  continent?: string\n  timezone?: string\n  locality?: string\n  postalCode?: string\n  raw?: GeocodingResponse\n}\n\nexport interface GeocodingError {\n  code: number\n  message: string\n}\n\ninterface GeocodingResponse {\n  address: {\n    city?: string\n    town?: string\n    village?: string\n    municipality?: string\n    state?: string\n    state_code?: string\n    country?: string\n    country_code?: string\n    continent?: string\n    postcode?: string\n    locality?: string\n    suburb?: string\n    neighborhood?: string\n  }\n  timezone?: string\n  lat: string\n  lon: string\n}\n\nconst NOMINATIM_BASE_URL = 'https://nominatim.openstreetmap.org'\n\nexport function reverseGeocode(\n  latitude: number,\n  longitude: number,\n  onSuccess: (result: GeoLocationResult) => void,\n  onError?: (error: GeocodingError) => void,\n  options?: {\n    baseUrl?: string\n    userAgent?: string\n  }\n): void {\n  const baseUrl = options?.baseUrl ?? NOMINATIM_BASE_URL\n  const userAgent = options?.userAgent ?? 'KubesenseBrowserSDK/1.0'\n\n  const url = `${baseUrl}/reverse?lat=${latitude}&lon=${longitude}&format=json&addressdetails=1&timezone=1`\n\n  fetch(url, {\n    headers: {\n      'User-Agent': userAgent,\n      Accept: 'application/json',\n    },\n  })\n    .then((response) => {\n      if (!response.ok) {\n        throw new Error(`Geocoding failed: ${response.status}`)\n      }\n      return response.json()\n    })\n    .then((data: GeocodingResponse) => {\n      const result = parseGeocodingResponse(data)\n      onSuccess(result)\n    })\n    .catch((error) => {\n      onError?.({\n        code: -1,\n        message: error.message || 'Failed to reverse geocode',\n      })\n    })\n}\n\nexport function reverseGeocodeWithPosition(\n  position: GeoPosition,\n  onSuccess: (result: GeoLocationResult) => void,\n  onError?: (error: GeocodingError) => void,\n  options?: {\n    baseUrl?: string\n    userAgent?: string\n  }\n): void {\n  reverseGeocode(position.latitude, position.longitude, onSuccess, onError, options)\n}\n\nfunction parseGeocodingResponse(data: GeocodingResponse): GeoLocationResult {\n  const address = data.address || {}\n\n  return {\n    city: address.city ?? address.town ?? address.village ?? address.municipality,\n    state: address.state,\n    stateCode: address.state_code,\n    country: address.country,\n    countryCode: address.country_code?.toUpperCase(),\n    continent: address.continent,\n    timezone: data.timezone,\n    locality: address.locality ?? address.suburb ?? address.neighborhood,\n    postalCode: address.postcode,\n    raw: data,\n  }\n}\n\nexport function getLocationName(result: GeoLocationResult): string {\n  const parts: string[] = []\n\n  if (result.locality) {\n    parts.push(result.locality)\n  }\n  if (result.city) {\n    parts.push(result.city)\n  }\n  if (result.state) {\n    parts.push(result.state)\n  }\n  if (result.country) {\n    parts.push(result.country)\n  }\n\n  return parts.join(', ')\n}\n\nexport function reverseGeocodeAsync(\n  latitude: number,\n  longitude: number,\n  options?: {\n    baseUrl?: string\n    userAgent?: string\n  }\n): Promise<GeoLocationResult> {\n  return new Promise((resolve, reject) => {\n    reverseGeocode(latitude, longitude, resolve, (error) => reject(new Error(error.message)), options)\n  })\n}\n\nexport function reverseGeocodeWithPositionAsync(\n  position: GeoPosition,\n  options?: {\n    baseUrl?: string\n    userAgent?: string\n  }\n): Promise<GeoLocationResult> {\n  return reverseGeocodeAsync(position.latitude, position.longitude, options)\n}\n"],"mappings":";;AAgDA,MAAM,qBAAqB;AAE3B,SAAgB,eACd,UACA,WACA,WACA,SACA,SAIM;CACN,MAAM,UAAU,SAAS,WAAW;CACpC,MAAM,YAAY,SAAS,aAAa;CAExC,MAAM,MAAM,GAAG,QAAQ,eAAe,SAAS,OAAO,UAAU;CAEhE,cAAA,MAAM,KAAK,EACT,SAAS;EACP,cAAc;EACd,QAAQ;CACV,EACF,CAAC,CAAC,CACC,MAAM,aAAa;EAClB,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MAAM,qBAAqB,SAAS,QAAQ;EAExD,OAAO,SAAS,KAAK;CACvB,CAAC,CAAC,CACD,MAAM,SAA4B;EAEjC,UADe,uBAAuB,IACvB,CAAC;CAClB,CAAC,CAAC,CACD,OAAO,UAAU;EAChB,UAAU;GACR,MAAM;GACN,SAAS,MAAM,WAAW;EAC5B,CAAC;CACH,CAAC;AACL;AAEA,SAAgB,2BACd,UACA,WACA,SACA,SAIM;CACN,eAAe,SAAS,UAAU,SAAS,WAAW,WAAW,SAAS,OAAO;AACnF;AAEA,SAAS,uBAAuB,MAA4C;CAC1E,MAAM,UAAU,KAAK,WAAW,CAAC;CAEjC,OAAO;EACL,MAAM,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,WAAW,QAAQ;EACjE,OAAO,QAAQ;EACf,WAAW,QAAQ;EACnB,SAAS,QAAQ;EACjB,aAAa,QAAQ,cAAc,YAAY;EAC/C,WAAW,QAAQ;EACnB,UAAU,KAAK;EACf,UAAU,QAAQ,YAAY,QAAQ,UAAU,QAAQ;EACxD,YAAY,QAAQ;EACpB,KAAK;CACP;AACF;AAEA,SAAgB,gBAAgB,QAAmC;CACjE,MAAM,QAAkB,CAAC;CAEzB,IAAI,OAAO,UACT,MAAM,KAAK,OAAO,QAAQ;CAE5B,IAAI,OAAO,MACT,MAAM,KAAK,OAAO,IAAI;CAExB,IAAI,OAAO,OACT,MAAM,KAAK,OAAO,KAAK;CAEzB,IAAI,OAAO,SACT,MAAM,KAAK,OAAO,OAAO;CAG3B,OAAO,MAAM,KAAK,IAAI;AACxB;AAEA,SAAgB,oBACd,UACA,WACA,SAI4B;CAC5B,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,eAAe,UAAU,WAAW,UAAU,UAAU,OAAO,IAAI,MAAM,MAAM,OAAO,CAAC,GAAG,OAAO;CACnG,CAAC;AACH;AAEA,SAAgB,gCACd,UACA,SAI4B;CAC5B,OAAO,oBAAoB,SAAS,UAAU,SAAS,WAAW,OAAO;AAC3E"}

package/cjs/domain/geo/geolocation.js

@@ -0,0 +1,72 @@
+//#region src/domain/geo/geolocation.ts
+function canUseGeoLocation() {
+	return "geolocation" in navigator;
+}
+function getCurrentPosition(onSuccess, onError, options) {
+	if (!canUseGeoLocation()) {
+		onError?.({
+			code: -1,
+			message: "Geolocation is not supported by this browser"
+		});
+		return;
+	}
+	navigator.geolocation.getCurrentPosition((position) => {
+		onSuccess({
+			latitude: position.coords.latitude,
+			longitude: position.coords.longitude,
+			accuracy: position.coords.accuracy,
+			altitude: position.coords.altitude ?? void 0,
+			altitudeAccuracy: position.coords.altitudeAccuracy ?? void 0,
+			heading: position.coords.heading ?? void 0,
+			speed: position.coords.speed ?? void 0
+		});
+	}, (error) => {
+		onError?.({
+			code: error.code,
+			message: error.message
+		});
+	}, {
+		enableHighAccuracy: options?.enableHighAccuracy ?? false,
+		timeout: options?.timeout ?? 1e4,
+		maximumAge: options?.maximumAge ?? 0
+	});
+}
+function watchPosition(onSuccess, onError, options) {
+	if (!canUseGeoLocation()) {
+		onError?.({
+			code: -1,
+			message: "Geolocation is not supported by this browser"
+		});
+		return -1;
+	}
+	return navigator.geolocation.watchPosition((position) => {
+		onSuccess({
+			latitude: position.coords.latitude,
+			longitude: position.coords.longitude,
+			accuracy: position.coords.accuracy,
+			altitude: position.coords.altitude ?? void 0,
+			altitudeAccuracy: position.coords.altitudeAccuracy ?? void 0,
+			heading: position.coords.heading ?? void 0,
+			speed: position.coords.speed ?? void 0
+		});
+	}, (error) => {
+		onError?.({
+			code: error.code,
+			message: error.message
+		});
+	}, {
+		enableHighAccuracy: options?.enableHighAccuracy ?? false,
+		timeout: options?.timeout ?? 1e4,
+		maximumAge: options?.maximumAge ?? 0
+	});
+}
+function clearWatch(watchId) {
+	if (canUseGeoLocation() && watchId >= 0) navigator.geolocation.clearWatch(watchId);
+}
+//#endregion
+exports.canUseGeoLocation = canUseGeoLocation;
+exports.clearWatch = clearWatch;
+exports.getCurrentPosition = getCurrentPosition;
+exports.watchPosition = watchPosition;
+
+//# sourceMappingURL=geolocation.js.map

package/cjs/domain/geo/geolocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geolocation.js","names":[],"sources":["../../../src/domain/geo/geolocation.ts"],"sourcesContent":["export interface GeoPosition {\n  latitude: number\n  longitude: number\n  accuracy: number\n  altitude?: number\n  altitudeAccuracy?: number\n  heading?: number\n  speed?: number\n}\n\nexport interface GeoPositionError {\n  code: number\n  message: string\n}\n\nexport type GeoPositionCallback = (position: GeoPosition) => void\nexport type GeoErrorCallback = (error: GeoPositionError) => void\n\nexport interface GeoLocationOptions {\n  enableHighAccuracy?: boolean\n  timeout?: number\n  maximumAge?: number\n}\n\nexport function canUseGeoLocation(): boolean {\n  return 'geolocation' in navigator\n}\n\nexport function getCurrentPosition(\n  onSuccess: GeoPositionCallback,\n  onError?: GeoErrorCallback,\n  options?: GeoLocationOptions\n): void {\n  if (!canUseGeoLocation()) {\n    onError?.({\n      code: -1,\n      message: 'Geolocation is not supported by this browser',\n    })\n    return\n  }\n\n  navigator.geolocation.getCurrentPosition(\n    (position) => {\n      onSuccess({\n        latitude: position.coords.latitude,\n        longitude: position.coords.longitude,\n        accuracy: position.coords.accuracy,\n        altitude: position.coords.altitude ?? undefined,\n        altitudeAccuracy: position.coords.altitudeAccuracy ?? undefined,\n        heading: position.coords.heading ?? undefined,\n        speed: position.coords.speed ?? undefined,\n      })\n    },\n    (error) => {\n      onError?.({\n        code: error.code,\n        message: error.message,\n      })\n    },\n    {\n      enableHighAccuracy: options?.enableHighAccuracy ?? false,\n      timeout: options?.timeout ?? 10000,\n      maximumAge: options?.maximumAge ?? 0,\n    }\n  )\n}\n\nexport function watchPosition(\n  onSuccess: GeoPositionCallback,\n  onError?: GeoErrorCallback,\n  options?: GeoLocationOptions\n): number {\n  if (!canUseGeoLocation()) {\n    onError?.({\n      code: -1,\n      message: 'Geolocation is not supported by this browser',\n    })\n    return -1\n  }\n\n  return navigator.geolocation.watchPosition(\n    (position) => {\n      onSuccess({\n        latitude: position.coords.latitude,\n        longitude: position.coords.longitude,\n        accuracy: position.coords.accuracy,\n        altitude: position.coords.altitude ?? undefined,\n        altitudeAccuracy: position.coords.altitudeAccuracy ?? undefined,\n        heading: position.coords.heading ?? undefined,\n        speed: position.coords.speed ?? undefined,\n      })\n    },\n    (error) => {\n      onError?.({\n        code: error.code,\n        message: error.message,\n      })\n    },\n    {\n      enableHighAccuracy: options?.enableHighAccuracy ?? false,\n      timeout: options?.timeout ?? 10000,\n      maximumAge: options?.maximumAge ?? 0,\n    }\n  )\n}\n\nexport function clearWatch(watchId: number): void {\n  if (canUseGeoLocation() && watchId >= 0) {\n    navigator.geolocation.clearWatch(watchId)\n  }\n}\n"],"mappings":";AAwBA,SAAgB,oBAA6B;CAC3C,OAAO,iBAAiB;AAC1B;AAEA,SAAgB,mBACd,WACA,SACA,SACM;CACN,IAAI,CAAC,kBAAkB,GAAG;EACxB,UAAU;GACR,MAAM;GACN,SAAS;EACX,CAAC;EACD;CACF;CAEA,UAAU,YAAY,oBACnB,aAAa;EACZ,UAAU;GACR,UAAU,SAAS,OAAO;GAC1B,WAAW,SAAS,OAAO;GAC3B,UAAU,SAAS,OAAO;GAC1B,UAAU,SAAS,OAAO,YAAY,KAAA;GACtC,kBAAkB,SAAS,OAAO,oBAAoB,KAAA;GACtD,SAAS,SAAS,OAAO,WAAW,KAAA;GACpC,OAAO,SAAS,OAAO,SAAS,KAAA;EAClC,CAAC;CACH,IACC,UAAU;EACT,UAAU;GACR,MAAM,MAAM;GACZ,SAAS,MAAM;EACjB,CAAC;CACH,GACA;EACE,oBAAoB,SAAS,sBAAsB;EACnD,SAAS,SAAS,WAAW;EAC7B,YAAY,SAAS,cAAc;CACrC,CACF;AACF;AAEA,SAAgB,cACd,WACA,SACA,SACQ;CACR,IAAI,CAAC,kBAAkB,GAAG;EACxB,UAAU;GACR,MAAM;GACN,SAAS;EACX,CAAC;EACD,OAAO;CACT;CAEA,OAAO,UAAU,YAAY,eAC1B,aAAa;EACZ,UAAU;GACR,UAAU,SAAS,OAAO;GAC1B,WAAW,SAAS,OAAO;GAC3B,UAAU,SAAS,OAAO;GAC1B,UAAU,SAAS,OAAO,YAAY,KAAA;GACtC,kBAAkB,SAAS,OAAO,oBAAoB,KAAA;GACtD,SAAS,SAAS,OAAO,WAAW,KAAA;GACpC,OAAO,SAAS,OAAO,SAAS,KAAA;EAClC,CAAC;CACH,IACC,UAAU;EACT,UAAU;GACR,MAAM,MAAM;GACZ,SAAS,MAAM;EACjB,CAAC;CACH,GACA;EACE,oBAAoB,SAAS,sBAAsB;EACnD,SAAS,SAAS,WAAW;EAC7B,YAAY,SAAS,cAAc;CACrC,CACF;AACF;AAEA,SAAgB,WAAW,SAAuB;CAChD,IAAI,kBAAkB,KAAK,WAAW,GACpC,UAAU,YAAY,WAAW,OAAO;AAE5C"}

package/cjs/domain/report/reportObservable.d.ts

@@ -1,5 +1,4 @@
 import { Observable } from '../../tools/observable';
-import type { Configuration } from '../configuration';
 import type { RawError } from '../error/error.types';
 import type { InterventionReport, DeprecationReport } from './browser.types';
 export declare const RawReportType: {
@@ -11,4 +10,4 @@ export type RawReportType = (typeof RawReportType)[keyof typeof RawReportType];
 export type RawReportError = RawError & {
     originalError: SecurityPolicyViolationEvent | DeprecationReport | InterventionReport;
 };
-export declare function initReportObservable(configuration: Configuration, apis: RawReportType[]): Observable<RawReportError>;
+export declare function initReportObservable(apis: RawReportType[]): Observable<RawReportError>;