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

package/dist/docx/runConsolidator.d.ts

@@ -0,0 +1,57 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/runConsolidator.d.ts
+/**
+ * Check if two TextFormatting objects are equivalent
+ *
+ * Uses deep comparison of all properties to determine if runs
+ * can be merged without losing formatting information.
+ */
+declare function formattingEquals(a: document_d_exports.TextFormatting | undefined, b: document_d_exports.TextFormatting | undefined): boolean;
+/**
+ * Check if a run contains only text content
+ * (runs with special content like images, fields, etc. should not be merged)
+ */
+declare function isTextOnlyRun(run: document_d_exports.Run): boolean;
+/**
+ * Check if a run can be merged with another run
+ * Runs with breaks, tabs, images, fields, etc. act as merge boundaries
+ */
+declare function canMergeRun(run: document_d_exports.Run): boolean;
+/**
+ * Consolidate an array of runs by merging consecutive runs with identical formatting
+ *
+ * @param runs - Array of runs to consolidate
+ * @returns Consolidated array with fewer, larger runs
+ */
+declare function consolidateRuns(runs: document_d_exports.Run[]): document_d_exports.Run[];
+/**
+ * Consolidate runs within a paragraph content array
+ *
+ * This handles the full paragraph structure, consolidating runs while
+ * preserving hyperlinks, bookmarks, and fields as merge boundaries.
+ */
+declare function consolidateParagraphContent(content: document_d_exports.Hyperlink["children"]): document_d_exports.Hyperlink["children"];
+declare function consolidateParagraphContent(content: document_d_exports.ParagraphContent[]): document_d_exports.ParagraphContent[];
+/**
+ * Consolidate all runs within a paragraph
+ *
+ * @param paragraph - Paragraph to consolidate
+ * @returns New paragraph with consolidated runs
+ */
+declare function consolidateParagraph(paragraph: document_d_exports.Paragraph): document_d_exports.Paragraph;
+/**
+ * Get the number of runs in a paragraph (for debugging/metrics)
+ */
+declare function countRuns(paragraph: document_d_exports.Paragraph): number;
+/**
+ * Calculate the consolidation ratio (reduction in number of runs)
+ * Useful for debugging and metrics
+ */
+declare function getConsolidationStats(originalParagraphs: document_d_exports.Paragraph[], consolidatedParagraphs: document_d_exports.Paragraph[]): {
+  originalRunCount: number;
+  consolidatedRunCount: number;
+  reductionPercentage: number;
+};
+//#endregion
+export { canMergeRun, consolidateParagraph, consolidateParagraphContent, consolidateRuns, countRuns, formattingEquals, getConsolidationStats, isTextOnlyRun };

package/dist/docx/runConsolidator.js

