@kubesense/kubesense-browser-rum 1.7.0 → 2.0.0-beta.1

package/cjs/domain/profiling/transport/buildProfileEvent.js

@@ -0,0 +1,91 @@
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/profiling/transport/buildProfileEvent.ts
+/**
+* Builds a BrowserProfileEvent from a trace.
+*/
+function buildProfileEvent(profilerTrace, configuration, sessionId) {
+	const tags = (0, _kubesense_kubesense_browser_core.buildTags)(configuration);
+	const profileAttributes = buildProfileEventAttributes(profilerTrace, configuration.applicationId, sessionId);
+	const profileEventTags = buildProfileEventTags(tags);
+	return {
+		...profileAttributes,
+		attachments: ["wall-time.json"],
+		start: new Date(profilerTrace.startClocks.timeStamp).toISOString(),
+		end: new Date(profilerTrace.endClocks.timeStamp).toISOString(),
+		family: "chrome",
+		runtime: "chrome",
+		format: "json",
+		version: 4,
+		tags_profiler: profileEventTags.join(","),
+		_kubesense: { clock_drift: (0, _kubesense_kubesense_js_core_time.clockDrift)() }
+	};
+}
+/**
+* Builds attributes for the Profile Event.
+*
+* @param profilerTrace - Profiler trace
+* @param applicationId - application id.
+* @param sessionId - session id.
+* @returns Additional attributes.
+*/
+function buildProfileEventAttributes(profilerTrace, applicationId, sessionId) {
+	const { ids, names } = extractViewIdsAndNames(profilerTrace.views);
+	const longTaskIds = profilerTrace.longTasks.map((longTask) => longTask.id).filter((id) => id !== void 0);
+	const actionIds = profilerTrace.actions?.map((longTask) => longTask.id).filter((id) => id !== void 0) ?? [];
+	const { ids: vitalIds, labels: vitalLabels } = extractVitalIdsAndLabels(profilerTrace.vitals);
+	const attributes = { application: { id: applicationId } };
+	if (sessionId) attributes.session = { id: sessionId };
+	if (ids.length) attributes.view = {
+		id: ids,
+		name: names
+	};
+	if (longTaskIds.length) attributes.long_task = { id: longTaskIds };
+	if (actionIds.length) attributes.action = {
+		id: actionIds,
+		label: []
+	};
+	if (vitalIds.length) attributes.vital = {
+		id: vitalIds,
+		label: vitalLabels
+	};
+	return attributes;
+}
+function extractViewIdsAndNames(views) {
+	const result = {
+		ids: [],
+		names: []
+	};
+	for (const view of views) {
+		result.ids.push(view.viewId);
+		if (view.viewName) result.names.push(view.viewName);
+	}
+	result.names = Array.from(new Set(result.names));
+	return result;
+}
+function extractVitalIdsAndLabels(vitals) {
+	const result = {
+		ids: [],
+		labels: []
+	};
+	if (!vitals) return result;
+	for (const vital of vitals) {
+		result.ids.push(vital.id);
+		result.labels.push(vital.label);
+	}
+	result.labels = Array.from(new Set(result.labels));
+	return result;
+}
+function buildProfileEventTags(tags) {
+	return tags.concat([
+		"language:javascript",
+		"runtime:chrome",
+		"family:chrome",
+		"host:browser"
+	]);
+}
+//#endregion
+exports.buildProfileEvent = buildProfileEvent;
+exports.buildProfileEventAttributes = buildProfileEventAttributes;
+
+//# sourceMappingURL=buildProfileEvent.js.map

package/cjs/domain/profiling/transport/buildProfileEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildProfileEvent.js","names":["buildTags","clockDrift"],"sources":["../../../../src/domain/profiling/transport/buildProfileEvent.ts"],"sourcesContent":["import { clockDrift } from '@kubesense/kubesense-js-core/time'\nimport { buildTags } from '@kubesense/kubesense-browser-core'\nimport type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'\nimport type { BrowserProfileEvent, BrowserProfilerTrace, RumProfilerVitalEntry, RumViewEntry } from '../../../types'\n\nexport interface ProfileEventAttributes {\n  application: {\n    id: string\n  }\n  session?: {\n    id: string\n  }\n  view?: {\n    id: string[]\n    name: string[]\n  }\n  long_task?: {\n    id: string[]\n  }\n  action?: {\n    id: string[]\n    label: string[]\n  }\n  vital?: {\n    id: string[]\n    label: string[]\n  }\n}\n\n/**\n * Builds a BrowserProfileEvent from a trace.\n */\nexport function buildProfileEvent(\n  profilerTrace: BrowserProfilerTrace,\n  configuration: RumConfiguration,\n  sessionId: string | undefined\n): BrowserProfileEvent {\n  const tags = buildTags(configuration) // TODO: get that from the tagContext hook\n  const profileAttributes = buildProfileEventAttributes(profilerTrace, configuration.applicationId, sessionId)\n  const profileEventTags = buildProfileEventTags(tags)\n\n  return {\n    ...profileAttributes,\n    attachments: ['wall-time.json'],\n    start: new Date(profilerTrace.startClocks.timeStamp).toISOString(),\n    end: new Date(profilerTrace.endClocks.timeStamp).toISOString(),\n    family: 'chrome',\n    runtime: 'chrome',\n    format: 'json',\n    version: 4, // Ingestion event version (not the version application tag)\n    tags_profiler: profileEventTags.join(','),\n    _kubesense: {\n      clock_drift: clockDrift(),\n    },\n  }\n}\n\n/**\n * Builds attributes for the Profile Event.\n *\n * @param profilerTrace - Profiler trace\n * @param applicationId - application id.\n * @param sessionId - session id.\n * @returns Additional attributes.\n */\nexport function buildProfileEventAttributes(\n  profilerTrace: BrowserProfilerTrace,\n  applicationId: string,\n  sessionId: string | undefined\n): ProfileEventAttributes {\n  // Extract view ids and names from the profiler trace and add them as attributes of the profile event.\n  // This will be used to filter the profiles by @view.id and/or @view.name.\n  const { ids, names } = extractViewIdsAndNames(profilerTrace.views)\n\n  const longTaskIds: string[] = profilerTrace.longTasks.map((longTask) => longTask.id).filter((id) => id !== undefined)\n\n  const actionIds: string[] =\n    profilerTrace.actions?.map((longTask) => longTask.id).filter((id) => id !== undefined) ?? []\n\n  const { ids: vitalIds, labels: vitalLabels } = extractVitalIdsAndLabels(profilerTrace.vitals)\n\n  const attributes: ProfileEventAttributes = { application: { id: applicationId } }\n\n  if (sessionId) {\n    attributes.session = { id: sessionId }\n  }\n  if (ids.length) {\n    attributes.view = { id: ids, name: names }\n  }\n  if (longTaskIds.length) {\n    attributes.long_task = { id: longTaskIds }\n  }\n  if (actionIds.length) {\n    attributes.action = { id: actionIds, label: [] }\n  }\n  if (vitalIds.length) {\n    attributes.vital = { id: vitalIds, label: vitalLabels }\n  }\n  return attributes\n}\n\nfunction extractViewIdsAndNames(views: RumViewEntry[]): { ids: string[]; names: string[] } {\n  const result: { ids: string[]; names: string[] } = { ids: [], names: [] }\n  for (const view of views) {\n    result.ids.push(view.viewId)\n\n    if (view.viewName) {\n      result.names.push(view.viewName)\n    }\n  }\n\n  // Remove duplicates\n  result.names = Array.from(new Set(result.names))\n\n  return result\n}\n\nfunction extractVitalIdsAndLabels(vitals?: RumProfilerVitalEntry[]): {\n  ids: string[]\n  labels: string[]\n} {\n  const result: { ids: string[]; labels: string[] } = { ids: [], labels: [] }\n\n  if (!vitals) {\n    return result\n  }\n\n  for (const vital of vitals) {\n    result.ids.push(vital.id)\n    result.labels.push(vital.label)\n  }\n\n  // Remove duplicates\n  result.labels = Array.from(new Set(result.labels))\n\n  return result\n}\n\nfunction buildProfileEventTags(tags: string[]): string[] {\n  // Tags already contains the common tags for all events. (service, env, version, etc.)\n  // Here we are adding some specific-to-profiling tags.\n  return tags.concat(['language:javascript', 'runtime:chrome', 'family:chrome', 'host:browser'])\n}\n"],"mappings":";;;;;;AAgCA,SAAgB,kBACd,eACA,eACA,WACqB;CACrB,MAAM,QAAA,GAAOA,kCAAAA,UAAAA,CAAU,aAAa;CACpC,MAAM,oBAAoB,4BAA4B,eAAe,cAAc,eAAe,SAAS;CAC3G,MAAM,mBAAmB,sBAAsB,IAAI;CAEnD,OAAO;EACL,GAAG;EACH,aAAa,CAAC,gBAAgB;EAC9B,OAAO,IAAI,KAAK,cAAc,YAAY,SAAS,CAAC,CAAC,YAAY;EACjE,KAAK,IAAI,KAAK,cAAc,UAAU,SAAS,CAAC,CAAC,YAAY;EAC7D,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,eAAe,iBAAiB,KAAK,GAAG;EACxC,YAAY,EACV,cAAA,GAAaC,kCAAAA,WAAAA,CAAW,EAC1B;CACF;AACF;;;;;;;;;AAUA,SAAgB,4BACd,eACA,eACA,WACwB;CAGxB,MAAM,EAAE,KAAK,UAAU,uBAAuB,cAAc,KAAK;CAEjE,MAAM,cAAwB,cAAc,UAAU,KAAK,aAAa,SAAS,EAAE,CAAC,CAAC,QAAQ,OAAO,OAAO,KAAA,CAAS;CAEpH,MAAM,YACJ,cAAc,SAAS,KAAK,aAAa,SAAS,EAAE,CAAC,CAAC,QAAQ,OAAO,OAAO,KAAA,CAAS,KAAK,CAAC;CAE7F,MAAM,EAAE,KAAK,UAAU,QAAQ,gBAAgB,yBAAyB,cAAc,MAAM;CAE5F,MAAM,aAAqC,EAAE,aAAa,EAAE,IAAI,cAAc,EAAE;CAEhF,IAAI,WACF,WAAW,UAAU,EAAE,IAAI,UAAU;CAEvC,IAAI,IAAI,QACN,WAAW,OAAO;EAAE,IAAI;EAAK,MAAM;CAAM;CAE3C,IAAI,YAAY,QACd,WAAW,YAAY,EAAE,IAAI,YAAY;CAE3C,IAAI,UAAU,QACZ,WAAW,SAAS;EAAE,IAAI;EAAW,OAAO,CAAC;CAAE;CAEjD,IAAI,SAAS,QACX,WAAW,QAAQ;EAAE,IAAI;EAAU,OAAO;CAAY;CAExD,OAAO;AACT;AAEA,SAAS,uBAAuB,OAA2D;CACzF,MAAM,SAA6C;EAAE,KAAK,CAAC;EAAG,OAAO,CAAC;CAAE;CACxE,KAAK,MAAM,QAAQ,OAAO;EACxB,OAAO,IAAI,KAAK,KAAK,MAAM;EAE3B,IAAI,KAAK,UACP,OAAO,MAAM,KAAK,KAAK,QAAQ;CAEnC;CAGA,OAAO,QAAQ,MAAM,KAAK,IAAI,IAAI,OAAO,KAAK,CAAC;CAE/C,OAAO;AACT;AAEA,SAAS,yBAAyB,QAGhC;CACA,MAAM,SAA8C;EAAE,KAAK,CAAC;EAAG,QAAQ,CAAC;CAAE;CAE1E,IAAI,CAAC,QACH,OAAO;CAGT,KAAK,MAAM,SAAS,QAAQ;EAC1B,OAAO,IAAI,KAAK,MAAM,EAAE;EACxB,OAAO,OAAO,KAAK,MAAM,KAAK;CAChC;CAGA,OAAO,SAAS,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,CAAC;CAEjD,OAAO;AACT;AAEA,SAAS,sBAAsB,MAA0B;CAGvD,OAAO,KAAK,OAAO;EAAC;EAAuB;EAAkB;EAAiB;CAAc,CAAC;AAC/F"}

