@docen/docx 0.3.1 → 0.3.3

package/dist/converters/styles.mjs

@@ -1,2 +1,308 @@
-import { a as stylesToCss, i as quickStyles, n as effectiveRunProps, r as inlineStyles, t as defaultParagraphStyleId } from "../styles-QSX3RhxK.mjs";
-export { defaultParagraphStyleId, effectiveRunProps, inlineStyles, quickStyles, stylesToCss };
+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). */
+const styleIndexCache = /* @__PURE__ */ new WeakMap();
+function indexParagraphStyles(styles) {
+	const cached = styleIndexCache.get(styles);
+	if (cached) return cached;
+	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);
+	}
+	styleIndexCache.set(styles, byId);
+	return byId;
+}
+/** Whether `v` is a plain object — an OOXML property group (spacing/indent/
+*  border/shading/font) that merges key by key — as opposed to an array
+*  (tabStops) or scalar, which replace. */
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Deep-merge `source` into `target` (mutates target) per the OOXML `basedOn`
+*  model: nested property groups merge key by key (a child's spacing.before
+*  merges with, not replaces, the parent's spacing.line); arrays and scalars
+*  replace. Nullish source values are skipped so an unset child key doesn't
+*  clobber an inherited value. */
+function deepMergeInto(target, source) {
+	for (const [key, srcVal] of Object.entries(source)) {
+		if (srcVal === null || srcVal === void 0) continue;
+		const tgtVal = target[key];
+		target[key] = isPlainObject(srcVal) && isPlainObject(tgtVal) ? deepMergeInto({ ...tgtVal }, srcVal) : isPlainObject(srcVal) ? { ...srcVal } : srcVal;
+	}
+	return target;
+}
+/** Merge a paragraph style's run/paragraph properties with its `basedOn` chain
+*  (root first, child overrides per-property) — the OOXML inheritance model.
+*  Nested property groups (spacing/indent/border/font) merge key by key; arrays
+*  and scalars replace. 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) deepMergeInto(run, s.run);
+		if (s.paragraph) deepMergeInto(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, indexParagraphStyles, inlineStyles, quickStyles, stylesToCss };