@stll/folio-core 0.46.0 → 0.47.1

package/dist/prosemirror/commands/sectionBreak.js

@@ -1,14 +1,192 @@
+import { mintSectionProperties, sectionPropertiesOf } from "../sectionCarrier.js";
 import { TextSelection } from "prosemirror-state";
 //#region src/prosemirror/commands/sectionBreak.ts
+const sectionEndingMarks = (doc) => {
+	const marks = [];
+	doc.descendants((node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		const properties = sectionPropertiesOf(node);
+		if (properties) marks.push({
+			markPosition: position + node.nodeSize - 1,
+			properties
+		});
+		return false;
+	});
+	return marks;
+};
+const withSectionProperties = (attrs, properties) => {
+	const next = { ...attrs };
+	if (properties === null) {
+		delete next["_sectionProperties"];
+		return next;
+	}
+	next["_sectionProperties"] = properties;
+	return next;
+};
+/**
+* Restate, over the whole document, which paragraph marks end a section.
+*
+* The rule is total in both directions, because a join is: it consumes one
+* paragraph mark and keeps the other, so exactly the marks that survived the
+* transaction still end the sections they ended before. ProseMirror keeps the
+* *first* node's attrs when it joins, which gets both halves of the rule wrong
+* on its own — the mark that survived a backward join loses a break it still
+* owns, and the node that absorbed a section-ending predecessor keeps a break
+* whose mark is gone.
+*
+* Word deletes the section break in the second case: with the caret at the
+* start of the paragraph *after* a break, Backspace removes the break, and the
+* paragraphs it governed join the following section, whose `w:sectPr` then
+* governs them (ECMA-376 Part 1 §17.6.18: a paragraph's `w:sectPr` states the
+* properties of the section ending at that paragraph, so content with no
+* `w:sectPr` before it belongs to the next one).
+*/
+const reconcileSectionEndingMarks = (transaction, marks) => {
+	const survivors = /* @__PURE__ */ new Map();
+	for (const { markPosition, properties } of marks) {
+		const mapped = transaction.mapping.mapResult(markPosition, 1);
+		if (!mapped.deleted) survivors.set(mapped.pos, properties);
+	}
+	const corrections = [];
+	transaction.doc.descendants((node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		const survived = survivors.get(position + node.nodeSize - 1) ?? null;
+		if (survived !== sectionPropertiesOf(node)) corrections.push({
+			position,
+			properties: survived
+		});
+		return false;
+	});
+	for (const { position, properties } of corrections) {
+		const paragraph = transaction.doc.nodeAt(position);
+		if (paragraph) transaction.setNodeMarkup(position, void 0, withSectionProperties(paragraph.attrs, properties));
+	}
+};
+/**
+* Run a command, keeping every section break on the paragraph whose mark
+* survived it.
+*
+* A section break is a property of a paragraph *mark*. The transfer is keyed on
+* the mark's position surviving the transaction, not on which command ran, so
+* deleting a section-ending paragraph outright still removes its section: that
+* mark is gone, and nothing inherits it.
+*/
+const keepSectionBreaksOnSurvivingMarks = (command) => (state, dispatch, view) => {
+	if (!dispatch) return command(state, void 0, view);
+	const marks = sectionEndingMarks(state.doc);
+	if (marks.length === 0) return command(state, dispatch, view);
+	let captured = null;
+	const capture = (transaction) => {
+		captured = transaction;
+	};
+	if (!command(state, capture, view)) return false;
+	const transaction = captured;
+	if (transaction === null) return true;
+	reconcileSectionEndingMarks(transaction, marks);
+	dispatch(transaction);
+	return true;
+};
+const selectedParagraphs = (state) => {
+	const paragraphs = [];
+	const { $from, $to } = state.selection;
+	state.doc.nodesBetween($from.pos, $to.pos, (node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		paragraphs.push({
+			position,
+			node
+		});
+		return false;
+	});
+	return paragraphs;
+};
+/**
+* Rewrite the section record of every paragraph the selection touches.
+*
+* A record is rewritten once and the replacement applied to every paragraph
+* holding it, wherever in the document it sits. A split leaves two halves over
+* one object until the save leg decides which of them ends the section;
+* rewriting them apart would turn that one section into two, and leaving a
+* sharer outside the selection behind would do the same.
+*
+* A paragraph that holds no record is asked on its own, so two break-less
+* paragraphs in one selection author two sections rather than share one.
+*/
+const rewriteSelectedSectionRecords = (rewrite) => (state, dispatch) => {
+	const selected = selectedParagraphs(state);
+	if (selected.length === 0) return false;
+	const replacements = /* @__PURE__ */ new Map();
+	for (const { node } of selected) {
+		const current = sectionPropertiesOf(node);
+		if (current !== null && !replacements.has(current)) replacements.set(current, rewrite(current));
+	}
+	const selectedPositions = new Set(selected.map(({ position }) => position));
+	const corrections = [];
+	state.doc.descendants((node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		const current = sectionPropertiesOf(node);
+		if (current === null) {
+			if (selectedPositions.has(position)) {
+				const minted = rewrite(null);
+				if (minted !== null) corrections.push({
+					position,
+					properties: minted
+				});
+			}
+			return false;
+		}
+		if (replacements.has(current)) {
+			const replacement = replacements.get(current) ?? null;
+			if (replacement !== current) corrections.push({
+				position,
+				properties: replacement
+			});
+		}
+		return false;
+	});
+	if (corrections.length === 0) return false;
+	if (dispatch) {
+		const transaction = state.tr;
+		for (const { position, properties } of corrections) {
+			const paragraph = transaction.doc.nodeAt(position);
+			if (paragraph) transaction.setNodeMarkup(position, void 0, withSectionProperties(paragraph.attrs, properties));
+		}
+		dispatch(transaction.scrollIntoView());
+	}
+	return true;
+};
+/**
+* End the selection's sections with `breakType`.
+*
+* A paragraph that already ends a section keeps its page size, margins,
+* columns and header references and changes only `w:type` (§17.6.22), which is
+* the one field the type names; a paragraph that ends none mints a record
+* stating that type alone, and inherits the rest from the section that follows
+* it.
+*/
+const setSectionBreakType = (breakType) => rewriteSelectedSectionRecords((current) => current === null ? mintSectionProperties(breakType) : {
+	...current,
+	sectionStart: breakType
+});
+/**
+* Remove the section break the selection's paragraphs carry.
+*
+* The record goes, and with it the section boundary: the paragraphs it
+* governed become part of the section that follows, whose `w:sectPr` governs
+* them from then on. That is Word's own rule for deleting a section break, and
+* it is what §17.6.18 says a paragraph with no `w:sectPr` means — nothing has
+* to be merged into the following record, because the following record already
+* states the whole of the section it heads.
+*/
+const removeSectionBreakAtSelection = rewriteSelectedSectionRecords(() => null);
 /**
 * Insert a section break at the current cursor position.
 *
 * In OOXML a section break is the `sectPr` carried by the *last* paragraph of a
-* section. So we split the current paragraph at the cursor, mark the first half
-* with `sectionBreakType` (it becomes the section end), and leave the cursor in
-* the second half (the first paragraph of the new section). Content after the
-* cursor therefore flows into the new section — onto a new page for `nextPage`,
-* or in place for `continuous`.
+* section (§17.6.18). So we split the current paragraph at the cursor, give the
+* first half the one record this insertion mints (it becomes the section end),
+* and leave the cursor in the second half (the first paragraph of the new
+* section). Content after the cursor therefore flows into the new section —
+* onto a new page for `nextPage`, or in place for `continuous`.
 */
 function insertSectionBreakAtCursor(breakType) {
 	return (state, dispatch) => {
@@ -19,19 +197,17 @@ function insertSectionBreakAtCursor(breakType) {
 		if (!($from.parent.isTextblock ? state.doc.resolve($from.before()).depth === 0 : $from.depth === 0)) return false;
 		if (dispatch) {
 			const tr = state.tr;
+			const sectionProperties = mintSectionProperties(breakType);
 			let cursorPos;
 			if ($from.parent.isTextblock) {
 				const paraPos = $from.before();
 				tr.split($from.pos);
 				const firstPara = tr.doc.nodeAt(paraPos);
-				if (firstPara) tr.setNodeMarkup(paraPos, void 0, {
-					...firstPara.attrs,
-					sectionBreakType: breakType
-				});
+				if (firstPara) tr.setNodeMarkup(paraPos, void 0, withSectionProperties(firstPara.attrs, sectionProperties));
 				cursorPos = tr.mapping.map($from.pos);
 			} else {
 				const pos = $from.pos;
-				tr.insert(pos, paragraphType.create({ sectionBreakType: breakType }));
+				tr.insert(pos, paragraphType.create({ _sectionProperties: sectionProperties }));
 				cursorPos = pos + 1;
 			}
 			tr.setSelection(TextSelection.create(tr.doc, cursorPos));
@@ -51,4 +227,4 @@ const insertSectionBreakNextPage = insertSectionBreakAtCursor("nextPage");
 */
 const insertSectionBreakContinuous = insertSectionBreakAtCursor("continuous");
 //#endregion
-export { insertSectionBreakContinuous, insertSectionBreakNextPage };
+export { insertSectionBreakContinuous, insertSectionBreakNextPage, keepSectionBreaksOnSurvivingMarks, removeSectionBreakAtSelection, setSectionBreakType };

package/dist/prosemirror/conversion/fromProseDoc.d.ts

@@ -3,8 +3,24 @@ import { TableAttrs, TableCellAttrs, TableRowAttrs } from "../schema/nodes.js";
 import { RunStyleResolver } from "../runStyleFormatting.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/conversion/fromProseDoc.d.ts
+/**
+ * Whether a record the editor did not change may come back from the base
+ * document by reference.
+ *
+ * `"none"` rebuilds every record out of ProseMirror, which is what folio does
+ * today. `"matched"` is the merge against a matched base record; it is declared
+ * here because the measurement that tells the two apart has to exist before the
+ * merge does, and it panics until it is implemented. An accepted-but-inert
+ * value would let a caller believe it had asked for a merge and get a rebuild.
+ */
+type ProjectionReuse = "none" | "matched";
+/** How the conversion treats records the editor did not change. */
+type FromProseDocOptions = {
+  /** Defaults to `"none"`, the only value implemented. */
+  reuse?: ProjectionReuse;
+};
 /** Convert a ProseMirror document to the document model. */
-declare function fromProseDoc(pmDoc: Node, baseDocument?: document_d_exports.Document): document_d_exports.Document;
+declare function fromProseDoc(pmDoc: Node, baseDocument?: document_d_exports.Document, { reuse }?: FromProseDocOptions): document_d_exports.Document;
 /**
  * Convert ProseMirror marks to TextFormatting
  */
@@ -37,4 +53,4 @@ declare function updateDocumentContent(originalDocument: document_d_exports.Docu
  */
 declare function proseDocToBlocks(pmDoc: Node, baseContent?: document_d_exports.BlockContent[], styles?: NonNullable<document_d_exports.Document["package"]>["styles"]): document_d_exports.BlockContent[];
 //#endregion
-export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };
+export { FromProseDocOptions, ProjectionReuse, fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };