mirror of
https://github.com/amitwh/markdown-converter.git
synced 2026-10-01 09:19:34 +05:30
amitwh
c8883e77fe
Replaces the two native OS dialogs used to configure the DOCX "Enhanced"
export template (an open-file picker + a message-box question) with a
single in-app modal that shows the currently active template state, per
Task 18's original audit finding that this state was invisible until a
user thought to reopen the menu. Consolidates the "Select Word
Template..."/"Template Settings..." menu items into one "Word Template
Settings..." entry wired to the new dialog; Browse still uses the native
file picker since there is genuinely no bundled folder of templates to
enumerate (confirmed by investigation — see task-18-report.md).
Also fixes a related dangling-reference bug: WordTemplateExporter's
hardcoded default template path (word_template.docx) was deleted from
the repo in an earlier commit, but the code still tried to read it and
threw ENOENT whenever no custom template was selected. convert() now
degrades gracefully by generating a minimal, valid DOCX shell (styles +
numbering matching what markdownToWordXml() already references) instead
of crashing, and the new dialog surfaces this state honestly ("using
default formatting, no default template is bundled") rather than
implying a working default exists.
Out of scope, per explicit instruction: bundling fabricated starter
.docx templates to populate a literal multi-item gallery (rejected as
disproportionate/fake-content scope), and an EPUB template gallery (no
EPUB template mechanism exists anywhere in this codebase to build one
for).
Amit Haridas
1110 lines
36 KiB
JavaScript
1110 lines
36 KiB
JavaScript
/**
|
|
* Word Template Exporter
|
|
* Loads word_template.docx, preserves first 2 pages (cover + TOC),
|
|
* and adds markdown content starting from page 3 using template styles
|
|
*/
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const PizZip = require('pizzip');
|
|
|
|
class WordTemplateExporter {
|
|
/**
|
|
* Path used when no explicit template is configured. Historically a
|
|
* `word_template.docx` shipped at the repo root, but it was removed from
|
|
* the project (see git history) while this fallback reference was not
|
|
* updated, so this path is not guaranteed to exist on disk — callers
|
|
* must not assume it does. Exposed as a static so the UI layer (main.js)
|
|
* can check availability without duplicating the path logic.
|
|
*/
|
|
static getDefaultTemplatePath() {
|
|
return path.join(__dirname, '../word_template.docx');
|
|
}
|
|
|
|
constructor(templatePath, startPage = 3, pageSettings = null) {
|
|
this.templatePath = templatePath || WordTemplateExporter.getDefaultTemplatePath();
|
|
this.startPage = startPage; // Which page to start inserting content
|
|
this.pageSettings = pageSettings; // Page size and orientation settings
|
|
}
|
|
|
|
/**
|
|
* Whether a real, readable template file exists at this.templatePath.
|
|
* When false, convert() degrades gracefully to a minimal generated
|
|
* document instead of throwing ENOENT.
|
|
*/
|
|
hasTemplateFile() {
|
|
return !!this.templatePath && fs.existsSync(this.templatePath);
|
|
}
|
|
|
|
/**
|
|
* Strip HTML artifacts that Pandoc / Word cannot render and that would
|
|
* otherwise appear as visible text in DOCX output.
|
|
* Removes HTML comments, <style> blocks, and <div> tags (including
|
|
* alignment attributes). Code blocks and inline code spans are preserved.
|
|
*/
|
|
static preprocessMarkdownForWordExport(markdown) {
|
|
if (typeof markdown !== 'string') return markdown;
|
|
|
|
// Split markdown into code-block and non-code-block segments so we do
|
|
// not strip HTML that the author intentionally placed inside fences.
|
|
const segments = [];
|
|
let inCodeBlock = false;
|
|
let currentLines = [];
|
|
|
|
const flush = () => {
|
|
if (currentLines.length === 0) return;
|
|
segments.push({
|
|
type: inCodeBlock ? 'code' : 'text',
|
|
text: currentLines.join('\n'),
|
|
});
|
|
currentLines = [];
|
|
};
|
|
|
|
for (const line of markdown.split('\n')) {
|
|
if (/^\s*```/.test(line)) {
|
|
if (inCodeBlock) {
|
|
currentLines.push(line);
|
|
flush();
|
|
inCodeBlock = false;
|
|
} else {
|
|
flush();
|
|
currentLines.push(line);
|
|
inCodeBlock = true;
|
|
}
|
|
} else {
|
|
currentLines.push(line);
|
|
}
|
|
}
|
|
flush();
|
|
|
|
const stripArtifacts = (text) => {
|
|
// Protect inline code spans so HTML inside backticks is preserved.
|
|
const codeSpans = [];
|
|
const protectedText = text.replace(/`[^`]+`/g, (match) => {
|
|
codeSpans.push(match);
|
|
return ` INLINE_CODE_${codeSpans.length - 1} `;
|
|
});
|
|
|
|
const stripped = protectedText
|
|
// HTML comments (multi-line)
|
|
.replace(/<!--[\s\S]*?-->/g, '')
|
|
// <style> blocks (case-insensitive, multi-line)
|
|
.replace(/<style\b[\s\S]*?<\/style>/gi, '')
|
|
// <div> opening tags with any attributes
|
|
.replace(/<div\b[^>]*>/gi, '')
|
|
// Closing </div> tags
|
|
.replace(/<\/div\s*>/gi, '');
|
|
|
|
return stripped.replace(/ INLINE_CODE_(\d+) /g, (_, index) => codeSpans[+index]);
|
|
};
|
|
|
|
return segments
|
|
.map((segment) => (segment.type === 'code' ? segment.text : stripArtifacts(segment.text)))
|
|
.join('\n');
|
|
}
|
|
|
|
/**
|
|
* Convert markdown to Word document using template
|
|
*/
|
|
async convert(markdownContent, outputPath) {
|
|
try {
|
|
// Parse markdown and generate Word XML (needed either way)
|
|
const cleanedContent = WordTemplateExporter.preprocessMarkdownForWordExport(markdownContent);
|
|
const newContentXml = this.markdownToWordXml(cleanedContent);
|
|
|
|
let zip;
|
|
|
|
if (this.hasTemplateFile()) {
|
|
// Load template
|
|
const templateBuffer = fs.readFileSync(this.templatePath);
|
|
zip = new PizZip(templateBuffer);
|
|
|
|
// Extract document.xml
|
|
let documentXml = zip.file('word/document.xml').asText();
|
|
|
|
// Set page size if settings provided
|
|
if (this.pageSettings) {
|
|
documentXml = this.setPageSize(documentXml);
|
|
}
|
|
|
|
// Insert new content after the specified start page
|
|
const modifiedXml = this.insertContentAfterPage(documentXml, newContentXml, this.startPage);
|
|
|
|
// Update the zip with modified XML
|
|
zip.file('word/document.xml', modifiedXml);
|
|
} else {
|
|
// No template file is available — neither a custom one was
|
|
// selected nor does the bundled default exist on disk. Rather
|
|
// than throw ENOENT, degrade gracefully: generate a minimal,
|
|
// valid DOCX with default formatting so export still succeeds.
|
|
console.warn(
|
|
`[WordTemplateExporter] No template file found at "${this.templatePath}" — exporting with default formatting instead.`
|
|
);
|
|
zip = this.buildDefaultDocumentZip(newContentXml);
|
|
}
|
|
|
|
// Generate and save the new document
|
|
const newDocBuffer = zip.generate({ type: 'nodebuffer' });
|
|
fs.writeFileSync(outputPath, newDocBuffer);
|
|
|
|
return outputPath;
|
|
} catch (error) {
|
|
console.error('Error in Word export:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Build a minimal, self-contained DOCX package (as a PizZip archive) for
|
|
* use when no template file is available. It provides just enough of the
|
|
* OOXML package — content types, package relationships, styles and
|
|
* numbering definitions — for the markup produced by markdownToWordXml()
|
|
* (which references styles like "Heading1"/"Normal"/"Quote" and numId 1/2
|
|
* for lists) to open cleanly in Word with sensible default formatting.
|
|
* There is no cover page or table of contents, since there is no
|
|
* template to source them from — content starts on page 1.
|
|
*/
|
|
buildDefaultDocumentZip(bodyContentXml) {
|
|
const zip = new PizZip();
|
|
|
|
zip.file(
|
|
'[Content_Types].xml',
|
|
`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
|
|
<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
|
|
<Default Extension="xml" ContentType="application/xml"/>
|
|
<Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
|
|
<Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
|
|
<Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>
|
|
</Types>`
|
|
);
|
|
|
|
zip.file(
|
|
'_rels/.rels',
|
|
`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
|
|
</Relationships>`
|
|
);
|
|
|
|
zip.file(
|
|
'word/_rels/document.xml.rels',
|
|
`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
|
|
<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" Target="numbering.xml"/>
|
|
</Relationships>`
|
|
);
|
|
|
|
zip.file('word/styles.xml', this.buildDefaultStylesXml());
|
|
zip.file('word/numbering.xml', this.buildDefaultNumberingXml());
|
|
|
|
const { width, height, orientation } = this.resolveDefaultPageDimensions();
|
|
|
|
zip.file(
|
|
'word/document.xml',
|
|
`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
|
|
<w:body>
|
|
${bodyContentXml}
|
|
<w:sectPr>
|
|
<w:pgSz w:w="${width}" w:h="${height}" w:orient="${orientation}"/>
|
|
<w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="708" w:footer="708" w:gutter="0"/>
|
|
</w:sectPr>
|
|
</w:body>
|
|
</w:document>`
|
|
);
|
|
|
|
return zip;
|
|
}
|
|
|
|
/**
|
|
* Resolve page width/height/orientation for the generated default
|
|
* document, honoring this.pageSettings the same way setPageSize() does
|
|
* for the template path. Defaults to A4 portrait.
|
|
*/
|
|
resolveDefaultPageDimensions() {
|
|
const PAGE_SIZES = {
|
|
a4: { width: 11906, height: 16838 },
|
|
a3: { width: 16838, height: 23811 },
|
|
a5: { width: 8391, height: 11906 },
|
|
b4: { width: 14170, height: 20015 },
|
|
b5: { width: 9979, height: 14170 },
|
|
letter: { width: 12240, height: 15840 },
|
|
legal: { width: 12240, height: 20160 },
|
|
tabloid: { width: 15840, height: 24480 },
|
|
};
|
|
|
|
let width = 11906;
|
|
let height = 16838;
|
|
const orientation =
|
|
this.pageSettings && this.pageSettings.orientation === 'landscape' ? 'landscape' : 'portrait';
|
|
|
|
if (this.pageSettings) {
|
|
const pageSize = PAGE_SIZES[this.pageSettings.size];
|
|
if (pageSize) {
|
|
width = pageSize.width;
|
|
height = pageSize.height;
|
|
}
|
|
if (orientation === 'landscape') {
|
|
[width, height] = [height, width];
|
|
}
|
|
}
|
|
|
|
return { width, height, orientation };
|
|
}
|
|
|
|
/**
|
|
* Minimal styles.xml defining every style name referenced by
|
|
* markdownToWordXml() (Normal, Heading1-6, Quote, ListNumber,
|
|
* ListBullet, and the TableGrid table style).
|
|
*/
|
|
buildDefaultStylesXml() {
|
|
const headingSizes = { 1: 32, 2: 28, 3: 24, 4: 22, 5: 22, 6: 22 };
|
|
const headingStyles = Object.entries(headingSizes)
|
|
.map(
|
|
([level, size]) => `
|
|
<w:style w:type="paragraph" w:styleId="Heading${level}">
|
|
<w:name w:val="heading ${level}"/>
|
|
<w:basedOn w:val="Normal"/>
|
|
<w:next w:val="Normal"/>
|
|
<w:qFormat/>
|
|
<w:pPr><w:outlineLvl w:val="${level - 1}"/></w:pPr>
|
|
<w:rPr><w:b/><w:sz w:val="${size}"/><w:szCs w:val="${size}"/></w:rPr>
|
|
</w:style>`
|
|
)
|
|
.join('');
|
|
|
|
return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
<w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
|
|
<w:docDefaults>
|
|
<w:rPrDefault>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Calibri" w:hAnsi="Calibri" w:cs="Calibri"/>
|
|
<w:sz w:val="22"/>
|
|
<w:szCs w:val="22"/>
|
|
</w:rPr>
|
|
</w:rPrDefault>
|
|
</w:docDefaults>
|
|
<w:style w:type="paragraph" w:default="1" w:styleId="Normal">
|
|
<w:name w:val="Normal"/>
|
|
<w:qFormat/>
|
|
</w:style>${headingStyles}
|
|
<w:style w:type="paragraph" w:styleId="Quote">
|
|
<w:name w:val="Quote"/>
|
|
<w:basedOn w:val="Normal"/>
|
|
<w:pPr>
|
|
<w:ind w:left="720"/>
|
|
<w:pBdr><w:left w:val="single" w:sz="12" w:space="8" w:color="CCCCCC"/></w:pBdr>
|
|
</w:pPr>
|
|
<w:rPr><w:i/></w:rPr>
|
|
</w:style>
|
|
<w:style w:type="paragraph" w:styleId="ListNumber">
|
|
<w:name w:val="List Number"/>
|
|
<w:basedOn w:val="Normal"/>
|
|
</w:style>
|
|
<w:style w:type="paragraph" w:styleId="ListBullet">
|
|
<w:name w:val="List Bullet"/>
|
|
<w:basedOn w:val="Normal"/>
|
|
</w:style>
|
|
<w:style w:type="table" w:styleId="TableGrid">
|
|
<w:name w:val="Table Grid"/>
|
|
<w:tblPr>
|
|
<w:tblBorders>
|
|
<w:top w:val="single" w:sz="4" w:space="0" w:color="auto"/>
|
|
<w:left w:val="single" w:sz="4" w:space="0" w:color="auto"/>
|
|
<w:bottom w:val="single" w:sz="4" w:space="0" w:color="auto"/>
|
|
<w:right w:val="single" w:sz="4" w:space="0" w:color="auto"/>
|
|
<w:insideH w:val="single" w:sz="4" w:space="0" w:color="auto"/>
|
|
<w:insideV w:val="single" w:sz="4" w:space="0" w:color="auto"/>
|
|
</w:tblBorders>
|
|
</w:tblPr>
|
|
</w:style>
|
|
</w:styles>`;
|
|
}
|
|
|
|
/**
|
|
* Minimal numbering.xml defining numId 1 (decimal, used for ordered
|
|
* lists) and numId 2 (bullet, used for unordered lists) — matching the
|
|
* numId values createListItemXml() already hardcodes.
|
|
*/
|
|
buildDefaultNumberingXml() {
|
|
return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
|
|
<w:abstractNum w:abstractNumId="0">
|
|
<w:lvl w:ilvl="0">
|
|
<w:start w:val="1"/>
|
|
<w:numFmt w:val="decimal"/>
|
|
<w:lvlText w:val="%1."/>
|
|
<w:lvlJc w:val="left"/>
|
|
<w:pPr><w:ind w:left="720" w:hanging="360"/></w:pPr>
|
|
</w:lvl>
|
|
</w:abstractNum>
|
|
<w:abstractNum w:abstractNumId="1">
|
|
<w:lvl w:ilvl="0">
|
|
<w:start w:val="1"/>
|
|
<w:numFmt w:val="bullet"/>
|
|
<w:lvlText w:val="•"/>
|
|
<w:lvlJc w:val="left"/>
|
|
<w:pPr><w:ind w:left="720" w:hanging="360"/></w:pPr>
|
|
<w:rPr><w:rFonts w:ascii="Symbol" w:hAnsi="Symbol" w:hint="default"/></w:rPr>
|
|
</w:lvl>
|
|
</w:abstractNum>
|
|
<w:num w:numId="1"><w:abstractNumId w:val="0"/></w:num>
|
|
<w:num w:numId="2"><w:abstractNumId w:val="1"/></w:num>
|
|
</w:numbering>`;
|
|
}
|
|
|
|
/**
|
|
* Set page size in document XML
|
|
*/
|
|
setPageSize(documentXml) {
|
|
// Import PAGE_SIZES from main process (need to pass as parameter)
|
|
const PAGE_SIZES = {
|
|
a4: { width: 11906, height: 16838 },
|
|
a3: { width: 16838, height: 23811 },
|
|
a5: { width: 8391, height: 11906 },
|
|
b4: { width: 14170, height: 20015 },
|
|
b5: { width: 9979, height: 14170 },
|
|
letter: { width: 12240, height: 15840 },
|
|
legal: { width: 12240, height: 20160 },
|
|
tabloid: { width: 15840, height: 24480 },
|
|
};
|
|
|
|
let width, height;
|
|
const pageSize = PAGE_SIZES[this.pageSettings.size];
|
|
|
|
if (pageSize) {
|
|
width = pageSize.width;
|
|
height = pageSize.height;
|
|
} else {
|
|
// Default to A4
|
|
width = 11906;
|
|
height = 16838;
|
|
}
|
|
|
|
// Swap dimensions for landscape
|
|
if (this.pageSettings.orientation === 'landscape') {
|
|
[width, height] = [height, width];
|
|
}
|
|
|
|
// Update all <w:pgSz> elements in section properties
|
|
const pgSzRegex = /<w:pgSz[^>]*\/>/g;
|
|
let modifiedXml = documentXml.replace(pgSzRegex, () => {
|
|
return `<w:pgSz w:w="${width}" w:h="${height}" w:orient="${this.pageSettings.orientation}"/>`;
|
|
});
|
|
|
|
// If no pgSz found, add it to all sectPr elements
|
|
if (!pgSzRegex.test(documentXml)) {
|
|
const sectPrRegex = /<w:sectPr[^>]*>/g;
|
|
modifiedXml = modifiedXml.replace(sectPrRegex, (match) => {
|
|
return `${match}<w:pgSz w:w="${width}" w:h="${height}" w:orient="${this.pageSettings.orientation}"/>`;
|
|
});
|
|
}
|
|
|
|
return modifiedXml;
|
|
}
|
|
|
|
/**
|
|
* Insert markdown content after the specified page in the document
|
|
* @param {string} documentXml - The document XML
|
|
* @param {string} newContentXml - The new content to insert
|
|
* @param {number} afterPage - Insert content after this page number (1-based)
|
|
*/
|
|
insertContentAfterPage(documentXml, newContentXml, afterPage) {
|
|
// Find section breaks that mark page boundaries
|
|
// Look for the section properties tag that marks page breaks
|
|
const sectionBreakRegex = /<w:sectPr[^>]*>[\s\S]*?<\/w:sectPr>/g;
|
|
const matches = [...documentXml.matchAll(sectionBreakRegex)];
|
|
|
|
// Calculate which section break to insert after
|
|
// Page 1 = before 1st section break
|
|
// Page 2 = after 1st section break
|
|
// Page 3 = after 2nd section break, etc.
|
|
const sectionIndex = afterPage - 1;
|
|
|
|
if (matches.length >= sectionIndex && sectionIndex > 0) {
|
|
// Insert after the specified section break
|
|
const insertPoint = matches[sectionIndex - 1].index + matches[sectionIndex - 1][0].length;
|
|
return documentXml.slice(0, insertPoint) + newContentXml + documentXml.slice(insertPoint);
|
|
} else if (afterPage === 1 || matches.length === 0) {
|
|
// Insert at the beginning (after <w:body>) or if no section breaks found
|
|
const bodyStart = documentXml.indexOf('<w:body>') + 8;
|
|
return documentXml.slice(0, bodyStart) + newContentXml + documentXml.slice(bodyStart);
|
|
} else {
|
|
// If not enough section breaks, insert before closing body tag
|
|
return documentXml.replace('</w:body>', newContentXml + '</w:body>');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert markdown to Word XML format
|
|
*/
|
|
markdownToWordXml(markdown) {
|
|
const lines = markdown.split('\n');
|
|
let xml = '';
|
|
let inCodeBlock = false;
|
|
let codeLines = [];
|
|
|
|
for (let i = 0; i < lines.length; i++) {
|
|
const line = lines[i];
|
|
|
|
// Handle code blocks
|
|
if (line.trim().startsWith('```')) {
|
|
if (inCodeBlock) {
|
|
// End code block
|
|
xml += this.createCodeBlockXml(codeLines.join('\n'));
|
|
codeLines = [];
|
|
inCodeBlock = false;
|
|
} else {
|
|
inCodeBlock = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (inCodeBlock) {
|
|
codeLines.push(line);
|
|
continue;
|
|
}
|
|
|
|
// Empty lines
|
|
if (!line.trim()) {
|
|
xml += '<w:p><w:pPr></w:pPr></w:p>';
|
|
continue;
|
|
}
|
|
|
|
// Tables - detect table lines
|
|
if (line.includes('|') && line.trim().startsWith('|')) {
|
|
const tableLines = [line];
|
|
i++;
|
|
// Collect all consecutive table lines
|
|
while (i < lines.length && lines[i].includes('|')) {
|
|
tableLines.push(lines[i]);
|
|
i++;
|
|
}
|
|
i--; // Back up one line
|
|
xml += this.createTableXml(tableLines);
|
|
continue;
|
|
}
|
|
|
|
// ASCII flowcharts/diagrams - detect box drawing characters
|
|
if (this.isAsciiArt(line)) {
|
|
const asciiLines = [line];
|
|
i++;
|
|
// Collect all consecutive ASCII art lines
|
|
while (i < lines.length && (this.isAsciiArt(lines[i]) || !lines[i].trim())) {
|
|
asciiLines.push(lines[i]);
|
|
i++;
|
|
if (i < lines.length && lines[i].trim() && !this.isAsciiArt(lines[i])) {
|
|
break;
|
|
}
|
|
}
|
|
i--; // Back up one line
|
|
xml += this.createAsciiArtXml(asciiLines.join('\n'));
|
|
continue;
|
|
}
|
|
|
|
// Headings - strip markdown numbering
|
|
if (line.trim().startsWith('#')) {
|
|
const level = (line.match(/^#+/) || [''])[0].length;
|
|
let text = line.replace(/^#+\s*/, '').trim();
|
|
// Remove markdown numbering like "1.1 Title" -> "Title"
|
|
text = text.replace(/^\d+(\.\d+)*\.?\s+/, '');
|
|
xml += this.createHeadingXml(text, level);
|
|
continue;
|
|
}
|
|
|
|
// Blockquotes
|
|
if (line.trim().startsWith('>')) {
|
|
const text = line.replace(/^>\s*/, '').trim();
|
|
xml += this.createQuoteXml(text);
|
|
continue;
|
|
}
|
|
|
|
// Ordered lists - strip markdown numbering, use template numbering
|
|
if (/^\s*\d+\.\s+/.test(line)) {
|
|
const text = line.replace(/^\s*\d+\.\s+/, '');
|
|
xml += this.createListItemXml(text, true);
|
|
continue;
|
|
}
|
|
|
|
// Unordered lists
|
|
if (/^\s*[-*+]\s+/.test(line)) {
|
|
const text = line.replace(/^\s*[-*+]\s+/, '');
|
|
xml += this.createListItemXml(text, false);
|
|
continue;
|
|
}
|
|
|
|
// Horizontal rule
|
|
if (/^[-*_]{3,}$/.test(line.trim())) {
|
|
xml += this.createHorizontalRuleXml();
|
|
continue;
|
|
}
|
|
|
|
// Normal paragraph
|
|
xml += this.createParagraphXml(line);
|
|
}
|
|
|
|
return xml;
|
|
}
|
|
|
|
/**
|
|
* Create heading XML using template styles
|
|
*/
|
|
createHeadingXml(text, level) {
|
|
const styleName = `Heading${level}`;
|
|
const runs = this.parseInlineFormatting(text);
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="${styleName}"/>
|
|
</w:pPr>
|
|
${runs}
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create paragraph XML with Normal style
|
|
*/
|
|
createParagraphXml(text) {
|
|
const runs = this.parseInlineFormatting(text);
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="Normal"/>
|
|
</w:pPr>
|
|
${runs}
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create quote XML
|
|
*/
|
|
createQuoteXml(text) {
|
|
const runs = this.parseInlineFormatting(text);
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="Quote"/>
|
|
</w:pPr>
|
|
${runs}
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create list item XML using template numbering
|
|
*/
|
|
createListItemXml(text, numbered) {
|
|
const runs = this.parseInlineFormatting(text);
|
|
const numId = numbered ? '1' : '2'; // Template numbering IDs
|
|
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="${numbered ? 'ListNumber' : 'ListBullet'}"/>
|
|
<w:numPr>
|
|
<w:ilvl w:val="0"/>
|
|
<w:numId w:val="${numId}"/>
|
|
</w:numPr>
|
|
</w:pPr>
|
|
${runs}
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create code block XML - renders each line as separate paragraph
|
|
* to preserve exact formatting like in preview (monospace, no wrapping)
|
|
* Background shading applied at paragraph level to extend full width
|
|
*/
|
|
createCodeBlockXml(code) {
|
|
const lines = code.split('\n');
|
|
let xml = '';
|
|
|
|
lines.forEach((line, index) => {
|
|
const escapedLine = this.escapeXml(line);
|
|
|
|
// Each line gets its own paragraph with exact spacing and no wrapping
|
|
// Shading (shd) is at paragraph level so background extends full width
|
|
xml += `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="Normal"/>
|
|
<w:shd w:val="clear" w:color="auto" w:fill="F5F5F5"/>
|
|
<w:spacing w:before="${index === 0 ? '120' : '0'}" w:after="${index === lines.length - 1 ? '120' : '0'}" w:line="240" w:lineRule="exact"/>
|
|
<w:ind w:left="284" w:right="284"/>
|
|
<w:jc w:val="left"/>
|
|
<w:keepLines/>
|
|
<w:wordWrap w:val="0"/>
|
|
</w:pPr>
|
|
<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="18"/>
|
|
<w:szCs w:val="18"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${escapedLine}</w:t>
|
|
</w:r>
|
|
</w:p>`;
|
|
});
|
|
|
|
return xml;
|
|
}
|
|
|
|
/**
|
|
* Create horizontal rule XML
|
|
*/
|
|
createHorizontalRuleXml() {
|
|
return `<w:p>
|
|
<w:pPr>
|
|
<w:pBdr>
|
|
<w:bottom w:val="single" w:sz="6" w:space="1" w:color="auto"/>
|
|
</w:pBdr>
|
|
</w:pPr>
|
|
</w:p>`;
|
|
}
|
|
|
|
/**
|
|
* Create table XML from markdown table lines with template styling
|
|
* Uses full-width tables with equal column distribution matching template style
|
|
*/
|
|
createTableXml(tableLines) {
|
|
// Parse table
|
|
const rows = [];
|
|
for (const line of tableLines) {
|
|
// Skip separator lines (e.g., |---|---|)
|
|
if (/^\s*\|[\s\-:]+\|\s*$/.test(line)) {
|
|
continue;
|
|
}
|
|
// Split by | and trim
|
|
const cells = line
|
|
.split('|')
|
|
.filter((cell) => cell.trim())
|
|
.map((cell) => cell.trim());
|
|
if (cells.length > 0) {
|
|
rows.push(cells);
|
|
}
|
|
}
|
|
|
|
if (rows.length === 0) return '';
|
|
|
|
// Calculate number of columns
|
|
const numCols = Math.max(...rows.map((row) => row.length));
|
|
|
|
// Calculate column width in twips (1440 twips = 1 inch)
|
|
// Assume standard page width of 9360 twips (6.5 inches usable)
|
|
const totalTableWidth = 9360;
|
|
const colWidth = Math.floor(totalTableWidth / numCols);
|
|
|
|
// Build table XML
|
|
let tableXml = '<w:tbl>';
|
|
|
|
// Table properties - use template table style with full width
|
|
tableXml += `<w:tblPr>
|
|
<w:tblStyle w:val="TableGrid"/>
|
|
<w:tblW w:w="0" w:type="auto"/>
|
|
<w:tblLayout w:type="fixed"/>
|
|
<w:tblLook w:val="04A0" w:firstRow="1" w:lastRow="0" w:firstColumn="0" w:lastColumn="0" w:noHBand="0" w:noVBand="1"/>
|
|
<w:tblBorders>
|
|
<w:top w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:left w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:bottom w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:right w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:insideH w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
<w:insideV w:val="single" w:sz="8" w:space="0" w:color="F58220"/>
|
|
</w:tblBorders>
|
|
</w:tblPr>`;
|
|
|
|
// Table grid with explicit column widths
|
|
tableXml += '<w:tblGrid>';
|
|
for (let i = 0; i < numCols; i++) {
|
|
tableXml += `<w:gridCol w:w="${colWidth}"/>`;
|
|
}
|
|
tableXml += '</w:tblGrid>';
|
|
|
|
// Table rows
|
|
rows.forEach((rowCells, rowIndex) => {
|
|
const isHeader = rowIndex === 0;
|
|
|
|
tableXml += '<w:tr>';
|
|
|
|
// Row properties for consistent height
|
|
tableXml += '<w:trPr><w:trHeight w:val="0" w:hRule="atLeast"/></w:trPr>';
|
|
|
|
// Pad row to have same number of columns
|
|
while (rowCells.length < numCols) {
|
|
rowCells.push('');
|
|
}
|
|
|
|
rowCells.forEach((cellText, _colIndex) => {
|
|
tableXml += '<w:tc>';
|
|
tableXml += '<w:tcPr>';
|
|
|
|
// Cell width
|
|
tableXml += `<w:tcW w:w="${colWidth}" w:type="dxa"/>`;
|
|
|
|
// Cell shading - orange for header, white for data rows
|
|
if (isHeader) {
|
|
tableXml += '<w:shd w:val="clear" w:color="auto" w:fill="F58220"/>';
|
|
} else {
|
|
tableXml += '<w:shd w:val="clear" w:color="auto" w:fill="FFFFFF"/>';
|
|
}
|
|
|
|
// Cell borders
|
|
tableXml +=
|
|
'<w:tcBorders>' +
|
|
'<w:top w:val="single" w:sz="8" w:space="0" w:color="F58220"/>' +
|
|
'<w:left w:val="single" w:sz="8" w:space="0" w:color="F58220"/>' +
|
|
'<w:bottom w:val="single" w:sz="8" w:space="0" w:color="F58220"/>' +
|
|
'<w:right w:val="single" w:sz="8" w:space="0" w:color="F58220"/>' +
|
|
'</w:tcBorders>';
|
|
|
|
// Cell margins for proper padding
|
|
tableXml +=
|
|
'<w:tcMar>' +
|
|
'<w:top w:w="80" w:type="dxa"/>' +
|
|
'<w:left w:w="120" w:type="dxa"/>' +
|
|
'<w:bottom w:w="80" w:type="dxa"/>' +
|
|
'<w:right w:w="120" w:type="dxa"/>' +
|
|
'</w:tcMar>';
|
|
|
|
tableXml += '</w:tcPr>';
|
|
|
|
// Cell content
|
|
tableXml += '<w:p>';
|
|
tableXml += '<w:pPr>';
|
|
tableXml += '<w:spacing w:before="0" w:after="0" w:line="240" w:lineRule="auto"/>';
|
|
tableXml += '</w:pPr>';
|
|
|
|
const runs = this.parseInlineFormatting(cellText);
|
|
|
|
if (isHeader) {
|
|
// Header: bold white text
|
|
tableXml += runs.replace(/<w:rPr>/g, '<w:rPr><w:b/><w:color w:val="FFFFFF"/>');
|
|
} else {
|
|
// Data rows: normal black text
|
|
tableXml += runs;
|
|
}
|
|
|
|
tableXml += '</w:p>';
|
|
tableXml += '</w:tc>';
|
|
});
|
|
|
|
tableXml += '</w:tr>';
|
|
});
|
|
|
|
tableXml += '</w:tbl>';
|
|
|
|
// Add spacing after table
|
|
tableXml += '<w:p><w:pPr><w:spacing w:before="120" w:after="0"/></w:pPr></w:p>';
|
|
|
|
return tableXml;
|
|
}
|
|
|
|
/**
|
|
* Detect if line contains ASCII art/flowchart characters
|
|
*/
|
|
isAsciiArt(line) {
|
|
// Don't treat markdown tables as ASCII art
|
|
if (line.trim().startsWith('|') && line.trim().endsWith('|')) {
|
|
// Check if it's a proper markdown table (has multiple cells)
|
|
const cells = line.split('|').filter((c) => c.trim());
|
|
if (cells.length >= 2) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Common ASCII art characters (Unicode box drawing and symbols)
|
|
const asciiArtChars = [
|
|
'─',
|
|
'│',
|
|
'┌',
|
|
'┐',
|
|
'└',
|
|
'┘',
|
|
'├',
|
|
'┤',
|
|
'┬',
|
|
'┴',
|
|
'┼', // Box drawing
|
|
'═',
|
|
'║',
|
|
'╔',
|
|
'╗',
|
|
'╚',
|
|
'╝',
|
|
'╠',
|
|
'╣',
|
|
'╦',
|
|
'╩',
|
|
'╬', // Double box
|
|
'╭',
|
|
'╮',
|
|
'╯',
|
|
'╰', // Rounded corners
|
|
'▲',
|
|
'▼',
|
|
'◄',
|
|
'►',
|
|
'♦',
|
|
'●',
|
|
'○',
|
|
'■',
|
|
'□',
|
|
'◆',
|
|
'◇', // Shapes
|
|
'↓',
|
|
'→',
|
|
'←',
|
|
'↑',
|
|
'↔',
|
|
'↕',
|
|
'⇒',
|
|
'⇐',
|
|
'⇓',
|
|
'⇑', // Arrows
|
|
'┃',
|
|
'━',
|
|
'┏',
|
|
'┓',
|
|
'┗',
|
|
'┛',
|
|
'┣',
|
|
'┫',
|
|
'┳',
|
|
'┻',
|
|
'╋', // Heavy box
|
|
'░',
|
|
'▒',
|
|
'▓',
|
|
'█', // Shading
|
|
];
|
|
|
|
// Check for box drawing characters
|
|
if (asciiArtChars.some((char) => line.includes(char))) {
|
|
return true;
|
|
}
|
|
|
|
// Check for ASCII box patterns with regular characters
|
|
const asciiPatterns = [
|
|
/^\s*\+[-=_+]+\+/, // +-----+ or +=====+
|
|
/^\s*\|[-=_]{3,}\|/, // |-----|
|
|
/^\s*[-=_]{5,}$/, // -----
|
|
/^\s*\+[-]+\+[-]+\+/, // +---+---+
|
|
/^\s*\([A-Z][a-z]+\)\s*\|\|/, // (Deformable) ||
|
|
/^\s*\|\s+[A-Z\s]+[-:]\s+[A-Z]/, // | TILE ADHESIVE - TYPE
|
|
/^\s*\|\s*\[[^\]]+\]/, // | [BIS Mark / CE Mark]
|
|
/^\s*\|\s{2,}\w+.*\|\|/, // || text ||
|
|
/^\s*\[[^\]]+\]\s*$/, // [Step in brackets]
|
|
/^\s*<[-=]+>/, // <----> or <====>
|
|
/^\s*\/[-_\\\/]+\//, // /----/
|
|
/^\s*\*[-=\*]+\*/, // *----*
|
|
];
|
|
|
|
return asciiPatterns.some((pattern) => pattern.test(line));
|
|
}
|
|
|
|
/**
|
|
* Create ASCII art XML with monospace font
|
|
* Background shading applied at paragraph level to extend full width
|
|
*/
|
|
createAsciiArtXml(asciiContent) {
|
|
// Split ASCII art into individual lines and create a paragraph for each
|
|
const lines = asciiContent.split('\n');
|
|
let xml = '';
|
|
|
|
lines.forEach((line, index) => {
|
|
// Shading (shd) is at paragraph level so background extends full width
|
|
xml += `<w:p>
|
|
<w:pPr>
|
|
<w:pStyle w:val="Normal"/>
|
|
<w:shd w:val="clear" w:color="auto" w:fill="F5F5F5"/>
|
|
<w:spacing w:before="${index === 0 ? '120' : '0'}" w:after="${index === lines.length - 1 ? '120' : '0'}" w:line="240" w:lineRule="exact"/>
|
|
<w:ind w:left="284" w:right="284"/>
|
|
<w:jc w:val="left"/>
|
|
<w:keepLines/>
|
|
<w:wordWrap w:val="0"/>
|
|
</w:pPr>`;
|
|
|
|
// Check if line contains arrow characters and color them red
|
|
const arrowChars = ['↓', '→', '←', '↑', '▼', '►', '◄', '▲'];
|
|
const hasArrow = arrowChars.some((arrow) => line.includes(arrow));
|
|
|
|
if (hasArrow) {
|
|
// Split line into parts and color arrows red
|
|
let remainingLine = line;
|
|
|
|
while (remainingLine.length > 0) {
|
|
let foundArrow = false;
|
|
let arrowIndex = -1;
|
|
let foundArrowChar = '';
|
|
|
|
// Find the first arrow in the remaining text
|
|
for (const arrow of arrowChars) {
|
|
const idx = remainingLine.indexOf(arrow);
|
|
if (idx !== -1 && (arrowIndex === -1 || idx < arrowIndex)) {
|
|
arrowIndex = idx;
|
|
foundArrowChar = arrow;
|
|
foundArrow = true;
|
|
}
|
|
}
|
|
|
|
if (foundArrow) {
|
|
// Add text before arrow (if any)
|
|
if (arrowIndex > 0) {
|
|
const beforeArrow = this.escapeXml(remainingLine.substring(0, arrowIndex));
|
|
xml += `<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="16"/>
|
|
<w:szCs w:val="16"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${beforeArrow}</w:t>
|
|
</w:r>`;
|
|
}
|
|
|
|
// Add arrow in red
|
|
const escapedArrow = this.escapeXml(foundArrowChar);
|
|
xml += `<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="16"/>
|
|
<w:szCs w:val="16"/>
|
|
<w:color w:val="FF0000"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${escapedArrow}</w:t>
|
|
</w:r>`;
|
|
|
|
// Continue with remaining text
|
|
remainingLine = remainingLine.substring(arrowIndex + foundArrowChar.length);
|
|
} else {
|
|
// No more arrows, add remaining text
|
|
const escapedRemaining = this.escapeXml(remainingLine);
|
|
xml += `<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="16"/>
|
|
<w:szCs w:val="16"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${escapedRemaining}</w:t>
|
|
</w:r>`;
|
|
remainingLine = '';
|
|
}
|
|
}
|
|
} else {
|
|
// No arrows, just add the line normally
|
|
const escapedLine = this.escapeXml(line);
|
|
xml += `<w:r>
|
|
<w:rPr>
|
|
<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>
|
|
<w:sz w:val="16"/>
|
|
<w:szCs w:val="16"/>
|
|
<w:noProof/>
|
|
</w:rPr>
|
|
<w:t xml:space="preserve">${escapedLine}</w:t>
|
|
</w:r>`;
|
|
}
|
|
|
|
xml += `</w:p>`;
|
|
});
|
|
|
|
return xml;
|
|
}
|
|
|
|
/**
|
|
* Parse inline formatting (bold, italic, code)
|
|
*/
|
|
parseInlineFormatting(text) {
|
|
let xml = '';
|
|
|
|
// Patterns for inline formatting
|
|
const patterns = [
|
|
{ regex: /\*\*\*(.+?)\*\*\*/g, bold: true, italic: true },
|
|
{ regex: /\*\*(.+?)\*\*/g, bold: true },
|
|
{ regex: /\*(.+?)\*/g, italic: true },
|
|
{ regex: /`(.+?)`/g, code: true },
|
|
];
|
|
|
|
// Simple approach: process text sequentially
|
|
let remaining = text;
|
|
|
|
while (remaining.length > 0) {
|
|
let foundMatch = false;
|
|
let earliestPos = remaining.length;
|
|
let matchedPattern = null;
|
|
let match = null;
|
|
|
|
// Find earliest match
|
|
for (const pattern of patterns) {
|
|
pattern.regex.lastIndex = 0;
|
|
const m = pattern.regex.exec(remaining);
|
|
if (m && m.index < earliestPos) {
|
|
earliestPos = m.index;
|
|
matchedPattern = pattern;
|
|
match = m;
|
|
foundMatch = true;
|
|
}
|
|
}
|
|
|
|
if (foundMatch) {
|
|
// Add text before match
|
|
if (earliestPos > 0) {
|
|
xml += this.createRunXml(remaining.substring(0, earliestPos));
|
|
}
|
|
|
|
// Add formatted text
|
|
xml += this.createRunXml(
|
|
match[1],
|
|
matchedPattern.bold,
|
|
matchedPattern.italic,
|
|
matchedPattern.code
|
|
);
|
|
|
|
remaining = remaining.substring(earliestPos + match[0].length);
|
|
} else {
|
|
// No more matches, add remaining text
|
|
xml += this.createRunXml(remaining);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return xml;
|
|
}
|
|
|
|
/**
|
|
* Create a run (text segment) XML
|
|
*/
|
|
createRunXml(text, bold = false, italic = false, code = false) {
|
|
if (!text) return '';
|
|
|
|
const escapedText = this.escapeXml(text);
|
|
let propsXml = '<w:rPr>';
|
|
|
|
if (bold) propsXml += '<w:b/>';
|
|
if (italic) propsXml += '<w:i/>';
|
|
if (code) {
|
|
propsXml += '<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas"/>';
|
|
propsXml += '<w:sz w:val="20"/>';
|
|
}
|
|
|
|
propsXml += '</w:rPr>';
|
|
|
|
return `<w:r>${propsXml}<w:t xml:space="preserve">${escapedText}</w:t></w:r>`;
|
|
}
|
|
|
|
/**
|
|
* Escape XML special characters
|
|
*/
|
|
escapeXml(text) {
|
|
return text
|
|
.replace(/&/g, '&')
|
|
.replace(/</g, '<')
|
|
.replace(/>/g, '>')
|
|
.replace(/"/g, '"')
|
|
.replace(/'/g, ''');
|
|
}
|
|
}
|
|
|
|
module.exports = WordTemplateExporter;
|