superdoc 2.20.1-next.9 → 2.21.0-next.2

package/dist/chunks/{create-super-doc-ui-Cfwszc3b.es.js → create-super-doc-ui-0CZTlOvl.es.js}

@@ -1,5 +1,563 @@
 import { $ as watch, D as normalizeClass, E as nextTick, F as openBlock, H as shallowRef, L as ref, N as onMounted, R as renderList, U as toDisplayString, a as computed, c as createCommentVNode, f as createTextVNode, h as defineComponent, j as onBeforeUnmount, l as createElementBlock, n as Fragment, q as unref, rt as withModifiers, t as _plugin_vue_export_helper_default, u as createElementVNode } from "./_plugin-vue_export-helper-DHiJKCsy.es.js";
+//#region src/internal/diagnostics/workflow-recording.ts
+var fields$1 = /* @__PURE__ */ new Set([
+	"documentId",
+	"actionId",
+	"commandId",
+	"operation",
+	"source",
+	"origin",
+	"phase",
+	"kind",
+	"status",
+	"success",
+	"changed",
+	"reason",
+	"code",
+	"direction",
+	"outcome",
+	"receipt",
+	"result",
+	"failure",
+	"rejection",
+	"txId",
+	"documentEpoch",
+	"commitSequence",
+	"targetCommitSequence",
+	"paintedCommitSequence",
+	"renderInputEpoch",
+	"paintedRenderInputEpoch",
+	"health",
+	"selection",
+	"selectionBefore",
+	"selectionAfter",
+	"snapshot",
+	"target",
+	"start",
+	"end",
+	"anchor",
+	"focus",
+	"story",
+	"storyType",
+	"storyId",
+	"refId",
+	"noteId",
+	"textboxId",
+	"position",
+	"offset",
+	"unit",
+	"value",
+	"blockId",
+	"blockOffset",
+	"fragmentId",
+	"pageIndex",
+	"layoutEpoch",
+	"revision",
+	"sourceCommit",
+	"selectionLineageId",
+	"selectionIntentSequence",
+	"intentSequence",
+	"intentId",
+	"authoringMode",
+	"editableCommandKind",
+	"inputKind",
+	"visualIntent",
+	"preEdit",
+	"postEdit",
+	"fallback",
+	"selectionRevision",
+	"timing",
+	"selectionTargetMs",
+	"textReplaceMs",
+	"postEditSelectionMs",
+	"totalMs",
+	"inputAtMs",
+	"dispatchAtMs",
+	"committedAtMs",
+	"durationMs",
+	"elapsedMs",
+	"affectedStories",
+	"tableId",
+	"cellId",
+	"contentControlId",
+	"outsideContentControl",
+	"trackedBlockOffset",
+	"projectionBlockId",
+	"geometryBlockId",
+	"geometryBlockOffset",
+	"geometryTrackedBlockOffset",
+	"lineAffinity",
+	"inlineAffinity",
+	"stability",
+	"nativeId",
+	"paraId",
+	"partId",
+	"partRevision",
+	"storyRevision",
+	"pathFingerprint",
+	"path",
+	"index",
+	"name",
+	"id",
+	"range",
+	"hasRangeSelection",
+	"inputType",
+	"dataLength",
+	"isComposing",
+	"repeat",
+	"altKey",
+	"ctrlKey",
+	"metaKey",
+	"shiftKey",
+	"key",
+	"button",
+	"buttons",
+	"pointerType",
+	"clickCount",
+	"x",
+	"y",
+	"selector",
+	"domPath",
+	"scrollLeft",
+	"scrollTop",
+	"command",
+	"segments",
+	"nodeId",
+	"byteSpan",
+	"sdtId",
+	"controlId",
+	"scope",
+	"coordinateSpace",
+	"contentControlIds",
+	"scrollAncestors",
+	"layoutBlockRef",
+	"contextSource"
+]);
+var contentFields$1 = /* @__PURE__ */ new Set([
+	"text",
+	"data",
+	"message",
+	"errorMessage",
+	"quotedText"
+]);
+var inputTypes = [
+	"keydown",
+	"keyup",
+	"beforeinput",
+	"pointerdown",
+	"pointermove",
+	"pointerup",
+	"click",
+	"dblclick",
+	"mousedown",
+	"mouseup",
+	"scroll",
+	"compositionstart",
+	"compositionend",
+	"paste",
+	"cut",
+	"drop",
+	"dragstart"
+];
+var namedKeys = /* @__PURE__ */ new Set([
+	"Alt",
+	"AltGraph",
+	"CapsLock",
+	"Control",
+	"Meta",
+	"NumLock",
+	"ScrollLock",
+	"Shift",
+	"Enter",
+	"Tab",
+	"ArrowLeft",
+	"ArrowRight",
+	"ArrowUp",
+	"ArrowDown",
+	"End",
+	"Home",
+	"PageDown",
+	"PageUp",
+	"Backspace",
+	"Delete",
+	"Insert",
+	"Escape",
+	"ContextMenu",
+	"Pause",
+	"Dead",
+	"Process",
+	"Unidentified"
+]);
+var nextSession$1 = 0;
+function own$1(value, key) {
+	return value && typeof value === "object" ? Object.getOwnPropertyDescriptor(value, key)?.value : void 0;
+}
+function budget(value, fallback, maximum) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= maximum ? value : fallback;
+}
+var WorkflowRecorder = class {
+	constructor(root, version) {
+		this.root = root;
+		this.version = version;
+		this.session = null;
+		this.events = [];
+		this.startMs = 0;
+		this.maxEvents = 2e4;
+		this.maxBytes = 8388608;
+		this.closed = false;
+		this.pendingIntents = /* @__PURE__ */ new Set();
+		this.heldKeys = /* @__PURE__ */ new Set();
+		this.heldButtons = /* @__PURE__ */ new Set();
+		this.cleanups = [];
+		const recorder = this;
+		this.api = Object.freeze({
+			get active() {
+				return recorder.active;
+			},
+			start: (options) => this.start(options),
+			stop: () => this.stop(),
+			getSnapshot: () => this.snapshot()
+		});
+	}
+	attachInputs() {
+		const view = this.root.ownerDocument.defaultView;
+		if (!view) throw new Error("Workflow recording requires a browser window.");
+		try {
+			for (const type of inputTypes) {
+				const listener = (event) => {
+					if (!this.active || !event.isTrusted) return;
+					try {
+						if (event.target instanceof view.Node && this.root.contains(event.target)) this.input(event);
+						else if (event.type === "keyup" ? this.heldKeys.delete(event.key) : event.type === "pointerup" ? this.heldButtons.delete(event.button) : false) this.unsupported("input-released-outside-mount");
+					} catch {
+						this.fail("capture-failure");
+					}
+				};
+				view.addEventListener(type, listener, true);
+				this.cleanups.push(() => view.removeEventListener(type, listener, true));
+			}
+		} catch (error) {
+			this.detachInputs();
+			throw error;
+		}
+	}
+	detachInputs() {
+		const cleanups = this.cleanups;
+		this.cleanups = [];
+		for (const cleanup of cleanups) try {
+			cleanup();
+		} catch {}
+	}
+	get active() {
+		return this.session?.status === "recording";
+	}
+	start(options = {}) {
+		if (this.closed) throw new Error("Cannot record a destroyed SuperDoc instance.");
+		if (this.active) throw new Error("Stop the active workflow recording first.");
+		this.maxEvents = budget(own$1(options, "maxEvents"), 2e4, 1e5);
+		this.maxBytes = budget(own$1(options, "maxBytes"), 8388608, 67108864);
+		const view = this.root.ownerDocument.defaultView;
+		this.events = [];
+		this.pendingIntents.clear();
+		this.startMs = view.performance.now();
+		this.session = {
+			schemaVersion: 1,
+			sessionId: `workflow-${Date.now()}-${++nextSession$1}`,
+			version: this.version(),
+			status: "recording",
+			startedAt: Date.now(),
+			durationMs: 0,
+			timeOrigin: view.performance.timeOrigin,
+			startTimeMs: this.startMs,
+			captureContent: own$1(options, "captureContent") === true,
+			viewport: {
+				width: view.innerWidth,
+				height: view.innerHeight,
+				devicePixelRatio: view.devicePixelRatio
+			},
+			retainedBytes: 0,
+			replayUnsupportedReasons: [],
+			pendingIntentIds: []
+		};
+		try {
+			this.attachInputs();
+			this.observe("workflow:started", () => ({
+				scrollTop: this.root.scrollTop,
+				scrollLeft: this.root.scrollLeft
+			}));
+		} catch {
+			this.fail("capture-failure");
+		}
+		return this.snapshot();
+	}
+	observe(type, read) {
+		if (!this.active) return;
+		try {
+			let remaining = 4096;
+			const copy = (value, depth = 0) => {
+				if (--remaining < 0 || depth > 14) throw new Error("payload-limit");
+				if (value === null || typeof value === "boolean") return value;
+				if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+				if (typeof value === "string") {
+					if (value.length > 32768) throw new Error("payload-limit");
+					return value;
+				}
+				if (!value || typeof value !== "object") return void 0;
+				if (Array.isArray(value)) {
+					if (value.length > 256) throw new Error("payload-limit");
+					return Array.from({ length: value.length }, (_, i) => copy(own$1(value, String(i)), depth + 1) ?? null);
+				}
+				const result = {};
+				for (const key of fields$1) {
+					const item = own$1(value, key);
+					if (key === "value" && typeof item === "string" && !this.session.captureContent) continue;
+					if (item !== void 0) result[key] = copy(item, depth + 1);
+				}
+				if (this.session.captureContent) for (const key of contentFields$1) {
+					const item = own$1(value, key);
+					if (item !== void 0) result[key] = copy(item, depth + 1);
+				}
+				return result;
+			};
+			const event = {
+				sequence: this.events.length + 1,
+				atMs: this.root.ownerDocument.defaultView.performance.now() - this.startMs,
+				type,
+				data: copy(read()) ?? {}
+			};
+			const serialized = JSON.stringify(event);
+			if (this.events.length >= this.maxEvents || this.session.retainedBytes + serialized.length * 2 > this.maxBytes) {
+				this.fail("capture-limit");
+				return;
+			}
+			this.events.push(serialized);
+			this.session.retainedBytes += serialized.length * 2;
+			if (type === "interaction:intent") {
+				const id = `${event.data.documentId ?? ""}/${event.data.selectionLineageId}/${event.data.intentSequence}`;
+				if (event.data.phase === "enqueued" || event.data.phase === "executing") this.pendingIntents.add(id);
+				if (event.data.phase === "settled" || event.data.phase === "failed") this.pendingIntents.delete(id);
+			}
+		} catch {
+			this.fail("capture-failure");
+		}
+	}
+	unsupported(reason) {
+		if (!this.session.replayUnsupportedReasons.includes(reason)) this.session.replayUnsupportedReasons.push(reason);
+	}
+	fail(reason) {
+		if (!this.session) return;
+		this.unsupported(reason);
+		try {
+			this.session.durationMs = this.root.ownerDocument.defaultView.performance.now() - this.startMs;
+		} catch {}
+		this.session.status = "incomplete";
+		this.clearHeldInput();
+		this.detachInputs();
+	}
+	input(event) {
+		if (!this.active || !event.isTrusted) return;
+		try {
+			const target = event.target instanceof this.root.ownerDocument.defaultView.Element ? event.target : this.root;
+			const pointer = event;
+			if (event.type === "pointermove" && pointer.buttons === 0) return;
+			let element = target;
+			let selector = null;
+			while (element && element !== this.root) {
+				for (const attribute of [
+					"data-layout-fragment-id",
+					"data-layout-block-ref",
+					"data-page-index",
+					"data-item",
+					"data-testid",
+					"aria-label"
+				]) {
+					const value = element.getAttribute(attribute);
+					if (value) {
+						selector = `[${attribute}=${JSON.stringify(value)}]`;
+						break;
+					}
+				}
+				if (selector) break;
+				element = element.parentElement;
+			}
+			if (!selector && target !== this.root) {
+				const path = [];
+				element = target;
+				while (element && element !== this.root) {
+					const parent = element.parentElement;
+					if (!parent) break;
+					path.unshift(`:nth-child(${Array.prototype.indexOf.call(parent.children, element) + 1})`);
+					element = parent;
+				}
+				if (element === this.root) selector = `:scope > ${path.join(" > ")}`;
+				element = target;
+			}
+			const modifiers = event;
+			const paintedTarget = { selector };
+			if (event.type.startsWith("pointer") || [
+				"mousedown",
+				"mouseup",
+				"click",
+				"dblclick"
+			].includes(event.type)) {
+				const path = [];
+				let part = element ?? this.root;
+				while (part && part !== this.root) {
+					const parent = part.parentElement;
+					if (!parent) break;
+					path.unshift(`:nth-child(${Array.prototype.indexOf.call(parent.children, part) + 1})`);
+					part = parent;
+				}
+				if (part === this.root && path.length) paintedTarget.domPath = `:scope > ${path.join(" > ")}`;
+				const controls = /* @__PURE__ */ new Set();
+				for (let ancestor = target; ancestor && ancestor !== this.root; ancestor = ancestor.parentElement) {
+					for (const [attribute, field] of [
+						["data-source-node-id", "blockId"],
+						["data-layout-fragment-id", "fragmentId"],
+						["data-layout-block-ref", "layoutBlockRef"],
+						["data-layout-story", "storyId"],
+						["data-page-index", "pageIndex"]
+					]) {
+						const value = ancestor.getAttribute(attribute);
+						if (value && paintedTarget[field] == null) paintedTarget[field] = field === "pageIndex" ? Number(value) : value;
+					}
+					const control = ancestor.getAttribute("data-sdt-id") ?? ancestor.getAttribute("data-sdt-container-id");
+					if (control) controls.add(control);
+					if (ancestor.classList.contains("superdoc-table-fragment") && paintedTarget.tableId == null) paintedTarget.tableId = ancestor.getAttribute("data-layout-block-ref");
+				}
+				paintedTarget.contentControlIds = [...controls];
+				paintedTarget.contextSource = "painted-pointer";
+				if (paintedTarget.fragmentId && paintedTarget.pageIndex != null) paintedTarget.selector = `[data-page-index="${paintedTarget.pageIndex}"] ${selector}`;
+				const scrollAncestors = [];
+				for (let ancestor = target; ancestor; ancestor = ancestor.parentElement) {
+					const style = this.root.ownerDocument.defaultView.getComputedStyle(ancestor);
+					const scrollable = ancestor === this.root || /auto|scroll/.test(`${style.overflowX} ${style.overflowY}`);
+					if (ancestor.scrollLeft || ancestor.scrollTop || scrollable && (ancestor.scrollWidth > ancestor.clientWidth || ancestor.scrollHeight > ancestor.clientHeight)) {
+						const path = [];
+						let part = ancestor;
+						while (part && part !== this.root) {
+							const parent = part.parentElement;
+							if (!parent) break;
+							path.unshift(`:nth-child(${Array.prototype.indexOf.call(parent.children, part) + 1})`);
+							part = parent;
+						}
+						if (part === this.root) scrollAncestors.push({
+							selector: ancestor === this.root ? null : `:scope > ${path.join(" > ")}`,
+							scrollLeft: ancestor.scrollLeft,
+							scrollTop: ancestor.scrollTop
+						});
+					}
+					if (ancestor === this.root) break;
+					if (scrollAncestors.length >= 32) throw new Error("scroll-ancestor-limit");
+				}
+				paintedTarget.scrollAncestors = scrollAncestors;
+			}
+			const data = {
+				target: paintedTarget,
+				inputAtMs: event.timeStamp > this.root.ownerDocument.defaultView.performance.timeOrigin ? event.timeStamp - this.root.ownerDocument.defaultView.performance.timeOrigin : event.timeStamp,
+				altKey: modifiers.altKey,
+				ctrlKey: modifiers.ctrlKey,
+				metaKey: modifiers.metaKey,
+				shiftKey: modifiers.shiftKey
+			};
+			if (event.type === "keydown" || event.type === "keyup") {
+				const key = modifiers.key;
+				if (event.type === "keydown") this.heldKeys.add(key);
+				else this.heldKeys.delete(key);
+				const named = namedKeys.has(key) || /^F(?:[1-9]|1\d|2[0-4])$/.test(key);
+				data.key = !named && !this.session.captureContent ? void 0 : key;
+				data.repeat = modifiers.repeat;
+				data.isComposing = modifiers.isComposing;
+				if (!named && !this.session.captureContent) this.unsupported("content-redacted");
+				if (modifiers.isComposing || key === "Dead" || key === "Process") this.unsupported("ime");
+			} else if (event.type.startsWith("pointer") || [
+				"mousedown",
+				"mouseup",
+				"click",
+				"dblclick"
+			].includes(event.type)) {
+				const rect = (element ?? this.root).getBoundingClientRect();
+				if (event.type === "pointerdown") this.heldButtons.add(pointer.button);
+				if (event.type === "pointerup") this.heldButtons.delete(pointer.button);
+				Object.assign(data, {
+					button: pointer.button,
+					buttons: pointer.buttons,
+					pointerType: pointer.pointerType ?? "mouse",
+					clickCount: pointer.detail,
+					x: pointer.clientX - rect.left,
+					y: pointer.clientY - rect.top
+				});
+				if (pointer.pointerType && pointer.pointerType !== "mouse") this.unsupported("non-mouse-pointer");
+				if (!selector) this.unsupported("unresolved-pointer-target");
+			} else if (event.type === "scroll") {
+				Object.assign(data, {
+					scrollTop: target.scrollTop,
+					scrollLeft: target.scrollLeft
+				});
+				if (target !== this.root && !selector) this.unsupported("unresolved-scroll-target");
+			} else {
+				const input = event;
+				Object.assign(data, {
+					inputType: input.inputType,
+					dataLength: input.data?.length,
+					...this.session.captureContent ? { data: input.data } : {}
+				});
+				if (input.data && !this.session.captureContent) this.unsupported("content-redacted");
+				if ([
+					"paste",
+					"cut",
+					"drop",
+					"dragstart",
+					"compositionstart",
+					"compositionend"
+				].includes(event.type)) this.unsupported(event.type);
+				if (event.type === "beforeinput" && input.inputType !== "insertText" && !input.inputType?.startsWith("delete")) this.unsupported(`beforeinput:${input.inputType}`);
+			}
+			this.observe(`browser:${event.type}`, () => data);
+		} catch {
+			this.fail("capture-failure");
+		}
+	}
+	clearHeldInput() {
+		this.heldKeys.clear();
+		this.heldButtons.clear();
+	}
+	stop() {
+		if (this.active) {
+			if (this.heldKeys.size || this.heldButtons.size) this.unsupported("held-input-at-stop");
+			this.session.durationMs = this.root.ownerDocument.defaultView.performance.now() - this.startMs;
+			this.session.status = "stopped";
+			this.clearHeldInput();
+		}
+		this.detachInputs();
+		return this.snapshot();
+	}
+	snapshot() {
+		if (!this.session) return null;
+		return {
+			...this.session,
+			viewport: { ...this.session.viewport },
+			durationMs: this.active ? this.root.ownerDocument.defaultView.performance.now() - this.startMs : this.session.durationMs,
+			replayUnsupportedReasons: [...this.session.replayUnsupportedReasons],
+			events: this.events.map((event) => JSON.parse(event)),
+			pendingIntentIds: [...this.pendingIntents]
+		};
+	}
+	close() {
+		if (this.active) this.fail("instance-destroyed");
+		this.closed = true;
+		this.detachInputs();
+	}
+};
+//#endregion
 //#region src/internal/diagnostics/interaction-history.ts
