@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/docx/themeParser.js

@@ -0,0 +1,330 @@
+import { findChild, findChildren, getAttribute, getChildElements, getLocalName, parseXmlDocument } from "./xmlParser.js";
+//#region src/docx/themeParser.ts
+/**
+* Default theme colors (Office 2016 default theme)
+* Used when theme1.xml is missing or malformed
+*/
+const DEFAULT_COLORS = {
+	dk1: "000000",
+	lt1: "FFFFFF",
+	dk2: "44546A",
+	lt2: "E7E6E6",
+	accent1: "4472C4",
+	accent2: "ED7D31",
+	accent3: "A5A5A5",
+	accent4: "FFC000",
+	accent5: "5B9BD5",
+	accent6: "70AD47",
+	hlink: "0563C1",
+	folHlink: "954F72"
+};
+/**
+* Default font scheme
+*/
+const DEFAULT_FONTS = {
+	majorFont: {
+		latin: "Calibri Light",
+		ea: "",
+		cs: "",
+		fonts: {}
+	},
+	minorFont: {
+		latin: "Calibri",
+		ea: "",
+		cs: "",
+		fonts: {}
+	}
+};
+/**
+* Default theme when no theme1.xml exists
+*/
+const DEFAULT_THEME = {
+	name: "Office Theme",
+	colorScheme: DEFAULT_COLORS,
+	fontScheme: DEFAULT_FONTS
+};
+/**
+* Color slot names in theme
+*/
+const COLOR_SLOTS = [
+	"dk1",
+	"lt1",
+	"dk2",
+	"lt2",
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"hlink",
+	"folHlink"
+];
+/**
+* Parse a color element (srgbClr, sysClr, or schemeClr)
+*
+* @param element - Color child element
+* @returns Hex color value (6 characters, no #)
+*/
+function parseColorElement(element) {
+	if (!element) return null;
+	switch (getLocalName(element.name || "")) {
+		case "srgbClr": return getAttribute(element, "a", "val") ?? getAttribute(element, null, "val") ?? null;
+		case "sysClr": {
+			const lastClr = getAttribute(element, "a", "lastClr") ?? getAttribute(element, null, "lastClr");
+			if (lastClr) return lastClr;
+			switch (getAttribute(element, "a", "val") ?? getAttribute(element, null, "val")) {
+				case "windowText":
+				case "menuText":
+				case "captionText":
+				case "btnText": return "000000";
+				case "window":
+				case "menu":
+				case "btnFace":
+				case "btnHighlight": return "FFFFFF";
+				case "highlight": return "0078D7";
+				case "highlightText": return "FFFFFF";
+				case "grayText": return "808080";
+				default: return null;
+			}
+		}
+		case "schemeClr": return null;
+		default: return null;
+	}
+}
+/**
+* Parse the color scheme from a:clrScheme element
+*
+* @param clrScheme - The a:clrScheme element
+* @returns ThemeColorScheme with resolved hex colors
+*/
+function parseColorScheme(clrScheme) {
+	const result = { ...DEFAULT_COLORS };
+	if (!clrScheme) return result;
+	for (const slot of COLOR_SLOTS) {
+		const slotElement = findChild(clrScheme, "a", slot);
+		if (slotElement) {
+			const children = getChildElements(slotElement);
+			if (children.length > 0) {
+				const color = parseColorElement(children[0]);
+				if (color) result[slot] = color;
+			}
+		}
+	}
+	return result;
+}
+/**
+* Parse a font definition (majorFont or minorFont)
+*
+* @param fontElement - The a:majorFont or a:minorFont element
+* @returns ThemeFont with font family names
+*/
+function parseThemeFonts(fontElement) {
+	const result = {
+		latin: "",
+		ea: "",
+		cs: "",
+		fonts: {}
+	};
+	if (!fontElement) return result;
+	const latinEl = findChild(fontElement, "a", "latin");
+	if (latinEl) result.latin = getAttribute(latinEl, "a", "typeface") ?? getAttribute(latinEl, null, "typeface") ?? "";
+	const eaEl = findChild(fontElement, "a", "ea");
+	if (eaEl) result.ea = getAttribute(eaEl, "a", "typeface") ?? getAttribute(eaEl, null, "typeface") ?? "";
+	const csEl = findChild(fontElement, "a", "cs");
+	if (csEl) result.cs = getAttribute(csEl, "a", "typeface") ?? getAttribute(csEl, null, "typeface") ?? "";
+	const fontElements = findChildren(fontElement, "a", "font");
+	for (const font of fontElements) {
+		const script = getAttribute(font, "a", "script") ?? getAttribute(font, null, "script");
+		const typeface = getAttribute(font, "a", "typeface") ?? getAttribute(font, null, "typeface");
+		if (script && typeface) (result.fonts ??= {})[script] = typeface;
+	}
+	return result;
+}
+/**
+* Parse the font scheme from a:fontScheme element
+*
+* @param fontScheme - The a:fontScheme element
+* @returns ThemeFontScheme with major and minor fonts
+*/
+function parseFontScheme(fontScheme) {
+	const result = { ...DEFAULT_FONTS };
+	if (!fontScheme) return result;
+	const majorFontEl = findChild(fontScheme, "a", "majorFont");
+	if (majorFontEl) result.majorFont = parseThemeFonts(majorFontEl);
+	const minorFontEl = findChild(fontScheme, "a", "minorFont");
+	if (minorFontEl) result.minorFont = parseThemeFonts(minorFontEl);
+	return result;
+}
+/**
+* Parse theme1.xml content
+*
+* @param themeXml - XML content of theme1.xml, or null if not present
+* @returns Parsed Theme object with colors and fonts
+*/
+function parseTheme(themeXml) {
+	if (!themeXml) return { ...DEFAULT_THEME };
+	try {
+		const doc = parseXmlDocument(themeXml);
+		if (!doc) return { ...DEFAULT_THEME };
+		const themeName = getAttribute(doc, "a", "name") ?? getAttribute(doc, null, "name") ?? "Office Theme";
+		const themeElements = findChild(doc, "a", "themeElements");
+		return {
+			name: themeName,
+			colorScheme: parseColorScheme(findChild(themeElements, "a", "clrScheme")),
+			fontScheme: parseFontScheme(findChild(themeElements, "a", "fontScheme"))
+		};
+	} catch {
+		return { ...DEFAULT_THEME };
+	}
+}
+/**
+* Map a `w:themeFontLang` EastAsian language tag to the DrawingML `script`
+* attribute used by the theme's `<a:font script="…">` entries.
+*/
+function eastAsiaLangToScript(lang) {
+	const l = lang.toLowerCase();
+	if (l.startsWith("ja")) return "Jpan";
+	if (l.startsWith("ko")) return "Hang";
+	if (l.startsWith("zh")) {
+		if (l.includes("hant") || /-(?:tw|hk|mo)\b/u.test(l)) return "Hant";
+		return "Hans";
+	}
+	return null;
+}
+/**
+* Map a `w:themeFontLang` bidi/complex-script language tag to a DrawingML
+* `script` attribute.
+*/
+function bidiLangToScript(lang) {
+	const l = lang.toLowerCase();
+	if (l.startsWith("ar")) return "Arab";
+	if (l.startsWith("he") || l.startsWith("iw")) return "Hebr";
+	if (l.startsWith("th")) return "Thai";
+	if (l.startsWith("hi") || l.startsWith("mr") || l.startsWith("ne")) return "Deva";
+	return null;
+}
+/**
+* Resolve empty EastAsian/complex-script theme font slots using the document's
+* `w:themeFontLang` (port of eigenpal/docx-editor#949).
+*
+* Office's default theme leaves `<a:ea typeface="">`/`<a:cs typeface="">` empty
+* and instead lists the real typeface per script (`<a:font script="Jpan" …>`).
+* Word selects among those by the language declared in `w:themeFontLang`. A run
+* that references `minorEastAsia` in a Japanese document then resolves to
+* `ＭＳ 明朝` rather than an empty string — an empty font breaks both line-break
+* measurement and CJK rendering, so text overflows the right margin.
+*
+* Mutates the theme in place; the original `theme1.xml` is preserved verbatim on
+* save, so this only affects the in-memory model used for layout/rendering.
+*/
+function applyThemeFontLang(theme, themeFontLang) {
+	if (!theme?.fontScheme || !themeFontLang) return;
+	const eaScript = themeFontLang.eastAsia ? eastAsiaLangToScript(themeFontLang.eastAsia) : null;
+	const csScript = themeFontLang.bidi ? bidiLangToScript(themeFontLang.bidi) : null;
+	for (const font of [theme.fontScheme.majorFont, theme.fontScheme.minorFont]) {
+		if (!font) continue;
+		if (!font.ea && eaScript && font.fonts?.[eaScript]) font.ea = font.fonts[eaScript];
+		if (!font.cs && csScript && font.fonts?.[csScript]) font.cs = font.fonts[csScript];
+	}
+}
+/**
+* Get a color from the theme by slot name
+*
+* @param theme - Parsed theme
+* @param slot - Color slot name (dk1, lt1, accent1, etc.)
+* @returns Hex color value (6 characters, no #)
+*/
+function getThemeColor(theme, slot) {
+	if (!theme?.colorScheme) return DEFAULT_COLORS[slot] ?? "000000";
+	return theme.colorScheme[slot] ?? DEFAULT_COLORS[slot] ?? "000000";
+}
+/**
+* Get the major font (heading font) from theme
+*
+* @param theme - Parsed theme
+* @param script - Optional script code (defaults to latin)
+* @returns Font family name
+*/
+function getMajorFont(theme, script = "latin") {
+	if (!theme?.fontScheme?.majorFont) return DEFAULT_FONTS.majorFont?.latin ?? "Calibri Light";
+	const majorFont = theme.fontScheme.majorFont;
+	if (script === "latin") return majorFont.latin || "Calibri Light";
+	if (script === "ea") return majorFont.ea || "";
+	if (script === "cs") return majorFont.cs || "";
+	if (majorFont.fonts?.[script]) return majorFont.fonts[script];
+	return majorFont.latin || "Calibri Light";
+}
+/**
+* Get the minor font (body font) from theme
+*
+* @param theme - Parsed theme
+* @param script - Optional script code (defaults to latin)
+* @returns Font family name
+*/
+function getMinorFont(theme, script = "latin") {
+	if (!theme?.fontScheme?.minorFont) return DEFAULT_FONTS.minorFont?.latin ?? "Calibri";
+	const minorFont = theme.fontScheme.minorFont;
+	if (script === "latin") return minorFont.latin || "Calibri";
+	if (script === "ea") return minorFont.ea || "";
+	if (script === "cs") return minorFont.cs || "";
+	if (minorFont.fonts?.[script]) return minorFont.fonts[script];
+	return minorFont.latin || "Calibri";
+}
+/**
+* Resolve a theme font reference to an actual font name
+*
+* Theme font references are like: majorAscii, majorHAnsi, minorAscii, minorHAnsi, etc.
+*
+* @param theme - Parsed theme
+* @param themeRef - Theme font reference
+* @returns Font family name
+*/
+function resolveThemeFontRef(theme, themeRef) {
+	if (!themeRef) return "Calibri";
+	const isMajor = themeRef.toLowerCase().includes("major");
+	const isMinor = themeRef.toLowerCase().includes("minor");
+	let script = "latin";
+	const lowerRef = themeRef.toLowerCase();
+	if (lowerRef.includes("eastasia")) script = "ea";
+	else if (lowerRef.includes("bidi") || lowerRef.includes("cs")) script = "cs";
+	if (isMajor) return getMajorFont(theme, script);
+	else if (isMinor) return getMinorFont(theme, script);
+	return getMinorFont(theme, "latin");
+}
+/**
+* Get all font families from the theme for preloading
+*
+* @param theme - Parsed theme
+* @returns Array of unique font family names
+*/
+function getThemeFonts(theme) {
+	const fonts = /* @__PURE__ */ new Set();
+	if (theme?.fontScheme) {
+		const { majorFont, minorFont } = theme.fontScheme;
+		if (majorFont?.latin) fonts.add(majorFont.latin);
+		if (majorFont?.ea) fonts.add(majorFont.ea);
+		if (majorFont?.cs) fonts.add(majorFont.cs);
+		if (minorFont?.latin) fonts.add(minorFont.latin);
+		if (minorFont?.ea) fonts.add(minorFont.ea);
+		if (minorFont?.cs) fonts.add(minorFont.cs);
+		if (majorFont?.fonts) {
+			for (const font of Object.values(majorFont.fonts)) if (font) fonts.add(font);
+		}
+		if (minorFont?.fonts) {
+			for (const font of Object.values(minorFont.fonts)) if (font) fonts.add(font);
+		}
+	}
+	fonts.delete("");
+	return Array.from(fonts);
+}
+/**
+* Get the default theme (Office 2016 theme)
+*
+* @returns Default Theme object
+*/
+function getDefaultTheme() {
+	return { ...DEFAULT_THEME };
+}
+//#endregion
+export { applyThemeFontLang, getDefaultTheme, getMajorFont, getMinorFont, getThemeColor, getThemeFonts, parseTheme, resolveThemeFontRef };

