word 导出获取文件流

[XiYang66]

请问如何获取导出word方法的文件流

instance.executeExportDocx({
  fileName: string
})```

[wYuJian]

查看源码executeExportDocx，有转换blob。

[chanceab]

建议搞一个自定义插件 复制源码 稍微修改一下

instance.use(docxPlugin);
instance.use(wordPlus);

function saveAs(blob: Blob, name: string) {
  const a = document.createElement('a');
  a.href = window.URL.createObjectURL(blob);
  a.download = name;
  a.click();
  window.URL.revokeObjectURL(a.href);
}

if (edit.command?.executeExportDocx) {
  // @ts-ignore
  const blob = await edit.command!.executeExportDocx(
    edit.command,
  );
  // 保存
  saveAs(blob, 'word.docx');
}

// @ts-ignore
import Color from 'color';
import {
  Document,
  ExternalHyperlink,
  Footer,
  Header,
  HeadingLevel,
  ImageRun,
  MathRun,
  Packer,
  Paragraph,
  ParagraphChild,
  Tab,
  Table,
  TableCell,
  TableRow,
  TextRun,
  WidthType,
} from 'docx';
import Editor, {
  Command,
  ElementType,
  IElement,
  ListStyle,
  TitleLevel,
} from '../../editor';

export interface IExportDocxOption {
  fileName: string;
}

const titleLevelToHeadingLevel = {
  [TitleLevel.FIRST]: HeadingLevel.HEADING_1,
  [TitleLevel.SECOND]: HeadingLevel.HEADING_2,
  [TitleLevel.THIRD]: HeadingLevel.HEADING_3,
  [TitleLevel.FOURTH]: HeadingLevel.HEADING_4,
  [TitleLevel.FIFTH]: HeadingLevel.HEADING_5,
  [TitleLevel.SIXTH]: HeadingLevel.HEADING_6,
};

type DocxChildren = (Paragraph | Table)[];
function convertElementToParagraphChild(element: IElement): ParagraphChild {
  if (element.type === ElementType.IMAGE) {
    return new ImageRun({
      data: element.value,
      transformation: {
        width: element.width!,
        height: element.height!,
      },
    });
  }
  if (element.type === ElementType.HYPERLINK) {
    return new ExternalHyperlink({
      children: [
        new TextRun({
          text: element.valueList?.map((child) => child.value).join(''),
          style: 'Hyperlink',
        }),
      ],
      link: element.url!,
    });
  }
  if (element.type === ElementType.TAB) {
    return new TextRun({
      children: [new Tab()],
    });
  }
  if (element.type === ElementType.LATEX) {
    return new MathRun(element.value);
  }
  return new TextRun({
    font: element.font,
    text: element.value,
    bold: element.bold,
    size: `${(element.size || 16) / 0.75}pt`,
    color: Color(element.color).hex() || '#000000',
    italics: element.italic,
    strike: element.strikeout,
    highlight: element.highlight ? Color(element.highlight).hex() : undefined,
    superScript: element.type === ElementType.SUPERSCRIPT,
    subScript: element.type === ElementType.SUBSCRIPT,
    underline: element.underline ? {} : undefined,
  });
}

function convertElementListToDocxChildren(
  elementList: IElement[],
): DocxChildren {
  const children: DocxChildren = [];

  let paragraphChild: ParagraphChild[] = [];

  function appendParagraph() {
    if (paragraphChild.length) {
      children.push(
        new Paragraph({
          children: paragraphChild,
        }),
      );
      paragraphChild = [];
    }
  }

  for (let e = 0; e < elementList.length; e++) {
    const element = elementList[e];
    if (element.type === ElementType.TITLE) {
      appendParagraph();
      children.push(
        new Paragraph({
          heading: titleLevelToHeadingLevel[element.level!],
          children:
            element.valueList?.map((child) =>
              convertElementToParagraphChild(child),
            ) || [],
        }),
      );
    } else if (element.type === ElementType.LIST) {
      appendParagraph();
      // 拆分列表
      const listChildren =
        element.valueList
          ?.map((item) => item.value)
          .join('')
          .split('\n')
          .map(
            (text, index) =>
              new Paragraph({
                children: [
                  new TextRun({
                    text: `${
                      !element.listStyle ||
                      element.listStyle === ListStyle.DECIMAL
                        ? `${index + 1}. `
                        : `• `
                    }${text}`,
                  }),
                ],
              }),
          ) || [];
      children.push(...listChildren);
    } else if (element.type === ElementType.TABLE) {
      appendParagraph();
      const { trList } = element;
      const tableRowList: TableRow[] = [];
      for (let r = 0; r < trList!.length; r++) {
        const tdList = trList![r].tdList;
        const tableCellList: TableCell[] = [];
        for (let c = 0; c < tdList.length; c++) {
          const td = tdList[c];
          tableCellList.push(
            new TableCell({
              columnSpan: td.colspan,
              rowSpan: td.rowspan,
              children: convertElementListToDocxChildren(td.value) || [],
            }),
          );
        }
        tableRowList.push(
          new TableRow({
            children: tableCellList,
          }),
        );
      }
      children.push(
        new Table({
          rows: tableRowList,
          width: {
            size: '100%',
            type: WidthType.PERCENTAGE,
          },
        }),
      );
    } else if (element.type === ElementType.DATE) {
      paragraphChild.push(
        ...(element.valueList?.map((child) =>
          convertElementToParagraphChild(child),
        ) || []),
      );
    } else {
      if (/^\n/.test(element.value)) {
        appendParagraph();
        element.value = element.value.replace(/^\n/, '');
      }
      paragraphChild.push(convertElementToParagraphChild(element));
    }
  }
  appendParagraph();
  return children;
}

export function wordPlus(editor: Editor) {
  if ((editor.command as any)?.executeExportDocx) {
    (editor.command as any).executeExportDocx = (command: Command) => {
      const {
        data: { header, main, footer },
      } = command.getValue();

      const doc = new Document({
        sections: [
          {
            headers: {
              default: new Header({
                children: convertElementListToDocxChildren(header || []),
              }),
            },
            footers: {
              default: new Footer({
                children: convertElementListToDocxChildren(footer || []),
              }),
            },
            children: convertElementListToDocxChildren(main || []),
          },
        ],
      });

      Packer.toBlob(doc as any).then((blob) => {
        return blob;
      });
    };
  }
}