@docen/docx 0.3.1 → 0.3.2

package/dist/extensions/paragraph.mjs

@@ -1,2 +1,151 @@
-import { n as parseDocx, r as renderDocx, t as Paragraph } from "../paragraph-BrWH-BOV.mjs";
+import { Paragraph as Paragraph$1 } from "./tiptap.mjs";
+import { alignmentFromElement, bordersFromElement, indentFromElement, renderParagraphStyles, shadingFromElement, spacingFromElement } from "./utils.mjs";
+//#region src/extensions/paragraph.ts
+/**
+* Paragraph extension with nested office-open attrs.
+*
+* Attrs mirror ParagraphPropertiesOptionsBase (alignment/indent/spacing/border/
+* shading/frame as nested objects + scalar OOXML properties). DOCX round-trip is
+* near-identity: renderDocx/parseDocx pass attrs through; CSS conversion happens
+* only in renderHTML via utils mappers.
+*/
+const SECTION_ATTR_KEYS = new Set([
+	"sectionProperties",
+	"sectionHeaders",
+	"sectionFooters"
+]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	for (const [key, value] of Object.entries(attrs)) {
+		if (value === null || value === void 0) continue;
+		if (SECTION_ATTR_KEYS.has(key)) continue;
+		if (key === "styleId") {
+			opts.style = value;
+			continue;
+		}
+		opts[key] = value;
+	}
+	return opts;
+}
+/**
+* Structural/semantic keys handled elsewhere (heading ext, list handling, run/text
+* children). NOTE: `run` is intentionally NOT skipped — ParagraphOptions.run (the
+* paragraph's default run properties: font/size/color) is kept as an attr for
+* lossless round-trip (e.g. header/footer paragraphs whose styling lives there).
+*/
+const SKIP_KEYS = new Set([
+	"heading",
+	"style",
+	"bullet",
+	"numbering",
+	"children",
+	"text",
+	"thematicBreak"
+]);
+function parseDocx(opts) {
+	const resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.style) attrs.styleId = resolved.style;
+	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 Paragraph = Paragraph$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			styleId: {
+				default: null,
+				parseHTML: (el) => {
+					const m = (el.getAttribute("class") || "").match(/(?:^|\s)docx-style-(\S+)/);
+					return m ? m[1] : null;
+				}
+			},
+			alignment: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => alignmentFromElement(el)
+			},
+			indent: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => indentFromElement(el)
+			},
+			spacing: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => spacingFromElement(el)
+			},
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			border: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			frame: attrNative(),
+			run: attrNative(),
+			sectionProperties: attrNative(),
+			sectionHeaders: attrNative(),
+			sectionFooters: attrNative(),
+			keepNext: attrNative(),
+			keepLines: attrNative(),
+			pageBreakBefore: attrNative(),
+			widowControl: attrNative(),
+			contextualSpacing: attrNative(),
+			bidirectional: attrNative(),
+			outlineLevel: attrNative(),
+			textDirection: attrNative(),
+			textAlignment: attrNative(),
+			suppressLineNumbers: attrNative(),
+			wordWrap: attrNative(),
+			overflowPunctuation: attrNative(),
+			autoSpaceEastAsianText: attrNative(),
+			suppressOverlap: attrNative(),
+			suppressAutoHyphens: attrNative(),
+			adjustRightInd: attrNative(),
+			snapToGrid: attrNative(),
+			mirrorIndents: attrNative(),
+			kinsoku: attrNative(),
+			topLinePunct: attrNative(),
+			autoSpaceDE: attrNative(),
+			textboxTightWrap: attrNative(),
+			rightTabStop: attrNative(),
+			leftTabStop: attrNative(),
+			divId: attrNative(),
+			tabStops: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		let hasContent = false;
+		node.forEach?.((child) => {
+			if (child.isText || child.type?.name === "hardBreak" || child.type?.name === "image") hasContent = true;
+		});
+		const styles = renderParagraphStyles(node.attrs, { empty: !hasContent });
+		const attrs = { ...HTMLAttributes };
+		const styleId = node.attrs.styleId;
+		attrs.class = styleId ? `docx-style-${styleId}` : "docx-default";
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"p",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { Paragraph, parseDocx, renderDocx };

package/dist/extensions/passthrough.d.mts

@@ -1,2 +1,2 @@
-import { m as Passthrough } from "../core-fBMCCj4D.mjs";
+import { h as Passthrough } from "../core-C9VunJ8o.mjs";
 export { Passthrough };

package/dist/extensions/passthrough.mjs

@@ -1,2 +1,2 @@
-import { d as Passthrough } from "../core-DEqBHRzE.mjs";
+import { h as Passthrough } from "../core-DT9IrTzN.mjs";
 export { Passthrough };

package/dist/extensions/section-break.d.mts

