@stll/folio-core 0.47.7 → 0.49.0

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -5,6 +5,7 @@ import { isInlineSdtContent, isSimpleFieldContent } from "../../docx/inlineWrapp
 import { paragraphNumberingReferenceId as paragraphNumberingReferenceId$1, sameStatedParagraphNumbering as sameStatedParagraphNumbering$1 } from "../../docx/numberingReference.js";
 import { PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, ParagraphPropertySourceValidationError, copyDocumentParagraphPropertySourceContract, copyDocumentParagraphPropertySources, copyParagraphPropertyCapture, copyParagraphPropertySource, decodeTableCellParagraphSourcePayload, getDocumentParagraphPropertySourceContract, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceToken, getParagraphPropertySourceTransferId, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, isParagraphPropertySourceToken, linkParagraphPropertySourceCandidate, paragraphPropertySourceBelongsToDocument, paragraphPropertySourceTokenMatchesContract, recreateProseNodeWithParagraphPropertySource, restoreTableCellsWithParagraphPropertySources, visitDocumentStoryParagraphs, visitTableCellParagraphPropertySourceBindings } from "../../docx/paragraphPropertySource.js";
 import { BLOCK_TREE_DESCENT, visitBlockTreeRecords, visitDocxParagraphs } from "../../docx/paragraphTraversal.js";
+import { refingerprintShapeAlternateContent } from "../../docx/shapeAlternateContent.js";
 import { DATE_UTC_ATTRIBUTE } from "../../docx/trackedChangeInfo.js";
 import { copiedWrapPolygon } from "../../docx/wrapPolygon.js";
 import { isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission } from "../../internal/paragraphFormattingSerialization.js";
@@ -15,12 +16,14 @@ import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
 import { emuToPixels, emuToStrokePixels, pixelsToEmu } from "../../utils/units.js";
+import { unchangedAlternateContentXml } from "../alternateContentAttrs.js";
 import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../attrs/index.js";
 import { readAuthoredTransform } from "../authoredTransformAttrs.js";
 import { autospacingMatchesBase, hasAutospacingBaseSide } from "../autospacingBase.js";
 import { bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs } from "../bookmarkBoundaryAttrs.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges } from "../commands/propertyChangeScope.js";
 import { expectCommentReferenceAttrs } from "../commentReferenceAttrs.js";
