@wonderwhy-er/desktop-commander 0.2.33 → 0.2.35

package/dist/tools/docx/structure.js

@@ -0,0 +1,102 @@
+/**
+ * DOCX Structure Parser and Builder
+ *
+ * Provides structure-preserving parsing and building of DOCX files.
+ * This approach maintains tables, images, and formatting at the DOCX element level,
+ * avoiding lossy markdown round-trips.
+ */
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+// @ts-ignore
+import * as docx from 'docx';
+const { Document, Packer } = docx;
+import { DocxError, DocxErrorCode, withErrorContext } from './errors.js';
+import { createZipFromBuffer, readZipFileText, } from './parsers/zip-reader.js';
+import { parseXml, getElementChildren, extractRelationshipMap, getHeadingLevelFromParagraph, } from './parsers/xml-parser.js';
+import { extractImagesFromZip } from './parsers/image-extractor.js';
+import { parseParagraphElement } from './parsers/paragraph-parser.js';
+import { parseTableElement } from './parsers/table-parser.js';
+/**
+ * Parse a DOCX file into structured elements that can be manipulated and rebuilt
+ *
+ * @param buffer - DOCX file buffer
+ * @returns Structured representation of the DOCX document
+ * @throws {DocxError} If the DOCX file is invalid or cannot be parsed
+ */
+export async function parseDocxStructure(buffer) {
+    return withErrorContext(async () => {
+        const zip = createZipFromBuffer(buffer);
+        const documentXml = readZipFileText(zip, 'word/document.xml');
+        if (!documentXml) {
+            throw new DocxError('Invalid DOCX file: word/document.xml not found', DocxErrorCode.INVALID_DOCX, {});
+        }
+        const relsXml = readZipFileText(zip, 'word/_rels/document.xml.rels');
+        const relMap = extractRelationshipMap(relsXml);
+        // Extract all images
+        const images = extractImagesFromZip(zip, relMap);
+        // Parse document body
+        const doc = parseXml(documentXml);
+        const body = doc.getElementsByTagName('w:body')[0];
+        if (!body) {
+            throw new DocxError('Invalid DOCX file: <w:body> not found', DocxErrorCode.INVALID_DOCX_XML, {});
+        }
+        // Parse all elements
+        const elements = [];
+        const children = getElementChildren(body);
+        for (const child of children) {
+            const nodeName = child.nodeName;
+            if (nodeName === 'w:p') {
+                const headingLevel = getHeadingLevelFromParagraph(child);
+                const para = parseParagraphElement(child, images, headingLevel);
+                if (para) {
+                    if (headingLevel) {
+                        elements.push({
+                            type: 'heading',
+                            level: headingLevel,
+                            content: para,
+                        });
+                    }
+                    else {
+                        elements.push({
+                            type: 'paragraph',
+                            content: para,
+                        });
+                    }
+                }
+            }
+            else if (nodeName === 'w:tbl') {
+                const table = parseTableElement(child, images);
+                if (table) {
+                    elements.push({
+                        type: 'table',
+                        content: table,
+                    });
+                }
+            }
+        }
+        return {
+            elements,
+            images,
+            relationships: relMap,
+        };
+    }, DocxErrorCode.DOCX_READ_FAILED, { bufferSize: buffer.length });
+}
+/**
+ * Build a DOCX file from structured elements
+ *
+ * @param structure - Structured DOCX representation
+ * @returns Buffer containing the DOCX file
+ * @throws {DocxError} If document building fails
+ */
+export async function buildDocxFromStructure(structure) {
+    return withErrorContext(async () => {
+        const children = structure.elements.map(el => el.content);
+        const doc = new Document({
+            sections: [{
+                    properties: {},
+                    children: children,
+                }],
+        });
+        return await Packer.toBuffer(doc);
+    }, DocxErrorCode.DOCX_CREATE_FAILED, { elementCount: structure.elements.length });
+}

package/dist/tools/docx/styled-html-parser.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Direct DOCX XML → Styled HTML Parser
+ *
+ * Parses the raw DOCX XML and produces HTML with full inline style preservation
+ * (font colours, sizes, families, text alignment, highlights, bold/italic/underline,
+ * images, hyperlinks, tables, and lists).
+ *
+ * mammoth.js deliberately strips visual styling; this parser fills that gap.
+ *
+ * @module docx/styled-html-parser
+ */
+import type { DocxImage, DocxDocumentDefaults } from './types.js';
+/**
+ * Convert a DOCX buffer to styled HTML by parsing the DOCX XML directly.
+ *
+ * Bypasses mammoth.js to preserve all inline styles (colours, fonts, sizes,
+ * alignment, highlights, bold/italic/underline, images, hyperlinks, tables).
+ */
+export declare function convertDocxToStyledHtml(buffer: Buffer, includeImages?: boolean): Promise<{
+    html: string;
+    images: DocxImage[];
+    documentDefaults: DocxDocumentDefaults;
+}>;