@stll/folio-core 0.44.0 → 0.46.0

package/dist/prosemirror/authoredTransformAttrs.js

@@ -0,0 +1,64 @@
+//#region src/prosemirror/authoredTransformAttrs.ts
+/**
+* The CSS the three authored values render as.
+*
+* Only what the browser has to draw: a rotation of zero and an explicit
+* "not flipped" are the identity, and emitting them would put a no-op
+* transform on every drawing that states one.
+*/
+const cssTransform = (rotation, flipH, flipV) => {
+	const parts = [];
+	if (rotation !== null && rotation !== 0) parts.push(`rotate(${rotation}deg)`);
+	if (flipH === true) parts.push("scaleX(-1)");
+	if (flipV === true) parts.push("scaleY(-1)");
+	return parts.length > 0 ? parts.join(" ") : void 0;
+};
+/** Project a model transform onto a drawing node's attrs. */
+const authoredTransformAttrs = (transform) => {
+	const docxRotation = transform?.rotation ?? null;
+	const docxFlipH = transform?.flipH ?? null;
+	const docxFlipV = transform?.flipV ?? null;
+	return {
+		docxFlipH,
+		docxFlipV,
+		docxRotation,
+		transform: cssTransform(docxRotation, docxFlipH, docxFlipV)
+	};
+};
+/**
+* The transform a node persisted before these attrs existed carries.
+*
+* The CSS can state neither an authored zero rotation nor an authored "not
+* flipped", which is why the attrs exist; such a node never carried them
+* either, so reading it this way loses nothing.
+*/
+const transformFromCss = (css) => {
+	if (!css) return;
+	const transform = {};
+	const rotateMatch = /rotate\((?<deg>[-\d.]+)deg\)/u.exec(css);
+	if (rotateMatch) {
+		const rotation = Number.parseFloat(rotateMatch.groups["deg"]);
+		if (Number.isFinite(rotation)) transform.rotation = rotation;
+	}
+	if (css.includes("scaleX(-1)")) transform.flipH = true;
+	if (css.includes("scaleY(-1)")) transform.flipV = true;
+	if (transform.rotation === void 0 && !transform.flipH && !transform.flipV) return;
+	return transform;
+};
+/**
+* Read a drawing node's authored transform back.
+*
+* The attrs are the record; the CSS string answers only for a node that states
+* none of them, which is how a node persisted before they existed arrives.
+*/
+const readAuthoredTransform = (attrs) => {
+	const { docxFlipH, docxFlipV, docxRotation } = attrs;
+	if (docxRotation == null && docxFlipH == null && docxFlipV == null) return transformFromCss(attrs.transform);
+	return {
+		...docxRotation == null ? {} : { rotation: docxRotation },
+		...docxFlipH == null ? {} : { flipH: docxFlipH },
+		...docxFlipV == null ? {} : { flipV: docxFlipV }
+	};
+};
+//#endregion
+export { authoredTransformAttrs, readAuthoredTransform };

package/dist/prosemirror/commands/contentControls.js

@@ -1,3 +1,4 @@
+import { checkboxDisplayContent } from "../../content-controls/checkboxDisplay.js";
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
 import { formatDate } from "../../docx/fieldParser.js";
 import { expectBlockSdtAttrs } from "../attrs/index.js";
@@ -220,8 +221,15 @@ function setContentControlValueTr(state, filter, input, options = {}) {
 			sdtType,
 			reason: "kind=checkbox requires sdtType=checkbox"
 		});