package/cjs/domain/profiling/transport/formDataEmitter.d.ts

@@ -0,0 +1,5 @@
+import type { Encoder } from '@kubesense/kubesense-browser-core';
+import { DeflateEncoderStreamId } from '@kubesense/kubesense-browser-core';
+import type { LifeCycle, RumConfiguration } from '@kubesense/kubesense-browser-rum-core';
+import type { ProfilingPayload } from '../types';
+export declare function createFormDataEmitter(configuration: RumConfiguration, lifeCycle: LifeCycle, createEncoder: (streamId: DeflateEncoderStreamId) => Encoder): (payload: ProfilingPayload) => void;

package/cjs/domain/profiling/transport/formDataEmitter.js

@@ -0,0 +1,17 @@
+let _kubesense_kubesense_browser_rum_core = require("@kubesense/kubesense-browser-rum-core");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/profiling/transport/formDataEmitter.ts
+function createFormDataEmitter(configuration, lifeCycle, createEncoder) {
+	const transport = (0, _kubesense_kubesense_browser_rum_core.createFormDataTransport)(configuration, lifeCycle, createEncoder, _kubesense_kubesense_browser_core.DeflateEncoderStreamId.PROFILING);
+	return ({ profile, trace }) => {
+		const formPayload = {
+			event: profile,
+			"wall-time.json": trace
+		};
+		transport.send(formPayload);
+	};
+}
+//#endregion
+exports.createFormDataEmitter = createFormDataEmitter;
+
+//# sourceMappingURL=formDataEmitter.js.map

package/cjs/domain/profiling/transport/formDataEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formDataEmitter.js","names":["createFormDataTransport","DeflateEncoderStreamId"],"sources":["../../../../src/domain/profiling/transport/formDataEmitter.ts"],"sourcesContent":["import type { Encoder } from '@kubesense/kubesense-browser-core'\nimport { DeflateEncoderStreamId } from '@kubesense/kubesense-browser-core'\nimport type { LifeCycle, RumConfiguration, TransportPayload } from '@kubesense/kubesense-browser-rum-core'\nimport { createFormDataTransport } from '@kubesense/kubesense-browser-rum-core'\nimport type { ProfilingPayload } from '../types'\n\nexport function createFormDataEmitter(\n  configuration: RumConfiguration,\n  lifeCycle: LifeCycle,\n  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder\n): (payload: ProfilingPayload) => void {\n  const transport = createFormDataTransport(configuration, lifeCycle, createEncoder, DeflateEncoderStreamId.PROFILING)\n  return ({ profile, trace }: ProfilingPayload) => {\n    const formPayload = { event: profile, 'wall-time.json': trace }\n    void transport.send(formPayload as unknown as TransportPayload)\n  }\n}\n"],"mappings":";;;AAMA,SAAgB,sBACd,eACA,WACA,eACqC;CACrC,MAAM,aAAA,GAAYA,sCAAAA,wBAAAA,CAAwB,eAAe,WAAW,eAAeC,kCAAAA,uBAAuB,SAAS;CACnH,QAAQ,EAAE,SAAS,YAA8B;EAC/C,MAAM,cAAc;GAAE,OAAO;GAAS,kBAAkB;EAAM;EAC9D,UAAe,KAAK,WAA0C;CAChE;AACF"}

package/cjs/domain/profiling/transport/profilingBridge.d.ts

@@ -0,0 +1,2 @@
+import type { ProfilingPayload } from '../types';
+export declare function createBridgeEmitter(): (payload: ProfilingPayload) => void;

package/cjs/domain/profiling/transport/profilingBridge.js

