@stll/folio-core 0.46.0 → 0.47.1

package/dist/docx/serializer/fontTableSerializer.js

@@ -1,18 +1,33 @@
+import { serializePreservedAttributes } from "../attributeRemainder.js";
+import { serializeWithPreservedChildren } from "../containerChildren.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { escapeXmlAttribute } from "@stll/docx-core";
 //#region src/docx/serializer/fontTableSerializer.ts
 const serializeFontTableXml = (fontTable) => "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
 	partPath: "word/fontTable.xml",
 	rootName: "w:fonts",
+	rootAttributes: serializePreservedAttributes([], fontTable.preservedAttributes).join(" "),
 	baselinePrefixes: ["w"],
 	sourceBindings: void 0,
-	body: fontTable.fonts.map(serializeFont).join("")
+	body: serializeWithPreservedChildren(fontTable.fonts.map(serializeFont), fontTable.preserved)
 });
+/**
+* One `w:font`, with its children in the order `CT_Font` declares them.
+*
+* The order is what makes the sink's index mean something: a capture recorded
+* after the third field the reader kept goes back after the third field this
+* writes, so unmodelled markup keeps the neighbours it was authored between.
+*/
 const serializeFont = (font) => {
 	const parts = [];
 	if (font.altName) parts.push(`<w:altName w:val="${escapeXmlAttribute(font.altName)}"/>`);
 	if (font.panose1) parts.push(`<w:panose1 w:val="${escapeXmlAttribute(font.panose1)}"/>`);
-	if (font.charset) parts.push(`<w:charset w:val="${escapeXmlAttribute(font.charset)}"/>`);
+	if (font.charset) {
+		const attributes = [];
+		if (font.charset.val !== void 0) attributes.push(`w:val="${escapeXmlAttribute(font.charset.val)}"`);
+		if (font.charset.characterSet !== void 0) attributes.push(`w:characterSet="${escapeXmlAttribute(font.charset.characterSet)}"`);
+		parts.push(attributes.length === 0 ? "<w:charset/>" : `<w:charset ${attributes.join(" ")}/>`);
+	}
 	if (font.family) parts.push(`<w:family w:val="${font.family}"/>`);
 	if (font.pitch) parts.push(`<w:pitch w:val="${font.pitch}"/>`);
 	if (font.sig) {
@@ -23,7 +38,20 @@ const serializeFont = (font) => {
 		}
 		if (attrs.length > 0) parts.push(`<w:sig ${attrs.join(" ")}/>`);
 	}
-	return `<w:font w:name="${escapeXmlAttribute(font.name)}">${parts.join("")}</w:font>`;
+	pushEmbed(parts, "embedRegular", font.embedRegular);
+	pushEmbed(parts, "embedBold", font.embedBold);
+	pushEmbed(parts, "embedItalic", font.embedItalic);
+	pushEmbed(parts, "embedBoldItalic", font.embedBoldItalic);
+	const attributes = serializePreservedAttributes([`w:name="${escapeXmlAttribute(font.name)}"`], font.preservedAttributes);
+	const body = serializeWithPreservedChildren(parts, font.preserved);
+	return `<w:font ${attributes.join(" ")}>${body}</w:font>`;
+};
+const pushEmbed = (parts, element, embed) => {
+	if (embed === void 0) return;
+	const attributes = [`r:id="${escapeXmlAttribute(embed.id)}"`];
+	if (embed.fontKey !== void 0) attributes.push(`w:fontKey="${escapeXmlAttribute(embed.fontKey)}"`);
+	if (embed.subsetted !== void 0) attributes.push(`w:subsetted="${embed.subsetted ? "1" : "0"}"`);
+	parts.push(`<w:${element} ${attributes.join(" ")}/>`);
 };
 //#endregion
 export { serializeFontTableXml };

package/dist/docx/serializer/headerFooterSerializer.js

@@ -3,6 +3,7 @@ import { isEmptyParagraph } from "../paragraphParser.js";
 import { captureVerbatimXml } from "../verbatimCapture.js";
 import { getLocalName, parseXmlDocument } from "../xmlParser.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
+import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTable } from "./tableSerializer.js";
@@ -41,6 +42,8 @@ function serializeBlock(block) {
 		case "table": return serializeTable(block, serializeParagraph);
 		case "blockSdt": return serializeBlockSdt(block, serializeBlock);
 		case "preservedBlock": return block.xml;
+		case "bookmarkStart":
+		case "bookmarkEnd": return serializeBookmarkMarker(block);
 		default: return block;
 	}
 }

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

