@docen/docx 0.3.0 → 0.3.1

package/dist/extensions/utils.mjs

@@ -1,289 +1,2 @@
-//#region src/extensions/utils.ts
-/** Common CSS named colors → hex */
-const CSS_COLORS = {
-	black: "#000000",
-	white: "#FFFFFF",
-	red: "#FF0000",
-	green: "#008000",
-	blue: "#0000FF",
-	yellow: "#FFFF00",
-	cyan: "#00FFFF",
-	magenta: "#FF00FF",
-	gray: "#808080",
-	grey: "#808080",
-	orange: "#FFA500",
-	purple: "#800080",
-	pink: "#FFC0CB",
-	brown: "#A52A2A",
-	lime: "#00FF00",
-	navy: "#000080",
-	teal: "#008080",
-	silver: "#C0C0C0",
-	maroon: "#800000",
-	olive: "#808000",
-	aqua: "#00FFFF",
-	fuchsia: "#FF00FF",
-	indigo: "#4B0082",
-	violet: "#EE82EE",
-	coral: "#FF7F50",
-	gold: "#FFD700",
-	salmon: "#FA8072",
-	tomato: "#FF6347"
-};
-/** Normalize a CSS color value to hex (e.g., "red" → "#FF0000", "#ff0000" → "#FF0000"). */
-function normalizeColorToHex(color) {
-	if (!color) return void 0;
-	if (color.startsWith("#")) return color.length === 4 ? `#${color[1]}${color[1]}${color[2]}${color[2]}${color[3]}${color[3]}`.toUpperCase() : color.toUpperCase();
-	if (/^[0-9A-Fa-f]{6}$/.test(color)) return `#${color.toUpperCase()}`;
-	if (/^[0-9A-Fa-f]{3}$/.test(color)) return `#${color[0]}${color[0]}${color[1]}${color[1]}${color[2]}${color[2]}`.toUpperCase();
-	return CSS_COLORS[color.toLowerCase()] ?? void 0;
-}
-/** Resolve a font value (string or OOXML rFonts { ascii, eastAsia, hAnsi, cs }) to a CSS family name. */
-function resolveFontName(font) {
-	if (!font) return null;
-	if (typeof font === "string") return font;
-	if (typeof font === "object") {
-		const f = font;
-		return f.ascii || f.hAnsi || f.eastAsia || null;
-	}
-	return null;
-}
-/** CSS value (e.g., "18pt") → twip number. 1 pt = 20 twips, 1 px = 15 twips (96 DPI). */
-function cssToTwip(value) {
-	if (!value) return void 0;
-	const match = value.match(/^([\d.]+)(pt|px|em|cm|in)?$/);
-	if (!match) return void 0;
-	const num = parseFloat(match[1]);
-	switch (match[2] ?? "pt") {
-		case "pt": return Math.round(num * 20);
-		case "px": return Math.round(num * 15);
-		case "in": return Math.round(num * 1440);
-		case "cm": return Math.round(num * 567);
-		case "em": return Math.round(num * 240);
-		default: return Math.round(num * 20);
-	}
-}
-/** Twip value → CSS string (e.g., 360 → "18pt"). */
-function twipToCss(value) {
-	if (value == null) return null;
-	if (typeof value === "string") return value;
-	return `${value / 20}pt`;
-}
-const ALIGNMENT_TO_CSS = {
-	left: "left",
-	center: "center",
-	right: "right",
-	start: "start",
-	end: "end",
-	both: "justify",
-	distribute: "justify"
-};
-const CSS_TO_ALIGNMENT = {
-	left: "left",
-	center: "center",
-	right: "right",
-	start: "start",
-	end: "end",
-	justify: "both"
-};
-/** OOXML alignment → CSS text-align. */
-function alignmentToCss(alignment) {
-	if (!alignment) return null;
-	return ALIGNMENT_TO_CSS[alignment] ?? null;
-}
-/** CSS text-align → OOXML alignment. */
-function alignmentFromCss(css) {
-	if (!css) return null;
-	return CSS_TO_ALIGNMENT[css] ?? null;
-}
-/** Shading.fill → CSS background-color hex. */
-function shadingToCss(shading) {
-	if (!shading?.fill) return null;
-	return normalizeColorToHex(shading.fill) ?? null;
-}
-/** CSS background-color → ShadingAttributesProperties (fill normalized to hex). */
-function shadingFromCss(css) {
-	const hex = normalizeColorToHex(css ?? void 0);
-	return hex ? {
-		fill: hex,
-		type: "clear"
-	} : null;
-}
-function lineSpacingToCss(spacing) {
-	if (!spacing?.line) return null;
-	const rule = spacing.lineRule;
-	if (rule === "exact" || rule === "exactly" || rule === "atLeast") return `${spacing.line / 20}pt`;
-	const multiple = Number((spacing.line / 240).toFixed(2));
-	return String(multiple);
-}
-function sizeToCss(size) {
-	if (size == null) return null;
-	return `${size}pt`;
-}
-function sizeFromCss(css) {
-	if (!css) return null;
-	const m = css.match(/^([\d.]+)(pt|px)?$/);
-	if (!m) return null;
-	const num = parseFloat(m[1]);
-	return (m[2] ?? "pt") === "px" ? num * .75 : num;
-}
-function characterSpacingToCss(spacing) {
-	if (spacing == null) return null;
-	return `${spacing / 20}pt`;
-}
-function characterSpacingFromCss(css) {
-	if (!css) return null;
-	const m = css.match(/^(-?[\d.]+)pt$/);
-	return m ? Math.round(parseFloat(m[1]) * 20) : null;
-}
-/** Render a BorderOptions to CSS string. OOXML border.size is in eighths of a point. */
-function renderBorderCSS(border) {
-	if (!border || border.style === "none") return null;
-	const size = border.size != null ? `${border.size / 8}pt` : "1pt";
-	const cssStyle = {
-		single: "solid",
-		dashed: "dashed",
-		dotted: "dotted",
-		double: "double",
-		dotDash: "dashed",
-		dotDotDash: "dotted"
-	}[border.style || "single"] || "solid";
-	const hex = border.color && border.color !== "auto" ? normalizeColorToHex(border.color) : null;
-	return hex ? `${cssStyle} ${size} ${hex}` : `${cssStyle} ${size}`;
-}
-/**
-* 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.
-*/
-function renderParagraphStyles(attrs) {
-	const a = attrs;
-	const styles = [];
-	const align = alignmentToCss(a.alignment);
-	if (align) styles.push(`text-align:${align}`);
-	if (a.indent) {
-		const left = twipToCss(a.indent.left);
-		if (left) styles.push(`margin-left:${left}`);
-		const right = twipToCss(a.indent.right);
-		if (right) styles.push(`margin-right:${right}`);
-		if (a.indent.firstLine != null) {
-			const fl = twipToCss(a.indent.firstLine);
-			if (fl) styles.push(`text-indent:${fl}`);
-		} else if (a.indent.hanging != null) {
-			const h = twipToCss(a.indent.hanging);
-			if (h) styles.push(`text-indent:-${h}`);
-		} else if (a.indent.firstLineChars != null) styles.push(`text-indent:${a.indent.firstLineChars / 100}em`);
-	}
-	if (a.spacing) {
-		const before = twipToCss(a.spacing.before);
-		if (before) styles.push(`margin-top:${before}`);
-		const after = twipToCss(a.spacing.after);
-		if (after) styles.push(`margin-bottom:${after}`);
-		const lh = lineSpacingToCss(a.spacing);
-		if (lh) styles.push(`line-height:${lh}`);
-	}
-	const bg = shadingToCss(a.shading);
-	if (bg) styles.push(`background-color:${bg}`);
-	if (a.border) {
-		const sides = [
-			["top", a.border.top],
-			["bottom", a.border.bottom],
-			["left", a.border.left],
-			["right", a.border.right]
-		];
-		for (const [side, b] of sides) {
-			const css = b ? renderBorderCSS(b) : null;
-			if (css) styles.push(`border-${side}:${css}`);
-		}
-	}
-	return styles;
-}
-/**
-* Compute table cell CSS styles from nested attrs.
-* Shared by TableCell and TableHeader extensions.
-*/
-function renderTableCellStyles(attrs) {
-	const a = attrs;
-	const styles = [];
-	if (a.noWrap) styles.push("white-space:nowrap");
-	const bg = shadingToCss(a.shading);
-	if (bg) styles.push(`background-color:${bg}`);
-	if (a.verticalAlign) styles.push(`vertical-align:${a.verticalAlign}`);
-	return styles;
-}
-/** Parse text-align → OOXML alignment. */
-function alignmentFromElement(el) {
-	return alignmentFromCss(el.style.textAlign || null);
-}
-/** Parse margin-left/right + text-indent → OOXML indent (twips). */
-function indentFromElement(el) {
-	const indent = {};
-	const left = cssToTwip(el.style.marginLeft);
-	if (left) indent.left = left;
-	const right = cssToTwip(el.style.marginRight);
-	if (right) indent.right = right;
-	const ti = el.style.textIndent;
-	if (ti) if (ti.startsWith("-")) {
-		const h = cssToTwip(ti.slice(1));
-		if (h) indent.hanging = h;
-	} else {
-		const f = cssToTwip(ti);
-		if (f) indent.firstLine = f;
-	}
-	return Object.keys(indent).length > 0 ? indent : null;
-}
-/** Parse margin-top/bottom + line-height → OOXML spacing (twips). */
-function spacingFromElement(el) {
-	const spacing = {};
-	const before = cssToTwip(el.style.marginTop);
-	if (before) spacing.before = before;
-	const after = cssToTwip(el.style.marginBottom);
-	if (after) spacing.after = after;
-	const lh = el.style.lineHeight;
-	if (lh) {
-		const m = lh.match(/^([\d.]+)(pt|px)?$/);
-		if (m) {
-			const num = parseFloat(m[1]);
-			if (m[2]) {
-				spacing.line = Math.round(num * (m[2] === "px" ? 15 : 20));
-				spacing.lineRule = "exact";
-			} else {
-				spacing.line = Math.round(num * 240);
-				spacing.lineRule = "auto";
-			}
-		}
-	}
-	return Object.keys(spacing).length > 0 ? spacing : null;
-}
-/** Parse border-* → OOXML BordersOptions. */
-function bordersFromElement(el) {
-	const borders = {};
-	const sides = [
-		["top", el.style.borderTop],
-		["bottom", el.style.borderBottom],
-		["left", el.style.borderLeft],
-		["right", el.style.borderRight]
-	];
-	for (const [side, css] of sides) {
-		if (!css || css === "initial" || css === "none") continue;
-		const m = css.match(/^(none|solid|dashed|dotted|double)\s+([\d.]+pt)\s+(.+)$/);
-		if (!m) continue;
-		borders[side] = {
-			style: {
-				solid: "single",
-				dashed: "dashed",
-				dotted: "dotted",
-				double: "double"
-			}[m[1]] ?? "single",
-			size: Math.round(parseFloat(m[2]) * 8),
-			color: m[3]
-		};
-	}
-	return Object.keys(borders).length > 0 ? borders : null;
-}
-/** Parse background-color → OOXML shading. */
-function shadingFromElement(el) {
-	return shadingFromCss(el.style.backgroundColor || null);
-}
-//#endregion
-export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderTableCellStyles, resolveFontName, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss };
+import { S as twipToCss, _ as shadingFromElement, a as characterSpacingFromCss, b as sizeToCss, c as indentFromElement, d as renderBorderCSS, f as renderParagraphStyles, g as shadingFromCss, h as resolveFontName, i as bordersFromElement, l as lineSpacingToCss, m as renderTableCellStyles, n as alignmentFromElement, o as characterSpacingToCss, p as renderRunStyles, r as alignmentToCss, s as cssToTwip, t as alignmentFromCss, u as normalizeColorToHex, v as shadingToCss, x as spacingFromElement, y as sizeFromCss } from "../utils-BPT4tjcn.mjs";
+export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderRunStyles, renderTableCellStyles, resolveFontName, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss };

