docxmlater 10.4.0 → 11.0.4

package/dist/esm/processors/ChangelogGenerator.js

@@ -0,0 +1,970 @@
+import { getGlobalLogger, createScopedLogger } from '../utils/logger.js';
+function getLogger() {
+    return createScopedLogger(getGlobalLogger(), 'ChangelogGenerator');
+}
+export class ChangelogGenerator {
+    static fromDocument(doc, options) {
+        const revisionManager = doc.getRevisionManager();
+        if (!revisionManager) {
+            return [];
+        }
+        const revisions = revisionManager.getAllRevisions();
+        return this.fromRevisions(revisions, options, doc);
+    }
+    static fromRevisions(revisions, options, _doc) {
+        const logger = getLogger();
+        const opts = {
+            includeFormattingChanges: true,
+            consolidate: false,
+            maxContextLength: 50,
+            ...options,
+        };
+        logger.debug('Processing revisions', {
+            total: revisions.length,
+            filters: {
+                categories: opts.filterCategories?.length ?? 0,
+                authors: opts.filterAuthors?.length ?? 0,
+                dateRange: !!opts.filterDateRange,
+            },
+        });
+        const entries = [];
+        let filtered = 0;
+        for (let i = 0; i < revisions.length; i++) {
+            const revision = revisions[i];
+            if (!revision)
+                continue;
+            const category = this.categorize(revision);
+            if (opts.filterCategories && !opts.filterCategories.includes(category)) {
+                filtered++;
+                continue;
+            }
+            if (!opts.includeFormattingChanges && category === 'formatting') {
+                filtered++;
+                continue;
+            }
+            if (opts.filterAuthors && !opts.filterAuthors.includes(revision.getAuthor())) {
+                filtered++;
+                continue;
+            }
+            if (opts.filterDateRange) {
+                const revDate = revision.getDate();
+                if (revDate < opts.filterDateRange.start || revDate > opts.filterDateRange.end) {
+                    filtered++;
+                    continue;
+                }
+            }
+            const entry = this.revisionToEntry(revision, i, opts.maxContextLength);
+            entries.push(entry);
+        }
+        if (filtered > 0) {
+            logger.debug('Revisions filtered', { included: entries.length, filtered });
+        }
+        return entries;
+    }
+    static revisionToEntry(revision, index, maxContextLength) {
+        const type = revision.getType();
+        const category = this.categorize(revision);
+        const runs = revision.getRuns();
+        const text = runs.map((r) => r.getText()).join('');
+        const truncatedText = text.length > maxContextLength ? text.substring(0, maxContextLength) + '...' : text;
+        const content = {};
+        if (type === 'insert' || type === 'moveTo') {
+            content.after = truncatedText;
+        }
+        else if (type === 'delete' || type === 'moveFrom') {
+            content.before = truncatedText;
+        }
+        else if (this.isPropertyChangeType(type)) {
+            content.affectedText = truncatedText;
+        }
+        const prevProps = revision.getPreviousProperties();
+        const newProps = revision.getNewProperties();
+        if (type === 'hyperlinkChange' && (prevProps || newProps)) {
+            content.hyperlinkChange = {
+                urlBefore: prevProps?.url,
+                urlAfter: newProps?.url,
+                textBefore: prevProps?.text,
+                textAfter: newProps?.text,
+            };
+            if (prevProps?.url !== newProps?.url) {
+                content.before = prevProps?.url;
+                content.after = newProps?.url;
+            }
+            else if (prevProps?.text !== newProps?.text) {
+                content.before = prevProps?.text;
+                content.after = newProps?.text;
+            }
+        }
+        let propertyChange;
+        if (prevProps || newProps) {
+            const allKeys = new Set([...Object.keys(prevProps || {}), ...Object.keys(newProps || {})]);
+            const firstKey = Array.from(allKeys)[0];
+            if (firstKey) {
+                propertyChange = {
+                    property: firstKey,
+                    oldValue: this.formatPropertyValue(prevProps?.[firstKey]),
+                    newValue: this.formatPropertyValue(newProps?.[firstKey]),
+                };
+            }
+        }
+        const revisionLocation = revision.getLocation();
+        const location = {
+            paragraphIndex: revisionLocation?.paragraphIndex ?? index,
+            sectionIndex: revisionLocation?.sectionIndex,
+            runIndex: revisionLocation?.runIndex,
+        };
+        return {
+            id: revision.getId().toString(),
+            revisionType: type,
+            category,
+            description: this.describeRevision(revision, maxContextLength),
+            author: revision.getAuthor(),
+            date: revision.getDate(),
+            location,
+            content,
+            propertyChange,
+        };
+    }
+    static getSummary(entries) {
+        const byCategory = {
+            content: 0,
+            formatting: 0,
+            structural: 0,
+            table: 0,
+            hyperlink: 0,
+            image: 0,
+            field: 0,
+            comment: 0,
+            bookmark: 0,
+            contentControl: 0,
+        };
+        const byType = {};
+        const byAuthor = {};
+        let earliest = null;
+        let latest = null;
+        for (const entry of entries) {
+            byCategory[entry.category]++;
+            byType[entry.revisionType] = (byType[entry.revisionType] || 0) + 1;
+            byAuthor[entry.author] = (byAuthor[entry.author] || 0) + 1;
+            if (!earliest || entry.date < earliest) {
+                earliest = entry.date;
+            }
+            if (!latest || entry.date > latest) {
+                latest = entry.date;
+            }
+        }
+        return {
+            total: entries.length,
+            byCategory,
+            byType,
+            byAuthor,
+            dateRange: earliest && latest ? { earliest, latest } : null,
+        };
+    }
+    static consolidate(entries) {
+        const groups = new Map();
+        for (const entry of entries) {
+            let key = `${entry.revisionType}_${entry.category}`;
+            if (entry.propertyChange) {
+                key += `_${entry.propertyChange.property}_${entry.propertyChange.newValue || ''}`;
+            }
+            key += `_${entry.author}`;
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key).push(entry);
+        }
+        const consolidated = [];
+        for (const [_, groupEntries] of groups) {
+            const first = groupEntries[0];
+            if (!first)
+                continue;
+            let description;
+            if (groupEntries.length === 1) {
+                description = first.description;
+            }
+            else {
+                description = this.generateConsolidatedDescription(groupEntries);
+            }
+            consolidated.push({
+                description,
+                count: groupEntries.length,
+                category: first.category,
+                commonAttributes: {
+                    author: this.allSame(groupEntries.map((e) => e.author)) ? first.author : undefined,
+                    revisionType: first.revisionType,
+                    propertyChanged: first.propertyChange?.property,
+                    newValue: first.propertyChange?.newValue,
+                },
+                changeIds: groupEntries.map((e) => e.id),
+            });
+        }
+        consolidated.sort((a, b) => b.count - a.count);
+        if (entries.length > 0) {
+            getLogger().info('Entries consolidated', {
+                input: entries.length,
+                groups: consolidated.length,
+                reduction: `${Math.round((1 - consolidated.length / entries.length) * 100)}%`,
+            });
+        }
+        return consolidated;
+    }
+    static generateConsolidatedDescription(entries) {
+        const first = entries[0];
+        if (!first) {
+            return `${entries.length} changes`;
+        }
+        const count = entries.length;
+        switch (first.revisionType) {
+            case 'insert':
+                return `Inserted text in ${count} locations`;
+            case 'delete':
+                return `Deleted text from ${count} locations`;
+            case 'moveFrom':
+            case 'moveTo':
+                return `Moved content (${count} operations)`;
+            case 'runPropertiesChange':
+                if (first.propertyChange) {
+                    return `Changed ${first.propertyChange.property} to "${first.propertyChange.newValue}" (${count} times)`;
+                }
+                return `Changed run formatting (${count} times)`;
+            case 'paragraphPropertiesChange':
+                if (first.propertyChange) {
+                    return `Changed paragraph ${first.propertyChange.property} (${count} times)`;
+                }
+                return `Changed paragraph formatting (${count} times)`;
+            case 'tablePropertiesChange':
+            case 'tableRowPropertiesChange':
+            case 'tableCellPropertiesChange':
+                return `Changed table formatting (${count} times)`;
+            case 'tableCellInsert':
+                return `Inserted ${count} table cells`;
+            case 'tableCellDelete':
+                return `Deleted ${count} table cells`;
+            case 'tableCellMerge':
+                return `Merged table cells (${count} operations)`;
+            case 'numberingChange':
+                return `Changed list numbering (${count} times)`;
+            case 'sectionPropertiesChange':
+                return `Changed section properties (${count} times)`;
+            default:
+                return `${count} changes of type ${first.revisionType}`;
+        }
+    }
+    static allSame(arr) {
+        if (arr.length === 0)
+            return true;
+        const first = arr[0];
+        return arr.every((v) => v === first);
+    }
+    static categorize(revision) {
+        const type = revision.getType();
+        switch (type) {
+            case 'insert':
+            case 'delete':
+                return 'content';
+            case 'moveFrom':
+            case 'moveTo':
+            case 'sectionPropertiesChange':
+                return 'structural';
+            case 'runPropertiesChange':
+            case 'paragraphPropertiesChange':
+            case 'numberingChange':
+                return 'formatting';
+            case 'tablePropertiesChange':
+            case 'tableExceptionPropertiesChange':
+            case 'tableRowPropertiesChange':
+            case 'tableCellPropertiesChange':
+            case 'tableCellInsert':
+            case 'tableCellDelete':
+            case 'tableCellMerge':
+                return 'table';
+            case 'hyperlinkChange':
+                return 'hyperlink';
+            case 'imageChange':
+                return 'image';
+            case 'fieldChange':
+                return 'field';
+            case 'commentChange':
+                return 'comment';
+            case 'bookmarkChange':
+                return 'bookmark';
+            case 'contentControlChange':
+                return 'contentControl';
+            default:
+                return 'content';
+        }
+    }
+    static isPropertyChangeType(type) {
+        return [
+            'runPropertiesChange',
+            'paragraphPropertiesChange',
+            'tablePropertiesChange',
+            'tableExceptionPropertiesChange',
+            'tableRowPropertiesChange',
+            'tableCellPropertiesChange',
+            'sectionPropertiesChange',
+            'numberingChange',
+        ].includes(type);
+    }
+    static describeRevision(revision, maxLength = 50) {
+        const type = revision.getType();
+        const runs = revision.getRuns();
+        const text = runs.map((r) => r.getText()).join('');
+        const excerpt = text.length > maxLength ? `"${text.substring(0, maxLength)}..."` : text ? `"${text}"` : '';
+        switch (type) {
+            case 'insert':
+                return excerpt ? `Inserted ${excerpt}` : 'Inserted content';
+            case 'delete':
+                return excerpt ? `Deleted ${excerpt}` : 'Deleted content';
+            case 'moveFrom':
+                return excerpt ? `Moved ${excerpt} from here` : 'Moved content from here';
+            case 'moveTo':
+                return excerpt ? `Moved ${excerpt} to here` : 'Moved content to here';
+            case 'runPropertiesChange':
+                return this.describePropertyChange(revision, 'run formatting');
+            case 'paragraphPropertiesChange':
+                return this.describePropertyChange(revision, 'paragraph formatting');
+            case 'tablePropertiesChange':
+                return 'Changed table properties';
+            case 'tableExceptionPropertiesChange':
+                return 'Changed table exception properties';
+            case 'tableRowPropertiesChange':
+                return 'Changed table row properties';
+            case 'tableCellPropertiesChange':
+                return 'Changed table cell properties';
+            case 'sectionPropertiesChange':
+                return 'Changed section properties';
+            case 'tableCellInsert':
+                return 'Inserted table cell';
+            case 'tableCellDelete':
+                return 'Deleted table cell';
+            case 'tableCellMerge':
+                return 'Merged table cells';
+            case 'numberingChange':
+                return 'Changed list numbering';
+            case 'hyperlinkChange':
+                return this.describeHyperlinkChange(revision, maxLength);
+            case 'imageChange':
+                return this.describeImageChange(revision);
+            case 'fieldChange':
+                return this.describeFieldChange(revision);
+            case 'commentChange':
+                return this.describeCommentChange(revision);
+            case 'bookmarkChange':
+                return this.describeBookmarkChange(revision);
+            case 'contentControlChange':
+                return this.describeContentControlChange(revision);
+            default:
+                return `Changed (${type})`;
+        }
+    }
+    static describeHyperlinkChange(revision, _maxLength) {
+        const prevProps = revision.getPreviousProperties() || {};
+        const newProps = revision.getNewProperties() || {};
+        const changes = [];
+        if (prevProps.url !== newProps.url) {
+            changes.push('URL');
+        }
+        if (prevProps.text !== newProps.text) {
+            changes.push('display text');
+        }
+        if (prevProps.formatting !== newProps.formatting) {
+            changes.push('formatting');
+        }
+        if (changes.length === 0) {
+            return 'Updated hyperlink';
+        }
+        return `Changed hyperlink ${changes.join(' and ')}`;
+    }
+    static describeImageChange(revision) {
+        const prevProps = revision.getPreviousProperties() || {};
+        const newProps = revision.getNewProperties() || {};
+        const changes = [];
+        if (!prevProps.imageId && newProps.imageId) {
+            return `Inserted image${newProps.filename ? ` "${newProps.filename}"` : ''}`;
+        }
+        if (prevProps.imageId && !newProps.imageId) {
+            return `Deleted image${prevProps.filename ? ` "${prevProps.filename}"` : ''}`;
+        }
+        if (prevProps.width !== newProps.width || prevProps.height !== newProps.height) {
+            changes.push('size');
+        }
+        if (prevProps.position !== newProps.position) {
+            changes.push('position');
+        }
+        if (prevProps.wrapping !== newProps.wrapping) {
+            changes.push('wrapping');
+        }
+        if (prevProps.altText !== newProps.altText) {
+            changes.push('alt text');
+        }
+        if (changes.length === 0) {
+            return 'Updated image';
+        }
+        return `Changed image ${changes.join(' and ')}`;
+    }
+    static describeFieldChange(revision) {
+        const prevProps = revision.getPreviousProperties() || {};
+        const newProps = revision.getNewProperties() || {};
+        if (!prevProps.fieldType && newProps.fieldType) {
+            return `Inserted ${newProps.fieldType || 'field'}`;
+        }
+        if (prevProps.fieldType && !newProps.fieldType) {
+            return `Deleted ${prevProps.fieldType || 'field'}`;
+        }
+        if (prevProps.value !== newProps.value) {
+            return `Updated ${newProps.fieldType || 'field'} value`;
+        }
+        if (prevProps.formula !== newProps.formula) {
+            return `Changed ${newProps.fieldType || 'field'} formula`;
+        }
+        return `Updated ${newProps.fieldType || 'field'}`;
+    }
+    static describeCommentChange(revision) {
+        const prevProps = revision.getPreviousProperties() || {};
+        const newProps = revision.getNewProperties() || {};
+        if (!prevProps.commentId && newProps.commentId) {
+            return `Added comment${newProps.author ? ` by ${newProps.author}` : ''}`;
+        }
+        if (prevProps.commentId && !newProps.commentId) {
+            return `Deleted comment${prevProps.author ? ` by ${prevProps.author}` : ''}`;
+        }
+        if (prevProps.text !== newProps.text) {
+            return `Edited comment${newProps.author ? ` by ${newProps.author}` : ''}`;
+        }
+        return 'Updated comment';
+    }
+    static describeBookmarkChange(revision) {
+        const prevProps = revision.getPreviousProperties() || {};
+        const newProps = revision.getNewProperties() || {};
+        if (!prevProps.bookmarkId && newProps.bookmarkId) {
+            return `Created bookmark "${newProps.name || 'unnamed'}"`;
+        }
+        if (prevProps.bookmarkId && !newProps.bookmarkId) {
+            return `Deleted bookmark "${prevProps.name || 'unnamed'}"`;
+        }
+        if (prevProps.name !== newProps.name) {
+            return `Renamed bookmark from "${prevProps.name}" to "${newProps.name}"`;
+        }
+        if (prevProps.rangeStart !== newProps.rangeStart || prevProps.rangeEnd !== newProps.rangeEnd) {
+            return `Changed bookmark "${newProps.name || 'unnamed'}" range`;
+        }
+        return `Updated bookmark "${newProps.name || prevProps.name || 'unnamed'}"`;
+    }
+    static describeContentControlChange(revision) {
+        const prevProps = revision.getPreviousProperties() || {};
+        const newProps = revision.getNewProperties() || {};
+        if (!prevProps.sdtId && newProps.sdtId) {
+            return `Inserted content control${newProps.title ? ` "${newProps.title}"` : ''}`;
+        }
+        if (prevProps.sdtId && !newProps.sdtId) {
+            return `Deleted content control${prevProps.title ? ` "${prevProps.title}"` : ''}`;
+        }
+        if (prevProps.title !== newProps.title) {
+            return `Renamed content control to "${newProps.title}"`;
+        }
+        if (prevProps.content !== newProps.content) {
+            return `Changed content control${newProps.title ? ` "${newProps.title}"` : ''} content`;
+        }
+        return `Updated content control${newProps.title || prevProps.title ? ` "${newProps.title || prevProps.title}"` : ''}`;
+    }
+    static describePropertyChange(revision, context) {
+        const prevProps = revision.getPreviousProperties();
+        const newProps = revision.getNewProperties();
+        if (!prevProps && !newProps) {
+            return `Changed ${context}`;
+        }
+        const propNames = [];
+        const allKeys = new Set([...Object.keys(prevProps || {}), ...Object.keys(newProps || {})]);
+        for (const key of allKeys) {
+            const oldVal = prevProps?.[key];
+            const newVal = newProps?.[key];
+            if (oldVal !== newVal) {
+                propNames.push(this.friendlyPropertyName(key));
+            }
+        }
+        if (propNames.length === 0) {
+            return `Changed ${context}`;
+        }
+        if (propNames.length === 1) {
+            return `Changed ${propNames[0]}`;
+        }
+        if (propNames.length <= 3) {
+            return `Changed ${propNames.join(', ')}`;
+        }
+        return `Changed ${propNames.slice(0, 2).join(', ')} and ${propNames.length - 2} more`;
+    }
+    static formatPropertyValue(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (typeof value === 'object') {
+            try {
+                const json = JSON.stringify(value);
+                return json.length > 100 ? json.substring(0, 97) + '...' : json;
+            }
+            catch (e) {
+                getLogger().warn('Failed to stringify value for changelog', { error: String(e) });
+                return '[complex value]';
+            }
+        }
+        return String(value);
+    }
+    static friendlyPropertyName(key) {
+        const friendlyNames = {
+            b: 'bold',
+            i: 'italic',
+            u: 'underline',
+            strike: 'strikethrough',
+            dstrike: 'double strikethrough',
+            sz: 'font size',
+            szCs: 'complex script font size',
+            color: 'text color',
+            highlight: 'highlight',
+            rFonts: 'font',
+            rStyle: 'character style',
+            vertAlign: 'vertical alignment',
+            vanish: 'hidden text',
+            caps: 'all capitals',
+            smallCaps: 'small capitals',
+            outline: 'outline effect',
+            shadow: 'shadow effect',
+            emboss: 'emboss effect',
+            imprint: 'imprint effect',
+            kern: 'kerning',
+            w: 'character width',
+            spacing: 'character spacing',
+            position: 'text position',
+            shd: 'shading',
+            bdr: 'border',
+            lang: 'language',
+            eastAsianLayout: 'East Asian layout',
+            specVanish: 'special vanish',
+            oMath: 'math mode',
+            jc: 'alignment',
+            ind: 'indentation',
+            pStyle: 'paragraph style',
+            numPr: 'list numbering',
+            pBdr: 'paragraph border',
+            tabs: 'tab stops',
+            suppressAutoHyphens: 'hyphenation',
+            kinsoku: 'kinsoku rules',
+            wordWrap: 'word wrap',
+            overflowPunct: 'overflow punctuation',
+            topLinePunct: 'top line punctuation',
+            autoSpaceDE: 'auto space (DE)',
+            autoSpaceDN: 'auto space (DN)',
+            bidi: 'bidirectional',
+            adjustRightInd: 'right indent adjustment',
+            snapToGrid: 'snap to grid',
+            contextualSpacing: 'contextual spacing',
+            mirrorIndents: 'mirror indents',
+            suppressOverlap: 'suppress overlap',
+            outlineLvl: 'outline level',
+            divId: 'HTML division',
+            keepNext: 'keep with next',
+            keepLines: 'keep lines together',
+            pageBreakBefore: 'page break before',
+            widowControl: 'widow/orphan control',
+            suppressLineNumbers: 'suppress line numbers',
+            textboxTightWrap: 'textbox tight wrap',
+            tblStyle: 'table style',
+            tblW: 'table width',
+            tblInd: 'table indent',
+            tblBorders: 'table borders',
+            tblCellMar: 'table cell margins',
+            tblLook: 'table look',
+            tblLayout: 'table layout',
+            gridSpan: 'column span',
+            vMerge: 'vertical merge',
+            tcW: 'cell width',
+            tcBorders: 'cell borders',
+            vAlign: 'vertical alignment',
+            textDirection: 'text direction',
+            noWrap: 'no wrap',
+            tcMar: 'cell margins',
+            tcFitText: 'fit text',
+            hideMark: 'hide mark',
+            sectPr: 'section properties',
+            pgSz: 'page size',
+            pgMar: 'page margins',
+            cols: 'columns',
+            docGrid: 'document grid',
+            headerReference: 'header',
+            footerReference: 'footer',
+            pgNumType: 'page numbering',
+            formProt: 'form protection',
+            titlePg: 'different first page',
+            type: 'section type',
+        };
+        return friendlyNames[key] || key;
+    }
+    static toMarkdown(entries, options) {
+        const opts = { includeMetadata: true, ...options };
+        const lines = [];
+        lines.push('# Document Changes');
+        lines.push('');
+        if (opts.includeMetadata) {
+            const summary = this.getSummary(entries);
+            lines.push(`**Total Changes:** ${summary.total}`);
+            lines.push('');
+            if (summary.dateRange) {
+                lines.push(`**Date Range:** ${summary.dateRange.earliest.toLocaleDateString()} - ${summary.dateRange.latest.toLocaleDateString()}`);
+                lines.push('');
+            }
+            const authors = Object.keys(summary.byAuthor);
+            if (authors.length > 0) {
+                lines.push(`**Authors:** ${authors.join(', ')}`);
+                lines.push('');
+            }
+            lines.push('---');
+            lines.push('');
+        }
+        const byCategory = new Map();
+        for (const entry of entries) {
+            if (!byCategory.has(entry.category)) {
+                byCategory.set(entry.category, []);
+            }
+            byCategory.get(entry.category).push(entry);
+        }
+        const categoryTitles = {
+            content: 'Content Changes',
+            formatting: 'Formatting Changes',
+            structural: 'Structural Changes',
+            table: 'Table Changes',
+            hyperlink: 'Hyperlink Changes',
+            image: 'Image Changes',
+            field: 'Field Changes',
+            comment: 'Comment Changes',
+            bookmark: 'Bookmark Changes',
+            contentControl: 'Content Control Changes',
+        };
+        for (const [category, categoryEntries] of byCategory) {
+            if (categoryEntries.length === 0)
+                continue;
+            lines.push(`## ${categoryTitles[category]}`);
+            lines.push('');
+            for (const entry of categoryEntries) {
+                const date = entry.date.toLocaleDateString();
+                lines.push(`- ${entry.description} *(${entry.author}, ${date})*`);
+                if (entry.content.before) {
+                    lines.push(`  - Removed: "${entry.content.before}"`);
+                }
+                if (entry.content.after) {
+                    lines.push(`  - Added: "${entry.content.after}"`);
+                }
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    static toPlainText(entries) {
+        const lines = [];
+        lines.push('DOCUMENT CHANGES');
+        lines.push('================');
+        lines.push('');
+        for (const entry of entries) {
+            const date = entry.date.toLocaleDateString();
+            lines.push(`[${date}] ${entry.author}: ${entry.description}`);
+            if (entry.content.before) {
+                lines.push(`  - ${entry.content.before}`);
+            }
+            if (entry.content.after) {
+                lines.push(`  + ${entry.content.after}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    static toJSON(entries) {
+        return JSON.stringify({
+            generated: new Date().toISOString(),
+            summary: this.getSummary(entries),
+            entries,
+        }, null, 2);
+    }
+    static generate(doc, options) {
+        const logger = getLogger();
+        const format = options?.format || 'markdown';
+        logger.info('Generating changelog', { format });
+        let entries = this.fromDocument(doc, options);
+        if (options?.sortBy) {
+            entries = this.sortEntries(entries, options.sortBy, options.sortOrder || 'asc');
+        }
+        logger.info('Changelog entries processed', {
+            entries: entries.length,
+            format,
+            sorted: !!options?.sortBy,
+        });
+        switch (format) {
+            case 'json':
+                return this.toJSON(entries);
+            case 'markdown':
+                return this.toMarkdown(entries, { includeMetadata: true });
+            case 'text':
+                return this.toPlainText(entries);
+            case 'html':
+                return this.toHTML(entries, options);
+            case 'csv':
+                return this.toCSV(entries);
+            default:
+                return this.toMarkdown(entries);
+        }
+    }
+    static toHTML(entries, _options) {
+        const summary = this.getSummary(entries);
+        const byCategory = new Map();
+        for (const entry of entries) {
+            if (!byCategory.has(entry.category)) {
+                byCategory.set(entry.category, []);
+            }
+            byCategory.get(entry.category).push(entry);
+        }
+        const categoryTitles = {
+            content: 'Content Changes',
+            formatting: 'Formatting Changes',
+            structural: 'Structural Changes',
+            table: 'Table Changes',
+            hyperlink: 'Hyperlink Changes',
+            image: 'Image Changes',
+            field: 'Field Changes',
+            comment: 'Comment Changes',
+            bookmark: 'Bookmark Changes',
+            contentControl: 'Content Control Changes',
+        };
+        let html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Document Changes</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 900px;
+      margin: 0 auto;
+      padding: 20px;
+      line-height: 1.6;
+      color: #333;
+    }
+    h1 { color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 10px; }
+    h2 { color: #34495e; margin-top: 30px; }
+    .summary { background: #f8f9fa; padding: 15px; border-radius: 8px; margin-bottom: 20px; }
+    .summary p { margin: 5px 0; }
+    .category { margin-bottom: 30px; }
+    .change-list { list-style: none; padding: 0; }
+    .change-item {
+      background: #fff;
+      border: 1px solid #e9ecef;
+      border-radius: 6px;
+      padding: 12px 15px;
+      margin-bottom: 10px;
+    }
+    .change-item:hover { box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
+    .change-description { font-weight: 500; color: #2c3e50; }
+    .change-meta { font-size: 0.85em; color: #7f8c8d; margin-top: 5px; }
+    .change-content { margin-top: 8px; font-size: 0.9em; }
+    .removed { color: #c0392b; text-decoration: line-through; }
+    .added { color: #27ae60; }
+    .badge {
+      display: inline-block;
+      padding: 2px 8px;
+      border-radius: 4px;
+      font-size: 0.75em;
+      font-weight: 600;
+      text-transform: uppercase;
+    }
+    .badge-insert { background: #d4edda; color: #155724; }
+    .badge-delete { background: #f8d7da; color: #721c24; }
+    .badge-formatting { background: #cce5ff; color: #004085; }
+    .badge-structural { background: #fff3cd; color: #856404; }
+    .badge-table { background: #e2e3e5; color: #383d41; }
+  </style>
+</head>
+<body>
+  <h1>Document Changes</h1>
+
+  <div class="summary">
+    <p><strong>Total Changes:</strong> ${summary.total}</p>`;
+        if (summary.dateRange) {
+            html += `
+    <p><strong>Date Range:</strong> ${summary.dateRange.earliest.toLocaleDateString()} - ${summary.dateRange.latest.toLocaleDateString()}</p>`;
+        }
+        const authors = Object.keys(summary.byAuthor);
+        if (authors.length > 0) {
+            html += `
+    <p><strong>Authors:</strong> ${authors.join(', ')}</p>`;
+        }
+        html += `
+  </div>
+`;
+        for (const [category, categoryEntries] of byCategory) {
+            if (categoryEntries.length === 0)
+                continue;
+            html += `
+  <section class="category">
+    <h2>${categoryTitles[category]}</h2>
+    <ul class="change-list">`;
+            for (const entry of categoryEntries) {
+                const badgeClass = this.getBadgeClass(entry.revisionType);
+                const date = entry.date.toLocaleDateString();
+                html += `
+      <li class="change-item">
+        <span class="badge ${badgeClass}">${entry.revisionType}</span>
+        <div class="change-description">${this.escapeHTML(entry.description)}</div>
+        <div class="change-meta">${this.escapeHTML(entry.author)} - ${date}</div>`;
+                if (entry.content.before || entry.content.after) {
+                    html += `
+        <div class="change-content">`;
+                    if (entry.content.before) {
+                        html += `<span class="removed">${this.escapeHTML(entry.content.before || '')}</span> `;
+                    }
+                    if (entry.content.after) {
+                        html += `<span class="added">${this.escapeHTML(entry.content.after || '')}</span>`;
+                    }
+                    html += `</div>`;
+                }
+                html += `
+      </li>`;
+            }
+            html += `
+    </ul>
+  </section>`;
+        }
+        html += `
+</body>
+</html>`;
+        return html;
+    }
+    static toCSV(entries, options) {
+        const delimiter = options?.delimiter || ',';
+        const includeHeaders = options?.includeHeaders !== false;
+        const headers = [
+            'ID',
+            'Type',
+            'Category',
+            'Author',
+            'Date',
+            'Description',
+            'Before',
+            'After',
+            'Paragraph',
+            'Run',
+        ];
+        const lines = [];
+        if (includeHeaders) {
+            lines.push(headers.join(delimiter));
+        }
+        for (const entry of entries) {
+            const row = [
+                entry.id,
+                entry.revisionType,
+                entry.category,
+                this.escapeCSV(entry.author),
+                entry.date.toISOString(),
+                this.escapeCSV(entry.description),
+                this.escapeCSV(entry.content.before || ''),
+                this.escapeCSV(entry.content.after || ''),
+                entry.location.paragraphIndex?.toString() || '',
+                entry.location.runIndex?.toString() || '',
+            ];
+            lines.push(row.join(delimiter));
+        }
+        return lines.join('\n');
+    }
+    static getTimeline(entries) {
+        const timeline = new Map();
+        for (const entry of entries) {
+            const dateKey = entry.date.toISOString().split('T')[0];
+            if (!timeline.has(dateKey)) {
+                timeline.set(dateKey, []);
+            }
+            timeline.get(dateKey).push(entry);
+        }
+        const sortedTimeline = new Map([...timeline.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+        return sortedTimeline;
+    }
+    static getSummaryByElement(entries) {
+        return {
+            paragraphs: entries.filter((e) => e.revisionType === 'paragraphPropertiesChange' ||
+                e.revisionType === 'numberingChange' ||
+                (e.revisionType === 'insert' && !e.location.runIndex) ||
+                (e.revisionType === 'delete' && !e.location.runIndex)),
+            tables: entries.filter((e) => [
+                'tablePropertiesChange',
+                'tableRowPropertiesChange',
+                'tableCellPropertiesChange',
+                'tableExceptionPropertiesChange',
+                'tableCellInsert',
+                'tableCellDelete',
+                'tableCellMerge',
+            ].includes(e.revisionType)),
+            sections: entries.filter((e) => e.revisionType === 'sectionPropertiesChange'),
+            runs: entries.filter((e) => e.revisionType === 'runPropertiesChange' ||
+                (e.revisionType === 'insert' && e.location.runIndex !== undefined) ||
+                (e.revisionType === 'delete' && e.location.runIndex !== undefined)),
+            hyperlinks: entries.filter((e) => e.revisionType === 'hyperlinkChange'),
+        };
+    }
+    static sortEntries(entries, sortBy, order) {
+        const sorted = [...entries].sort((a, b) => {
+            let comparison = 0;
+            switch (sortBy) {
+                case 'date':
+                    comparison = a.date.getTime() - b.date.getTime();
+                    break;
+                case 'author':
+                    comparison = a.author.localeCompare(b.author);
+                    break;
+                case 'type':
+                    comparison = a.revisionType.localeCompare(b.revisionType);
+                    break;
+                case 'category':
+                    comparison = a.category.localeCompare(b.category);
+                    break;
+            }
+            return order === 'desc' ? -comparison : comparison;
+        });
+        return sorted;
+    }
+    static getBadgeClass(type) {
+        switch (type) {
+            case 'insert':
+            case 'moveTo':
+            case 'tableCellInsert':
+                return 'badge-insert';
+            case 'delete':
+            case 'moveFrom':
+            case 'tableCellDelete':
+                return 'badge-delete';
+            case 'runPropertiesChange':
+            case 'paragraphPropertiesChange':
+            case 'numberingChange':
+                return 'badge-formatting';
+            case 'sectionPropertiesChange':
+                return 'badge-structural';
+            case 'tablePropertiesChange':
+            case 'tableRowPropertiesChange':
+            case 'tableCellPropertiesChange':
+            case 'tableCellMerge':
+                return 'badge-table';
+            default:
+                return 'badge-formatting';
+        }
+    }
+    static escapeHTML(str) {
+        return str
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    }
+    static escapeCSV(str) {
+        if (str.includes(',') || str.includes('\n') || str.includes('"')) {
+            return `"${str.replace(/"/g, '""')}"`;
+        }
+        return str;
+    }
+}
+//# sourceMappingURL=ChangelogGenerator.js.map