@stll/folio-core 0.46.0 → 0.47.1

package/dist/docx/serializer/paragraphSerializer.js

@@ -1,21 +1,22 @@
-import { modelParagraphFormattingEmission } from "../../internal/paragraphFormattingSerialization.js";
+import { modelParagraphFormattingEmission, serializeParagraphPropertySet } from "../../internal/paragraphFormattingSerialization.js";
 import { serializePreservedAttributes } from "../attributeRemainder.js";
+import { CONTAINER_CHILDREN } from "../containerChildren.gen.js";
 import { fieldStateAttributes } from "../fieldState.js";
 import { getParagraphPropertySource, paragraphPropertySourceMatchesEmission } from "../paragraphPropertySource.js";
-import { reconcileRawSdtPr } from "../sdtPropertiesPatch.js";
 import { DATE_UTC_ATTRIBUTE } from "../trackedChangeInfo.js";
 import { toTransitionalNamespaceUri } from "../transitionalSpelling.js";
 import { captureVerbatimXml, sanitizeCapturedXmlElement } from "../verbatimCapture.js";
 import { NAMESPACES, OOXML_NAMESPACE_SCOPE, cloneElement, getChildElements, getLocalName, parseXml } from "../xmlParser.js";
-import { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes } from "./markupRangeAttributes.js";
+import { markupRangeAttributes, moveBookmarkAttributes, serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeRun } from "./runSerializer.js";
+import { serializeSdtWrapper } from "./sdtPropertiesSerializer.js";
 import { serializeSectionProperties } from "./sectionPropertiesSerializer.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
 import { serializeTrackedChangeAttributes, trackedChangeAttributeRecord } from "./trackedChangeAttributes.js";
-import { isSingleWellFormedElement } from "./xmlUtils.js";
 import { panic } from "better-result";
 import { escapeXmlAttribute, escapeXmlText } from "@stll/docx-core";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
+import { SEQUENCE_CHILDREN } from "@stll/docx-core/schema";
 //#region src/docx/serializer/paragraphSerializer.ts
 /**
 * Serialize paragraph formatting properties to w:pPr XML
@@ -52,83 +53,26 @@ const PARAGRAPH_APPEND_PREFIXES = /* @__PURE__ */ new Map([
 	["r", NAMESPACES.r],
 	["w15", NAMESPACES.w15]
 ]);