-		const glyph = input.checked ? "☒" : "☐";
-		return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, glyph)], {
+		const display = checkboxDisplayContent(typeof match.node.attrs["rawPropertiesXml"] === "string" ? match.node.attrs["rawPropertiesXml"] : void 0, input.checked);
+		let content = display.type === "symbol" ? state.schema.node("symbol", {
+			font: display.font,
+			char: display.char
+		}) : state.schema.text(display.text);
+		const sourceParagraph = match.node.firstChild;
+		const sourceInline = sourceParagraph?.firstChild;
+		if (sourceInline && sourceInline.marks.length > 0) content = content.mark(sourceInline.marks);
+		return replaceBlockSdtChildren(state, match, [state.schema.node("paragraph", sourceParagraph?.type.name === "paragraph" ? sourceParagraph.attrs : {}, [content])], {
 			checked: input.checked,
 			...bindingOverride
 		});

package/dist/prosemirror/commands/image.d.ts

@@ -1,3 +1,4 @@
+import { document_d_exports } from "../../types/document.js";
 import { ImageAttrs, ImagePositionAttrs } from "../schema/nodes.js";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/commands/image.d.ts
@@ -31,8 +32,14 @@ type ResolvedImageWrap = {
 };
 /** Map a toolbar wrap selection to the image's wrapType/displayMode/cssFloat, or null when unknown. */
 declare const resolveImageWrap: (wrapType: string) => ResolvedImageWrap | null;
-/** The CSS transform after applying a rotate/flip action to the current transform string. */
-declare const computeImageTransform: (currentTransform: string, action: ImageTransformAction) => string | undefined;
+/**
+ * The authored transform after applying a rotate/flip action.
+ *
+ * Every field the action decides is stated: rotating back to zero states zero,
+ * un-flipping states `false`. The editor is saying what the drawing is now, and
+ * leaving the field absent would hand the decision back to the file.
+ */
+declare const computeImageTransform: (current: document_d_exports.ImageTransform | undefined, action: ImageTransformAction) => document_d_exports.ImageTransform;
 declare const normalizeImageHorizontalPosition: (data: ImagePositionInput["horizontal"]) => ImagePositionAttrs["horizontal"] | undefined;
 declare const normalizeImageVerticalPosition: (data: ImagePositionInput["vertical"]) => ImagePositionAttrs["vertical"] | undefined;
 /** Clamp an image's intrinsic size to the page text width, preserving aspect ratio. */

package/dist/prosemirror/commands/image.js

@@ -1,7 +1,9 @@
+import { FOLIO_INSERTED_PICTURE_FRAME_LOCKS } from "../../docx/graphicFrameLocks.js";
 import { IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES } from "../../types/documentEnumValues.js";
 import { isSafeImageFile } from "../../utils/imageValidation.js";
 import { sanitizeImageSrc } from "../../utils/sanitizeImageSrc.js";
 import { expectImageAttrs, mergeImageAttrs } from "../attrs/index.js";
+import { authoredTransformAttrs, readAuthoredTransform } from "../authoredTransformAttrs.js";
 //#region src/prosemirror/commands/image.ts
 /** Map a toolbar wrap selection to the image's wrapType/displayMode/cssFloat, or null when unknown. */
 const resolveImageWrap = (wrapType) => {
@@ -42,32 +44,44 @@ const resolveImageWrap = (wrapType) => {
 		default: return null;
 	}
 };
-/** The CSS transform after applying a rotate/flip action to the current transform string. */
-const computeImageTransform = (currentTransform, action) => {
-	const rotateMatch = /rotate\((?<degrees>-?\d+(?:\.\d+)?)deg\)/u.exec(currentTransform);
-	let rotation = rotateMatch ? Number.parseFloat(rotateMatch.groups["degrees"]) : 0;
-	let hasFlipH = currentTransform.includes("scaleX(-1)");
-	let hasFlipV = currentTransform.includes("scaleY(-1)");
+const QUARTER_TURN = 90;
+const FULL_TURN = 360;
+/**
+* The turn `degrees` names, in `[0, 360)`.
+*
+* `%` keeps the sign of its left operand in JavaScript, and an authored
+* rotation may be negative, so a bare remainder answers `-270` where the
+* drawing is at `90`.
+*/
+const withinOneTurn = (degrees) => (degrees % FULL_TURN + FULL_TURN) % FULL_TURN;
+/**
+* The authored transform after applying a rotate/flip action.
+*
+* Every field the action decides is stated: rotating back to zero states zero,
+* un-flipping states `false`. The editor is saying what the drawing is now, and
+* leaving the field absent would hand the decision back to the file.
+*/
+const computeImageTransform = (current, action) => {
+	const rotation = current?.rotation ?? 0;
 	switch (action) {
-		case "rotateCW":
-			rotation = (rotation + 90) % 360;
-			break;
-		case "rotateCCW":
-			rotation = (rotation - 90 + 360) % 360;
-			break;
-		case "flipH":
-			hasFlipH = !hasFlipH;
-			break;
-		case "flipV":
-			hasFlipV = !hasFlipV;
-			break;
-		default: break;
+		case "rotateCW": return {
+			...current,
+			rotation: withinOneTurn(rotation + QUARTER_TURN)
+		};
+		case "rotateCCW": return {
+			...current,
+			rotation: withinOneTurn(rotation - QUARTER_TURN)
+		};
+		case "flipH": return {
+			...current,
+			flipH: current?.flipH !== true
+		};
+		case "flipV": return {
+			...current,
+			flipV: current?.flipV !== true
+		};
+		default: return action;
 	}
-	const parts = [];
-	if (rotation !== 0) parts.push(`rotate(${rotation}deg)`);
-	if (hasFlipH) parts.push("scaleX(-1)");
-	if (hasFlipV) parts.push("scaleY(-1)");
-	return parts.length > 0 ? parts.join(" ") : void 0;
 };
 const isOneOf = (value, values) => value !== void 0 && values.some((allowed) => allowed === value);
 const normalizeImageHorizontalPosition = (data) => {
@@ -126,9 +140,8 @@ const applyImageWrapType = (view, pos, wrapType) => {
 const applyImageTransform = (view, pos, action) => {
 	const node = imageNodeAt(view, pos);
 	if (!node) return false;
-	const currentTransform = expectImageAttrs(node).transform ?? "";
-	const transform = computeImageTransform(currentTransform, action);
-	const tr = view.state.tr.setNodeMarkup(pos, void 0, mergeImageAttrs(node, { transform }));
+	const transform = computeImageTransform(readAuthoredTransform(expectImageAttrs(node)), action);
+	const tr = view.state.tr.setNodeMarkup(pos, void 0, mergeImageAttrs(node, authoredTransformAttrs(transform)));
 	view.dispatch(tr.scrollIntoView());
 	return true;
 };
@@ -179,12 +192,14 @@ const insertImageFromFile = async (view, file, onInserted) => {
 	if (!imageType) return;
 	const imageNode = imageType.create({
 		src: dataUrl,
+		docPrName: file.name,
 		alt: file.name,
 		width: constrained.width,
 		height: constrained.height,
 		rId: `rId_img_${Date.now()}`,
 		wrapType: "inline",
-		displayMode: "inline"
+		displayMode: "inline",
+		frameLocks: FOLIO_INSERTED_PICTURE_FRAME_LOCKS
 	});
 	const { from } = view.state.selection;
 	const tr = view.state.tr.insert(from, imageNode);

package/dist/prosemirror/commands/pageBreak.js

@@ -29,7 +29,7 @@ const insertPageBreak = (state, dispatch) => {
 	const { $from } = state.selection;
 	if (!pageBreakRunType || !state.selection.empty || !$from.parent.isTextblock) return false;
 	for (let depth = $from.depth; depth >= 0; depth--) if (UNSUPPORTED_PAGE_BREAK_RUN_ANCESTORS.has($from.node(depth).type.name)) return false;
-	if ($from.parent.type.name !== "paragraph" || pageBreakRunParagraphProjectionDisposition($from.parent).status === "unsupported" || hasTextBoxAnchorAtOrAfter($from.parent, $from.start(), $from.pos)) return false;
+	if ($from.parent.type.name !== "paragraph" || pageBreakRunParagraphProjectionDisposition($from.parent).status === "approximate" || hasTextBoxAnchorAtOrAfter($from.parent, $from.start(), $from.pos)) return false;
 	if (dispatch) {
 		const pageBreak = pageBreakRunType.create();
 		dispatch(state.tr.replaceSelectionWith(pageBreak).scrollIntoView());

package/dist/prosemirror/commentReferenceAttrs.d.ts

@@ -0,0 +1,8 @@
+import { CommentReferenceAttrs } from "./schema/nodes.js";
+import { ReadProseMirrorAttrsResult } from "./attrs/index.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/commentReferenceAttrs.d.ts
+declare const readCommentReferenceAttrs: (node: Node) => ReadProseMirrorAttrsResult<CommentReferenceAttrs>;
+declare const expectCommentReferenceAttrs: (node: Node) => CommentReferenceAttrs;
+//#endregion
+export { expectCommentReferenceAttrs, readCommentReferenceAttrs };

package/dist/prosemirror/commentReferenceAttrs.js

@@ -0,0 +1,33 @@
+import { panic } from "better-result";
+//#region src/prosemirror/commentReferenceAttrs.ts
+const attrsCache = /* @__PURE__ */ new WeakMap();
+const readCommentReferenceAttrs = (node) => {
+	const issues = [];
+	if (node.type.name !== "commentReference") issues.push({
+		path: "commentReference.type.name",
+		message: `Expected commentReference, got ${node.type.name}.`
+	});
+	const commentId = node.attrs["commentId"];
+	if (typeof commentId !== "number" || !Number.isInteger(commentId) || commentId < 0) issues.push({
+		path: "commentReference.attrs.commentId",
+		message: "Expected a non-negative integer."
+	});
+	if (issues.length > 0 || typeof commentId !== "number") return {
+		ok: false,
+		issues
+	};
+	return {
+		ok: true,
+		value: { commentId }
+	};
+};
+const expectCommentReferenceAttrs = (node) => {
+	const cached = attrsCache.get(node);
+	if (cached) return cached;
+	const result = readCommentReferenceAttrs(node);
+	if (!result.ok) panic(`Invalid ProseMirror comment reference attrs:\n${result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
+	attrsCache.set(node, result.value);
+	return result.value;
+};
+//#endregion
+export { expectCommentReferenceAttrs, readCommentReferenceAttrs };

package/dist/prosemirror/commentReferenceIntegrity.d.ts

@@ -0,0 +1,47 @@
+//#region src/prosemirror/commentReferenceIntegrity.d.ts
+/**
+ * What a document must hold for every comment: exactly one `commentReference`
+ * node, after the last position its `comment` mark covers.
+ *
+ * The reference is the run Word paints the visible comment mark with, so a
+ * comment without one is invisible in Word and a duplicate paints the mark
+ * twice. Editing cannot be trusted to keep that true — a paste duplicates a
+ * reference, deleting the commented text orphans one, and a command that adds
+ * a comment mark creates none — so the repair is computed here and applied by
+ * the extension's `appendTransaction`, rather than left to each call site.
+ */
+type CommentReferenceOccurrence = {
+  commentId: number;
+  position: number;
+  /** Node size, so a caller can delete the node without re-reading it. */
+  size: number;
+  malformed: boolean;
+};
+/** Where a comment's mark last covers content, and how far that content runs. */
+type CommentMarkExtent = {
+  commentId: number;
+  /** Document position just past the last inline node carrying the mark. */
+  end: number;
+};
+type CommentReferenceRepair = {
+  type: "delete";
+  position: number;
+  size: number;
+} | {
+  type: "insert";
+  position: number;
+  commentId: number;
+};
+type CommentReferenceRepairInput = {
+  references: readonly CommentReferenceOccurrence[];
+  markExtents: readonly CommentMarkExtent[];
+};
+/**
+ * The repairs that make a document total, as positions in the document they
+ * were read from. Deletions come first, last-first, so they apply in sequence
+ * without mapping; the insertions that follow still carry pre-repair positions
+ * and the applier maps them through the transaction.
+ */
+declare const planCommentReferenceRepairs: ({ references, markExtents }: CommentReferenceRepairInput) => readonly CommentReferenceRepair[];
+//#endregion
+export { CommentMarkExtent, CommentReferenceOccurrence, CommentReferenceRepair, planCommentReferenceRepairs };

package/dist/prosemirror/commentReferenceIntegrity.js

@@ -0,0 +1,43 @@
+//#region src/prosemirror/commentReferenceIntegrity.ts
+/**
+* The repairs that make a document total, as positions in the document they
+* were read from. Deletions come first, last-first, so they apply in sequence
+* without mapping; the insertions that follow still carry pre-repair positions
+* and the applier maps them through the transaction.
+*/
+const planCommentReferenceRepairs = ({ references, markExtents }) => {
+	const markedIds = new Set(markExtents.map(({ commentId }) => commentId));
+	const deletions = [];
+	const keptIds = /* @__PURE__ */ new Set();
+	for (const reference of references) {
+		if (reference.malformed || !markedIds.has(reference.commentId)) {
+			deletions.push({
+				type: "delete",
+				position: reference.position,
+				size: reference.size
+			});
+			continue;
+		}
+		if (keptIds.has(reference.commentId)) {
+			deletions.push({
+				type: "delete",
+				position: reference.position,
+				size: reference.size
+			});
+			continue;
+		}
+		keptIds.add(reference.commentId);
+	}
+	const insertions = [];
+	for (const { commentId, end } of markExtents) {
+		if (keptIds.has(commentId)) continue;
+		insertions.push({
+			type: "insert",
+			position: end,
+			commentId
+		});
+	}
+	return [...deletions.toSorted((first, second) => second.position - first.position), ...insertions.toSorted((first, second) => second.position - first.position)];
+};
+//#endregion
+export { planCommentReferenceRepairs };

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

@@ -5,14 +5,6 @@ import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/conversion/fromProseDoc.d.ts
 /** Convert a ProseMirror document to the document model. */
 declare function fromProseDoc(pmDoc: Node, baseDocument?: document_d_exports.Document): document_d_exports.Document;
-/**
- * What a field carrying no stored result reports.
- *
- * `serializerFallback` writes the visible page number a save has always given a
- * result-less PAGE/NUMPAGES field; `authored` reports the result the document
- * actually holds, so a text read of a story reads the same loaded and unloaded.
- */
-type EmptyFieldResultMode = "serializerFallback" | "authored";
 /**
  * Convert ProseMirror marks to TextFormatting
  */
@@ -36,9 +28,6 @@ declare function tableCellAttrsToFormatting(attrs: TableCellAttrs): document_d_e
  * Preserves all non-content parts of the original document
  */
 declare function updateDocumentContent(originalDocument: document_d_exports.Document, pmDoc: Node): document_d_exports.Document;
-type ProseDocToBlocksOptions = {
-  emptyFieldResult?: EmptyFieldResultMode;
-};
 /**
  * Convert a ProseMirror document back to an array of `BlockContent` blocks
  * (paragraphs, tables, and block-level content controls).
@@ -46,6 +35,6 @@ type ProseDocToBlocksOptions = {
  * Used for converting edited header/footer PM content back to the document
  * model.
  */
-declare function proseDocToBlocks(pmDoc: Node, baseContent?: document_d_exports.BlockContent[], styles?: NonNullable<document_d_exports.Document["package"]>["styles"], options?: ProseDocToBlocksOptions): document_d_exports.BlockContent[];
+declare function proseDocToBlocks(pmDoc: Node, baseContent?: document_d_exports.BlockContent[], styles?: NonNullable<document_d_exports.Document["package"]>["styles"]): document_d_exports.BlockContent[];
 //#endregion
-export { EmptyFieldResultMode, ProseDocToBlocksOptions, fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };
+export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };