officeparser 6.1.1 → 7.0.1

package/dist/generators/RtfGenerator.d.ts

@@ -0,0 +1,15 @@
+import { ConversionResult, GeneratorConfig, OfficeContentNode, OfficeParserAST } from '../types.js';
+import { BaseGenerator } from './BaseGenerator.js';
+/**
+ * Generates high-fidelity RTF (Rich Text Format) from an AST.
+ */
+export declare class RtfGenerator extends BaseGenerator<'rtf'> {
+    private colorTable;
+    private inTable;
+    constructor(ast: OfficeParserAST, config?: GeneratorConfig<'rtf'>);
+    generate(): Promise<ConversionResult>;
+    protected processNodeRecursive(node: OfficeContentNode, processor: (node: OfficeContentNode, childrenOutput: string) => Promise<string>): Promise<string>;
+    private renderBody;
+    private getColorIndex;
+    private escapeRtf;
+}

package/dist/generators/RtfGenerator.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtfGenerator = void 0;
+const BaseGenerator_js_1 = require("./BaseGenerator.js");
+/**
+ * Generates high-fidelity RTF (Rich Text Format) from an AST.
+ */
+class RtfGenerator extends BaseGenerator_js_1.BaseGenerator {
+    colorTable = [];
+    inTable = false;
+    constructor(ast, config) {
+        super('rtf', ast, config);
+    }
+    async generate() {
+        this.colorTable = [];
+        // We first process all nodes to collect colors
+        const bodyContent = await this.renderBody(this.ast);
+        let output = '{\\rtf1\\ansi\\deff0\n';
+        // 1. Info Group (Metadata)
+        if (this.config.renderMetadata && this.ast.metadata) {
+            output += '{\\info';
+            if (this.ast.metadata.title)
+                output += `{\\title ${this.escapeRtf(this.ast.metadata.title)}}`;
+            if (this.ast.metadata.author)
+                output += `{\\author ${this.escapeRtf(this.ast.metadata.author)}}`;
+            if (this.ast.metadata.description)
+                output += `{\\comm ${this.escapeRtf(this.ast.metadata.description)}}`;
+            output += '}\n';
+        }
+        // 2. Font Table
+        output += '{\\fonttbl{\\f0\\fnil\\fcharset0 Arial;}{\\f1\\fnil\\fcharset0 Times New Roman;}}\n';
+        // 3. Color Table
+        if (this.colorTable.length > 0) {
+            output += '{\\colortbl;';
+            for (const hex of this.colorTable) {
+                const r = parseInt(hex.substring(1, 3), 16);
+                const g = parseInt(hex.substring(3, 5), 16);
+                const b = parseInt(hex.substring(5, 7), 16);
+                output += `\\red${r}\\green${g}\\blue${b};`;
+            }
+            output += '}\n';
+        }
+        // 4. Body
+        output += '\\f0\\fs24\n';
+        output += bodyContent;
+        output += '}';
+        return {
+            value: output,
+            messages: this.messages
+        };
+    }
+    async processNodeRecursive(node, processor) {
+        const wasInTable = this.inTable;
+        if (node.type === 'table')
+            this.inTable = true;
+        const result = await super.processNodeRecursive(node, processor);
+        this.inTable = wasInTable;
+        return result;
+    }
+    async renderBody(ast) {
+        let body = '';
+        this.inTable = false;
+        const processor = async (node, childrenOutput) => {
+            // Handle Semantic Style Mapping for RTF using the semantic mapping helper
+            const mapping = this.getSemanticMapping(node);
+            if (mapping) {
+                if (mapping.tag === 'blockquote') {
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\li720\\ri720\\sa120 ${childrenOutput}\\par\n`;
+                }
+                const hMatch = mapping.tag.match(/^h([1-6])$/);
+                if (hMatch) {
+                    const level = parseInt(hMatch[1]);
+                    const fontSize = 24 + (6 - level) * 4;
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\s${level}\\sb240\\sa120{\\b\\fs${fontSize} ${childrenOutput}}\\par\n`;
+                }
+            }
+            switch (node.type) {
+                case 'text': {
+                    let text = this.escapeRtf(node.text || '');
+                    const f = node.formatting;
+                    const meta = node.metadata;
+                    if (this.config.includeFormatting && f) {
+                        let prefix = '';
+                        let suffix = '';
+                        if (f.bold) {
+                            prefix += '\\b ';
+                            suffix = '\\b0 ' + suffix;
+                        }
+                        if (f.italic) {
+                            prefix += '\\i ';
+                            suffix = '\\i0 ' + suffix;
+                        }
+                        if (f.underline) {
+                            prefix += '\\ul ';
+                            suffix = '\\ul0 ' + suffix;
+                        }
+                        if (f.strikethrough) {
+                            prefix += '\\strike ';
+                            suffix = '\\strike0 ' + suffix;
+                        }
+                        if (f.color) {
+                            const idx = this.getColorIndex(f.color);
+                            prefix += `\\cf${idx + 1} `;
+                        }
+                        if (f.backgroundColor) {
+                            const idx = this.getColorIndex(f.backgroundColor);
+                            prefix += `\\highlight${idx + 1} `;
+                        }
+                        if (f.size) {
+                            const pt = parseInt(f.size);
+                            prefix += `\\fs${pt * 2} `;
+                        }
+                        text = `{\\rtlch\\f1 ${prefix}${text}${suffix}}`;
+                    }
+                    if (meta?.link) {
+                        const isInternal = meta.linkType !== 'external';
+                        if (!this.config.ignoreInternalLinks || !isInternal) {
+                            return `{\\field{\\*\\fldinst{HYPERLINK "${meta.link}"}}{\\fldrslt ${text}}}`;
+                        }
+                    }
+                    return text;
+                }
+                case 'heading': {
+                    const meta = node.metadata;
+                    const level = meta?.level || 1;
+                    const fontSize = 24 + (6 - level) * 4;
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\s${level}\\sb240\\sa120{\\b\\fs${fontSize} ${childrenOutput}}\\par\n`;
+                }
+                case 'paragraph': {
+                    let pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    pPr += '\\sa120';
+                    if (this.config.includeFormatting && node.metadata) {
+                        const meta = node.metadata;
+                        if (meta.alignment) {
+                            if (meta.alignment === 'center')
+                                pPr += '\\qc';
+                            else if (meta.alignment === 'right')
+                                pPr += '\\qr';
+                            else if (meta.alignment === 'justify')
+                                pPr += '\\qj';
+                        }
+                        if (meta.paragraphIndentation) {
+                            const ind = meta.paragraphIndentation;
+                            if (ind.left)
+                                pPr += `\\li${ind.left}`;
+                            if (ind.right)
+                                pPr += `\\ri${ind.right}`;
+                            if (ind.firstLine)
+                                pPr += `\\fi${ind.firstLine}`;
+                        }
+                    }
+                    return `${pPr} ${childrenOutput}\\par\n`;
+                }
+                case 'list': {
+                    const meta = node.metadata;
+                    const indent = ((meta?.indentation || 0) + 1) * 360;
+                    const isOrdered = meta?.listType === 'ordered';
+                    const marker = isOrdered ? `${(meta.itemIndex ?? 0) + 1}. ` : '\\bullet ';
+                    const listControl = isOrdered ? '\\pndec' : '\\pnbullet';
+                    const level = meta?.indentation || 0;
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\li${indent}\\fi-360\\ilvl${level}${listControl} ${marker}${childrenOutput}\\par\n`;
+                }
+                case 'table': {
+                    return `\\pard\\sa0\n${childrenOutput}`;
+                }
+                case 'row': {
+                    return `\\trowd\\trgaph108\\trleft-108\n${childrenOutput}\\row\n`;
+                }
+                case 'cell': {
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\intbl\\sb60\\sa60 ${childrenOutput}\\cell\n`;
+                }
+                case 'break': {
+                    return node.metadata?.breakType === 'page' ? '\\page\n' : '\\line\n';
+                }
+                default:
+                    return childrenOutput;
+            }
+        };
+        for (const node of ast.content) {
+            body += await this.processNodeRecursive(node, processor);
+        }
+        return body;
+    }
+    getColorIndex(hex) {
+        const h = hex.toUpperCase();
+        let idx = this.colorTable.indexOf(h);
+        if (idx === -1) {
+            idx = this.colorTable.length;
+            this.colorTable.push(h);
+        }
+        return idx;
+    }
+    escapeRtf(text) {
+        return text
+            .replace(/\\/g, '\\\\')
+            .replace(/{/g, '\\{')
+            .replace(/}/g, '\\}')
+            .replace(/[^\x00-\x7F]/g, (match) => {
+            return `\\u${match.charCodeAt(0)}?`;
+        });
+    }
+}
+exports.RtfGenerator = RtfGenerator;

package/dist/generators/TextGenerator.d.ts

@@ -0,0 +1,13 @@
+import { ConversionResult, GeneratorConfig, OfficeParserAST } from '../types.js';
+import { BaseGenerator } from './BaseGenerator.js';
+/**
+ * Generates plain text from an AST.
+ */
+export declare class TextGenerator extends BaseGenerator<'text'> {
+    constructor(ast: OfficeParserAST, config?: GeneratorConfig<'text'>);
+    /**
+     * Generates plain text by concatenating text content from nodes.
+     */
+    generate(): Promise<ConversionResult>;
+    private renderTable;
+}

package/dist/generators/TextGenerator.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextGenerator = void 0;
+const BaseGenerator_js_1 = require("./BaseGenerator.js");
+/**
+ * Generates plain text from an AST.
+ */
+class TextGenerator extends BaseGenerator_js_1.BaseGenerator {
+    constructor(ast, config) {
+        super('text', ast, config);
+    }
+    /**
+     * Generates plain text by concatenating text content from nodes.
+     */
+    async generate() {
+        let output = '';
+        const newline = this.config.textConfig.newlineDelimiter;
+        // Add Metadata Header
+        if (this.config.renderMetadata && this.ast.metadata) {
+            if (this.ast.metadata.title)
+                output += `Title: ${this.ast.metadata.title}${newline}`;
+            if (this.ast.metadata.author)
+                output += `Author: ${this.ast.metadata.author}${newline}`;
+            if (this.ast.metadata.created)
+                output += `Created: ${new Date(this.ast.metadata.created).toLocaleString()}${newline}`;
+            output += `-------------------${newline}${newline}`;
+        }
+        const processor = async (node, childrenOutput) => {
+            // Return raw text for text nodes
+            if (node.type === 'text' || node.type === 'code') {
+                return node.text || '';
+            }
+            // Handle explicit breaks
+            if (node.type === 'break') {
+                return newline;
+            }
+            if (node.type === 'image') {
+                if (!this.config.includeImages)
+                    return '';
+                const meta = node.metadata;
+                return `[Image: ${meta?.altText || meta?.attachmentName || 'Untitled'}]${newline}`;
+            }
+            if (node.type === 'table' && this.config.textConfig.preserveLayout) {
+                return await this.renderTable(node, processor, newline);
+            }
+            if (node.type === 'list' && this.config.textConfig.preserveLayout) {
+                const meta = node.metadata;
+                const indentSpaces = ' '.repeat(4);
+                const indent = indentSpaces.repeat(meta?.indentation || 0);
+                const marker = meta?.listType === 'ordered' ? `${(meta.itemIndex ?? 0) + 1}. ` : '- ';
+                return `${indent}${marker}${childrenOutput.trimStart()}` + (childrenOutput.endsWith(newline) ? '' : newline);
+            }
+            // Append newline for block-level elements to maintain structure
+            const blockTypes = ['paragraph', 'heading', 'row', 'sheet', 'slide', 'note', 'list', 'table', 'code'];
+            if (blockTypes.includes(node.type)) {
+                if (childrenOutput.trim() === '')
+                    return '';
+                return childrenOutput + (childrenOutput.endsWith(newline) ? '' : newline);
+            }
+            return childrenOutput;
+        };
+        for (const node of this.ast.content) {
+            output += await this.processNodeRecursive(node, processor);
+        }
+        return {
+            value: output.trim(),
+            messages: this.messages
+        };
+    }
+    async renderTable(node, processor, newline) {
+        if (!node.children || node.children.length === 0)
+            return '';
+        const rows = [];
+        const colWidths = [];
+        for (const rowNode of node.children) {
+            // Manual check for onNode in table rows since we are bypassing processNodeRecursive for rows here
+            const override = await this.handleOnNode(rowNode);
+            if (override === false)
+                continue;
+            if (typeof override === 'string') {
+                rows.push([override]);
+                continue;
+            }
+            const row = [];
+            if (rowNode.children) {
+                for (let i = 0; i < rowNode.children.length; i++) {
+                    const cellNode = rowNode.children[i];
+                    const cellText = (await this.processNodeRecursive(cellNode, processor))
+                        .trim()
+                        .replace(/\r?\n/g, ' ');
+                    row.push(cellText);
+                    colWidths[i] = Math.max(colWidths[i] || 0, cellText.length);
+                }
+            }
+            rows.push(row);
+        }
+        let tableOutput = newline;
+        for (const row of rows) {
+            tableOutput += '| ';
+            for (let i = 0; i < row.length; i++) {
+                tableOutput += (row[i] || '').padEnd(colWidths[i] || 0) + ' | ';
+            }
+            tableOutput += newline;
+        }
+        return tableOutput + newline;
+    }
+}
+exports.TextGenerator = TextGenerator;

package/dist/index.d.ts

@@ -7,8 +7,9 @@
  * **Supported Formats:**
  * - Microsoft Office: DOCX, XLSX, PPTX (Office Open XML)
  * - OpenDocument: ODT, ODP, ODS (ODF)
- * - Legacy: RTF (Rich Text Format)
  * - Portable: PDF
+ * - Legacy: RTF (Rich Text Format)
+ * - Web/Plain: CSV, MD, HTML
  *
  * **Key Features:**
  * - Unified AST output across all formats
@@ -35,17 +36,24 @@
  *
  * **Main Exports:**
  * - `OfficeParser` - Main parser class
+ * - `OfficeGenerator` - Main generator class for document conversion
  * - `OfficeParserConfig` - Configuration interface
+ * - `GeneratorConfig` - Generator configuration interface
  * - `OfficeParserAST` - AST result interface
  * - `OfficeContentNode` - Content tree node interface
  * - All type definitions
+
  *
  * @packageDocumentation
  * @module officeparser
  */
 import { OfficeParser } from './OfficeParser.js';
-import { OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata } from './types';
+import { OfficeGenerator } from './OfficeGenerator.js';
+import { OfficeConverter } from './OfficeConverter.js';
+import { OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverterConfig, OfficeErrorType, OfficeWarningType, ConversionResult } from './types.js';
 declare const parseOffice: typeof OfficeParser.parseOffice;
 declare const terminateOcr: typeof OfficeParser.terminateOcr;
-export { OfficeParser, parseOffice, terminateOcr, OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, };
+declare const convert: typeof OfficeConverter.convert;
+declare const generate: typeof OfficeGenerator.generate;
+export { OfficeParser, parseOffice, terminateOcr, OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, OfficeGenerator, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverter, OfficeConverterConfig, convert, generate, OfficeErrorType, OfficeWarningType, ConversionResult, };
 export default OfficeParser;

package/dist/index.js

@@ -8,8 +8,9 @@
  * **Supported Formats:**
  * - Microsoft Office: DOCX, XLSX, PPTX (Office Open XML)
  * - OpenDocument: ODT, ODP, ODS (ODF)
- * - Legacy: RTF (Rich Text Format)
  * - Portable: PDF
+ * - Legacy: RTF (Rich Text Format)
+ * - Web/Plain: CSV, MD, HTML
  *
  * **Key Features:**
  * - Unified AST output across all formats
@@ -36,21 +37,35 @@
  *
  * **Main Exports:**
  * - `OfficeParser` - Main parser class
+ * - `OfficeGenerator` - Main generator class for document conversion
  * - `OfficeParserConfig` - Configuration interface
+ * - `GeneratorConfig` - Generator configuration interface
  * - `OfficeParserAST` - AST result interface
  * - `OfficeContentNode` - Content tree node interface
  * - All type definitions
+
  *
  * @packageDocumentation
  * @module officeparser
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.terminateOcr = exports.parseOffice = exports.OfficeParser = void 0;
+exports.OfficeWarningType = exports.OfficeErrorType = exports.generate = exports.convert = exports.OfficeConverter = exports.OfficeGenerator = exports.terminateOcr = exports.parseOffice = exports.OfficeParser = void 0;
 const OfficeParser_js_1 = require("./OfficeParser.js");
 Object.defineProperty(exports, "OfficeParser", { enumerable: true, get: function () { return OfficeParser_js_1.OfficeParser; } });
+const OfficeGenerator_js_1 = require("./OfficeGenerator.js");
+Object.defineProperty(exports, "OfficeGenerator", { enumerable: true, get: function () { return OfficeGenerator_js_1.OfficeGenerator; } });
+const OfficeConverter_js_1 = require("./OfficeConverter.js");
+Object.defineProperty(exports, "OfficeConverter", { enumerable: true, get: function () { return OfficeConverter_js_1.OfficeConverter; } });
+const types_js_1 = require("./types.js");
+Object.defineProperty(exports, "OfficeErrorType", { enumerable: true, get: function () { return types_js_1.OfficeErrorType; } });
+Object.defineProperty(exports, "OfficeWarningType", { enumerable: true, get: function () { return types_js_1.OfficeWarningType; } });
 const parseOffice = OfficeParser_js_1.OfficeParser.parseOffice;
 exports.parseOffice = parseOffice;
 const terminateOcr = OfficeParser_js_1.OfficeParser.terminateOcr;
 exports.terminateOcr = terminateOcr;
+const convert = OfficeConverter_js_1.OfficeConverter.convert;
+exports.convert = convert;
+const generate = OfficeGenerator_js_1.OfficeGenerator.generate;
+exports.generate = generate;
 // Default export for backward compatibility
 exports.default = OfficeParser_js_1.OfficeParser;

package/dist/index.mjs

@@ -11,8 +11,8 @@
 import _module from './index.js';
 
 // Named exports
-const { OfficeParser, parseOffice, terminateOcr } = _module;
-export { OfficeParser, parseOffice, terminateOcr };
+const { OfficeParser, parseOffice, terminateOcr, OfficeGenerator, OfficeConverter, convert, generate, OfficeErrorType, OfficeWarningType } = _module;
+export { OfficeParser, parseOffice, terminateOcr, OfficeGenerator, OfficeConverter, convert, generate, OfficeErrorType, OfficeWarningType };
 
 // Default export
 export default _module.default ?? _module;