@@ -0,0 +1,224 @@
+//#region src/docx/runConsolidator.ts
+/**
+* Check if two TextFormatting objects are equivalent
+*
+* Uses deep comparison of all properties to determine if runs
+* can be merged without losing formatting information.
+*/
+function formattingEquals(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	if (a.bold !== b.bold) return false;
+	if (a.boldCs !== b.boldCs) return false;
+	if (a.italic !== b.italic) return false;
+	if (a.italicCs !== b.italicCs) return false;
+	if (a.strike !== b.strike) return false;
+	if (a.doubleStrike !== b.doubleStrike) return false;
+	if (a.smallCaps !== b.smallCaps) return false;
+	if (a.allCaps !== b.allCaps) return false;
+	if (a.hidden !== b.hidden) return false;
+	if (a.emboss !== b.emboss) return false;
+	if (a.imprint !== b.imprint) return false;
+	if (a.outline !== b.outline) return false;
+	if (a.shadow !== b.shadow) return false;
+	if (a.rtl !== b.rtl) return false;
+	if (a.cs !== b.cs) return false;
+	if (a.fontSize !== b.fontSize) return false;
+	if (a.fontSizeCs !== b.fontSizeCs) return false;
+	if (a.spacing !== b.spacing) return false;
+	if (a.position !== b.position) return false;
+	if (a.scale !== b.scale) return false;
+	if (a.kerning !== b.kerning) return false;
+	if (a.vertAlign !== b.vertAlign) return false;
+	if (a.highlight !== b.highlight) return false;
+	if (a.effect !== b.effect) return false;
+	if (a.emphasisMark !== b.emphasisMark) return false;
+	if (a.styleId !== b.styleId) return false;
+	if (!underlineEquals(a.underline, b.underline)) return false;
+	if (!colorEquals(a.color, b.color)) return false;
+	if (!shadingEquals(a.shading, b.shading)) return false;
+	if (!fontFamilyEquals(a.fontFamily, b.fontFamily)) return false;
+	return true;
+}
+/**
+* Compare underline settings
+*/
+function underlineEquals(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	if (a.style !== b.style) return false;
+	return colorEquals(a.color, b.color);
+}
+/**
+* Compare color values
+*/
+function colorEquals(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	return a.rgb === b.rgb && a.auto === b.auto && a.themeColor === b.themeColor && a.themeTint === b.themeTint && a.themeShade === b.themeShade;
+}
+/**
+* Compare shading properties
+*/
+function shadingEquals(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	if (a.pattern !== b.pattern) return false;
+	if (!colorEquals(a.color, b.color)) return false;
+	if (!colorEquals(a.fill, b.fill)) return false;
+	return true;
+}
+/**
+* Compare font family settings
+*/
+function fontFamilyEquals(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	return a.ascii === b.ascii && a.hAnsi === b.hAnsi && a.eastAsia === b.eastAsia && a.cs === b.cs && a.asciiTheme === b.asciiTheme && a.hAnsiTheme === b.hAnsiTheme && a.eastAsiaTheme === b.eastAsiaTheme && a.csTheme === b.csTheme;
+}
+/**
+* Check if a run contains only text content
+* (runs with special content like images, fields, etc. should not be merged)
+*/
+function isTextOnlyRun(run) {
+	return run.content.every((c) => c.type === "text" || c.type === "softHyphen" || c.type === "noBreakHyphen");
+}
+/**
+* Check if run content can be merged (simple text types)
+*/
+function isMergeableContent(content) {
+	return content.type === "text" || content.type === "softHyphen" || content.type === "noBreakHyphen";
+}
+/**
+* Check if a run can be merged with another run
+* Runs with breaks, tabs, images, fields, etc. act as merge boundaries
+*/
+function canMergeRun(run) {
+	if (run.content.length === 0) return true;
+	return run.content.every(isMergeableContent);
+}
+/**
+* Merge the content of two runs into a single content array
+*/
+function mergeRunContent(content1, content2) {
+	const result = [];
+	for (const c of content1) result.push(c);
+	const lastText = result.at(-1);
+	const firstText = content2[0];
+	if (lastText?.type === "text" && firstText?.type === "text") {
+		result[result.length - 1] = {
+			type: "text",
+			text: lastText.text + firstText.text,
+			...lastText.preserveSpace || firstText.preserveSpace ? { preserveSpace: true } : {}
+		};
+		for (let i = 1; i < content2.length; i++) result.push(content2[i]);
+	} else for (const c of content2) result.push(c);
+	return result;
+}
+/**
+* Consolidate an array of runs by merging consecutive runs with identical formatting
+*
+* @param runs - Array of runs to consolidate
+* @returns Consolidated array with fewer, larger runs
+*/
+function consolidateRuns(runs) {
+	if (runs.length <= 1) return runs;
+	const result = [];
+	let current = null;
+	for (const run of runs) {
+		if (run.content.length === 0) {
+			if (current !== null) {
+				result.push(current);
+				current = null;
+			}
+			continue;
+		}
+		if (current === null) {
+			current = {
+				...run,
+				content: [...run.content]
+			};
+			continue;
+		}
+		if (canMergeRun(current) && canMergeRun(run) && formattingEquals(current.formatting, run.formatting)) current = {
+			type: "run",
+			...current.formatting !== void 0 ? { formatting: current.formatting } : {},
+			content: mergeRunContent(current.content, run.content)
+		};
+		else {
+			result.push(current);
+			current = {
+				...run,
+				content: [...run.content]
+			};
+		}
+	}
+	if (current !== null) result.push(current);
+	return result;
+}
+function consolidateParagraphContent(content) {
+	if (content.length <= 1) return content;
+	const result = [];
+	const pendingRuns = [];
+	function flushRuns() {
+		if (pendingRuns.length > 0) {
+			const consolidated = consolidateRuns(pendingRuns);
+			result.push(...consolidated);
+			pendingRuns.length = 0;
+		}
+	}
+	for (const item of content) if (item.type === "run") pendingRuns.push(item);
+	else {
+		flushRuns();
+		if (item.type === "hyperlink") {
+			const hyperlink = {
+				...item,
+				children: consolidateParagraphContent(item.children)
+			};
+			result.push(hyperlink);
+		} else result.push(item);
+	}
+	flushRuns();
+	return result;
+}
+/**
+* Consolidate all runs within a paragraph
+*
+* @param paragraph - Paragraph to consolidate
+* @returns New paragraph with consolidated runs
+*/
+function consolidateParagraph(paragraph) {
+	if (paragraph.content.length === 0) return paragraph;
+	return {
+		...paragraph,
+		content: consolidateParagraphContent(paragraph.content)
+	};
+}
+/**
+* Get the number of runs in a paragraph (for debugging/metrics)
+*/
+function countRuns(paragraph) {
+	let count = 0;
+	function countInContent(content) {
+		for (const item of content) if (item.type === "run") count++;
+		else if (item.type === "hyperlink") countInContent(item.children);
+	}
+	countInContent(paragraph.content);
+	return count;
+}
+/**
+* Calculate the consolidation ratio (reduction in number of runs)
+* Useful for debugging and metrics
+*/
+function getConsolidationStats(originalParagraphs, consolidatedParagraphs) {
+	const originalCount = originalParagraphs.reduce((sum, p) => sum + countRuns(p), 0);
+	const consolidatedCount = consolidatedParagraphs.reduce((sum, p) => sum + countRuns(p), 0);
+	const reduction = originalCount > 0 ? (originalCount - consolidatedCount) / originalCount * 100 : 0;
+	return {
+		originalRunCount: originalCount,
+		consolidatedRunCount: consolidatedCount,
+		reductionPercentage: Math.round(reduction * 10) / 10
+	};
+}
+//#endregion
+export { canMergeRun, consolidateParagraph, consolidateParagraphContent, consolidateRuns, countRuns, formattingEquals, getConsolidationStats, isTextOnlyRun };

