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

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

@@ -1,5 +1,4 @@
 import type { Observable, RawError } from '@kubesense/kubesense-browser-core';
-import type { RumConfiguration } from '../configuration';
-export declare function trackReportError(configuration: RumConfiguration, errorObservable: Observable<RawError>): {
+export declare function trackReportError(errorObservable: Observable<RawError>): {
     stop: () => void;
 };

package/cjs/domain/error/trackReportError.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackReportError = trackReportError;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-function trackReportError(configuration, errorObservable) {
-    const subscription = (0, kubesense_browser_core_1.initReportObservable)(configuration, [
-        kubesense_browser_core_1.RawReportType.cspViolation,
-        kubesense_browser_core_1.RawReportType.intervention,
-    ]).subscribe((rawError) => errorObservable.notify(rawError));
-    return {
-        stop: () => {
-            subscription.unsubscribe();
-        },
-    };
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/error/trackReportError.ts
+function trackReportError(errorObservable) {
+	const subscription = (0, _kubesense_kubesense_browser_core.initReportObservable)([_kubesense_kubesense_browser_core.RawReportType.cspViolation, _kubesense_kubesense_browser_core.RawReportType.intervention]).subscribe((rawError) => errorObservable.notify(rawError));
+	return { stop: () => {
+		subscription.unsubscribe();
+	} };
 }
+//#endregion
+exports.trackReportError = trackReportError;
+
 //# sourceMappingURL=trackReportError.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"trackReportError.js","sourceRoot":"","sources":["../../../src/domain/error/trackReportError.ts"],"names":[],"mappings":";;AAIA,4CAWC;AAdD,8EAAuF;AAGvF,SAAgB,gBAAgB,CAAC,aAA+B,EAAE,eAAqC;IACrG,MAAM,YAAY,GAAG,IAAA,6CAAoB,EAAC,aAAa,EAAE;QACvD,sCAAa,CAAC,YAAY;QAC1B,sCAAa,CAAC,YAAY;KAC3B,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;IAE5D,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,YAAY,CAAC,WAAW,EAAE,CAAA;QAC5B,CAAC;KACF,CAAA;AACH,CAAC"}
+{"version":3,"file":"trackReportError.js","names":["initReportObservable","RawReportType"],"sources":["../../../src/domain/error/trackReportError.ts"],"sourcesContent":["import type { Observable, RawError } from '@kubesense/kubesense-browser-core'\nimport { initReportObservable, RawReportType } from '@kubesense/kubesense-browser-core'\nexport function trackReportError(errorObservable: Observable<RawError>) {\n  const subscription = initReportObservable([RawReportType.cspViolation, RawReportType.intervention]).subscribe(\n    (rawError) => errorObservable.notify(rawError)\n  )\n\n  return {\n    stop: () => {\n      subscription.unsubscribe()\n    },\n  }\n}\n"],"mappings":";;AAEA,SAAgB,iBAAiB,iBAAuC;CACtE,MAAM,gBAAA,GAAeA,kCAAAA,qBAAAA,CAAqB,CAACC,kCAAAA,cAAc,cAAcA,kCAAAA,cAAc,YAAY,CAAC,CAAC,CAAC,WACjG,aAAa,gBAAgB,OAAO,QAAQ,CAC/C;CAEA,OAAO,EACL,YAAY;EACV,aAAa,YAAY;CAC3B,EACF;AACF"}

package/cjs/domain/event/eventCollection.d.ts

@@ -1,4 +1,5 @@
-import type { Context, Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { Duration, RelativeTime } from '@kubesense/kubesense-js-core/time';
+import type { Context } from '@kubesense/kubesense-browser-core';
 import type { RumEventDomainContext } from '../../domainContext.types';
 import type { LifeCycle } from '../lifeCycle';
 import type { RawRumActionEvent, RawRumErrorEvent, RawRumLongAnimationFrameEvent, RawRumLongTaskEvent, RawRumResourceEvent, RawRumVitalEvent } from '../../rawRumEvent.types';

package/cjs/domain/event/eventCollection.js

@@ -1,27 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startEventCollection = startEventCollection;
-const rawRumEvent_types_1 = require("../../rawRumEvent.types");
+const require_rawRumEvent_types = require("../../rawRumEvent.types.js");
+require("../lifeCycle.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/event/eventCollection.ts
 const allowedEventTypes = [
-    rawRumEvent_types_1.RumEventType.ACTION,
-    rawRumEvent_types_1.RumEventType.ERROR,
-    rawRumEvent_types_1.RumEventType.LONG_TASK,
-    rawRumEvent_types_1.RumEventType.RESOURCE,
-    rawRumEvent_types_1.RumEventType.VITAL,
+	require_rawRumEvent_types.RumEventType.ACTION,
+	require_rawRumEvent_types.RumEventType.ERROR,
+	require_rawRumEvent_types.RumEventType.LONG_TASK,
+	require_rawRumEvent_types.RumEventType.RESOURCE,
+	require_rawRumEvent_types.RumEventType.VITAL
 ];
 function startEventCollection(lifeCycle) {
-    return {
-        addEvent: (startTime, event, domainContext, duration) => {
-            if (!allowedEventTypes.includes(event.type)) {
-                return;
-            }
-            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {
-                startTime,
-                rawRumEvent: event,
-                domainContext,
-                duration,
-            });
-        },
-    };
+	return { addEvent: (startTime, event, domainContext, duration) => {
+		if (!allowedEventTypes.includes(event.type)) return;
+		lifeCycle.notify(13, {
+			startClocks: (0, _kubesense_kubesense_js_core_time.relativeToClocks)(startTime),
+			rawRumEvent: event,
+			domainContext,
+			duration
+		});
+	} };
 }
+//#endregion
+exports.startEventCollection = startEventCollection;
+
 //# sourceMappingURL=eventCollection.js.map

package/cjs/domain/event/eventCollection.js.map

@@ -1 +1 @@
-{"version":3,"file":"eventCollection.js","sourceRoot":"","sources":["../../../src/domain/event/eventCollection.ts"],"names":[],"mappings":";;AAgCA,oDAoBC;AAvCD,+DAAsD;AAEtD,MAAM,iBAAiB,GAAG;IACxB,gCAAY,CAAC,MAAM;IACnB,gCAAY,CAAC,KAAK;IAClB,gCAAY,CAAC,SAAS;IACtB,gCAAY,CAAC,QAAQ;IACrB,gCAAY,CAAC,KAAK;CACV,CAAA;AAWV,SAAgB,oBAAoB,CAAC,SAAoB;IACvD,OAAO;QACL,QAAQ,EAAE,CACR,SAAuB,EACvB,KAAyB,EACzB,aAAoC,EACpC,QAAmB,EACnB,EAAE;YACF,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC5C,OAAM;YACR,CAAC;YAED,SAAS,CAAC,MAAM,sDAA6C;gBAC3D,SAAS;gBACT,WAAW,EAAE,KAAK;gBAClB,aAAa;gBACb,QAAQ;aACT,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC"}
+{"version":3,"file":"eventCollection.js","names":["RumEventType","relativeToClocks"],"sources":["../../../src/domain/event/eventCollection.ts"],"sourcesContent":["import { relativeToClocks } from '@kubesense/kubesense-js-core/time'\nimport type { Duration, RelativeTime } from '@kubesense/kubesense-js-core/time'\nimport type { Context } from '@kubesense/kubesense-browser-core'\nimport type { RumEventDomainContext } from '../../domainContext.types'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\n\nimport type {\n  RawRumActionEvent,\n  RawRumErrorEvent,\n  RawRumLongAnimationFrameEvent,\n  RawRumLongTaskEvent,\n  RawRumResourceEvent,\n  RawRumVitalEvent,\n} from '../../rawRumEvent.types'\nimport { RumEventType } from '../../rawRumEvent.types'\n\nconst allowedEventTypes = [\n  RumEventType.ACTION,\n  RumEventType.ERROR,\n  RumEventType.LONG_TASK,\n  RumEventType.RESOURCE,\n  RumEventType.VITAL,\n] as const\n\nexport type AllowedRawRumEvent = (\n  | RawRumErrorEvent\n  | RawRumResourceEvent\n  | RawRumLongTaskEvent\n  | RawRumLongAnimationFrameEvent\n  | RawRumActionEvent\n  | RawRumVitalEvent\n) & { context?: Context }\n\nexport function startEventCollection(lifeCycle: LifeCycle) {\n  return {\n    addEvent: (\n      startTime: RelativeTime,\n      event: AllowedRawRumEvent,\n      domainContext: RumEventDomainContext,\n      duration?: Duration\n    ) => {\n      if (!allowedEventTypes.includes(event.type)) {\n        return\n      }\n\n      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {\n        startClocks: relativeToClocks(startTime),\n        rawRumEvent: event,\n        domainContext,\n        duration,\n      })\n    },\n  }\n}\n"],"mappings":";;;;AAiBA,MAAM,oBAAoB;CACxBA,0BAAAA,aAAa;CACbA,0BAAAA,aAAa;CACbA,0BAAAA,aAAa;CACbA,0BAAAA,aAAa;CACbA,0BAAAA,aAAa;AACf;AAWA,SAAgB,qBAAqB,WAAsB;CACzD,OAAO,EACL,WACE,WACA,OACA,eACA,aACG;EACH,IAAI,CAAC,kBAAkB,SAAS,MAAM,IAAI,GACxC;EAGF,UAAU,OAAA,IAAmD;GAC3D,cAAA,GAAaC,kCAAAA,iBAAAA,CAAiB,SAAS;GACvC,aAAa;GACb;GACA;EACF,CAAC;CACH,EACF;AACF"}

package/cjs/domain/eventTracker.d.ts

@@ -0,0 +1,37 @@
+import type { ClocksState, RelativeTime, Duration } from '@kubesense/kubesense-js-core/time';
+import type { ValueHistoryEntry } from '@kubesense/kubesense-browser-core';
+import type { RumActionEvent, RumErrorEvent, RumLongTaskEvent, RumResourceEvent } from '../rumEvent.types';
+import type { LifeCycle } from './lifeCycle';
+import type { EventCounts } from './trackEventCounts';
+import { trackEventCounts } from './trackEventCounts';
+export declare const EVENT_CONTEXT_TIME_OUT_DELAY: number;
+type BaseTrackedEvent<TData = object> = TData & {
+    id: string;
+    startClocks: ClocksState;
+    counts?: EventCounts;
+};
+export type StoppedEvent<TData> = BaseTrackedEvent<TData> & {
+    duration: Duration;
+};
+export type DiscardedEvent<TData> = BaseTrackedEvent<TData>;
+export interface StartOptions {
+    isChildEvent?: (id: string) => (event: RumActionEvent | RumErrorEvent | RumLongTaskEvent | RumResourceEvent) => boolean;
+}
+export interface EventTracker<TData> {
+    start: (key: string, startClocks: ClocksState, data: TData, options?: StartOptions) => TrackedEventData<TData>;
+    stop: (key: string, stopClocks: ClocksState, data?: Partial<TData>) => StoppedEvent<TData> | undefined;
+    discard: (key: string) => DiscardedEvent<TData> | undefined;
+    getCounts: (key: string) => EventCounts | undefined;
+    findId: (startTime?: RelativeTime) => string[];
+    stopAll: () => void;
+}
+export interface TrackedEventData<TData> {
+    id: string;
+    key: string;
+    startClocks: ClocksState;
+    data: TData;
+    historyEntry: ValueHistoryEntry<string>;
+    eventCounts?: ReturnType<typeof trackEventCounts>;
+}
+export declare function startEventTracker<TData>(lifeCycle: LifeCycle): EventTracker<TData>;
+export {};

package/cjs/domain/eventTracker.js

@@ -0,0 +1,94 @@
+require("./lifeCycle.js");
+const require_trackEventCounts = require("./trackEventCounts.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/eventTracker.ts
+const EVENT_CONTEXT_TIME_OUT_DELAY = 5 * _kubesense_kubesense_js_core_time.ONE_MINUTE;
+function startEventTracker(lifeCycle) {
+	const history = (0, _kubesense_kubesense_browser_core.createValueHistory)({ expireDelay: EVENT_CONTEXT_TIME_OUT_DELAY });
+	const keyedEvents = /* @__PURE__ */ new Map();
+	function cleanUpEvent(event) {
+		keyedEvents.delete(event.key);
+		event.eventCounts?.stop();
+	}
+	function discardAll() {
+		keyedEvents.forEach((event) => {
+			cleanUpEvent(event);
+		});
+		history.reset();
+	}
+	const sessionRenewalSubscription = lifeCycle.subscribe(11, discardAll);
+	function start(key, startClocks, data, options) {
+		const id = (0, _kubesense_kubesense_browser_core.generateUUID)();
+		const historyEntry = history.add(id, startClocks.relative);
+		const existing = keyedEvents.get(key);
+		if (existing) cleanUpEvent(existing);
+		const trackedEventData = {
+			id,
+			key,
+			startClocks,
+			data,
+			historyEntry,
+			eventCounts: options?.isChildEvent ? require_trackEventCounts.trackEventCounts({
+				lifeCycle,
+				isChildEvent: options.isChildEvent(id)
+			}) : void 0
+		};
+		keyedEvents.set(key, trackedEventData);
+		return trackedEventData;
+	}
+	function stop(key, stopClocks, extraData) {
+		const event = keyedEvents.get(key);
+		if (!event) return;
+		const finalData = extraData ? (0, _kubesense_kubesense_js_core_util.combine)(event.data, extraData) : event.data;
+		event.historyEntry.close(stopClocks.relative);
+		const duration = (0, _kubesense_kubesense_js_core_time.elapsed)(event.startClocks.timeStamp, stopClocks.timeStamp);
+		const counts = event.eventCounts?.eventCounts;
+		cleanUpEvent(event);
+		return {
+			...finalData,
+			id: event.id,
+			startClocks: event.startClocks,
+			duration,
+			counts
+		};
+	}
+	function discard(key) {
+		const event = keyedEvents.get(key);
+		if (!event) return;
+		const counts = event.eventCounts?.eventCounts;
+		cleanUpEvent(event);
+		event.historyEntry.remove();
+		return {
+			...event.data,
+			id: event.id,
+			startClocks: event.startClocks,
+			counts
+		};
+	}
+	function findId(startTime) {
+		return history.findAll(startTime);
+	}
+	function getCounts(key) {
+		return keyedEvents.get(key)?.eventCounts?.eventCounts;
+	}
+	function stopTracker() {
+		sessionRenewalSubscription.unsubscribe();
+		discardAll();
+		history.stop();
+	}
+	return {
+		start,
+		stop,
+		discard,
+		getCounts,
+		findId,
+		stopAll: stopTracker
+	};
+}
+//#endregion
+exports.EVENT_CONTEXT_TIME_OUT_DELAY = EVENT_CONTEXT_TIME_OUT_DELAY;
+exports.startEventTracker = startEventTracker;
+
+//# sourceMappingURL=eventTracker.js.map

package/cjs/domain/eventTracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventTracker.js","names":["ONE_MINUTE","createValueHistory","generateUUID","trackEventCounts","combine","elapsed"],"sources":["../../src/domain/eventTracker.ts"],"sourcesContent":["import type { ClocksState, RelativeTime, Duration } from '@kubesense/kubesense-js-core/time'\nimport type { ValueHistoryEntry } from '@kubesense/kubesense-browser-core'\nimport { ONE_MINUTE, elapsed } from '@kubesense/kubesense-js-core/time'\nimport { generateUUID, createValueHistory } from '@kubesense/kubesense-browser-core'\nimport { combine } from '@kubesense/kubesense-js-core/util'\nimport type { RumActionEvent, RumErrorEvent, RumLongTaskEvent, RumResourceEvent } from '../rumEvent.types'\nimport { LifeCycleEventType } from './lifeCycle'\nimport type { LifeCycle } from './lifeCycle'\nimport type { EventCounts } from './trackEventCounts'\nimport { trackEventCounts } from './trackEventCounts'\n\nexport const EVENT_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE // arbitrary\n\ntype BaseTrackedEvent<TData = object> = TData & {\n  id: string\n  startClocks: ClocksState\n  counts?: EventCounts\n}\n\nexport type StoppedEvent<TData> = BaseTrackedEvent<TData> & {\n  duration: Duration\n}\n\nexport type DiscardedEvent<TData> = BaseTrackedEvent<TData>\n\nexport interface StartOptions {\n  isChildEvent?: (\n    id: string\n  ) => (event: RumActionEvent | RumErrorEvent | RumLongTaskEvent | RumResourceEvent) => boolean\n}\n\nexport interface EventTracker<TData> {\n  start: (key: string, startClocks: ClocksState, data: TData, options?: StartOptions) => TrackedEventData<TData>\n  stop: (key: string, stopClocks: ClocksState, data?: Partial<TData>) => StoppedEvent<TData> | undefined\n  discard: (key: string) => DiscardedEvent<TData> | undefined\n  getCounts: (key: string) => EventCounts | undefined\n  findId: (startTime?: RelativeTime) => string[]\n  stopAll: () => void\n}\n\nexport interface TrackedEventData<TData> {\n  id: string\n  key: string\n  startClocks: ClocksState\n  data: TData\n  historyEntry: ValueHistoryEntry<string>\n  eventCounts?: ReturnType<typeof trackEventCounts>\n}\n\nexport function startEventTracker<TData>(lifeCycle: LifeCycle): EventTracker<TData> {\n  // Used by actions to associate events with actions.\n  const history = createValueHistory<string>({ expireDelay: EVENT_CONTEXT_TIME_OUT_DELAY })\n  // Used by manual actions and resources that use named keys to match the start and stop calls.\n  const keyedEvents = new Map<string, TrackedEventData<TData>>()\n\n  function cleanUpEvent(event: TrackedEventData<TData>) {\n    keyedEvents.delete(event.key)\n\n    event.eventCounts?.stop()\n  }\n\n  function discardAll() {\n    keyedEvents.forEach((event) => {\n      cleanUpEvent(event)\n    })\n\n    history.reset()\n  }\n\n  const sessionRenewalSubscription = lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, discardAll)\n\n  function start(key: string, startClocks: ClocksState, data: TData, options?: StartOptions): TrackedEventData<TData> {\n    const id = generateUUID()\n\n    const historyEntry = history.add(id, startClocks.relative)\n\n    const existing = keyedEvents.get(key)\n    if (existing) {\n      cleanUpEvent(existing)\n    }\n\n    const eventCounts = options?.isChildEvent\n      ? trackEventCounts({\n          lifeCycle,\n          isChildEvent: options.isChildEvent(id),\n        })\n      : undefined\n\n    const trackedEventData: TrackedEventData<TData> = {\n      id,\n      key,\n      startClocks,\n      data,\n      historyEntry,\n      eventCounts,\n    }\n\n    keyedEvents.set(key, trackedEventData)\n    return trackedEventData\n  }\n\n  function stop(key: string, stopClocks: ClocksState, extraData?: Partial<TData>): StoppedEvent<TData> | undefined {\n    const event = keyedEvents.get(key)\n    if (!event) {\n      return undefined\n    }\n\n    const finalData = extraData ? (combine(event.data, extraData) as TData) : event.data\n\n    event.historyEntry.close(stopClocks.relative)\n\n    const duration = elapsed(event.startClocks.timeStamp, stopClocks.timeStamp)\n\n    const counts = event.eventCounts?.eventCounts\n\n    cleanUpEvent(event)\n\n    return {\n      ...finalData,\n      id: event.id,\n      startClocks: event.startClocks,\n      duration,\n      counts,\n    }\n  }\n\n  function discard(key: string): DiscardedEvent<TData> | undefined {\n    const event = keyedEvents.get(key)\n    if (!event) {\n      return undefined\n    }\n\n    const counts = event.eventCounts?.eventCounts\n\n    cleanUpEvent(event)\n\n    event.historyEntry.remove()\n\n    return {\n      ...event.data,\n      id: event.id,\n      startClocks: event.startClocks,\n      counts,\n    }\n  }\n\n  function findId(startTime?: RelativeTime): string[] {\n    return history.findAll(startTime)\n  }\n\n  function getCounts(key: string): EventCounts | undefined {\n    return keyedEvents.get(key)?.eventCounts?.eventCounts\n  }\n\n  function stopTracker() {\n    sessionRenewalSubscription.unsubscribe()\n    discardAll()\n    history.stop()\n  }\n\n  return {\n    start,\n    stop,\n    discard,\n    getCounts,\n    findId,\n    stopAll: stopTracker,\n  }\n}\n"],"mappings":";;;;;;AAWA,MAAa,+BAA+B,IAAIA,kCAAAA;AAsChD,SAAgB,kBAAyB,WAA2C;CAElF,MAAM,WAAA,GAAUC,kCAAAA,mBAAAA,CAA2B,EAAE,aAAa,6BAA6B,CAAC;CAExF,MAAM,8BAAc,IAAI,IAAqC;CAE7D,SAAS,aAAa,OAAgC;EACpD,YAAY,OAAO,MAAM,GAAG;EAE5B,MAAM,aAAa,KAAK;CAC1B;CAEA,SAAS,aAAa;EACpB,YAAY,SAAS,UAAU;GAC7B,aAAa,KAAK;EACpB,CAAC;EAED,QAAQ,MAAM;CAChB;CAEA,MAAM,6BAA6B,UAAU,UAAA,IAA8C,UAAU;CAErG,SAAS,MAAM,KAAa,aAA0B,MAAa,SAAiD;EAClH,MAAM,MAAA,GAAKC,kCAAAA,aAAAA,CAAa;EAExB,MAAM,eAAe,QAAQ,IAAI,IAAI,YAAY,QAAQ;EAEzD,MAAM,WAAW,YAAY,IAAI,GAAG;EACpC,IAAI,UACF,aAAa,QAAQ;EAUvB,MAAM,mBAA4C;GAChD;GACA;GACA;GACA;GACA;GACA,aAbkB,SAAS,eACzBC,yBAAAA,iBAAiB;IACf;IACA,cAAc,QAAQ,aAAa,EAAE;GACvC,CAAC,IACD,KAAA;EASJ;EAEA,YAAY,IAAI,KAAK,gBAAgB;EACrC,OAAO;CACT;CAEA,SAAS,KAAK,KAAa,YAAyB,WAA6D;EAC/G,MAAM,QAAQ,YAAY,IAAI,GAAG;EACjC,IAAI,CAAC,OACH;EAGF,MAAM,YAAY,aAAA,GAAaC,kCAAAA,QAAAA,CAAQ,MAAM,MAAM,SAAS,IAAc,MAAM;EAEhF,MAAM,aAAa,MAAM,WAAW,QAAQ;EAE5C,MAAM,YAAA,GAAWC,kCAAAA,QAAAA,CAAQ,MAAM,YAAY,WAAW,WAAW,SAAS;EAE1E,MAAM,SAAS,MAAM,aAAa;EAElC,aAAa,KAAK;EAElB,OAAO;GACL,GAAG;GACH,IAAI,MAAM;GACV,aAAa,MAAM;GACnB;GACA;EACF;CACF;CAEA,SAAS,QAAQ,KAAgD;EAC/D,MAAM,QAAQ,YAAY,IAAI,GAAG;EACjC,IAAI,CAAC,OACH;EAGF,MAAM,SAAS,MAAM,aAAa;EAElC,aAAa,KAAK;EAElB,MAAM,aAAa,OAAO;EAE1B,OAAO;GACL,GAAG,MAAM;GACT,IAAI,MAAM;GACV,aAAa,MAAM;GACnB;EACF;CACF;CAEA,SAAS,OAAO,WAAoC;EAClD,OAAO,QAAQ,QAAQ,SAAS;CAClC;CAEA,SAAS,UAAU,KAAsC;EACvD,OAAO,YAAY,IAAI,GAAG,CAAC,EAAE,aAAa;CAC5C;CAEA,SAAS,cAAc;EACrB,2BAA2B,YAAY;EACvC,WAAW;EACX,QAAQ,KAAK;CACf;CAEA,OAAO;EACL;EACA;EACA;EACA;EACA;EACA,SAAS;CACX;AACF"}

package/cjs/domain/extractRegexMatch.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Executes a RegExp against a string and returns the first capture group, or the full match if
+ * there is no capture group. Returns undefined when the pattern does not match.
+ */
+export declare function extractRegexMatch(candidate: string, extractor: RegExp): string | undefined;

package/cjs/domain/extractRegexMatch.js

@@ -0,0 +1,16 @@
+//#region src/domain/extractRegexMatch.ts
+/**
+* Executes a RegExp against a string and returns the first capture group, or the full match if
+* there is no capture group. Returns undefined when the pattern does not match.
+*/
+function extractRegexMatch(candidate, extractor) {
+	extractor.lastIndex = 0;
+	const regexResult = extractor.exec(candidate);
+	if (!regexResult) return;
+	const [match, capture] = regexResult;
+	return capture ? capture : match;
+}
+//#endregion
+exports.extractRegexMatch = extractRegexMatch;
+
+//# sourceMappingURL=extractRegexMatch.js.map

package/cjs/domain/extractRegexMatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractRegexMatch.js","names":[],"sources":["../../src/domain/extractRegexMatch.ts"],"sourcesContent":["/**\n * Executes a RegExp against a string and returns the first capture group, or the full match if\n * there is no capture group. Returns undefined when the pattern does not match.\n */\nexport function extractRegexMatch(candidate: string, extractor: RegExp): string | undefined {\n  // Prevent stateful matching when the RegExp has the global or sticky flag\n  extractor.lastIndex = 0\n\n  const regexResult = extractor.exec(candidate)\n  if (!regexResult) {\n    return undefined\n  }\n  const [match, capture] = regexResult\n  return capture ? capture : match\n}\n"],"mappings":";;;;;AAIA,SAAgB,kBAAkB,WAAmB,WAAuC;CAE1F,UAAU,YAAY;CAEtB,MAAM,cAAc,UAAU,KAAK,SAAS;CAC5C,IAAI,CAAC,aACH;CAEF,MAAM,CAAC,OAAO,WAAW;CACzB,OAAO,UAAU,UAAU;AAC7B"}

package/cjs/domain/getComposedPathSelector.d.ts

@@ -0,0 +1,22 @@
+/**
+ * arbitrary value, we want to truncate the selector if it exceeds the limit
+ */
+export declare const CHARACTER_LIMIT: number;
+/**
+ * Safe attributes that can be collected without PII concerns.
+ * These are commonly used for testing, accessibility, and UI identification.
+ */
+export declare const SAFE_ATTRIBUTES: string[];
+/**
+ * Extracts a selector string from a MouseEvent composedPath.
+ *
+ * This function:
+ * 1. Filters out non-Element items (Document, Window, ShadowRoot)
+ * 2. Extracts a selector string from each element
+ * 3. Truncates the selector string if it exceeds the character limit
+ * 4. Returns the selector string
+ *
+ * @param composedPath - The composedPath from a MouseEvent
+ * @returns A selector string
+ */
+export declare function getComposedPathSelector(composedPath: EventTarget[], actionNameAttribute: string | undefined): string;

package/cjs/domain/getComposedPathSelector.js

@@ -0,0 +1,95 @@
+const require_getSelectorFromElement = require("./getSelectorFromElement.js");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/getComposedPathSelector.ts
+const FILTERED_TAGNAMES = ["HTML", "BODY"];
+/**
+* arbitrary value, we want to truncate the selector if it exceeds the limit
+*/
+const CHARACTER_LIMIT = 2 * _kubesense_kubesense_browser_core.ONE_KIBI_BYTE;
+/**
+* Safe attributes that can be collected without PII concerns.
+* These are commonly used for testing, accessibility, and UI identification.
+*/
+const SAFE_ATTRIBUTES = require_getSelectorFromElement.STABLE_ATTRIBUTES.concat([
+	"role",
+	"type",
+	"disabled",
+	"readonly",
+	"tabindex",
+	"draggable",
+	"target",
+	"rel",
+	"download",
+	"method",
+	"action",
+	"enctype",
+	"autocomplete"
+]);
+/**
+* Extracts a selector string from a MouseEvent composedPath.
+*
+* This function:
+* 1. Filters out non-Element items (Document, Window, ShadowRoot)
+* 2. Extracts a selector string from each element
+* 3. Truncates the selector string if it exceeds the character limit
+* 4. Returns the selector string
+*
+* @param composedPath - The composedPath from a MouseEvent
+* @returns A selector string
+*/
+function getComposedPathSelector(composedPath, actionNameAttribute) {
+	const elements = composedPath.filter((el) => el instanceof Element && !FILTERED_TAGNAMES.includes(el.tagName));
+	if (elements.length === 0) return "";
+	const allowedAttributes = actionNameAttribute ? [actionNameAttribute].concat(SAFE_ATTRIBUTES) : SAFE_ATTRIBUTES;
+	let result = "";
+	for (const element of elements) {
+		const part = getSelectorStringFromElement(element, allowedAttributes);
+		result += part;
+		if (result.length >= CHARACTER_LIMIT) return (0, _kubesense_kubesense_browser_core.safeTruncate)(result, CHARACTER_LIMIT);
+	}
+	return result;
+}
+/**
+* Extracts a selector string from an element.
+*/
+function getSelectorStringFromElement(element, allowedAttributes) {
+	const tagName = require_getSelectorFromElement.getTagNameSelector(element);
+	const id = require_getSelectorFromElement.getIDSelector(element);
+	const classes = getElementClassesString(element);
+	const attributes = extractSafeAttributesString(element, allowedAttributes);
+	const positionData = computePositionDataString(element);
+	return `${tagName}${id || ""}${attributes}${classes}${positionData};`;
+}
+function getElementClassesString(element) {
+	return Array.from(element.classList).filter((c) => !require_getSelectorFromElement.isGeneratedValue(c)).sort().map((c) => `.${CSS.escape(c)}`).join("");
+}
+/**
+* Computes the nthChild and nthOfType positions for an element.
+*
+* @param element - The element to compute the position data for
+* @returns A string of the form ":nth-child(1):nth-of-type(1)"
+*/
+function computePositionDataString(element) {
+	const siblings = Array.from(element.parentNode.children);
+	if (siblings.length <= 1) return "";
+	const sameTypeSiblings = siblings.filter((sibling) => sibling.tagName === element.tagName);
+	const nthChild = siblings.indexOf(element);
+	const nthOfType = require_getSelectorFromElement.getNthOfTypeSelector(element);
+	return `:nth-child(${nthChild + 1})${sameTypeSiblings.length > 1 ? `:nth-of-type(${nthOfType})` : ""}`;
+}
+/**
+* Extracts only the safe (allowlisted) attributes from an element.
+* The attributes are sorted alphabetically by name.
+*/
+function extractSafeAttributesString(element, allowedAttributes) {
+	const result = [];
+	const attributes = Array.from(element.attributes);
+	for (const attribute of attributes) if (allowedAttributes.includes(attribute.name)) result.push(require_getSelectorFromElement.getAttributeValueSelector(attribute.name, attribute.value));
+	return result.sort().join("");
+}
+//#endregion
+exports.CHARACTER_LIMIT = CHARACTER_LIMIT;
+exports.SAFE_ATTRIBUTES = SAFE_ATTRIBUTES;
+exports.getComposedPathSelector = getComposedPathSelector;
+
+//# sourceMappingURL=getComposedPathSelector.js.map

package/cjs/domain/getComposedPathSelector.js.map

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

package/cjs/domain/getSelectorFromElement.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Marker used to indicate shadow DOM boundaries in selectors.
+ * Named after the deprecated Shadow DOM v0 '::shadow' pseudo-element which served the same
+ * purpose of marking entry into a shadow root.
+ * Note: This is NOT a valid CSS selector, it's an internal marker that requires custom
+ * parsing logic.
+ */
+export declare const SHADOW_DOM_MARKER = "::shadow ";
 /**
  * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:
  * component). Those attribute values should not be generated randomly (hardcoded most of the time)
@@ -5,17 +13,21 @@
  */
 export declare const STABLE_ATTRIBUTES: string[];
 export declare function getSelectorFromElement(targetElement: Element, actionNameAttribute: string | undefined): string | undefined;
+export declare function isGeneratedValue(value: string): boolean;
+export declare function getIDSelector(element: Element): string | undefined;
+export declare function getTagNameSelector(element: Element): string;
+export declare function getAttributeValueSelector(attributeName: string, attributeValue: string): string;
+export declare function getNthOfTypeSelector(element: Element): number;
 /**
  * Check whether the selector is unique among the element siblings. In other words, it returns true
  * if "ELEMENT_PARENT > CHILD_SELECTOR" returns a single element.
  *
- * @param {Element} currentElement - the element being considered while iterating over the target
+ * @param currentElement - the element being considered while iterating over the target
  * element ancestors.
- *
- * @param {string} currentElementSelector - a selector that matches the current element. That
+ * @param _rootNode - the root node (document or shadow root) - unused but required for predicate signature.
+ * @param currentElementSelector - a selector that matches the current element. That
  * selector is not a composed selector (i.e. it might be a single tag name, class name...).
- *
- * @param {string|undefined} childSelector - child selector is a selector that targets a descendant
+ * @param childSelector - child selector is a selector that targets a descendant
  * of the current element. When undefined, the current element is the target element.
  *
  * # Scope selector usage
@@ -61,4 +73,4 @@ export declare function getSelectorFromElement(targetElement: Element, actionNam
  * selector within a sibling, we know that it's not unique. This allows us to use `querySelector`
  * (or `matches`, when the current element is the target element) instead of `querySelectorAll`.
  */
-export declare function isSelectorUniqueAmongSiblings(currentElement: Element, currentElementSelector: string, childSelector: string | undefined): boolean;
+export declare function isSelectorUniqueAmongSiblings(currentElement: Element, _rootNode: Document | ShadowRoot, currentElementSelector: string, childSelector: string | undefined): boolean;