package/dist/docx/trackedMoveRangeNormalization.d.ts

@@ -0,0 +1,22 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/trackedMoveRangeNormalization.d.ts
+type NormalizeTrackedMoveRangesInput = {
+  documentBody: document_d_exports.DocumentBody;
+  headers?: Map<string, document_d_exports.HeaderFooter>;
+  footers?: Map<string, document_d_exports.HeaderFooter>;
+  footnotes?: readonly document_d_exports.Footnote[];
+  endnotes?: readonly document_d_exports.Endnote[];
+};
+type NormalizeTrackedMoveRangesResult = {
+  removedUnbalancedMoveRangeMarkers: number;
+};
+declare const normalizeTrackedMoveRanges: ({
+  documentBody,
+  headers,
+  footers,
+  footnotes,
+  endnotes
+}: NormalizeTrackedMoveRangesInput) => NormalizeTrackedMoveRangesResult;
+//#endregion
+export { normalizeTrackedMoveRanges };

package/dist/docx/trackedMoveRangeNormalization.js

@@ -0,0 +1,100 @@
+import { visitDocxParagraphs } from "./paragraphTraversal.js";
+//#region src/docx/trackedMoveRangeNormalization.ts
+const normalizeTrackedMoveRanges = ({ documentBody, headers, footers, footnotes, endnotes }) => {
+	const rangeMarkers = [];
+	visitDocxParagraphs({
+		documentBody,
+		headers,
+		footers,
+		footnotes,
+		endnotes
+	}, (paragraph) => {
+		for (const [index, content] of paragraph.content.entries()) {
+			const marker = toMoveRangeMarkerRef(paragraph.content, index, content);
+			if (marker) rangeMarkers.push(marker);
+		}
+	});
+	return { removedUnbalancedMoveRangeMarkers: removeUnbalancedMoveRangeMarkers(rangeMarkers) };
+};
+const removeUnbalancedMoveRangeMarkers = (rangeMarkers) => {
+	const byRange = /* @__PURE__ */ new Map();
+	for (const marker of rangeMarkers) {
+		const key = `${marker.kind}:${marker.id}`;
+		const markers = byRange.get(key);
+		if (markers) {
+			markers.push(marker);
+			continue;
+		}
+		byRange.set(key, [marker]);
+	}
+	const removals = /* @__PURE__ */ new Map();
+	const markForRemoval = (marker) => {
+		const indexes = removals.get(marker.content);
+		if (indexes) {
+			indexes.add(marker.index);
+			return;
+		}
+		removals.set(marker.content, /* @__PURE__ */ new Set([marker.index]));
+	};
+	for (const markers of byRange.values()) {
+		let openStart = null;
+		for (const marker of markers) {
+			if (marker.side === "start") {
+				if (openStart) {
+					markForRemoval(marker);
+					continue;
+				}
+				openStart = marker;
+				continue;
+			}
+			if (!openStart) {
+				markForRemoval(marker);
+				continue;
+			}
+			openStart = null;
+		}
+		if (openStart) markForRemoval(openStart);
+	}
+	let removedCount = 0;
+	for (const [content, indexes] of removals.entries()) {
+		if (indexes.size === 0) continue;
+		const nextContent = content.filter((_, index) => !indexes.has(index));
+		removedCount += content.length - nextContent.length;
+		content.length = 0;
+		content.push(...nextContent);
+	}
+	return removedCount;
+};
+const toMoveRangeMarkerRef = (content, index, marker) => {
+	if (marker.type === "moveFromRangeStart") return {
+		content,
+		index,
+		id: marker.id,
+		kind: "moveFrom",
+		side: "start"
+	};
+	if (marker.type === "moveFromRangeEnd") return {
+		content,
+		index,
+		id: marker.id,
+		kind: "moveFrom",
+		side: "end"
+	};
+	if (marker.type === "moveToRangeStart") return {
+		content,
+		index,
+		id: marker.id,
+		kind: "moveTo",
+		side: "start"
+	};
+	if (marker.type === "moveToRangeEnd") return {
+		content,
+		index,
+		id: marker.id,
+		kind: "moveTo",
+		side: "end"
+	};
+	return null;
+};
+//#endregion
+export { normalizeTrackedMoveRanges };

