@docen/docx 0.3.0 → 0.3.1

package/dist/paragraph-BrWH-BOV.mjs

@@ -0,0 +1,147 @@
+import { T as Paragraph$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/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 }) {
+		const styles = renderParagraphStyles(node.attrs);
+		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 { parseDocx as n, renderDocx as r, Paragraph as t };

package/dist/paragraph-D8mpHo_o.d.mts

@@ -0,0 +1,8 @@
+import { JSONContent } from "@tiptap/core";
+
+//#region src/extensions/paragraph.d.ts
+declare function renderDocx(node: JSONContent): Record<string, unknown>;
+declare function parseDocx(opts: Record<string, unknown>): Record<string, unknown>;
+declare const Paragraph: import("@tiptap/core").Node<import("@tiptap/extension-paragraph").ParagraphOptions, any>;
+//#endregion
+export { parseDocx as n, renderDocx as r, Paragraph as t };

package/dist/patch-Cdp5WKJz.d.mts

@@ -0,0 +1,53 @@
+import { a as JSONContent } from "./core-fBMCCj4D.mjs";
+import { n as PrepareStep } from "./prepare-CPAvcv6q.mjs";
+import { OutputByType, OutputType, patchDocument } from "@office-open/docx";
+
+//#region src/converters/patch.d.ts
+/**
+ * A patch's replacement content, expressed as Tiptap JSON. `compileDocument`
+ * converts it to office-open `SectionChild[]` before applying.
+ */
+interface DocxPatchContent {
+  content: JSONContent;
+}
+/**
+ * Options for patching a DOCX template.
+ *
+ * Mirrors the legacy `@docen/export-docx` DocxPatchOptions minus `exportOptions`
+ * — `compileDocument` already derives all styling from the Tiptap attrs, so no
+ * separate export configuration is needed.
+ */
+interface DocxPatchOptions<T extends OutputType = OutputType> {
+  /** Template DOCX to patch. */
+  template: Parameters<typeof patchDocument>[0]["data"];
+  /** Placeholder name → replacement content. */
+  patches: Record<string, DocxPatchContent>;
+  /**
+   * Pre-compilation steps run on each patch's content in place (default:
+   * `prepareImages()`). `false` skips; `PrepareStep[]` runs custom steps.
+   * Required when patch content references http image URLs.
+   */
+  prepare?: boolean | PrepareStep[];
+  /** Custom placeholder delimiters (default `{{` / `}}`). */
+  placeholderDelimiters?: {
+    start?: string;
+    end?: string;
+  };
+  /** Keep the template's paragraph styles on patched content. */
+  keepOriginalStyles?: boolean;
+  /** Recurse into nested patches. */
+  recursive?: boolean;
+  /** Output container type. */
+  outputType: T;
+}
+/**
+ * Patch a DOCX template by replacing placeholders with Tiptap-JSON content.
+ *
+ * Each patch's `content` is prepared (default: `prepareImages`, in place) then
+ * compiled (`compileDocument` → `DocumentOptions`); its first section's
+ * `children` become the replacement. Patching is delegated to
+ * `@office-open/docx`'s `patchDocument`.
+ */
+declare function patchDOCX<T extends OutputType>(options: DocxPatchOptions<T>): Promise<OutputByType[T]>;
+//#endregion
+export { DocxPatchOptions as n, patchDOCX as r, DocxPatchContent as t };

package/dist/patch-IZ13tXTu.mjs

@@ -0,0 +1,36 @@
+import { n as prepareDocument } from "./prepare-Bdk8Cjkf.mjs";
+import { n as compileDocument } from "./docx-CONyAedl.mjs";
+import { patchDocument } from "@office-open/docx";
+//#region src/converters/patch.ts
+/**
+* Patch a DOCX template by replacing placeholders with Tiptap-JSON content.
+*
+* Each patch's `content` is prepared (default: `prepareImages`, in place) then
+* compiled (`compileDocument` → `DocumentOptions`); its first section's
+* `children` become the replacement. Patching is delegated to
+* `@office-open/docx`'s `patchDocument`.
+*/
+async function patchDOCX(options) {
+	const { template, patches, prepare = true, placeholderDelimiters, keepOriginalStyles, recursive, outputType } = options;
+	const patchesObject = {};
+	for (const [key, patchContent] of Object.entries(patches)) {
+		if (prepare !== false) await prepareDocument(patchContent.content, prepare === true ? void 0 : prepare);
+		patchesObject[key] = {
+			type: "document",
+			children: compileDocument(patchContent.content).sections?.[0]?.children ?? []
+		};
+	}
+	return patchDocument({
+		outputType,
+		data: template,
+		placeholders: patchesObject,
+		...keepOriginalStyles !== void 0 && { keepOriginalStyles },
+		...recursive !== void 0 && { recursive },
+		...placeholderDelimiters && { placeholderDelimiters: {
+			start: placeholderDelimiters.start ?? "{{",
+			end: placeholderDelimiters.end ?? "}}"
+		} }
+	});
+}
+//#endregion
+export { patchDOCX as t };

package/dist/prepare-Bdk8Cjkf.mjs

@@ -0,0 +1,122 @@
+import { t as encodeBase64 } from "./dist-B6B3HnVZ.mjs";
+import { imageMeta } from "image-meta";
+//#region src/converters/prepare.ts
+/**
+* Default fetch handler using the global `fetch` API (Node 18+ and browsers).
+*/
+async function fetchImageHandler(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to fetch image from ${url}: ${response.status} ${response.statusText}`);
+	const buffer = await response.arrayBuffer();
+	return new Uint8Array(buffer);
+}
+/**
+* Create a prepare step that fetches external image URLs and converts them to data URLs.
+*
+* @param handler - Custom fetch handler (defaults to `fetchImageHandler`)
+*
+* @example
+* ```ts
+* // Use with defaults
+* await prepareDocument(json);
+*
+* // Custom handler
+* await prepareDocument(json, [prepareImages(myHandler)]);
+* ```
+*/
+function prepareImages(handler = fetchImageHandler) {
+	return async (json) => {
+		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(), 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(), prepareImageSizes()]` when no steps are provided.
+*
+* @example
+* ```ts
+* const json = parseHTML(html);
+* await prepareDocument(json);             // default: fetch images
+* const docOpts = compileDocument(json);
+* ```
+*/
+async function prepareDocument(json, steps = DEFAULT_STEPS) {
+	for (const step of steps) await step(json);
+}
+async function toDataUrl(src, handler) {
+	const data = await handler(src);
+	return `data:${{
+		jpg: "image/jpeg",
+		jpeg: "image/jpeg",
+		png: "image/png",
+		gif: "image/gif",
+		bmp: "image/bmp",
+		svg: "image/svg+xml",
+		webp: "image/webp"
+	}[src.split(".").pop()?.toLowerCase() ?? "png"] ?? "image/png"};base64,${encodeBase64(data)}`;
+}
+async function walkImages(node, handler) {
+	if (node.type === "image" && node.attrs) {
+		const src = node.attrs.src;
+		if (src && (src.startsWith("http://") || src.startsWith("https://"))) try {
+			node.attrs.src = await toDataUrl(src, handler);
+		} catch (error) {
+			console.warn(`Failed to fetch image: ${src}`, error instanceof Error ? error.message : error);
+		}
+	}
+	const tasks = [];
+	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 { prepareImages as i, prepareDocument as n, prepareImageSizes as r, fetchImageHandler as t };

package/dist/prepare-CPAvcv6q.d.mts

@@ -0,0 +1,63 @@
+import { a as JSONContent } from "./core-fBMCCj4D.mjs";
+
+//#region src/converters/prepare.d.ts
+/**
+ * A prepare step that transforms Tiptap JSON in place (e.g. fetch external resources).
+ */
+type PrepareStep = (json: JSONContent) => Promise<void>;
+/**
+ * Fetch handler for external image URLs.
+ *
+ * Receives the URL, returns the image binary data.
+ * Override to customize fetching (proxy, auth, caching, etc.).
+ */
+type ImageFetchHandler = (url: string) => Promise<Uint8Array>;
+/**
+ * Default fetch handler using the global `fetch` API (Node 18+ and browsers).
+ */
+declare function fetchImageHandler(url: string): Promise<Uint8Array>;
+/**
+ * Create a prepare step that fetches external image URLs and converts them to data URLs.
+ *
+ * @param handler - Custom fetch handler (defaults to `fetchImageHandler`)
+ *
+ * @example
+ * ```ts
+ * // Use with defaults
+ * await prepareDocument(json);
+ *
+ * // Custom handler
+ * await prepareDocument(json, [prepareImages(myHandler)]);
+ * ```
+ */
+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(), prepareImageSizes()]` when no steps are provided.
+ *
+ * @example
+ * ```ts
+ * const json = parseHTML(html);
+ * await prepareDocument(json);             // default: fetch images
+ * const docOpts = compileDocument(json);
+ * ```
+ */
+declare function prepareDocument(json: JSONContent, steps?: readonly PrepareStep[]): Promise<void>;
+//#endregion
+export { prepareImageSizes as a, prepareDocument as i, PrepareStep as n, prepareImages as o, fetchImageHandler as r, ImageFetchHandler as t };

package/dist/strike-hWxShOgb.mjs

@@ -0,0 +1,50 @@
+import { E as Strike$1 } from "./tiptap-D7pl4I5U.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 { parseDocx as n, renderDocx as r, Strike as t };