@stll/folio-core 0.66.1 → 0.66.2

package/dist/prosemirror/tableRunIn.js

@@ -1,11 +1,12 @@
 import { getProseParagraphPropertySourceToken, recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
 import { expectParagraphAttrs } from "./attrs/index.js";
-import { paragraphRemainsOf } from "./keptRangeBoundaries.js";
+import { REVISION_MARK_NAMES, paragraphRemainsOf, revisionLayerRemovesContent } from "./keptRangeBoundaries.js";
 import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
 import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+import { trackedRevisionPathOf } from "./trackedRevisionPath.js";
 import { paragraphContentOf } from "./zeroWidthAnchors.js";
 import { Fragment, Slice } from "prosemirror-model";
-import { ReplaceAroundStep, StepMap } from "prosemirror-transform";
+import { ReplaceAroundStep, ReplaceStep, StepMap } from "prosemirror-transform";
 import { paragraphMarkOutcome } from "@stll/docx-core/ops";
 // src/prosemirror/tableRunIn.ts
 /**
@@ -19,35 +20,53 @@ import { paragraphMarkOutcome } from "@stll/docx-core/ops";
 *
 * A paragraph with nothing left to carry is simply removed by the resolvers;
 * one that ends a section keeps its place, as does one before a table whose
-* rows or cells are themselves pending.
+* first row or cell may not stay. Rejecting every change gives the document
+* before back, so a deleted row stays for it. A table that resolving every
+* change removes never stood in the way: the paragraph runs on into what follows
+* that table.
 */
 /**
 * Whether the cell a paragraph's words would run into is itself pending: its
 * row or the cell (through nested tables' first cells) is inserted, deleted
-* or merged, so resolving may not keep it. Pending rows or cells elsewhere in
-* the table leave that cell where it is.
+* or merged, so resolving may not keep it. A deletion is not pending for a
+* rejection of every change. Pending rows or cells elsewhere in the table leave
+* that cell where it is.
 */
-const runInCellPending = (table) => {
+const runInCellPending = (table, everyChange) => {
+	const deletionStays = everyChange === "reject";
 	let node = table;
 	while (node?.type.spec["tableRole"] === "table") {
 		const row = node.firstChild;
 		if (!row) return false;
-		if (row.attrs["trIns"] != null || row.attrs["trDel"] != null) return true;
+		if (row.attrs["trIns"] != null) return true;
+		if (row.attrs["trDel"] != null && !deletionStays) return true;
 		const cell = row.firstChild;
 		if (!cell) return false;
-		if (cell.attrs["cellMarker"] != null) return true;
+		const marker = cell.attrs["cellMarker"];
+		if (marker != null && !(deletionStays && marker.kind === "del")) return true;
 		node = cell.firstChild;
 	}
 	return false;
 };
+/**
+* Whether resolving every change takes this row out with what it records. The
+* table it stands in goes when all its rows do.
+*/
+const rowGoes = (row, mode) => row.attrs[mode === "accept" ? "trDel" : "trIns"] != null;
+/** Whether resolving every change in `mode` removes the whole table. */
+const tableGoes = (table, mode) => {
+	if (table.type.spec["tableRole"] !== "table" || table.childCount === 0) return false;
+	for (let index = 0; index < table.childCount; index++) if (!rowGoes(table.child(index), mode)) return false;
+	return true;
+};
 /** The first paragraph of a table's first cell, descending into nested tables. */
-const runInTarget = (doc, tablePos) => {
+const runInTarget = (doc, tablePos, everyChange) => {
 	let node = doc.nodeAt(tablePos);
 	let pos = tablePos;
 	const table = node;
 	const firstRow = table?.firstChild;
 	if (!table || table.type.spec["tableRole"] !== "table" || !firstRow) return null;
-	if (runInCellPending(table)) return null;
+	if (runInCellPending(table, everyChange)) return null;
 	while (node && node.type.name !== "paragraph") {
 		const child = node.firstChild;
 		if (!child || child.isInline) return null;
@@ -59,22 +78,22 @@ const runInTarget = (doc, tablePos) => {
 		node
 	} : null;
 };
-const paragraphAfterContentRemoval = (paragraph, removedMark) => removedMark ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !removedMark.isInSet(child.marks)))) : paragraph;
+const paragraphAfterContentRemoval = (paragraph, everyChange) => everyChange ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !child.marks.some((mark) => REVISION_MARK_NAMES.has(mark.type.name) && trackedRevisionPathOf(mark).some((layer) => revisionLayerRemovesContent(layer, everyChange)))))) : paragraph;
 /**
 * Run the paragraph at `paragraphPos` on into the table right after it.
 * Returns where the paragraph that took its words now starts and the
 * paragraph-property source it hands over, or null when it did not run in and
 * the caller keeps its own handling.
 */