@@ -0,0 +1,12 @@
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/profiling/transport/profilingBridge.ts
+function createBridgeEmitter() {
+	const bridge = (0, _kubesense_kubesense_browser_core.getEventBridge)();
+	return (payload) => {
+		bridge.send("profile", payload);
+	};
+}
+//#endregion
+exports.createBridgeEmitter = createBridgeEmitter;
+
+//# sourceMappingURL=profilingBridge.js.map

package/cjs/domain/profiling/transport/profilingBridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profilingBridge.js","names":["getEventBridge"],"sources":["../../../../src/domain/profiling/transport/profilingBridge.ts"],"sourcesContent":["import { getEventBridge } from '@kubesense/kubesense-browser-core'\nimport type { ProfilingPayload } from '../types'\n\nexport function createBridgeEmitter(): (payload: ProfilingPayload) => void {\n  const bridge = getEventBridge<'profile', ProfilingPayload>()!\n  return (payload: ProfilingPayload) => {\n    bridge.send('profile', payload)\n  }\n}\n"],"mappings":";;AAGA,SAAgB,sBAA2D;CACzE,MAAM,UAAA,GAASA,kCAAAA,eAAAA,CAA4C;CAC3D,QAAQ,YAA8B;EACpC,OAAO,KAAK,WAAW,OAAO;CAChC;AACF"}

package/cjs/domain/profiling/{types/rumProfiler.types.d.ts → types.d.ts}

@@ -1,14 +1,8 @@
-import type { TimeoutId, ClocksState } from '@kubesense/kubesense-browser-core';
-import type { LongTaskContext } from '@kubesense/kubesense-browser-rum-core';
-import type { ProfilerTrace, Profiler } from './profilerApi.types';
-export interface RumViewEntry {
-    /** Detected start time of view */
-    readonly startClocks: ClocksState;
-    /** RUM view id */
-    readonly viewId: string;
-    /** RUM view name */
-    readonly viewName: string | undefined;
-}
+import type { Profiler } from '@kubesense/kubesense-js-core/util';
+import type { ClocksState } from '@kubesense/kubesense-js-core/time';
+import type { TimeoutId } from '@kubesense/kubesense-browser-core';
+import type { BrowserProfileEvent, BrowserProfilerTrace, RumViewEntry } from '../../types';
+import type { LongTaskContext } from './longTaskHistory';
 /**
  * Additional data recorded during profiling session
  */
@@ -18,22 +12,12 @@ export interface RumProfilerEnrichmentData {
     /** List of detected navigation entries */
     readonly views: RumViewEntry[];
 }
-export interface RumProfilerTrace extends ProfilerTrace, RumProfilerEnrichmentData {
-    /** High resolution time when profiler trace started, relative to the profiling session's time origin */
-    readonly startClocks: ClocksState;
-    /** High resolution time when profiler trace ended, relative to the profiling session's time origin */
-    readonly endClocks: ClocksState;
-    /** Time origin of the profiling session */
-    readonly clocksOrigin: ClocksState;
-    /** Sample interval in milliseconds */
-    readonly sampleInterval: number;
-}
 /**
  * Describes profiler session state when it's stopped
  */
 export interface RumProfilerStoppedInstance {
     readonly state: 'stopped';
-    readonly stateReason: 'session-expired' | 'stopped-by-user' | 'initializing';
+    readonly stateReason: 'session-expired' | 'stopped-by-user' | 'initializing' | 'quota_ko';
 }
 /**
  * Describes profiler session state when it's paused
@@ -55,18 +39,23 @@ export interface RumProfilerRunningInstance extends RumProfilerEnrichmentData {
     readonly timeoutId: TimeoutId;
     /** Clean-up tasks to execute after running the Profiler */
     readonly cleanupTasks: Array<() => void>;
+    /** Session ID */
+    readonly sessionId: string | undefined;
 }
 export type RumProfilerInstance = RumProfilerStoppedInstance | RumProfilerPausedInstance | RumProfilerRunningInstance;
 export interface RUMProfiler {
     start: () => void;
-    stop: () => Promise<void>;
+    stop: () => void;
     isStopped: () => boolean;
     isRunning: () => boolean;
     isPaused: () => boolean;
 }
+export interface ProfilingPayload {
+    profile: BrowserProfileEvent;
+    trace: BrowserProfilerTrace;
+}
 export interface RUMProfilerConfiguration {
     sampleIntervalMs: number;
     collectIntervalMs: number;
     minProfileDurationMs: number;
-    minNumberOfSamples: number;
 }

package/cjs/domain/profiling/utils/getCustomOrDefaultViewName.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCustomOrDefaultViewName = void 0;
-const getDefaultViewName_1 = require("./getDefaultViewName");
-const getCustomOrDefaultViewName = (customViewName, viewPathUrl) => customViewName || (0, getDefaultViewName_1.getDefaultViewName)(viewPathUrl);
+const require_getDefaultViewName = require("./getDefaultViewName.js");
+//#region src/domain/profiling/utils/getCustomOrDefaultViewName.ts
+const getCustomOrDefaultViewName = (customViewName, viewPathUrl) => customViewName || require_getDefaultViewName.getDefaultViewName(viewPathUrl);
+//#endregion
 exports.getCustomOrDefaultViewName = getCustomOrDefaultViewName;
+
 //# sourceMappingURL=getCustomOrDefaultViewName.js.map

package/cjs/domain/profiling/utils/getCustomOrDefaultViewName.js.map

@@ -1 +1 @@
-{"version":3,"file":"getCustomOrDefaultViewName.js","sourceRoot":"","sources":["../../../../src/domain/profiling/utils/getCustomOrDefaultViewName.ts"],"names":[],"mappings":";;;AAAA,6DAAyD;AAElD,MAAM,0BAA0B,GAAG,CAAC,cAAkC,EAAE,WAAmB,EAAU,EAAE,CAC5G,cAAc,IAAI,IAAA,uCAAkB,EAAC,WAAW,CAAC,CAAA;AADtC,QAAA,0BAA0B,8BACY"}
+{"version":3,"file":"getCustomOrDefaultViewName.js","names":["getDefaultViewName"],"sources":["../../../../src/domain/profiling/utils/getCustomOrDefaultViewName.ts"],"sourcesContent":["import { getDefaultViewName } from './getDefaultViewName'\n\nexport const getCustomOrDefaultViewName = (customViewName: string | undefined, viewPathUrl: string): string =>\n  customViewName || getDefaultViewName(viewPathUrl)\n"],"mappings":";;AAEA,MAAa,8BAA8B,gBAAoC,gBAC7E,kBAAkBA,2BAAAA,mBAAmB,WAAW"}

package/cjs/domain/profiling/utils/getDefaultViewName.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultViewName = getDefaultViewName;
-// This is the regex used to extract the path from the url (from SimpleUrlGroupingProcessor.java)
-// It's a bit different from the one in the java code because we removed the lookbehind unsupported by Safari.
+//#region src/domain/profiling/utils/getDefaultViewName.ts
 const PATH_MIXED_ALPHANUMERICS = /\/(?![vV]\d{1,2}\/)([^/\d?]*\d+[^/?]*)/g;
 function getDefaultViewName(viewPathUrl) {
-    if (!viewPathUrl) {
-        return '/';
-    }
-    // Replace all the mixed alphanumerics with a ?
-    return viewPathUrl.replace(PATH_MIXED_ALPHANUMERICS, '/?');
+	if (!viewPathUrl) return "/";
+	return viewPathUrl.replace(PATH_MIXED_ALPHANUMERICS, "/?");
 }
+//#endregion
+exports.getDefaultViewName = getDefaultViewName;
+
 //# sourceMappingURL=getDefaultViewName.js.map

package/cjs/domain/profiling/utils/getDefaultViewName.js.map

