@docen/docx 0.3.0

package/dist/extensions/table-row.mjs

@@ -0,0 +1,84 @@
+import { TableRow as TableRow$1 } from "./tiptap.mjs";
+import { cssToTwip } from "./utils.mjs";
+//#region src/extensions/table-row.ts
+/**
+* Table row extension with nested office-open attrs.
+*
+* Attrs mirror TableRowPropertiesOptionsBase (cantSplit/tableHeader/hidden as
+* booleans; height as a nested { value, rule } object; cellSpacing as a native
+* value; widthBefore/widthAfter as TableWidthProperties; etc.). DOCX round-trip
+* is near-identity: renderDocx/parseDocx pass attrs through (omitting the
+* `cells` structural key that DocxManager owns). CSS conversion happens only
+* in renderHTML.
+*/
+/** Structural keys filled by DocxManager (compileTableNode). */
+const SKIP_KEYS = new Set(["cells"]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	for (const [key, value] of Object.entries(attrs)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+function parseDocx(opts) {
+	const attrs = {};
+	for (const [key, value] of Object.entries(opts)) {
+		if (SKIP_KEYS.has(key)) continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const TableRow = TableRow$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			height: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => {
+					const twips = cssToTwip(el.style.height || el.getAttribute("height") || "");
+					return twips != null ? {
+						value: twips,
+						rule: "atLeast"
+					} : null;
+				}
+			},
+			cantSplit: attrNative(),
+			tableHeader: attrNative(),
+			hidden: attrNative(),
+			divId: attrNative(),
+			gridBefore: attrNative(),
+			gridAfter: attrNative(),
+			rowAlignment: attrNative(),
+			cnfStyle: attrNative(),
+			cellSpacing: attrNative(),
+			widthBefore: attrNative(),
+			widthAfter: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const attrs = { ...HTMLAttributes };
+		const styles = [];
+		if (node.attrs.height && typeof node.attrs.height === "object") {
+			const h = node.attrs.height;
+			if (h.value != null) styles.push(`height:${h.value / 20}pt`);
+		}
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"tr",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
+export { TableRow, parseDocx, renderDocx };

package/dist/extensions/table.d.mts

@@ -0,0 +1,2 @@
+import { n as parseDocx, r as renderDocx, t as Table } from "../table-BFkfeRp9.mjs";
+export { Table, parseDocx, renderDocx };

package/dist/extensions/table.mjs

@@ -0,0 +1,134 @@
+import { Table as Table$1 } from "./tiptap.mjs";
+import { alignmentFromElement, alignmentToCss, bordersFromElement, renderBorderCSS, shadingFromElement, shadingToCss, twipToCss } from "./utils.mjs";
+//#region src/extensions/table.ts
+/**
+* Table extension with nested office-open attrs.
+*
+* Attrs mirror TableOptions (width/float/layout/borders/alignment/margins/indent/
+* cellSpacing/tableLook/columnWidths/etc.). DOCX round-trip is near-identity:
+* renderDocx/parseDocx pass attrs through (omitting only `rows`, which DocxManager
+* rebuilds from the row/cell nodes). CSS conversion happens only in renderHTML.
+*/
+/** Structural key rebuilt by DocxManager (compileTableNode walks the row nodes). */
+const SKIP_KEYS = new Set(["rows", "columnWidthsRevision"]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	for (const [key, value] of Object.entries(attrs)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+function parseDocx(opts) {
+	const attrs = {};
+	for (const [key, value] of Object.entries(opts)) {
+		if (SKIP_KEYS.has(key)) continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const Table = Table$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			width: attrNative(),
+			columnWidths: attrNative(),
+			indent: attrNative(),
+			margins: attrNative(),
+			float: attrNative(),
+			borders: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			alignment: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => alignmentFromElement(el)
+			},
+			layout: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.tableLayout === "fixed" ? "fixed" : null
+			},
+			style: attrNative(),
+			visuallyRightToLeft: attrNative(),
+			tableLook: attrNative(),
+			cellSpacing: attrNative(),
+			styleRowBandSize: attrNative(),
+			styleColBandSize: attrNative(),
+			caption: attrNative(),
+			description: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const a = node.attrs;
+		const attrs = { ...HTMLAttributes };
+		const styles = [];
+		const align = alignmentToCss(a.alignment);
+		if (align === "center") styles.push("margin-left:auto", "margin-right:auto");
+		else if (align === "right") styles.push("margin-left:auto", "margin-right:0");
+		else if (align) styles.push("margin-left:0", "margin-right:auto");
+		if (a.layout === "fixed") styles.push("table-layout:fixed");
+		if (a.width && typeof a.width === "object") {
+			const w = a.width;
+			const numSize = typeof w.size === "string" ? parseFloat(w.size) : w.size;
+			if (w.type === "pct") {
+				if (!Number.isNaN(numSize)) styles.push(`width:${numSize / 50}%`);
+			} else if (numSize != null) {
+				const css = twipToCss(numSize);
+				if (css) styles.push(`width:${css}`);
+			}
+		}
+		if (a.indent && typeof a.indent === "object") {
+			const ind = a.indent;
+			if (ind.size != null) {
+				const css = twipToCss(ind.size);
+				if (css) styles.push(`margin-left:${css}`);
+			}
+		}
+		if (a.cellSpacing && typeof a.cellSpacing === "object") {
+			const cs = a.cellSpacing;
+			if (cs.value != null) {
+				const css = twipToCss(cs.value);
+				if (css) styles.push(`border-spacing:${css}`);
+			}
+		}
+		const bg = shadingToCss(a.shading);
+		if (bg) styles.push(`background-color:${bg}`);
+		if (a.borders && typeof a.borders === "object") {
+			const b = a.borders;
+			const sides = [
+				["top", b.top],
+				["bottom", b.bottom],
+				["left", b.left],
+				["right", b.right]
+			];
+			for (const [side, border] of sides) {
+				const css = renderBorderCSS(border);
+				if (css) styles.push(`border-${side}:${css}`);
+			}
+		}
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"table",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
+export { Table, parseDocx, renderDocx };

package/dist/extensions/text-style.d.mts

@@ -0,0 +1,2 @@
+import { n as parseDocx, r as renderDocx, t as TextStyle } from "../text-style-BHdtXkMb.mjs";
+export { TextStyle, parseDocx, renderDocx };

package/dist/extensions/text-style.mjs

@@ -0,0 +1,134 @@
+import { TextStyle as TextStyle$1 } from "./tiptap.mjs";
+import { characterSpacingFromCss, characterSpacingToCss, normalizeColorToHex, resolveFontName, shadingFromCss, shadingToCss, sizeFromCss, sizeToCss } from "./utils.mjs";
+//#region src/extensions/text-style.ts
+/**
+* TextStyle mark with office-open attrs.
+*
+* Attrs mirror RunStylePropertiesOptions (bold/italic/strike/subScript/
+* superScript handled by dedicated marks and therefore omitted). DOCX
+* round-trip is near-identity: renderDocx/parseDocx pass attrs through;
+* CSS conversion happens only in attribute-level renderHTML/parseHTML.
+*/
+/** Structural/semantic keys expressed elsewhere (run children/text, style name). */
+const SKIP_KEYS = new Set([
+	"children",
+	"text",
+	"style",
+	"break",
+	"bold",
+	"italic",
+	"strike",
+	"doubleStrike",
+	"subScript",
+	"superScript"
+]);
+function renderDocx(attrs) {
+	const opts = {};
+	for (const [key, value] of Object.entries(attrs)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (value === null || value === void 0) continue;
+		opts[key] = value;
+	}
+	return opts;
+}
+function parseDocx(opts) {
+	const resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	for (const [key, value] of Object.entries(resolved)) {
+		if (SKIP_KEYS.has(key)) continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const TextStyle = TextStyle$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			color: {
+				default: null,
+				parseHTML: (element) => normalizeColorToHex(element.style.color || void 0) ?? null,
+				renderHTML: (attributes) => {
+					const hex = normalizeColorToHex(attributes.color);
+					return hex ? { style: `color:${hex}` } : {};
+				}
+			},
+			characterSpacing: {
+				default: null,
+				parseHTML: (element) => characterSpacingFromCss(element.style.letterSpacing || null),
+				renderHTML: (attributes) => {
+					const css = characterSpacingToCss(attributes.characterSpacing);
+					return css ? { style: `letter-spacing:${css}` } : {};
+				}
+			},
+			font: {
+				default: null,
+				parseHTML: (element) => element.style.fontFamily || null,
+				renderHTML: (attributes) => {
+					const name = resolveFontName(attributes.font);
+					return name ? { style: `font-family:${name}` } : {};
+				}
+			},
+			rightToLeft: {
+				default: null,
+				parseHTML: (element) => element.dir === "rtl" ? true : null,
+				renderHTML: (attributes) => attributes.rightToLeft ? { style: "direction:rtl" } : {}
+			},
+			size: {
+				default: null,
+				parseHTML: (element) => sizeFromCss(element.style.fontSize),
+				renderHTML: (attributes) => {
+					const css = sizeToCss(attributes.size);
+					return css ? { style: `font-size:${css}` } : {};
+				}
+			},
+			shading: {
+				default: null,
+				parseHTML: (element) => shadingFromCss(element.style.backgroundColor),
+				renderHTML: (attributes) => {
+					const css = shadingToCss(attributes.shading);
+					return css ? { style: `background-color:${css}` } : {};
+				}
+			},
+			underline: attrNative(),
+			emphasisMark: attrNative(),
+			highlight: attrNative(),
+			smallCaps: attrNative(),
+			allCaps: attrNative(),
+			kern: attrNative(),
+			position: attrNative(),
+			effect: attrNative(),
+			noProof: attrNative(),
+			sizeComplexScript: attrNative(),
+			highlightComplexScript: attrNative(),
+			boldComplexScript: attrNative(),
+			italicComplexScript: attrNative(),
+			doubleStrike: attrNative(),
+			emboss: attrNative(),
+			imprint: attrNative(),
+			revision: attrNative(),
+			language: attrNative(),
+			border: attrNative(),
+			snapToGrid: attrNative(),
+			vanish: attrNative(),
+			specVanish: attrNative(),
+			scale: attrNative(),
+			math: attrNative(),
+			outline: attrNative(),
+			shadow: attrNative(),
+			webHidden: attrNative(),
+			fitText: attrNative(),
+			complexScript: attrNative(),
+			eastAsianLayout: attrNative(),
+			contentPartRId: attrNative()
+		};
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
+export { TextStyle, parseDocx, renderDocx };

package/dist/extensions/tiptap.d.mts

@@ -0,0 +1,2 @@
+import { A as TableCell, B as UndoRedo, C as Mention, D as Subscript, E as Strike, F as Text, I as TextAlign, L as TextStyle, M as TableRow, N as TaskItem, O as Superscript, P as TaskList, R as TrailingNode, S as Mathematics, T as Paragraph, _ as Image, a as CodeBlockLowlight, b as ListItem, c as DetailsSummary, d as Emoji, f as Gapcursor, g as HorizontalRule, h as Highlight, i as Code, j as TableHeader, k as Table, l as Document, m as Heading, n as Bold, o as Details, p as HardBreak, r as BulletList, s as DetailsContent, t as Blockquote, u as Dropcursor, v as Italic, w as OrderedList, x as ListKeymap, y as Link, z as Underline } from "../tiptap-TErPjuNJ.mjs";
+export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, Dropcursor, Emoji, Gapcursor, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, ListKeymap, Mathematics, Mention, OrderedList, Paragraph, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TrailingNode, Underline, UndoRedo };

package/dist/extensions/tiptap.mjs

@@ -0,0 +1,33 @@
+import { Document } from "@tiptap/extension-document";
+import { Text } from "@tiptap/extension-text";
+import { Paragraph } from "@tiptap/extension-paragraph";
+import { Heading } from "@tiptap/extension-heading";
+import { Blockquote } from "@tiptap/extension-blockquote";
+import { HorizontalRule } from "@tiptap/extension-horizontal-rule";
+import { CodeBlockLowlight } from "@tiptap/extension-code-block-lowlight";
+import { BulletList } from "@tiptap/extension-bullet-list";
+import { OrderedList } from "@tiptap/extension-ordered-list";
+import { ListItem } from "@tiptap/extension-list-item";
+import { TaskList } from "@tiptap/extension-task-list";
+import { TaskItem } from "@tiptap/extension-task-item";
+import { Table, TableCell, TableHeader, TableRow } from "@tiptap/extension-table";
+import { Image } from "@tiptap/extension-image";
+import { HardBreak } from "@tiptap/extension-hard-break";
+import { Details, DetailsContent, DetailsSummary } from "@tiptap/extension-details";
+import { Emoji } from "@tiptap/extension-emoji";
+import { Mention } from "@tiptap/extension-mention";
+import { Mathematics } from "@tiptap/extension-mathematics";
+import { Bold } from "@tiptap/extension-bold";
+import { Italic } from "@tiptap/extension-italic";
+import { Underline } from "@tiptap/extension-underline";
+import { Strike } from "@tiptap/extension-strike";
+import { Code } from "@tiptap/extension-code";
+import { Link } from "@tiptap/extension-link";
+import { Highlight } from "@tiptap/extension-highlight";
+import { Subscript } from "@tiptap/extension-subscript";
+import { Superscript } from "@tiptap/extension-superscript";
+import { TextStyle } from "@tiptap/extension-text-style";
+import { TextAlign } from "@tiptap/extension-text-align";
+import { Dropcursor, Gapcursor, TrailingNode, UndoRedo } from "@tiptap/extensions";
+import { ListKeymap } from "@tiptap/extension-list";
+export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, Dropcursor, Emoji, Gapcursor, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, ListKeymap, Mathematics, Mention, OrderedList, Paragraph, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TrailingNode, Underline, UndoRedo };

package/dist/extensions/types.d.mts

@@ -0,0 +1,30 @@
+import { JSONContent } from "@tiptap/core";
+import { RunOptions } from "@office-open/docx";
+
+//#region src/extensions/types.d.ts
+declare module "@tiptap/core" {
+  interface NodeConfig<Options, Storage> {
+    /**
+     * DOCX serialization: Tiptap JSON node → DOCX opts.
+     * Each node extension defines this to convert its attrs to DOCX properties.
+     */
+    renderDocx?: (node: JSONContent) => Record<string, unknown>;
+    /**
+     * DOCX deserialization: DOCX opts → Tiptap JSON attrs.
+     * Each node extension defines this to convert DOCX properties back to attrs.
+     */
+    parseDocx?: (opts: Record<string, unknown>) => Record<string, unknown>;
+  }
+  interface MarkConfig<Options, Storage> {
+    /**
+     * DOCX serialization: mark attrs → RunOptions properties.
+     * Each mark extension defines this to contribute run-level properties.
+     */
+    renderDocx?: (attrs: Record<string, unknown>) => Partial<RunOptions>;
+    /**
+     * DOCX deserialization: RunOptions → mark attrs.
+     * Each mark extension defines this to extract its attrs from run properties.
+     */
+    parseDocx?: (opts: RunOptions) => Record<string, unknown>;
+  }
+}

package/dist/extensions/utils.d.mts

@@ -0,0 +1,49 @@
+import { BorderOptions, BordersOptions, IndentAttributesProperties, ShadingAttributesProperties, SpacingProperties } from "@office-open/docx";
+
+//#region src/extensions/utils.d.ts
+/** Normalize a CSS color value to hex (e.g., "red" → "#FF0000", "#ff0000" → "#FF0000"). */
+declare function normalizeColorToHex(color: string | undefined): string | undefined;
+/** Resolve a font value (string or OOXML rFonts { ascii, eastAsia, hAnsi, cs }) to a CSS family name. */
+declare function resolveFontName(font: unknown): string | null;
+/** CSS value (e.g., "18pt") → twip number. 1 pt = 20 twips, 1 px = 15 twips (96 DPI). */
+declare function cssToTwip(value: string | undefined): number | undefined;
+/** Twip value → CSS string (e.g., 360 → "18pt"). */
+declare function twipToCss(value: number | string | undefined): string | null;
+/** OOXML alignment → CSS text-align. */
+declare function alignmentToCss(alignment: string | null | undefined): string | null;
+/** CSS text-align → OOXML alignment. */
+declare function alignmentFromCss(css: string | null | undefined): string | null;
+/** Shading.fill → CSS background-color hex. */
+declare function shadingToCss(shading: ShadingAttributesProperties | null | undefined): string | null;
+/** CSS background-color → ShadingAttributesProperties (fill normalized to hex). */
+declare function shadingFromCss(css: string | null | undefined): ShadingAttributesProperties | null;
+declare function lineSpacingToCss(spacing: SpacingProperties | null | undefined): string | null;
+declare function sizeToCss(size: number | null | undefined): string | null;
+declare function sizeFromCss(css: string | null | undefined): number | null;
+declare function characterSpacingToCss(spacing: number | null | undefined): string | null;
+declare function characterSpacingFromCss(css: string | null | undefined): number | null;
+/** Render a BorderOptions to CSS string. OOXML border.size is in eighths of a point. */
+declare function renderBorderCSS(border: BorderOptions): string | null;
+/**
+ * Compute all paragraph-level CSS styles from nested attrs.
+ * Shared by Paragraph and Heading extensions for node-level renderHTML.
+ * Attrs store office-open native values; mappers here convert to CSS.
+ */
+declare function renderParagraphStyles(attrs: Record<string, unknown>): string[];
+/**
+ * Compute table cell CSS styles from nested attrs.
+ * Shared by TableCell and TableHeader extensions.
+ */
+declare function renderTableCellStyles(attrs: Record<string, unknown>): string[];
+/** Parse text-align → OOXML alignment. */
+declare function alignmentFromElement(el: HTMLElement): string | null;
+/** Parse margin-left/right + text-indent → OOXML indent (twips). */
+declare function indentFromElement(el: HTMLElement): IndentAttributesProperties | null;
+/** Parse margin-top/bottom + line-height → OOXML spacing (twips). */
+declare function spacingFromElement(el: HTMLElement): SpacingProperties | null;
+/** Parse border-* → OOXML BordersOptions. */
+declare function bordersFromElement(el: HTMLElement): BordersOptions | null;
+/** Parse background-color → OOXML shading. */
+declare function shadingFromElement(el: HTMLElement): ShadingAttributesProperties | null;
+//#endregion
+export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderTableCellStyles, resolveFontName, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss };