@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/docx/serializer/noteSerializer.js

@@ -0,0 +1,70 @@
+import { serializeBlockSdt } from "./blockSdtSerializer.js";
+import { serializeParagraph } from "./paragraphSerializer.js";
+import { serializeTable } from "./tableSerializer.js";
+//#region src/docx/serializer/noteSerializer.ts
+const NAMESPACES = {
+	wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+	mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+	o: "urn:schemas-microsoft-com:office:office",
+	r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+	m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+	v: "urn:schemas-microsoft-com:vml",
+	a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+	pic: "http://schemas.openxmlformats.org/drawingml/2006/picture",
+	wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+	wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+	w10: "urn:schemas-microsoft-com:office:word",
+	w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+	w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+	w15: "http://schemas.microsoft.com/office/word/2012/wordml",
+	w16: "http://schemas.microsoft.com/office/word/2018/wordml",
+	w16cex: "http://schemas.microsoft.com/office/word/2018/wordml/cex",
+	w16cid: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
+	w16sdtdh: "http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash",
+	w16se: "http://schemas.microsoft.com/office/word/2015/wordml/symex",
+	wpg: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+	wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
+};
+function buildNamespaceDeclarations() {
+	return Object.entries(NAMESPACES).map(([prefix, uri]) => `xmlns:${prefix}="${uri}"`).join(" ");
+}
+/**
+* Serialize a block content item (paragraph, table, or block-level SDT) for a
+* note body.
+*/
+function serializeBlock(block) {
+	if (block.type === "paragraph") return serializeParagraph(block);
+	if (block.type === "table") return serializeTable(block);
+	return serializeBlockSdt(block, serializeBlock);
+}
+/**
+* Serialize a single note element. Footnotes and endnotes share the same
+* structure, differing only in the wrapper element name.
+*/
+function serializeNote(elementName, note) {
+	const attrs = [];
+	if (note.noteType && note.noteType !== "normal") attrs.push(`w:type="${note.noteType}"`);
+	attrs.push(`w:id="${note.id}"`);
+	const body = note.content.map((block) => serializeBlock(block)).join("");
+	return `<w:${elementName} ${attrs.join(" ")}>${body}</w:${elementName}>`;
+}
+/**
+* Serialize footnotes to a complete word/footnotes.xml string.
+*
+* @param footnotes - Notes to serialize (the model's normal footnotes).
+* @returns Complete footnotes.xml string.
+*/
+function serializeFootnotes(footnotes) {
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:footnotes ${buildNamespaceDeclarations()} mc:Ignorable="w14 w15 wp14">${footnotes.map((fn) => serializeNote("footnote", fn)).join("")}</w:footnotes>`;
+}
+/**
+* Serialize endnotes to a complete word/endnotes.xml string.
+*
+* @param endnotes - Notes to serialize (the model's normal endnotes).
+* @returns Complete endnotes.xml string.
+*/
+function serializeEndnotes(endnotes) {
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:endnotes ${buildNamespaceDeclarations()} mc:Ignorable="w14 w15 wp14">${endnotes.map((en) => serializeNote("endnote", en)).join("")}</w:endnotes>`;
+}
+//#endregion
+export { serializeEndnotes, serializeFootnotes };

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

@@ -0,0 +1,12 @@
+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.
+ */
+declare function serializeNumberingXml(numbering: document_d_exports.NumberingDefinitions): string;
+//#endregion
+export { serializeNumberingXml };

package/dist/docx/serializer/numberingSerializer.js

@@ -0,0 +1,93 @@
+import { escapeXml, intAttr } from "./xmlUtils.js";
+import { serializeTextFormatting } from "./runSerializer.js";
+//#region src/docx/serializer/numberingSerializer.ts
+const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+/**
+* 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.
+*/
+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="${escapeXml(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="${escapeXml(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(" ")}/>`);
+	}
+	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>`;
+}
+/**
+* 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.
+*/
+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="${escapeXml(abstractNum.name)}"/>`);
+	if (abstractNum.styleLink !== void 0) parts.push(`<w:styleLink w:val="${escapeXml(abstractNum.styleLink)}"/>`);
+	if (abstractNum.numStyleLink !== void 0) parts.push(`<w:numStyleLink w:val="${escapeXml(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>`;
+}
+/**
+* Serialize one `w:num` (a concrete numbering instance referenced by `numId`).
+*/
+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>`;
+}
+/**
+* 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.
+*/
+function serializeNumberingXml(numbering) {
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:numbering xmlns:w="${W_NS}">${numbering.abstractNums.map(serializeAbstractNum).join("")}${numbering.nums.map(serializeNum).join("")}</w:numbering>`;
+}
+//#endregion
+export { serializeNumberingXml };

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

@@ -0,0 +1,48 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/paragraphSerializer.d.ts
+declare function serializeParagraphFormatting(formatting: document_d_exports.ParagraphFormatting | undefined, propertyChanges?: document_d_exports.ParagraphPropertyChange[], pPrMark?: document_d_exports.ParagraphMarkChange): string;
+/**
+ * Serialize a paragraph to OOXML XML (w:p)
+ *
+ * @param paragraph - The paragraph to serialize
+ * @returns XML string for the paragraph
+ */
+declare function serializeParagraph(paragraph: document_d_exports.Paragraph): string;
+/**
+ * Serialize multiple paragraphs to OOXML XML
+ *
+ * @param paragraphs - The paragraphs to serialize
+ * @returns XML string for all paragraphs
+ */
+declare function serializeParagraphs(paragraphs: document_d_exports.Paragraph[]): string;
+/**
+ * Check if a paragraph has any content
+ */
+declare function hasParagraphContent(paragraph: document_d_exports.Paragraph): boolean;
+/**
+ * Check if a paragraph has formatting
+ */
+declare function hasParagraphFormatting(paragraph: document_d_exports.Paragraph): boolean;
+/**
+ * Get plain text from a paragraph (for comparison/debugging)
+ */
+declare function getParagraphPlainText(paragraph: document_d_exports.Paragraph): string;
+/**
+ * Create an empty paragraph
+ */
+declare function createEmptyParagraph(formatting?: document_d_exports.ParagraphFormatting): document_d_exports.Paragraph;
+/**
+ * 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, getParagraphPlainText, hasParagraphContent, hasParagraphFormatting, isListParagraph, serializeParagraph, serializeParagraphFormatting, serializeParagraphs };