@@ -1 +1 @@
-{"version":3,"file":"getDefaultViewName.js","sourceRoot":"","sources":["../../../../src/domain/profiling/utils/getDefaultViewName.ts"],"names":[],"mappings":";;AAIA,gDAOC;AAXD,iGAAiG;AACjG,8GAA8G;AAC9G,MAAM,wBAAwB,GAAG,yCAAyC,CAAA;AAE1E,SAAgB,kBAAkB,CAAC,WAAmB;IACpD,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,+CAA+C;IAC/C,OAAO,WAAW,CAAC,OAAO,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAA;AAC5D,CAAC"}
+{"version":3,"file":"getDefaultViewName.js","names":[],"sources":["../../../../src/domain/profiling/utils/getDefaultViewName.ts"],"sourcesContent":["// This is the regex used to extract the path from the url (from SimpleUrlGroupingProcessor.java)\n// It's a bit different from the one in the java code because we removed the lookbehind unsupported by Safari.\nconst PATH_MIXED_ALPHANUMERICS = /\\/(?![vV]\\d{1,2}\\/)([^/\\d?]*\\d+[^/?]*)/g\n\nexport function getDefaultViewName(viewPathUrl: string): string {\n  if (!viewPathUrl) {\n    return '/'\n  }\n\n  // Replace all the mixed alphanumerics with a ?\n  return viewPathUrl.replace(PATH_MIXED_ALPHANUMERICS, '/?')\n}\n"],"mappings":";AAEA,MAAM,2BAA2B;AAEjC,SAAgB,mBAAmB,aAA6B;CAC9D,IAAI,CAAC,aACH,OAAO;CAIT,OAAO,YAAY,QAAQ,0BAA0B,IAAI;AAC3D"}

package/cjs/domain/profiling/vitalHistory.d.ts

@@ -0,0 +1,13 @@
+import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time';
+import type { LifeCycle } from '@kubesense/kubesense-browser-rum-core';
+import { VitalType } from '@kubesense/kubesense-browser-rum-core';
+export declare const VITAL_ID_HISTORY_TIME_OUT_DELAY: number;
+export interface VitalContext {
+    id: string;
+    type: VitalType;
+    label: string;
+    operationKey?: string;
+    duration?: Duration;
+    startClocks: ClocksState;
+}
+export declare function createVitalHistory(lifeCycle: LifeCycle): import("@kubesense/kubesense-browser-core").ValueHistory<VitalContext>;

package/cjs/domain/profiling/vitalHistory.js

@@ -0,0 +1,56 @@
+let _kubesense_kubesense_browser_rum_core = require("@kubesense/kubesense-browser-rum-core");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/profiling/vitalHistory.ts
+const VITAL_ID_HISTORY_TIME_OUT_DELAY = _kubesense_kubesense_browser_core.SESSION_TIME_OUT_DELAY;
+function createVitalHistory(lifeCycle) {
+	const history = (0, _kubesense_kubesense_browser_core.createValueHistory)({ expireDelay: VITAL_ID_HISTORY_TIME_OUT_DELAY });
+	lifeCycle.subscribe(_kubesense_kubesense_browser_rum_core.LifeCycleEventType.DURATION_VITAL_STARTED, (vitalStart) => {
+		history.add({
+			id: vitalStart.id,
+			type: _kubesense_kubesense_browser_rum_core.VitalType.DURATION,
+			startClocks: vitalStart.startClocks,
+			duration: void 0,
+			label: vitalStart.name
+		}, vitalStart.startClocks.relative);
+	});
+	lifeCycle.subscribe(_kubesense_kubesense_browser_rum_core.LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, ({ rawRumEvent, startClocks, duration }) => {
+		if (rawRumEvent.type !== "vital") return;
+		if (rawRumEvent.vital.type === _kubesense_kubesense_browser_rum_core.VitalType.OPERATION_STEP) {
+			if (rawRumEvent.vital.step_type === "start") history.add({
+				id: rawRumEvent.vital.id,
+				type: rawRumEvent.vital.type,
+				operationKey: rawRumEvent.vital.operation_key,
+				startClocks,
+				label: rawRumEvent.vital.name
+			}, startClocks.relative);
+			else if (rawRumEvent.vital.step_type === "end") {
+				const historyEntry = history.findAllEntries().find((entry) => entry.value.type === _kubesense_kubesense_browser_rum_core.VitalType.OPERATION_STEP && entry.value.label === rawRumEvent.vital.name && entry.value.operationKey === rawRumEvent.vital.operation_key);
+				if (!historyEntry) return;
+				historyEntry.value.duration = (0, _kubesense_kubesense_js_core_time.elapsed)(historyEntry.value.startClocks.relative, startClocks.relative);
+				historyEntry.close(startClocks.relative);
+			}
+			return;
+		}
+		const historyEntry = history.getEntries(startClocks.relative).find((entry) => entry.value.id === rawRumEvent.vital.id);
+		if (historyEntry) {
+			historyEntry.value.duration = duration;
+			historyEntry.close((0, _kubesense_kubesense_js_core_time.addDuration)(startClocks.relative, duration));
+			return;
+		}
+		history.add({
+			id: rawRumEvent.vital.id,
+			type: rawRumEvent.vital.type,
+			operationKey: rawRumEvent.vital.operation_key,
+			startClocks,
+			duration,
+			label: rawRumEvent.vital.name
+		}, startClocks.relative).close((0, _kubesense_kubesense_js_core_time.addDuration)(startClocks.relative, duration));
+	});
+	return history;
+}
+//#endregion
+exports.VITAL_ID_HISTORY_TIME_OUT_DELAY = VITAL_ID_HISTORY_TIME_OUT_DELAY;
+exports.createVitalHistory = createVitalHistory;
+
+//# sourceMappingURL=vitalHistory.js.map

