自定义节点导出为 Word、PDF 与 OFD

import { docx } from '@quirekit/lit-docx';
import type { Nodes } from 'mdast';
import { markdownExportTemplateService, type MarkdownDocxExtension } from '@quirekit/markdown-docx';
import { defaultExportTemplate } from '@quirekit/export-template';
import { approvalCardMarkdown, readApprovalCard } from './data';
import type { ApprovalCardNode } from './types';

const tag = 'example:approval-card';

/** @returns A standalone converter shared by Word and PDF; no editor or browser required. */
export function createApprovalCardExtension(): MarkdownDocxExtension {
  return {
    name: 'example.approval-card',
    prepare(root, context) {
      // Claim only validated fences. Invalid input remains ordinary code, with
      // a loss report; unrelated code and the caller's source are unchanged.
      /** @param node - Source subtree. @returns A fresh export-only projection. */
      function visit(node: Nodes): Nodes {
        if (node.type === 'code' && node.lang === 'approval-card') {
          try {
            if (node.value.length > 24_000) throw new Error('Card source exceeds its budget.');
            const data = readApprovalCard(JSON.parse(node.value));
            const card: ApprovalCardNode = { type: 'exampleApprovalCard', card: data, position: node.position,
              children: data.paragraphs.map(text => ({ type: 'paragraph', children: [{ type: 'text', value: text }] })) };
            return card;
          } catch {
            context.report({ code: 'approval-card-invalid', path: `/source/${node.position?.start.offset ?? 0}`,
              severity: 'warning', disposition: 'approximated', message: 'Invalid card data was retained as source code.' });
            return node;
          }
        }
        return 'children' in node ? { ...node, children: node.children.map(visit) } as Nodes : node;
      }
      return { ...root, children: root.children.map(node => visit(node) as typeof node) };
    },
    addDocx: () => docx.codec.node<Nodes, never>({
      id: 'example.approval-card', modelType: 'exampleApprovalCard',
      export: { convert: ({ node, docx: api, convertChildren, resolveService }) => {
        if (node.type !== 'exampleApprovalCard') throw new Error('Unexpected card node.');
        // Use the resolved template, then let the common projector constrain
        // the table width and Classic paginate it. Never set a fixed row height.
        const style = (resolveService(markdownExportTemplateService) ?? defaultExportTemplate.style).containers.note;
        const border = { val: style.border ? 'single' : 'nil', color: style.border?.color ?? 'auto',
          sz: Math.round((style.border?.width ?? 0) * 8), space: 0 };
        const padding = Math.round(style.padding * 20); // Template pt → native cell twips.
        const children = [api.blocks.paragraph({ properties: { keepNext: true },
          children: [api.inline.text(node.card.title, { marks: [api.marks.bold()] })] }), ...convertChildren(node.children)];
        const styled = children.map(child => ({ ...child, attrs: { ...child.attrs, styleId: 'QuireKitContainer_note' } }));
        const cell = api.tables.cell({ children: styled, width: { value: 5000, type: 'pct' },
          shading: { val: style.fill ? 'clear' : 'nil', fill: style.fill ?? 'auto' },
          borders: { top: border, bottom: border, left: border, right: border } });
        const table = api.tables.table({ width: { value: 5000, type: 'pct' }, rows: [api.tables.row({ cells: [
          { ...cell, attrs: { ...cell.attrs, cellMargins: { top: padding, bottom: padding, left: padding, right: padding } } },
        ] })] });
        return [api.roundTrip.taggedBlock({ tag, alias: node.card.title, children: [table],
          metadata: { version: 1, data: { title: node.card.title, paragraphs: [...node.card.paragraphs] } } })];
      } },
      import: { from: docx.roundTrip.matchTag(tag), creates: ['docxSource', 'paragraph', 'heading', 'list', 'blockquote', 'code', 'table', 'thematicBreak'],
        convert: ({ node, docx: api, convertChildren, report }) => {
          // The shared codec first verifies visible-content fingerprints. Then
          // validate our own payload/version; never resurrect stale Word text.
          const metadata = api.roundTrip.readMetadata(node);
          if (metadata?.version === 1) {
            try { return [{ type: 'docxSource', value: approvalCardMarkdown(readApprovalCard(metadata.data)) }]; }
            catch { /* Invalid business data must use the current visible content. */ }
          }
          report({ code: 'approval-card-source-unavailable', severity: 'warning', disposition: 'approximated',
            message: 'Card metadata is unavailable; current visible content was retained.' });
          const children = (node.children ?? []).flatMap(child => child.type === 'table' && child.children?.length === 1
            && child.children[0]?.children?.length === 1 ? child.children[0].children[0]!.children ?? [] : [child]);
          return convertChildren(children);
        } },
    }),
  };
}

import { createMarkdownDocxCodeImageExtension, type MarkdownDocxCodeImageRequest, type MarkdownDocxExtension } from '@quirekit/markdown-docx';

/**
 * Draws a bounded chart from source data without reading a mounted editor view.
 * @param request - A progress-chart fence containing a JSON number array.
 * @param ownerDocument - Explicit browser capability owned by this export.
 * @param signal - Cancellation of this export, not a global editor signal.
 * @returns A complete PNG data URI; malformed data throws for the shared source fallback.
 */
export async function renderProgressChart(request: MarkdownDocxCodeImageRequest, ownerDocument: Document, signal?: AbortSignal): Promise<string> {
  signal?.throwIfAborted();
  if (request.language !== 'progress-chart' || request.value.length > 2000) throw new Error('Unsupported chart input.');
  const values: unknown = JSON.parse(request.value);
  if (!Array.isArray(values) || !values.length || values.length > 12
    || values.some(value => typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 100)) throw new Error('Expected 1–12 values between 0 and 100.');
  const canvas = ownerDocument.createElement('canvas');
  // Raster dimensions are fixed and bounded. The common exporter separately
  // fits this image to the current page/cell width without changing its ratio.
  canvas.width = 1200; canvas.height = 480;
  try {
    const context = canvas.getContext('2d');
    if (!context) throw new Error('Canvas 2D is unavailable.');
    context.fillStyle = '#FFFFFF'; context.fillRect(0, 0, canvas.width, canvas.height);
    context.fillStyle = '#172033'; context.font = 'bold 32px sans-serif'; context.fillText('Progress', 40, 52);
    const step = 1120 / values.length;
    values.forEach((value: number, index: number) => {
      const height = value * 3;
      context.fillStyle = '#4F63D8'; context.fillRect(40 + step * index, 410 - height, step * .65, height);
      context.fillStyle = '#172033'; context.font = '24px sans-serif'; context.fillText(String(value), 40 + step * index, 444);
    });
    signal?.throwIfAborted();
    return canvas.toDataURL('image/png');
  } finally { canvas.width = 0; canvas.height = 0; }
}

/**
 * Registers the image recipe for a standalone conversion operation.
 * @param ownerDocument - Browser capability used for offscreen rendering.
 * @param signal - Optional operation cancellation.
 * @param metadata - Word source recovery; PDF has no round-trip store.
 * @returns The one code-image owner. Merge other languages into its renderer when composing with Mermaid.
 */
export function createProgressChartExtension(ownerDocument: Document, signal?: AbortSignal, metadata = true): MarkdownDocxExtension {
  return createMarkdownDocxCodeImageExtension({ languages: ['progress-chart'], metadata,
    render: request => renderProgressChart(request, ownerDocument, signal) });
}