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

package/dist/utils/rotationBoundingBox.d.ts

@@ -0,0 +1,12 @@
+import { ImageRun } from "../layout-engine/types.js";
+
+//#region src/utils/rotationBoundingBox.d.ts
+type BoundingBox = {
+  width: number;
+  height: number;
+};
+declare function parseRotationDegrees(transform: string | undefined): number;
+declare function rotatedBoundingBox(w: number, h: number, deg: number): BoundingBox;
+declare function inlineImageBoundingBox(run: ImageRun): BoundingBox;
+//#endregion
+export { BoundingBox, inlineImageBoundingBox, parseRotationDegrees, rotatedBoundingBox };

package/dist/utils/rotationBoundingBox.js

@@ -0,0 +1,36 @@
+//#region src/utils/rotationBoundingBox.ts
+function parseRotationDegrees(transform) {
+	if (!transform) return 0;
+	const match = /rotate\(\s*(?<degrees>[-\d.]+)\s*deg\s*\)/iu.exec(transform);
+	if (!match) return 0;
+	const raw = Number.parseFloat(match.groups["degrees"]);
+	if (!Number.isFinite(raw)) return 0;
+	return (raw % 360 + 360) % 360;
+}
+function rotatedBoundingBox(w, h, deg) {
+	if (deg === 0 || deg === 180) return {
+		width: w,
+		height: h
+	};
+	if (deg === 90 || deg === 270) return {
+		width: h,
+		height: w
+	};
+	const rad = deg * Math.PI / 180;
+	const sinA = Math.abs(Math.sin(rad));
+	const cosA = Math.abs(Math.cos(rad));
+	return {
+		width: w * cosA + h * sinA,
+		height: w * sinA + h * cosA
+	};
+}
+function inlineImageBoundingBox(run) {
+	const rotation = parseRotationDegrees(run.transform);
+	if (rotation === 0) return {
+		width: run.width,
+		height: run.height
+	};
+	return rotatedBoundingBox(run.width, run.height, rotation);
+}
+//#endregion
+export { inlineImageBoundingBox, parseRotationDegrees, rotatedBoundingBox };

package/dist/utils/scriptSegments.d.ts

@@ -0,0 +1,36 @@
+//#region src/utils/scriptSegments.d.ts
+/**
+ * Script segmentation for per-character East-Asian font selection.
+ *
+ * Word resolves a run's font per character: East-Asian (CJK) code points use
+ * the run's `w:eastAsia` font slot, everything else uses `w:ascii`/`w:hAnsi`.
+ * folio mirrors this by splitting a run's text into maximal same-script
+ * segments that the measurer and the painter both consume, so line wrapping
+ * stays in sync with rendering.
+ *
+ * Ranges are authored with `\u` escapes only — never pasted glyphs (a pasted
+ * glyph once silently corrupted an RTL character class here).
+ */
+type ScriptSegment = {
+  text: string;
+  isCjk: boolean;
+};
+/**
+ * True when a code point belongs to an East-Asian script that Word renders with
+ * the `w:eastAsia` font slot: CJK ideographs, kana, Hangul, CJK symbols and
+ * punctuation, and fullwidth/halfwidth forms.
+ */
+declare function isCjkCodePoint(cp: number): boolean;
+/**
+ * True when the text contains at least one East-Asian code point. Callers use
+ * this to skip segmentation entirely on the common all-Latin path.
+ */
+declare function hasCjk(text: string): boolean;
+/**
+ * Split text into maximal runs of one script class (CJK vs. non-CJK). Iterates
+ * by code point so astral ideographs (surrogate pairs) are never split between
+ * fonts. Empty input yields no segments; single-class input yields one.
+ */
+declare function segmentByScript(text: string): ScriptSegment[];
+//#endregion
+export { ScriptSegment, hasCjk, isCjkCodePoint, segmentByScript };

package/dist/utils/scriptSegments.js