package/cjs/domain/profiling/vitalHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitalHistory.js","names":["SESSION_TIME_OUT_DELAY","createValueHistory","LifeCycleEventType","VitalType","elapsed","addDuration"],"sources":["../../../src/domain/profiling/vitalHistory.ts"],"sourcesContent":["import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time'\nimport { elapsed, addDuration } from '@kubesense/kubesense-js-core/time'\nimport { createValueHistory, SESSION_TIME_OUT_DELAY } from '@kubesense/kubesense-browser-core'\nimport type { LifeCycle } from '@kubesense/kubesense-browser-rum-core'\nimport { LifeCycleEventType, VitalType } from '@kubesense/kubesense-browser-rum-core'\n\nexport const VITAL_ID_HISTORY_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY\n\nexport interface VitalContext {\n  id: string\n  type: VitalType\n  label: string\n  operationKey?: string\n  duration?: Duration\n  startClocks: ClocksState\n}\n\nexport function createVitalHistory(lifeCycle: LifeCycle) {\n  const history = createValueHistory<VitalContext>({\n    expireDelay: VITAL_ID_HISTORY_TIME_OUT_DELAY,\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.DURATION_VITAL_STARTED, (vitalStart) => {\n    history.add(\n      {\n        id: vitalStart.id,\n        type: VitalType.DURATION,\n        startClocks: vitalStart.startClocks,\n        duration: undefined,\n        label: vitalStart.name,\n      },\n      vitalStart.startClocks.relative\n    )\n  })\n\n  lifeCycle.subscribe(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, ({ rawRumEvent, startClocks, duration }) => {\n    if (rawRumEvent.type !== 'vital') {\n      return\n    }\n\n    // For operation step vitals, we only tag profiles with the start step's id.\n    // This means that if we receive an end step vital, we need to look for the\n    // corresponding start one and update its duration. If we receive a start step vital\n    // however, we just store it and wait for the end step.\n    if (rawRumEvent.vital.type === VitalType.OPERATION_STEP) {\n      if (rawRumEvent.vital.step_type === 'start') {\n        history.add(\n          {\n            id: rawRumEvent.vital.id,\n            type: rawRumEvent.vital.type,\n            operationKey: rawRumEvent.vital.operation_key,\n            startClocks,\n            label: rawRumEvent.vital.name,\n          },\n          startClocks.relative\n        )\n      } else if (rawRumEvent.vital.step_type === 'end') {\n        const historyEntry = history\n          .findAllEntries()\n          .find(\n            (entry) =>\n              entry.value.type === VitalType.OPERATION_STEP &&\n              entry.value.label === rawRumEvent.vital.name &&\n              entry.value.operationKey === rawRumEvent.vital.operation_key\n          )\n\n        if (!historyEntry) {\n          return\n        }\n\n        historyEntry.value.duration = elapsed(historyEntry.value.startClocks.relative, startClocks.relative)\n        historyEntry.close(startClocks.relative)\n      }\n\n      return\n    }\n\n    // All the other vital types are handled normally (i.e. stored in the\n    // history and tagged on the profiles)\n    const historyEntry = history\n      .getEntries(startClocks.relative)\n      .find((entry) => entry.value.id === rawRumEvent.vital.id)\n\n    if (historyEntry) {\n      historyEntry.value.duration = duration!\n      historyEntry.close(addDuration(startClocks.relative, duration!))\n      return\n    }\n\n    history\n      .add(\n        {\n          id: rawRumEvent.vital.id,\n          type: rawRumEvent.vital.type,\n          operationKey: rawRumEvent.vital.operation_key,\n          startClocks,\n          duration,\n          label: rawRumEvent.vital.name,\n        },\n        startClocks.relative\n      )\n      .close(addDuration(startClocks.relative, duration!))\n  })\n\n  return history\n}\n"],"mappings":";;;;AAMA,MAAa,kCAAkCA,kCAAAA;AAW/C,SAAgB,mBAAmB,WAAsB;CACvD,MAAM,WAAA,GAAUC,kCAAAA,mBAAAA,CAAiC,EAC/C,aAAa,gCACf,CAAC;CAED,UAAU,UAAUC,sCAAAA,mBAAmB,yBAAyB,eAAe;EAC7E,QAAQ,IACN;GACE,IAAI,WAAW;GACf,MAAMC,sCAAAA,UAAU;GAChB,aAAa,WAAW;GACxB,UAAU,KAAA;GACV,OAAO,WAAW;EACpB,GACA,WAAW,YAAY,QACzB;CACF,CAAC;CAED,UAAU,UAAUD,sCAAAA,mBAAmB,0BAA0B,EAAE,aAAa,aAAa,eAAe;EAC1G,IAAI,YAAY,SAAS,SACvB;EAOF,IAAI,YAAY,MAAM,SAASC,sCAAAA,UAAU,gBAAgB;GACvD,IAAI,YAAY,MAAM,cAAc,SAClC,QAAQ,IACN;IACE,IAAI,YAAY,MAAM;IACtB,MAAM,YAAY,MAAM;IACxB,cAAc,YAAY,MAAM;IAChC;IACA,OAAO,YAAY,MAAM;GAC3B,GACA,YAAY,QACd;QACK,IAAI,YAAY,MAAM,cAAc,OAAO;IAChD,MAAM,eAAe,QAClB,eAAe,CAAC,CAChB,MACE,UACC,MAAM,MAAM,SAASA,sCAAAA,UAAU,kBAC/B,MAAM,MAAM,UAAU,YAAY,MAAM,QACxC,MAAM,MAAM,iBAAiB,YAAY,MAAM,aACnD;IAEF,IAAI,CAAC,cACH;IAGF,aAAa,MAAM,YAAA,GAAWC,kCAAAA,QAAAA,CAAQ,aAAa,MAAM,YAAY,UAAU,YAAY,QAAQ;IACnG,aAAa,MAAM,YAAY,QAAQ;GACzC;GAEA;EACF;EAIA,MAAM,eAAe,QAClB,WAAW,YAAY,QAAQ,CAAC,CAChC,MAAM,UAAU,MAAM,MAAM,OAAO,YAAY,MAAM,EAAE;EAE1D,IAAI,cAAc;GAChB,aAAa,MAAM,WAAW;GAC9B,aAAa,OAAA,GAAMC,kCAAAA,YAAAA,CAAY,YAAY,UAAU,QAAS,CAAC;GAC/D;EACF;EAEA,QACG,IACC;GACE,IAAI,YAAY,MAAM;GACtB,MAAM,YAAY,MAAM;GACxB,cAAc,YAAY,MAAM;GAChC;GACA;GACA,OAAO,YAAY,MAAM;EAC3B,GACA,YAAY,QACd,CAAC,CACA,OAAA,GAAMA,kCAAAA,YAAAA,CAAY,YAAY,UAAU,QAAS,CAAC;CACvD,CAAC;CAED,OAAO;AACT"}

package/cjs/domain/record/assembly.d.ts

@@ -1,2 +1,3 @@
+import type { TimeStamp } from '@kubesense/kubesense-js-core/time';
 import type { BrowserIncrementalData, BrowserIncrementalSnapshotRecord } from '../../types';
-export declare function assembleIncrementalSnapshot<Data extends BrowserIncrementalData>(source: Data['source'], data: Omit<Data, 'source'>): BrowserIncrementalSnapshotRecord;
+export declare function assembleIncrementalSnapshot<Data extends BrowserIncrementalData>(source: Data['source'], data: Omit<Data, 'source'>, timestamp?: TimeStamp): BrowserIncrementalSnapshotRecord;

package/cjs/domain/record/assembly.js

