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

package/esm/domain/record/encoding/changeDecoder.mjs

@@ -0,0 +1,152 @@
+import { ChangeType, StringRole } from "../../../types/sessionReplayConstants.mjs";
+import { createStringTable } from "./stringTable.mjs";
+//#region src/domain/record/encoding/changeDecoder.ts
+function createChangeDecoder({ allowObsoleteStringRepresentations = false, keepRoles = false } = {}) {
+	const self = {
+		decode(record) {
+			return decodeChangeRecord(record, self.stringTable, allowObsoleteStringRepresentations);
+		},
+		stringTable: createStringTable(allowObsoleteStringRepresentations, keepRoles)
+	};
+	return self;
+}
+function decodeChangeRecord(record, stringTable, allowObsoleteStringRepresentations) {
+	const decodedData = [];
+	for (const change of record.data) switch (change[0]) {
+		case ChangeType.AddString:
+			if (!allowObsoleteStringRepresentations) throw new Error("Obsolete AddString change: string table entries are defined by role now");
+			for (let i = 1; i < change.length; i++) stringTable.add(change[i], StringRole.Default);
+			break;
+		case ChangeType.AddRoleAnnotatedStrings:
+			for (let i = 1; i < change.length; i++) {
+				const [role, ...newStrings] = change[i];
+				for (const newString of newStrings) stringTable.add(newString, role);
+			}
+			break;
+		case ChangeType.ClearStrings:
+			stringTable.clear();
+			break;
+		case ChangeType.AddNode: {
+			const decoded = [ChangeType.AddNode];
+			for (let i = 1; i < change.length; i++) decoded.push(decodeAddNodeChange(change[i], stringTable));
+			decodedData.push(decoded);
+			break;
+		}
+		case ChangeType.RemoveNode:
+			decodedData.push(change);
+			break;
+		case ChangeType.Attribute: {
+			const decoded = [ChangeType.Attribute];
+			for (let i = 1; i < change.length; i++) decoded.push(decodeAttributeChange(change[i], stringTable));
+			decodedData.push(decoded);
+			break;
+		}
+		case ChangeType.Text: {
+			const decoded = [ChangeType.Text];
+			for (let i = 1; i < change.length; i++) decoded.push(decodeTextChange(change[i], stringTable));
+			decodedData.push(decoded);
+			break;
+		}
+		case ChangeType.InputValue: {
+			const decoded = [ChangeType.InputValue];
+			for (let i = 1; i < change.length; i++) decoded.push(decodeInputValueChange(change[i], stringTable));
+			decodedData.push(decoded);
+			break;
+		}
+		case ChangeType.Size:
+		case ChangeType.ScrollPosition:
+		case ChangeType.AttachedStyleSheets:
+		case ChangeType.MediaPlaybackState:
+		case ChangeType.VisualViewport:
+		case ChangeType.InputSelection:
+			decodedData.push(change);
+			break;
+		case ChangeType.AddStyleSheet: {
+			const decoded = [ChangeType.AddStyleSheet];
+			for (let i = 1; i < change.length; i++) decoded.push(decodeAddStyleSheetChange(change[i], stringTable));
+			decodedData.push(decoded);
+			break;
+		}
+		case ChangeType.ImageContent: {
+			const decoded = [ChangeType.ImageContent];
+			for (let i = 1; i < change.length; i++) {
+				const imageContentChange = change[i];
+				decoded.push([imageContentChange[0], stringTable.decodeAnnotated(imageContentChange[1])]);
+			}
+			decodedData.push(decoded);
+			break;
+		}
+		default: throw new Error(`Unsupported ChangeType: ${change[0]}`);
+	}
+	return {
+		...record,
+		data: decodedData
+	};
+}
+function decodeAddNodeChange(change, stringTable) {
+	const insertionPoint = change[0];
+	const nodeName = stringTable.decode(change[1]);
+	const decodedNodeName = stringTable.decodeAnnotated(change[1]);
+	switch (nodeName) {
+		case "#cdata-section":
+		case "#document":
+		case "#document-fragment":
+		case "#shadow-root": return [insertionPoint, decodedNodeName];
+		case "#doctype": {
+			const [, , name, publicId, systemId] = change;
+			return [
+				insertionPoint,
+				decodedNodeName,
+				stringTable.decodeAnnotated(name),
+				stringTable.decodeAnnotated(publicId),
+				stringTable.decodeAnnotated(systemId)
+			];
+		}
+		case "#text": {
+			const [, , textContent] = change;
+			return [
+				insertionPoint,
+				decodedNodeName,
+				stringTable.decodeAnnotated(textContent)
+			];
+		}
+		default: {
+			const decodedChange = [insertionPoint, decodedNodeName];
+			const [, , ...attrs] = change;
+			for (const [name, value] of attrs) decodedChange.push([stringTable.decodeAnnotated(name), stringTable.decodeAnnotated(value)]);
+			return decodedChange;
+		}
+	}
+}
+function decodeAttributeChange(change, stringTable) {
+	const [nodeId, ...mutations] = change;
+	const decodedMutations = mutations.map((mutation) => {
+		if (mutation.length === 1) return [stringTable.decodeAnnotated(mutation[0])];
+		return [stringTable.decodeAnnotated(mutation[0]), stringTable.decodeAnnotated(mutation[1])];
+	});
+	const decodedChange = [nodeId];
+	decodedChange.push(...decodedMutations);
+	return decodedChange;
+}
+function decodeTextChange(change, stringTable) {
+	return [change[0], stringTable.decodeAnnotated(change[1])];
+}
+function decodeInputValueChange(change, stringTable) {
+	return [change[0], stringTable.decodeAnnotated(change[1])];
+}
+function decodeAddStyleSheetChange(change, stringTable) {
+	const rules = change[0];
+	const decodedRules = Array.isArray(rules) ? rules.map((rule) => stringTable.decodeAnnotated(rule)) : stringTable.decodeAnnotated(rules);
+	if (change.length === 1) return [decodedRules];
+	const decodedMediaList = change[1].map((item) => stringTable.decodeAnnotated(item));
+	if (change.length === 2) return [decodedRules, decodedMediaList];
+	return [
+		decodedRules,
+		decodedMediaList,
+		change[2]
+	];
+}
+//#endregion
+export { createChangeDecoder };
+
+//# sourceMappingURL=changeDecoder.mjs.map