package/dist/docx/runParser.d.ts

@@ -0,0 +1,78 @@
+import { document_d_exports } from "../types/document.js";
+import { StyleMap } from "./styleParser.js";
+import { XmlElement } from "./xmlParser.js";
+
+//#region src/docx/runParser.d.ts
+/**
+ * Parse run formatting properties (w:rPr)
+ *
+ * Handles ALL rPr properties:
+ * - w:b (bold), w:i (italic), w:u (underline with style)
+ * - w:strike (strikethrough), w:dstrike (double strike)
+ * - w:vertAlign (superscript/subscript)
+ * - w:smallCaps, w:caps (capitalization)
+ * - w:highlight (text highlight color)
+ * - w:shd (character shading)
+ * - w:color (text color with theme resolution)
+ * - w:sz (font size in half-points)
+ * - w:rFonts (font family with theme resolution)
+ * - w:spacing (character spacing)
+ * - w:effect (text effects)
+ * - And more...
+ */
+declare function parseRunProperties(rPr: XmlElement | null, theme: document_d_exports.Theme | null, _styles?: StyleMap): document_d_exports.TextFormatting | undefined;
+/**
+ * Parse a run element (w:r)
+ *
+ * @param node - The w:r XML element
+ * @param styles - Style map for resolving style references
+ * @param theme - Theme for resolving theme colors/fonts
+ * @param rels - Relationship map for resolving image references
+ * @param media - Media files map for image data
+ * @returns Parsed Run object
+ */
+declare function parseRun(node: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null, rootXmlns?: Record<string, string>): document_d_exports.Run;
+/**
+ * Get plain text from a run
+ *
+ * @param run - Parsed Run object
+ * @returns Concatenated text content
+ */
+declare function getRunText(run: document_d_exports.Run): string;
+/**
+ * Check if a run contains any actual content
+ *
+ * @param run - Parsed Run object
+ * @returns true if run has visible content
+ */
+declare function hasContent(run: document_d_exports.Run): boolean;
+/**
+ * Check if a run contains a drawing/image
+ *
+ * @param run - Parsed Run object
+ * @returns true if run contains an image
+ */
+declare function hasImage(run: document_d_exports.Run): boolean;
+/**
+ * Get all images from a run
+ *
+ * @param run - Parsed Run object
+ * @returns Array of Image objects
+ */
+declare function getImages(run: document_d_exports.Run): document_d_exports.Image[];
+/**
+ * Check if a run is part of a complex field
+ *
+ * @param run - Parsed Run object
+ * @returns true if run contains field characters
+ */
+declare function hasFieldChar(run: document_d_exports.Run): boolean;
+/**
+ * Get field character type if present
+ *
+ * @param run - Parsed Run object
+ * @returns Field character type or null
+ */
+declare function getFieldCharType(run: document_d_exports.Run): "begin" | "separate" | "end" | null;
+//#endregion
+export { getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, parseRun, parseRunProperties };