@@ -2,7 +2,15 @@ import { document_d_exports } from "../../types/document.js";
 //#region src/docx/serializer/markupRangeAttributes.d.ts
 declare const markupRangeAttributes: (marker: document_d_exports.MarkupRangeMarker) => string[];
 declare const bookmarkRangeAttributes: (marker: document_d_exports.BookmarkRangeMarker) => string[];
+/**
+ * One bookmark marker, wherever it stands.
+ *
+ * The same element is a paragraph child, a block, a child of `w:tr` and a
+ * child of `w:tbl`, so the four serializers share one writer: an attribute
+ * added to `CT_Bookmark` reaches every level at once.
+ */
+declare const serializeBookmarkMarker: (marker: document_d_exports.BookmarkStart | document_d_exports.BookmarkEnd) => string;
 /** `w:author` is required, so it is always written; `w:date` only when known. */
 declare const moveBookmarkAttributes: (marker: document_d_exports.MoveBookmarkMarker) => string[];
 //#endregion
-export { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes };
+export { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes, serializeBookmarkMarker };

package/dist/docx/serializer/markupRangeAttributes.js

@@ -13,6 +13,14 @@ const bookmarkRangeAttributes = (marker) => {
 	attributes.push(attribute("w:name", marker.name));
 	return attributes;
 };
+/**
+* One bookmark marker, wherever it stands.
+*
+* The same element is a paragraph child, a block, a child of `w:tr` and a
+* child of `w:tbl`, so the four serializers share one writer: an attribute
+* added to `CT_Bookmark` reaches every level at once.
+*/
+const serializeBookmarkMarker = (marker) => marker.type === "bookmarkStart" ? `<w:bookmarkStart ${bookmarkRangeAttributes(marker).join(" ")}/>` : `<w:bookmarkEnd ${markupRangeAttributes(marker).join(" ")}/>`;
 /** `w:author` is required, so it is always written; `w:date` only when known. */
 const moveBookmarkAttributes = (marker) => {
 	const attributes = bookmarkRangeAttributes(marker);
@@ -21,4 +29,4 @@ const moveBookmarkAttributes = (marker) => {
 	return attributes;
 };
 //#endregion
-export { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes };
+export { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes, serializeBookmarkMarker };

package/dist/docx/serializer/noteSerializer.js

@@ -1,4 +1,5 @@
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
+import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTable } from "./tableSerializer.js";
@@ -43,6 +44,8 @@ function serializeBlock(block) {
 		case "table": return serializeTable(block, serializeParagraph);
 		case "blockSdt": return serializeBlockSdt(block, serializeBlock);
 		case "preservedBlock": return block.xml;
+		case "bookmarkStart":
+		case "bookmarkEnd": return serializeBookmarkMarker(block);
 		default: return block;
 	}
 }

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

@@ -1,11 +1,6 @@
 import { document_d_exports } from "../../types/document.js";
 //#region src/docx/serializer/numberingSerializer.d.ts
-/**
- * Serialize {@link NumberingDefinitions} to a complete `word/numbering.xml`
- * string. `w:abstractNum` elements precede `w:num` elements as ECMA-376 §17.9
- * requires. See the module note: this whole-part output is used only for
- * change detection and per-definition splicing, never to overwrite the part.
- */
+/** Serialize a complete `word/numbering.xml` part. */
 declare function serializeNumberingXml(numbering: document_d_exports.NumberingDefinitions): string;
 //#endregion
 export { serializeNumberingXml };

package/dist/docx/serializer/numberingSerializer.js

@@ -1,99 +1,101 @@
+import { serializeParagraphPropertySet } from "../../internal/paragraphFormattingSerialization.js";
+import { serializePreservedAttributes } from "../attributeRemainder.js";
+import { customNumberFormatOf } from "../numberingParser.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
 import { intAttr } from "./xmlUtils.js";
-import { escapeXmlAttribute } from "@stll/docx-core";
+import { escapeXmlAttribute, serializeOnOffElement } from "@stll/docx-core";
+import { serializeSequenceChildren } from "@stll/docx-core/schema";
 //#region src/docx/serializer/numberingSerializer.ts