package/esm/domain/record/encoding/changeDecoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeDecoder.mjs","names":[],"sources":["../../../../src/domain/record/encoding/changeDecoder.ts"],"sourcesContent":["import { ChangeType, StringRole } from '../../../types'\nimport type {\n  AddDocTypeNodeChange,\n  AddRoleAnnotatedStringsChange,\n  AddElementNodeChange,\n  AddNodeChange,\n  AddStyleSheetChange,\n  AddTextNodeChange,\n  AttributeAssignmentOrDeletion,\n  AttributeChange,\n  BrowserChangeRecord,\n  BrowserFullSnapshotChangeRecord,\n  Change,\n  InputValueChange,\n  StyleSheetRules,\n  TextChange,\n  ImageContentChange,\n} from '../../../types'\nimport type { StringTable } from './stringTable'\nimport { createStringTable } from './stringTable'\n\n/**\n * ChangeDecoder converts a BrowserChangeRecord, or a stream of BrowserChangeRecords, into\n * a more human-readable form by:\n * - Removing the changes that manage the string table.\n * - Replacing string table references in all other changes with their literal values.\n *\n * This makes it easier to visualize the contents of BrowserChangeRecords or to write test\n * expectations against the record's content.\n */\nexport interface ChangeDecoder {\n  decode(record: BrowserChangeRecord): BrowserChangeRecord\n  decode(record: BrowserFullSnapshotChangeRecord): BrowserFullSnapshotChangeRecord\n  decode(\n    record: BrowserChangeRecord | BrowserFullSnapshotChangeRecord\n  ): BrowserChangeRecord | BrowserFullSnapshotChangeRecord\n\n  stringTable: StringTable\n}\n\nexport interface ChangeDecoderOptions {\n  /**\n   * If true, accept the string representations that the ChangeEncoder does not produce:\n   * - AddStringChange (replaced by AddRoleAnnotatedStringsChange)\n   * - StringLiteral (only string table references are generated)\n   * - RoleAnnotatedStringLiteral (only string table references are generated)\n   *\n   * When this option is false (the default), ChangeDecoder will throw when it encounters\n   * these obsolete string representations.\n   *\n   * In the future, we expect that certain KubeSense features will be unavailable for\n   * recordings which include obsolete string representations, so it's important to be\n   * sure that we don't accidentally generate them.\n   */\n  allowObsoleteStringRepresentations?: boolean\n\n  /**\n   * If true, decode string references to RoleAnnotatedStringLiteral objects. This allows\n   * you to inspect the recorded role annotations. Defaults to false.\n   */\n  keepRoles?: boolean\n}\n\nexport function createChangeDecoder({\n  allowObsoleteStringRepresentations = false,\n  keepRoles = false,\n}: ChangeDecoderOptions = {}): ChangeDecoder {\n  const self = {\n    decode(\n      record: BrowserChangeRecord | BrowserFullSnapshotChangeRecord\n    ): BrowserChangeRecord | BrowserFullSnapshotChangeRecord {\n      return decodeChangeRecord(record, self.stringTable, allowObsoleteStringRepresentations)\n    },\n\n    stringTable: createStringTable(allowObsoleteStringRepresentations, keepRoles),\n  } as ChangeDecoder\n\n  return self\n}\n\nfunction decodeChangeRecord(\n  record: BrowserChangeRecord | BrowserFullSnapshotChangeRecord,\n  stringTable: StringTable,\n  allowObsoleteStringRepresentations: boolean\n): BrowserChangeRecord | BrowserFullSnapshotChangeRecord {\n  const decodedData: Change[] = []\n\n  for (const change of record.data) {\n    switch (change[0]) {\n      case ChangeType.AddString:\n        if (!allowObsoleteStringRepresentations) {\n          throw new Error('Obsolete AddString change: string table entries are defined by role now')\n        }\n\n        // Update the string table.\n        for (let i = 1; i < change.length; i++) {\n          stringTable.add(change[i] as string, StringRole.Default)\n        }\n\n        // Deliberately don't include this change in the decoded record.\n        break\n\n      case ChangeType.AddRoleAnnotatedStrings:\n        // Update the string table, remembering the role each run was defined in so that the\n        // decoded record can carry it when the decoder was asked to keep roles.\n        for (let i = 1; i < change.length; i++) {\n          const [role, ...newStrings] = change[i] as AddRoleAnnotatedStringsChange\n          for (const newString of newStrings) {\n            stringTable.add(newString, role)\n          }\n        }\n\n        // Deliberately don't include this change in the decoded record.\n        break\n\n      case ChangeType.ClearStrings:\n        stringTable.clear()\n\n        // Deliberately don't include this change in the decoded record.\n        break\n\n      case ChangeType.AddNode: {\n        const decoded: [typeof ChangeType.AddNode, ...AddNodeChange[]] = [ChangeType.AddNode]\n        for (let i = 1; i < change.length; i++) {\n          decoded.push(decodeAddNodeChange(change[i] as AddNodeChange, stringTable))\n        }\n        decodedData.push(decoded)\n        break\n      }\n\n      case ChangeType.RemoveNode:\n        decodedData.push(change)\n        break\n\n      case ChangeType.Attribute: {\n        const decoded: [typeof ChangeType.Attribute, ...AttributeChange[]] = [ChangeType.Attribute]\n        for (let i = 1; i < change.length; i++) {\n          decoded.push(decodeAttributeChange(change[i] as AttributeChange, stringTable))\n        }\n        decodedData.push(decoded)\n        break\n      }\n\n      case ChangeType.Text: {\n        const decoded: [typeof ChangeType.Text, ...TextChange[]] = [ChangeType.Text]\n        for (let i = 1; i < change.length; i++) {\n          decoded.push(decodeTextChange(change[i] as TextChange, stringTable))\n        }\n        decodedData.push(decoded)\n        break\n      }\n\n      case ChangeType.InputValue: {\n        const decoded: [typeof ChangeType.InputValue, ...InputValueChange[]] = [ChangeType.InputValue]\n        for (let i = 1; i < change.length; i++) {\n          decoded.push(decodeInputValueChange(change[i] as InputValueChange, stringTable))\n        }\n        decodedData.push(decoded)\n        break\n      }\n\n      case ChangeType.Size:\n      case ChangeType.ScrollPosition:\n      case ChangeType.AttachedStyleSheets:\n      case ChangeType.MediaPlaybackState:\n      case ChangeType.VisualViewport:\n      case ChangeType.InputSelection:\n        decodedData.push(change)\n        break\n\n      case ChangeType.AddStyleSheet: {\n        const decoded: [typeof ChangeType.AddStyleSheet, ...AddStyleSheetChange[]] = [ChangeType.AddStyleSheet]\n        for (let i = 1; i < change.length; i++) {\n          decoded.push(decodeAddStyleSheetChange(change[i] as AddStyleSheetChange, stringTable))\n        }\n        decodedData.push(decoded)\n        break\n      }\n\n      case ChangeType.ImageContent: {\n        const decoded: [typeof ChangeType.ImageContent, ...ImageContentChange[]] = [ChangeType.ImageContent]\n        for (let i = 1; i < change.length; i++) {\n          const imageContentChange = change[i] as ImageContentChange\n          decoded.push([imageContentChange[0], stringTable.decodeAnnotated(imageContentChange[1])])\n        }\n        decodedData.push(decoded)\n        break\n      }\n\n      default:\n        change satisfies never\n        throw new Error(`Unsupported ChangeType: ${change[0] as any}`)\n    }\n  }\n\n  return { ...record, data: decodedData }\n}\n\nfunction decodeAddNodeChange(change: AddNodeChange, stringTable: StringTable): AddNodeChange {\n  const insertionPoint = change[0]\n\n  // Which kind of node this is has to be decided from the node name on its own, but the name that\n  // goes into the decoded record is the annotated one.\n  const nodeName = stringTable.decode(change[1])\n  const decodedNodeName = stringTable.decodeAnnotated(change[1])\n\n  switch (nodeName) {\n    case '#cdata-section':\n    case '#document':\n    case '#document-fragment':\n    case '#shadow-root':\n      return [insertionPoint, decodedNodeName]\n\n    case '#doctype': {\n      const [, , name, publicId, systemId] = change as AddDocTypeNodeChange\n      // The schema says an annotated '#doctype' carries the node name role, but the role here is\n      // whatever the record gave it, which is exactly what a reader wants to see. The cast keeps a\n      // record that got the role wrong legible, rather than hiding it.\n      return [\n        insertionPoint,\n        decodedNodeName,\n        stringTable.decodeAnnotated(name),\n        stringTable.decodeAnnotated(publicId),\n        stringTable.decodeAnnotated(systemId),\n      ] as AddDocTypeNodeChange\n    }\n\n    case '#text': {\n      const [, , textContent] = change as AddTextNodeChange\n      // Cast for the same reason as '#doctype' above.\n      return [insertionPoint, decodedNodeName, stringTable.decodeAnnotated(textContent)] as AddTextNodeChange\n    }\n\n    default: {\n      const decodedChange: AddElementNodeChange = [insertionPoint, decodedNodeName]\n\n      const [, , ...attrs] = change as AddElementNodeChange\n      for (const [name, value] of attrs) {\n        decodedChange.push([stringTable.decodeAnnotated(name), stringTable.decodeAnnotated(value)])\n      }\n\n      return decodedChange\n    }\n  }\n}\n\nfunction decodeAttributeChange(change: AttributeChange, stringTable: StringTable): AttributeChange {\n  const [nodeId, ...mutations] = change\n\n  const decodedMutations: AttributeAssignmentOrDeletion[] = mutations.map((mutation) => {\n    if (mutation.length === 1) {\n      return [stringTable.decodeAnnotated(mutation[0])]\n    }\n    return [stringTable.decodeAnnotated(mutation[0]), stringTable.decodeAnnotated(mutation[1])]\n  })\n\n  const decodedChange: AttributeChange = [nodeId]\n  decodedChange.push(...decodedMutations)\n  return decodedChange\n}\n\nfunction decodeTextChange(change: TextChange, stringTable: StringTable): TextChange {\n  return [change[0], stringTable.decodeAnnotated(change[1])]\n}\n\nfunction decodeInputValueChange(change: InputValueChange, stringTable: StringTable): InputValueChange {\n  return [change[0], stringTable.decodeAnnotated(change[1])]\n}\n\nfunction decodeAddStyleSheetChange(change: AddStyleSheetChange, stringTable: StringTable): AddStyleSheetChange {\n  const rules = change[0]\n  const decodedRules: StyleSheetRules = Array.isArray(rules)\n    ? rules.map((rule) => stringTable.decodeAnnotated(rule))\n    : stringTable.decodeAnnotated(rules)\n\n  if (change.length === 1) {\n    return [decodedRules]\n  }\n\n  const decodedMediaList = change[1].map((item) => stringTable.decodeAnnotated(item))\n\n  if (change.length === 2) {\n    return [decodedRules, decodedMediaList]\n  }\n\n  return [decodedRules, decodedMediaList, change[2]]\n}\n"],"mappings":"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"}

package/esm/domain/record/encoding/changeEncoder.mjs

@@ -0,0 +1,146 @@
+import { ChangeType, StringRole } from "../../../types/sessionReplayConstants.mjs";
+import { createString } from "./roles.mjs";
+//#region src/domain/record/encoding/changeEncoder.ts
+function createChangeEncoder(stringIds) {
+	let flushedChanges = [];
+	let run = createRunChangeEncoder(stringIds);
+	const endRun = () => {
+		run.flushInto(flushedChanges);
+		run = createRunChangeEncoder(stringIds);
+	};
+	const clearStringTable = () => {
+		endRun();
+		flushedChanges.push([ChangeType.ClearStrings]);
+		stringIds.clear();
+	};
+	const add = (type, data) => {
+		run.add(type, data);
+		if (stringIds.size + run.pendingStringCount >= 1e6) clearStringTable();
+	};
+	const flush = () => {
+		endRun();
+		const changes = flushedChanges;
+		flushedChanges = [];
+		return changes;
+	};
+	return {
+		add,
+		flush
+	};
+}
+function createRunChangeEncoder(stringIds) {
+	const pendingChanges = {};
+	const pendingGroups = /* @__PURE__ */ new Map();
+	const unresolvedChanges = [];
+	let pendingStringCount = 0;
+	let changeHasPendingStrings = false;
+	const referenceString = (literal) => {
+		const id = stringIds.get(literal);
+		if (id !== void 0) return id;
+		changeHasPendingStrings = true;
+		let group = pendingGroups.get(literal.role);
+		if (!group) {
+			group = {
+				role: literal.role,
+				strings: /* @__PURE__ */ new Map(),
+				references: 0
+			};
+			pendingGroups.set(literal.role, group);
+		}
+		group.references++;
+		const existingPendingString = group.strings.get(literal.string);
+		if (existingPendingString) return existingPendingString;
+		const pendingString = {
+			literal,
+			id: void 0
+		};
+		group.strings.set(literal.string, pendingString);
+		pendingStringCount++;
+		return pendingString;
+	};
+	const encodeStrings = (array) => {
+		for (let index = 0, length = array.length; index < length; index++) {
+			const item = array[index];
+			if (typeof item === "string") array[index] = referenceString(createString(StringRole.Default, item));
+			else if (Array.isArray(item)) encodeStrings(item);
+			else if (isRoleAnnotatedStringLiteral(item)) array[index] = referenceString(item);
+		}
+	};
+	const generateStringTableUpdates = () => {
+		if (pendingGroups.size === 0) return;
+		const stringTableUpdates = [ChangeType.AddRoleAnnotatedStrings];
+		for (const group of Array.from(pendingGroups.values()).sort(byDescendingReferences)) {
+			const update = [group.role];
+			for (const pendingString of group.strings.values()) {
+				pendingString.id = stringIds.getOrInsert(pendingString.literal);
+				update.push(pendingString.literal.string);
+			}
+			stringTableUpdates.push(update);
+		}
+		return stringTableUpdates;
+	};
+	const add = (type, data) => {
+		if (!(type in pendingChanges)) pendingChanges[type] = [type];
+		if (Array.isArray(data)) {
+			changeHasPendingStrings = false;
+			encodeStrings(data);
+			if (changeHasPendingStrings) unresolvedChanges.push(data);
+		}
+		pendingChanges[type].push(data);
+	};
+	const flushInto = (output) => {
+		const stringTableUpdates = generateStringTableUpdates();
+		if (stringTableUpdates) output.push(stringTableUpdates);
+		for (const change of unresolvedChanges) resolvePendingStrings(change);
+		[
+			ChangeType.AddNode,
+			ChangeType.RemoveNode,
+			ChangeType.Attribute,
+			ChangeType.Text,
+			ChangeType.InputValue,
+			ChangeType.InputSelection,
+			ChangeType.Size,
+			ChangeType.ScrollPosition,
+			ChangeType.AddStyleSheet,
+			ChangeType.AttachedStyleSheets,
+			ChangeType.MediaPlaybackState,
+			ChangeType.VisualViewport,
+			ChangeType.ImageContent
+		].forEach((changeType) => {
+			const change = pendingChanges[changeType];
+			if (change) output.push(change);
+		});
+	};
+	return {
+		add,
+		flushInto,
+		get pendingStringCount() {
+			return pendingStringCount;
+		}
+	};
+}
+/**
+* Replaces every string in the given change with the id it was assigned. A run gives every
+* pending string an id before it resolves anything, so by this point they all have one.
+*/
+function resolvePendingStrings(array) {
+	for (let index = 0, length = array.length; index < length; index++) {
+		const item = array[index];
+		if (Array.isArray(item)) resolvePendingStrings(item);
+		else if (isPendingString(item)) array[index] = item.id;
+	}
+}
+function byDescendingReferences(a, b) {
+	return b.references - a.references;
+}
+function isRoleAnnotatedStringLiteral(item) {
+	return typeof item === "object" && item !== null && "string" in item;
+}
+/** Every object left in change data once encodeStrings() has been over it is one of these. */
+function isPendingString(item) {
+	return typeof item === "object" && item !== null && "literal" in item;
+}
+//#endregion
+export { createChangeEncoder };
+
+//# sourceMappingURL=changeEncoder.mjs.map

package/esm/domain/record/encoding/changeEncoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeEncoder.mjs","names":[],"sources":["../../../../src/domain/record/encoding/changeEncoder.ts"],"sourcesContent":["import type { AddRoleAnnotatedStringsChange, Change, RoleAnnotatedStringLiteral } from '../../../types'\nimport { ChangeType, StringRole } from '../../../types'\nimport { createString } from './roles'\nimport { StringIdConstants } from './stringIds'\nimport type { StringId, StringIds } from './stringIds'\n\ntype ChangeData<T extends ChangeType> =\n  Extract<Change, [T, ...unknown[]]> extends [T, ...infer Rest] ? Rest[number] : never\n\ntype StringTableChangeTypes =\n  typeof ChangeType.AddString | typeof ChangeType.AddRoleAnnotatedStrings | typeof ChangeType.ClearStrings\n\n/**\n * The change operations a caller can add. Callers are not allowed to generate change\n * operations that manipulate the string table; that's the exclusive responsibility of the\n * encoder.\n */\ntype EncodableChangeType = Exclude<ChangeType, StringTableChangeTypes>\n\n/**\n * ChangeEncoder handles the low-level work of building compact, optimized sequences of\n * Changes. In particular, it:\n * - Converts literal strings to string table references, to eliminate the duplication\n * of transferring the same strings repeatedly.\n * - Groups the strings it defines by role to minimize the cost of transmitting role information.\n * - Sorts the busiest string groups first, so that the strings which are referenced most\n * frequently tend to get ids which have fewer digits and are thus cheaper to reference.\n * - Groups changes by type, instead of transmitting them strictly in order, so that we\n * can avoid transmitting a separate Change data structure with an independent type tag\n * for each small mutation. (It's safe to do this for changes that occur within the same\n * SerializationTransaction since they logically happen at the same time.)\n * - Clears the string table when it reaches its soft maximum size, so that there is always\n * room for the strings the encoder needs to define. Strings are therefore never transmitted\n * outside of the string table.\n */\nexport interface ChangeEncoder {\n  /**\n   * Encode a Change of the given type and add it to the internal buffer.\n   *\n   * The encoder takes ownership of `data`; the caller must not modify it after adding it.\n   */\n  add<T extends EncodableChangeType>(type: T, data: ChangeData<T>): void\n\n  /** Flush the internal buffer, returning all Changes added since the last flush(). */\n  flush(): Change[]\n}\n\nexport function createChangeEncoder(stringIds: StringIds): ChangeEncoder {\n  // Changes are encoded in runs. A run ends when the string table reaches its maximum\n  // size and is cleared; the changes in each run thus always share a single string id\n  // namespace. The currently-active run ends when the caller flushes the encoder.\n\n  // The changes of the runs that have already ended, waiting for the caller to flush them.\n  let flushedChanges: Change[] = []\n\n  // The run that the changes being added now belong to.\n  let run = createRunChangeEncoder(stringIds)\n\n  // Ends the current run, appending the changes it encoded to those of the runs before it,\n  // and starts a new one.\n  const endRun = (): void => {\n    run.flushInto(flushedChanges)\n    run = createRunChangeEncoder(stringIds)\n  }\n\n  // Clears the string table. This has the effect of creating a new string id namespace, so\n  // we also need to end the current run to ensure that the changes we've generated so far\n  // play back in the context of the previous namespace.\n  const clearStringTable = (): void => {\n    endRun()\n    flushedChanges.push([ChangeType.ClearStrings])\n    stringIds.clear()\n  }\n\n  const add = <T extends EncodableChangeType>(type: T, data: ChangeData<T>): void => {\n    run.add(type, data)\n\n    // If this change pushed the string table past its soft maximum size, we need to clear\n    // the string table.\n    if (stringIds.size + run.pendingStringCount >= Number(StringIdConstants.SOFT_MAX_SIZE)) {\n      clearStringTable()\n    }\n  }\n\n  const flush = (): Change[] => {\n    endRun()\n\n    const changes = flushedChanges\n    flushedChanges = []\n\n    return changes\n  }\n\n  return { add, flush }\n}\n\ntype StringTableUpdates = [typeof ChangeType.AddRoleAnnotatedStrings, ...AddRoleAnnotatedStringsChange[]]\n\n/** A string which is waiting for a string table id. */\ninterface PendingString {\n  /** The string itself, along with the role it belongs to. */\n  literal: RoleAnnotatedStringLiteral\n  /** The id this string was given; undefined until string table ids have been assigned. */\n  id: StringId | undefined\n}\n\n/** A group of strings with the same role which are waiting for string table ids. */\ninterface PendingStringGroup {\n  /** The role all of these strings belong to. */\n  role: StringRole\n  /** The strings, keyed by value, in the order they were first encountered. */\n  strings: Map<string, PendingString>\n  /** How many times the changes being encoded refer to a string in this run. */\n  references: number\n}\n\n/**\n * RunChangeEncoder encodes the changes of a single run for ChangeEncoder. Changes within\n * a run are grouped together to optimize their representation, and they share a common\n * string id namespace.\n */\ninterface RunChangeEncoder {\n  /**\n   * Encode a Change of the given type and add it to the run.\n   *\n   * The run takes ownership of `data`; the caller must not modify it after adding it.\n   */\n  add<T extends EncodableChangeType>(type: T, data: ChangeData<T>): void\n\n  /**\n   * End the run, appending the Changes it encoded to the given output array. The run must\n   * not be used again afterwards.\n   */\n  flushInto(output: Change[]): void\n\n  /** The number of strings the run will add to the string table when it ends. */\n  get pendingStringCount(): number\n}\n\nfunction createRunChangeEncoder(stringIds: StringIds): RunChangeEncoder {\n  // The changes added during this run, grouped by type.\n  const pendingChanges: Partial<Record<ChangeType, unknown[]>> = {}\n\n  // Every string in the changes added during this run which isn't in the string table yet,\n  // grouped by role.\n  const pendingGroups = new Map<StringRole, PendingStringGroup>()\n\n  // The changes added during this run that hold a string with no id yet, and so need a\n  // second pass once the run has handed out the ids. Tracking them minimizes the amount\n  // of work the second pass has to do; many changes, especially after the full snapshot,\n  // don't introduce any new strings and hence don't require a second pass.\n  const unresolvedChanges: unknown[][] = []\n\n  // How many strings pendingGroups holds.\n  let pendingStringCount = 0\n\n  // Set while a change is being encoded if any of its strings has no id yet.\n  let changeHasPendingStrings = false\n\n  // The reference that stands in for a string in the change data: its id, when the string\n  // is already in the string table, and a PendingString when it isn't. The ids depend on\n  // how the strings are grouped and on how often each of them is referenced, so we can't\n  // greedily assign ids for new strings as soon as we encounter them; we need to wait for\n  // the run to end.\n  const referenceString = (literal: RoleAnnotatedStringLiteral): StringId | PendingString => {\n    const id = stringIds.get(literal)\n    if (id !== undefined) {\n      return id\n    }\n\n    changeHasPendingStrings = true\n\n    let group = pendingGroups.get(literal.role)\n    if (!group) {\n      group = { role: literal.role, strings: new Map(), references: 0 }\n      pendingGroups.set(literal.role, group)\n    }\n    group.references++\n\n    const existingPendingString = group.strings.get(literal.string)\n    if (existingPendingString) {\n      return existingPendingString\n    }\n\n    const pendingString: PendingString = { literal, id: undefined }\n    group.strings.set(literal.string, pendingString)\n    pendingStringCount++\n    return pendingString\n  }\n\n  // A helper that searches for strings in arbitrarily-nested arrays and replaces each one it\n  // finds with a reference to it.\n  const encodeStrings = (array: any[]): void => {\n    for (let index = 0, length = array.length; index < length; index++) {\n      const item = array[index]\n      if (typeof item === 'string') {\n        array[index] = referenceString(createString(StringRole.Default, item))\n      } else if (Array.isArray(item)) {\n        encodeStrings(item)\n      } else if (isRoleAnnotatedStringLiteral(item)) {\n        array[index] = referenceString(item)\n      }\n    }\n  }\n\n  // Inserts the strings that aren't in the string table yet, positionally assigning them\n  // ids, and returns the resulting serialized string table update.\n  const generateStringTableUpdates = (): StringTableUpdates | undefined => {\n    if (pendingGroups.size === 0) {\n      return undefined\n    }\n\n    // AddRoleAnnotatedStrings operations logically append to the string table, and the id\n    // of each string is just its index in the table. Because a string table reference\n    // costs one byte per decimal digit of the target string's index, we sort the groups\n    // so that more frequently referenced groups appear first; this tends to reduce the\n    // cost of string table references overall in the recording.\n    const stringTableUpdates: StringTableUpdates = [ChangeType.AddRoleAnnotatedStrings]\n    for (const group of Array.from(pendingGroups.values()).sort(byDescendingReferences)) {\n      const update: AddRoleAnnotatedStringsChange = [group.role]\n      for (const pendingString of group.strings.values()) {\n        pendingString.id = stringIds.getOrInsert(pendingString.literal)\n        update.push(pendingString.literal.string)\n      }\n      stringTableUpdates.push(update)\n    }\n\n    return stringTableUpdates\n  }\n\n  const add = <T extends EncodableChangeType>(type: T, data: ChangeData<T>): void => {\n    if (!(type in pendingChanges)) {\n      pendingChanges[type] = [type]\n    }\n\n    // Not every kind of change data is an array; a RemoveNode change is a bare node id.\n    if (Array.isArray(data)) {\n      changeHasPendingStrings = false\n      encodeStrings(data)\n      if (changeHasPendingStrings) {\n        unresolvedChanges.push(data)\n      }\n    }\n\n    pendingChanges[type]!.push(data)\n  }\n\n  const flushInto = (output: Change[]): void => {\n    // String table updates have to come before any change that refers to them.\n    const stringTableUpdates = generateStringTableUpdates()\n    if (stringTableUpdates) {\n      output.push(stringTableUpdates)\n    }\n\n    // Every string has an id assigned now, so we can resolve the pending strings.\n    for (const change of unresolvedChanges) {\n      resolvePendingStrings(change)\n    }\n\n    // Place all changes into a single array. Because the player always just plays back\n    // the changes in order, the ordering of the changes matters; if a dependency can\n    // exist between two kinds of change, then the dependent change must come after the\n    // change it depends on. This list defines an ordering that ensures that these\n    // dependencies are always satisfied.\n    //\n    // Only the changes of this run need to be ordered this way. Callers add changes in an\n    // order that already satisfies their dependencies, so a change can only depend on one\n    // that was added before it, which is one in this run or in a run that already ended;\n    // it's grouping the changes by type that reorders them, and that happens within a run.\n    ;[\n      ChangeType.AddNode,\n      ChangeType.RemoveNode,\n      ChangeType.Attribute,\n      ChangeType.Text,\n      ChangeType.InputValue,\n      ChangeType.InputSelection,\n      ChangeType.Size,\n      ChangeType.ScrollPosition,\n      ChangeType.AddStyleSheet,\n      ChangeType.AttachedStyleSheets,\n      ChangeType.MediaPlaybackState,\n      ChangeType.VisualViewport,\n      ChangeType.ImageContent,\n    ].forEach((changeType: ChangeType): void => {\n      const change = pendingChanges[changeType]\n      if (change) {\n        output.push(change as Change)\n      }\n    })\n  }\n\n  return {\n    add,\n    flushInto,\n    get pendingStringCount(): number {\n      return pendingStringCount\n    },\n  }\n}\n\n/**\n * Replaces every string in the given change with the id it was assigned. A run gives every\n * pending string an id before it resolves anything, so by this point they all have one.\n */\nfunction resolvePendingStrings(array: any[]): void {\n  for (let index = 0, length = array.length; index < length; index++) {\n    const item = array[index]\n    if (Array.isArray(item)) {\n      resolvePendingStrings(item)\n    } else if (isPendingString(item)) {\n      array[index] = item.id\n    }\n  }\n}\n\nfunction byDescendingReferences(a: PendingStringGroup, b: PendingStringGroup): number {\n  return b.references - a.references\n}\n\nfunction isRoleAnnotatedStringLiteral(item: unknown): item is RoleAnnotatedStringLiteral {\n  return typeof item === 'object' && item !== null && 'string' in item\n}\n\n/** Every object left in change data once encodeStrings() has been over it is one of these. */\nfunction isPendingString(item: unknown): item is PendingString {\n  return typeof item === 'object' && item !== null && 'literal' in item\n}\n"],"mappings":"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"}

package/esm/domain/record/encoding/itemIds.mjs

@@ -0,0 +1,47 @@
+//#region src/domain/record/encoding/itemIds.ts
+function createEventIds() {
+	return createWeakIdMap(1);
+}
+function createNodeIds() {
+	return createWeakIdMap(0);
+}
+function createStyleSheetIds() {
+	return createWeakIdMap(0);
+}
+function createWeakIdMap(firstId) {
+	return createItemIds(() => /* @__PURE__ */ new WeakMap(), firstId);
+}
+function createItemIds(createMap, firstId) {
+	let map = createMap();
+	let nextId = firstId;
+	const get = (object) => map.get(object);
+	return {
+		clear() {
+			if (nextId === firstId) return;
+			map = createMap();
+			nextId = firstId;
+		},
+		delete(object) {
+			map.delete(object);
+		},
+		get,
+		getOrInsert(object) {
+			let id = get(object);
+			if (id === void 0) {
+				id = nextId++;
+				map.set(object, id);
+			}
+			return id;
+		},
+		get nextId() {
+			return nextId;
+		},
+		get size() {
+			return nextId - firstId;
+		}
+	};
+}
+//#endregion
+export { createEventIds, createNodeIds, createStyleSheetIds };
+
+//# sourceMappingURL=itemIds.mjs.map

package/esm/domain/record/encoding/itemIds.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"itemIds.mjs","names":[],"sources":["../../../../src/domain/record/encoding/itemIds.ts"],"sourcesContent":["export type EventId = number & { __brand: 'EventId' }\nexport type EventIds = ItemIds<Event, EventId>\nexport const enum EventIdConstants {\n  FIRST_ID = 1,\n}\nexport function createEventIds(): EventIds {\n  return createWeakIdMap(EventIdConstants.FIRST_ID as EventId)\n}\n\nexport type NodeId = number & { __brand: 'NodeId' }\nexport type NodeIds = ItemIds<Node, NodeId>\nexport const enum NodeIdConstants {\n  FIRST_ID = 0,\n}\nexport function createNodeIds(): NodeIds {\n  return createWeakIdMap(NodeIdConstants.FIRST_ID as NodeId)\n}\n\nexport type StyleSheetId = number & { __brand: 'StyleSheetId' }\nexport type StyleSheetIds = ItemIds<CSSStyleSheet, StyleSheetId>\nexport const enum StyleSheetIdConstants {\n  FIRST_ID = 0,\n}\nexport function createStyleSheetIds(): StyleSheetIds {\n  return createWeakIdMap(StyleSheetIdConstants.FIRST_ID as StyleSheetId)\n}\n\nexport interface ItemIds<ItemType, ItemId extends number> {\n  clear(this: void): void\n  delete(this: void, item: ItemType): void\n  get(this: void, item: ItemType): ItemId | undefined\n  getOrInsert(this: void, item: ItemType): ItemId\n  get nextId(): ItemId\n  get size(): number\n}\n\nfunction createWeakIdMap<ItemType extends object, ItemId extends number>(firstId: ItemId): ItemIds<ItemType, ItemId> {\n  return createItemIds(() => new WeakMap<ItemType, ItemId>(), firstId)\n}\n\ninterface MapLike<Key, Value> {\n  delete(key: Key): void\n  get(key: Key): Value | undefined\n  set(key: Key, value: Value): void\n}\n\nfunction createItemIds<ItemType, ItemId extends number>(\n  createMap: () => MapLike<ItemType, ItemId>,\n  firstId: ItemId\n): ItemIds<ItemType, ItemId> {\n  let map = createMap()\n  let nextId = firstId\n\n  const get = (object: ItemType): ItemId | undefined => map.get(object)\n\n  return {\n    clear(): void {\n      if (nextId === firstId) {\n        return\n      }\n      map = createMap()\n      nextId = firstId\n    },\n    delete(object: ItemType): void {\n      map.delete(object)\n    },\n    get,\n    getOrInsert(object: ItemType): ItemId {\n      // Try to reuse any existing id.\n      let id = get(object)\n      if (id === undefined) {\n        id = nextId++ as ItemId\n        map.set(object, id)\n      }\n      return id\n    },\n    get nextId(): ItemId {\n      return nextId\n    },\n    get size(): number {\n      return nextId - firstId\n    },\n  }\n}\n"],"mappings":";AAKA,SAAgB,iBAA2B;CACzC,OAAO,gBAAA,CAAoD;AAC7D;AAOA,SAAgB,gBAAyB;CACvC,OAAO,gBAAA,CAAkD;AAC3D;AAOA,SAAgB,sBAAqC;CACnD,OAAO,gBAAA,CAA8D;AACvE;AAWA,SAAS,gBAAgE,SAA4C;CACnH,OAAO,oCAAoB,IAAI,QAA0B,GAAG,OAAO;AACrE;AAQA,SAAS,cACP,WACA,SAC2B;CAC3B,IAAI,MAAM,UAAU;CACpB,IAAI,SAAS;CAEb,MAAM,OAAO,WAAyC,IAAI,IAAI,MAAM;CAEpE,OAAO;EACL,QAAc;GACZ,IAAI,WAAW,SACb;GAEF,MAAM,UAAU;GAChB,SAAS;EACX;EACA,OAAO,QAAwB;GAC7B,IAAI,OAAO,MAAM;EACnB;EACA;EACA,YAAY,QAA0B;GAEpC,IAAI,KAAK,IAAI,MAAM;GACnB,IAAI,OAAO,KAAA,GAAW;IACpB,KAAK;IACL,IAAI,IAAI,QAAQ,EAAE;GACpB;GACA,OAAO;EACT;EACA,IAAI,SAAiB;GACnB,OAAO;EACT;EACA,IAAI,OAAe;GACjB,OAAO,SAAS;EAClB;CACF;AACF"}

package/esm/domain/record/encoding/roles.mjs

@@ -0,0 +1,64 @@
+import { StringRole } from "../../../types/sessionReplayConstants.mjs";
+//#region src/domain/record/encoding/roles.ts
+/** Create a serialized string literal annotated with the given role. */
+function createString(role, string) {
+	return {
+		role,
+		string
+	};
+}
+/**
+* Given a normalized tag name, an attribute name, and an attribute value, returns a
+* serialized attribute assignment annotated with the appropriate roles.
+*/
+function createAttributeAssignment(tagName, attributeName, attributeValue) {
+	return [createString(StringRole.AttributeName, attributeName), createString(attributeValueRole(tagName, attributeName), attributeValue)];
+}
+/**
+* Given a normalized tag name, an attribute name, and an attribute value, returns a
+* serialized attribute assignment or deletion annotated with the appropriate roles.
+*/
+function createAttributeAssignmentOrDeletion(tagName, attributeName, attributeValue) {
+	const name = createString(StringRole.AttributeName, attributeName);
+	if (attributeValue === null) return [name];
+	return [name, createString(attributeValueRole(tagName, attributeName), attributeValue)];
+}
+/**
+* Elements whose `value` attribute holds form input. Every other element that carries a `value`
+* attribute — `<li>`, `<button>`, `<meter>`, `<param>`, and the rest — holds an ordinary attribute
+* value there, and masking it would change how the page renders rather than hide anything private.
+*/
+const FORM_ELEMENT_NAMES = /* @__PURE__ */ new Set([
+	"input",
+	"option",
+	"select",
+	"textarea"
+]);
+/** Attributes whose value is a URL or a list of URLs. */
+const URL_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
+	"action",
+	"background",
+	"cite",
+	"data",
+	"formaction",
+	"href",
+	"longdesc",
+	"manifest",
+	"ping",
+	"poster",
+	"src",
+	"srcset",
+	"xlink:href"
+]);
+/** The role that the value of the given attribute plays on the given element. */
+function attributeValueRole(tagName, attributeName) {
+	switch (attributeName) {
+		case "value": return FORM_ELEMENT_NAMES.has(tagName) ? StringRole.FormInput : StringRole.AttributeValue;
+		case "style": return StringRole.Css;
+		default: return URL_ATTRIBUTE_NAMES.has(attributeName) ? StringRole.Url : StringRole.AttributeValue;
+	}
+}
+//#endregion
+export { createAttributeAssignment, createAttributeAssignmentOrDeletion, createString };
+
+//# sourceMappingURL=roles.mjs.map

package/esm/domain/record/encoding/roles.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.mjs","names":[],"sources":["../../../../src/domain/record/encoding/roles.ts"],"sourcesContent":["/* eslint-disable id-denylist */\n\nimport type {\n  AddNodeChange,\n  RoleAnnotatedStringLiteral,\n  StringLiteral,\n  StringOrStringReference,\n  StringReference,\n} from '../../../types'\nimport { StringRole } from '../../../types'\nimport type { NodeId } from './itemIds'\n\n/** The node name of an AddNode change operation, in its role-annotated form. */\nexport type RoleAnnotatedAddNodeName<NodeChange extends AddNodeChange> = Exclude<\n  NodeChange[1],\n  StringLiteral | StringReference\n>\n\n/**\n * The node-type-specific parameters of an AddNode change operation, with every string\n * in its role-annotated form.\n */\nexport type RoleAnnotatedAddNodeParams<NodeChange extends AddNodeChange> = NodeChange extends [\n  any,\n  any,\n  ...infer Params,\n]\n  ? RoleAnnotatedParams<Params>\n  : never\n\ntype RoleAnnotatedParams<Params> = { [Index in keyof Params]: RoleAnnotatedParam<Params[Index]> }\n\ntype RoleAnnotatedParam<Param> = Param extends StringOrStringReference\n  ? RoleAnnotatedStringLiteral\n  : RoleAnnotatedParams<Param>\n\n/**\n * An attribute change whose strings are all annotated with their roles. The node id is a number\n * rather than a string, so it is unaffected.\n */\nexport type RoleAnnotatedAttributeChange = [NodeId, ...RoleAnnotatedAttributeAssignmentOrDeletion[]]\n\n/** An attribute assignment, annotated with string roles. */\nexport type RoleAnnotatedAttributeAssignment = [RoleAnnotatedStringLiteral, RoleAnnotatedStringLiteral]\n\n/** An attribute assignment or deletion, annotated with string roles. */\nexport type RoleAnnotatedAttributeAssignmentOrDeletion =\n  [RoleAnnotatedStringLiteral, RoleAnnotatedStringLiteral] | [RoleAnnotatedStringLiteral]\n\n/** The string literal portion of a role-annotated string literal type. */\nexport type RoleAnnotatedStringLiteralValue<Literal> = Literal extends RoleAnnotatedStringLiteral\n  ? Literal['string']\n  : never\n\n/** The rules of a stylesheet, annotated with their roles. */\nexport type RoleAnnotatedStyleSheetRules = RoleAnnotatedStringLiteral | RoleAnnotatedStringLiteral[]\n\n/** The media list of a stylesheet, annotated with their roles. */\nexport type RoleAnnotatedStyleSheetMediaList = RoleAnnotatedStringLiteral[]\n\n/** Create a serialized string literal annotated with the given role. */\nexport function createString<Role extends StringRole, Literal extends string>(\n  role: Role,\n  string: Literal\n): RoleAnnotatedStringLiteral & { role: Role; string: Literal } {\n  return { role, string }\n}\n\n/**\n * Given a normalized tag name, an attribute name, and an attribute value, returns a\n * serialized attribute assignment annotated with the appropriate roles.\n */\nexport function createAttributeAssignment(\n  tagName: string,\n  attributeName: string,\n  attributeValue: string\n): RoleAnnotatedAttributeAssignment {\n  return [\n    createString(StringRole.AttributeName, attributeName),\n    createString(attributeValueRole(tagName, attributeName), attributeValue),\n  ]\n}\n\n/**\n * Given a normalized tag name, an attribute name, and an attribute value, returns a\n * serialized attribute assignment or deletion annotated with the appropriate roles.\n */\nexport function createAttributeAssignmentOrDeletion(\n  tagName: string,\n  attributeName: string,\n  attributeValue: string | null\n): RoleAnnotatedAttributeAssignmentOrDeletion {\n  const name = createString(StringRole.AttributeName, attributeName)\n\n  if (attributeValue === null) {\n    return [name]\n  }\n\n  return [name, createString(attributeValueRole(tagName, attributeName), attributeValue)]\n}\n\n/**\n * Elements whose `value` attribute holds form input. Every other element that carries a `value`\n * attribute — `<li>`, `<button>`, `<meter>`, `<param>`, and the rest — holds an ordinary attribute\n * value there, and masking it would change how the page renders rather than hide anything private.\n */\nconst FORM_ELEMENT_NAMES = new Set(['input', 'option', 'select', 'textarea'])\n\n/** Attributes whose value is a URL or a list of URLs. */\nconst URL_ATTRIBUTE_NAMES = new Set([\n  'action',\n  'background',\n  'cite',\n  'data',\n  'formaction',\n  'href',\n  'longdesc',\n  'manifest',\n  'ping',\n  'poster',\n  'src',\n  'srcset',\n  'xlink:href',\n])\n\n/** The role that the value of the given attribute plays on the given element. */\nfunction attributeValueRole(tagName: string, attributeName: string): StringRole {\n  switch (attributeName) {\n    case 'value':\n      return FORM_ELEMENT_NAMES.has(tagName) ? StringRole.FormInput : StringRole.AttributeValue\n    case 'style':\n      return StringRole.Css\n    default:\n      return URL_ATTRIBUTE_NAMES.has(attributeName) ? StringRole.Url : StringRole.AttributeValue\n  }\n}\n"],"mappings":";;;AA6DA,SAAgB,aACd,MACA,QAC8D;CAC9D,OAAO;EAAE;EAAM;CAAO;AACxB;;;;;AAMA,SAAgB,0BACd,SACA,eACA,gBACkC;CAClC,OAAO,CACL,aAAa,WAAW,eAAe,aAAa,GACpD,aAAa,mBAAmB,SAAS,aAAa,GAAG,cAAc,CACzE;AACF;;;;;AAMA,SAAgB,oCACd,SACA,eACA,gBAC4C;CAC5C,MAAM,OAAO,aAAa,WAAW,eAAe,aAAa;CAEjE,IAAI,mBAAmB,MACrB,OAAO,CAAC,IAAI;CAGd,OAAO,CAAC,MAAM,aAAa,mBAAmB,SAAS,aAAa,GAAG,cAAc,CAAC;AACxF;;;;;;AAOA,MAAM,qCAAqB,IAAI,IAAI;CAAC;CAAS;CAAU;CAAU;AAAU,CAAC;;AAG5E,MAAM,sCAAsB,IAAI,IAAI;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;AAGD,SAAS,mBAAmB,SAAiB,eAAmC;CAC9E,QAAQ,eAAR;EACE,KAAK,SACH,OAAO,mBAAmB,IAAI,OAAO,IAAI,WAAW,YAAY,WAAW;EAC7E,KAAK,SACH,OAAO,WAAW;EACpB,SACE,OAAO,oBAAoB,IAAI,aAAa,IAAI,WAAW,MAAM,WAAW;CAChF;AACF"}

package/esm/domain/record/encoding/stringIds.mjs

@@ -0,0 +1,47 @@
+import { StringRole } from "../../../types/sessionReplayConstants.mjs";
+//#region src/domain/record/encoding/stringIds.ts
+function createStringIds() {
+	const firstId = 0;
+	let nextId = firstId;
+	let mapsByRole = createMapsByRole();
+	const get = (literal) => mapsByRole[literal.role][literal.string];
+	return {
+		clear() {
+			if (nextId === firstId) return;
+			mapsByRole = createMapsByRole();
+			nextId = firstId;
+		},
+		get,
+		getOrInsert(literal) {
+			let id = get(literal);
+			if (id === void 0) {
+				id = nextId++;
+				mapsByRole[literal.role][literal.string] = id;
+			}
+			return id;
+		},
+		get size() {
+			return nextId - firstId;
+		}
+	};
+}
+function createMapsByRole() {
+	return {
+		[StringRole.Default]: createStringIdMap(),
+		[StringRole.NodeName]: createStringIdMap(),
+		[StringRole.AttributeName]: createStringIdMap(),
+		[StringRole.AttributeValue]: createStringIdMap(),
+		[StringRole.TextContent]: createStringIdMap(),
+		[StringRole.FormInput]: createStringIdMap(),
+		[StringRole.Css]: createStringIdMap(),
+		[StringRole.Url]: createStringIdMap(),
+		[StringRole.ResourceId]: createStringIdMap()
+	};
+}
+function createStringIdMap() {
+	return Object.create(null);
+}
+//#endregion
+export { createStringIds };
+
+//# sourceMappingURL=stringIds.mjs.map

package/esm/domain/record/encoding/stringIds.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringIds.mjs","names":[],"sources":["../../../../src/domain/record/encoding/stringIds.ts"],"sourcesContent":["import type { RoleAnnotatedStringLiteral } from '../../../types'\nimport { StringRole } from '../../../types'\n\nexport type StringId = number & { __brand: 'StringId' }\n\nexport interface StringIds {\n  clear(this: void): void\n  get(this: void, literal: RoleAnnotatedStringLiteral): StringId | undefined\n  getOrInsert(this: void, literal: RoleAnnotatedStringLiteral): StringId\n  get size(): number\n}\n\nexport const enum StringIdConstants {\n  FIRST_ID = 0,\n\n  // An arbitrarily-chosen soft limit on the maximum size of the string id map.\n  SOFT_MAX_SIZE = 1000000,\n}\n\ntype StringIdMap = Record<string, StringId | undefined>\ntype StringIdMapsByRole = Record<StringRole, StringIdMap>\n\nexport function createStringIds(): StringIds {\n  const firstId = StringIdConstants.FIRST_ID as StringId\n  let nextId = firstId\n  let mapsByRole = createMapsByRole()\n\n  const get = (literal: RoleAnnotatedStringLiteral): StringId | undefined => mapsByRole[literal.role][literal.string]\n\n  return {\n    clear(): void {\n      if (nextId === firstId) {\n        return\n      }\n      mapsByRole = createMapsByRole()\n      nextId = firstId\n    },\n    get,\n    getOrInsert(literal: RoleAnnotatedStringLiteral): StringId {\n      // Try to reuse any existing id.\n      let id = get(literal)\n      if (id === undefined) {\n        id = nextId++ as StringId\n        mapsByRole[literal.role][literal.string] = id\n      }\n      return id\n    },\n    get size(): number {\n      return nextId - firstId\n    },\n  }\n}\n\nfunction createMapsByRole(): StringIdMapsByRole {\n  return {\n    [StringRole.Default]: createStringIdMap(),\n    [StringRole.NodeName]: createStringIdMap(),\n    [StringRole.AttributeName]: createStringIdMap(),\n    [StringRole.AttributeValue]: createStringIdMap(),\n    [StringRole.TextContent]: createStringIdMap(),\n    [StringRole.FormInput]: createStringIdMap(),\n    [StringRole.Css]: createStringIdMap(),\n    [StringRole.Url]: createStringIdMap(),\n    [StringRole.ResourceId]: createStringIdMap(),\n  }\n}\n\nfunction createStringIdMap(): StringIdMap {\n  return Object.create(null) as StringIdMap\n}\n"],"mappings":";;AAsBA,SAAgB,kBAA6B;CAC3C,MAAM,UAAA;CACN,IAAI,SAAS;CACb,IAAI,aAAa,iBAAiB;CAElC,MAAM,OAAO,YAA8D,WAAW,QAAQ,KAAK,CAAC,QAAQ;CAE5G,OAAO;EACL,QAAc;GACZ,IAAI,WAAW,SACb;GAEF,aAAa,iBAAiB;GAC9B,SAAS;EACX;EACA;EACA,YAAY,SAA+C;GAEzD,IAAI,KAAK,IAAI,OAAO;GACpB,IAAI,OAAO,KAAA,GAAW;IACpB,KAAK;IACL,WAAW,QAAQ,KAAK,CAAC,QAAQ,UAAU;GAC7C;GACA,OAAO;EACT;EACA,IAAI,OAAe;GACjB,OAAO,SAAS;EAClB;CACF;AACF;AAEA,SAAS,mBAAuC;CAC9C,OAAO;GACJ,WAAW,UAAU,kBAAkB;GACvC,WAAW,WAAW,kBAAkB;GACxC,WAAW,gBAAgB,kBAAkB;GAC7C,WAAW,iBAAiB,kBAAkB;GAC9C,WAAW,cAAc,kBAAkB;GAC3C,WAAW,YAAY,kBAAkB;GACzC,WAAW,MAAM,kBAAkB;GACnC,WAAW,MAAM,kBAAkB;GACnC,WAAW,aAAa,kBAAkB;CAC7C;AACF;AAEA,SAAS,oBAAiC;CACxC,OAAO,OAAO,OAAO,IAAI;AAC3B"}

package/esm/domain/record/encoding/stringTable.mjs

@@ -0,0 +1,38 @@
+import { StringRole } from "../../../types/sessionReplayConstants.mjs";
+import { createString } from "./roles.mjs";
+//#region src/domain/record/encoding/stringTable.ts
+function createStringTable(allowObsoleteStringRepresentations = false, keepRoles = false) {
+	const strings = /* @__PURE__ */ new Map();
+	const literalOf = (value) => {
+		if (typeof value === "string") {
+			if (!allowObsoleteStringRepresentations) throw new Error(`Obsolete untagged string literal: ${value}`);
+			return createString(StringRole.Default, value);
+		}
+		if (typeof value === "object") {
+			if (!allowObsoleteStringRepresentations) throw new Error(`Obsolete string literal outside the string table: ${value.string}`);
+			return value;
+		}
+		const referencedString = strings.get(value);
+		if (referencedString === void 0) throw new Error(`Reference to unknown string: ${value}`);
+		return referencedString;
+	};
+	return {
+		add(newString, role) {
+			strings.set(strings.size, createString(role, newString));
+		},
+		clear() {
+			strings.clear();
+		},
+		decode(value) {
+			return literalOf(value).string;
+		},
+		decodeAnnotated(value) {
+			const literal = literalOf(value);
+			return keepRoles ? literal : literal.string;
+		}
+	};
+}
+//#endregion
+export { createStringTable };
+
+//# sourceMappingURL=stringTable.mjs.map

package/esm/domain/record/encoding/stringTable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringTable.mjs","names":[],"sources":["../../../../src/domain/record/encoding/stringTable.ts"],"sourcesContent":["import type { RoleAnnotatedStringLiteral, StringLiteral, StringOrStringReference } from '../../../types'\nimport { StringRole } from '../../../types'\nimport { createString } from './roles'\nimport type { StringId } from './stringIds'\n\nexport interface StringTable {\n  add(newString: string, role: StringRole): void\n\n  /** Remove every string from the table, so that the next string added gets the first id. */\n  clear(): void\n\n  /** The string that the given value holds, whichever form it takes. */\n  decode(value: StringOrStringReference): string\n\n  /**\n   * The given value in the form the decoded record should carry it: the string on its own, or the\n   * string together with the role it was defined in, depending on how the table was created.\n   */\n  decodeAnnotated(value: StringOrStringReference): StringLiteral | RoleAnnotatedStringLiteral\n}\n\nexport function createStringTable(allowObsoleteStringRepresentations = false, keepRoles = false): StringTable {\n  const strings = new Map<StringId, RoleAnnotatedStringLiteral>()\n\n  // The string the given value holds, along with the role it holds it in.\n  const literalOf = (value: StringOrStringReference): RoleAnnotatedStringLiteral => {\n    if (typeof value === 'string') {\n      // A plain string literal. The encoder tags every literal it emits with a role, so one\n      // without a role means something built this change data outside the encoder.\n      if (!allowObsoleteStringRepresentations) {\n        throw new Error(`Obsolete untagged string literal: ${value}`)\n      }\n      // An untagged literal says nothing about what it holds, which is the default role.\n      return createString(StringRole.Default, value)\n    }\n\n    if (typeof value === 'object') {\n      // A role-annotated string literal. The encoder gives every string an entry in the\n      // string table, so something must have built this change data outside the encoder.\n      if (!allowObsoleteStringRepresentations) {\n        throw new Error(`Obsolete string literal outside the string table: ${value.string}`)\n      }\n      return value\n    }\n\n    const referencedString = strings.get(value as StringId)\n    if (referencedString === undefined) {\n      throw new Error(`Reference to unknown string: ${value}`)\n    }\n    return referencedString\n  }\n\n  return {\n    add(newString: string, role: StringRole): void {\n      strings.set(strings.size as StringId, createString(role, newString))\n    },\n    clear(): void {\n      strings.clear()\n    },\n    decode(value: StringOrStringReference): string {\n      return literalOf(value).string\n    },\n    decodeAnnotated(value: StringOrStringReference): StringLiteral | RoleAnnotatedStringLiteral {\n      const literal = literalOf(value)\n      return keepRoles ? literal : literal.string\n    },\n  }\n}\n"],"mappings":";;;AAqBA,SAAgB,kBAAkB,qCAAqC,OAAO,YAAY,OAAoB;CAC5G,MAAM,0BAAU,IAAI,IAA0C;CAG9D,MAAM,aAAa,UAA+D;EAChF,IAAI,OAAO,UAAU,UAAU;GAG7B,IAAI,CAAC,oCACH,MAAM,IAAI,MAAM,qCAAqC,OAAO;GAG9D,OAAO,aAAa,WAAW,SAAS,KAAK;EAC/C;EAEA,IAAI,OAAO,UAAU,UAAU;GAG7B,IAAI,CAAC,oCACH,MAAM,IAAI,MAAM,qDAAqD,MAAM,QAAQ;GAErF,OAAO;EACT;EAEA,MAAM,mBAAmB,QAAQ,IAAI,KAAiB;EACtD,IAAI,qBAAqB,KAAA,GACvB,MAAM,IAAI,MAAM,gCAAgC,OAAO;EAEzD,OAAO;CACT;CAEA,OAAO;EACL,IAAI,WAAmB,MAAwB;GAC7C,QAAQ,IAAI,QAAQ,MAAkB,aAAa,MAAM,SAAS,CAAC;EACrE;EACA,QAAc;GACZ,QAAQ,MAAM;EAChB;EACA,OAAO,OAAwC;GAC7C,OAAO,UAAU,KAAK,CAAC,CAAC;EAC1B;EACA,gBAAgB,OAA4E;GAC1F,MAAM,UAAU,UAAU,KAAK;GAC/B,OAAO,YAAY,UAAU,QAAQ;EACvC;CACF;AACF"}

package/esm/domain/record/eventsUtils.mjs

@@ -0,0 +1,13 @@
+import { isNodeShadowHost } from "@kubesense/kubesense-browser-rum-core";
+//#region src/domain/record/eventsUtils.ts
+function isTouchEvent(event) {
+	return Boolean(event.changedTouches);
+}
+function getEventTarget(event) {
+	if (event.composed === true && isNodeShadowHost(event.target)) return event.composedPath()[0];
+	return event.target;
+}
+//#endregion
+export { getEventTarget, isTouchEvent };
+
+//# sourceMappingURL=eventsUtils.mjs.map

package/esm/domain/record/eventsUtils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventsUtils.mjs","names":[],"sources":["../../../src/domain/record/eventsUtils.ts"],"sourcesContent":["import { isNodeShadowHost } from '@kubesense/kubesense-browser-rum-core'\n\nexport function isTouchEvent(event: MouseEvent | TouchEvent): event is TouchEvent {\n  return Boolean((event as TouchEvent).changedTouches)\n}\n\nexport function getEventTarget(event: Event): Node {\n  if (event.composed === true && isNodeShadowHost(event.target as Node)) {\n    return event.composedPath()[0] as Node\n  }\n  return event.target as Node\n}\n"],"mappings":";;AAEA,SAAgB,aAAa,OAAqD;CAChF,OAAO,QAAS,MAAqB,cAAc;AACrD;AAEA,SAAgB,eAAe,OAAoB;CACjD,IAAI,MAAM,aAAa,QAAQ,iBAAiB,MAAM,MAAc,GAClE,OAAO,MAAM,aAAa,CAAC,CAAC;CAE9B,OAAO,MAAM;AACf"}

package/esm/domain/record/index.mjs

@@ -0,0 +1,8 @@
+import "./mutationBatch.mjs";
+import { createChangeDecoder } from "./encoding/changeDecoder.mjs";
+import { aggregateSerializationStats, createSerializationStats } from "./serialization/serializationStats.mjs";
+import "./serialization/index.mjs";
+import "./elementsScrollPositions.mjs";
+import { takeFullSnapshot, takeNodeSnapshot } from "./internalApi.mjs";
+import { record } from "./record.mjs";
+export { aggregateSerializationStats, createChangeDecoder, createSerializationStats, record, takeFullSnapshot, takeNodeSnapshot };