-const runParagraphIntoTable = ({ tr, paragraphPos, styleResolver, removedMark }) => {
+const runParagraphIntoTable = ({ tr, paragraphPos, styleResolver, everyChange }) => {
 	const paragraph = tr.doc.nodeAt(paragraphPos);
 	if (paragraph?.type.name !== "paragraph") return null;
 	if (expectParagraphAttrs(paragraph)._sectionProperties !== void 0) return null;
-	const left = paragraphAfterContentRemoval(paragraph, removedMark);
+	const left = paragraphAfterContentRemoval(paragraph, everyChange);
 	const remains = paragraphRemainsOf(left);
 	if (!paragraphContentOf(left) && (remains.blocks.length > 0 || remains.comments.length === 0)) return null;
 	const tablePos = paragraphPos + paragraph.nodeSize;
-	const target = runInTarget(tr.doc, tablePos);
+	const target = runInTarget(tr.doc, tablePos, everyChange);
 	if (!target) return null;
 	const $target = tr.doc.resolve(target.pos + 1);
 	const containerDepth = tr.doc.resolve(paragraphPos).depth;
@@ -118,6 +137,36 @@ const markGoes = (paragraph, mode) => {
 	if (!mark) return false;
 	return (mark.kind === "ins" || mark.kind === "moveTo") !== (mode === "accept");
 };
+/** Whether resolving every change in `mode` leaves nothing of this paragraph. */
+const paragraphGoes = (paragraph, mode) => {
+	if (paragraph.type.name !== "paragraph" || !markGoes(paragraph, mode) || expectParagraphAttrs(paragraph)._sectionProperties != null) return false;
+	const left = paragraphAfterContentRemoval(paragraph, mode);
+	if (paragraphContentOf(left)) return false;
+	const remains = paragraphRemainsOf(left);
+	return remains.blocks.length === 0 && remains.comments.length === 0 && remains.inline.length === 0;
+};
+/**
+* Whether what stands right after a paragraph whose mark goes is itself removed
+* by this resolution, so the paragraph runs on into what stands after that, as
+* it would had the removed block never been there: a table it removes, or, when
+* rejecting, an inserted paragraph it empties with a table after it. (Accepted,
+* a deleted paragraph did stand there, and the join ended at it. Paragraphs join
+* among themselves without help.)
+*/
+const paragraphBeforeRemovedBlock = ({ parent, index, mode }) => {
+	const paragraph = parent.child(index);
+	const next = parent.maybeChild(index + 1);
+	if (paragraph.type.name !== "paragraph" || !next || !markGoes(paragraph, mode)) return false;
+	if (tableGoes(next, mode)) return true;
+	if (mode !== "reject" || paragraphGoes(paragraph, mode)) return false;
+	let following = index + 1;
+	while (following < parent.childCount) {
+		const block = parent.child(following);
+		if (!paragraphGoes(block, mode)) break;
+		following += 1;
+	}
+	return following > index + 1 && parent.maybeChild(following)?.type.spec["tableRole"] === "table";
+};
 const runsIntoFollowingTable = ({ parent, index, mode }) => {
 	const paragraph = parent.child(index);
 	const next = parent.maybeChild(index + 1);
@@ -125,7 +174,6 @@ const runsIntoFollowingTable = ({ parent, index, mode }) => {
 	const remains = paragraphRemainsOf(paragraph);
 	const holdsContent = paragraphContentOf(paragraph);
 	const needsCommentHost = !holdsContent && remains.blocks.length === 0 && remains.comments.length > 0;
-	const removedMark = paragraph.type.schema.marks[mode === "accept" ? "deletion" : "insertion"];
 	let hasPrecedingCommentHost = false;
 	for (let previousIndex = needsCommentHost ? index - 1 : -1; previousIndex >= 0; previousIndex -= 1) {
 		const previous = parent.child(previousIndex);
@@ -134,7 +182,7 @@ const runsIntoFollowingTable = ({ parent, index, mode }) => {
 			hasPrecedingCommentHost = true;
 			break;
 		}
-		const retained = paragraphAfterContentRemoval(previous, removedMark);
+		const retained = paragraphAfterContentRemoval(previous, mode);
 		if (paragraphContentOf(retained)) break;
 		if (paragraphRemainsOf(retained).blocks.length > 0) {
 			hasPrecedingCommentHost = true;
@@ -146,22 +194,60 @@ const runsIntoFollowingTable = ({ parent, index, mode }) => {
 		holdsContent,
 		markWasAdded: expectParagraphAttrs(paragraph).pPrMark?.kind === "ins" || expectParagraphAttrs(paragraph).pPrMark?.kind === "moveTo",
 		containerStillEndsWithParagraph: false,
-		followingTableCanReceiveRunIn: expectParagraphAttrs(paragraph)._sectionProperties === void 0 && !runInCellPending(next),
+		followingTableCanReceiveRunIn: expectParagraphAttrs(paragraph)._sectionProperties === void 0 && !runInCellPending(next, mode),
 		needsFollowingCommentHost: needsCommentHost && !hasPrecedingCommentHost
 	}).kind === "run-in";
 };
 /**
+* Stand each block this resolution removes before the paragraph whose mark goes
+* right before it, so that paragraph meets what it will run on into. The block
+* is going, so where it goes from does not show; the paragraph's words keep
+* mapping to themselves.
+*/
+const moveRemovedBlocksBeforeParagraphs = (tr, mode) => {
+	const maps = [];
+	for (;;) {
+		let move = null;
+		tr.doc.descendants((node, position, parent, index) => {
+			if (move !== null) return false;
+			if (node.type.name !== "paragraph") return !node.isTextblock;
+			const block = parent?.maybeChild(index + 1);
+			if (parent && block && paragraphBeforeRemovedBlock({
+				parent,
+				index,
+				mode
+			})) move = {
+				position,
+				paragraph: node,
+				block
+			};
+			return false;
+		});
+		if (move === null) return maps;
+		const { position, paragraph, block } = move;
+		const blockPosition = position + paragraph.nodeSize;
+		tr.step(new ReplaceStep(position, blockPosition + block.nodeSize, new Slice(Fragment.fromArray([block, paragraph]), 0, 0)));
+		maps.push(new StepMap([
+			position,
+			0,
+			block.nodeSize,
+			blockPosition,
+			block.nodeSize,
+			0
+		]));
+	}
+};
+/**
 * Before every change in a story is resolved: run each paragraph whose mark
 * goes and that sits right before a table on into that table. Returns each
 * paragraph that took words (its position after the step count given) and
 * the paragraph-property sources handed over.
 */
 const runParagraphsIntoTables = (tr, mode, styleResolver) => {
-	const removedMark = tr.doc.type.schema.marks[mode === "accept" ? "deletion" : "insertion"];
 	const tried = /* @__PURE__ */ new Set();
 	const targets = [];
 	const transfers = [];
-	const maps = [];
+	const maps = moveRemovedBlocksBeforeParagraphs(tr, mode);
 	for (;;) {
 		let candidate = null;
 		tr.doc.descendants((node, pos, parent, index) => {
@@ -183,7 +269,7 @@ const runParagraphsIntoTables = (tr, mode, styleResolver) => {
 			tr,
 			paragraphPos: candidate,
 			styleResolver,
-			removedMark
+			everyChange: mode
 		});
 		if (ranIn !== null) {
 			targets.push({
@@ -196,4 +282,4 @@ const runParagraphsIntoTables = (tr, mode, styleResolver) => {
 		}
 	}
 };
-export { runInCellPending, runParagraphIntoTable, runParagraphsIntoTables, runsIntoFollowingTable };
+export { paragraphBeforeRemovedBlock, runInCellPending, runParagraphIntoTable, runParagraphsIntoTables, runsIntoFollowingTable };

package/dist/prosemirror/textInput.js

@@ -30,8 +30,10 @@ const dispatchEditorTextInput = (view, input) => {
 			});
 			const tr = view.state.tr;
 			if (formattingMarks !== void 0) tr.setStoredMarks(formattingMarks);
+			const typesOverSelection = !selection.empty && selection.from === from && selection.to === to;
+			if (typesOverSelection && !selection.$from.parent.inlineContent) return tr.insertText(text);
 			tr.insertText(text, from, to);
-			return !selection.empty && selection.from === from && selection.to === to ? tr.setSelection(TextSelection.create(tr.doc, from + text.length)) : tr;
+			return typesOverSelection ? tr.setSelection(TextSelection.create(tr.doc, from + text.length)) : tr;
 		}
 		const start = Selection.atStart(view.state.doc);
 		const end = Selection.atEnd(view.state.doc);

package/dist/prosemirror/validation.js

@@ -3,7 +3,9 @@ import { readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAtt
 import { readBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
 import { readCommentRangeBoundaryAttrs } from "./commentRangeBoundaryAttrs.js";
 import { readCommentReferenceAttrs } from "./commentReferenceAttrs.js";
+import { HYPHEN_ELEMENT_MARK_NAME } from "./conversion/hyphenTextCarriers.js";
 import { fieldRequiresStructuredContent } from "./fieldRepresentation.js";
+import { readHyphenElementMarkAttrs } from "./hyphenElementAttrs.js";
 import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
 import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
 import { isRunContentInlineNodeName } from "./runContentProjection.js";
@@ -15,6 +17,7 @@ import { readTextBoxAnchorAttrs } from "./textBoxAnchorAttrs.js";
 const COMPLEX_FIELD_RESULT_MARK_NAMES = /* @__PURE__ */ new Set([
 	...RUN_FORMATTING_MARK_NAMES,
 	RUN_IDENTITY_MARK_NAME,
+	HYPHEN_ELEMENT_MARK_NAME,
 	"runPropertyChange",
 	"footnoteRef"
 ]);
@@ -352,6 +355,9 @@ const validateMark = (mark, markPath, issues) => {
 		case "textShadow":
 		case "textOutline":
 		case "rtl": return;
+		case "hyphenElement":
+			appendAttrIssues(markPath, readHyphenElementMarkAttrs(mark), issues);
+			return;
 		case "textEffect":
 			appendAttrIssues(markPath, readTextEffectMarkAttrs(mark), issues);
 			return;

package/dist/utils/createDocument.js

@@ -5,6 +5,7 @@ import { formatParseWarnings } from "../docx/parseWarningMessage.js";
 import { DEFAULT_TAB_STOP_TWIPS as DEFAULT_TAB_STOP_TWIPS$1 } from "../docx/settingsParser.js";
 import { STYLE_SET_PART, normalizeDocumentStyleSet } from "../style-sets/styleSetNormalization.js";
 import "../style-sets/types.js";
+import { generateHexId } from "./hexId.js";
 import { panic } from "better-result";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 // src/utils/createDocument.ts
@@ -368,17 +369,19 @@ function createEmptyDocument(options = {}) {
 	if (options.marginLeft !== void 0) sectionProps.marginLeft = Math.round(options.marginLeft);
 	if (options.marginRight !== void 0) sectionProps.marginRight = Math.round(options.marginRight);
 	const initialText = options.initialText ?? "";
+	const run = {
+		type: "run",
+		content: initialText ? [{
+			type: "text",
+			text: initialText
+		}] : [],
+		formatting: {}
+	};
 	const documentBody = {
 		content: [{
 			type: "paragraph",
-			content: [{
-				type: "run",
-				content: initialText ? [{
-					type: "text",
-					text: initialText
-				}] : [],
-				formatting: {}
-			}],
+			paraId: generateHexId(),
+			content: [run],
 			formatting: { styleId: styleSet?.initialParagraphStyleId ?? "Normal" }
 		}],
 		finalSectionProperties: sectionProps

package/dist/utils/formatToStyle.js

@@ -6,7 +6,7 @@ import { resolveColor, resolveHighlightToCss, resolveShadingColor } from "./colo
 import { resolveFontFamily, resolveThemeFont } from "./fontResolver.js";
 import { getHorizontalScaleFactor, normalizeHorizontalScalePercent } from "./horizontalScale.js";
 import { textFlowCss } from "./textDirectionFlow.js";
-import { AUTO_PARAGRAPH_SPACING_PX, eighthsToPixels, formatPx, halfPointsToPixels, halfPointsToPoints, twipsToPixels } from "./units.js";
+import { AUTO_PARAGRAPH_SPACING_PX, eighthsToPixels, formatPx, halfPointsToPixels, halfPointsToPoints, hangingFirstLineIndent, twipsToPixels } from "./units.js";
 import { statesNoBorder } from "@stll/docx-core/model";
 // src/utils/formatToStyle.ts
 /**
@@ -119,7 +119,7 @@ function paragraphToStyle(formatting, theme) {
 	if (formatting.indentLeft !== void 0) style.marginLeft = formatPx(twipsToPixels(formatting.indentLeft));
 	if (formatting.indentRight !== void 0) style.marginRight = formatPx(twipsToPixels(formatting.indentRight));
 	if (formatting.indentFirstLine !== void 0) {
-		const textIndent = formatting.hangingIndent ? -Math.abs(formatting.indentFirstLine) : formatting.indentFirstLine;
+		const textIndent = formatting.hangingIndent ? hangingFirstLineIndent(formatting.indentFirstLine) : formatting.indentFirstLine;
 		style.textIndent = formatPx(twipsToPixels(textIndent));
 	}
 	if (formatting.borders) {

package/dist/utils/units.d.ts

@@ -22,6 +22,11 @@ export declare const PIXELS_PER_INCH: 96;
  * twips conversion. See eigenpal/docx-editor#823.
  */
 export declare const AUTO_PARAGRAPH_SPACING_PX: number;
+/**
+ * The `indentFirstLine` a hanging indent of `magnitude` twips stores: negated,
+ * but never as `-0`, which compares unequal to the `0` a model holds elsewhere.
+ */
+export declare const hangingFirstLineIndent: (magnitude: number) => number;
 /**
  * Convert twips to pixels (at 96 DPI)
  *

package/dist/utils/units.js

@@ -34,6 +34,11 @@ const PIXELS_PER_INCH = STANDARD_DPI;
 */
 const AUTO_PARAGRAPH_SPACING_PX = pointsToPixels(14);
 /**
+* The `indentFirstLine` a hanging indent of `magnitude` twips stores: negated,
+* but never as `-0`, which compares unequal to the `0` a model holds elsewhere.
+*/
+const hangingFirstLineIndent = (magnitude) => magnitude === 0 ? 0 : -Math.abs(magnitude);
+/**
 * Convert twips to pixels (at 96 DPI)
 *
 * 1 inch = 1440 twips = 96 pixels
@@ -146,4 +151,4 @@ function clamp(value, min, max) {
 function formatPx(px) {
 	return `${roundPixels(px)}px`;
 }
-export { AUTO_PARAGRAPH_SPACING_PX, PIXELS_PER_INCH, TWIPS_PER_INCH, clamp, eighthsToPixels, emuToPixels, emuToStrokePixels, emuToTwips, formatPx, halfPointsToPixels, halfPointsToPoints, pixelsToEmu, pixelsToTwips, pointsToHalfPoints, pointsToPixels, roundPixels, twipsToEmu, twipsToPixels };
+export { AUTO_PARAGRAPH_SPACING_PX, PIXELS_PER_INCH, TWIPS_PER_INCH, clamp, eighthsToPixels, emuToPixels, emuToStrokePixels, emuToTwips, formatPx, halfPointsToPixels, halfPointsToPoints, hangingFirstLineIndent, pixelsToEmu, pixelsToTwips, pointsToHalfPoints, pointsToPixels, roundPixels, twipsToEmu, twipsToPixels };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.66.1",
+  "version": "0.66.2",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",
@@ -173,7 +173,7 @@
     "perf": "bun scripts/profile-editor.ts"
   },
   "dependencies": {
-    "@stll/docx-core": "^0.41.0",
+    "@stll/docx-core": "^0.42.0",
     "@stll/docx-utils": "^0.2.0",
     "@stll/template-conditions": "^0.6.2",
     "@stll/utf8-boundaries": "0.2.0",
@@ -198,7 +198,7 @@
     "prosemirror-state": "^1.4.4",
     "prosemirror-tables": "^1.8.5",
     "prosemirror-transform": "^1.12.4",
-    "prosemirror-view": "^1.42.7",
+    "prosemirror-view": "^1.42.8",
     "y-prosemirror": "^1.3.7",
     "y-protocols": "^1.0.6",
     "yjs": "^13.6.33"