@@ -1,4 +1,4 @@
-import { r as Extension } from "../core-fBMCCj4D.mjs";
+import { r as Extension } from "../core-C9VunJ8o.mjs";
 
 //#region src/extensions/section-break.d.ts
 /**
@@ -14,12 +14,29 @@ import { r as Extension } from "../core-fBMCCj4D.mjs";
  * The final section's sectPr rides on doc.attrs.sectionProperties (it lives at
  * <w:body>'s end in OOXML). Single-section documents have no section-carrying
  * paragraph at all.
+ *
+ * Next Page semantics: `setSectionBreak` stamps sectionProperties on the current
+ * paragraph (making it the section's last paragraph) AND inserts a fresh empty
+ * paragraph after it (the next section's first paragraph), then moves the
+ * selection into that new paragraph. The page-plugin's `forcesPageBreakAfter`
+ * treats a sectionProperties-bearing paragraph as a page break, so repaginate
+ * pushes the new paragraph onto the next page — and the caret follows. This
+ * mirrors Word's "Section Break (Next Page)".
+ *
+ * Split hygiene: pressing Enter inside a section-carrying paragraph must NOT
+ * split it. A split would place the new paragraph past the section boundary —
+ * forcesPageBreakAfter then pushes it onto the next page (next section), and
+ * splitBlock would copy sectionProperties onto it (a second break mark). Word
+ * instead inserts a fresh paragraph BEFORE the section's last paragraph, so the
+ * new paragraph stays in this section and the stamped paragraph remains last.
+ * The Enter shortcut does exactly that; non-section paragraphs fall through to
+ * the default Enter unchanged.
  */
 declare const SectionBreak: Extension<any, any>;
 declare module "@tiptap/core" {
   interface Commands<ReturnType> {
     sectionBreak: {
-      /** Stamp sectionProperties on the current paragraph, ending a section. */setSectionBreak: () => ReturnType;
+      /** Insert a Next Page section break at the current paragraph. */setSectionBreak: () => ReturnType;
     };
   }
 }

package/dist/extensions/section-break.mjs

@@ -1,2 +1,2 @@
-import { u as SectionBreak } from "../core-DEqBHRzE.mjs";
+import { m as SectionBreak } from "../core-DT9IrTzN.mjs";
 export { SectionBreak };

package/dist/extensions/strike.mjs

@@ -1,2 +1,50 @@
-import { n as parseDocx, r as renderDocx, t as Strike } from "../strike-hWxShOgb.mjs";
+import { Strike as Strike$1 } from "./tiptap.mjs";
+//#region src/extensions/strike.ts
+/**
+* Strike mark extension with nested office-open attrs.
+*
+* OOXML represents strikethrough on a run via two mutually exclusive booleans:
+* `strike` (single) and `doubleStrike` (double). The mark itself is "single
+* strikethrough"; the `doubleStrike` attr flips it to double. DOCX round-trip
+* is near-identity for the doubleStrike flag; `strike` itself is implied by the
+* mark's presence and handled in renderDocx/parseDocx.
+*
+* Mark attribute-level renderHTML is delegated to the base Strike extension
+* (renders `<s>`); only the DOCX flag needs custom handling.
+*/
+/**
+* attrs → run properties.
+*
+* The mark presence itself means single strikethrough. When `doubleStrike` is
+* set, emit the OOXML double-strike flag instead (the two are mutually
+* exclusive in OOXML). DocxManager calls this with `mark.attrs`.
+*/
+function renderDocx(attrs) {
+	return attrs.doubleStrike ? { doubleStrike: true } : { strike: true };
+}
+/**
+* run properties → attrs.
+*
+* Only the `doubleStrike` flag needs to round-trip; single strike is implied by
+* the mark's existence. `strike` is structural/semantic (the mark) and skipped.
+*/
+function parseDocx(runOpts) {
+	return { doubleStrike: runOpts.doubleStrike ?? null };
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const Strike = Strike$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			doubleStrike: attrNative()
+		};
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { Strike, parseDocx, renderDocx };

package/dist/extensions/table-cell.mjs