+function isWorkflowRecordingEnabled(config) {
+	try {
+		return own(own(own(config, "diagnostics"), "recording"), "enabled") === true;
+	} catch {
+		return false;
+	}
+}
 var recorders = /* @__PURE__ */ new WeakMap();
 var nextSession = 0;
 var fields = [
@@ -105,7 +663,7 @@ function limit(value, fallback, ceiling) {
 	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= ceiling ? value : fallback;
 }
 var InteractionRecorder = class {
-	constructor(config, version) {
+	constructor(config, version, root) {
 		this.version = version;
 		this.sessionId = `interaction-${++nextSession}`;
 		this.slots = [];
@@ -119,6 +677,9 @@ var InteractionRecorder = class {
 		this.failures = 0;
 		this.closed = false;
 		this.cleanups = [];
+		if (isWorkflowRecordingEnabled(config)) try {
+			this.workflow = new WorkflowRecorder(root, version);
+		} catch {}
 		const history = own(own(config, "diagnostics"), "history");
 		this.enabled = own(history, "enabled") !== false;
 		this.captureContent = own(history, "captureContent") === true;
@@ -126,6 +687,7 @@ var InteractionRecorder = class {
 		this.maxBytes = limit(own(history, "maxBytes"), 1048576, 16777216);
 	}
 	record(type, read) {
+		this.workflow?.observe(type, read);
 		if (!this.enabled || this.closed) return;
 		try {
 			let truncated = false;
@@ -202,7 +764,7 @@ var InteractionRecorder = class {
 		}
 	}
 	action() {
-		return this.enabled && !this.closed ? `${this.sessionId}:${++this.actions}` : void 0;
+		return (this.enabled || this.workflow?.active) && !this.closed ? `${this.sessionId}:${++this.actions}` : void 0;
 	}
 	snapshot() {
 		const events = [];
@@ -286,6 +848,7 @@ var InteractionRecorder = class {
 		}
 	}
 	close() {
+		this.workflow?.close();
 		this.closed = true;
 		for (const cleanup of this.cleanups) try {
 			cleanup();
@@ -312,10 +875,11 @@ var unavailable = Object.freeze({
 });
 function createInteractionHistory(owner, config, version, root) {
 	try {
-		const recorder = new InteractionRecorder(config, version);
+		const recorder = new InteractionRecorder(config, version, root);
 		recorders.set(owner, recorder);
 		recorder.attach(root);
 		const handle = Object.freeze({
+			...recorder.workflow ? { recording: recorder.workflow.api } : {},
 			getSnapshot: () => {
 				try {
 					return recorder.snapshot();
@@ -360,6 +924,9 @@ function closeInteractionHistory(owner) {
 		recorders.delete(owner);
 	} catch {}
 }
+function getWorkflowRecording(owner) {
+	return recorders.get(owner)?.workflow?.api;
+}
 //#endregion
 //#region ../layout-engine/dom-contract/src/class-names.ts
 /**
@@ -13660,4 +14227,4 @@ function commandIsActive(descriptor, selection) {
 	return descriptor.activeMark ? selection.activeMarks.includes(descriptor.activeMark) : false;
 }
 //#endregion
-export { BUILT_IN_COMMAND_IDS as a, createImageFilePicker as c, DOM_CLASS_NAMES as d, closeInteractionHistory as f, registerFirstPartyCommandMutation as i, resolveImageSrc as l, recordInteraction as m, executeFirstPartyCommandAsync as n, applyV2CommentInvalidationFromMutation as o, createInteractionHistory as p, readFirstPartyPageNumbers as r, getV2TrackedChangeMutationImpact as s, createSuperDocUI as t, shallowEqual as u };
+export { BUILT_IN_COMMAND_IDS as a, createImageFilePicker as c, DOM_CLASS_NAMES as d, closeInteractionHistory as f, recordInteraction as g, isWorkflowRecordingEnabled as h, registerFirstPartyCommandMutation as i, resolveImageSrc as l, getWorkflowRecording as m, executeFirstPartyCommandAsync as n, applyV2CommentInvalidationFromMutation as o, createInteractionHistory as p, readFirstPartyPageNumbers as r, getV2TrackedChangeMutationImpact as s, createSuperDocUI as t, shallowEqual as u };