+import { enclosingRevisionIds } from "../contentControlRevisions.js";
 import { INLINE_WRAPPER_MARK_NAME } from "../extensions/marks/InlineWrapperExtension.js";
 import { applyRunFormattingOverrideAttrs, buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
 import { textFormattingToMarks } from "../extensions/marks/markUtils.js";
@@ -31,7 +34,7 @@ import { listRenderingFromAttrs as listRenderingFromAttrs$1 } from "../listRende
 import { expectMoveRangeBoundaryAttrs } from "../moveRangeBoundaryAttrs.js";
 import { resolveNumberedRefFields } from "../numberedRefFields.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
-import { directionToBidi } from "../paragraphDirection.js";
+import { directionToAuthoredBidi } from "../paragraphDirection.js";
 import { directParagraphSpacing } from "../paragraphSpacing.js";
 import { expectRangeAnchorAttrs } from "../rangeAnchorAttrs.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
@@ -42,6 +45,7 @@ import { schema } from "../schema/index.js";
 import { PRESERVED_XML_LEVELS } from "../schema/nodes.js";
 import { parseShapeGeometryAdjustments } from "../shapeGeometryAdjustments.js";
 import { expectTextBoxAnchorAttrs } from "../textBoxAnchorAttrs.js";
+import { textBoxHostParagraph } from "../textBoxHostParagraph.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { hasSinkChildren } from "./preservedSinkCarriers.js";
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "./runShadingMark.js";
@@ -678,7 +682,7 @@ function isStillSyntheticFiller(blocks) {
 }
 function appendTextBoxBlock(blocks, node, options) {
 	const attrs = expectTextBoxAttrs(node);
-	const paragraph = convertPMTextBox(node, options.styleResolver);
+	let paragraph = convertPMTextBox(node, options.styleResolver);
 	const previousBlock = blocks.at(-1);
 	if (attrs._docxPlacement === "inlineWithPrevious" && previousBlock?.type === "paragraph") {
 		appendPageBreaks(previousBlock, options.pendingPageBreaks);
@@ -696,6 +700,12 @@ function appendTextBoxBlock(blocks, node, options) {
 		if (!mergeTextBoxIntoTrailingInlineSdts(options.previousStandaloneTextBox.paragraph, paragraph, attrs._docxInlineSdts ?? [])) options.previousStandaloneTextBox.paragraph.content.push(...paragraph.content);
 		return options.previousStandaloneTextBox;
 	}
+	const host = attrs._docxPlacement === "standalone" ? textBoxHostParagraph(node) : void 0;
+	if (host) {
+		const hostParagraph = convertPMParagraph(host, void 0, void 0, options.styleResolver);
+		hostParagraph.content = paragraph.content;
+		paragraph = hostParagraph;
+	}
 	if (attrs._docxPlacement === "standalone" && attrs._preservedAttributes?.length) paragraph.preservedAttributes = attrs._preservedAttributes;
 	prependPageBreaks(paragraph, options.pendingPageBreaks);
 	blocks.push(paragraph);
@@ -1043,7 +1053,7 @@ function paragraphAttrsToFormatting(attrs) {
 		assignBooleanToggle(result, attrs, orig, "suppressAutoHyphens");
 		if (attrs.spacingExplicit !== orig.spacingExplicit) if (attrs.spacingExplicit) result.spacingExplicit = attrs.spacingExplicit;
 		else delete result.spacingExplicit;
-		const bidi = authoredParagraphValue("bidi", directionToBidi(attrs.direction), orig, attrs._resolvedFormatting);
+		const bidi = authoredParagraphValue("bidi", directionToAuthoredBidi(attrs.direction), orig, attrs._resolvedFormatting);
 		if (bidi !== (orig.bidi ?? void 0)) if (bidi === void 0) delete result.bidi;
 		else result.bidi = bidi;
 		return result;
@@ -1051,7 +1061,7 @@ function paragraphAttrsToFormatting(attrs) {
 	const resolved = attrs._resolvedFormatting;
 	const authored = (field, value) => authoredParagraphValue(field, value ?? void 0, void 0, resolved);
 	const outlineLevel = authored("outlineLevel", Reflect.get(attrs, "outlineLevel"));
-	const bidi = authored("bidi", directionToBidi(attrs.direction));
+	const bidi = authored("bidi", directionToAuthoredBidi(attrs.direction));
 	const snapToGrid = authored("snapToGrid", attrs.snapToGrid);
 	const indentLeft = authored("indentLeft", attrs.indentLeft);
 	const indentRight = authored("indentRight", attrs.indentRight);
@@ -1343,6 +1353,7 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 		}
 	};
 	const appendDirectRun = (node, run, coalescePlainText = false) => {
+		if (currentHyperlink) flushCurrentInline();
 		const marksKey = getMarksKey(node.marks);
 		const ownerId = runIdentityId(node);
 		const currentOwnerId = currentRun ? sourceRunOwners.get(currentRun) : void 0;
@@ -2255,6 +2266,7 @@ function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormattin
 		};
 		if (attrs.fldLock !== void 0) complex.fldLock = attrs.fldLock;
 		if (attrs.dirty !== void 0) complex.dirty = attrs.dirty;
+		if (attrs.fieldResultIsFallback !== void 0) complex.fieldResultIsFallback = attrs.fieldResultIsFallback;
 		return complex;
 	}
 	const simple = {
@@ -2317,21 +2329,21 @@ function createMathFromNode(node) {
 	return math;
 }
 /**
-* A revision covering every child of a control, written around the control.
+* A revision that encloses a control, written around the control.
 *
 * `w:ins > w:sdt` and `w:sdt > w:ins` reach the editor as the same revision
-* mark on the same leaves, so the save leg has to pick one and writes the
-* canonical order: the revision outermost, as it already is around a hyperlink
-* and around a transparent wrapper. Outermost is also the only form in which
-* accepting or rejecting the change is an operation over the whole control —
-* the reader who inserted a bound field inserted the field, not its text.
+* mark on the same leaves; the control's enclosing-revision record says which
+* one it was (`contentControlRevisions.ts`). A revision it names that still
+* covers every child goes outermost, the only form in which accepting or
+* rejecting the change is an operation over the whole control: the reader who
+* inserted a bound field inserted the field, not its text.
 *
-* A revision that covers only part of the content has no such form and stays
-* where the editor holds it, per child.
+* Any other revision, including one over all of the content, revises the
+* content and stays where the editor holds it, per child.
 */
-const hoistUniformRevision = (sdt) => {
+const hoistUniformRevision = (sdt, enclosingIds) => {
 	const only = sdt.content.length === 1 ? sdt.content.at(0) : void 0;
-	if (only === void 0 || !isRevisionWrapper(only)) return sdt;
+	if (only === void 0 || !isRevisionWrapper(only) || !enclosingIds.includes(only.info.id)) return sdt;
 	const admitted = only.content.filter(isInlineSdtContent);
 	if (admitted.length !== only.content.length) return sdt;
 	return {
@@ -2352,7 +2364,7 @@ function createInlineSdtFromNode(node, textBoxAnchorMarkers, formattingContext)
 		type: "inlineSdt",
 		properties,
 		content
-	});
+	}, enclosingRevisionIds(node));
 }
 /**
 * Create a Run containing an image
@@ -2481,6 +2493,17 @@ const drawingFromImageAttrs = (image, attrs) => {
 		default: return mode;
 	}
 };
+const shapeContentFromNode = ({ node, shape, captured }) => {
+	const xml = unchangedAlternateContentXml(node, captured);
+	return xml === void 0 ? {
+		type: "shape",
+		shape
+	} : {
+		type: "shape",
+		shape,
+		alternateContent: refingerprintShapeAlternateContent(shape, xml)
+	};
+};
 /**
 * Create a Run from a ProseMirror shape node
 */
@@ -2550,10 +2573,11 @@ function createShapeRun(node) {
 		if (attrs.outlineColor) shapeOutline.color = attrs.outlineColorValue ?? { rgb: attrs.outlineColor.replace("#", "") };
 		shape.outline = shapeOutline;
 	}
-	const shapeContent = {
-		type: "shape",
-		shape
-	};
+	const shapeContent = shapeContentFromNode({
+		node,
+		shape,
+		captured: attrs._docxAlternateContent
+	});
 	const run = {
 		type: "run",
 		...carriedRunFormatting(attrs._docxRunFormatting),
@@ -3576,6 +3600,7 @@ function convertPMTextBox(node, styleResolver = null) {
 		type: "solid",
 		color: { rgb: attrs.fillColor.replace("#", "") }
 	};
+	else if (attrs.gradientFill?.gradient) shape.fill = structuredClone(attrs.gradientFill);
 	if (attrs.outlineStyle !== "none" && attrs.outlineWidth && attrs.outlineWidth > 0) {
 		const tbOutline = {
 			width: emuFromPixels(attrs.outlineWidth, "outlineWidth", authoredEmu, emuToStrokePixels),
@@ -3590,12 +3615,18 @@ function convertPMTextBox(node, styleResolver = null) {
 	if (position) shape.position = position;
 	const anchor = restoredDrawingAnchor(attrs.anchor);
 	if (anchor) shape.anchor = anchor;
+	if (attrs._docxGroupChild) shape.groupChild = {
+		path: [...attrs._docxGroupChild.path],
+		group: attrs._docxGroupChild.group,
+		content: attrs._docxGroupChild.content
+	};
 	const run = {
 		type: "run",
-		content: [{
-			type: "shape",
-			shape
-		}]
+		content: [shapeContentFromNode({
+			node,
+			shape,
+			captured: attrs._docxAlternateContent
+		})]
 	};
 	const trackedChange = attrs._docxTrackedChange;
 	const inlineSdts = attrs._docxInlineSdts ?? [];

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

@@ -0,0 +1,21 @@
+import { MarkFactory } from "../extensions/marks/markUtils.js";
+import { Schema } from "prosemirror-model";
+//#region src/prosemirror/conversion/markInterner.d.ts
+/**
+ * Build marks that share one instance per distinct (type, attrs) value.
+ *
+ * A document repeats a small set of run formattings across thousands of runs,
+ * so one conversion builds each distinct mark once. Marks are immutable, and
+ * ProseMirror compares them by value, so sharing an instance changes nothing a
+ * caller can observe except the saved allocation. Create one interner per
+ * conversion; it holds every mark it built until it is dropped.
+ *
+ * The native JSON serialization is only a lookup key: it collapses values the
+ * mark would keep apart (`-0`, `NaN`, nested `undefined`), so a hit is shared
+ * only after an exact comparison, and a mismatch builds an unshared mark. A
+ * mark holding `NaN` is never shared: ProseMirror does not find two of them
+ * equal, and a shared instance would.
+ */
+declare const createMarkInterner: (schema: Schema) => MarkFactory;
+//#endregion
+export { createMarkInterner };

package/dist/prosemirror/conversion/markInterner.js

@@ -0,0 +1,90 @@
+import { panic } from "better-result";
+//#region src/prosemirror/conversion/markInterner.ts
+/**
+* Leaves ProseMirror compares with `===`, minus `-0`/`0`: sharing a mark makes
+* `Mark.eq` take its identity shortcut, so two leaves may share only when
+* ProseMirror would call them equal anyway. `NaN` never equals itself there.
+*/
+const sameLeaf = (left, right) => left === right && Object.is(left, right);
+/**
+* Whether two attr values are interchangeable: `sameLeaf` on leaves, and the
+* same own keys in the same order, so `-0`/`0`, `NaN` and `undefined`/absent
+* stay apart. Output follows the shared value's key order, which is why order
+* counts.
+*/
+const sameAttrValue = (left, right) => {
+	if (sameLeaf(left, right)) return true;
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+	if (Object.getPrototypeOf(left) !== Object.getPrototypeOf(right)) return false;
+	if (Array.isArray(left)) {
+		if (!Array.isArray(right) || left.length !== right.length) return false;
+		for (let index = 0; index < left.length; index += 1) if (index in left !== index in right || !sameAttrValue(left[index], right[index])) return false;
+		return true;
+	}
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && sameAttrValue(Reflect.get(left, key), Reflect.get(right, key)));
+};
+const internedMark = (type, attrs) => {
+	const mark = type.create(attrs);
+	const nonDefault = /* @__PURE__ */ new Set();
+	for (const [name, spec] of Object.entries(type.spec.attrs ?? {})) if (!sameLeaf(mark.attrs[name], spec.default)) nonDefault.add(name);
+	return {
+		mark,
+		nonDefault
+	};
+};
+/**
+* Whether `create(attrs)` would compute attrs interchangeable with the
+* interned mark's. `create` fills every declared attr `attrs` leaves
+* `undefined` from its default, so the given attrs must match each value they
+* set and set every attr where the mark holds something else.
+*/
+const matchesInterned = (type, attrs, { mark, nonDefault }) => {
+	const specs = type.spec.attrs ?? {};
+	let covered = 0;
+	for (const name in attrs) {
+		const given = attrs[name];
+		if (given === void 0 || !Object.hasOwn(specs, name)) continue;
+		if (!sameAttrValue(given, mark.attrs[name])) return false;
+		if (nonDefault.has(name)) covered += 1;
+	}
+	return covered === nonDefault.size;
+};
+/**
+* Build marks that share one instance per distinct (type, attrs) value.
+*
+* A document repeats a small set of run formattings across thousands of runs,
+* so one conversion builds each distinct mark once. Marks are immutable, and
+* ProseMirror compares them by value, so sharing an instance changes nothing a
+* caller can observe except the saved allocation. Create one interner per
+* conversion; it holds every mark it built until it is dropped.
+*
+* The native JSON serialization is only a lookup key: it collapses values the
+* mark would keep apart (`-0`, `NaN`, nested `undefined`), so a hit is shared
+* only after an exact comparison, and a mismatch builds an unshared mark. A
+* mark holding `NaN` is never shared: ProseMirror does not find two of them
+* equal, and a shared instance would.
+*/
+const createMarkInterner = (schema) => {
+	const marksByType = /* @__PURE__ */ new Map();
+	return (typeName, attrs) => {
+		const type = schema.marks[typeName];
+		if (type === void 0) panic(`Unknown mark type ${typeName}.`);
+		let marks = marksByType.get(type);
+		if (marks === void 0) {
+			marks = /* @__PURE__ */ new Map();
+			marksByType.set(type, marks);
+		}
+		const key = JSON.stringify(attrs ?? null);
+		const cached = marks.get(key);
+		if (cached === void 0) {
+			const interned = internedMark(type, attrs);
+			marks.set(key, interned);
+			return interned.mark;
+		}
+		return matchesInterned(type, attrs, cached) ? cached.mark : type.create(attrs);
+	};
+};
+//#endregion
+export { createMarkInterner };