@@ -1,2 +1,112 @@
-import { n as parseDocx, r as renderDocx, t as TableCell } from "../table-cell-DmkfYwDc.mjs";
+import { TableCell as TableCell$1 } from "./tiptap.mjs";
+import { bordersFromElement, renderTableCellStyles, shadingFromElement } from "./utils.mjs";
+//#region src/extensions/table-cell.ts
+/**
+* Table cell extension with nested office-open attrs.
+*
+* Attrs mirror TableCellPropertiesOptionsBase (shading/margins/borders/width as
+* nested objects + scalar OOXML properties) plus the inherited Tiptap structural
+* names colspan/rowspan/colwidth/align (rendered: false for the OOXML-named ones).
+* DOCX round-trip is near-identity: renderDocx/parseDocx pass OOXML-native attrs
+* through and only map the Tiptap structural names colspan/rowspan/colwidth to
+* OOXML columnSpan/rowSpan/width. CSS conversion happens solely in renderHTML via
+* utils.renderTableCellStyles (consuming nested shading/verticalAlign/noWrap).
+*/
+/** Tiptap structural attrs expressed via OOXML structural fields, not passed through. */
+const SKIP_KEYS = new Set([
+	"colspan",
+	"rowspan",
+	"colwidth",
+	"children"
+]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	const colspan = attrs.colspan;
+	if (colspan && colspan > 1) opts.columnSpan = colspan;
+	const rowspan = attrs.rowspan;
+	if (rowspan && rowspan > 1) opts.rowSpan = rowspan;
+	const colwidth = attrs.colwidth;
+	if (colwidth && colwidth.length > 0) {
+		const totalPx = colwidth.reduce((sum, w) => sum + (w || 0), 0);
+		if (totalPx > 0) opts.width = {
+			size: totalPx * 15,
+			type: "dxa"
+		};
+	}
+	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 resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.columnSpan != null) attrs.colspan = resolved.columnSpan;
+	if (resolved.rowSpan != null) attrs.rowspan = resolved.rowSpan;
+	if (resolved.width) {
+		const twips = resolved.width.size ?? 0;
+		if (twips) attrs.colwidth = [Math.round(twips / 15)];
+	}
+	for (const [key, value] of Object.entries(resolved)) {
+		if (key === "columnSpan" || key === "rowSpan" || key === "width" || key === "children") continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const TableCell = TableCell$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			borders: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			verticalAlign: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.verticalAlign || null
+			},
+			textDirection: attrNative(),
+			width: attrNative(),
+			margins: attrNative(),
+			noWrap: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.whiteSpace === "nowrap" ? true : null
+			},
+			verticalMerge: attrNative(),
+			horizontalMerge: attrNative(),
+			fitText: attrNative(),
+			hideMark: attrNative(),
+			headers: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const styles = renderTableCellStyles(node.attrs);
+		const attrs = { ...HTMLAttributes };
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"td",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { TableCell, parseDocx, renderDocx };

package/dist/extensions/table-header.mjs

@@ -1,2 +1,112 @@
-import { n as parseDocx, r as renderDocx, t as TableHeader } from "../table-header-Bwr5GKWg.mjs";
+import { TableHeader as TableHeader$1 } from "./tiptap.mjs";
+import { bordersFromElement, renderTableCellStyles, shadingFromElement } from "./utils.mjs";
+//#region src/extensions/table-header.ts
+/**
+* Table header extension with nested office-open attrs (mirrors TableCell).
+*
+* Attrs mirror TableCellPropertiesOptionsBase (shading/margins/borders/width as
+* nested objects + scalar OOXML properties) plus the inherited Tiptap structural
+* names colspan/rowspan/colwidth/align (rendered: false for the OOXML-named ones).
+* DOCX round-trip is near-identity: renderDocx/parseDocx pass OOXML-native attrs
+* through and only map the Tiptap structural names colspan/rowspan/colwidth to
+* OOXML columnSpan/rowSpan/width. CSS conversion happens solely in renderHTML via
+* utils.renderTableCellStyles (consuming nested shading/verticalAlign/noWrap).
+*/
+/** Tiptap structural attrs expressed via OOXML structural fields, not passed through. */
+const SKIP_KEYS = new Set([
+	"colspan",
+	"rowspan",
+	"colwidth",
+	"children"
+]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	const colspan = attrs.colspan;
+	if (colspan && colspan > 1) opts.columnSpan = colspan;
+	const rowspan = attrs.rowspan;
+	if (rowspan && rowspan > 1) opts.rowSpan = rowspan;
+	const colwidth = attrs.colwidth;
+	if (colwidth && colwidth.length > 0) {
+		const totalPx = colwidth.reduce((sum, w) => sum + (w || 0), 0);
+		if (totalPx > 0) opts.width = {
+			size: totalPx * 15,
+			type: "dxa"
+		};
+	}
+	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 resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.columnSpan != null) attrs.colspan = resolved.columnSpan;
+	if (resolved.rowSpan != null) attrs.rowspan = resolved.rowSpan;
+	if (resolved.width) {
+		const twips = resolved.width.size ?? 0;
+		if (twips) attrs.colwidth = [Math.round(twips / 15)];
+	}
+	for (const [key, value] of Object.entries(resolved)) {
+		if (key === "columnSpan" || key === "rowSpan" || key === "width" || key === "children") continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const TableHeader = TableHeader$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			borders: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			verticalAlign: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.verticalAlign || null
+			},
+			textDirection: attrNative(),
+			width: attrNative(),
+			margins: attrNative(),
+			noWrap: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.whiteSpace === "nowrap" ? true : null
+			},
+			verticalMerge: attrNative(),
+			horizontalMerge: attrNative(),
+			fitText: attrNative(),
+			hideMark: attrNative(),
+			headers: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const styles = renderTableCellStyles(node.attrs);
+		const attrs = { ...HTMLAttributes };
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"th",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { TableHeader, parseDocx, renderDocx };

package/dist/extensions/table-row.mjs

@@ -1,2 +1,84 @@
-import { n as parseDocx, r as renderDocx, t as TableRow } from "../table-row-vew1y7WH.mjs";
+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 };