-/**
-* Serialize a level's paragraph properties — the modeled subset is indentation
-* plus tab stops (see `parseLevelParagraphProps`). Returns "" when neither is
-* present so an empty `<w:pPr/>` is not emitted.
-*/
-function serializeLevelParagraphProps(pPr) {
-	const indAttrs = [];
-	if (pPr.indentLeft !== void 0) indAttrs.push(`w:left="${intAttr(pPr.indentLeft)}"`);
-	if (pPr.indentRight !== void 0) indAttrs.push(`w:right="${intAttr(pPr.indentRight)}"`);
-	if (pPr.indentFirstLine !== void 0) {
-		if (pPr.hangingIndent) indAttrs.push(`w:hanging="${intAttr(Math.abs(pPr.indentFirstLine))}"`);
-		else if (pPr.indentFirstLine !== 0) indAttrs.push(`w:firstLine="${intAttr(pPr.indentFirstLine)}"`);
-	}
-	const parts = [];
-	if (pPr.tabs && pPr.tabs.length > 0) {
-		const tabs = pPr.tabs.map((tab) => {
-			const attrs = [`w:val="${tab.alignment}"`, `w:pos="${intAttr(tab.position)}"`];
-			if (tab.leader) attrs.push(`w:leader="${tab.leader}"`);
-			return `<w:tab ${attrs.join(" ")}/>`;
-		}).join("");
-		parts.push(`<w:tabs>${tabs}</w:tabs>`);
-	}
-	if (indAttrs.length > 0) parts.push(`<w:ind ${indAttrs.join(" ")}/>`);
-	if (parts.length === 0) return "";
-	return `<w:pPr>${parts.join("")}</w:pPr>`;
-}
-/**
-* Serialize one `w:lvl`. Children follow the ECMA-376 §17.9.6 CT_Lvl order
-* (start, numFmt, lvlRestart, isLgl, suff, lvlText, legacy, lvlJc, pPr, rPr) so
-* a re-emitted level parses back into an equivalent model.
-*/
+/** Serialize one `w:lvl`. */
 function serializeLevel(level) {
-	const parts = [];
-	if (level.start !== void 0) parts.push(`<w:start w:val="${intAttr(level.start)}"/>`);
-	parts.push(`<w:numFmt w:val="${escapeXmlAttribute(level.numFmt)}"/>`);
-	if (level.lvlRestart !== void 0) parts.push(`<w:lvlRestart w:val="${intAttr(level.lvlRestart)}"/>`);
-	if (level.isLgl) parts.push("<w:isLgl/>");
-	if (level.suffix) parts.push(`<w:suff w:val="${level.suffix}"/>`);
-	parts.push(`<w:lvlText w:val="${escapeXmlAttribute(level.lvlText)}"/>`);
-	if (level.legacy) {
-		const legacyAttrs = [`w:legacy="${level.legacy.legacy ? 1 : 0}"`];
-		if (level.legacy.legacySpace !== void 0) legacyAttrs.push(`w:legacySpace="${intAttr(level.legacy.legacySpace)}"`);
-		if (level.legacy.legacyIndent !== void 0) legacyAttrs.push(`w:legacyIndent="${intAttr(level.legacy.legacyIndent)}"`);
-		parts.push(`<w:legacy ${legacyAttrs.join(" ")}/>`);
+	const customFormat = customNumberFormatOf(level);
+	const numFmtFormat = customFormat === void 0 ? "" : ` w:format="${escapeXmlAttribute(customFormat)}"`;
+	const pPr = level.pPr === void 0 ? "" : serializeParagraphPropertySet({ formatting: level.pPr }) || "<w:pPr/>";
+	const rPr = level.rPr === void 0 ? "" : serializeTextFormatting(level.rPr) || "<w:rPr/>";
+	const lvlTextAttrs = [`w:val="${escapeXmlAttribute(level.lvlText)}"`];
+	if (level.lvlTextNull !== void 0) lvlTextAttrs.push(`w:null="${level.lvlTextNull ? 1 : 0}"`);
+	let legacy = "";
+	if (level.legacy !== void 0) {
+		const attributes = [];
+		if (level.legacy.legacy !== void 0) attributes.push(`w:legacy="${level.legacy.legacy ? 1 : 0}"`);
+		if (level.legacy.legacySpace !== void 0) attributes.push(`w:legacySpace="${intAttr(level.legacy.legacySpace)}"`);
+		if (level.legacy.legacyIndent !== void 0) attributes.push(`w:legacyIndent="${intAttr(level.legacy.legacyIndent)}"`);
+		legacy = attributes.length === 0 ? "<w:legacy/>" : `<w:legacy ${attributes.join(" ")}/>`;
 	}
-	if (level.lvlJc) parts.push(`<w:lvlJc w:val="${level.lvlJc}"/>`);
-	if (level.pPr) parts.push(serializeLevelParagraphProps(level.pPr));
-	parts.push(serializeTextFormatting(level.rPr));
-	return `<w:lvl w:ilvl="${intAttr(level.ilvl)}">${parts.join("")}</w:lvl>`;
+	const children = serializeSequenceChildren({
+		container: "w:lvl",
+		modelled: [
+			["start", level.start === void 0 ? "" : `<w:start w:val="${intAttr(level.start)}"/>`],
+			["numFmt", `<w:numFmt w:val="${escapeXmlAttribute(level.numFmt)}"${numFmtFormat}/>`],
+			["lvlRestart", level.lvlRestart === void 0 ? "" : `<w:lvlRestart w:val="${intAttr(level.lvlRestart)}"/>`],
+			["pStyle", level.pStyle === void 0 ? "" : `<w:pStyle w:val="${escapeXmlAttribute(level.pStyle)}"/>`],
+			["isLgl", serializeOnOffElement(level.isLgl, "isLgl")],
+			["suff", level.suffix === void 0 ? "" : `<w:suff w:val="${escapeXmlAttribute(level.suffix)}"/>`],
+			["lvlText", `<w:lvlText ${lvlTextAttrs.join(" ")}/>`],
+			["lvlPicBulletId", level.lvlPicBulletId === void 0 ? "" : `<w:lvlPicBulletId w:val="${intAttr(level.lvlPicBulletId)}"/>`],
+			["legacy", legacy],
+			["lvlJc", level.lvlJc === void 0 ? "" : `<w:lvlJc w:val="${escapeXmlAttribute(level.lvlJc)}"/>`],
+			["pPr", pPr],
+			["rPr", rPr]
+		],
+		preserved: level.preserved
+	});
+	const attributes = [`w:ilvl="${intAttr(level.ilvl)}"`];
+	if (level.tplc !== void 0) attributes.push(`w:tplc="${escapeXmlAttribute(level.tplc)}"`);
+	if (level.tentative !== void 0) attributes.push(`w:tentative="${level.tentative ? 1 : 0}"`);
+	return `<w:lvl ${serializePreservedAttributes(attributes, level.preservedAttributes).join(" ")}>${children.join("")}</w:lvl>`;
 }
-/**
-* Serialize one `w:abstractNum` (the reusable list template). Children follow
-* ECMA-376 §17.9.1 CT_AbstractNum order for the modeled subset (multiLevelType,
-* name, styleLink, numStyleLink, lvl+); `w:nsid` / `w:tmpl` are not modeled.
-*/
+/** Serialize one reusable `w:abstractNum` list template. */
 function serializeAbstractNum(abstractNum) {
-	const parts = [];
-	if (abstractNum.multiLevelType) parts.push(`<w:multiLevelType w:val="${abstractNum.multiLevelType}"/>`);
-	if (abstractNum.name !== void 0) parts.push(`<w:name w:val="${escapeXmlAttribute(abstractNum.name)}"/>`);
-	if (abstractNum.styleLink !== void 0) parts.push(`<w:styleLink w:val="${escapeXmlAttribute(abstractNum.styleLink)}"/>`);
-	if (abstractNum.numStyleLink !== void 0) parts.push(`<w:numStyleLink w:val="${escapeXmlAttribute(abstractNum.numStyleLink)}"/>`);
-	const levels = [...abstractNum.levels].sort((a, b) => a.ilvl - b.ilvl);
-	for (const level of levels) parts.push(serializeLevel(level));
-	return `<w:abstractNum w:abstractNumId="${intAttr(abstractNum.abstractNumId)}">${parts.join("")}</w:abstractNum>`;
+	const levels = [...abstractNum.levels].sort((left, right) => left.ilvl - right.ilvl);
+	const children = serializeSequenceChildren({
+		container: "w:abstractNum",
+		modelled: [
+			["nsid", abstractNum.nsid === void 0 ? "" : `<w:nsid w:val="${escapeXmlAttribute(abstractNum.nsid)}"/>`],
+			["multiLevelType", abstractNum.multiLevelType === void 0 ? "" : `<w:multiLevelType w:val="${escapeXmlAttribute(abstractNum.multiLevelType)}"/>`],
+			["tmpl", abstractNum.tmpl === void 0 ? "" : `<w:tmpl w:val="${escapeXmlAttribute(abstractNum.tmpl)}"/>`],
+			["name", abstractNum.name === void 0 ? "" : `<w:name w:val="${escapeXmlAttribute(abstractNum.name)}"/>`],
+			["styleLink", abstractNum.styleLink === void 0 ? "" : `<w:styleLink w:val="${escapeXmlAttribute(abstractNum.styleLink)}"/>`],
+			["numStyleLink", abstractNum.numStyleLink === void 0 ? "" : `<w:numStyleLink w:val="${escapeXmlAttribute(abstractNum.numStyleLink)}"/>`],
+			["lvl", levels.map(serializeLevel).join("")]
+		],
+		preserved: abstractNum.preserved
+	});
+	return `<w:abstractNum ${serializePreservedAttributes([`w:abstractNumId="${intAttr(abstractNum.abstractNumId)}"`], abstractNum.preservedAttributes).join(" ")}>${children.join("")}</w:abstractNum>`;
 }
-/**
-* Serialize one `w:num` (a concrete numbering instance referenced by `numId`).
-*/
+/** Serialize one concrete instance's per-level override. */
+function serializeLevelOverride(override) {
+	const children = serializeSequenceChildren({
+		container: "w:lvlOverride",
+		modelled: [["startOverride", override.startOverride === void 0 ? "" : `<w:startOverride w:val="${intAttr(override.startOverride)}"/>`], ["lvl", override.lvl === void 0 ? "" : serializeLevel(override.lvl)]],
+		preserved: override.preserved
+	});
+	return `<w:lvlOverride ${serializePreservedAttributes([`w:ilvl="${intAttr(override.ilvl)}"`], override.preservedAttributes).join(" ")}>${children.join("")}</w:lvlOverride>`;
+}
+/** Serialize one concrete `w:num` numbering instance. */
 function serializeNum(instance) {
-	const parts = [`<w:abstractNumId w:val="${intAttr(instance.abstractNumId)}"/>`];
-	for (const override of instance.levelOverrides ?? []) {
-		const overrideParts = [];
-		if (override.startOverride !== void 0) overrideParts.push(`<w:startOverride w:val="${intAttr(override.startOverride)}"/>`);
-		if (override.lvl) overrideParts.push(serializeLevel(override.lvl));
-		parts.push(`<w:lvlOverride w:ilvl="${intAttr(override.ilvl)}">${overrideParts.join("")}</w:lvlOverride>`);
-	}
-	return `<w:num w:numId="${intAttr(instance.numId)}">${parts.join("")}</w:num>`;
+	const children = serializeSequenceChildren({
+		container: "w:num",
+		modelled: [["abstractNumId", `<w:abstractNumId w:val="${intAttr(instance.abstractNumId)}"/>`], ["lvlOverride", (instance.levelOverrides ?? []).map(serializeLevelOverride).join("")]],
+		preserved: instance.preserved
+	});
+	return `<w:num ${serializePreservedAttributes([`w:numId="${intAttr(instance.numId)}"`], instance.preservedAttributes).join(" ")}>${children.join("")}</w:num>`;
 }
-/**
-* Serialize {@link NumberingDefinitions} to a complete `word/numbering.xml`
-* string. `w:abstractNum` elements precede `w:num` elements as ECMA-376 §17.9
-* requires. See the module note: this whole-part output is used only for
-* change detection and per-definition splicing, never to overwrite the part.
-*/
+/** Serialize a complete `word/numbering.xml` part. */
 function serializeNumberingXml(numbering) {
+	const children = serializeSequenceChildren({
+		container: "w:numbering",
+		modelled: [["abstractNum", numbering.abstractNums.map(serializeAbstractNum).join("")], ["num", numbering.nums.map(serializeNum).join("")]],
+		preserved: numbering.preserved
+	});
 	return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
 		partPath: "word/numbering.xml",
 		rootName: "w:numbering",
+		rootAttributes: serializePreservedAttributes([], numbering.preservedAttributes).join(" "),
 		baselinePrefixes: ["w"],
 		sourceBindings: void 0,
-		body: `${numbering.abstractNums.map(serializeAbstractNum).join("")}${numbering.nums.map(serializeNum).join("")}`
+		body: children.join("")
 	});
 }
 //#endregion

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

@@ -31,13 +31,5 @@ declare function createEmptyParagraph(formatting?: document_d_exports.ParagraphF
  * Create a paragraph with a single text run
  */
 declare function createTextParagraph(text: string, paragraphFormatting?: document_d_exports.ParagraphFormatting, textFormatting?: document_d_exports.TextFormatting): document_d_exports.Paragraph;
-/**
- * Check if paragraph is a list item
- */
-declare function isListParagraph(paragraph: document_d_exports.Paragraph): boolean;
-/**
- * Get list level of a paragraph (0-8, or -1 if not a list)
- */
-declare function getListLevel(paragraph: document_d_exports.Paragraph): number;
 //#endregion
-export { createEmptyParagraph, createTextParagraph, getListLevel, hasParagraphContent, hasParagraphFormatting, isListParagraph, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };
+export { createEmptyParagraph, createTextParagraph, hasParagraphContent, hasParagraphFormatting, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };