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

package/dist/chunks/{create-super-doc-ui-j8Qm5SYa.cjs → create-super-doc-ui-yKesgn9b.cjs}

@@ -1,5 +1,563 @@
 const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper-CYxINHh_.cjs");
+//#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
 /**
@@ -13715,6 +14282,18 @@ Object.defineProperty(exports, "getV2TrackedChangeMutationImpact", {
 		return getV2TrackedChangeMutationImpact;
 	}
 });
+Object.defineProperty(exports, "getWorkflowRecording", {
+	enumerable: true,
+	get: function() {
+		return getWorkflowRecording;
+	}
+});
+Object.defineProperty(exports, "isWorkflowRecordingEnabled", {
+	enumerable: true,
+	get: function() {
+		return isWorkflowRecordingEnabled;
+	}
+});
 Object.defineProperty(exports, "readFirstPartyPageNumbers", {
 	enumerable: true,
 	get: function() {

package/dist/collaboration-upgrade-engine.cjs

@@ -19,7 +19,7 @@ var COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR = 20;
 var PRIVATE_ENGINE_INFO = (0, _superdoc_docx_engine_collaboration_upgrade_engine.getCollaborationUpgradeEngineInfo)();
 var ENGINE_INFO = Object.freeze({
 	...PRIVATE_ENGINE_INFO,
-	superdocVersion: "2.20.1-next.9",
+	superdocVersion: "2.21.0-next.2",
 	roomSchemaVersion: Object.freeze({ ...PRIVATE_ENGINE_INFO.roomSchemaVersion }),
 	supportedBundleVersions: SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS,
 	supportedV1ReaderContractVersions: SUPPORTED_V1_READER_CONTRACT_VERSIONS

package/dist/collaboration-upgrade-engine.es.js

@@ -18,7 +18,7 @@ var COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR = 20;
 var PRIVATE_ENGINE_INFO = getCollaborationUpgradeEngineInfo$1();
 var ENGINE_INFO = Object.freeze({
 	...PRIVATE_ENGINE_INFO,
-	superdocVersion: "2.20.1-next.9",
+	superdocVersion: "2.21.0-next.2",
 	roomSchemaVersion: Object.freeze({ ...PRIVATE_ENGINE_INFO.roomSchemaVersion }),
 	supportedBundleVersions: SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS,
 	supportedV1ReaderContractVersions: SUPPORTED_V1_READER_CONTRACT_VERSIONS