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

package/dist/docx/textBoxParser.d.ts

@@ -0,0 +1,117 @@
+import { document_d_exports } from "../types/document.js";
+import { NumberingMap } from "./numberingParser.js";
+import { StyleMap } from "./styleParser.js";
+import { XmlElement } from "./xmlParser.js";
+
+//#region src/docx/textBoxParser.d.ts
+/**
+ * Extract raw paragraph elements from w:txbxContent
+ * Actual parsing happens via document parser to avoid circular dependencies
+ */
+declare function extractTextBoxContentElements(txbxContent: XmlElement | null): {
+  paragraphElements: XmlElement[];
+  tableElements: XmlElement[];
+};
+/**
+ * Type for the paragraph parser function to avoid circular imports
+ */
+type ParagraphParserFn = (node: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null) => document_d_exports.Paragraph;
+/**
+ * Type for the table parser function to avoid circular imports
+ */
+type TableParserFn = (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>) => document_d_exports.Table;
+/**
+ * Parse text box content with provided parser functions
+ * This avoids circular dependencies by accepting parser functions as parameters
+ */
+declare function parseTextBoxContent(txbxContent: XmlElement | null, parseParagraph: ParagraphParserFn, parseTable: TableParserFn | null, 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>): document_d_exports.Paragraph[];
+/**
+ * Check if a drawing element contains a text box
+ * Text boxes are shapes with wps:txbx content
+ */
+declare function isTextBoxDrawing(drawingEl: XmlElement): boolean;
+/**
+ * Check if a wps:wsp element is a text box
+ */
+declare function isShapeTextBox(wsp: XmlElement): boolean;
+/**
+ * Parse a text box from a w:drawing element
+ *
+ * This creates a TextBox object with placeholder content.
+ * The actual content parsing requires paragraph/table parsers which
+ * creates a circular dependency. The document parser should call
+ * parseTextBoxContent() separately with the required parsers.
+ *
+ * @param drawingEl - The w:drawing XML element
+ * @returns TextBox object with placeholder content, or null if not a text box
+ */
+declare function parseTextBox(drawingEl: XmlElement): document_d_exports.TextBox | null;
+/**
+ * Parse text box content XML element
+ * @param wsp - The wps:wsp element containing the text box
+ * @returns The w:txbxContent element or null
+ */
+declare function getTextBoxContentElement(wsp: XmlElement): XmlElement | null;
+/**
+ * Parse text box from a wps:wsp element directly
+ * Useful when you already have the shape element
+ */
+declare function parseTextBoxFromShape(wsp: XmlElement, size: document_d_exports.ImageSize, position?: document_d_exports.ImagePosition, wrap?: document_d_exports.ImageWrap): document_d_exports.TextBox | null;
+/**
+ * Get text box width in pixels
+ */
+declare function getTextBoxWidthPx(textBox: document_d_exports.TextBox): number;
+/**
+ * Get text box height in pixels
+ */
+declare function getTextBoxHeightPx(textBox: document_d_exports.TextBox): number;
+/**
+ * Get text box dimensions in pixels
+ */
+declare function getTextBoxDimensionsPx(textBox: document_d_exports.TextBox): {
+  width: number;
+  height: number;
+};
+/**
+ * Get text box margins in pixels
+ */
+declare function getTextBoxMarginsPx(textBox: document_d_exports.TextBox): {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+};
+/**
+ * Check if text box is floating (anchored)
+ */
+declare function isFloatingTextBox(textBox: document_d_exports.TextBox): boolean;
+/**
+ * Check if text box has fill
+ */
+declare function hasTextBoxFill(textBox: document_d_exports.TextBox): boolean;
+/**
+ * Check if text box has outline
+ */
+declare function hasTextBoxOutline(textBox: document_d_exports.TextBox): boolean;
+/**
+ * Check if text box has content
+ */
+declare function hasTextBoxContent(textBox: document_d_exports.TextBox): boolean;
+/**
+ * Get plain text from text box (helper for search/indexing)
+ */
+declare function getTextBoxText(textBox: document_d_exports.TextBox): string;
+/**
+ * Resolve fill color to CSS color string
+ */
+declare function resolveTextBoxFillColor(textBox: document_d_exports.TextBox): string | undefined;
+/**
+ * Resolve outline color to CSS color string
+ */
+declare function resolveTextBoxOutlineColor(textBox: document_d_exports.TextBox): string | undefined;
+/**
+ * Get outline width in pixels
+ */
+declare function getTextBoxOutlineWidthPx(textBox: document_d_exports.TextBox): number;
+//#endregion
+export { ParagraphParserFn, TableParserFn, extractTextBoxContentElements, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxText, getTextBoxWidthPx, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, isFloatingTextBox, isShapeTextBox, isTextBoxDrawing, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, resolveTextBoxFillColor, resolveTextBoxOutlineColor };

