superdoc 2.0.0-next.40 → 2.0.0-next.42

package/dist/chunks/{create-super-doc-ui-BDAxgGrE.es.js → create-super-doc-ui-BFz0iim0.es.js}

@@ -1230,6 +1230,257 @@ const decodeLayoutStoryDataset = (raw) => {
 };
 `${DOM_CLASS_NAMES.BLOCK_SDT}${DATA_ATTRS.SDT_ID}`;
 `${DATA_ATTRS.DRAGGABLE}`;
+var schemaBooleanOrNull = () => ({ oneOf: [{ type: "boolean" }, { type: "null" }] });
+var schemaStringOrNull = () => ({ oneOf: [{
+	type: "string",
+	minLength: 1
+}, { type: "null" }] });
+var schemaNumberOrNull = () => ({ oneOf: [{ type: "number" }, { type: "null" }] });
+var schemaObjectOrNull = (properties) => ({ oneOf: [{
+	type: "object",
+	properties,
+	additionalProperties: false,
+	minProperties: 1
+}, { type: "null" }] });
+var UNDERLINE_OBJECT_SCHEMA = {
+	type: "object",
+	properties: {
+		style: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		color: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		themeColor: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] }
+	},
+	additionalProperties: false,
+	minProperties: 1
+};
+var STYLISTIC_SET_ITEM_SCHEMA = {
+	type: "object",
+	properties: {
+		id: { type: "number" },
+		val: { type: "boolean" }
+	},
+	required: ["id"],
+	additionalProperties: false
+};
+var schemaUnderlinePatch = () => ({ oneOf: [
+	{ type: "boolean" },
+	{ type: "null" },
+	UNDERLINE_OBJECT_SCHEMA
+] });
+var schemaStylisticSets = () => ({ oneOf: [{
+	type: "array",
+	items: STYLISTIC_SET_ITEM_SCHEMA,
+	minItems: 1
+}, { type: "null" }] });
+function markCarrier(markName, textStyleAttr) {
+	return {
+		storage: "mark",
+		markName,
+		textStyleAttr
+	};
+}
+function runAttributeCarrier(runPropertyKey) {
+	return {
+		storage: "runAttribute",
+		nodeName: "run",
+		runPropertyKey
+	};
+}
+var markBoolean = (key, ooxmlElement, markName) => ({
+	key,
+	type: "boolean",
+	ooxmlElement,
+	storage: "mark",
+	tracked: true,
+	carrier: markCarrier(markName),
+	schema: schemaBooleanOrNull()
+});
+var markTextStyleValue = (key, type, ooxmlElement, schema, textStyleAttr) => ({
+	key,
+	type,
+	ooxmlElement,
+	storage: "mark",
+	tracked: true,
+	carrier: markCarrier("textStyle", textStyleAttr ?? key),
+	schema
+});
+var runAttribute = (key, type, ooxmlElement, schema, runPropertyKey) => ({
+	key,
+	type,
+	ooxmlElement,
+	storage: "runAttribute",
+	tracked: false,
+	carrier: runAttributeCarrier(runPropertyKey ?? key),
+	schema
+});
+const INLINE_PROPERTY_REGISTRY = [
+	markBoolean("bold", "w:b", "bold"),
+	markBoolean("italic", "w:i", "italic"),
+	markBoolean("strike", "w:strike", "strike"),
+	{
+		key: "underline",
+		type: "object",
+		ooxmlElement: "w:u",
+		storage: "mark",
+		tracked: true,
+		carrier: markCarrier("underline"),
+		schema: schemaUnderlinePatch()
+	},
+	{
+		key: "highlight",
+		type: "string",
+		ooxmlElement: "w:highlight",
+		storage: "mark",
+		tracked: true,
+		carrier: markCarrier("highlight"),
+		schema: schemaStringOrNull()
+	},
+	markTextStyleValue("color", "string", "w:color", schemaStringOrNull()),
+	markTextStyleValue("fontSize", "number", "w:sz", schemaNumberOrNull()),
+	markTextStyleValue("fontFamily", "string", "w:rFonts", schemaStringOrNull()),
+	markTextStyleValue("letterSpacing", "number", "w:spacing", schemaNumberOrNull()),
+	markTextStyleValue("vertAlign", "string", "w:vertAlign", { oneOf: [{ enum: [
+		"superscript",
+		"subscript",
+		"baseline"
+	] }, { type: "null" }] }),
+	markTextStyleValue("position", "number", "w:position", schemaNumberOrNull()),
+	runAttribute("dstrike", "boolean", "w:dstrike", schemaBooleanOrNull()),
+	runAttribute("smallCaps", "boolean", "w:smallCaps", schemaBooleanOrNull()),
+	markTextStyleValue("caps", "boolean", "w:caps", schemaBooleanOrNull(), "textTransform"),
+	runAttribute("shading", "object", "w:shd", schemaObjectOrNull({
+		fill: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		color: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		val: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] }
+	})),
+	runAttribute("border", "object", "w:bdr", schemaObjectOrNull({
+		val: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		sz: { oneOf: [{ type: "number" }, { type: "null" }] },
+		color: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		space: { oneOf: [{ type: "number" }, { type: "null" }] }
+	}), "borders"),
+	runAttribute("outline", "boolean", "w:outline", schemaBooleanOrNull()),
+	runAttribute("shadow", "boolean", "w:shadow", schemaBooleanOrNull()),
+	runAttribute("emboss", "boolean", "w:emboss", schemaBooleanOrNull()),
+	runAttribute("imprint", "boolean", "w:imprint", schemaBooleanOrNull()),
+	runAttribute("charScale", "number", "w:w", schemaNumberOrNull(), "w"),
+	runAttribute("kerning", "number", "w:kern", schemaNumberOrNull(), "kern"),
+	runAttribute("vanish", "boolean", "w:vanish", schemaBooleanOrNull()),
+	runAttribute("webHidden", "boolean", "w:webHidden", schemaBooleanOrNull()),
+	runAttribute("specVanish", "boolean", "w:specVanish", schemaBooleanOrNull()),
+	runAttribute("rtl", "boolean", "w:rtl", schemaBooleanOrNull()),
+	runAttribute("cs", "boolean", "w:cs", schemaBooleanOrNull()),
+	runAttribute("bCs", "boolean", "w:bCs", schemaBooleanOrNull(), "boldCs"),
+	runAttribute("iCs", "boolean", "w:iCs", schemaBooleanOrNull(), "italicCs"),
+	runAttribute("eastAsianLayout", "object", "w:eastAsianLayout", schemaObjectOrNull({
+		id: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		combine: { oneOf: [{ type: "boolean" }, { type: "null" }] },
+		combineBrackets: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		vert: { oneOf: [{ type: "boolean" }, { type: "null" }] },
+		vertCompress: { oneOf: [{ type: "boolean" }, { type: "null" }] }
+	})),
+	runAttribute("em", "string", "w:em", schemaStringOrNull()),
+	runAttribute("fitText", "object", "w:fitText", schemaObjectOrNull({
+		val: { oneOf: [{ type: "number" }, { type: "null" }] },
+		id: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] }
+	})),
+	runAttribute("snapToGrid", "boolean", "w:snapToGrid", schemaBooleanOrNull()),
+	runAttribute("lang", "object", "w:lang", schemaObjectOrNull({
+		val: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		eastAsia: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		bidi: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] }
+	})),
+	runAttribute("oMath", "boolean", "w:oMath", schemaBooleanOrNull()),
+	runAttribute("rStyle", "string", "w:rStyle", schemaStringOrNull(), "styleId"),
+	runAttribute("rFonts", "object", "w:rFonts", schemaObjectOrNull({
+		ascii: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		hAnsi: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		eastAsia: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		cs: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		asciiTheme: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		hAnsiTheme: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		eastAsiaTheme: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		csTheme: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] },
+		hint: { oneOf: [{
+			type: "string",
+			minLength: 1
+		}, { type: "null" }] }
+	}), "fontFamily"),
+	runAttribute("fontSizeCs", "number", "w:szCs", schemaNumberOrNull()),
+	runAttribute("ligatures", "string", "w14:ligatures", schemaStringOrNull()),
+	runAttribute("numForm", "string", "w14:numForm", schemaStringOrNull()),
+	runAttribute("numSpacing", "string", "w14:numSpacing", schemaStringOrNull()),
+	runAttribute("stylisticSets", "array", "w14:stylisticSets", schemaStylisticSets()),
+	runAttribute("contextualAlternates", "boolean", "w14:cntxtAlts", schemaBooleanOrNull())
+];
+new Set(INLINE_PROPERTY_REGISTRY.map((entry) => entry.key));
+const INLINE_PROPERTY_BY_KEY = Object.fromEntries(INLINE_PROPERTY_REGISTRY.map((entry) => [entry.key, entry]));
+INLINE_PROPERTY_REGISTRY.filter((entry) => entry.storage === "mark").map((entry) => entry.key), INLINE_PROPERTY_REGISTRY.filter((entry) => entry.storage === "runAttribute").map((entry) => entry.key);
 var POST_DECISION_TRACKED_CHANGES_LIST_OPTIONS = Object.freeze({
 	mode: "background-reconcile",
 	refreshReason: "post-decision-background",
@@ -1872,6 +2123,12 @@ var MIRRORED_EDIT_COMMAND_IDS = {
 	undo: "history.undo",
 	redo: "history.redo"
 };
+var EFFECTIVE_MARK_KEYS = [
+	"bold",
+	"italic",
+	"underline",
+	"strikethrough"
+];
 function isProjectedInlineSelectionValueKey(value) {
 	return PROJECTED_INLINE_SELECTION_VALUE_KEYS.includes(value);
 }
@@ -2292,6 +2549,7 @@ var CLEAR_INLINE_PATCH = {
 	letterSpacing: null,
 	dstrike: null
 };
+var TRACKED_CLEAR_INLINE_PATCH = Object.fromEntries(Object.entries(CLEAR_INLINE_PATCH).filter(([key]) => INLINE_PROPERTY_BY_KEY[key]?.tracked === true));
 function buildInlineFormatInput(spec, target, payload, active) {
 	switch (spec.kind) {
 		case "toggle": {
@@ -3923,6 +4181,112 @@ function createSuperDocUI(options) {
 		if (sizes.size === 1) projection.fontSize = [...sizes][0];
 		return projection;
 	};
+	const resolveEffectiveMarkValuesFromLayout = (selection$1) => {
+		const host = getHost();
+		const blockIds = new Set(selectionBlockIds(selection$1));
+		if (blockIds.size === 0) return {};
+		const readByIds = host?.readMountedProjectionBlocksByIds;
+		const readAll = host?.readMountedProjectionBlocks;
+		if (typeof readByIds !== "function" && typeof readAll !== "function") return {};
+		const blocks = safeCall(() => {
+			if (typeof readByIds !== "function") return readAll.call(host);
+			const story = selectionStoryLocator(selection$1);
+			return story ? readByIds.call(host, [...blockIds], story) : readByIds.call(host, [...blockIds]);
+		}, null);
+		if (!Array.isArray(blocks)) return {};
+		const flatBlocks = collectProjectionTextBlocks(blocks);
+		const runMarkValues = (run) => ({
+			bold: run.bold === true,
+			italic: run.italic === true,
+			underline: run.underline != null,
+			strikethrough: run.strike === true
+		});
+		const collapseMarkSets = (sets) => {
+			const out = {};
+			for (const key of EFFECTIVE_MARK_KEYS) {
+				const set = sets[key];
+				if (set.size === 1) out[key] = [...set][0];
+			}
+			return out;
+		};
+		const caret = collapsedTextAddressFromSelection(selection$1);
+		const caretOffset = caret && typeof caret.range?.start === "number" ? caret.range.start : null;
+		if (caret && caretOffset !== null && blockIds.has(caret.blockId)) {
+			const block = flatBlocks.find((b) => projectionBlockMatchesId(b, caret.blockId));
+			const runs = block && Array.isArray(block.runs) ? block.runs : null;
+			if (runs && runs.length > 0 && runs.every((r) => r?.kind === "text" || r?.kind === "tab")) {
+				let acc = 0;
+				let chosen = null;
+				for (const run of runs) {
+					const len = typeof run.text === "string" ? run.text.length : 0;
+					if (caretOffset >= acc && caretOffset < acc + len) {
+						chosen = run;
+						break;
+					}
+					acc += len;
+				}
+				if (!chosen) {
+					for (let i = runs.length - 1; i >= 0 && !chosen; i -= 1) if (runs[i]?.kind === "text") chosen = runs[i];
+					chosen ??= runs[runs.length - 1] ?? null;
+				}
+				if (!chosen) return {};
+				return runMarkValues(chosen);
+			}
+		}
+		const segments = selectionTextSegments(selection$1);
+		if (segments.length > 0) {
+			const rangeSets = {
+				bold: /* @__PURE__ */ new Set(),
+				italic: /* @__PURE__ */ new Set(),
+				underline: /* @__PURE__ */ new Set(),
+				strikethrough: /* @__PURE__ */ new Set()
+			};
+			let rangeSawRun = false;
+			let offsetSafe = true;
+			for (const seg of segments) {
+				const block = flatBlocks.find((b) => projectionBlockMatchesId(b, seg.blockId));
+				if (!block) return {};
+				const runs = Array.isArray(block.runs) ? block.runs : [];
+				if (runs.length === 0) continue;
+				if (!runs.every((r) => r?.kind === "text" || r?.kind === "tab")) {
+					offsetSafe = false;
+					break;
+				}
+				let acc = 0;
+				for (const run of runs) {
+					const len = typeof run.text === "string" ? run.text.length : 0;
+					const runStart = acc;
+					const runEnd = acc + len;
+					if (runStart < seg.end && runEnd > seg.start) {
+						rangeSawRun = true;
+						const values = runMarkValues(run);
+						for (const key of EFFECTIVE_MARK_KEYS) rangeSets[key].add(values[key]);
+					}
+					acc = runEnd;
+				}
+			}
+			if (offsetSafe && rangeSawRun) return collapseMarkSets(rangeSets);
+		}
+		const wholeSets = {
+			bold: /* @__PURE__ */ new Set(),
+			italic: /* @__PURE__ */ new Set(),
+			underline: /* @__PURE__ */ new Set(),
+			strikethrough: /* @__PURE__ */ new Set()
+		};
+		let sawWholeRun = false;
+		for (const block of flatBlocks) {
+			if (![...blockIds].some((id) => projectionBlockMatchesId(block, id))) continue;
+			const runs = Array.isArray(block.runs) ? block.runs : [];
+			for (const run of runs) {
+				if (run?.kind !== "text") continue;
+				sawWholeRun = true;
+				const values = runMarkValues(run);
+				for (const key of EFFECTIVE_MARK_KEYS) wholeSets[key].add(values[key]);
+			}
+		}
+		if (!sawWholeRun) return {};
+		return collapseMarkSets(wholeSets);
+	};
 	const completeProjectedInlineValues = (selection$1, direct) => {
 		if (direct.fontFamily !== void 0 && direct.fontSize !== void 0 && direct.color !== void 0 && direct.highlight !== void 0) return {
 			values: direct,
@@ -3952,21 +4316,33 @@ function createSuperDocUI(options) {
 			effectiveUniformityStatus: "ready"
 		};
 	};
-	const resolveEffectiveInlineUniformityValues = (selection$1) => {
+	const EFFECTIVE_INLINE_UNIFORMITY_KEYS = [
+		"fontFamily",
+		"fontSize",
+		"bold",
+		"italic",
+		"underline",
+		"strikethrough"
+	];
+	const readEffectiveInlineUniformityCached = (selection$1) => {
 		const target = selection$1.selectionTarget;
 		if (!target) return {
-			values: null,
+			value: null,
 			status: "ready"
 		};
 		const op = resolveDocOperation(getDoc(), "format.readEffectiveInlineUniformity");
 		if (!op) return {
-			values: null,
+			value: null,
 			status: "ready"
 		};
-		const { value, status } = readAsync(`effInline:${selectionEffectiveUniformitySignature(selection$1) ?? selectionSignature(selection$1)}`, contentToken(), () => op({
+		return readAsync(`effInline:${selectionEffectiveUniformitySignature(selection$1) ?? selectionSignature(selection$1)}`, contentToken(), () => op({
 			target,
-			offsetSpace: "selection"
+			offsetSpace: "selection",
+			keys: EFFECTIVE_INLINE_UNIFORMITY_KEYS
 		}), (raw) => raw && typeof raw === "object" ? raw : null);
+	};
+	const resolveEffectiveInlineUniformityValues = (selection$1) => {
+		const { value, status } = readEffectiveInlineUniformityCached(selection$1);
 		if (!value || value.success !== true) return {
 			values: null,
 			status
@@ -3985,6 +4361,33 @@ function createSuperDocUI(options) {
 			status
 		};
 	};
+	const resolveEffectiveMarkUniformityValues = (selection$1) => {
+		const { value, status } = readEffectiveInlineUniformityCached(selection$1);
+		if (!value || value.success !== true) return {
+			values: null,
+			status
+		};
+		const states = value.values;
+		const values = {};
+		for (const key of EFFECTIVE_MARK_KEYS) {
+			const entry = states?.[key];
+			if (entry?.state === "uniform" && (entry.value === "true" || entry.value === "false")) values[key] = entry.value === "true";
+		}
+		return {
+			values,
+			status
+		};
+	};
+	const effectiveMarkActiveState = (descriptor, selection$1) => {
+		const mark = descriptor.activeMark;
+		if (!mark || !EFFECTIVE_MARK_KEYS.includes(mark)) return null;
+		const key = mark;
+		const fromLayout = resolveEffectiveMarkValuesFromLayout(selection$1)[key];
+		if (fromLayout !== void 0) return fromLayout;
+		const { values } = resolveEffectiveMarkUniformityValues(selection$1);
+		const fromWorker = values?.[key];
+		return fromWorker !== void 0 ? fromWorker : null;
+	};
 	const readEffectiveInlineUniformityNow = async (selection$1) => {
 		const target = selection$1.selectionTarget;
 		if (!target) return null;
@@ -4353,6 +4756,8 @@ function createSuperDocUI(options) {
 		const optimistic = optimisticInlineToggles.get(descriptor.id);
 		const selectionSignature$1 = selectionInlineValueSignature(selection$1);
 		if (selectionSignature$1 && optimistic?.selectionSignature === selectionSignature$1) return optimistic.active;
+		const effective = effectiveMarkActiveState(descriptor, selection$1);
+		if (effective !== null) return effective;
 		return commandIsActive(descriptor, selection$1);
 	};
 	const routedCommandValue = (descriptor, doc, selection$1, projectedInlineValues) => {
@@ -5621,6 +6026,7 @@ function createSuperDocUI(options) {
 		if (UNSUPPORTED_TRACKED_UI_MUTATION_ROUTES.has(route)) return unsupportedTrackedMutationReceipt(route);
 		return { changeMode: "tracked" };
 	};
+	const clearInlinePatchForMode = () => readDocumentMode() === "suggesting" ? TRACKED_CLEAR_INLINE_PATCH : CLEAR_INLINE_PATCH;
 	const callEditorMutation = (route, op, input) => {
 		const options$1 = editorMutationOptionsForRoute(route);
 		if (options$1 && options$1.success === false) return options$1;
@@ -5877,7 +6283,7 @@ function createSuperDocUI(options) {
 			if (inlineOp) try {
 				record(callInlineFormatMutation("format.apply", inlineOp, {
 					target: rangeTarget,
-					inline: { ...CLEAR_INLINE_PATCH }
+					inline: { ...clearInlinePatchForMode() }
 				}));
 			} catch {
 				immediateResults.push(false);