@stll/folio-core 0.47.7 → 0.49.0

package/dist/docx/packageParts.js

@@ -3,9 +3,25 @@ import { resolveRelativePath } from "./relsParser.js";
 const CONTENT_TYPE_ELEMENT = /<(?:Default|Override)\b[^>]*?\/?>/giu;
 const PART_NAME_ATTRIBUTE = /\bPartName\s*=\s*(?<quote>["'])(?<value>[^"']*)\k<quote>/u;
 const RELATIONSHIP_ELEMENT = /<Relationship\b[^>]*?(?:\/>|>\s*<\/Relationship>)/giu;
+const RELATIONSHIP_ID_ATTRIBUTE = /\bId\s*=\s*(?<quote>["'])(?<value>[^"']*)\k<quote>/u;
 const TARGET_ATTRIBUTE = /\bTarget\s*=\s*(?<quote>["'])(?<value>[^"']*)\k<quote>/u;
 const TARGET_MODE_ATTRIBUTE = /\bTargetMode\s*=\s*(?<quote>["'])(?<value>[^"']*)\k<quote>/u;
 const CONTENT_TYPES_PATTERN = /^\[Content_Types\]\.xml$/iu;
+/** Escape a string for literal use inside a `RegExp`. */
+const escapeRegExp = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+/**
+* The XML part a `.rels` part describes: `word/_rels/header1.xml.rels` ->
+* `word/header1.xml`; the package-level `_rels/.rels` has no single owning
+* part (its relationships are resolved by type, never by `r:id`), so it maps
+* to `undefined`.
+*/
+const owningPartPath = (relsPath) => {
+	const slash = relsPath.lastIndexOf("/_rels/");
+	if (slash === -1) return;
+	const directory = relsPath.slice(0, slash);
+	const fileName = relsPath.slice(slash + 7).replace(/\.rels$/iu, "");
+	return fileName ? `${directory ? `${directory}/` : ""}${fileName}` : void 0;
+};
 /** Normalize a package path for comparison: lower case, no leading slash. */
 const normalizePartPath = (path) => (path.startsWith("/") ? path.slice(1) : path).toLowerCase();
 /**
@@ -80,8 +96,10 @@ const reconcilePackageReferences = async (zip, compressionLevel) => {
 	const present = presentPartPaths(zip);
 	const repair = {
 		danglingRelationships: [],
-		danglingOverrides: []
+		danglingOverrides: [],
+		orphanedIdReferences: []
 	};
+	const removedIdsByOwningPart = /* @__PURE__ */ new Map();
 	for (const { path, xml } of await readRelationshipParts(zip)) {
 		let dropped = false;
 		const pruned = xml.replaceAll(RELATIONSHIP_ELEMENT, (element) => {
@@ -89,6 +107,13 @@ const reconcilePackageReferences = async (zip, compressionLevel) => {
 			if (target === null || isPresent(present, target)) return element;
 			repair.danglingRelationships.push(target);
 			dropped = true;
+			const id = RELATIONSHIP_ID_ATTRIBUTE.exec(element)?.groups?.["value"];
+			const owningPart = owningPartPath(path);
+			if (id !== void 0 && owningPart !== void 0) {
+				const ids = removedIdsByOwningPart.get(owningPart) ?? /* @__PURE__ */ new Set();
+				ids.add(id);
+				removedIdsByOwningPart.set(owningPart, ids);
+			}
 			return "";
 		});
 		if (dropped) writePart({
@@ -98,6 +123,28 @@ const reconcilePackageReferences = async (zip, compressionLevel) => {
 			compressionLevel
 		});
 	}
+	for (const [partPath, ids] of removedIdsByOwningPart) {
+		const file = zip.file(partPath);
+		if (!file) continue;
+		const idPattern = [...ids].map((id) => escapeRegExp(id)).join("|");
+		const referencePattern = new RegExp(`\\s+r:[A-Za-z]+\\s*=\\s*(?<quote>["'])(?<id>${idPattern})\\k<quote>`, "gu");
+		const xml = await file.async("text");
+		const removedIds = /* @__PURE__ */ new Set();
+		const scrubbed = xml.replaceAll(referencePattern, (...args) => {
+			const groups = args.at(-1);
+			if (groups?.id !== void 0) removedIds.add(groups.id);
+			return "";
+		});
+		if (removedIds.size > 0) {
+			writePart({
+				zip,
+				path: partPath,
+				xml: scrubbed,
+				compressionLevel
+			});
+			for (const id of removedIds) repair.orphanedIdReferences.push(`${partPath}|${id}`);
+		}
+	}
 	const contentTypes = zip.file(CONTENT_TYPES_PATTERN)[0];
 	if (!contentTypes) return repair;
 	let droppedOverride = false;
@@ -116,5 +163,49 @@ const reconcilePackageReferences = async (zip, compressionLevel) => {
 	});
 	return repair;
 };
+/** Every `r:*`-style attribute value found anywhere in an XML part's text. */
+const REFERENCE_ATTRIBUTE = /\br:[A-Za-z]+\s*=\s*(?<quote>["'])(?<id>[^"']*)\k<quote>/gu;
+/**
+* Verify the two invariants an OPC package must hold for a conforming
+* consumer to accept it: every `r:*` reference in an XML part resolves in
+* that part's own `.rels`, and every internal relationship target names a
+* part the package actually holds.
+*
+* A read-only counterpart to {@link reconcilePackageReferences} — that
+* function repairs a package by removing what does not resolve; this one
+* only reports what still does not, so a test can assert a save produced
+* nothing for it to find. Cheap enough to run after every repack in a test
+* or a corpus-gate invariant: one pass over the `.rels` parts building an id
+* census, one pass over the XML parts checking references against it.
+*/
+const checkPackageIntegrity = async (zip) => {
+	const present = presentPartPaths(zip);
+	const report = {
+		unresolvedReferences: [],
+		danglingRelationshipTargets: []
+	};
+	const idsByOwningPart = /* @__PURE__ */ new Map();
+	for (const { path, xml } of await readRelationshipParts(zip)) {
+		const owningPart = owningPartPath(path);
+		const ids = /* @__PURE__ */ new Set();
+		for (const element of xml.match(RELATIONSHIP_ELEMENT) ?? []) {
+			const id = RELATIONSHIP_ID_ATTRIBUTE.exec(element)?.groups?.["value"];
+			if (id !== void 0) ids.add(id);
+			const target = relationshipTarget(element, path);
+			if (target !== null && !isPresent(present, target)) report.danglingRelationshipTargets.push(`${path}|${target}`);
+		}
+		if (owningPart !== void 0) idsByOwningPart.set(owningPart, ids);
+	}
+	for (const [path, file] of Object.entries(zip.files)) {
+		if (file.dir || !normalizePartPath(path).endsWith(".xml")) continue;
+		const xml = await file.async("text");
+		const ids = idsByOwningPart.get(path);
+		for (const match of xml.matchAll(REFERENCE_ATTRIBUTE)) {
+			const id = match.groups?.["id"];
+			if (id !== void 0 && !ids?.has(id)) report.unresolvedReferences.push(`${path}|${id}`);
+		}
+	}
+	return report;
+};
 //#endregion
-export { isUnsafePackagePath, reconcilePackageReferences, removeUnsafeEntries };
+export { checkPackageIntegrity, isUnsafePackagePath, reconcilePackageReferences, removeUnsafeEntries };

package/dist/docx/paraIdAttribute.d.ts

@@ -85,8 +85,9 @@ declare const alignParagraphOrdinals: (base: readonly ParagraphIdentity[], revis
  * describe one document — the source part and the model parsed from it — so
  * {@link alignParagraphOrdinals}'s `consistent` is the whole of the question: a
  * package with ids on some paragraphs proves its own alignment through them,
- * and one with none is aligned vacuously behind the paragraph-count check the
- * caller already runs.
+ * and one with none is aligned exactly when the two sequences have the same
+ * length. The save asks this per story (main flow, text boxes), so a text box
+ * the model re-reads cannot misalign the main flow.
  */
 type ParagraphIdentityPlan = {
   identities: readonly ParagraphIdentity[];

package/dist/docx/paragraphParser.d.ts

@@ -1,12 +1,15 @@
 import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
 import { XmlElement } from "./xmlParser.js";
+import { PreviewLedger } from "./previewBudget.js";
 import { StyleMap } from "./styleParser.js";
 //#region src/docx/paragraphParser.d.ts
 declare function parseParagraphPropertyChanges(pPr: XmlElement | null, theme: document_d_exports.Theme | null, currentFormatting: document_d_exports.ParagraphFormatting | undefined): document_d_exports.ParagraphPropertyChange[] | undefined;
 type ParseParagraphOptions = {
   inHeaderFooter?: boolean;
   rootXmlns?: Record<string, string>;
+  /** The ledger of the package this paragraph belongs to. */
+  previews: PreviewLedger;
   /** Delay run merging until a source-position-dependent enrichment pass completes. */
   runConsolidation?: "immediate" | "deferred";
 };
@@ -19,7 +22,8 @@ type ParseParagraphOptions = {
  * @param numbering - Numbering definitions for list info
  * @param rels - Relationship map for resolving hyperlink URLs
  * @param media - Media files map for image data
- * @param options - Parsing options for context-specific body behavior
+ * @param options - Parsing options for context-specific body behavior; a
+ *   paragraph read without them charges its previews to no package
  * @returns Parsed Paragraph object
  */
 declare function parseParagraph(node: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null, options?: ParseParagraphOptions): document_d_exports.Paragraph;