package/dist/docx/textBoxParser.js

@@ -0,0 +1,262 @@
+import { findByFullName, findChildrenByLocalName, getAttribute, getChildElements, parseNumericAttribute } from "./xmlParser.js";
+import { emuToPixels } from "../utils/units.js";
+import { parseAnchorPosition, parseAnchorWrap, parseFill, parseOutline, resolveColorValueToHex } from "./drawingUtils.js";
+//#region src/docx/textBoxParser.ts
+/** Default text box margins in EMUs (0.1 inch) */
+const DEFAULT_MARGIN_EMU = 91440;
+/**
+* Parse text body properties from wps:bodyPr
+* Returns margins/insets for the text box
+*/
+function parseBodyProperties(bodyPr) {
+	if (!bodyPr) return {};
+	const result = {};
+	const lIns = parseNumericAttribute(bodyPr, null, "lIns");
+	const rIns = parseNumericAttribute(bodyPr, null, "rIns");
+	const tIns = parseNumericAttribute(bodyPr, null, "tIns");
+	const bIns = parseNumericAttribute(bodyPr, null, "bIns");
+	if (lIns !== void 0 || rIns !== void 0 || tIns !== void 0 || bIns !== void 0) result.margins = {
+		...lIns !== void 0 ? { left: lIns } : {},
+		...rIns !== void 0 ? { right: rIns } : {},
+		...tIns !== void 0 ? { top: tIns } : {},
+		...bIns !== void 0 ? { bottom: bIns } : {}
+	};
+	return result;
+}
+/**
+* Extract raw paragraph elements from w:txbxContent
+* Actual parsing happens via document parser to avoid circular dependencies
+*/
+function extractTextBoxContentElements(txbxContent) {
+	if (!txbxContent) return {
+		paragraphElements: [],
+		tableElements: []
+	};
+	return {
+		paragraphElements: findChildrenByLocalName(txbxContent, "p"),
+		tableElements: findChildrenByLocalName(txbxContent, "tbl")
+	};
+}
+/**
+* Parse text box content with provided parser functions
+* This avoids circular dependencies by accepting parser functions as parameters
+*/
+function parseTextBoxContent(txbxContent, parseParagraph, parseTable, styles, theme, numbering, rels, _media) {
+	if (!txbxContent) return [];
+	const paragraphs = [];
+	const children = getChildElements(txbxContent);
+	for (const child of children) {
+		const name = child.name || "";
+		const colonIdx = name.indexOf(":");
+		const localName = colonIdx !== -1 ? name.slice(colonIdx + 1) : name;
+		if (localName === "p") {
+			const paragraph = parseParagraph(child, styles, theme, numbering, rels);
+			paragraphs.push(paragraph);
+		} else if (localName === "tbl" && parseTable) {}
+	}
+	return paragraphs;
+}
+/**
+* Check if a drawing element contains a text box
+* Text boxes are shapes with wps:txbx content
+*/
+function isTextBoxDrawing(drawingEl) {
+	const container = getChildElements(drawingEl).find((el) => el.name === "wp:inline" || el.name === "wp:anchor");
+	if (!container) return false;
+	const graphic = findByFullName(container, "a:graphic");
+	if (!graphic) return false;
+	const graphicData = findByFullName(graphic, "a:graphicData");
+	if (!graphicData) return false;
+	const wsp = findByFullName(graphicData, "wps:wsp");
+	if (!wsp) return false;
+	return findByFullName(wsp, "wps:txbx") !== null;
+}
+/**
+* Check if a wps:wsp element is a text box
+*/
+function isShapeTextBox(wsp) {
+	return findByFullName(wsp, "wps:txbx") !== null;
+}
+/**
+* Parse a text box from a w:drawing element
+*
+* This creates a TextBox object with placeholder content.
+* The actual content parsing requires paragraph/table parsers which
+* creates a circular dependency. The document parser should call
+* parseTextBoxContent() separately with the required parsers.
+*
+* @param drawingEl - The w:drawing XML element
+* @returns TextBox object with placeholder content, or null if not a text box
+*/
+function parseTextBox(drawingEl) {
+	const container = getChildElements(drawingEl).find((el) => el.name === "wp:inline" || el.name === "wp:anchor");
+	if (!container) return null;
+	const isAnchor = container.name === "wp:anchor";
+	const graphic = findByFullName(container, "a:graphic");
+	if (!graphic) return null;
+	const graphicData = findByFullName(graphic, "a:graphicData");
+	if (!graphicData) return null;
+	const wsp = findByFullName(graphicData, "wps:wsp");
+	if (!wsp) return null;
+	if (!findByFullName(wsp, "wps:txbx")) return null;
+	const wspChildren = getChildElements(wsp);
+	const spPr = wspChildren.find((el) => el.name === "wps:spPr");
+	const bodyPr = wspChildren.find((el) => el.name === "wps:bodyPr");
+	const extent = findByFullName(container, "wp:extent");
+	const size = {
+		width: parseNumericAttribute(extent, null, "cx") ?? 0,
+		height: parseNumericAttribute(extent, null, "cy") ?? 0
+	};
+	const docPr = findByFullName(container, "wp:docPr");
+	const id = docPr ? getAttribute(docPr, null, "id") ?? void 0 : void 0;
+	const fill = parseFill(spPr ?? null);
+	const outline = parseOutline(spPr ?? null);
+	const bodyProps = parseBodyProperties(bodyPr ?? null);
+	const textBox = {
+		type: "textBox",
+		size,
+		content: []
+	};
+	if (id) textBox.id = id;
+	if (fill) textBox.fill = fill;
+	if (outline) textBox.outline = outline;
+	if (bodyProps.margins) textBox.margins = bodyProps.margins;
+	if (isAnchor) {
+		const position = parseAnchorPosition(container);
+		if (position) textBox.position = position;
+		const wrap = parseAnchorWrap(container);
+		if (wrap) textBox.wrap = wrap;
+	}
+	return textBox;
+}
+/**
+* Parse text box content XML element
+* @param wsp - The wps:wsp element containing the text box
+* @returns The w:txbxContent element or null
+*/
+function getTextBoxContentElement(wsp) {
+	const txbx = findByFullName(wsp, "wps:txbx");
+	if (!txbx) return null;
+	return findByFullName(txbx, "w:txbxContent");
+}
+/**
+* Parse text box from a wps:wsp element directly
+* Useful when you already have the shape element
+*/
+function parseTextBoxFromShape(wsp, size, position, wrap) {
+	if (!findByFullName(wsp, "wps:txbx")) return null;
+	const wspChildren = getChildElements(wsp);
+	const spPr = wspChildren.find((el) => el.name === "wps:spPr");
+	const bodyPr = wspChildren.find((el) => el.name === "wps:bodyPr");
+	const cNvPr = wspChildren.find((el) => el.name === "wps:cNvPr");
+	const id = cNvPr ? getAttribute(cNvPr, null, "id") ?? void 0 : void 0;
+	const fill = parseFill(spPr ?? null);
+	const outline = parseOutline(spPr ?? null);
+	const bodyProps = parseBodyProperties(bodyPr ?? null);
+	const textBox = {
+		type: "textBox",
+		size,
+		content: []
+	};
+	if (id) textBox.id = id;
+	if (fill) textBox.fill = fill;
+	if (outline) textBox.outline = outline;
+	if (bodyProps.margins) textBox.margins = bodyProps.margins;
+	if (position) textBox.position = position;
+	if (wrap) textBox.wrap = wrap;
+	return textBox;
+}
+/**
+* Get text box width in pixels
+*/
+function getTextBoxWidthPx(textBox) {
+	return emuToPixels(textBox.size.width);
+}
+/**
+* Get text box height in pixels
+*/
+function getTextBoxHeightPx(textBox) {
+	return emuToPixels(textBox.size.height);
+}
+/**
+* Get text box dimensions in pixels
+*/
+function getTextBoxDimensionsPx(textBox) {
+	return {
+		width: emuToPixels(textBox.size.width),
+		height: emuToPixels(textBox.size.height)
+	};
+}
+/**
+* Get text box margins in pixels
+*/
+function getTextBoxMarginsPx(textBox) {
+	const margins = textBox.margins;
+	return {
+		top: emuToPixels(margins?.top ?? DEFAULT_MARGIN_EMU),
+		bottom: emuToPixels(margins?.bottom ?? DEFAULT_MARGIN_EMU),
+		left: emuToPixels(margins?.left ?? DEFAULT_MARGIN_EMU),
+		right: emuToPixels(margins?.right ?? DEFAULT_MARGIN_EMU)
+	};
+}
+/**
+* Check if text box is floating (anchored)
+*/
+function isFloatingTextBox(textBox) {
+	return textBox.position !== void 0 || textBox.wrap !== void 0;
+}
+/**
+* Check if text box has fill
+*/
+function hasTextBoxFill(textBox) {
+	return textBox.fill !== void 0 && textBox.fill.type !== "none";
+}
+/**
+* Check if text box has outline
+*/
+function hasTextBoxOutline(textBox) {
+	return textBox.outline !== void 0;
+}
+/**
+* Check if text box has content
+*/
+function hasTextBoxContent(textBox) {
+	return textBox.content.length > 0;
+}
+/**
+* Get plain text from text box (helper for search/indexing)
+*/
+function getTextBoxText(textBox) {
+	const parts = [];
+	for (const paragraph of textBox.content) {
+		const runTexts = [];
+		for (const item of paragraph.content) if (item.type === "run") {
+			for (const content of item.content) if (content.type === "text") runTexts.push(content.text);
+		}
+		parts.push(runTexts.join(""));
+	}
+	return parts.join("\n");
+}
+/**
+* Resolve fill color to CSS color string
+*/
+function resolveTextBoxFillColor(textBox) {
+	if (!textBox.fill || textBox.fill.type !== "solid") return;
+	return resolveColorValueToHex(textBox.fill.color);
+}
+/**
+* Resolve outline color to CSS color string
+*/
+function resolveTextBoxOutlineColor(textBox) {
+	if (!textBox.outline?.color) return;
+	return resolveColorValueToHex(textBox.outline.color);
+}
+/**
+* Get outline width in pixels
+*/
+function getTextBoxOutlineWidthPx(textBox) {
+	if (!textBox.outline?.width) return 0;
+	return emuToPixels(textBox.outline.width);
+}
+//#endregion
+export { extractTextBoxContentElements, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxText, getTextBoxWidthPx, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, isFloatingTextBox, isShapeTextBox, isTextBoxDrawing, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, resolveTextBoxFillColor, resolveTextBoxOutlineColor };