@@ -0,0 +1,52 @@
+//#region src/utils/scriptSegments.ts
+/**
+* True when a code point belongs to an East-Asian script that Word renders with
+* the `w:eastAsia` font slot: CJK ideographs, kana, Hangul, CJK symbols and
+* punctuation, and fullwidth/halfwidth forms.
+*/
+function isCjkCodePoint(cp) {
+	return cp >= 11904 && cp <= 12287 || cp >= 12288 && cp <= 13311 || cp >= 13312 && cp <= 19903 || cp >= 19968 && cp <= 40959 || cp >= 43360 && cp <= 43391 || cp >= 44032 && cp <= 55295 || cp >= 4352 && cp <= 4607 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65519 || cp >= 131072 && cp <= 262143;
+}
+/**
+* True when the text contains at least one East-Asian code point. Callers use
+* this to skip segmentation entirely on the common all-Latin path.
+*/
+function hasCjk(text) {
+	for (const ch of text) if (isCjkCodePoint(ch.codePointAt(0))) return true;
+	return false;
+}
+/**
+* Split text into maximal runs of one script class (CJK vs. non-CJK). Iterates
+* by code point so astral ideographs (surrogate pairs) are never split between
+* fonts. Empty input yields no segments; single-class input yields one.
+*/
+function segmentByScript(text) {
+	const segments = [];
+	let current = "";
+	let currentIsCjk = false;
+	for (const ch of text) {
+		const cjk = isCjkCodePoint(ch.codePointAt(0));
+		if (current.length === 0) {
+			current = ch;
+			currentIsCjk = cjk;
+			continue;
+		}
+		if (cjk === currentIsCjk) {
+			current += ch;
+			continue;
+		}
+		segments.push({
+			text: current,
+			isCjk: currentIsCjk
+		});
+		current = ch;
+		currentIsCjk = cjk;
+	}
+	if (current.length > 0) segments.push({
+		text: current,
+		isCjk: currentIsCjk
+	});
+	return segments;
+}
+//#endregion
+export { hasCjk, isCjkCodePoint, segmentByScript };

package/dist/utils/tableOperations.d.ts

@@ -0,0 +1,87 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/utils/tableOperations.d.ts
+type TableAction = "addRowAbove" | "addRowBelow" | "addColumnLeft" | "addColumnRight" | "deleteRow" | "deleteColumn" | "mergeCells" | "splitCell" | "deleteTable" | "selectTable" | "selectRow" | "selectColumn" | "borderAll" | "borderOutside" | "borderInside" | "borderNone" | "borderTop" | "borderBottom" | "borderLeft" | "borderRight" | {
+  type: "cellFillColor";
+  color: string | null;
+} | {
+  type: "borderColor";
+  color: string;
+} | {
+  type: "borderWidth";
+  size: number;
+} | {
+  type: "cellBorder";
+  side: "top" | "bottom" | "left" | "right" | "all";
+  style: string;
+  size: number;
+  color: string;
+} | {
+  type: "cellVerticalAlign";
+  align: "top" | "center" | "bottom";
+} | {
+  type: "cellMargins";
+  margins: {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+  };
+} | {
+  type: "cellTextDirection";
+  direction: string | null;
+} | {
+  type: "toggleNoWrap";
+} | {
+  type: "rowHeight";
+  height: number | null;
+  rule?: "auto" | "atLeast" | "exact";
+} | {
+  type: "toggleHeaderRow";
+} | {
+  type: "distributeColumns";
+} | {
+  type: "autoFitContents";
+} | {
+  type: "tableProperties";
+  props: {
+    width?: number | null;
+    widthType?: string | null;
+    justification?: "left" | "center" | "right" | null;
+  };
+} | {
+  type: "openTableProperties";
+} | {
+  type: "applyTableStyle";
+  styleId: string;
+};
+type TableSelection = {
+  tableIndex: number;
+  rowIndex: number;
+  columnIndex: number;
+  selectedCells?: {
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+  };
+};
+type TableContext = {
+  table: document_d_exports.Table;
+  selection: TableSelection;
+  hasMultiCellSelection: boolean;
+  canSplitCell: boolean;
+  rowCount: number;
+  columnCount: number;
+};
+declare const getColumnCount: (table: document_d_exports.Table) => number;
+declare const getCellAt: (table: document_d_exports.Table, rowIndex: number, columnIndex: number) => document_d_exports.TableCell | null;
+declare const createTableContext: (table: document_d_exports.Table, selection: TableSelection) => TableContext;
+declare const addRow: (table: document_d_exports.Table, atIndex: number, position?: "before" | "after") => document_d_exports.Table;
+declare const deleteRow: (table: document_d_exports.Table, rowIndex: number) => document_d_exports.Table;
+declare const addColumn: (table: document_d_exports.Table, atIndex: number, position?: "before" | "after") => document_d_exports.Table;
+declare const deleteColumn: (table: document_d_exports.Table, columnIndex: number) => document_d_exports.Table;
+declare const mergeCells: (table: document_d_exports.Table, selection: TableSelection) => document_d_exports.Table;
+declare const splitCell: (table: document_d_exports.Table, rowIndex: number, columnIndex: number) => document_d_exports.Table;
+//#endregion
+export { TableAction, TableContext, TableSelection, addColumn, addRow, createTableContext, deleteColumn, deleteRow, getCellAt, getColumnCount, mergeCells, splitCell };