package/dist/docx/unzip.d.ts

@@ -0,0 +1,118 @@
+import JSZip from "jszip";
+
+//#region src/docx/unzip.d.ts
+declare class DocxSecurityError extends Error {
+  constructor(message: string);
+}
+type DocxUnzipLimits = {
+  maxInputBytes: number;
+  maxFiles: number;
+  maxXmlBytes: number;
+  maxMediaBytes: number;
+  maxFontBytes: number;
+  maxTotalUncompressedBytes: number;
+  allowedMediaMimeTypes: ReadonlySet<string>;
+};
+type PartialDocxUnzipLimits = Partial<Omit<DocxUnzipLimits, "allowedMediaMimeTypes">> & {
+  allowedMediaMimeTypes?: Iterable<string>;
+};
+/**
+ * Raw extracted content from a DOCX file
+ */
+type RawDocxContent = {
+  documentXml: string | null;
+  stylesXml: string | null;
+  themeXml: string | null;
+  numberingXml: string | null;
+  fontTableXml: string | null;
+  settingsXml: string | null;
+  webSettingsXml: string | null;
+  headers: Map<string, string>;
+  footers: Map<string, string>;
+  footnotesXml: string | null;
+  endnotesXml: string | null;
+  commentsXml: string | null;
+  commentsExtensibleXml: string | null;
+  commentsExtendedXml: string | null;
+  documentRels: string | null;
+  packageRels: string | null;
+  contentTypesXml: string | null;
+  corePropsXml: string | null;
+  appPropsXml: string | null;
+  customPropsXml: string | null;
+  media: Map<string, ArrayBuffer>;
+  fonts: Map<string, ArrayBuffer>;
+  allXml: Map<string, string>;
+  originalZip: JSZip;
+  originalBuffer: ArrayBuffer;
+  warnings: string[];
+};
+/**
+ * Extract all content from a DOCX file
+ *
+ * @param buffer - DOCX file as ArrayBuffer
+ * @returns Promise resolving to extracted content
+ */
+declare function unzipDocx(buffer: ArrayBuffer, options?: PartialDocxUnzipLimits): Promise<RawDocxContent>;
+declare function isPreservableDocxEntry(path: string): boolean;
+/**
+ * Get a list of all files in the DOCX
+ *
+ * @param content - Extracted DOCX content
+ * @returns Array of file paths
+ */
+declare function getFileList(content: RawDocxContent): string[];
+/**
+ * Get the MIME type for a media file based on extension
+ *
+ * @param path - File path
+ * @returns MIME type string
+ */
+declare function getMediaMimeType(path: string): string;
+/**
+ * Convert media file to data URL
+ *
+ * @param data - Binary data
+ * @param mimeType - MIME type
+ * @returns Data URL string
+ */
+declare function mediaToDataUrl(data: ArrayBuffer, mimeType: string): string;
+/**
+ * Extract a specific file from the original ZIP
+ *
+ * @param content - Extracted DOCX content
+ * @param path - File path within the ZIP
+ * @returns File content as string or ArrayBuffer, or null if not found
+ */
+declare function extractFile(content: RawDocxContent, path: string): Promise<string | ArrayBuffer | null>;
+/**
+ * Check if a file exists in the DOCX
+ *
+ * @param content - Extracted DOCX content
+ * @param path - File path to check
+ * @returns true if file exists
+ */
+declare function hasFile(content: RawDocxContent, path: string): boolean;
+/**
+ * Get summary of DOCX content
+ *
+ * @param content - Extracted DOCX content
+ * @returns Object with file counts and presence flags
+ */
+declare function getContentSummary(content: RawDocxContent): {
+  hasDocument: boolean;
+  hasStyles: boolean;
+  hasTheme: boolean;
+  hasNumbering: boolean;
+  hasFontTable: boolean;
+  hasFootnotes: boolean;
+  hasEndnotes: boolean;
+  hasComments: boolean;
+  headerCount: number;
+  footerCount: number;
+  mediaCount: number;
+  fontCount: number;
+  totalFiles: number;
+};
+//#endregion
+export { DocxSecurityError, DocxUnzipLimits, RawDocxContent, extractFile, getContentSummary, getFileList, getMediaMimeType, hasFile, isPreservableDocxEntry, mediaToDataUrl, unzipDocx };