@docen/docx 0.3.0 → 0.3.2

package/dist/converters/html.d.mts

@@ -1,14 +1,29 @@
-import { a as JSONContent, i as Extensions } from "../core-omBKMRtl.mjs";
+import { a as JSONContent, i as Extensions } from "../core-C9VunJ8o.mjs";
 import { ParseOptions } from "@tiptap/pm/model";
 
 //#region src/converters/html.d.ts
 /**
- * Parse HTML string to Tiptap JSON.
+ * Serialize Tiptap JSON to an HTML string. Renders per-section: each OOXML
+ * section (CT_SectPr) becomes a `<section>` carrying its own page margin
+ * (padding) and a document-grid line-height (the font's `normal` metric —
+ * Word does not add the grid pitch to rendered line height), so paragraph
+ * line-spacing multiples resolve against the section's font, not a fallback.
+ * The document background (CT_DocumentBase, single for the whole doc) wraps all
+ * sections.
+ *
+ * Same ProseMirror DOMSerializer pipeline as @tiptap/html, on a linkedom
+ * document: happy-dom drops calc(var(…)) when re-serializing the style
+ * attribute, so DOCX line-spacing survives only with linkedom.
  */
-declare function parseHTML(html: string, extensions?: Extensions, options?: ParseOptions): JSONContent;
+declare function generateHTML(doc: JSONContent, extensions?: Extensions): string;
 /**
- * Generate HTML string from Tiptap JSON.
+ * Parse an HTML string into Tiptap JSON. Same ProseMirror DOMParser pipeline as
+ * @tiptap/html on a linkedom document. The background wrapper and section
+ * containers are unknown elements (no doc/div/section node in the schema), so
+ * the parser ignores their tags and extracts the content. Section geometry
+ * (linePitch/margins) and the page background are section/doc-level metadata,
+ * not content — they round-trip losslessly via DOCX, not HTML.
  */
-declare function generateHTML(doc: JSONContent, extensions?: Extensions): string;
+declare function parseHTML(html: string, extensions?: Extensions, options?: ParseOptions): JSONContent;
 //#endregion
 export { generateHTML, parseHTML };

package/dist/converters/html.mjs

@@ -1,18 +1,104 @@
-import { s as docxExtensions } from "../core-CFIQVRfx.mjs";
-import { generateHTML as generateHTML$1, generateJSON } from "@tiptap/html";
+import { s as docxExtensions } from "../core-DT9IrTzN.mjs";
+import { sectionLinePitchCss, sectionMarginCss } from "../extensions/utils.mjs";
+import { getSchema } from "@tiptap/core";
+import { encodeBase64 } from "@office-open/core";
+import { DOMParser, DOMSerializer, Node } from "@tiptap/pm/model";
+import { parseHTML as parseHTML$1 } from "linkedom";
 //#region src/converters/html.ts
 const defaultExtensions = docxExtensions;
+/** JSON round-trips byte arrays as plain objects ({0:byte,…}); rebuild here. */
+function toBytes(data) {
+	if (!data) return null;
+	return data instanceof Uint8Array ? data : new Uint8Array(Object.values(data));
+}
+/** Page background → CSS for the root wrapper. Color renders directly; a VML
+*  pattern's first media item tiles as an image. OOXML patterns have no CSS
+*  equivalent, so DOCX (not HTML) is the fidelity source. */
+function backgroundToCss(bg) {
+	const styles = [];
+	if (bg?.color) styles.push(`background-color:#${bg.color}`);
+	const media = bg?.rawMedia?.[0];
+	const bytes = toBytes(media?.data);
+	if (bytes) styles.push(`background-image:url(data:image/${media?.type ?? "png"};base64,${encodeBase64(bytes)})`, "background-repeat:repeat");
+	return styles.length ? styles.join(";") : void 0;
+}
+/** Split flat `doc > block+` into sections by section-carrying paragraphs.
+*  Mirrors DocxManager's compile-time split (converters/docx.ts): a paragraph
+*  with `sectionProperties` closes its section; trailing blocks form the final
+*  section under doc.attrs.sectionProperties. No section-carrying paragraph →
+*  a single section (backward compatible). */
+function splitJsonSections(doc) {
+	const sections = [];
+	let current = [];
+	for (const node of doc.content ?? []) {
+		current.push(node);
+		const sp = node.attrs?.sectionProperties;
+		if (sp != null) {
+			sections.push({
+				properties: sp,
+				blocks: current
+			});
+			current = [];
+		}
+	}
+	const tailProps = doc.attrs?.sectionProperties;
+	sections.push({
+		properties: tailProps ?? null,
+		blocks: current
+	});
+	return sections;
+}
 /**
-* Parse HTML string to Tiptap JSON.
+* Serialize Tiptap JSON to an HTML string. Renders per-section: each OOXML
+* section (CT_SectPr) becomes a `<section>` carrying its own page margin
+* (padding) and a document-grid line-height (the font's `normal` metric —
+* Word does not add the grid pitch to rendered line height), so paragraph
+* line-spacing multiples resolve against the section's font, not a fallback.
+* The document background (CT_DocumentBase, single for the whole doc) wraps all
+* sections.
+*
+* Same ProseMirror DOMSerializer pipeline as @tiptap/html, on a linkedom
+* document: happy-dom drops calc(var(…)) when re-serializing the style
+* attribute, so DOCX line-spacing survives only with linkedom.
 */