package/dist/utils/tableOperations.js

@@ -0,0 +1,259 @@
+//#region src/utils/tableOperations.ts
+const getColumnCount = (table) => {
+	let maxCols = 0;
+	for (const row of table.rows) {
+		let colCount = 0;
+		for (const cell of row.cells) colCount += cell.formatting?.gridSpan ?? 1;
+		maxCols = Math.max(maxCols, colCount);
+	}
+	return maxCols;
+};
+const getCellAt = (table, rowIndex, columnIndex) => {
+	const row = table.rows[rowIndex];
+	if (!row) return null;
+	let currentCol = 0;
+	for (const cell of row.cells) {
+		const colspan = cell.formatting?.gridSpan ?? 1;
+		if (columnIndex >= currentCol && columnIndex < currentCol + colspan) return cell;
+		currentCol += colspan;
+	}
+	return null;
+};
+const createTableContext = (table, selection) => {
+	const rowCount = table.rows.length;
+	const columnCount = getColumnCount(table);
+	const hasMultiCellSelection = !!(selection.selectedCells && (selection.selectedCells.startRow !== selection.selectedCells.endRow || selection.selectedCells.startCol !== selection.selectedCells.endCol));
+	const currentCell = getCellAt(table, selection.rowIndex, selection.columnIndex);
+	return {
+		table,
+		selection,
+		hasMultiCellSelection,
+		canSplitCell: !!(currentCell && ((currentCell.formatting?.gridSpan ?? 1) > 1 || currentCell.formatting?.vMerge === "restart")),
+		rowCount,
+		columnCount
+	};
+};
+const createEmptyCell = () => ({
+	type: "tableCell",
+	content: [{
+		type: "paragraph",
+		content: [],
+		formatting: {}
+	}],
+	formatting: {}
+});
+const createEmptyRow = (templateRow, columnCount) => {
+	const cells = [];
+	let colIndex = 0;
+	for (const templateCell of templateRow.cells) {
+		cells.push({
+			type: "tableCell",
+			content: [{
+				type: "paragraph",
+				content: [],
+				formatting: {}
+			}],
+			formatting: (() => {
+				if (!templateCell.formatting) return {};
+				const { vMerge: _vm, ...rest } = templateCell.formatting;
+				return rest;
+			})()
+		});
+		colIndex += templateCell.formatting?.gridSpan ?? 1;
+	}
+	while (colIndex < columnCount) {
+		cells.push(createEmptyCell());
+		colIndex++;
+	}
+	return {
+		type: "tableRow",
+		cells,
+		formatting: {
+			...templateRow.formatting,
+			header: false
+		}
+	};
+};
+const addRow = (table, atIndex, position = "after") => {
+	const newRows = [...table.rows];
+	const insertIndex = position === "before" ? atIndex : atIndex + 1;
+	const templateRow = table.rows[atIndex] ?? table.rows[0];
+	if (!templateRow) return table;
+	newRows.splice(insertIndex, 0, createEmptyRow(templateRow, getColumnCount(table)));
+	return {
+		...table,
+		rows: newRows
+	};
+};
+const deleteRow = (table, rowIndex) => {
+	if (table.rows.length <= 1) return table;
+	return {
+		...table,
+		rows: table.rows.filter((_, i) => i !== rowIndex)
+	};
+};
+const addColumn = (table, atIndex, position = "after") => {
+	const insertIndex = position === "before" ? atIndex : atIndex + 1;
+	const newRows = table.rows.map((row) => {
+		const newCells = [...row.cells];
+		let currentCol = 0;
+		let insertCellIndex = 0;
+		for (let i = 0; i < row.cells.length; i++) {
+			const colspan = row.cells[i]?.formatting?.gridSpan ?? 1;
+			if (insertIndex <= currentCol + colspan) {
+				insertCellIndex = position === "before" ? i : i + 1;
+				break;
+			}
+			currentCol += colspan;
+			insertCellIndex = i + 1;
+		}
+		newCells.splice(insertCellIndex, 0, createEmptyCell());
+		return {
+			...row,
+			cells: newCells
+		};
+	});
+	let newColumnWidths = table.columnWidths;
+	if (table.columnWidths && table.columnWidths.length > 0) {
+		newColumnWidths = [...table.columnWidths];
+		const templateWidth = table.columnWidths[atIndex] ?? table.columnWidths[0] ?? 1440;
+		newColumnWidths.splice(insertIndex, 0, templateWidth);
+	}
+	return {
+		...table,
+		rows: newRows,
+		...newColumnWidths !== void 0 ? { columnWidths: newColumnWidths } : {}
+	};
+};
+const deleteColumn = (table, columnIndex) => {
+	if (getColumnCount(table) <= 1) return table;
+	const newRows = table.rows.map((row) => {
+		let currentCol = 0;
+		const newCells = [];
+		for (const cell of row.cells) {
+			const colspan = cell.formatting?.gridSpan ?? 1;
+			if (columnIndex >= currentCol && columnIndex < currentCol + colspan) {
+				if (colspan > 1) newCells.push({
+					...cell,
+					formatting: {
+						...cell.formatting,
+						gridSpan: colspan - 1
+					}
+				});
+			} else newCells.push(cell);
+			currentCol += colspan;
+		}
+		return {
+			...row,
+			cells: newCells
+		};
+	});
+	let newColumnWidths = table.columnWidths;
+	if (table.columnWidths && table.columnWidths.length > columnIndex) newColumnWidths = table.columnWidths.filter((_, i) => i !== columnIndex);
+	return {
+		...table,
+		rows: newRows,
+		...newColumnWidths !== void 0 ? { columnWidths: newColumnWidths } : {}
+	};
+};
+const mergeCells = (table, selection) => {
+	if (!selection.selectedCells) return table;
+	const { startRow, startCol, endRow, endCol } = selection.selectedCells;
+	const rowSpan = endRow - startRow + 1;
+	const colSpan = endCol - startCol + 1;
+	const newRows = table.rows.map((row, rowIndex) => {
+		if (rowIndex < startRow || rowIndex > endRow) return row;
+		const newCells = [];
+		let currentCol = 0;
+		for (const cell of row.cells) {
+			const cellColSpan = cell.formatting?.gridSpan ?? 1;
+			const cellEndCol = currentCol + cellColSpan - 1;
+			if (!(currentCol <= endCol && cellEndCol >= startCol)) newCells.push(cell);
+			else if (rowIndex === startRow && currentCol === startCol) newCells.push({
+				...cell,
+				formatting: {
+					...cell.formatting,
+					gridSpan: colSpan,
+					...rowSpan > 1 ? { vMerge: "restart" } : {}
+				}
+			});
+			else if (rowIndex > startRow && currentCol === startCol) newCells.push({
+				...cell,
+				formatting: {
+					...cell.formatting,
+					gridSpan: colSpan,
+					vMerge: "continue"
+				}
+			});
+			currentCol += cellColSpan;
+		}
+		return {
+			...row,
+			cells: newCells
+		};
+	});
+	return {
+		...table,
+		rows: newRows
+	};
+};
+const splitCell = (table, rowIndex, columnIndex) => {
+	const cell = getCellAt(table, rowIndex, columnIndex);
+	if (!cell) return table;
+	const gridSpan = cell.formatting?.gridSpan ?? 1;
+	const isVMergeStart = cell.formatting?.vMerge === "restart";
+	if (gridSpan <= 1 && !isVMergeStart) return table;
+	const newRows = table.rows.map((row, rIndex) => {
+		if (rIndex !== rowIndex && !isVMergeStart) return row;
+		const newCells = [];
+		let currentCol = 0;
+		for (const rowCell of row.cells) {
+			const cellColSpan = rowCell.formatting?.gridSpan ?? 1;
+			if (currentCol === columnIndex || currentCol <= columnIndex && columnIndex < currentCol + cellColSpan) if (gridSpan > 1) for (let i = 0; i < gridSpan; i++) newCells.push({
+				type: "tableCell",
+				content: i === 0 ? rowCell.content : [{
+					type: "paragraph",
+					content: [],
+					formatting: {}
+				}],
+				formatting: (() => {
+					if (!rowCell.formatting) return {};
+					const { gridSpan: _gs, vMerge: _vm, ...rest } = rowCell.formatting;
+					return rest;
+				})()
+			});
+			else if (isVMergeStart && rIndex === rowIndex) newCells.push({
+				...rowCell,
+				formatting: (() => {
+					if (!rowCell.formatting) return {};
+					const { vMerge: _vm, ...rest } = rowCell.formatting;
+					return rest;
+				})()
+			});
+			else if (rowCell.formatting?.vMerge === "continue") {
+				const { vMerge: _vm, ...restFormatting } = rowCell.formatting;
+				newCells.push({
+					type: "tableCell",
+					content: [{
+						type: "paragraph",
+						content: [],
+						formatting: {}
+					}],
+					formatting: restFormatting
+				});
+			} else newCells.push(rowCell);
+			else newCells.push(rowCell);
+			currentCol += cellColSpan;
+		}
+		return {
+			...row,
+			cells: newCells
+		};
+	});
+	return {
+		...table,
+		rows: newRows
+	};
+};
+//#endregion
+export { addColumn, addRow, createTableContext, deleteColumn, deleteRow, getCellAt, getColumnCount, mergeCells, splitCell };