package/dist/docx/themeParser.d.ts

@@ -0,0 +1,77 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/themeParser.d.ts
+/**
+ * Parse theme1.xml content
+ *
+ * @param themeXml - XML content of theme1.xml, or null if not present
+ * @returns Parsed Theme object with colors and fonts
+ */
+declare function parseTheme(themeXml: string | null): document_d_exports.Theme;
+/**
+ * Resolve empty EastAsian/complex-script theme font slots using the document's
+ * `w:themeFontLang` (port of eigenpal/docx-editor#949).
+ *
+ * Office's default theme leaves `<a:ea typeface="">`/`<a:cs typeface="">` empty
+ * and instead lists the real typeface per script (`<a:font script="Jpan" …>`).
+ * Word selects among those by the language declared in `w:themeFontLang`. A run
+ * that references `minorEastAsia` in a Japanese document then resolves to
+ * `ＭＳ 明朝` rather than an empty string — an empty font breaks both line-break
+ * measurement and CJK rendering, so text overflows the right margin.
+ *
+ * Mutates the theme in place; the original `theme1.xml` is preserved verbatim on
+ * save, so this only affects the in-memory model used for layout/rendering.
+ */
+declare function applyThemeFontLang(theme: document_d_exports.Theme | null | undefined, themeFontLang: {
+  eastAsia?: string;
+  bidi?: string;
+} | undefined): void;
+/**
+ * Get a color from the theme by slot name
+ *
+ * @param theme - Parsed theme
+ * @param slot - Color slot name (dk1, lt1, accent1, etc.)
+ * @returns Hex color value (6 characters, no #)
+ */
+declare function getThemeColor(theme: document_d_exports.Theme | null | undefined, slot: keyof document_d_exports.ThemeColorScheme): string;
+/**
+ * Get the major font (heading font) from theme
+ *
+ * @param theme - Parsed theme
+ * @param script - Optional script code (defaults to latin)
+ * @returns Font family name
+ */
+declare function getMajorFont(theme: document_d_exports.Theme | null | undefined, script?: string): string;
+/**
+ * Get the minor font (body font) from theme
+ *
+ * @param theme - Parsed theme
+ * @param script - Optional script code (defaults to latin)
+ * @returns Font family name
+ */
+declare function getMinorFont(theme: document_d_exports.Theme | null | undefined, script?: string): string;
+/**
+ * Resolve a theme font reference to an actual font name
+ *
+ * Theme font references are like: majorAscii, majorHAnsi, minorAscii, minorHAnsi, etc.
+ *
+ * @param theme - Parsed theme
+ * @param themeRef - Theme font reference
+ * @returns Font family name
+ */
+declare function resolveThemeFontRef(theme: document_d_exports.Theme | null | undefined, themeRef: string): string;
+/**
+ * Get all font families from the theme for preloading
+ *
+ * @param theme - Parsed theme
+ * @returns Array of unique font family names
+ */
+declare function getThemeFonts(theme: document_d_exports.Theme | null | undefined): string[];
+/**
+ * Get the default theme (Office 2016 theme)
+ *
+ * @returns Default Theme object
+ */
+declare function getDefaultTheme(): document_d_exports.Theme;
+//#endregion
+export { applyThemeFontLang, getDefaultTheme, getMajorFont, getMinorFont, getThemeColor, getThemeFonts, parseTheme, resolveThemeFontRef };