package/dist/heading-DAubgJJN.mjs

@@ -0,0 +1,166 @@
+import { m as Heading$1 } from "./tiptap-D7pl4I5U.mjs";
+import { _ as shadingFromElement, c as indentFromElement, f as renderParagraphStyles, i as bordersFromElement, n as alignmentFromElement, x as spacingFromElement } from "./utils-BPT4tjcn.mjs";
+//#region src/extensions/heading.ts
+/**
+* Heading extension with nested office-open attrs (mirrors Paragraph).
+*
+* Attrs mirror ParagraphPropertiesOptionsBase (alignment/indent/spacing/border/
+* shading/frame as nested objects + scalar OOXML properties) plus the inherited
+* Tiptap `level` (1-6, rendered: false). DOCX round-trip is near-identity:
+* renderDocx/parseDocx pass attrs through and only map `level` ↔ OOXML
+* `heading` (HeadingLevel literal). CSS conversion happens solely in
+* renderHTML via utils mappers.
+*/
+const HEADING_COMPILE_MAP = {
+	1: "Heading1",
+	2: "Heading2",
+	3: "Heading3",
+	4: "Heading4",
+	5: "Heading5",
+	6: "Heading6"
+};
+const HEADING_PARSE_MAP = {
+	Heading1: 1,
+	Heading2: 2,
+	Heading3: 3,
+	Heading4: 4,
+	Heading5: 5,
+	Heading6: 6,
+	Title: 1
+};
+/** HeadingLevel literals that office-open lifts from a pStyle into `heading`.
+*  Used to round-trip the literal via styleId (covers "Title", which level 1
+*  alone would collapse to "Heading1"). */
+const HEADING_STYLE_IDS = new Set(Object.keys(HEADING_PARSE_MAP));
+/** Runtime-only attrs the TableOfContents extension injects on each heading
+*  (`id` / `data-toc-id`). They are regenerated on every load, so never persist
+*  them to DOCX — skip them in renderDocx. */
+const TOC_RUNTIME_KEYS = new Set(["id", "data-toc-id"]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	const level = attrs.level;
+	const styleId = attrs.styleId;
+	if (styleId && HEADING_STYLE_IDS.has(styleId)) opts.heading = styleId;
+	else if (level) opts.heading = HEADING_COMPILE_MAP[level] ?? "Heading1";
+	for (const [key, value] of Object.entries(attrs)) {
+		if (key === "level" || key === "styleId" || TOC_RUNTIME_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+/** Structural/semantic keys expressed elsewhere (heading handled separately, list handling, run children). */
+const SKIP_KEYS = new Set([
+	"heading",
+	"style",
+	"bullet",
+	"numbering",
+	"run",
+	"children",
+	"text",
+	"thematicBreak"
+]);
+function parseDocx(opts) {
+	const resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.heading) {
+		const level = HEADING_PARSE_MAP[resolved.heading];
+		if (level) attrs.level = level;
+		attrs.styleId = resolved.heading;
+	}
+	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 Heading = Heading$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(),
+			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 }) {
+		const styles = renderParagraphStyles(node.attrs);
+		const level = node.attrs?.level ?? 1;
+		const attrs = { ...HTMLAttributes };
+		const styleId = node.attrs.styleId;
+		if (styleId) attrs.class = `docx-style-${styleId}`;
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			`h${level}`,
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
+export { parseDocx as n, renderDocx as r, Heading as t };

package/dist/html-DCC_DSHv.d.mts

@@ -0,0 +1,18 @@
+import { a as JSONContent, i as Extensions } from "./core-fBMCCj4D.mjs";
+import { ParseOptions } from "@tiptap/pm/model";
+
+//#region src/converters/html.d.ts
+/**
+ * Parse HTML string to Tiptap JSON. Reads back the page background base color
+ * from a generateHTML wrapper div (pattern image is lost — OOXML patterns have
+ * no HTML equivalent; the DOCX round-trip preserves the full background).
+ */
+declare function parseHTML(html: string, extensions?: Extensions, options?: ParseOptions): JSONContent;
+/**
+ * Generate HTML string from Tiptap JSON. Wraps the content in a div carrying
+ * the page background (color + pattern image) so the document background is
+ * visible — Tiptap's DOMSerializer only serializes content nodes, not doc attrs.
+ */
+declare function generateHTML(doc: JSONContent, extensions?: Extensions): string;
+//#endregion
+export { parseHTML as n, generateHTML as t };

package/dist/html-DedDWPoO.mjs

@@ -0,0 +1,66 @@
+import { s as docxExtensions } from "./core-DEqBHRzE.mjs";
+import { t as encodeBase64 } from "./dist-B6B3HnVZ.mjs";
+import { generateHTML, generateJSON } from "@tiptap/html";
+//#region src/converters/html.ts
+const defaultExtensions = docxExtensions;
+/**
+* Normalize a media payload to Uint8Array — JSON round-trips byte arrays as
+* plain objects ({0:byte,...}), so rebuild before base64-encoding.
+*/
+function toBytes(d) {
+	if (!d) return null;
+	if (d instanceof Uint8Array) return d;
+	return new Uint8Array(Object.values(d));
+}
+/**
+* Build a CSS background style from DocumentBackgroundOptions. VML/rawXml page
+* backgrounds (base fill + pattern image) reduce to a solid color (the w:color
+* base fill) plus a tiled image (rawMedia) — OOXML pattern semantics can't be
+* expressed in CSS, but base color + tile gives a visually close result.
+*/
+function extractBackgroundStyle(bg) {
+	if (!bg || typeof bg !== "object") return void 0;
+	const b = bg;
+	let color;
+	if (b.color) color = b.color;
+	else if (b.rawXml) {
+		const m = b.rawXml.match(/w:color="([0-9A-Fa-f]{6})"/);
+		if (m) color = m[1];
+	}
+	const media = b.image?.data ?? b.rawMedia?.[0];
+	const bytes = toBytes(media?.data);
+	const styles = [];
+	if (color) styles.push(`background-color:#${color}`);
+	if (bytes) {
+		const type = media?.type ?? "png";
+		styles.push(`background-image:url(data:image/${type};base64,${encodeBase64(bytes)})`, "background-repeat:repeat");
+	}
+	return styles.length ? styles.join(";") : void 0;
+}
+/**
+* Parse HTML string to Tiptap JSON. Reads back the page background base color
+* from a generateHTML wrapper div (pattern image is lost — OOXML patterns have
+* no HTML equivalent; the DOCX round-trip preserves the full background).
+*/
+function parseHTML(html, extensions, options) {
+	const doc = generateJSON(html, extensions ?? defaultExtensions, options);
+	const m = html.match(/<div style="background-color:#([0-9A-Fa-f]{6})/);
+	if (m) {
+		if (!doc.attrs) doc.attrs = {};
+		doc.attrs.background = { color: m[1] };
+	}
+	return doc;
+}
+/**
+* Generate HTML string from Tiptap JSON. Wraps the content in a div carrying
+* the page background (color + pattern image) so the document background is
+* visible — Tiptap's DOMSerializer only serializes content nodes, not doc attrs.
+*/
+function generateHTML$1(doc, extensions) {
+	const html = generateHTML(doc, extensions ?? defaultExtensions);
+	const style = extractBackgroundStyle(doc.attrs?.background);
+	if (style) return `<div style="${style}">${html}</div>`;
+	return html;
+}
+//#endregion
+export { parseHTML as n, generateHTML$1 as t };