weaver-work-cli 0.1.29 → 0.1.31

package/dist/shortcuts/meeting/invitation/docx.js

@@ -0,0 +1,442 @@
+/**
+ * 邀请函 docx 渲染 —— WordPress 无关的纯 OOXML 处理，零第三方依赖。
+ *
+ * 为什么不用现成库：本 CLI 要对外分发（skill 随 CLI 走），依赖树越小越好；
+ * 而需要用到的能力只有「读 docx(zip) → 改 document.xml 文本 → 写回 docx(zip)」，
+ * 用 node 内置 zlib 即可完成，不引入 jszip 等包。
+ *
+ * ⚠️ 关键坑（2026-10-23 实测模板）：Word 会把 `{mt_name}` 这样的占位符**拆成多个 run**：
+ *   `会议名称：{` / `mt_name` / `}`
+ * 因此**不能**在 document.xml 上做字符串替换，必须按段落把 w:t 文本拼起来再替换，
+ * 否则任何占位符都替换不到（这是"模板看着没问题、一填就空"的根因）。
+ *
+ * 渲染策略：
+ * - 逐个段落处理（含表格单元格内的段落）。段落内合并文本 → 匹配 `{key}` → 按 run 回写。
+ * - 命中不了的占位符**不留字面量**：渲染成带黄色高亮的「【待补充】」，便于人工定位。
+ * - 只在段落内出现 `{` 时才重建该段；其余段落原样保留（避免无谓改动）。
+ */
+import { deflateRawSync, inflateRawSync } from 'node:zlib';
+// ---------------------------------------------------------------------------
+// ZIP（docx 就是 zip）
+// ---------------------------------------------------------------------------
+const EOCD_SIG = 0x06054b50;
+const CEN_SIG = 0x02014b50;
+const LOC_SIG = 0x04034b50;
+function findEocd(buf) {
+    const min = Math.max(0, buf.length - 0xffff - 22);
+    for (let i = buf.length - 22; i >= min; i -= 1) {
+        if (buf.readUInt32LE(i) === EOCD_SIG)
+            return i;
+    }
+    throw new Error('docx 解析失败：找不到 ZIP 结束记录（EOCD）');
+}
+/** 读取 docx（zip）的全部条目，保持原始顺序。 */
+export function readDocxEntries(buf) {
+    const eocd = findEocd(buf);
+    const count = buf.readUInt16LE(eocd + 10);
+    let offset = buf.readUInt32LE(eocd + 16);
+    const entries = [];
+    for (let i = 0; i < count; i += 1) {
+        if (buf.readUInt32LE(offset) !== CEN_SIG) {
+            throw new Error('docx 解析失败：中央目录条目签名不匹配');
+        }
+        const method = buf.readUInt16LE(offset + 10);
+        const compSize = buf.readUInt32LE(offset + 20);
+        const nameLen = buf.readUInt16LE(offset + 28);
+        const extraLen = buf.readUInt16LE(offset + 30);
+        const commentLen = buf.readUInt16LE(offset + 32);
+        const localOffset = buf.readUInt32LE(offset + 42);
+        const name = buf.subarray(offset + 46, offset + 46 + nameLen).toString('utf8');
+        if (buf.readUInt32LE(localOffset) !== LOC_SIG) {
+            throw new Error(`docx 解析失败：${name} 的本地头签名不匹配`);
+        }
+        const localNameLen = buf.readUInt16LE(localOffset + 26);
+        const localExtraLen = buf.readUInt16LE(localOffset + 28);
+        const dataStart = localOffset + 30 + localNameLen + localExtraLen;
+        const raw = buf.subarray(dataStart, dataStart + compSize);
+        const data = method === 0 ? Buffer.from(raw) : inflateRawSync(raw);
+        entries.push({ name, data });
+        offset += 46 + nameLen + extraLen + commentLen;
+    }
+    return entries;
+}
+const CRC_TABLE = (() => {
+    const table = new Int32Array(256);
+    for (let i = 0; i < 256; i += 1) {
+        let c = i;
+        for (let k = 0; k < 8; k += 1)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[i] = c;
+    }
+    return table;
+})();
+function crc32(buf) {
+    let crc = -1;
+    for (let i = 0; i < buf.length; i += 1)
+        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+    return (crc ^ -1) >>> 0;
+}
+function dosDateTime(date) {
+    const time = ((date.getHours() << 11) | (date.getMinutes() << 5) | (date.getSeconds() >> 1)) & 0xffff;
+    const d = (((date.getFullYear() - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate()) & 0xffff;
+    return { time, date: d };
+}
+/** 把条目写回 docx（deflate，必要时降级 store）。 */
+export function writeDocxEntries(entries, now = new Date()) {
+    const { time, date } = dosDateTime(now);
+    const locals = [];
+    const centrals = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const nameBuf = Buffer.from(entry.name, 'utf8');
+        const crc = crc32(entry.data);
+        const deflated = deflateRawSync(entry.data);
+        const useDeflate = deflated.length < entry.data.length;
+        const payload = useDeflate ? deflated : entry.data;
+        const method = useDeflate ? 8 : 0;
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(LOC_SIG, 0);
+        local.writeUInt16LE(20, 4); // version needed
+        local.writeUInt16LE(0x0800, 6); // UTF-8 文件名
+        local.writeUInt16LE(method, 8);
+        local.writeUInt16LE(time, 10);
+        local.writeUInt16LE(date, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(payload.length, 18);
+        local.writeUInt32LE(entry.data.length, 22);
+        local.writeUInt16LE(nameBuf.length, 26);
+        local.writeUInt16LE(0, 28);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(CEN_SIG, 0);
+        central.writeUInt16LE(20, 4); // version made by
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(method, 10);
+        central.writeUInt16LE(time, 12);
+        central.writeUInt16LE(date, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(payload.length, 20);
+        central.writeUInt32LE(entry.data.length, 24);
+        central.writeUInt16LE(nameBuf.length, 28);
+        central.writeUInt16LE(0, 30);
+        central.writeUInt16LE(0, 32);
+        central.writeUInt16LE(0, 34);
+        central.writeUInt16LE(0, 36);
+        central.writeUInt32LE(0, 38);
+        central.writeUInt32LE(offset, 42);
+        locals.push(local, nameBuf, payload);
+        centrals.push(central, nameBuf);
+        offset += local.length + nameBuf.length + payload.length;
+    }
+    const centralBuf = Buffer.concat(centrals);
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(EOCD_SIG, 0);
+    eocd.writeUInt16LE(0, 4);
+    eocd.writeUInt16LE(0, 6);
+    eocd.writeUInt16LE(entries.length, 8);
+    eocd.writeUInt16LE(entries.length, 10);
+    eocd.writeUInt32LE(centralBuf.length, 12);
+    eocd.writeUInt32LE(offset, 16);
+    eocd.writeUInt16LE(0, 20);
+    return Buffer.concat([...locals, centralBuf, eocd]);
+}
+export const PENDING_MARK = '【待补充】';
+function unescapeXml(text) {
+    return text
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+function escapeXml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const PLACEHOLDER_RE = /\{([A-Za-z_][A-Za-z0-9_.]*)\}/g;
+/** 非全局版本：只用来判断「这段文本里到底有没有占位符」。 */
+const PLACEHOLDER_TEST = /\{[A-Za-z_][A-Za-z0-9_.]*\}/;
+/**
+ * 段落内若存在绘图/超链接/域/内容控件等非纯文本结构，重建会破坏它们 ⇒ 跳过该段。
+ * 模板是纯文本段落 + 普通表格，正常不会命中；命中时如实计入 skippedParagraphs。
+ */
+const UNSAFE_PARAGRAPH_RE = /<w:(drawing|pict|hyperlink|fldSimple|sdt|object|txbxContent)\b/;
+/** 提取段落的 w:pPr（原样保留）与内容体。 */
+function splitParagraph(paraXml) {
+    const openMatch = /^<w:p(?:\s[^>]*)?>/.exec(paraXml);
+    const open = openMatch ? openMatch[0] : '<w:p>';
+    let body = paraXml.slice(open.length).replace(/<\/w:p>\s*$/, '');
+    let pPr = '';
+    const pPrMatch = /^<w:pPr>[\s\S]*?<\/w:pPr>/.exec(body);
+    if (pPrMatch) {
+        pPr = pPrMatch[0];
+        body = body.slice(pPr.length);
+    }
+    return { open, pPr, body };
+}
+function parseRuns(body) {
+    const runs = [];
+    const runRe = /<w:r(?:\s[^>]*)?>([\s\S]*?)<\/w:r>/g;
+    let match;
+    while ((match = runRe.exec(body)) !== null) {
+        const inner = match[1];
+        const rPrMatch = /<w:rPr>[\s\S]*?<\/w:rPr>/.exec(inner);
+        const rPr = rPrMatch ? rPrMatch[0] : '';
+        let text = '';
+        const tRe = /<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>/g;
+        let tMatch;
+        while ((tMatch = tRe.exec(inner)) !== null)
+            text += unescapeXml(tMatch[1]);
+        runs.push({ rPr, text });
+    }
+    return runs;
+}
+function withHighlight(rPr) {
+    const highlight = '<w:highlight w:val="yellow"/>';
+    if (!rPr)
+        return `<w:rPr>${highlight}</w:rPr>`;
+    if (rPr.includes('<w:highlight'))
+        return rPr;
+    // 插入到 rPr 末尾（rPr 内元素顺序对 Word 不严格，highlight 放在最后可被正确识别）
+    return rPr.replace(/<\/w:rPr>$/, `${highlight}</w:rPr>`);
+}
+function emitRun(rPr, text) {
+    // xml:space="preserve" 防止首尾空格被吞
+    return `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r>`;
+}
+/**
+ * 替换单个段落中的占位符。
+ * 文本按 run 顺序合并后匹配，替换结果尽量写回**占位符起点所在的 run**，
+ * 其余 run 仅删除占位符所占字符 —— 这样段落内其他文字的格式不受影响。
+ *
+ * 返回值语义：
+ * - `null`：该段无需/无法处理（不含占位符，或没有文本 run）
+ * - `'unsafe'`：含占位符但段落里有图片/超链接等结构，重建会破坏它 ⇒ 跳过并计数
+ * - `string`：替换后的段落 XML
+ */
+function replaceInParagraph(paraXml, resolver, filled, pending) {
+    if (!paraXml.includes('{'))
+        return null;
+    const { open, pPr, body } = splitParagraph(paraXml);
+    const runs = parseRuns(body);
+    if (runs.length === 0)
+        return null;
+    const concat = runs.map((run) => run.text).join('');
+    // ⚠️ 必须在**合并后的文本**上判断占位符：Word 把 `{mt_name}` 拆成多个 run，
+    // 直接在原始 XML 上匹配 `\{key\}` 永远匹配不到（首版就踩了这个坑）。
+    if (!PLACEHOLDER_TEST.test(concat))
+        return null;
+    if (UNSAFE_PARAGRAPH_RE.test(paraXml))
+        return 'unsafe';
+    PLACEHOLDER_RE.lastIndex = 0;
+    const matches = [...concat.matchAll(PLACEHOLDER_RE)];
+    if (matches.length === 0)
+        return null;
+    // 每个 run 在 concat 中的区间
+    const spans = [];
+    let cursor = 0;
+    for (const run of runs) {
+        spans.push({ start: cursor, end: cursor + run.text.length });
+        cursor += run.text.length;
+    }
+    const runAt = (pos) => {
+        for (let i = 0; i < spans.length; i += 1)
+            if (pos >= spans[i].start && pos < spans[i].end)
+                return i;
+        return spans.length - 1;
+    };
+    // 用**字符级归属**做替换：每个字符记住它来自哪个 run、是否属于【待补充】。
+    // 这样"取不到值"时只把【待补充】这三个字标黄，而不会把整个 run（整句）染黄
+    // —— 2026-10-28 用户反馈：「【待补充】 诚邀您参加「…」，现将会议安排通知如下：」整行都是黄底，
+    // 实际只有召集人那一段该高亮。
+    const units = [];
+    runs.forEach((run, index) => {
+        for (const ch of run.text)
+            units.push({ ch, run: index, highlight: false });
+    });
+    // 从后往前替换，避免前面替换影响后面区间（units 的下标与 concat 一一对应）
+    for (const match of [...matches].reverse()) {
+        const key = match[1];
+        const start = match.index ?? 0;
+        const end = start + match[0].length;
+        const value = resolver(key);
+        // 取不到值时只渲染【待补充】（不回显 dataKey）。
+        // 2026-10-28 真机：模板「尊敬的 {guest_org}：」渲染成了「尊敬的 【待补充】：guest_org：」——
+        // 原因是 resolver 对缺失字段返回 `text=key`，拼进去把字段名漏进了**对外的邀请函**。
+        // 字段名仍然通过返回值 pendingFields 告诉调用方，不必写在文档正文里。
+        const text = value.pending ? PENDING_MARK : value.text;
+        (value.pending ? pending : filled).push(key);
+        const firstRun = runAt(start);
+        const replacement = [...text].map((ch) => ({ ch, run: firstRun, highlight: Boolean(value.pending) }));
+        units.splice(start, end - start, ...replacement);
+    }
+    // 相邻且（run 相同 / 格式与高亮相同）的字符合并回 run
+    const merged = [];
+    for (const unit of units) {
+        const rPr = runs[unit.run]?.rPr ?? '';
+        const last = merged[merged.length - 1];
+        if (last && last.rPr === rPr && last.highlight === unit.highlight)
+            last.text += unit.ch;
+        else
+            merged.push({ text: unit.ch, rPr, highlight: unit.highlight });
+    }
+    const rendered = merged
+        .map((run) => emitRun(run.highlight ? withHighlight(run.rPr) : run.rPr, run.text))
+        .join('');
+    return `${open}${pPr}${rendered}</w:p>`;
+}
+/** 在整份 XML（document.xml / header*.xml / footer*.xml）上替换占位符。 */
+export function replacePlaceholdersInXml(xml, resolver) {
+    const filled = [];
+    const pending = [];
+    let skippedParagraphs = 0;
+    const output = xml.replace(/<w:p(?:\s[^>]*)?>[\s\S]*?<\/w:p>/g, (paraXml) => {
+        if (!paraXml.includes('{'))
+            return paraXml;
+        const replaced = replaceInParagraph(paraXml, resolver, filled, pending);
+        if (replaced === 'unsafe') {
+            skippedParagraphs += 1;
+            return paraXml;
+        }
+        if (replaced === null)
+            return paraXml;
+        return replaced;
+    });
+    return {
+        xml: output,
+        filled: [...new Set(filled)],
+        pending: [...new Set(pending)],
+        skippedParagraphs,
+    };
+}
+const TR_RE = /<w:tr(?:\s[^>]*)?>[\s\S]*?<\/w:tr>/g;
+const TC_RE = /<w:tc(?:\s[^>]*)?>[\s\S]*?<\/w:tc>/g;
+const WT_RE = /<w:t(?:\s[^>]*)?>([^<]*)<\/w:t>/g;
+function cellText(tc) {
+    return [...tc.matchAll(WT_RE)].map((match) => unescapeXml(match[1])).join('');
+}
+/**
+ * 把单元格文字整体换掉，同时保留原有格式。
+ *
+ * Word 的单元格内可能有多个段落、每个段落多个 run。这里压成**一段一个 run**：
+ * 段落属性取原第一段，run 属性优先取原第一个 run（否则回退段落标记的 rPr）。
+ * 模板每格都是一段，所以压平不会丢版式。
+ */
+function setCellText(tc, text) {
+    const tcOpen = /^<w:tc(?:\s[^>]*)?>/.exec(tc)?.[0] ?? '<w:tc>';
+    const tcPr = /<w:tcPr>[\s\S]*?<\/w:tcPr>/.exec(tc)?.[0] ?? '';
+    const paragraphs = tc.match(/<w:p(?:\s[^>]*)?>[\s\S]*?<\/w:p>/g) ?? [];
+    const firstParagraph = paragraphs[0] ?? '<w:p></w:p>';
+    const pOpen = /^<w:p(?:\s[^>]*)?>/.exec(firstParagraph)?.[0] ?? '<w:p>';
+    const pPr = /<w:pPr>[\s\S]*?<\/w:pPr>/.exec(firstParagraph)?.[0] ?? '';
+    const firstRun = /<w:r(?:\s[^>]*)?>[\s\S]*?<\/w:r>/.exec(firstParagraph)?.[0] ?? '';
+    const rPr = /<w:rPr>[\s\S]*?<\/w:rPr>/.exec(firstRun)?.[0] ??
+        /<w:rPr>[\s\S]*?<\/w:rPr>/.exec(pPr)?.[0] ??
+        '';
+    const run = text ? `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r>` : '';
+    return `${tcOpen}${tcPr}${pOpen}${pPr}${run}</w:p></w:tc>`;
+}
+/**
+ * 在 document.xml 上按「表头关键字」定位表格，重建数据行。
+ *
+ * 没有匹配到表格、或 `rows` 为空时**原样返回**（`filled:false`）——
+ * 「没有议题就保持模板原样」是产品口径，不能把示例行清空。
+ */
+export function fillTableRowsInXml(xml, option) {
+    const rows = option.rows.filter((row) => row.some((cell) => String(cell ?? '').trim() !== ''));
+    if (rows.length === 0)
+        return { xml, filled: false, rowCount: 0 };
+    const tables = [...xml.matchAll(/<w:tbl(?:\s[^>]*)?>[\s\S]*?<\/w:tbl>/g)];
+    for (const table of tables) {
+        const tableXml = table[0];
+        const tableRows = tableXml.match(TR_RE) ?? [];
+        if (tableRows.length < 2)
+            continue;
+        const headerRow = tableRows[0];
+        const headerText = (headerRow.match(TC_RE) ?? []).map(cellText).join(' ');
+        if (!headerText.includes(option.headerKeyword))
+            continue;
+        const dataRows = tableRows.slice(1);
+        const cloneSource = dataRows[dataRows.length - 1];
+        // 斑马纹：模板里的数据行通常给「1 行带底纹 + 1 行无底纹」两种样式。
+        // 原来按 `dataRows[index]` 取样式，超过模板行数后就一直克隆最后一行，
+        // 于是第 3 行起全是同一种底色、条纹断掉（2026-10-28 用户反馈：第一行淡蓝、后面全白）。
+        // 这里改成按**数据行序号奇偶**套用「有底纹 / 无底纹」两种模板行：
+        // 奇数行（index 0、2、4…）用带底纹那行，偶数行用无底纹那行；模板只有一种样式时保持原行为。
+        const shadingFill = (rowXml) => {
+            const matched = /<w:shd\b[^>]*w:fill="([^"]*)"/.exec(rowXml);
+            return (matched?.[1] ?? '').trim().toUpperCase();
+        };
+        const isShadedRow = (rowXml) => {
+            const fill = shadingFill(rowXml);
+            return fill !== '' && fill !== 'AUTO' && fill !== 'FFFFFF';
+        };
+        const shadedRow = dataRows.find((row) => isShadedRow(row));
+        const plainRow = dataRows.find((row) => !isShadedRow(row));
+        const hasZebra = Boolean(shadedRow && plainRow);
+        const rebuilt = [headerRow];
+        rows.forEach((values, index) => {
+            // 有斑马纹模板：奇数行（0-based 偶数）用带底纹行，偶数行用无底纹行
+            const base = hasZebra
+                ? (index % 2 === 0 ? shadedRow : plainRow)
+                : (dataRows[index] ?? cloneSource);
+            const trOpen = /^<w:tr(?:\s[^>]*)?>/.exec(base)?.[0] ?? '<w:tr>';
+            const trPr = /<w:trPr>[\s\S]*?<\/w:trPr>/.exec(base)?.[0] ?? '';
+            const cells = base.match(TC_RE) ?? [];
+            const rebuiltCells = cells.map((cell, cellIndex) => setCellText(cell, values[cellIndex] ?? ''));
+            rebuilt.push(`${trOpen}${trPr}${rebuiltCells.join('')}</w:tr>`);
+        });
+        // 表格根节点之后的部分（</w:tbl>）保留，之前的 tblPr / tblGrid 也保留
+        const firstRowIndex = tableXml.indexOf(headerRow);
+        const head = tableXml.slice(0, firstRowIndex);
+        const newTableXml = `${head}${rebuilt.join('')}</w:tbl>`;
+        const start = table.index ?? 0;
+        return {
+            xml: `${xml.slice(0, start)}${newTableXml}${xml.slice(start + tableXml.length)}`,
+            filled: true,
+            rowCount: rows.length,
+        };
+    }
+    return { xml, filled: false, rowCount: 0 };
+}
+/** 需要处理的 XML 部件（正文 + 页眉页脚 + 脚注尾注）。 */
+const TEXT_PART_RE = /^word\/(document|header\d*|footer\d*|footnotes|endnotes)\.xml$/;
+/** 渲染整个 docx：替换所有文本部件里的占位符，其余条目原样保留。 */
+export function renderDocx(template, resolver, options = {}) {
+    const entries = readDocxEntries(template);
+    const filled = new Set();
+    const pending = new Set();
+    let skippedParagraphs = 0;
+    let agenda;
+    const updated = entries.map((entry) => {
+        if (!TEXT_PART_RE.test(entry.name))
+            return entry;
+        let xml = entry.data.toString('utf8');
+        // 表格行填充必须**先于**占位符替换：重建行会把单元格压成单 run，
+        // 若先替换再重建，占位符所在的 run 结构会被丢弃。
+        if (options.agenda && entry.name === 'word/document.xml') {
+            const tableResult = fillTableRowsInXml(xml, options.agenda);
+            agenda = { filled: tableResult.filled, rowCount: tableResult.rowCount };
+            xml = tableResult.xml;
+        }
+        if (!xml.includes('{')) {
+            return xml === entry.data.toString('utf8') ? entry : { name: entry.name, data: Buffer.from(xml, 'utf8') };
+        }
+        const result = replacePlaceholdersInXml(xml, resolver);
+        result.filled.forEach((key) => filled.add(key));
+        result.pending.forEach((key) => pending.add(key));
+        skippedParagraphs += result.skippedParagraphs;
+        return { name: entry.name, data: Buffer.from(result.xml, 'utf8') };
+    });
+    return {
+        buffer: writeDocxEntries(updated),
+        filled: [...filled],
+        pending: [...pending],
+        skippedParagraphs,
+        ...(options.agenda ? { agenda: agenda ?? { filled: false, rowCount: 0 } } : {}),
+    };
+}