@docen/docx 0.3.1 → 0.3.2

package/dist/converters/styles.mjs

@@ -1,2 +1,285 @@
-import { a as stylesToCss, i as quickStyles, n as effectiveRunProps, r as inlineStyles, t as defaultParagraphStyleId } from "../styles-QSX3RhxK.mjs";
+import { renderParagraphStyles, renderRunStyles, resolveFontName } from "../extensions/utils.mjs";
+//#region src/converters/styles.ts
+/** Escape a style id for safe use in a CSS class selector. OOXML style ids are
+*  NCNames so this is rarely needed, but it keeps arbitrary ids safe. */
+function escapeClass(id) {
+	return id.replace(/[^A-Za-z0-9_-]/g, (ch) => `\\${ch}`);
+}
+/** The pStyle val (class hook `docx-style-{id}`) for a built-in named style
+*  nested under DefaultStylesOptions: the key with its first letter upper-cased
+*  ("heading1" → "Heading1", "title" → "Title", "listParagraph" → "ListParagraph").
+*  This matches office-open's HeadingLevel literals / pStyle ids, so we derive
+*  the id from the key instead of hard-coding a name table. */
+function pStyleIdFromKey(key) {
+	return key.charAt(0).toUpperCase() + key.slice(1);
+}
+/** 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. */
+function defaultParagraphStyleId(styles) {
+	if (!styles) return null;
+	for (const ps of styles.paragraphStyles ?? []) if (ps.default) return ps.id;
+	const defaults = styles.default;
+	for (const [key, style] of Object.entries(defaults ?? {})) {
+		if (key === "document" || !style) continue;
+		if (style.default) return pStyleIdFromKey(key);
+	}
+	return 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.
+*/
+function stylesToCss(styles, scope) {
+	if (!styles) return "";
+	const rules = [];
+	const within = scope ? `${scope} ` : "";
+	const doc = styles.default?.document;
+	if (doc) {
+		const runDecls = doc.run ? renderRunStyles(doc.run) : [];
+		if (runDecls.length && scope) rules.push(`${scope} { ${runDecls.join(";")} }`);
+		const paraDecls = doc.paragraph ? renderParagraphStyles(doc.paragraph) : [];
+		if (paraDecls.length) {
+			const paraSel = `${within}p, ${within}h1, ${within}h2, ${within}h3, ${within}h4, ${within}h5, ${within}h6`;
+			rules.push(`${paraSel} { ${paraDecls.join(";")} }`);
+		}
+	}
+	const byId = indexParagraphStyles(styles);
+	const defaultId = defaultParagraphStyleId(styles);
+	for (const id of byId.keys()) {
+		const { run, paragraph } = mergeStyleChain(byId, id);
+		const decls = [];
+		if (Object.keys(run).length) decls.push(...renderRunStyles(run));
+		if (Object.keys(paragraph).length) decls.push(...renderParagraphStyles(paragraph));
+		if (!decls.length) continue;
+		const selector = id === defaultId ? `${within}.docx-default, ${within}.docx-style-${escapeClass(id)}` : `${within}.docx-style-${escapeClass(id)}`;
+		rules.push(`${selector} { ${decls.join(";")} }`);
+	}
+	for (const cs of styles.characterStyles ?? []) {
+		const decls = [];
+		if (cs.run) decls.push(...renderRunStyles(cs.run));
+		if (decls.length) rules.push(`${within}.docx-char-${escapeClass(cs.id)} { ${decls.join(";")} }`);
+	}
+	return rules.join("\n");
+}
+/** Build an id → style-entry index over every paragraph style: the explicit
+*  `paragraphStyles` plus the built-in named styles nested under `default`
+*  (key → pStyle id via pStyleIdFromKey). `document` is docDefaults, not a
+*  named style, so it is excluded. A built-in that also appears in
+*  paragraphStyles is deduped by id (paragraphStyles wins on insertion order). */
+function indexParagraphStyles(styles) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const ps of styles.paragraphStyles ?? []) byId.set(ps.id, ps);
+	const defaults = styles.default;
+	for (const [key, style] of Object.entries(defaults ?? {})) {
+		if (key === "document" || !style) continue;
+		byId.set(pStyleIdFromKey(key), style);
+	}
+	return byId;
+}
+/** Merge a paragraph style's run/paragraph properties with its `basedOn` chain
+*  (root first, child overrides per-property) — the OOXML inheritance model. A
+*  flat property-level merge: a child property overrides the parent's; an unset
+*  property is inherited. Shared by stylesToCss (rendering) and
+*  effectiveRunProps (the caret resolver) so the gallery box and the rendered
+*  page resolve identical values. */
+function mergeStyleChain(byId, styleId) {
+	const chain = [];
+	const visited = /* @__PURE__ */ new Set();
+	let curId = styleId || void 0;
+	while (curId && !visited.has(curId)) {
+		visited.add(curId);
+		const style = byId.get(curId);
+		if (!style) break;
+		chain.unshift(style);
+		curId = style.basedOn ?? void 0;
+	}
+	const run = {};
+	const paragraph = {};
+	for (const style of chain) {
+		const s = style;
+		if (s.run) Object.assign(run, s.run);
+		if (s.paragraph) Object.assign(paragraph, s.paragraph);
+	}
+	return {
+		run,
+		paragraph
+	};
+}
+/** The `DefaultStylesOptions` keys whose values are character styles, not
+*  paragraph styles. The Quick Styles gallery is paragraph-only, so these are
+*  excluded even when flagged `quickFormat` (the authoritative source is
+*  office-open's DefaultStylesOptions interface). */
+const CHARACTER_DEFAULT_KEYS = new Set([
+	"hyperlink",
+	"footnoteReference",
+	"footnoteTextChar",
+	"endnoteReference",
+	"endnoteTextChar"
+]);
+/**
+* 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.
+*/
+function quickStyles(styles) {
+	if (!styles) return [];
+	const all = [];
+	const seen = /* @__PURE__ */ new Set();
+	const push = (id, style) => {
+		if (seen.has(id)) return;
+		seen.add(id);
+		all.push({
+			id,
+			name: style.name || id,
+			uiPriority: style.uiPriority ?? 9999,
+			quick: !!style.quickFormat
+		});
+	};
+	for (const ps of styles.paragraphStyles ?? []) push(ps.id, ps);
+	const defaults = styles.default;
+	for (const [key, style] of Object.entries(defaults)) {
+		if (key === "document" || CHARACTER_DEFAULT_KEYS.has(key) || !style) continue;
+		push(pStyleIdFromKey(key), style);
+	}
+	const byPriority = (a, b) => a.uiPriority - b.uiPriority;
+	const quick = all.filter((s) => s.quick).sort(byPriority);
+	return (quick.length > 0 ? quick : all).map(({ id, name }) => ({
+		id,
+		name
+	}));
+}
+/** 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. */
+function effectiveRunProps(styles, styleId, direct) {
+	let font = null;
+	let size = null;
+	if (direct) {
+		font = resolveFontName(direct.font);
+		if (typeof direct.size === "number" && direct.size > 0) size = direct.size;
+	}
+	if ((font == null || size == null) && styles) {
+		const effStyleId = styleId || defaultParagraphStyleId(styles);
+		const { run } = mergeStyleChain(indexParagraphStyles(styles), effStyleId);
+		if (font == null) font = resolveFontName(run.font);
+		if (size == null && typeof run.size === "number" && run.size > 0) size = run.size;
+		if (font == null || size == null) {
+			const docRun = styles.default?.document?.run;
+			if (docRun) {
+				if (font == null) font = resolveFontName(docRun.font);
+				if (size == null && typeof docRun.size === "number" && docRun.size > 0) size = docRun.size;
+			}
+		}
+	}
+	return {
+		font,
+		size
+	};
+}
+/** Index a document's character styles (explicit `characterStyles` + the
+*  built-in character keys under `default`) by pStyle id → run properties. Core
+*  phase: a character style's own run only (its basedOn chain is not walked —
+*  rare in practice; paragraph styles above already deep-merge). */
+function indexCharacterRunStyles(styles) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const cs of styles.characterStyles ?? []) if (cs.run) byId.set(cs.id, cs.run);
+	const defaults = styles.default;
+	for (const [key, style] of Object.entries(defaults ?? {})) {
+		if (!style || !style.run || key === "document") continue;
+		if (!CHARACTER_DEFAULT_KEYS.has(key)) continue;
+		byId.set(pStyleIdFromKey(key), style.run);
+	}
+	return byId;
+}
+/** Resolve one node's style inheritance: a paragraph/heading absorbs its
+*  styleId's basedOn chain (paragraph properties + the default `run`); a
+*  textStyle mark absorbs its character style's run. Explicit attrs/marks
+*  override the inherited values; styleId is preserved. Pure JSON — no DOM, no
+*  marks pushed onto text. */
+function resolveNode(node, paraById, charRunById) {
+	const out = { ...node };
+	const attrs = node.attrs;
+	const type = node.type;
+	if ((type === "paragraph" || type === "heading") && attrs?.styleId) {
+		const { paragraph, run } = mergeStyleChain(paraById, attrs.styleId);
+		const mergedRun = {
+			...run,
+			...attrs.run
+		};
+		out.attrs = {
+			...paragraph,
+			...attrs,
+			run: mergedRun
+		};
+	}
+	if (node.marks) out.marks = node.marks.map((m) => {
+		if (m.type !== "textStyle") return m;
+		const sid = m.attrs?.styleId;
+		const crun = sid ? charRunById.get(sid) : void 0;
+		return crun ? {
+			...m,
+			attrs: {
+				...crun,
+				...m.attrs
+			}
+		} : m;
+	});
+	if (node.content) out.content = node.content.map((c) => resolveNode(c, paraById, charRunById));
+	return out;
+}
+/**
+* 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.
+*/
+function inlineStyles(json, styles) {
+	const docStyles = styles ?? json.attrs?.styles;
+	if (!docStyles) return json;
+	return resolveNode(json, indexParagraphStyles(docStyles), indexCharacterRunStyles(docStyles));
+}
+//#endregion
 export { defaultParagraphStyleId, effectiveRunProps, inlineStyles, quickStyles, stylesToCss };