-function parseHTML(html, extensions, options) {
-	return generateJSON(html, extensions ?? defaultExtensions, options);
+function generateHTML(doc, extensions = defaultExtensions) {
+	const schema = getSchema(extensions);
+	const { document } = parseHTML$1("<!DOCTYPE html><html><body></body></html>");
+	const serializer = DOMSerializer.fromSchema(schema);
+	const parts = [];
+	for (const section of splitJsonSections(doc)) {
+		const sp = section.properties;
+		const styles = [];
+		const padding = sectionMarginCss(sp?.page?.margin);
+		if (padding) styles.push(padding);
+		styles.push(...sectionLinePitchCss(sp?.grid));
+		const sec = document.createElement("section");
+		if (styles.length) sec.setAttribute("style", styles.join(";"));
+		if (section.blocks.length) {
+			const fragment = Node.fromJSON(schema, {
+				type: "doc",
+				content: section.blocks
+			}).content;
+			serializer.serializeFragment(fragment, { document }, sec);
+		}
+		parts.push(sec.outerHTML);
+	}
+	const body = parts.join("");
+	const bgCss = backgroundToCss(doc.attrs?.background);
+	return bgCss ? `<div style="${bgCss}">${body}</div>` : body;
 }
 /**
-* Generate HTML string from Tiptap JSON.
+* Parse an HTML string into Tiptap JSON. Same ProseMirror DOMParser pipeline as
+* @tiptap/html on a linkedom document. The background wrapper and section
+* containers are unknown elements (no doc/div/section node in the schema), so
+* the parser ignores their tags and extracts the content. Section geometry
+* (linePitch/margins) and the page background are section/doc-level metadata,
+* not content — they round-trip losslessly via DOCX, not HTML.
 */
-function generateHTML(doc, extensions) {
-	return generateHTML$1(doc, extensions ?? defaultExtensions);
+function parseHTML(html, extensions = defaultExtensions, options) {
+	const schema = getSchema(extensions);
+	const { document } = parseHTML$1(`<!DOCTYPE html><html><body>${html}</body></html>`);
+	return DOMParser.fromSchema(schema).parse(document.body, options).toJSON();
 }
 //#endregion
 export { generateHTML, parseHTML };

package/dist/converters/markdown.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent } from "../core-omBKMRtl.mjs";
+import { a as JSONContent } from "../core-C9VunJ8o.mjs";
 
 //#region src/converters/markdown.d.ts
 /**

package/dist/converters/markdown.mjs

@@ -1,4 +1,4 @@
-import { s as docxExtensions } from "../core-CFIQVRfx.mjs";
+import { s as docxExtensions } from "../core-DT9IrTzN.mjs";
 import { Markdown, MarkdownManager } from "@tiptap/markdown";
 //#region src/converters/markdown.ts
 const markdownManager = new MarkdownManager({ extensions: [...docxExtensions, Markdown] });

package/dist/converters/patch.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent } from "../core-omBKMRtl.mjs";
+import { a as JSONContent } from "../core-C9VunJ8o.mjs";
 import { PrepareStep } from "./prepare.mjs";
 import { OutputByType, OutputType, patchDocument } from "@office-open/docx";
 

package/dist/converters/patch.mjs

@@ -1,6 +1,6 @@
 import { prepareDocument } from "./prepare.mjs";
 import { compileDocument } from "./docx.mjs";
-import { PatchType, patchDocument } from "@office-open/docx";
+import { patchDocument } from "@office-open/docx";
 //#region src/converters/patch.ts
 /**
 * Patch a DOCX template by replacing placeholders with Tiptap-JSON content.
@@ -15,16 +15,15 @@ async function patchDOCX(options) {
 	const patchesObject = {};
 	for (const [key, patchContent] of Object.entries(patches)) {
 		if (prepare !== false) await prepareDocument(patchContent.content, prepare === true ? void 0 : prepare);
-		const children = compileDocument(patchContent.content).sections?.[0]?.children ?? [];
 		patchesObject[key] = {
-			type: PatchType.DOCUMENT,
-			children
+			type: "document",
+			children: compileDocument(patchContent.content).sections?.[0]?.children ?? []
 		};
 	}
 	return patchDocument({
 		outputType,
 		data: template,
-		patches: patchesObject,
+		placeholders: patchesObject,
 		...keepOriginalStyles !== void 0 && { keepOriginalStyles },
 		...recursive !== void 0 && { recursive },
 		...placeholderDelimiters && { placeholderDelimiters: {

package/dist/converters/prepare.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent } from "../core-omBKMRtl.mjs";
+import { a as JSONContent } from "../core-C9VunJ8o.mjs";
 
 //#region src/converters/prepare.d.ts
 /**
@@ -31,13 +31,25 @@ declare function fetchImageHandler(url: string): Promise<Uint8Array>;
  * ```
  */
 declare function prepareImages(handler?: ImageFetchHandler): PrepareStep;
+/**
+ * Create a prepare step that fills in missing image dimensions by reading image
+ * metadata. Intended to run after {@link prepareImages} so HTTP sources are
+ * already embedded as data URLs.
+ *
+ * Only images lacking `width` or `height` are probed — the DOCX round-trip path
+ * already carries `transformation.width/height`, so this mainly serves images
+ * entering via HTML/Markdown (which carry no intrinsic size). Images whose
+ * metadata can't be read are left untouched; `renderDocx` falls back to 600×400
+ * (see extensions/image.ts).
+ */
+declare function prepareImageSizes(): PrepareStep;
 /**
  * Run prepare steps on a Tiptap JSON document before compilation.
  *
  * Each step receives the JSON and may mutate it in place (e.g. replace external
  * URLs with embedded data). Steps run sequentially in order.
  *
- * Defaults to `[prepareImages()]` when no steps are provided.
+ * Defaults to `[prepareImages(), prepareImageSizes()]` when no steps are provided.
  *
  * @example
  * ```ts
@@ -48,4 +60,4 @@ declare function prepareImages(handler?: ImageFetchHandler): PrepareStep;
  */
 declare function prepareDocument(json: JSONContent, steps?: readonly PrepareStep[]): Promise<void>;
 //#endregion
-export { ImageFetchHandler, PrepareStep, fetchImageHandler, prepareDocument, prepareImages };
+export { ImageFetchHandler, PrepareStep, fetchImageHandler, prepareDocument, prepareImageSizes, prepareImages };

package/dist/converters/prepare.mjs

@@ -1,3 +1,5 @@
+import { encodeBase64 } from "@office-open/core";
+import { imageMeta } from "image-meta";
 //#region src/converters/prepare.ts
 /**
 * Default fetch handler using the global `fetch` API (Node 18+ and browsers).
@@ -27,15 +29,31 @@ function prepareImages(handler = fetchImageHandler) {
 		await walkImages(json, handler);
 	};
 }
+/**
+* Create a prepare step that fills in missing image dimensions by reading image
+* metadata. Intended to run after {@link prepareImages} so HTTP sources are
+* already embedded as data URLs.
+*
+* Only images lacking `width` or `height` are probed — the DOCX round-trip path
+* already carries `transformation.width/height`, so this mainly serves images
+* entering via HTML/Markdown (which carry no intrinsic size). Images whose
+* metadata can't be read are left untouched; `renderDocx` falls back to 600×400
+* (see extensions/image.ts).
+*/
+function prepareImageSizes() {
+	return async (json) => {
+		await walkImageSizes(json);
+	};
+}
 /** Built-in prepare steps, run when no custom steps are provided. */
-const DEFAULT_STEPS = [prepareImages()];
+const DEFAULT_STEPS = [prepareImages(), prepareImageSizes()];
 /**
 * Run prepare steps on a Tiptap JSON document before compilation.
 *
 * Each step receives the JSON and may mutate it in place (e.g. replace external
 * URLs with embedded data). Steps run sequentially in order.
 *
-* Defaults to `[prepareImages()]` when no steps are provided.
+* Defaults to `[prepareImages(), prepareImageSizes()]` when no steps are provided.
 *
 * @example
 * ```ts
@@ -57,7 +75,7 @@ async function toDataUrl(src, handler) {
 		bmp: "image/bmp",
 		svg: "image/svg+xml",
 		webp: "image/webp"
-	}[src.split(".").pop()?.toLowerCase() ?? "png"] ?? "image/png"};base64,${typeof btoa !== "undefined" ? btoa(String.fromCharCode(...data)) : Buffer.from(data).toString("base64")}`;
+	}[src.split(".").pop()?.toLowerCase() ?? "png"] ?? "image/png"};base64,${encodeBase64(data)}`;
 }
 async function walkImages(node, handler) {
 	if (node.type === "image" && node.attrs) {
@@ -72,5 +90,33 @@ async function walkImages(node, handler) {
 	for (const child of node.content ?? []) tasks.push(walkImages(child, handler));
 	await Promise.all(tasks);
 }
+async function walkImageSizes(node) {
+	if (node.type === "image" && node.attrs) {
+		const attrs = node.attrs;
+		const needsWidth = attrs.width == null;
+		const needsHeight = attrs.height == null;
+		if (needsWidth || needsHeight) {
+			const bytes = decodeDataUrl(attrs.src);
+			if (bytes) try {
+				const meta = imageMeta(bytes);
+				if (needsWidth && typeof meta.width === "number") attrs.width = meta.width;
+				if (needsHeight && typeof meta.height === "number") attrs.height = meta.height;
+			} catch {}
+		}
+	}
+	const tasks = [];
+	for (const child of node.content ?? []) tasks.push(walkImageSizes(child));
+	await Promise.all(tasks);
+}
+/** Decode a `data:image/...;base64,...` URL to bytes; null if not a data URL. */
+function decodeDataUrl(src) {
+	if (!src) return null;
+	const match = src.match(/^data:image\/[\w.+-]+;base64,(.+)$/);
+	if (!match) return null;
+	const binary = atob(match[1]);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
 //#endregion
-export { fetchImageHandler, prepareDocument, prepareImages };
+export { fetchImageHandler, prepareDocument, prepareImageSizes, prepareImages };

package/dist/converters/styles.d.mts

@@ -0,0 +1,85 @@
+import { JSONContent } from "@tiptap/core";
+import { StylesOptions } from "@office-open/docx";
+
+//#region src/converters/styles.d.ts
+/** The styleId of the document's default paragraph style (`w:default="1"`
+ *  type="paragraph") — the implicit style applied to every paragraph WITHOUT an
+ *  explicit pStyle. OOXML renders a pStyle-less paragraph as this style (usually
+ *  "Normal"), so the editor's `.docx-default` class — emitted by Paragraph/
+ *  Heading renderHTML on a styleId-less node — targets it. Searched in
+ *  `paragraphStyles` and the built-in named styles nested under `default`
+ *  (key → pStyle id). null when the document declares none. */
+declare function defaultParagraphStyleId(styles: StylesOptions | null | undefined): string | null;
+/**
+ * Generate scoped CSS from a document's `styles.xml` model (`StylesOptions`) so
+ * named paragraph/character styles and the document defaults render correctly
+ * in the editor. All rules are scoped to `.docen-page` (the editor's page
+ * surface); the editor injects the result into a `<style>` after load.
+ *
+ * - `default.document` → `.docen-page` base run + paragraph defaults (the doc's
+ *   default font/size, line spacing, …).
+ * - `paragraphStyles[]` → `.docen-page .docx-style-{id}` (run + paragraph CSS).
+ *   Paragraph nodes carry `class="docx-style-{styleId}"` (see the Paragraph /
+ *   Heading extensions' pStyle ↔ styleId round-trip).
+ * - `characterStyles[]` → `.docen-page .docx-char-{id}` (run CSS).
+ *
+ * `basedOn` inheritance is deep-merged per-property into each named style's
+ * rule (root first, child overrides) — see mergeStyleChain. CSS inheritance
+ * follows the DOM tree, not a style's basedOn, so each `.docx-style-{id}` rule
+ * carries its full ancestor chain rather than relying on source order.
+ */
+declare function stylesToCss(styles: StylesOptions | null | undefined, scope: string): string;
+/** A gallery-ready paragraph-style entry for the Styles combobox. */
+interface QuickStyleEntry {
+  id: string;
+  name: string;
+}
+/**
+ * The paragraph styles to list in the Quick Styles gallery, matching Word's
+ * default behavior: the gallery is a *paragraph-style* selector (it applies a
+ * pStyle), so only paragraph styles appear — never character styles, even
+ * those flagged `quickFormat` (those live in the Styles task pane). Among
+ * paragraph styles, only those flagged `quickFormat` are listed, ordered by
+ * `uiPriority` (Word orders the gallery this way).
+ *
+ * Reads `quickFormat`/`uiPriority`/`name` straight from office-open's styles
+ * model (`StylesOptions`): `paragraphStyles` (Normal + custom) and the built-in
+ * named paragraph styles nested under `default` (title/heading1-9/quote/…). The
+ * `default` keys that hold character styles are excluded via
+ * `CHARACTER_DEFAULT_KEYS`. When a document carries no quickFormat flags at all
+ * (e.g. some LibreOffice-generated files), fall back to all paragraph styles so
+ * the gallery is never empty.
+ */
+declare function quickStyles(styles: StylesOptions | null | undefined): QuickStyleEntry[];
+/** Resolve the effective run-level properties (font name, size in points) at the
+ *  caret, staying in the document's own units — no px conversion. Priority:
+ *  direct run props (the textStyle mark) → the paragraph style (`styleId`) →
+ *  its `basedOn` chain → the document defaults. `font` is resolved to a single
+ *  display name (ascii/hAnsi/eastAsia). Returns null where nothing in the chain
+ *  sets a property, so the caller can leave the box empty. */
+declare function effectiveRunProps(styles: StylesOptions | null | undefined, styleId: string | null | undefined, direct?: {
+  font?: unknown;
+  size?: unknown;
+}): {
+  font: string | null;
+  size: number | null;
+};
+/**
+ * Inline a document's styles into each node's attrs — a self-contained
+ * JSONContent that round-trips and renders without the styles context. A
+ * paragraph/heading absorbs its styleId's `basedOn` chain (paragraph properties
+ * + the paragraph's default `run`); a textStyle mark absorbs its character
+ * style's run. Explicit attrs/marks always override the inherited values;
+ * styleId is preserved (the semantic reference is kept). The style definitions
+ * themselves are untouched — only properties are copied onto nodes.
+ *
+ * Styles default to the document's own `attrs.styles` (the round-tripped
+ * styles.xml model carried on the doc node), so `inlineStyles(doc)` needs no
+ * second argument; pass `styles` explicitly to override. Use cases:
+ * cross-document paste (the snippet carries its styling) and self-contained
+ * export. The editor still renders via global styles — this only merges JSON
+ * properties.
+ */
+declare function inlineStyles(json: JSONContent, styles?: StylesOptions | null): JSONContent;
+//#endregion
+export { QuickStyleEntry, type StylesOptions, defaultParagraphStyleId, effectiveRunProps, inlineStyles, quickStyles, stylesToCss };