@@ -1,16 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assembleIncrementalSnapshot = assembleIncrementalSnapshot;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const types_1 = require("../../types");
-function assembleIncrementalSnapshot(source, data) {
-    return {
-        data: {
-            source,
-            ...data,
-        },
-        type: types_1.RecordType.IncrementalSnapshot,
-        timestamp: (0, kubesense_browser_core_1.timeStampNow)(),
-    };
+const require_sessionReplayConstants = require("../../types/sessionReplayConstants.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/record/assembly.ts
+function assembleIncrementalSnapshot(source, data, timestamp = (0, _kubesense_kubesense_js_core_time.timeStampNow)()) {
+	return {
+		data: {
+			source,
+			...data
+		},
+		type: require_sessionReplayConstants.RecordType.IncrementalSnapshot,
+		timestamp
+	};
 }
+//#endregion
+exports.assembleIncrementalSnapshot = assembleIncrementalSnapshot;
+
 //# sourceMappingURL=assembly.js.map

package/cjs/domain/record/assembly.js.map

@@ -1 +1 @@
-{"version":3,"file":"assembly.js","sourceRoot":"","sources":["../../../src/domain/record/assembly.ts"],"names":[],"mappings":";;AAIA,kEAYC;AAhBD,8EAAgE;AAEhE,uCAAwC;AAExC,SAAgB,2BAA2B,CACzC,MAAsB,EACtB,IAA0B;IAE1B,OAAO;QACL,IAAI,EAAE;YACJ,MAAM;YACN,GAAG,IAAI;SACA;QACT,IAAI,EAAE,kBAAU,CAAC,mBAAmB;QACpC,SAAS,EAAE,IAAA,qCAAY,GAAE;KAC1B,CAAA;AACH,CAAC"}
+{"version":3,"file":"assembly.js","names":["timeStampNow","RecordType"],"sources":["../../../src/domain/record/assembly.ts"],"sourcesContent":["import { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { TimeStamp } from '@kubesense/kubesense-js-core/time'\nimport type { BrowserIncrementalData, BrowserIncrementalSnapshotRecord } from '../../types'\nimport { RecordType } from '../../types'\n\nexport function assembleIncrementalSnapshot<Data extends BrowserIncrementalData>(\n  source: Data['source'],\n  data: Omit<Data, 'source'>,\n  timestamp: TimeStamp = timeStampNow()\n): BrowserIncrementalSnapshotRecord {\n  return {\n    data: {\n      source,\n      ...data,\n    } as Data,\n    type: RecordType.IncrementalSnapshot,\n    timestamp,\n  }\n}\n"],"mappings":";;;AAKA,SAAgB,4BACd,QACA,MACA,aAAA,GAAuBA,kCAAAA,aAAAA,CAAa,GACF;CAClC,OAAO;EACL,MAAM;GACJ;GACA,GAAG;EACL;EACA,MAAMC,+BAAAA,WAAW;EACjB;CACF;AACF"}

package/cjs/domain/record/canvas/canvasHash.d.ts

@@ -0,0 +1,2 @@
+import type { CanvasSnapshot } from './canvasSnapshot';
+export declare function computeImageHash(snapshot: CanvasSnapshot, maxHashDimension: number): Promise<string | undefined>;

package/cjs/domain/record/canvas/canvasHash.js

@@ -0,0 +1,33 @@
+const require_canvasSnapshot = require("./canvasSnapshot.js");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+//#region src/domain/record/canvas/canvasHash.ts
+function computeImageHash(snapshot, maxHashDimension) {
+	const { height: sourceHeight, width: sourceWidth } = snapshot.source;
+	const thumbnail = Math.max(sourceWidth, sourceHeight) <= maxHashDimension ? snapshot.source : require_canvasSnapshot.createDownscaledCanvas(snapshot.source, sourceWidth, sourceHeight, maxHashDimension);
+	if (!thumbnail) return Promise.resolve(void 0);
+	const context = thumbnail.getContext("2d");
+	if (!context) return Promise.resolve(void 0);
+	const data = context.getImageData(0, 0, thumbnail.width, thumbnail.height).data;
+	const subtleCrypto = (0, _kubesense_kubesense_browser_core.mockable)(_kubesense_kubesense_js_core_util.globalObject.crypto?.subtle);
+	if (!subtleCrypto) return Promise.resolve(createChangeHash(snapshot.canvasWidth, snapshot.canvasHeight, fnv1aHash(data)));
+	return subtleCrypto.digest("SHA-256", data).then((buffer) => createChangeHash(snapshot.canvasWidth, snapshot.canvasHeight, arrayBufferToHex(buffer)), () => createChangeHash(snapshot.canvasWidth, snapshot.canvasHeight, fnv1aHash(data)));
+}
+function arrayBufferToHex(buffer) {
+	return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function createChangeHash(width, height, pixelHash) {
+	return `${width}x${height}-${pixelHash}`;
+}
+function fnv1aHash(data) {
+	let hash = 2166136261;
+	for (let index = 0; index < data.length; index += 1) {
+		hash ^= data[index];
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+//#endregion
+exports.computeImageHash = computeImageHash;
+
+//# sourceMappingURL=canvasHash.js.map

package/cjs/domain/record/canvas/canvasHash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvasHash.js","names":["createDownscaledCanvas","mockable","globalObject"],"sources":["../../../../src/domain/record/canvas/canvasHash.ts"],"sourcesContent":["import { mockable } from '@kubesense/kubesense-browser-core'\nimport { globalObject } from '@kubesense/kubesense-js-core/util'\nimport type { CanvasSnapshot } from './canvasSnapshot'\nimport { createDownscaledCanvas } from './canvasSnapshot'\n\nexport function computeImageHash(snapshot: CanvasSnapshot, maxHashDimension: number): Promise<string | undefined> {\n  const { height: sourceHeight, width: sourceWidth } = snapshot.source\n  // The snapshot is already frozen, so if it already fits, hash it directly instead of downscaling it again.\n  const thumbnail =\n    Math.max(sourceWidth, sourceHeight) <= maxHashDimension\n      ? snapshot.source\n      : createDownscaledCanvas(snapshot.source, sourceWidth, sourceHeight, maxHashDimension)\n  if (!thumbnail) {\n    return Promise.resolve(undefined)\n  }\n\n  const context = thumbnail.getContext('2d')\n  if (!context) {\n    return Promise.resolve(undefined)\n  }\n\n  const data = context.getImageData(0, 0, thumbnail.width, thumbnail.height).data\n  // crypto.subtle is only exposed in secure contexts, so it is missing on plain HTTP pages.\n  const subtleCrypto = mockable(globalObject.crypto?.subtle)\n  if (!subtleCrypto) {\n    return Promise.resolve(createChangeHash(snapshot.canvasWidth, snapshot.canvasHeight, fnv1aHash(data)))\n  }\n\n  return subtleCrypto.digest('SHA-256', data).then(\n    (buffer) => createChangeHash(snapshot.canvasWidth, snapshot.canvasHeight, arrayBufferToHex(buffer)),\n    () => createChangeHash(snapshot.canvasWidth, snapshot.canvasHeight, fnv1aHash(data))\n  )\n}\n\nfunction arrayBufferToHex(buffer: ArrayBuffer): string {\n  return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, '0')).join('')\n}\n\nfunction createChangeHash(width: number, height: number, pixelHash: string): string {\n  return `${width}x${height}-${pixelHash}`\n}\n\n/* eslint-disable no-bitwise */\nfunction fnv1aHash(data: ArrayLike<number>): string {\n  let hash = 0x811c9dc5\n\n  for (let index = 0; index < data.length; index += 1) {\n    hash ^= data[index]\n    hash = Math.imul(hash, 0x01000193)\n  }\n\n  return (hash >>> 0).toString(16).padStart(8, '0')\n}\n/* eslint-enable no-bitwise */\n"],"mappings":";;;;AAKA,SAAgB,iBAAiB,UAA0B,kBAAuD;CAChH,MAAM,EAAE,QAAQ,cAAc,OAAO,gBAAgB,SAAS;CAE9D,MAAM,YACJ,KAAK,IAAI,aAAa,YAAY,KAAK,mBACnC,SAAS,SACTA,uBAAAA,uBAAuB,SAAS,QAAQ,aAAa,cAAc,gBAAgB;CACzF,IAAI,CAAC,WACH,OAAO,QAAQ,QAAQ,KAAA,CAAS;CAGlC,MAAM,UAAU,UAAU,WAAW,IAAI;CACzC,IAAI,CAAC,SACH,OAAO,QAAQ,QAAQ,KAAA,CAAS;CAGlC,MAAM,OAAO,QAAQ,aAAa,GAAG,GAAG,UAAU,OAAO,UAAU,MAAM,CAAC,CAAC;CAE3E,MAAM,gBAAA,GAAeC,kCAAAA,SAAAA,CAASC,kCAAAA,aAAa,QAAQ,MAAM;CACzD,IAAI,CAAC,cACH,OAAO,QAAQ,QAAQ,iBAAiB,SAAS,aAAa,SAAS,cAAc,UAAU,IAAI,CAAC,CAAC;CAGvG,OAAO,aAAa,OAAO,WAAW,IAAI,CAAC,CAAC,MACzC,WAAW,iBAAiB,SAAS,aAAa,SAAS,cAAc,iBAAiB,MAAM,CAAC,SAC5F,iBAAiB,SAAS,aAAa,SAAS,cAAc,UAAU,IAAI,CAAC,CACrF;AACF;AAEA,SAAS,iBAAiB,QAA6B;CACrD,OAAO,MAAM,KAAK,IAAI,WAAW,MAAM,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE;AACjG;AAEA,SAAS,iBAAiB,OAAe,QAAgB,WAA2B;CAClF,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG;AAC/B;AAGA,SAAS,UAAU,MAAiC;CAClD,IAAI,OAAO;CAEX,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;EACnD,QAAQ,KAAK;EACb,OAAO,KAAK,KAAK,MAAM,QAAU;CACnC;CAEA,QAAQ,SAAS,EAAA,CAAG,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;AAClD"}

package/cjs/domain/record/canvas/canvasManager.d.ts

@@ -0,0 +1,42 @@
+export declare const enum CanvasStatus {
+    /** The canvas is clean, meaning it has not been marked as dirty or tainted */
+    Clean = 0,
+    /** The canvas is dirty, meaning it has been marked as dirty by a draw operation */
+    Dirty = 1,
+    /** The canvas is tainted, meaning it has been marked as tainted by a SecurityError */
+    Tainted = 2
+}
+export interface CanvasCaptureAttempt {
+    /** changeHash emitted the last time this canvas was captured, taken when the attempt started */
+    readonly lastChangeHash: string | undefined;
+    /** false if the canvas was forgotten/reset, or if another attempt took its place */
+    isCurrent: () => boolean;
+    /** stores the changeHash */
+    setLastChangeHash: (changeHash: string) => void;
+}
+export interface CanvasContentMutation {
+    canvas: HTMLCanvasElement;
+    captureAttempt: CanvasCaptureAttempt;
+    hash: string;
+    image: Blob;
+}
+export interface CanvasManager {
+    /** Single entry point for the canvas status */
+    markCanvas: (canvas: HTMLCanvasElement, status: CanvasStatus) => void;
+    /** The node left the DOM: forget its tracking state, but not its taint */
+    forgetCanvas: (canvas: HTMLCanvasElement) => void;
+    /** width/height were assigned: the bitmap was cleared, so drop the last hash and mark dirty */
+    resetCanvasBitmap: (canvas: HTMLCanvasElement) => void;
+    /** Takes dirty, connected, non-tainted canvases and clears their dirty state */
+    takeCapturableCanvases: () => HTMLCanvasElement[];
+    /** Starts a capture attempt for a canvas */
+    startCaptureAttempt: (canvas: HTMLCanvasElement) => CanvasCaptureAttempt;
+    discardCaptureAttempt: (canvas: HTMLCanvasElement, captureAttempt: CanvasCaptureAttempt) => void;
+    /** Discards the last capture hash and retries a rejected capture */
+    retryCanvas: (canvas: HTMLCanvasElement) => void;
+    addCanvasContentMutation: (mutation: CanvasContentMutation) => void;
+    takeCanvasContentMutations: () => CanvasContentMutation[];
+    /** New record stream: discards the per-stream tracking states (not the taint) */
+    reset: () => void;
+}
+export declare function createCanvasManager(): CanvasManager;

package/cjs/domain/record/canvas/canvasManager.js

@@ -0,0 +1,99 @@
+//#region src/domain/record/canvas/canvasManager.ts
+function createCanvasManager() {
+	const dirtyCanvases = /* @__PURE__ */ new Set();
+	const taintedCanvases = /* @__PURE__ */ new WeakSet();
+	let canvasContentMutations = [];
+	let canvasTrackingStates = /* @__PURE__ */ new WeakMap();
+	function getTrackingState(canvas) {
+		let trackingState = canvasTrackingStates.get(canvas);
+		if (!trackingState) {
+			trackingState = { capturePending: false };
+			canvasTrackingStates.set(canvas, trackingState);
+		}
+		return trackingState;
+	}
+	function startCaptureAttempt(canvas) {
+		const trackingState = getTrackingState(canvas);
+		trackingState.capturePending = true;
+		const isCurrent = () => canvasTrackingStates.get(canvas) === trackingState;
+		return {
+			lastChangeHash: trackingState.lastChangeHash,
+			isCurrent,
+			setLastChangeHash: (changeHash) => {
+				if (isCurrent()) trackingState.lastChangeHash = changeHash;
+			}
+		};
+	}
+	function markDirty(canvas) {
+		if (!canvas.isConnected || taintedCanvases.has(canvas)) return;
+		dirtyCanvases.add(canvas);
+	}
+	function markClean(canvas) {
+		dirtyCanvases.delete(canvas);
+	}
+	function markTainted(canvas) {
+		taintedCanvases.add(canvas);
+		dirtyCanvases.delete(canvas);
+	}
+	return {
+		markCanvas: (canvas, status) => {
+			switch (status) {
+				case 1:
+					markDirty(canvas);
+					return;
+				case 0:
+					markClean(canvas);
+					return;
+				case 2:
+					markTainted(canvas);
+					return;
+				default: return;
+			}
+		},
+		forgetCanvas: (canvas) => {
+			dirtyCanvases.delete(canvas);
+			canvasTrackingStates.delete(canvas);
+		},
+		resetCanvasBitmap: (canvas) => {
+			canvasTrackingStates.delete(canvas);
+			markDirty(canvas);
+		},
+		takeCapturableCanvases: () => {
+			const capturableCanvases = [];
+			dirtyCanvases.forEach((canvas) => {
+				if (!canvas.isConnected) dirtyCanvases.delete(canvas);
+				else if (!taintedCanvases.has(canvas) && !getTrackingState(canvas).capturePending) {
+					dirtyCanvases.delete(canvas);
+					capturableCanvases.push(canvas);
+				}
+			});
+			return capturableCanvases;
+		},
+		startCaptureAttempt,
+		discardCaptureAttempt: (canvas, captureAttempt) => {
+			if (captureAttempt.isCurrent()) getTrackingState(canvas).capturePending = false;
+		},
+		retryCanvas: (canvas) => {
+			canvasTrackingStates.delete(canvas);
+			markDirty(canvas);
+		},
+		addCanvasContentMutation: (mutation) => {
+			canvasContentMutations.push(mutation);
+		},
+		takeCanvasContentMutations: () => {
+			const mutations = canvasContentMutations;
+			canvasContentMutations = [];
+			for (const mutation of mutations) if (mutation.captureAttempt.isCurrent()) getTrackingState(mutation.canvas).capturePending = false;
+			return mutations;
+		},
+		reset: () => {
+			dirtyCanvases.clear();
+			canvasContentMutations = [];
+			canvasTrackingStates = /* @__PURE__ */ new WeakMap();
+		}
+	};
+}
+//#endregion
+exports.createCanvasManager = createCanvasManager;
+
+//# sourceMappingURL=canvasManager.js.map

package/cjs/domain/record/canvas/canvasManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvasManager.js","names":[],"sources":["../../../../src/domain/record/canvas/canvasManager.ts"],"sourcesContent":["export const enum CanvasStatus {\n  /** The canvas is clean, meaning it has not been marked as dirty or tainted */\n  Clean,\n  /** The canvas is dirty, meaning it has been marked as dirty by a draw operation */\n  Dirty,\n  /** The canvas is tainted, meaning it has been marked as tainted by a SecurityError */\n  Tainted,\n}\n\nexport interface CanvasCaptureAttempt {\n  /** changeHash emitted the last time this canvas was captured, taken when the attempt started */\n  readonly lastChangeHash: string | undefined\n  /** false if the canvas was forgotten/reset, or if another attempt took its place */\n  isCurrent: () => boolean\n  /** stores the changeHash */\n  setLastChangeHash: (changeHash: string) => void\n}\n\nexport interface CanvasContentMutation {\n  canvas: HTMLCanvasElement\n  captureAttempt: CanvasCaptureAttempt\n  hash: string\n  image: Blob\n}\n\nexport interface CanvasManager {\n  /** Single entry point for the canvas status */\n  markCanvas: (canvas: HTMLCanvasElement, status: CanvasStatus) => void\n  /** The node left the DOM: forget its tracking state, but not its taint */\n  forgetCanvas: (canvas: HTMLCanvasElement) => void\n  /** width/height were assigned: the bitmap was cleared, so drop the last hash and mark dirty */\n  resetCanvasBitmap: (canvas: HTMLCanvasElement) => void\n  /** Takes dirty, connected, non-tainted canvases and clears their dirty state */\n  takeCapturableCanvases: () => HTMLCanvasElement[]\n  /** Starts a capture attempt for a canvas */\n  startCaptureAttempt: (canvas: HTMLCanvasElement) => CanvasCaptureAttempt\n  discardCaptureAttempt: (canvas: HTMLCanvasElement, captureAttempt: CanvasCaptureAttempt) => void\n  /** Discards the last capture hash and retries a rejected capture */\n  retryCanvas: (canvas: HTMLCanvasElement) => void\n  addCanvasContentMutation: (mutation: CanvasContentMutation) => void\n  takeCanvasContentMutations: () => CanvasContentMutation[]\n  /** New record stream: discards the per-stream tracking states (not the taint) */\n  reset: () => void\n}\n\ninterface CanvasTrackingState {\n  capturePending: boolean\n  lastChangeHash?: string\n}\n\nexport function createCanvasManager(): CanvasManager {\n  const dirtyCanvases = new Set<HTMLCanvasElement>()\n  const taintedCanvases = new WeakSet<HTMLCanvasElement>()\n  let canvasContentMutations: CanvasContentMutation[] = []\n  let canvasTrackingStates = new WeakMap<HTMLCanvasElement, CanvasTrackingState>()\n\n  function getTrackingState(canvas: HTMLCanvasElement): CanvasTrackingState {\n    let trackingState = canvasTrackingStates.get(canvas)\n    if (!trackingState) {\n      trackingState = { capturePending: false }\n      canvasTrackingStates.set(canvas, trackingState)\n    }\n    return trackingState\n  }\n\n  function startCaptureAttempt(canvas: HTMLCanvasElement): CanvasCaptureAttempt {\n    const trackingState = getTrackingState(canvas)\n    trackingState.capturePending = true\n    const isCurrent = () => canvasTrackingStates.get(canvas) === trackingState\n\n    return {\n      lastChangeHash: trackingState.lastChangeHash,\n      isCurrent,\n      setLastChangeHash: (changeHash) => {\n        if (isCurrent()) {\n          trackingState.lastChangeHash = changeHash\n        }\n      },\n    }\n  }\n\n  function markDirty(canvas: HTMLCanvasElement) {\n    if (!canvas.isConnected || taintedCanvases.has(canvas)) {\n      return\n    }\n    dirtyCanvases.add(canvas)\n  }\n\n  function markClean(canvas: HTMLCanvasElement) {\n    dirtyCanvases.delete(canvas)\n  }\n\n  function markTainted(canvas: HTMLCanvasElement) {\n    taintedCanvases.add(canvas)\n    dirtyCanvases.delete(canvas)\n  }\n\n  return {\n    markCanvas: (canvas, status) => {\n      switch (status) {\n        case CanvasStatus.Dirty:\n          markDirty(canvas)\n          return\n        case CanvasStatus.Clean:\n          markClean(canvas)\n          return\n        case CanvasStatus.Tainted:\n          markTainted(canvas)\n          return\n        default:\n          status satisfies never\n          return\n      }\n    },\n\n    forgetCanvas: (canvas) => {\n      dirtyCanvases.delete(canvas)\n      canvasTrackingStates.delete(canvas)\n    },\n\n    resetCanvasBitmap: (canvas) => {\n      canvasTrackingStates.delete(canvas)\n      markDirty(canvas)\n    },\n\n    takeCapturableCanvases: () => {\n      const capturableCanvases: HTMLCanvasElement[] = []\n\n      dirtyCanvases.forEach((canvas) => {\n        if (!canvas.isConnected) {\n          dirtyCanvases.delete(canvas)\n        } else if (!taintedCanvases.has(canvas) && !getTrackingState(canvas).capturePending) {\n          dirtyCanvases.delete(canvas)\n          capturableCanvases.push(canvas)\n        }\n      })\n\n      return capturableCanvases\n    },\n\n    startCaptureAttempt,\n\n    discardCaptureAttempt: (canvas, captureAttempt) => {\n      if (captureAttempt.isCurrent()) {\n        getTrackingState(canvas).capturePending = false\n      }\n    },\n\n    retryCanvas: (canvas) => {\n      canvasTrackingStates.delete(canvas)\n      markDirty(canvas)\n    },\n\n    addCanvasContentMutation: (mutation) => {\n      canvasContentMutations.push(mutation)\n    },\n\n    takeCanvasContentMutations: () => {\n      const mutations = canvasContentMutations\n      canvasContentMutations = []\n      for (const mutation of mutations) {\n        if (mutation.captureAttempt.isCurrent()) {\n          getTrackingState(mutation.canvas).capturePending = false\n        }\n      }\n      return mutations\n    },\n\n    reset: () => {\n      dirtyCanvases.clear()\n      canvasContentMutations = []\n      canvasTrackingStates = new WeakMap()\n    },\n  }\n}\n"],"mappings":";AAkDA,SAAgB,sBAAqC;CACnD,MAAM,gCAAgB,IAAI,IAAuB;CACjD,MAAM,kCAAkB,IAAI,QAA2B;CACvD,IAAI,yBAAkD,CAAC;CACvD,IAAI,uCAAuB,IAAI,QAAgD;CAE/E,SAAS,iBAAiB,QAAgD;EACxE,IAAI,gBAAgB,qBAAqB,IAAI,MAAM;EACnD,IAAI,CAAC,eAAe;GAClB,gBAAgB,EAAE,gBAAgB,MAAM;GACxC,qBAAqB,IAAI,QAAQ,aAAa;EAChD;EACA,OAAO;CACT;CAEA,SAAS,oBAAoB,QAAiD;EAC5E,MAAM,gBAAgB,iBAAiB,MAAM;EAC7C,cAAc,iBAAiB;EAC/B,MAAM,kBAAkB,qBAAqB,IAAI,MAAM,MAAM;EAE7D,OAAO;GACL,gBAAgB,cAAc;GAC9B;GACA,oBAAoB,eAAe;IACjC,IAAI,UAAU,GACZ,cAAc,iBAAiB;GAEnC;EACF;CACF;CAEA,SAAS,UAAU,QAA2B;EAC5C,IAAI,CAAC,OAAO,eAAe,gBAAgB,IAAI,MAAM,GACnD;EAEF,cAAc,IAAI,MAAM;CAC1B;CAEA,SAAS,UAAU,QAA2B;EAC5C,cAAc,OAAO,MAAM;CAC7B;CAEA,SAAS,YAAY,QAA2B;EAC9C,gBAAgB,IAAI,MAAM;EAC1B,cAAc,OAAO,MAAM;CAC7B;CAEA,OAAO;EACL,aAAa,QAAQ,WAAW;GAC9B,QAAQ,QAAR;IACE,KAAA;KACE,UAAU,MAAM;KAChB;IACF,KAAA;KACE,UAAU,MAAM;KAChB;IACF,KAAA;KACE,YAAY,MAAM;KAClB;IACF,SAEE;GACJ;EACF;EAEA,eAAe,WAAW;GACxB,cAAc,OAAO,MAAM;GAC3B,qBAAqB,OAAO,MAAM;EACpC;EAEA,oBAAoB,WAAW;GAC7B,qBAAqB,OAAO,MAAM;GAClC,UAAU,MAAM;EAClB;EAEA,8BAA8B;GAC5B,MAAM,qBAA0C,CAAC;GAEjD,cAAc,SAAS,WAAW;IAChC,IAAI,CAAC,OAAO,aACV,cAAc,OAAO,MAAM;SACtB,IAAI,CAAC,gBAAgB,IAAI,MAAM,KAAK,CAAC,iBAAiB,MAAM,CAAC,CAAC,gBAAgB;KACnF,cAAc,OAAO,MAAM;KAC3B,mBAAmB,KAAK,MAAM;IAChC;GACF,CAAC;GAED,OAAO;EACT;EAEA;EAEA,wBAAwB,QAAQ,mBAAmB;GACjD,IAAI,eAAe,UAAU,GAC3B,iBAAiB,MAAM,CAAC,CAAC,iBAAiB;EAE9C;EAEA,cAAc,WAAW;GACvB,qBAAqB,OAAO,MAAM;GAClC,UAAU,MAAM;EAClB;EAEA,2BAA2B,aAAa;GACtC,uBAAuB,KAAK,QAAQ;EACtC;EAEA,kCAAkC;GAChC,MAAM,YAAY;GAClB,yBAAyB,CAAC;GAC1B,KAAK,MAAM,YAAY,WACrB,IAAI,SAAS,eAAe,UAAU,GACpC,iBAAiB,SAAS,MAAM,CAAC,CAAC,iBAAiB;GAGvD,OAAO;EACT;EAEA,aAAa;GACX,cAAc,MAAM;GACpB,yBAAyB,CAAC;GAC1B,uCAAuB,IAAI,QAAQ;EACrC;CACF;AACF"}

package/cjs/domain/record/canvas/canvasSnapshot.d.ts

@@ -0,0 +1,8 @@
+export interface CanvasSnapshot {
+    canvasHeight: number;
+    canvasWidth: number;
+    source: HTMLCanvasElement;
+}
+export declare function createCanvasSnapshot(canvas: HTMLCanvasElement, maxImageDimension: number): CanvasSnapshot | undefined;
+export declare function createDownscaledCanvas(image: CanvasImageSource, width: number, height: number, maxDimension: number): HTMLCanvasElement | undefined;
+export declare function captureCanvasImage(snapshot: CanvasSnapshot, encodeQuality: number): Promise<Blob | undefined>;