package/dist/core-C9VunJ8o.d.mts

@@ -0,0 +1,174 @@
+import { AnyExtension, Editor, Extension, Extensions, JSONContent as JSONContent$1, Mark, Node } from "@tiptap/core";
+import { TextAlign } from "@tiptap/extension-text-align";
+
+//#region src/extensions/image.d.ts
+type CropRect = {
+  left?: number;
+  top?: number;
+  right?: number;
+  bottom?: number;
+};
+/**
+ * Tiptap JSON image node → CoreImageOptions-shaped object.
+ *
+ * Returns `{ image: ImageOptions }` (structural wrapper) or null when no
+ * embedded image data is available (external URLs need pre-fetching).
+ * rotation is carried via transformation.rotation (not dropped).
+ */
+declare function renderDocx(node: JSONContent$1): Record<string, unknown> | null;
+/**
+ * ImageOptions-shaped object → Tiptap attrs.
+ *
+ * Near-identity unpack: transformation → width/height/rotation, altText → alt/title,
+ * floating/srcRect(→crop)/outline passed through verbatim. src is reconstructed by
+ * DocxManager from the image data bytes (kept out of parseDocx).
+ */
+declare function parseDocx(imageOpts: Record<string, unknown>): Record<string, unknown>;
+/** Extent-box dimensions needed to size the inner <img> for a cropped image. */
+interface CropRenderContext {
+  width?: number;
+  height?: number;
+}
+/**
+ * Render crop as the inner <img> style for byte-accurate four-sided srcRect.
+ *
+ * object-fit:cover scales uniformly, so it only matches single-axis crops.
+ * Instead the inner <img> is sized to the un-cropped display size per axis
+ * (imgW = W/visibleW, imgH = H/visibleH) and translated so the visible srcRect
+ * region maps exactly onto the extent box; the outer box clips (overflow:hidden)
+ * the cropped-out left/top region. Mathematically equivalent to a
+ * background-size/background-position crop, but keeps a real <img> (alt,
+ * accessibility, semantics, drag-to-save).
+ */
+declare function renderCropAttrs(crop: Record<string, unknown> | CropRect, ctx?: CropRenderContext): {
+  style: string;
+};
+declare const Image: import("@tiptap/core").Node<import("@tiptap/extension-image").ImageOptions, any>;
+//#endregion
+//#region src/extensions/wpg-group.d.ts
+interface FillColor {
+  value?: string;
+}
+interface Fill {
+  type?: string;
+  color?: FillColor;
+}
+interface Outline {
+  type?: string;
+  color?: FillColor;
+  width?: number;
+  dash?: string;
+}
+/** wps shape data (WpsShapeCoreOptions subset used for rendering). */
+interface WpsBodyProperties {
+  rotation?: number;
+  lIns?: number;
+  tIns?: number;
+  rIns?: number;
+  bIns?: number;
+  vert?: string;
+}
+interface WpsData {
+  fill?: Fill;
+  outline?: Outline;
+  bodyProperties?: WpsBodyProperties & Record<string, unknown>;
+  children?: unknown[];
+}
+type Spec = ReadonlyArray<unknown>;
+/** wps text-body paragraphs (office-open ParagraphOptions[]) → inline HTML runs
+ *  so a text-box shape shows its text. Each paragraph's run defaults merge with
+ *  each text run; renderRunStyles converts font/color/size/… to CSS. Advanced run
+ *  props (shadow w14RawXml, kern) are carried in attrs but not rendered. */
+declare function renderWpsText(children: unknown): Spec[];
+/**
+ * Render a wps shape's interior (fill/outline/insets/rotation/writing-mode + text
+ * body) as a positioned div. Shared by the wpg group's inline wps children and
+ * the standalone wpsShape node, so a text-box shape renders identically whether
+ * it floats alone (wp:anchor > wps:wsp) or sits inside a group. `positionStyle`
+ * carries the placement — absolute group coords for a group child, the floating
+ * anchor CSS for a standalone shape. `opts.rotation` overrides bodyPr rotation
+ * (a group child's rotation may come from the group transform, not bodyPr).
+ */
+declare function renderWpsInterior(data: WpsData, positionStyle: string, opts?: {
+  rotation?: number;
+  attrs?: Record<string, string>;
+}): Spec;
+declare const WpgGroup: Node<any, any>;
+//#endregion
+//#region src/extensions/wps-shape.d.ts
+declare const WpsShape: Node<any, any>;
+//#endregion
+//#region src/extensions/passthrough.d.ts
+/**
+ * Passthrough — block atom carrying an opaque {@link SectionChild} that has
+ * no native Tiptap representation (rawXml, bookmarkStart/End, toc, textbox,
+ * altChunk, subDoc, customXml).
+ *
+ * The full SectionChild is stored as JSON in `attrs.data` so the DOCX→JSON→DOCX
+ * round-trip stays byte-faithful: office-open's stringify handles the inner
+ * structure verbatim (including a textbox's nested children, which remain as
+ * structured ParagraphOptions inside the blob rather than editable Tiptap
+ * nodes). The node is not editable — it renders a read-only placeholder in HTML.
+ *
+ * DOCX serialization is inlined in DocxManager (compile/resolve read/write
+ * `attrs.data` directly), so no renderDocx/parseDocx is needed here.
+ */
+declare const Passthrough: Node<any, any>;
+//#endregion
+//#region src/extensions/extensions.d.ts
+declare const tiptapNodeExtensions: AnyExtension[];
+declare const tiptapMarkExtensions: AnyExtension[];
+declare const docxExtensions: AnyExtension[];
+interface DocxKitOptions {
+  bold?: Record<string, any> | false;
+  blockquote?: Record<string, any> | false;
+  bulletList?: Record<string, any> | false;
+  code?: Record<string, any> | false;
+  codeBlock?: Record<string, any> | false;
+  document?: false;
+  hardBreak?: Record<string, any> | false;
+  heading?: Record<string, any> | false;
+  horizontalRule?: Record<string, any> | false;
+  italic?: Record<string, any> | false;
+  listItem?: Record<string, any> | false;
+  link?: Record<string, any> | false;
+  orderedList?: Record<string, any> | false;
+  paragraph?: Record<string, any> | false;
+  strike?: Record<string, any> | false;
+  text?: false;
+  underline?: Record<string, any> | false;
+}
+declare const DocxKit: Extension<DocxKitOptions, any>;
+//#endregion
+//#region src/extensions/page-break.d.ts
+/**
+ * PageBreak — inline atom node for DOCX page breaks (`<w:br w:type="page"/>`).
+ *
+ * OOXML page breaks live inside a run (inline), so the Tiptap node is inline
+ * too (group "inline"). This keeps a break inside its paragraph on round-trip
+ * — a break mid-paragraph stays mid-paragraph instead of splitting the
+ * paragraph into separate blocks (which would lose the original structure).
+ * Sibling to HardBreak: both render `<w:br>`, differing only by type.
+ *
+ * The DOCX payload (`{ pageBreak: true }`) is inlined in DocxManager — a
+ * one-liner with no per-node variance, so no extension helper for it.
+ *
+ * Inserting a page break must also visually reflow (the C-route paginator only
+ * forces a new page after a block *containing* a pageBreak atom). So
+ * `setPageBreak` inserts the atom then splits the paragraph — the atom lands at
+ * the end of the first half, the trailing text becomes a fresh paragraph, and
+ * the paginator's `forcesPageBreakAfter` moves it to the next page (matching
+ * Word's Ctrl+Enter behavior).
+ */
+declare const PageBreak: Node<any, any>;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    pageBreak: {
+      /** Insert a page break at the cursor and split the paragraph so the
+       *  trailing content reflows to the next page. */
+      setPageBreak: () => ReturnType;
+    };
+  }
+}
+//#endregion
+export { parseDocx as C, Image as S, renderDocx as T, WpgGroup as _, JSONContent$1 as a, renderWpsText as b, PageBreak as c, TextAlign as d, docxExtensions as f, WpsShape as g, Passthrough as h, Extensions as i, DocxKit as l, tiptapNodeExtensions as m, Editor as n, Mark as o, tiptapMarkExtensions as p, Extension as r, Node as s, AnyExtension as t, DocxKitOptions as u, WpsData as v, renderCropAttrs as w, CropRenderContext as x, renderWpsInterior as y };