@tiptap-pro/extension-export-docx changelog

0.28.0

Minor Changes

• The exportDocx command now automatically derives pageSize and body pageMargins from the Pages extension's current pageFormat (built-in presets and custom pixel formats), so the exported page geometry matches the on-screen layout — the same auto-pull already applied to headers, footers, and their edge distances. Explicitly provided pageSize/pageMargins fields always win over the derived values, and exports without the Pages extension are unchanged. Behavioral note: documents exported with Pages installed and no explicit page setup previously used the A4/Word-margin defaults and now follow the Pages layout instead.

Patch Changes

• Preserve block images nested in list items and align them with the list body text in DOCX exports.

0.27.0

Minor Changes

• Export tracked changes to DOCX: text carrying a tracked-changes suggestion mark now becomes a Word insertion or deletion, keeping the author and date so the change shows up in Word's review pane.

  Text can carry several suggestions at once, for example when a reviewer deletes something another author inserted. A Word revision cannot wrap another, so one has to describe the run: a deletion wins, attributed to the reviewer who deleted. Accepting everything in Word then gives the same document as accepting everything in Tiptap. The same rule applies to a deleted link, which exports as a deletion without the link, while an inserted link keeps the link.

  A suggestion whose author or date is not a string no longer fails the export. Those values fall back to an anonymous author and a placeholder date.

Patch Changes

• The pixelsToHalfPoints, pixelsToPoints and pointsToTwips helpers now come from the shared OOXML registry instead of being implemented twice, so import and export can never drift apart on unit conversions. They are still exported from this package and return the same values as before.
• Updated dependencies
• Updated dependencies
  • @tiptap-pro/extension-convert-kit@0.9.0

0.26.1

Patch Changes

• Empty paragraphs are no longer stripped on export: each empty paragraph node now emits an empty <w:p> (keeping its spacing, indent and alignment attributes), so the exported DOCX — and the DOCX-first PDF export — match the editor's vertical spacing and page flow.
• Updated dependencies
  • @tiptap-pro/extension-convert-kit@0.8.0

0.26.0

Minor Changes

• Add internal-anchor support so in-document navigation round-trips with DOCX. A new bookmark node represents an anchor target, and links whose href is #anchor now export as Word internal hyperlinks that point at the matching bookmark instead of as external links.

Patch Changes

• Preserve the underline style when converting to and from DOCX. Double, dotted, dashed, wavy and the other Word underline patterns now round-trip instead of every underline becoming a plain single line. The underline mark gains an underlineType attribute, and the exporter emits the matching underline type.
• Updated dependencies
• Updated dependencies
  • @tiptap-pro/extension-convert-kit@0.7.0

0.25.0

Minor Changes

• Tab characters (\t) now export as real Word tab stops instead of literal tab characters, so they align to tab positions. A new defaultTabStop option sets the document's default tab width (in twips) when a paragraph has no explicit tab stops.
• DOCX export now preserves more table formatting. Table cell background color and vertical alignment, cell borders, row heights (with the exact or at-least rule), and table width and left indentation now round-trip into Word instead of being dropped on export.
• Custom node render functions may now return a Promise. Async renders are awaited everywhere they are dispatched — block-level conversion, inline dispatch inside paragraphs, and DSL $children slots — where a returned Promise was previously discarded or landed in the output unresolved. Adds the exported CustomNodeResult type describing the allowed render results. Also fixes function-form paragraphOverrides on comment-thread image anchors to receive the image node instead of the enclosing blockThread node.

Patch Changes