package/dist/utils/textFormattingMerge.d.ts

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/utils/textFormattingMerge.d.ts
+declare function mergeTextFormatting(target: document_d_exports.TextFormatting | undefined, source: document_d_exports.TextFormatting | undefined): document_d_exports.TextFormatting | undefined;
+//#endregion
+export { mergeTextFormatting };

package/dist/utils/textFormattingMerge.js

@@ -0,0 +1,31 @@
+import { mergeFontFamily } from "./fontFamilyMerge.js";
+//#region src/utils/textFormattingMerge.ts
+function mergeTextFormatting(target, source) {
+	if (!source && !target) return;
+	if (!source) return target;
+	if (!target) return { ...source };
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const value = source[key];
+		if (value === void 0) continue;
+		if (key === "fontFamily" && typeof value === "object") {
+			result["fontFamily"] = mergeFontFamily(target.fontFamily, value);
+			continue;
+		}
+		if (key === "color" && typeof value === "object") {
+			result["color"] = value;
+			continue;
+		}
+		if (typeof value === "object" && !Array.isArray(value)) {
+			result[key] = {
+				...target[key],
+				...value
+			};
+			continue;
+		}
+		result[key] = value;
+	}
+	return result;
+}
+//#endregion
+export { mergeTextFormatting };

package/dist/utils/tiffConverter.d.ts

