@stll/folio-core 0.53.0 → 0.54.1

package/dist/markdown/renderRuns.js

@@ -5,6 +5,7 @@ import { wrapComment, wrapDeletion, wrapInsertion, wrapMoveFrom, wrapMoveTo } fr
 import { escapeAltText, escapeInline, escapeLinkUrl } from "./escape.js";
 import { registerImage } from "./images.js";
 import { numberNoteReference, pushWarning } from "./internals.js";
+import { compileMarkdownToContent } from "@stll/docx-core";
 //#region src/markdown/renderRuns.ts
 const MARK_DELIMS = {
 	bold: "**",
@@ -32,9 +33,9 @@ function marksFor(run) {
 	const f = run.formatting;
 	if (!f) return [];
 	const out = [];
+	if (f.strike) out.push("strike");
 	if (f.bold) out.push("bold");
 	if (f.italic) out.push("italic");
-	if (f.strike) out.push("strike");
 	const ascii = f.fontFamily?.ascii?.toLowerCase();
 	if (ascii && MONOSPACE_FONTS.has(ascii)) out.push("code");
 	return out;
@@ -42,7 +43,7 @@ function marksFor(run) {
 function applyMarks(text, marks) {
 	if (!text) return text;
 	if (marks.includes("code")) {
-		const literal = text.replace(/\\(?<char>[\\`*[\]_<])/gu, "$<char>");
+		const literal = text.replace(/\\(?<char>[\\`*[\]_<~])/gu, "$<char>");
 		let longestRun = 0;
 		for (const m of literal.matchAll(/`+/gu)) longestRun = Math.max(longestRun, m[0].length);
 		const fence = "`".repeat(longestRun + 1);
@@ -56,6 +57,133 @@ function applyMarks(text, marks) {
 	}
 	return out;
 }
+const UNKNOWN_NEIGHBORS = {
+	before: void 0,
+	after: void 0
+};
+const isBlank = (ch) => ch === "" || ch !== void 0 && /\s/u.test(ch);
+/**
+* Which mark wraps a stretch of runs first, outermost first. Strikethrough
+* goes inside emphasis: an emphasis delimiter beside a tilde opens and closes
+* wherever it stands, where the other way round (`~~*`) needs a blank or
+* punctuation outside.
+*/
+const GROUPING_ORDER = [
+	"italic",
+	"bold",
+	"strike"
+];
+/** The stackings tried, in turn, where the reader misreads one. */
+const GROUPING_ORDERS = [GROUPING_ORDER, [
+	"bold",
+	"italic",
+	"strike"
+]];
+/**
+* CommonMark punctuation (Unicode P and S categories) as a delimiter of
+* `mark` meets it. Beside an emphasis delimiter, an asterisk is another
+* delimiter that runs together with it, and a tilde does not let it close
+* (the GFM reader's rule): both count as letters. (Words carry them escaped,
+* as a two-character unit.)
+*/
+const punctuationFor = (mark) => (ch) => {
+	if (ch === void 0 || ch === "" || ch === "~") return false;
+	if (mark !== "strike" && ch === "*") return false;
+	return /[\p{P}\p{S}]/u.test(ch);
+};
+/** One escape pair (`\*`) or one code point of escaped inline text. */
+const INLINE_UNIT = /\\[\s\S]|[\s\S]/gu;
+/**
+* Wrap `inner` in `mark` so a CommonMark reader reads it back. A delimiter
+* opens only before a character that is not blank, and before punctuation
+* only where blank or punctuation precedes it; closing mirrors that. Where
+* the words at an edge would stop a delimiter from opening or closing (a
+* space at the edge, emphasis ending in a full stop right before a letter),
+* those characters are left outside the emphasis rather than written as
+* literal asterisks.
+*/
+function wrapFlanking(inner, mark, { before, after }) {
+	const isPunctuation = punctuationFor(mark);
+	const opensAfter = (ch) => isBlank(ch) || isPunctuation(ch);
+	const units = Array.from(inner.matchAll(INLINE_UNIT), ([unit]) => unit);
+	const isPunctuationUnit = (unit) => unit.length === 2 && unit.startsWith("\\") || isPunctuation(unit);
+	let start = 0;
+	let end = units.length;
+	let outside = before;
+	for (;;) {
+		const unit = units[start];
+		if (unit === void 0 || start >= end) break;
+		if (!isBlank(unit) && (!isPunctuationUnit(unit) || opensAfter(outside))) break;
+		outside = unit.at(-1);
+		start++;
+	}
+	outside = after;
+	for (;;) {
+		const unit = units[end - 1];
+		if (unit === void 0 || end <= start) break;
+		if (!isBlank(unit) && (!isPunctuationUnit(unit) || opensAfter(outside))) break;
+		outside = unit.at(0);
+		end--;
+	}
+	return units.slice(0, start).join("") + applyMarks(units.slice(start, end).join(""), start < end ? [mark] : []) + units.slice(end).join("");
+}
+/** Paragraph content that writes nothing to the line. */
+const SILENT_MARKERS = /* @__PURE__ */ new Set([
+	"bookmarkStart",
+	"bookmarkEnd",
+	"moveFromRangeStart",
+	"moveFromRangeEnd",
+	"moveToRangeStart",
+	"moveToRangeEnd"
+]);
+/** Comment range markers, which write nothing when comments are stripped. */
+const COMMENT_MARKERS = /* @__PURE__ */ new Set(["commentRangeStart", "commentRangeEnd"]);
+/** The first character `piece` puts on the line, inside the marks `outer` already opened. */
+const pieceStart = (piece, outer, order) => {
+	const first = piece.text.match(INLINE_UNIT)?.[0];
+	if (first === void 0 || isBlank(first)) return first;
+	const opens = order.find((mark) => piece.marks.has(mark) && !outer.has(mark));
+	if (opens === void 0) return first;
+	return opens === "strike" ? "~" : "*";
+};
+/**
+* Wrap consecutive pieces in their emphasis, one mark at a time: the pieces
+* sharing the outermost mark are wrapped once, around the rest of their
+* emphasis. Written run by run, the closing delimiter of one would meet the
+* opening one of the next (`*a**b*`), which no reader takes for two
+* emphases.
+*/
+function renderPieces(pieces, outer, edges, order = GROUPING_ORDER) {
+	let out = "";
+	let index = 0;
+	while (index < pieces.length) {
+		const piece = pieces[index];
+		if (!piece) break;
+		const mark = order.find((key) => piece.marks.has(key) && !outer.has(key));
+		if (mark === void 0) {
+			out += piece.text;
+			index++;
+			continue;
+		}
+		let last = index;
+		while (pieces[last + 1]?.marks.has(mark)) last++;
+		const next = pieces[last + 1];
+		const around = {
+			before: out.length > 0 ? out.at(-1) : edges.before,
+			after: next === void 0 ? edges.after : pieceStart(next, outer, order)
+		};
+		const inner = renderPieces(pieces.slice(index, last + 1), /* @__PURE__ */ new Set([...outer, mark]), around, order);
+		out += wrapFlanking(inner, mark, around);
+		index = last + 1;
+	}
+	return out;
+}
+/** The first character an item that is not a run puts on the line, where it is fixed. */
+function renderedStart(item) {
+	if (item?.type !== "hyperlink") return void 0;
+	const link = item;
+	return link.href || link.anchor ? "[" : void 0;
+}
 /** Render a single run's RunContent array into the inline text fragment. */
 function renderRunContent(ctx, pkg, content, paraId) {
 	let out = "";
@@ -111,21 +239,111 @@ function renderRunContent(ctx, pkg, content, paraId) {
 	}
 	return out;
 }
-/** Render a single Run with its formatting applied. */
-function renderRun(ctx, pkg, run, paraId) {
-	if (run.formatting?.hidden) return "";
+/** A run's rendered text and the emphasis it still takes; `null` when it writes nothing. */
+function pieceOf(ctx, pkg, run, paraId) {
+	if (run.formatting?.hidden) return null;
 	const inner = renderRunContent(ctx, pkg, run.content, paraId);
-	if (!inner) return "";
+	if (!inner) return null;
+	const marks = marksFor(run);
+	if (!marks.includes("code")) return {
+		text: inner,
+		marks: new Set(marks)
+	};
 	const leadLen = inner.length - inner.trimStart().length;
 	const trailLen = inner.length - inner.trimEnd().length;
 	const core = inner.slice(leadLen, inner.length - trailLen);
-	if (!core) return inner;
-	const lead = inner.slice(0, leadLen);
-	const trail = inner.slice(inner.length - trailLen);
-	return `${lead}${applyMarks(core, marksFor(run))}${trail}`;
+	return {
+		text: core ? `${inner.slice(0, leadLen)}${applyMarks(core, marks)}${inner.slice(inner.length - trailLen)}` : inner,
+		marks: /* @__PURE__ */ new Set()
+	};
 }
+/** What a markdown reader reads from one line: each character with its emphasis. */
+const readLine = (line) => compileMarkdownToContent(line).content.flatMap((block) => block.type === "paragraph" ? block.content : []).flatMap((item) => item.type === "hyperlink" ? item.children : [item]).flatMap((item) => {
+	if (item.type !== "run") return [{
+		char: "\0",
+		marks: /* @__PURE__ */ new Set()
+	}];
+	const marks = new Set(GROUPING_ORDER.filter((key) => item.formatting?.[key] === true));
+	return item.content.flatMap((content) => content.type === "text" ? Array.from(content.text, (char) => ({
+		char,
+		marks
+	})) : [{
+		char: "\0",
+		marks
+	}]);
+});
+const sameMarks = (left, right) => left.size === right.size && [...left].every((key) => right.has(key));
+/**
+* How `rendered`, between `edges`, reads back: `"exact"` with the pieces'
+* text and each letter's emphasis, `"text"` with their text alone (emphasis
+* lost somewhere, none of it read as literal asterisks), or `null`.
+*/
+const readBack = (rendered, pieces, edges) => {
+	const side = (ch) => {
+		if (ch === void 0) return "x";
+		return ch === "" ? " " : ch;
+	};
+	const line = (inner) => `x ${side(edges.before)}${inner}${side(edges.after)} x`;
+	const read = readLine(line(rendered));
+	const plain = readLine(line(pieces.map(({ text }) => text).join("")));
+	if (read.map(({ char }) => char).join("") !== plain.map(({ char }) => char).join("")) return null;
+	const expected = pieces.flatMap(({ text, marks }) => readLine(`x${text}x`).slice(1, -1).map(({ char }) => ({
+		char,
+		marks
+	})));
+	const start = Array.from(`x ${side(edges.before)}`).length;
+	const end = Array.from(`${side(edges.after)} x`).length;
+	if (read.length !== start + expected.length + end) return read.every(({ marks }) => marks.size === 0) ? "text" : null;
+	let exact = true;
+	for (const [index, { char, marks }] of expected.entries()) {
+		const at = read[start + index];
+		if (at?.char !== char) return null;
+		if ([...at.marks].some((mark) => !marks.has(mark))) return null;
+		if (/[\p{L}\p{N}]/u.test(char) && !sameMarks(at.marks, marks)) exact = false;
+	}
+	return exact ? "exact" : "text";
+};
+/**
+* Render consecutive runs with their formatting applied. The delimiters are
+* placed by the flanking rules the reader applies, and the result is checked
+* against the reader: a stacking it misreads is tried the other way round,
+* or with more punctuation left outside, and failing all of those, the runs
+* go out without emphasis rather than with stray asterisks.
+*/
+function renderRuns(ctx, pkg, runs, paraId, edges = UNKNOWN_NEIGHBORS) {
+	const pieces = runs.flatMap((run) => pieceOf(ctx, pkg, run, paraId) ?? []);
+	const plain = pieces.map(({ text }) => text).join("");
+	if (!pieces.some(({ marks }) => marks.size > 0)) return plain;
+	let fallback;
+	for (const split of [pieces, splitAtBlanks(pieces)]) for (const order of GROUPING_ORDERS) for (const neighbors of [edges, UNKNOWN_NEIGHBORS]) {
+		const rendered = renderPieces(split, /* @__PURE__ */ new Set(), neighbors, order);
+		const read = readBack(rendered, pieces, edges);
+		if (read === "exact") return rendered;
+		if (read === "text") fallback ??= rendered;
+	}
+	return fallback ?? plain;
+}
+/** The pieces with every blank a piece of its own, without emphasis. */
+const splitAtBlanks = (pieces) => pieces.flatMap((piece) => {
+	if (piece.marks.size === 0) return [piece];
+	const parts = [];
+	for (const [unit] of piece.text.matchAll(INLINE_UNIT)) {
+		const marks = isBlank(unit) ? /* @__PURE__ */ new Set() : piece.marks;
+		const last = parts.at(-1);
+		if (last && last.marks === marks) last.text += unit;
+		else parts.push({
+			text: unit,
+			marks
+		});
+	}
+	return parts;
+});
 function renderHyperlink(ctx, pkg, link, paraId) {
-	const inner = getHyperlinkRuns(link).map((run) => renderRun(ctx, pkg, run, paraId)).join("");
+	const bracketed = Boolean(link.href ?? link.anchor);
+	const inner = renderRuns(ctx, pkg, getHyperlinkRuns(link), paraId, bracketed ? {
+		before: "[",
+		after: "]"
+	} : UNKNOWN_NEIGHBORS);
 	if (!inner) return "";
 	const href = link.href ?? (link.anchor ? `#${link.anchor}` : "");
 	if (!href) {
@@ -145,17 +363,17 @@ function renderHyperlink(ctx, pkg, link, paraId) {
 function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 	const renderChild = (child) => {
 		switch (child.type) {
-			case "run": return renderRun(ctx, pkg, child, paraId);
+			case "run": return renderRuns(ctx, pkg, [child], paraId);
 			case "hyperlink": return renderHyperlink(ctx, pkg, child, paraId);
 			case "mathEquation": return child.plainText ? escapeInline(child.plainText) : "";
 			case "inlineWrapper":
-			case "inlineSdt": return renderParagraphInline(ctx, pkg, child.content, paraId);
+			case "inlineSdt": return renderParagraphInline(ctx, pkg, child.content, paraId, UNKNOWN_NEIGHBORS);
 			case "insertion":
 			case "deletion":
 			case "moveFrom":
 			case "moveTo": return renderTrackedWrapper(ctx, pkg, child, paraId);
 			case "simpleField":
-			case "complexField": return renderParagraphInline(ctx, pkg, [child], paraId);
+			case "complexField": return renderParagraphInline(ctx, pkg, [child], paraId, UNKNOWN_NEIGHBORS);
 			case "bookmarkStart":
 			case "bookmarkEnd":
 			case "moveFromRangeStart":
@@ -166,11 +384,33 @@ function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 			default: return child;
 		}
 	};
+	const renderChildren = () => {
+		let rendered = "";
+		let runs = [];
+		const flush = (after) => {
+			if (runs.length === 0) return;
+			rendered += renderRuns(ctx, pkg, runs, paraId, {
+				before: rendered.length > 0 ? rendered.at(-1) : void 0,
+				after
+			});
+			runs = [];
+		};
+		for (const child of wrapper.content) {
+			if (child.type === "run") {
+				runs.push(child);
+				continue;
+			}
+			flush(renderedStart(child));
+			rendered += renderChild(child);
+		}
+		flush(void 0);
+		return rendered;
+	};
 	if (ctx.opts.trackedChanges === "clean") {
-		if (wrapper.type === "insertion" || wrapper.type === "moveTo") return wrapper.content.map(renderChild).join("");
+		if (wrapper.type === "insertion" || wrapper.type === "moveTo") return renderChildren();
 		return "";
 	}
-	const inner = wrapper.content.map(renderChild).join("");
+	const inner = renderChildren();
 	switch (wrapper.type) {
 		case "insertion": return wrapInsertion(ctx, wrapper.info, inner);
 		case "deletion": return wrapDeletion(ctx, wrapper.info, inner);
@@ -182,55 +422,76 @@ function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 * Render the full inline content of a paragraph, tracking comment-range
 * boundaries to apply the configured wrapper.
 */
-function renderParagraphInline(ctx, pkg, content, paraId) {
+function renderParagraphInline(ctx, pkg, content, paraId, edges = {
+	before: "",
+	after: ""
+}) {
 	let out = "";
 	const openComments = [];
-	for (const item of content) switch (item.type) {
-		case "run":
-			out += renderRun(ctx, pkg, item, paraId);
-			break;
-		case "hyperlink":
-			out += renderHyperlink(ctx, pkg, item, paraId);
-			break;
-		case "insertion":
-		case "deletion":
-		case "moveFrom":
-		case "moveTo":
-			out += renderTrackedWrapper(ctx, pkg, item, paraId);
-			break;
-		case "commentRangeStart":
-			out += handleCommentStart(ctx, pkg, item, openComments, out.length);
-			break;
-		case "commentRangeEnd":
-			out = handleCommentEnd(ctx, item, openComments, out);
-			break;
-		case "commentReference":
-			out += renderPointComment(ctx, pkg, item.id);
-			break;
-		case "simpleField":
-		case "complexField": {
-			const runs = item.type === "simpleField" ? item.content : item.fieldResult;
-			for (const child of runs) {
-				if (child.type === "run") {
-					out += renderRun(ctx, pkg, child, paraId);
-					continue;
+	const items = content.filter((item) => !SILENT_MARKERS.has(item.type) && !(ctx.opts.comments === "strip" && COMMENT_MARKERS.has(item.type)));
+	const around = (index) => {
+		const next = items[index + 1];
+		return {
+			before: out.length > 0 ? out.at(-1) : edges.before,
+			after: next === void 0 ? edges.after : renderedStart(next)
+		};
+	};
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index];
+		if (item === void 0) break;
+		switch (item.type) {
+			case "run": {
+				const runs = [item];
+				while (items[index + 1]?.type === "run") {
+					runs.push(items[index + 1]);
+					index++;
 				}
-				if (child.type === "hyperlink") {
-					out += renderHyperlink(ctx, pkg, child, paraId);
-					continue;
+				out += renderRuns(ctx, pkg, runs, paraId, around(index));
+				break;
+			}
+			case "hyperlink":
+				out += renderHyperlink(ctx, pkg, item, paraId);
+				break;
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo":
+				out += renderTrackedWrapper(ctx, pkg, item, paraId);
+				break;
+			case "commentRangeStart":
+				out += handleCommentStart(ctx, pkg, item, openComments, out.length);
+				break;
+			case "commentRangeEnd":
+				out = handleCommentEnd(ctx, item, openComments, out);
+				break;
+			case "commentReference":
+				out += renderPointComment(ctx, pkg, item.id);
+				break;
+			case "simpleField":
+			case "complexField": {
+				const runs = item.type === "simpleField" ? item.content : item.fieldResult;
+				for (const child of runs) {
+					if (child.type === "run") {
+						out += renderRuns(ctx, pkg, [child], paraId);
+						continue;
+					}
+					if (child.type === "hyperlink") {
+						out += renderHyperlink(ctx, pkg, child, paraId);
+						continue;
+					}
+					out += child.type === "inlineWrapper" ? renderParagraphInline(ctx, pkg, child.content, paraId, UNKNOWN_NEIGHBORS) : child.text;
 				}
-				out += child.type === "inlineWrapper" ? renderParagraphInline(ctx, pkg, child.content, paraId) : child.text;
+				break;
 			}
-			break;
+			case "inlineSdt":
+			case "inlineWrapper":
+				out += renderParagraphInline(ctx, pkg, item.content, paraId, around(index));
+				break;
+			case "mathEquation":
+				if (item.plainText) out += escapeInline(item.plainText);
+				break;
+			default: break;
 		}
-		case "inlineSdt":
-		case "inlineWrapper":
-			out += renderParagraphInline(ctx, pkg, item.content, paraId);
-			break;
-		case "mathEquation":
-			if (item.plainText) out += escapeInline(item.plainText);
-			break;
-		default: break;
 	}
 	while (openComments.length) {
 		const slot = openComments.pop();

package/dist/prosemirror/clearRunColor.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "prosemirror-state";
+//#region src/prosemirror/clearRunColor.d.ts
+/** Clearing direct color reveals the run's character/paragraph style color. */
+declare const clearRunColor: () => Command;
+//#endregion
+export { clearRunColor };

package/dist/prosemirror/clearRunColor.js

@@ -0,0 +1,46 @@
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { applyMarksToRunFormattingRepresentation, selectRunFormattingCarrierRepresentations } from "./runFormattingInlineCarriers.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContextAt } from "./runStyleFormatting.js";
+//#region src/prosemirror/clearRunColor.ts
+/** Clearing direct color reveals the run's character/paragraph style color. */
+const clearRunColor = () => (state, dispatch) => {
+	if (!dispatch) return true;
+	const styleResolver = getDocumentStyleResolver(state);
+	const tr = state.tr;
+	const { from, to, empty } = state.selection;
+	const clearedMarks = (node, position) => {
+		const context = paragraphRunStyleContextAt({
+			doc: state.doc,
+			pos: position,
+			styleResolver
+		});
+		const { color: _color, ...authoredFormatting } = readAuthoredRunFormatting({
+			context,
+			marks: node.marks,
+			styleResolver
+		});
+		return reconcileRunFormattingMarks({
+			authoredFormatting,
+			context,
+			node,
+			styleResolver
+		});
+	};
+	if (empty) {
+		const node = state.schema.text(" ", state.storedMarks ?? state.selection.$from.marks());
+		tr.setStoredMarks(clearedMarks(node, from));
+	} else for (const representation of selectRunFormattingCarrierRepresentations({
+		doc: state.doc,
+		from,
+		to
+	})) applyMarksToRunFormattingRepresentation({
+		tr,
+		representation,
+		marks: clearedMarks(representation.node, representation.position)
+	});
+	dispatch(tr.scrollIntoView());
+	return true;
+};
+//#endregion
+export { clearRunColor };