• Export width-less tables as fluid percentage-width tables (100%, autofit) instead of pinning them to a fixed page-derived width. Tables that carry an explicit width still export at that fixed width. This lets a full-width table stay fluid through a DOCX round-trip.
• Add right and hanging indent support to DOCX conversion. Paragraphs and headings now carry a right indent (w:ind right) and hanging indents round-trip correctly, so legal-style numbered clauses and right-margin insets keep their shape through import and export.
• Round-trip the DOCX keep-with-next (w:keepNext) and keep-lines-together (w:keepLines) pagination hints. Paragraphs and headings now carry keepNext and keepLines attributes that survive a conversion round-trip and export back to DOCX. They are layout hints with no visual effect in the editor, so they are stored on the node without affecting its HTML.
• Add disclaimer banner to build
• Round-trip table borders (w:tblBorders) through DOCX conversion. A table's own six borders — outer edges plus the inside horizontal and vertical grid — are now preserved on the table itself, and cell border overrides carry across intact. Tables with no borders defined export as truly borderless instead of gaining a default border.
• Improve table fidelity when converting to DOCX. Cell and border colors written as a named color (red), rgb()/rgba(), or short hex (#ff0) now export correctly instead of failing, and fully transparent colors are dropped rather than turned opaque. Table rows with an "at least" height now show that height in the editor while still growing with their content. The Convert Kit table also honors the renderWrapper option again, so its static HTML output includes the table wrapper.
• Fixed-width tables now export to DOCX with their column widths as the source of truth, so the table width, the column grid, and the individual cell widths always agree. When a table's declared width disagrees with its column widths, the columns win and the table width is the sum of the columns. Tables that are not cleanly sized fall back to an even split that is still internally consistent, and percentage-width tables are unchanged. The shared column-grid logic lives in the Convert Kit OOXML registry so import and export stay consistent.
• Updated dependencies
• Updated dependencies
• Updated dependencies
• Updated dependencies
• Updated dependencies
• Updated dependencies
• Updated dependencies
  • @tiptap-pro/extension-convert-kit@0.6.0

0.24.0

Minor Changes

• Allow imageOverrides to be a function that receives the current image node.

  imageOverrides previously accepted only a static object applied to every image. It now also accepts a function of the form (node) => overrides, so you can return different overrides per image based on the node and its attributes. The existing object form keeps working unchanged, so this is a backwards-compatible addition.

  // Static object (unchanged)
  imageOverrides: { transformation: { width: 400, height: 300 } }
  
  // New function form: overrides derived from each image node
  imageOverrides: node => ({
    altText: { name: node.attrs?.alt, description: node.attrs?.alt },
  })

• Allow every DOCX export override to be a function that receives the current node, and add a new tableRowOverrides option.

  paragraphOverrides, textRunOverrides, tableOverrides, and tableCellOverrides now accept either a static object (applied to every node of that type, unchanged) or a function (node) => overrides that returns the overrides for the node currently being converted — the same form imageOverrides already supports. A new tableRowOverrides option (object or function) lets you set row-level properties such as cantSplit, tableHeader, and height. All forms are backwards compatible.

  // Object form (unchanged) and the new function form
  paragraphOverrides: (node) => ({
    keepNext: node.attrs?.keepWithNext === true,
  });
  tableRowOverrides: {
    cantSplit: true;
  }

Patch Changes

• Honor pt, rem, and em units in textStyle font sizes on DOCX export instead of treating every value as pixels. A value with no unit is still read as pixels, so existing documents are unchanged. Previously a size like 12pt was exported about 25% too small.
• Fix exported DOCX headings bleeding into the following paragraph. Heading styles were emitted twice with the same id, so Word used the library's spacing-less default and the heading lost its before/after spacing. Heading styles now ship as a single, complete definition.
• Honor fixed (unit-based) line heights on DOCX export. A lineHeight carrying an absolute unit (24px, 18pt, 1cm, …) now maps to a fixed DOCX line rule instead of being dropped, so the exported document keeps the spacing shown in the editor. Proportional values (1.5, 150%) are unchanged.

0.23.3

Patch Changes

• Export every top-level block of a header/footer, and support any block type — not just the first paragraph. convertHeader/convertFooter (and the exportDocx command's auto-assembled headers/footers) previously converted only node.content[0], and only when that block was a paragraph or table. As a result a header/footer with multiple blocks (e.g. several paragraphs, common in imported DOCX documents) lost everything after the first, and a header/footer whose top-level block was an image, heading, list, blockquote, or horizontal rule was dropped entirely — even though convertNode already knows how to promote those to block-level (a top-level image becomes a paragraph via convertImage). They now run every top-level block through convertNode and keep whatever block-level result it produces (Paragraph/Table), mirroring convertNode's own blockThread branch. Multi-block and image-only headers/footers now export correctly; anything that can't become a direct child (e.g. a bare text run from a custom node) is dropped.

0.23.2

Patch Changes

• pages: add Word-style endnotes — references collect at the end of the document with lowercase Roman numerals, with a fully editable overlay. DOCX import injects endnotes automatically and DOCX export ships them as real Word endnotes.

0.23.1

Patch Changes

• DOCX comment export now writes stable comment ids (durableId) so comments survive a round-trip even after editing in Microsoft Word.
• Fix DOCX comment export dropping replies: each comment in a thread (root and every reply) now gets its own commentReference in the document body, so replies appear and stay threaded in Word instead of being silently dropped. Also support comment content provided as a plain string (previously exported as an empty comment).
• Fix DOCX comment export when comments are auto-collected: the Comments provider's getThreads is now called as a method so its this binding is preserved. Previously, exporting a document with comments threw Cannot read properties of undefined (reading 'getYThreads').
• Fix DOCX comment round-trip duplication: exported comments now reuse the w:id they were imported with (originalWId) when present, instead of always hashing the server id. This keeps an imported comment's identity stable so re-importing an exported document reconciles to the same comments (collab-born comments, which have no originalWId, still use a deterministic hash). Previously, imported comments could be duplicated on re-import.

0.23.0

Minor Changes

• Export comments: editor comment threads now become real DOCX comments (with replies, resolved state, and ranges anchored in the text), auto-collected from the Comments extension. The exported file can be edited in Word and re-imported without duplicating threads. Also exposes a tiny @tiptap-pro/extension-export-docx/hash31 subpath used to keep comment identity stable across the import/export round-trip.
• Export footnotes: footnoteReference nodes become real DOCX footnotes, auto-extracted from the Pages extension's footnote storage or provided via the new footnotes option.

0.22.0

Minor Changes

• Stop forcing single line spacing on paragraphs and headings that have no explicit line height. The exporter previously wrote a per-paragraph line value on every paragraph, which overrode the line height declared by the paragraph style (e.g. Normal) or by paragraphOverrides. The per-paragraph line is now emitted only when the node carries an explicit relative line height, so a paragraph without one inherits the line height from its style — matching how the blockquote/styled path already behaves and how styleOverrides / paragraphOverrides are expected to apply.

  Behavior change: a document that relied on the implicit forced single spacing (and set no line on its Normal style) now follows that style's line height instead. Explicit per-node line heights, headers, and footers are unaffected.

0.21.0

Minor Changes

• Derive paragraph and heading spacing from node attributes, not only from a block-level textStyle mark. lineHeight (proportional values only — a unitless number such as 1.5 or a percentage such as 150%; unit-suffixed lengths like 24px, 3pt, or 1.5em have no proportional DOCX equivalent and are ignored), spacingBefore, spacingAfter, indent, firstLineIndent, and contextualSpacing set on paragraph/heading nodes — the shape ConvertKit and the DOCX import produce — now round-trip to DOCX instead of being dropped. A block-level textStyle line height still takes precedence, so existing output is unchanged.

  This formatting now also applies to styled paragraphs (e.g. blockquotes, which export with the Quote style); previously the styled-paragraph path returned early and silently dropped per-paragraph spacing, indentation, contextual spacing, and alignment. Defaults are not injected there, so the named style's own formatting still shows through when a node carries no explicit value.

  A negative firstLineIndent is now emitted as a hanging indent (w:hanging) instead of a negative w:firstLine, which the DOCX writer rejects ("Must be a positive integer") — previously this threw and aborted the entire export.

0.20.0

Minor Changes

• Add an embedFonts option that automatically embeds the fonts a document uses into the exported DOCX: font files are located through the page's @font-face rules (with a Google Fonts fallback) and WOFF2 fonts are converted to TTF via the Tiptap Convert Service (appId/token). Also fixes fontFamily values quoted with single quotes keeping the literal quote in the exported font name.
• Add a fonts option to embed custom TTF/OTF fonts into exported DOCX files. Pass the font family name and its raw bytes (Buffer, Uint8Array, or ArrayBuffer — e.g. from fetch(...).arrayBuffer() in the browser) and the document renders with the intended font in Word even on machines where it is not installed.

0.19.0

Minor Changes

• Add ordered list numbering format support to DOCX export.

  • numberingFormats?: NumberingFormatDefinition[] option on ExportDocx / exportDocx() / ConvertConfig. Each entry is a multilevel numbering definition (per-level base style, marker template, indent, alignment, font) that the exporter resolves against the numberingFormat string attribute on the outermost <ol> of each multilevel list. Unknown / missing ids fall through to the package's default 'ordered-list' numbering — consumers who don't opt in see zero behavior change.
  • New types NumberingFormatDefinition and NumberingLevelDefinition. Word's <w:lvlText> grammar (%N references the counter at level N) is used verbatim. No preset formats are shipped — define your own.
  • LevelFormat, IRunOptions, and PositiveUniversalMeasure are re-exported from docx so consumers can build definitions without a second import.

  Editor-side wiring (the Tiptap attribute extension and the editor-preview CSS) is the consumer's responsibility — a reference implementation is in demos/src/Extensions/ExportDocxOrderedListNumbering/React/.

  Also fixes a pre-existing bug where nested ordered lists each allocated their own DOCX numId, fragmenting counter chains across nesting boundaries. The outermost list's instance id is now threaded through every nested convertOrderedList call so a multilevel list shares one numId and Word's per-level counter logic works as expected.

0.18.0

Minor Changes

• Add customNodeDsl — a JSON-native way to describe how custom Tiptap nodes should render into DOCX.

  The existing customNodes API is great inside the editor, but it relies on JavaScript functions, which can't be sent over HTTP. That has historically meant that the DOCX REST API had no way to render application-specific content like callouts, mentions, or hint boxes. customNodeDsl closes that gap with a small, serializable language that produces identical output to the function API and travels cleanly over the wire.

  What's in the box:

  • A versioned wire format (dslVersion: "1.0") with seven render-node shapes (element, $children, $text, $fragment, $if, $switch, null) and a closed element catalog (Paragraph, TextRun, ExternalHyperlink, Table, TableRow, TableCell, PageBreak).
  • A typed value-expression layer — $ref for PM-node attributes, $template for string interpolation, $op for typed compute, $unit for the same unit helpers the function API ships (pointsToTwips, pixelsToHalfPoints, normalizeColor, …), plus $switch/$if for conditional rendering. No eval, no Turing-completeness, no surprises.
  • Full marks integration — MarkPolicy on $children/$text and applyMarks on inline elements, both reusing the same standard mark pipeline as the rest of the converter, plus per-mark overrides and disable for fine-grained control.
  • A clean override-precedence ladder so DSL props compose predictably with cssStyles, styleOverrides, and the existing *Overrides bundles.
  • Source-mapped errors (every error carries dslPath and, at runtime, nodePath + nodeType) and configurable resource caps via the new customNodeDslLimits option.
  • Both APIs coexist on the editor — when the same node type appears in both customNodes and customNodeDsl, the function definition wins and a single console.warn is emitted per export. Existing function-based customers see zero behavior change.

  Refactoring under the hood: the mark-to-TextRun translation in convertTextNode was extracted into reusable computeMarkFormatting and buildTextRun helpers so the DSL pipeline can drive marks identically without synthesizing fake PM nodes. This is a behavior-preserving change — every existing test passes unchanged.

  The new CustomNodeDsl, CustomNodeRule, RenderProgram, RenderNode, ValueExpr, MarkPolicy, ApplyMarksPolicy, and CustomNodeDslLimits types are exported from the package root, alongside the compileCustomNodeDsl, DslCompileError, and DslRuntimeError runtime helpers for advanced users running the extension on their own server.

  TypeScript builder under a tree-shakeable subpath. Authoring rules in TypeScript? Import the fluent builder from @tiptap-pro/extension-export-docx/dsl and let the type system catch containment violations at edit time:

  import {
    childrenInline,
    docxNode,
    paragraph,
    ref,
    template,
    textRun,
  } from "@tiptap-pro/extension-export-docx/dsl";
  
  const dsl = {
    dslVersion: "1.0",
    nodes: [
      docxNode("hintbox")
        .block()
        .emit(
          paragraph({ style: "Hintbox" }).children(
            childrenInline({ marks: "default" })
          )
        )
        .toJSON(),
      docxNode("mention")
        .inline()
        .emit(
          textRun({
            text: template("@{node.attrs.label}"),
            color: ref("node.attrs.color", {
              default: "4472C4",
              transform: "hexNoHash",
            }),
          }).applyMarks("node")
        )
        .toJSON(),
    ],
  };

  What you get:

  • Autocomplete on every element prop. paragraph({ … }) suggests style, alignment, spacing, border, shading, … exactly the field set the DSL compiler validates.
  • Compile-time containment safety. paragraph().children(childrenBlock()) is a TypeScript error — paragraphs only accept inline children. table().rows(paragraph()) is also an error — Table.rows requires TableRow builders. The errors fire at edit time, not at runtime.
  • Required-prop checking. externalHyperlink({}) is a TypeScript error: the link prop is required.
  • Wire-format compatibility. .toJSON() produces the exact same JSON the Custom-nodes DSL compiler accepts. Same payload works inside the editor, in a Node.js server, or as a customNodeDsl field over the convert REST API.
  • Tree-shakeable. The builder ships under a separate ./dsl subpath in the package's exports field — callers who never touch it don't pay for it.

  The full builder surface (docxNode, paragraph, textRun, externalHyperlink, table, tableRow, tableCell, pageBreak, childrenInline / childrenBlock / childrenTableRow / childrenTableCell, iff / switch_ / fragment / textOp, ref / template / op / unit / switchValue / marks, plus all per-element prop interfaces) is documented at Custom-nodes DSL builder.

  Inline decoration on Paragraph. The DSL Paragraph element gains border and shading props that mirror the IParagraphOptions shape on docx.js. Custom nodes that previously needed a named styleOverrides.paragraphStyles entry purely to carry decorative chrome (boxes, callouts, hint boxes) can now express it inline on the DSL element — no parallel style declaration, no round-trip indirection. The named-style label still works for round-trip identity (<w:pStyle> survives whether or not it's declared in styles.xml), so existing payloads keep behaving the same.

  See the new Custom-nodes DSL docs for the JSON spec, worked examples (hintbox, mention, callout box, code block, custom link), and the precedence model — and the DSL builder docs for the TypeScript-ergonomic equivalent.

• Add a pageColor option to ExportDocx and convert() that writes the DOCX w:background element, letting Word display the document with a colored page. Accepts any CSS color the package's normalizeColor helper resolves (hex, rgb() / rgba(), named colors); "transparent" and unresolvable values omit the element. Note that Word does not print page background by default — users must enable "Print background colors and images" under Word Options for the color to appear in printed output or PDF exports.

• Configurable header/footer placeholders with end-to-end DOCX round-trip support.

  • Pages: new placeholders option to rename the built-in {page} / {total} tokens or disable substitution. Defaults preserve existing behavior.
  • ExportDocx: header/footer text now translates registered tokens into live Word PAGE / NUMPAGES fields instead of literal text. When the Pages extension is installed, the export auto-picks up its placeholders config so the editor preview and the exported .docx stay aligned. Body content is never substituted.
  • ImportDocx: the importer now forwards Pages.options.placeholders to the convert service so Word PAGE / NUMPAGES fields come back as text tokens that match your active Pages registry — {page} / {total} by default, or your rename. The editor preview substitutes the imported tokens natively, with no .replace() step and no placeholders: { total: 'numpages' } workaround. Pass placeholders: false on the command to opt out, or placeholders: { page, total } to override the editor's registry per-call.

  The convert service exposes the same placeholders field on /import/docx and /export/docx for direct REST API callers who want the same control without an editor.

0.17.0

Minor Changes

• Add export docx missing overrides for header and footers
• DOCX export now serializes subscript and superscript text marks. Content like H₂O and x² preserves its formatting on export, where it was previously emitted as plain text.

Patch Changes

• Update fast-xml-parser to patch vulnerabilities CVE-2026-33349 and CVE-2026-41650

0.16.1

Patch Changes

• Fix image dimensions in DOCX export. Images were previously shrunk to 75 % of their intended size because pixel values were converted to points before being passed to docx's ImageRun.transformation, which already expects pixels at 96 dpi.

0.16.0

Minor Changes

• Add support for paragraph, table, text run, table cell, and image overrides in header and footer content. Also add a new headerFooterOverrides option for styling headers and footers separately from the body.

  • convertHeader and convertFooter now accept these options: customNodes, pageSize, pageMargins, tableOverrides, tableCellOverrides, paragraphOverrides, textRunOverrides, imageOverrides. Before, header and footer content was always converted with default values, so the overrides did not work.
  • New option headerFooterOverrides in ExportDocxOptions. You can use this to style header and footer content different from the body. Each field replaces the body-wide value, it does not merge. If a field is not set, it uses the body value. This only works for headers and footers that come from the Pages extension.
  • Fix: when you set paragraphOverrides.spacing.before or spacing.after, the values were lost because the code overwrote the spacing object with only spacing.line. Now before, after, and line all work together.

• Add header and footer properties to the pageMargins option, controlling the distance from the page edge to the header/footer. When the Pages extension is configured, these values are auto-derived from headerTopMargin and footerBottomMargin; caller-provided values always take precedence.

  For extension-export-pdf, extension-export-doc, and extension-export-odt, full end-to-end support requires the Tiptap convert service to be on a version that accepts the new pageMargins.header/footer fields and ships an updated @tiptap-pro/extension-export-docx.

0.15.5

Patch Changes

• Render {page} and {total} tokens in plain-text headers and footers as live PageNumber.CURRENT / PageNumber.TOTAL_PAGES fields, so exported DOCX files show the actual page number and total page count instead of the literal token strings.

0.15.4

Patch Changes

• Inline images inside a paragraph now inherit the paragraph's formatting (alignment, line spacing, paragraphOverrides, heading level, list numbering) in the DOCX export. Previously these attributes were dropped because the image was emitted as its own wrapper paragraph. Block-level images (siblings of paragraphs) and the public convertImage API are unchanged; a new convertImageRun helper is exported for callers that need the raw inline run.

0.15.3

Patch Changes

• Fix DOCX rendering in viewers that don't support universal measures by converting page dimensions and margins to numeric twips, and add explicit document defaults for font size, font family, and language settings

0.15.2

Patch Changes

• Minor bugfixes & improvements

0.15.1

Patch Changes

• fix: do not overwrite global default styles

0.15.0

Minor Changes

• Add page break support to DOCX export. The pageBreak node is now converted to a <w:br w:type="page"/> element, producing a standard Word page break in the exported document. A new convertPageBreak function is also publicly exported for use in custom node conversion pipelines.

0.14.0

Minor Changes

• Fix table cells only rendering paragraphs by delegating to the central node converter, enabling support for lists, headings, images, blockquotes, and nested tables inside table cells

0.13.0

Minor Changes

• Extend DOCX export with deep customization overrides for paragraphs, text runs, table cells, and images.

  tableOverrides (new)

  Allows overriding any ITableOptions property except rows. Values are spread last, so user-provided table-level properties (borders, margins, layout) win over computed defaults.

  paragraphOverrides (new)

  Accepts any IParagraphOptions property except children. Spread first as base defaults — per-node computed values like alignment, spacing, heading level, and list numbering override them. Applied to all paragraph creation paths: standard paragraphs, headings, blockquotes, bullet lists, ordered lists, and list items.

  textRunOverrides (new)

  Accepts any IRunOptions property except text. Spread first as base defaults — per-mark formatting (bold, italic, underline, font family, font size, color, highlight, etc.) overrides them. Useful for setting a default font or size across the entire exported document. Applied to all text run creation paths including styled paragraphs (e.g. blockquotes) and standard content.

  tableCellOverrides (new)

  Accepts any ITableCellOptions property except children. Spread first as base defaults — per-cell computed values like width, column span, and width type override them. Useful for applying consistent cell shading, vertical alignment, or border styles across all table cells.

  imageOverrides (new)

  Accepts any IImageOptions property except data, type, and fallback. Spread last so user-provided values (e.g. custom transformation dimensions) win over the intrinsic dimensions detected from the image buffer. SVG fallback data is always preserved regardless of overrides.

  Usage example

  editor.commands.exportDocx({
    onCompleteExport: (result) => {
      /* ... */
    },
    exportType: "blob",
    paragraphOverrides: {
      spacing: { after: 200, before: 100 },
    },
    textRunOverrides: {
      font: "Arial",
      size: 24, // 12pt in half-points
    },
    tableCellOverrides: {
      shading: { fill: "F0F0F0", type: ShadingType.SOLID },
    },
    imageOverrides: {
      transformation: { width: 400, height: 300 },
    },
  });

  Note: All override objects use shallow spreading, not deep merging. When overriding nested properties like spacing or transformation, provide the complete nested object to avoid undefined fields.

  ---

  Node attribute inference (new)

  The DOCX export now respects node-level attributes set by the editor instead of always computing values from scratch.

  Image width/height from node attrs

  When an image has been resized in the editor (via ResizableNodeView), the user-set width and height attributes are now used for the exported dimensions instead of the intrinsic image dimensions. If only one dimension is set, the other is computed proportionally from the intrinsic aspect ratio. Priority chain: imageOverrides.transformation > node.attrs.width/height > intrinsic dimensions.

  Image alt text

  The alt attribute on image nodes is now mapped to the docx altText property (DocPropertiesOptions.name), providing accessibility metadata in the exported document.

  Table cell colwidth

  When table columns have been resized in the editor, the per-cell colwidth attribute (pixel array) is now used to compute precise column widths in the export. Falls back to even distribution when colwidth is not set.

  Table cell rowspan

  The rowspan attribute on table cells is now supported. Cells spanning multiple rows are correctly exported with the rowSpan property in the docx output.

  Paragraph textAlign: 'justify'

  Justified text alignment is now correctly mapped to AlignmentType.JUSTIFIED in the export. Previously, 'justify' fell through to left alignment.

  Text run backgroundColor

  The backgroundColor attribute on the textStyle mark is now exported as solid character shading on text runs. Previously, inline background colors were silently dropped.

• Initial beta point for export and pages packages

3.0.0-beta.31

3.0.0-beta.30

Patch Changes

• Bumped Tiptap and Hocuspocus Dependencies to most recent version

3.0.0-beta.29

3.0.0-beta.28

3.0.0-beta.27

3.0.0-beta.26

3.0.0-beta.25

Patch Changes

• Bumped @tiptap and @hocuspocus dependencies

3.0.0-beta.24

Patch Changes

• Bump tiptap and hocuspocus dependencies

3.0.0-beta.23

3.0.0-beta.22

Patch Changes

• upgraded hocuspocus and tiptap dependencies

3.0.0-beta.21

3.0.0-beta.20

Patch Changes

• Bumped tiptap and hocuspocus dependencies

3.0.0-beta.19

3.0.0-beta.18

Patch Changes

• updated tiptap and hocuspocus dependencies

3.0.0-beta.17

3.0.0-beta.16

Patch Changes

• Updated tiptap packages

3.0.0-beta.15

Major Changes

• Updated all tiptap dependencies

0.1.0

Initial release of extension-export-docx as beta version.