@@ -0,0 +1,18 @@
+//#region src/utils/tiffConverter.d.ts
+/**
+ * TIFF to PNG Converter
+ *
+ * Browsers don't support TIFF in `<img>` tags, so DOCX-embedded TIFFs are
+ * decoded with utif2 and re-encoded as PNG via the Canvas API. Returns
+ * null in environments without Canvas (Node.js parsing); callers fall
+ * back to the raw TIFF data URL, which won't render in browsers but is
+ * fine for headless round-trips.
+ */
+declare function isTiffMimeType(mimeType: string): boolean;
+type ConvertedTiff = {
+  dataUrl: string;
+  data: ArrayBuffer;
+};
+declare function convertTiffToPngDataUrl(tiffData: ArrayBuffer): Promise<ConvertedTiff | null>;
+//#endregion
+export { ConvertedTiff, convertTiffToPngDataUrl, isTiffMimeType };

package/dist/utils/tiffConverter.js

@@ -0,0 +1,83 @@
+//#region src/utils/tiffConverter.ts
+/**
+* TIFF to PNG Converter
+*
+* Browsers don't support TIFF in `<img>` tags, so DOCX-embedded TIFFs are
+* decoded with utif2 and re-encoded as PNG via the Canvas API. Returns
+* null in environments without Canvas (Node.js parsing); callers fall
+* back to the raw TIFF data URL, which won't render in browsers but is
+* fine for headless round-trips.
+*/
+/**
+* Hard cap on the pixel count we'll attempt to decode. Each pixel costs 4 B
+* for the intermediate RGBA buffer plus another canvas-managed bitmap, so
+* 64 MP ≈ 256 MB before counting the PNG re-encode. A crafted TIFF whose
+* declared dimensions exceed this is rejected without allocating the
+* RGBA buffer, which would otherwise hang or OOM the tab.
+*/
+const MAX_TIFF_PIXELS = 64e6;
+function isTiffMimeType(mimeType) {
+	const lower = mimeType.toLowerCase();
+	return lower === "image/tiff" || lower === "image/tif";
+}
+async function convertTiffToPngDataUrl(tiffData) {
+	if (typeof document === "undefined" || typeof document.createElement !== "function") return null;
+	try {
+		const UTIF = await import("utif2");
+		const firstImage = UTIF.decode(tiffData)[0];
+		if (!firstImage) return null;
+		const declaredWidth = readTiffTagNumber(firstImage["t256"]);
+		const declaredHeight = readTiffTagNumber(firstImage["t257"]);
+		if (!declaredWidth || !declaredHeight) return null;
+		if (declaredWidth * declaredHeight > MAX_TIFF_PIXELS) return null;
+		UTIF.decodeImage(tiffData, firstImage);
+		const rgba = UTIF.toRGBA8(firstImage);
+		if (rgba.length === 0) return null;
+		const width = firstImage.width;
+		const height = firstImage.height;
+		if (!width || !height) return null;
+		const canvas = document.createElement("canvas");
+		canvas.width = width;
+		canvas.height = height;
+		const ctx = canvas.getContext("2d");
+		if (!ctx) return null;
+		const clamped = new Uint8ClampedArray(rgba.length);
+		clamped.set(rgba);
+		const imageData = new ImageData(clamped, width, height);
+		ctx.putImageData(imageData, 0, 0);
+		const dataUrl = canvas.toDataURL("image/png");
+		const data = dataUrlToArrayBuffer(dataUrl);
+		if (!data) return null;
+		return {
+			dataUrl,
+			data
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Read a numeric TIFF tag value. utif2 stores tag values as arrays
+* (typed or plain), so the cap-check helpers only need the first element.
+*/
+function readTiffTagNumber(tag) {
+	if (typeof tag === "number") return tag;
+	if (Array.isArray(tag) || tag instanceof Uint8Array || tag instanceof Uint16Array || tag instanceof Uint32Array) {
+		const first = tag[0];
+		if (typeof first === "number") return first;
+	}
+}
+function dataUrlToArrayBuffer(dataUrl) {
+	const base64 = dataUrl.split(",", 2)[1];
+	if (!base64) return null;
+	try {
+		const binary = atob(base64);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.codePointAt(i) ?? 0;
+		return bytes.buffer;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { convertTiffToPngDataUrl, isTiffMimeType };