-const PARAGRAPH_PROPERTY_CHILD_ORDER = new Map([
-	"pStyle",
-	"keepNext",
-	"keepLines",
-	"pageBreakBefore",
-	"framePr",
-	"widowControl",
-	"numPr",
-	"suppressLineNumbers",
-	"pBdr",
-	"shd",
-	"tabs",
-	"suppressAutoHyphens",
-	"kinsoku",
-	"wordWrap",
-	"overflowPunct",
-	"topLinePunct",
-	"autoSpaceDE",
-	"autoSpaceDN",
-	"bidi",
-	"adjustRightInd",
-	"snapToGrid",
-	"spacing",
-	"ind",
-	"contextualSpacing",
-	"mirrorIndents",
-	"suppressOverlap",
-	"jc",
-	"textDirection",
-	"textAlignment",
-	"textboxTightWrap",
-	"outlineLvl",
-	"divId",
-	"cnfStyle",
-	"rPr"
-].map((name, index) => [name, index]));
-const PARAGRAPH_MARK_BASE_CHILDREN = /* @__PURE__ */ new Set([
-	"rStyle",
-	"rFonts",
-	"b",
-	"bCs",
-	"i",
-	"iCs",
-	"caps",
-	"smallCaps",
-	"strike",
-	"dstrike",
-	"outline",
-	"shadow",
-	"emboss",
-	"imprint",
-	"snapToGrid",
-	"vanish",
-	"webHidden",
-	"color",
-	"spacing",
-	"w",
-	"kern",
-	"position",
-	"sz",
-	"szCs",
-	"noProof",
-	"highlight",
-	"u",
-	"effect",
-	"bdr",
-	"shd",
-	"fitText",
-	"vertAlign",
-	"rtl",
-	"cs",
-	"em",
-	"lang",
-	"eastAsianLayout",
-	"specVanish",
-	"oMath"
-]);
+/**
+* The order a replayed `w:pPr` has to already be in, from the generated table.
+*
+* This used to be the same list written out again, which is a mirror of the
+* order the writer emits: the two could disagree and a capture the gate let
+* through would then be markup the rebuild would never have written.
+* `w:sectPr` and `w:pPrChange` are in the generated list and are refused
+* before this map is consulted, because they have their own lifecycles.
+*/
+const PARAGRAPH_PROPERTY_CHILD_ORDER = new Map(SEQUENCE_CHILDREN["paragraph-properties"].map((name, index) => [name, index]));
+/**
+* `EG_RPrBase`: the paragraph mark's `w:rPr` children a replay may carry.
+*
+* Derived from the generated declared-child list rather than restated, so the
+* set a capture is checked against and the set the parser makes a decision for
+* are one list. The revisions `CT_ParaRPr` adds around it are excluded here
+* and refused by {@link RESERVED_PARAGRAPH_CAPTURE_CHILDREN}, which is what
+* keeps a replayed `w:pPr` from carrying a revision the model also writes.
+*/
+const PARAGRAPH_MARK_BASE_CHILDREN = new Set(CONTAINER_CHILDREN["run-properties"].filter((name) => !RESERVED_PARAGRAPH_CAPTURE_CHILDREN.has(name)));
 const PARAGRAPH_NESTED_PROPERTY_CHILDREN = /* @__PURE__ */ new Map([
 	["numPr", /* @__PURE__ */ new Set([
 		"ilvl",
@@ -306,15 +250,12 @@ const serializeParagraphFormattingWithOptions = (formatting, { propertyChanges,
 		const sourceWithMark = paragraphMarkChange ? withParagraphMarkChange(verifiedSource, paragraphMarkChange) : verifiedSource;
 		return withTrailingParagraphPropertyChildren(sourceWithMark, [sectionPropertiesXml, ...propertyChangesXml]);
 	}
-	const parts = [];
-	if (modeledFormatting.propertiesXml) parts.push(modeledFormatting.propertiesXml);
-	const paragraphMarkPropertiesInnerXml = `${paragraphMarkXml}${modeledFormatting.paragraphMarkPropertiesInnerXml ?? ""}`;
-	if (paragraphMarkPropertiesInnerXml) parts.push(`<w:rPr>${paragraphMarkPropertiesInnerXml}</w:rPr>`);
-	parts.push(sectionPropertiesXml);
-	if (propertyChangesXml.length > 0) parts.push(...propertyChangesXml);
-	const inner = parts.join("");
-	if (inner.length === 0) return "";
-	return `<w:pPr>${inner}</w:pPr>`;
+	return serializeParagraphPropertySet({
+		formatting,
+		markPropertiesPrefixXml: paragraphMarkXml,
+		sectionPropertiesXml,
+		propertyChangesXml
+	});
 };
 function serializeParagraphFormatting(formatting, propertyChanges, paragraphMarkChange) {
 	return serializeParagraphFormattingWithOptions(formatting, {
@@ -343,37 +284,35 @@ function hyperlinkAttributes(hyperlink) {
 	if (hyperlink.docLocation) attrs.push(`w:docLocation="${escapeXmlAttribute(hyperlink.docLocation)}"`);
 	return attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
 }
-/** One `w:hyperlink` child, with the caller deciding how a run is written. */
-function serializeHyperlinkChild(child, serializeChildRun) {
-	if (child.type === "run") return serializeChildRun(child);
-	if (child.type === "bookmarkStart") return serializeBookmarkStart(child);
-	return child.type === "bookmarkEnd" ? serializeBookmarkEnd(child) : child.xml;
+/** One `w:hyperlink` child, written with the link's own disposition. */
+function serializeHyperlinkChild(child, disposition) {
+	switch (child.type) {
+		case "run": return serializeInlineRun(child, disposition);
+		case "bookmarkStart": return serializeBookmarkMarker(child);
+		case "bookmarkEnd": return serializeBookmarkMarker(child);
+		case "inlineWrapper": return serializeParagraphContent(child, disposition);
+		case "preservedInline": return child.xml;
+		default: return child;
+	}
 }
 /**
 * Serialize a hyperlink (w:hyperlink)
 */
 function serializeHyperlink(hyperlink, disposition = "kept") {
-	const childrenXml = hyperlink.children.map((child) => serializeHyperlinkChild(child, (run) => serializeInlineRun(run, disposition))).join("");
+	const childrenXml = hyperlink.children.map((child) => serializeHyperlinkChild(child, disposition)).join("");
 	return `<w:hyperlink${hyperlinkAttributes(hyperlink)}>${childrenXml}</w:hyperlink>`;
 }
-/**
-* Serialize bookmark start (w:bookmarkStart)
-*/
-function serializeBookmarkStart(bookmark) {
-	return `<w:bookmarkStart ${bookmarkRangeAttributes(bookmark).join(" ")}/>`;
-}
-/**
-* Serialize bookmark end (w:bookmarkEnd)
-*/
-function serializeBookmarkEnd(bookmark) {
-	return `<w:bookmarkEnd ${markupRangeAttributes(bookmark).join(" ")}/>`;
-}
 /** Serialize a simple field without changing its authored OOXML field form. */
 function serializeSimpleField(field) {
 	const attrs = [`w:instr="${escapeXmlAttribute(field.instruction)}"`, ...fieldStateAttributes(field)];
 	const contentXml = field.content.map((item) => {
-		if (item.type === "run") return serializeRun(item);
-		return item.type === "hyperlink" ? serializeHyperlink(item) : item.xml;
+		switch (item.type) {
+			case "run": return serializeRun(item);
+			case "hyperlink": return serializeHyperlink(item);
+			case "inlineWrapper": return serializeParagraphContent(item);
+			case "preservedInline": return item.xml;
+			default: return item;
+		}
 	}).join("");
 	return `<w:fldSimple ${attrs.join(" ")}>${contentXml}</w:fldSimple>`;
 }
@@ -399,56 +338,6 @@ function serializeComplexField(field) {
 	return parts.join("");
 }
 /**
-* Synthesize a `<w:sdtPr>` from the modeled {@link SdtProperties}.
-*
-* Only reached for an inline SDT that carries no captured `rawPropertiesXml`
-* (constructed programmatically rather than parsed from a DOCX). Mirrors the
-* block-SDT fallback: emit `w:id` first so the parsed numeric id survives,
-* then the shared identity fields, then the type-defining marker.
-*/
-function synthesizeInlineSdtPr(props) {
-	const prParts = [];
-	if (typeof props.id === "number") prParts.push(`<w:id w:val="${props.id}"/>`);
-	if (props.alias) prParts.push(`<w:alias w:val="${escapeXmlAttribute(props.alias)}"/>`);
-	if (props.tag) prParts.push(`<w:tag w:val="${escapeXmlAttribute(props.tag)}"/>`);
-	if (props.lock && props.lock !== "unlocked") prParts.push(`<w:lock w:val="${props.lock}"/>`);
-	if (props.placeholder) prParts.push(`<w:placeholder><w:docPart w:val="${escapeXmlAttribute(props.placeholder)}"/></w:placeholder>`);
-	if (props.showingPlaceholder) prParts.push("<w:showingPlcHdr/>");
-	switch (props.sdtType) {
-		case "plainText":
-			prParts.push("<w:text/>");
-			break;
-		case "date": {
-			const fullDateAttr = props.dateValueISO ? ` w:fullDate="${escapeXmlAttribute(props.dateValueISO)}"` : "";
-			const formatChild = props.dateFormat ? `<w:dateFormat w:val="${escapeXmlAttribute(props.dateFormat)}"/>` : "";
-			if (fullDateAttr || formatChild) prParts.push(`<w:date${fullDateAttr}>${formatChild}</w:date>`);
-			else prParts.push("<w:date/>");
-			break;
-		}
-		case "dropdown": {
-			const items = (props.listItems ?? []).map((i) => `<w:listItem w:displayText="${escapeXmlAttribute(i.displayText)}" w:value="${escapeXmlAttribute(i.value)}"/>`).join("");
-			prParts.push(`<w:dropDownList>${items}</w:dropDownList>`);
-			break;
-		}
-		case "comboBox": {
-			const items = (props.listItems ?? []).map((i) => `<w:listItem w:displayText="${escapeXmlAttribute(i.displayText)}" w:value="${escapeXmlAttribute(i.value)}"/>`).join("");
-			prParts.push(`<w:comboBox>${items}</w:comboBox>`);
-			break;
-		}
-		case "checkbox":
-			prParts.push(`<w14:checkbox><w14:checked w14:val="${props.checked ? "1" : "0"}"/></w14:checkbox>`);
-			break;
-		case "picture":
-			prParts.push("<w:picture/>");
-			break;
-		case "richText":
-		case "buildingBlockGallery":
-		case "group":
-		case "unknown": break;
-	}
-	return `<w:sdtPr>${prParts.join("")}</w:sdtPr>`;
-}
-/**
 * Serialize an inline SDT (w:sdt).
 *
 * Replays the captured `<w:sdtPr>` / `<w:sdtEndPr>` verbatim so unmodeled
@@ -459,7 +348,7 @@ function synthesizeInlineSdtPr(props) {
 */
 function serializeInlineSdt(sdt, disposition = "kept") {
 	const props = sdt.properties;
-	const contentXml = sdt.content.map((item) => {
+	return serializeSdtWrapper(props, sdt.content.map((item) => {
 		switch (item.type) {
 			case "run": return serializeInlineRun(item, disposition);
 			case "hyperlink": return serializeHyperlink(item, disposition);
@@ -467,6 +356,8 @@ function serializeInlineSdt(sdt, disposition = "kept") {
 			case "complexField": return serializeComplexField(item);
 			case "inlineSdt": return serializeInlineSdt(item, disposition);
 			case "inlineWrapper": return serializeParagraphContent(item, disposition);
+			case "bookmarkStart": return serializeBookmarkMarker(item);
+			case "bookmarkEnd": return serializeBookmarkMarker(item);
 			case "insertion": return serializeTrackedChange("ins", item);
 			case "deletion": return serializeTrackedChange("del", item);
 			case "moveFrom": return serializeTrackedChange("moveFrom", item);
@@ -475,14 +366,7 @@ function serializeInlineSdt(sdt, disposition = "kept") {
 			case "preservedInline": return item.xml;
 			default: return item;
 		}
-	}).join("");
-	const baseSdtPr = props.rawPropertiesXml && isSingleWellFormedElement(props.rawPropertiesXml, "sdtPr") ? props.rawPropertiesXml : synthesizeInlineSdtPr(props);
-	const dateFullDate = props.sdtType === "date" && props.dateValueISO ? props.dateValueISO : void 0;
-	const dropdownLastValue = (props.sdtType === "dropdown" || props.sdtType === "comboBox") && typeof props.dropdownLastValue === "string" ? props.dropdownLastValue : void 0;
-	return `<w:sdt>${reconcileRawSdtPr(baseSdtPr, props, {
-		...dateFullDate !== void 0 ? { dateFullDate } : {},
-		...dropdownLastValue !== void 0 ? { dropdownLastValue } : {}
-	})}${props.rawEndPropertiesXml && isSingleWellFormedElement(props.rawEndPropertiesXml, "sdtEndPr") ? props.rawEndPropertiesXml : ""}<w:sdtContent>${contentXml}</w:sdtContent></w:sdt>`;
+	}).join(""));
 }
 function serializeMoveRangeStart(tag, marker) {
 	return `<w:${tag} ${moveBookmarkAttributes(marker).join(" ")}/>`;
@@ -534,8 +418,8 @@ function serializeTrackedChange(tag, change) {
 			case "deletion":
 			case "moveFrom":
 			case "moveTo": return serializeTrackedChange(trackedChangeTag(item), item);
-			case "bookmarkStart": return serializeBookmarkStart(item);
-			case "bookmarkEnd": return serializeBookmarkEnd(item);
+			case "bookmarkStart":
+			case "bookmarkEnd": return serializeBookmarkMarker(item);
 			case "preservedInline": return item.xml;
 			case "inlineWrapper":
 			case "inlineSdt": return serializeParagraphContent(item, disposition);
@@ -557,7 +441,7 @@ function serializeTrackedChange(tag, change) {
 	for (const item of change.content) {
 		if (item.type === "hyperlink") {
 			flushPending();
-			const childrenXml = item.children.map((child) => serializeHyperlinkChild(child, serializeContentRun)).join("");
+			const childrenXml = item.children.map((child) => serializeHyperlinkChild(child, disposition)).join("");
 			segments.push(`<w:hyperlink${hyperlinkAttributes(item)}>${open}${childrenXml}${close}</w:hyperlink>`);
 			continue;
 		}
@@ -566,6 +450,32 @@ function serializeTrackedChange(tag, change) {
 	flushPending();
 	return segments.join("");
 }
+const TAGGED_WRAPPER_PROPERTY_NAMES = {
+	smartTag: /* @__PURE__ */ new Set(["smartTagPr"]),
+	customXml: /* @__PURE__ */ new Set(["customXmlPr"])
+};
+/**
+* Emit a `w:smartTag` or a run-level `w:customXml` around content already written.
+*
+* `w:element` is required by both content models, so it is always spelled;
+* `w:uri` is written only when the source stated one, because inventing an
+* empty namespace would change what the tag names. The properties element
+* comes first, as both content models declare it.
+*
+* The captured properties are replayed only when they are structurally the one
+* element they claim to be. The layer rides a ProseMirror mark, so a paste from
+* outside the editor can put any string there, and a string that closed the
+* wrapper early would splice sibling markup into the part.
+*/
+function serializeTaggedWrapper(kind, wrapper, inner) {
+	const uri = wrapper.uri === void 0 ? "" : ` w:uri="${escapeXmlAttribute(wrapper.uri)}"`;
+	const properties = sanitizeCapturedXmlElement(wrapper.propertiesXml, {
+		allowedLocalNames: TAGGED_WRAPPER_PROPERTY_NAMES[kind],
+		allowedNamespaceUris: WORDPROCESSINGML_NAMESPACE,
+		inheritedNamespaceScope: OOXML_NAMESPACE_SCOPE
+	}) ?? "";
+	return `<w:${kind}${uri} w:element="${escapeXmlAttribute(wrapper.element)}">${properties}${inner}</w:${kind}>`;
+}
 /** Emit the `<w:commentReference>` run Word places after a comment range end. */
 function serializeCommentReferenceRun(id) {
 	return `<w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="${id}"/></w:r>`;
@@ -582,8 +492,8 @@ function serializeParagraphContent(content, disposition = "kept") {
 	switch (content.type) {
 		case "run": return serializeInlineRun(content, disposition);
 		case "hyperlink": return serializeHyperlink(content, disposition);
-		case "bookmarkStart": return serializeBookmarkStart(content);
-		case "bookmarkEnd": return serializeBookmarkEnd(content);
+		case "bookmarkStart":
+		case "bookmarkEnd": return serializeBookmarkMarker(content);
 		case "simpleField": return serializeSimpleField(content);
 		case "complexField": return serializeComplexField(content);
 		case "inlineSdt": return serializeInlineSdt(content, disposition);
@@ -605,7 +515,9 @@ function serializeParagraphContent(content, disposition = "kept") {
 					const tag = content.control === "override" ? "bdo" : "dir";
 					return `<w:${tag}${content.direction === void 0 ? "" : ` w:val="${escapeXmlAttribute(content.direction)}"`}>${inner}</w:${tag}>`;
 				}
-				default: return content.kind;
+				case "smartTag": return serializeTaggedWrapper("smartTag", content, inner);
+				case "customXml": return serializeTaggedWrapper("customXml", content, inner);
+				default: return content;
 			}
 		}
 		case "mathEquation": return content.ommlXml || "";
@@ -720,17 +632,5 @@ function createTextParagraph(text, paragraphFormatting, textFormatting) {
 		}]
 	};
 }
-/**
-* Check if paragraph is a list item
-*/
-function isListParagraph(paragraph) {
-	return paragraph.formatting?.numPr !== void 0;
-}
-/**
-* Get list level of a paragraph (0-8, or -1 if not a list)
-*/
-function getListLevel(paragraph) {
-	return paragraph.formatting?.numPr?.ilvl ?? -1;
-}
 //#endregion
-export { createEmptyParagraph, createTextParagraph, getListLevel, hasParagraphContent, hasParagraphFormatting, isListParagraph, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };
+export { createEmptyParagraph, createTextParagraph, hasParagraphContent, hasParagraphFormatting, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };

package/dist/docx/serializer/runSerializer.d.ts

@@ -19,10 +19,6 @@ declare function serializeRun(run: document_d_exports.Run): string;
  * @returns XML string for all runs
  */
 declare function serializeRuns(runs: document_d_exports.Run[]): string;
-/**
- * Check if a run has any content
- */
-declare function hasRunContent(run: document_d_exports.Run): boolean;
 /**
  * Check if a run has formatting
  */
@@ -48,4 +44,4 @@ declare function createBreakRun(breakType?: "page" | "column" | "textWrapping",
  */
 declare function createTabRun(formatting?: document_d_exports.TextFormatting): document_d_exports.Run;
 //#endregion
-export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunContent, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns };
+export { createBreakRun, createEmptyRun, createTabRun, createTextRun, getRunPlainText, hasRunFormatting, resetAutoIdCounter, serializeRun, serializeRuns };