@open-egretta/lexical-export-docx 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 open-egretta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# @open-egretta/lexical-export-docx
+
+Export [Lexical](https://lexical.dev/) editor content to `.docx` format.
+
+## Installation
+
+```bash
+npm install @open-egretta/lexical-export-docx
+```
+
+Requires `lexical >= 0.41.0` as a peer dependency.
+
+## Usage
+
+### Inside a React component
+
+```ts
+import { exportDocx } from "@open-egretta/lexical-export-docx";
+
+// editor is a LexicalEditor instance
+const blob = await exportDocx(editor);
+
+const url = URL.createObjectURL(blob);
+const a = document.createElement("a");
+a.href = url;
+a.download = "document.docx";
+a.click();
+URL.revokeObjectURL(url);
+```
+
+### From JSON (SSR / Node.js)
+
+```ts
+import { exportDocxFromJSON } from "@open-egretta/lexical-export-docx";
+import type { SerializedEditorState } from "lexical";
+
+const json: SerializedEditorState = {
+  /* ... */
+};
+const blob = await exportDocxFromJSON(json);
+```
+
+## API
+
+### `exportDocx(editor: LexicalEditor): Promise<Blob>`
+
+Reads the current editor state and returns a `.docx` `Blob`. Use this inside a React component where you have access to the `LexicalEditor` instance.
+
+### `exportDocxFromJSON(json: SerializedEditorState): Promise<Blob>`
+
+Converts a serialized editor state directly to a `.docx` `Blob`. Has zero dependency on the Lexical runtime — suitable for SSR, testing, and Node.js environments.
+
+## Supported nodes
+
+| Node        | Details                     |
+| ----------- | --------------------------- |
+| `paragraph` | Plain paragraph             |
+| `heading`   | h1 – h6                     |
+| `text`      | Bold, italic, underline     |
+| `list`      | Bullet and numbered, nested |
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,145 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  exportDocx: () => exportDocx,
+  exportDocxFromJSON: () => exportDocxFromJSON
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/builder.ts
+var import_docx = require("docx");
+async function buildDocx(elements) {
+  const doc = new import_docx.Document({
+    //
+    numbering: {
+      config: [
+        {
+          reference: "default-numbering",
+          levels: [
+            {
+              level: 0,
+              format: import_docx.NumberFormat.DECIMAL,
+              text: "%1.",
+              alignment: import_docx.AlignmentType.LEFT,
+              style: {
+                paragraph: {
+                  indent: { left: 480, hanging: 480 }
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    //
+    sections: [
+      {
+        children: elements
+      }
+    ]
+  });
+  return import_docx.Packer.toBlob(doc);
+}
+
+// src/nodes/paragraph.ts
+var import_docx3 = require("docx");
+
+// src/nodes/text.ts
+var import_docx2 = require("docx");
+function convertText(node) {
+  return new import_docx2.TextRun({
+    text: node.text,
+    bold: (node.format & 1) !== 0,
+    italics: (node.format & 2) !== 0,
+    underline: (node.format & 8) !== 0 ? {} : void 0
+  });
+}
+
+// src/nodes/paragraph.ts
+function convertParagraph(node) {
+  const runs = node.children.filter((child) => child.type === "text").map((child) => convertText(child));
+  return new import_docx3.Paragraph({ children: runs });
+}
+
+// src/nodes/heading.ts
+var import_docx4 = require("docx");
+var HEADING_MAP = {
+  h1: import_docx4.HeadingLevel.HEADING_1,
+  h2: import_docx4.HeadingLevel.HEADING_2,
+  h3: import_docx4.HeadingLevel.HEADING_3,
+  h4: import_docx4.HeadingLevel.HEADING_4,
+  h5: import_docx4.HeadingLevel.HEADING_5,
+  h6: import_docx4.HeadingLevel.HEADING_6
+};
+function convertHeading(node) {
+  const runs = node.children.filter((child) => child.type === "text").map((child) => convertText(child));
+  return new import_docx4.Paragraph({
+    heading: HEADING_MAP[node.tag],
+    children: runs
+  });
+}
+
+// src/nodes/list.ts
+var import_docx5 = require("docx");
+function convertList(node) {
+  return node.children.filter(
+    (child) => child.type === "listitem"
+  ).map((item) => {
+    const runs = item.children.filter((child) => child.type === "text").map((child) => convertText(child));
+    return new import_docx5.Paragraph({
+      bullet: node.listType === "bullet" ? { level: item.indent } : void 0,
+      numbering: node.listType === "number" ? { reference: "default-numbering", level: item.indent } : void 0,
+      children: runs
+    });
+  });
+}
+
+// src/serializer.ts
+function serialize(children) {
+  return children.flatMap((node) => {
+    switch (node.type) {
+      case "paragraph":
+        return convertParagraph(node);
+      case "list":
+        return convertList(node);
+      case "heading":
+        return convertHeading(node);
+      default:
+        return [];
+    }
+  });
+}
+
+// src/index.ts
+async function exportDocx(editor) {
+  const json = editor.getEditorState().toJSON();
+  return exportDocxFromJSON(json);
+}
+async function exportDocxFromJSON(json) {
+  const elements = serialize(json.root.children);
+  return buildDocx(elements);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportDocx,
+  exportDocxFromJSON
+});

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+import { LexicalEditor, SerializedEditorState } from 'lexical';
+
+declare function exportDocx(editor: LexicalEditor): Promise<Blob>;
+declare function exportDocxFromJSON(json: SerializedEditorState): Promise<Blob>;
+
+export { exportDocx, exportDocxFromJSON };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { LexicalEditor, SerializedEditorState } from 'lexical';
+
+declare function exportDocx(editor: LexicalEditor): Promise<Blob>;
+declare function exportDocxFromJSON(json: SerializedEditorState): Promise<Blob>;
+
+export { exportDocx, exportDocxFromJSON };

package/dist/index.js

@@ -0,0 +1,117 @@
+// src/core/builder.ts
+import { AlignmentType, Document, NumberFormat, Packer } from "docx";
+async function buildDocx(elements) {
+  const doc = new Document({
+    //
+    numbering: {
+      config: [
+        {
+          reference: "default-numbering",
+          levels: [
+            {
+              level: 0,
+              format: NumberFormat.DECIMAL,
+              text: "%1.",
+              alignment: AlignmentType.LEFT,
+              style: {
+                paragraph: {
+                  indent: { left: 480, hanging: 480 }
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    //
+    sections: [
+      {
+        children: elements
+      }
+    ]
+  });
+  return Packer.toBlob(doc);
+}
+
+// src/nodes/paragraph.ts
+import { Paragraph as Paragraph2 } from "docx";
+
+// src/nodes/text.ts
+import { TextRun } from "docx";
+function convertText(node) {
+  return new TextRun({
+    text: node.text,
+    bold: (node.format & 1) !== 0,
+    italics: (node.format & 2) !== 0,
+    underline: (node.format & 8) !== 0 ? {} : void 0
+  });
+}
+
+// src/nodes/paragraph.ts
+function convertParagraph(node) {
+  const runs = node.children.filter((child) => child.type === "text").map((child) => convertText(child));
+  return new Paragraph2({ children: runs });
+}
+
+// src/nodes/heading.ts
+import { Paragraph as Paragraph3, HeadingLevel } from "docx";
+var HEADING_MAP = {
+  h1: HeadingLevel.HEADING_1,
+  h2: HeadingLevel.HEADING_2,
+  h3: HeadingLevel.HEADING_3,
+  h4: HeadingLevel.HEADING_4,
+  h5: HeadingLevel.HEADING_5,
+  h6: HeadingLevel.HEADING_6
+};
+function convertHeading(node) {
+  const runs = node.children.filter((child) => child.type === "text").map((child) => convertText(child));
+  return new Paragraph3({
+    heading: HEADING_MAP[node.tag],
+    children: runs
+  });
+}
+
+// src/nodes/list.ts
+import { Paragraph as Paragraph4 } from "docx";
+function convertList(node) {
+  return node.children.filter(
+    (child) => child.type === "listitem"
+  ).map((item) => {
+    const runs = item.children.filter((child) => child.type === "text").map((child) => convertText(child));
+    return new Paragraph4({
+      bullet: node.listType === "bullet" ? { level: item.indent } : void 0,
+      numbering: node.listType === "number" ? { reference: "default-numbering", level: item.indent } : void 0,
+      children: runs
+    });
+  });
+}
+
+// src/serializer.ts
+function serialize(children) {
+  return children.flatMap((node) => {
+    switch (node.type) {
+      case "paragraph":
+        return convertParagraph(node);
+      case "list":
+        return convertList(node);
+      case "heading":
+        return convertHeading(node);
+      default:
+        return [];
+    }
+  });
+}
+
+// src/index.ts
+async function exportDocx(editor) {
+  const json = editor.getEditorState().toJSON();
+  return exportDocxFromJSON(json);
+}
+async function exportDocxFromJSON(json) {
+  const elements = serialize(json.root.children);
+  return buildDocx(elements);
+}
+export {
+  exportDocx,
+  exportDocxFromJSON
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@open-egretta/lexical-export-docx",
+  "version": "0.0.1",
+  "description": "Export Lexical editor content to .docx format",
+  "license": "MIT",
+  "author": "",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "keywords": [
+    "lexical",
+    "editor",
+    "docx",
+    "export"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/open-egretta/lexical-export-docx"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "docx": "^9.6.1"
+  },
+  "peerDependencies": {
+    "lexical": ">=0.41.0"
+  },
+  "devDependencies": {
+    "@lexical/list": "^0.41.0",
+    "@lexical/rich-text": "^0.41.0",
+    "lexical": "^0.41.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}