documents.js 1.57.1 → 1.58.0

package/dist/layout/slides.js

@@ -0,0 +1,192 @@
+import { flipY } from "../model/geometry.js";
+import { layoutFormula } from "../mathml/layout.js";
+import { alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, lineNaturalHeightPt, registerImage, sumColumnWidthsPt } from "./shared.js";
+import { COLOR_BLACK, LAYOUT_FORMAT_VERSION } from "document-schema.js";
+import { loadMathFont, rotatePointAboutCenter, wrapRunsToWidth } from "pdf-codec";
+//#region src/layout/slides.ts
+const MIN_FORMULA_SIZE_PT = 8;
+function formulaSizePtFromFrame(frameHeightPt) {
+	return Math.max(MIN_FORMULA_SIZE_PT, frameHeightPt / 2);
+}
+function shapePlacement(flippedFrame, rotationDeg) {
+	if (rotationDeg === void 0 || rotationDeg === 0) return {
+		place: (p) => p,
+		layoutRotationDeg: void 0
+	};
+	const ccwDeg = -rotationDeg;
+	const center = {
+		x: flippedFrame.xPt + flippedFrame.widthPt / 2,
+		y: flippedFrame.yPt + flippedFrame.heightPt / 2
+	};
+	return {
+		place: (p) => rotatePointAboutCenter(p, center, ccwDeg),
+		layoutRotationDeg: ccwDeg
+	};
+}
+function layoutParagraph(paragraph, contentLeftXDown, contentWidthPt, startYDown, slideHeightPt, placement, fontScale, spacingScale, measurer, out) {
+	let cursorYDown = startYDown + (paragraph.spacingBeforePt ?? 0);
+	const effectiveRuns = effectiveStyledRuns(paragraph.runs, fontScale);
+	const fallbackRun = effectiveRuns[0];
+	const paragraphLeftXDown = contentLeftXDown + (paragraph.indentLeftPt ?? 0);
+	const paragraphWidthPt = Math.max(0, contentWidthPt - (paragraph.indentLeftPt ?? 0));
+	wrapRunsToWidth(effectiveRuns, measurer, paragraphWidthPt).forEach((line, lineIndex) => {
+		const scaledLineHeightPt = lineNaturalHeightPt(line, measurer, fallbackRun) * (paragraph.lineSpacing ?? 1) * spacingScale;
+		const baselineYDown = cursorYDown + line.ascentPt;
+		const firstLineIndentPt = lineIndex === 0 ? paragraph.indentFirstLinePt ?? 0 : 0;
+		const alignOffsetPt = alignmentOffsetPt(paragraph.alignment, paragraphWidthPt, line.widthPt);
+		for (const fragment of line.fragments) {
+			const unrotated = {
+				x: paragraphLeftXDown + firstLineIndentPt + alignOffsetPt + fragment.xOffsetPt,
+				y: slideHeightPt - baselineYDown
+			};
+			const placed = placement.place(unrotated);
+			const textItem = {
+				kind: "text",
+				text: fragment.text,
+				xPt: placed.x,
+				yPt: placed.y,
+				font: fragment.font,
+				sizePt: fragment.sizePt,
+				color: fragment.color,
+				underline: fragment.underline,
+				rotationDeg: placement.layoutRotationDeg,
+				sourcePath: fragment.sourcePath
+			};
+			out.push(textItem);
+			if (fragment.hyperlink !== void 0) {
+				const fragmentWidthPt = measurer.widthOfTextAtSize(fragment.text, fragment.font, fragment.sizePt);
+				const linkBottomLeft = placement.place({
+					x: unrotated.x,
+					y: unrotated.y + line.descentPt
+				});
+				const link = {
+					kind: "link",
+					uri: fragment.hyperlink,
+					xPt: linkBottomLeft.x,
+					yPt: linkBottomLeft.y,
+					widthPt: fragmentWidthPt,
+					heightPt: line.ascentPt - line.descentPt,
+					sourcePath: fragment.sourcePath
+				};
+				out.push(link);
+			}
+		}
+		cursorYDown += scaledLineHeightPt;
+	});
+	cursorYDown += paragraph.spacingAfterPt ?? 0;
+	return cursorYDown;
+}
+function layoutTable(table, contentLeftXDown, contentWidthPt, startYDown, slideHeightPt, placement, measurer, out) {
+	let cursorYDown = startYDown;
+	const gridWidthPt = table.columnWidthsPt.reduce((sum, w) => sum + w, 0);
+	const scale = gridWidthPt > 0 ? contentWidthPt / gridWidthPt : 1;
+	for (const row of table.rows) {
+		const rowHeightPt = row.heightPt ?? estimateRowHeightPt(row, measurer, table.columnWidthsPt, scale);
+		let cellXDown = contentLeftXDown;
+		let colIndex = 0;
+		for (const cell of row.cells) {
+			const span = cell.colSpan ?? 1;
+			const cellWidthPt = sumColumnWidthsPt(table.columnWidthsPt, colIndex, span) * scale;
+			if (cell.background !== void 0 && placement.layoutRotationDeg === void 0) {
+				const cellFrame = flipY({
+					xPt: cellXDown,
+					yPt: cursorYDown,
+					widthPt: cellWidthPt,
+					heightPt: rowHeightPt
+				}, slideHeightPt);
+				out.push({
+					kind: "rect",
+					xPt: cellFrame.xPt,
+					yPt: cellFrame.yPt,
+					widthPt: cellFrame.widthPt,
+					heightPt: cellFrame.heightPt,
+					fill: cell.background,
+					sourcePath: table.sourcePath
+				});
+			}
+			let cellCursorYDown = cursorYDown;
+			for (const block of cell.blocks) if (block.kind === "paragraph") cellCursorYDown = layoutParagraph(block, cellXDown, cellWidthPt, cellCursorYDown, slideHeightPt, placement, 1, 1, measurer, out);
+			cellXDown += cellWidthPt;
+			colIndex += span;
+		}
+		cursorYDown += rowHeightPt;
+	}
+	return cursorYDown;
+}
+function layoutShapeFormula(block, flippedFrame, formulaContext) {
+	const embedded = block.sourcePath === void 0 ? void 0 : formulaContext.formulas.get(block.sourcePath);
+	if (embedded === void 0) return;
+	const sizePt = formulaSizePtFromFrame(block.frame.heightPt);
+	const metrics = loadMathFont().metricsAt(sizePt);
+	const { box } = layoutFormula(embedded.mathml, {
+		metrics,
+		sizePt,
+		color: COLOR_BLACK
+	});
+	formulaContext.positioned.push({
+		pageIndex: formulaContext.pageIndex,
+		xPt: flippedFrame.xPt,
+		yPt: flippedFrame.yPt,
+		box
+	});
+}
+function convertShape(shape, slideHeightPt, measurer, images, out, formulaContext) {
+	const flippedFrame = flipY(shape.frame, slideHeightPt);
+	const placement = shapePlacement(flippedFrame, shape.rotationDeg);
+	const contentLeftXDown = shape.frame.xPt + shape.insetLeftPt;
+	const contentWidthPt = Math.max(0, shape.frame.widthPt - shape.insetLeftPt - shape.insetRightPt);
+	const fontScale = shape.fontScale ?? 1;
+	const spacingScale = 1 - (shape.lineSpacingReduction ?? 0);
+	let cursorYDown = shape.frame.yPt + shape.insetTopPt;
+	for (const block of shape.blocks) if (block.kind === "paragraph") cursorYDown = layoutParagraph(block, contentLeftXDown, contentWidthPt, cursorYDown, slideHeightPt, placement, fontScale, spacingScale, measurer, out);
+	else if (block.kind === "image") {
+		const imageId = registerImage(block, images);
+		const placed = placement.place({
+			x: flippedFrame.xPt,
+			y: flippedFrame.yPt
+		});
+		const imageItem = {
+			kind: "image",
+			imageId,
+			xPt: placed.x,
+			yPt: placed.y,
+			widthPt: flippedFrame.widthPt,
+			heightPt: flippedFrame.heightPt,
+			rotationDeg: placement.layoutRotationDeg,
+			sourcePath: block.sourcePath
+		};
+		out.push(imageItem);
+	} else if (block.kind === "table") cursorYDown = layoutTable(block, contentLeftXDown, contentWidthPt, cursorYDown, slideHeightPt, placement, measurer, out);
+	else if (block.kind === "embeddedObject" && block.objectKind === "formula" && formulaContext !== void 0) layoutShapeFormula(block, flippedFrame, formulaContext);
+}
+function convertSlide(slide, slideIndex, measurer, images, formulas, positioned) {
+	const items = [];
+	const formulaContext = formulas === void 0 ? void 0 : {
+		formulas,
+		pageIndex: slideIndex,
+		positioned
+	};
+	for (const shape of slide.shapes) convertShape(shape, slide.size.heightPt, measurer, images, items, formulaContext);
+	return {
+		widthPt: slide.size.widthPt,
+		heightPt: slide.size.heightPt,
+		items,
+		...slide.notes.length > 0 ? { notes: slide.notes } : {}
+	};
+}
+function convertPresentationToLayout(doc, options) {
+	const images = {};
+	const formulas = [];
+	const pages = doc.slides.map((slide, slideIndex) => convertSlide(slide, slideIndex, options.measurer, images, options.formulas, formulas));
+	return {
+		document: {
+			formatVersion: LAYOUT_FORMAT_VERSION,
+			metadata: doc.metadata,
+			pages,
+			images
+		},
+		formulas
+	};
+}
+//#endregion
+export { convertPresentationToLayout, convertShape };

package/dist/list-BuBM9rwQ.d.cts

@@ -0,0 +1,24 @@
+import { n as ParagraphInit, t as OdtParagraph } from "./paragraph-BXbXKPy3.cjs";
+import { Package, XmlElement, XmlNode } from "odf.js";
+//#region src/edit/odt/list.d.ts
+declare class OdtListItem {
+  private readonly node;
+  private readonly pkg;
+  constructor(node: XmlElement, pkg: Package);
+  appendParagraph(init?: ParagraphInit): OdtParagraph;
+  addNestedList(): OdtList;
+}
+declare class OdtList {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode[], node: XmlElement, pkg: Package);
+  private live;
+  items(): OdtListItem[];
+  addItem(): OdtListItem;
+  remove(): void;
+}
+declare function buildList(pkg: Package): XmlElement;
+//#endregion
+export { OdtListItem as n, buildList as r, OdtList as t };

package/dist/list-CvKxhy3y.d.ts

@@ -0,0 +1,24 @@
+import { n as ParagraphInit, t as OdtParagraph } from "./paragraph-CoUi_88j.js";
+import { Package, XmlElement, XmlNode } from "odf.js";
+//#region src/edit/odt/list.d.ts
+declare class OdtListItem {
+  private readonly node;
+  private readonly pkg;
+  constructor(node: XmlElement, pkg: Package);
+  appendParagraph(init?: ParagraphInit): OdtParagraph;
+  addNestedList(): OdtList;
+}
+declare class OdtList {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode[], node: XmlElement, pkg: Package);
+  private live;
+  items(): OdtListItem[];
+  addItem(): OdtListItem;
+  remove(): void;
+}
+declare function buildList(pkg: Package): XmlElement;
+//#endregion
+export { OdtListItem as n, buildList as r, OdtList as t };

package/dist/mathml/compose.cjs

@@ -0,0 +1,53 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/mathml/compose.ts
+const EMPTY_BOX = {
+	widthPt: 0,
+	heightPt: 0,
+	ascentPt: 0,
+	descentPt: 0,
+	items: []
+};
+function shiftItems(items, dxPt, dyPt) {
+	if (dxPt === 0 && dyPt === 0) return [...items];
+	return items.map((item) => {
+		if (item.kind === "stroke") return {
+			...item,
+			points: item.points.map((p) => ({
+				xPt: p.xPt + dxPt,
+				yPt: p.yPt + dyPt
+			}))
+		};
+		return {
+			...item,
+			xPt: item.xPt + dxPt,
+			yPt: item.yPt + dyPt
+		};
+	});
+}
+function placeChild(child, dxPt, baselineOffsetPt, overallAscentPt) {
+	const dyPt = overallAscentPt + baselineOffsetPt - child.ascentPt;
+	return shiftItems(child.items, dxPt, dyPt);
+}
+function concatBoxesHorizontally(boxes, gapsPt = []) {
+	const ascentPt = boxes.reduce((max, b) => Math.max(max, b.ascentPt), 0);
+	const descentPt = boxes.reduce((max, b) => Math.max(max, b.descentPt), 0);
+	const items = [];
+	let cursorXPt = 0;
+	boxes.forEach((box, index) => {
+		cursorXPt += gapsPt[index] ?? 0;
+		items.push(...placeChild(box, cursorXPt, 0, ascentPt));
+		cursorXPt += box.widthPt;
+	});
+	return {
+		widthPt: cursorXPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+//#endregion
+exports.EMPTY_BOX = EMPTY_BOX;
+exports.concatBoxesHorizontally = concatBoxesHorizontally;
+exports.placeChild = placeChild;
+exports.shiftItems = shiftItems;

package/dist/mathml/compose.d.cts

@@ -0,0 +1,8 @@
+import { MathBox, MathLayoutItem } from "./layout-types.cjs";
+//#region src/mathml/compose.d.ts
+declare const EMPTY_BOX: MathBox;
+declare function shiftItems(items: readonly MathLayoutItem[], dxPt: number, dyPt: number): MathLayoutItem[];
+declare function placeChild(child: MathBox, dxPt: number, baselineOffsetPt: number, overallAscentPt: number): readonly MathLayoutItem[];
+declare function concatBoxesHorizontally(boxes: readonly MathBox[], gapsPt?: readonly number[]): MathBox;
+//#endregion
+export { EMPTY_BOX, concatBoxesHorizontally, placeChild, shiftItems };

package/dist/mathml/compose.d.ts

@@ -0,0 +1,8 @@
+import { MathBox, MathLayoutItem } from "./layout-types.js";
+//#region src/mathml/compose.d.ts
+declare const EMPTY_BOX: MathBox;
+declare function shiftItems(items: readonly MathLayoutItem[], dxPt: number, dyPt: number): MathLayoutItem[];
+declare function placeChild(child: MathBox, dxPt: number, baselineOffsetPt: number, overallAscentPt: number): readonly MathLayoutItem[];
+declare function concatBoxesHorizontally(boxes: readonly MathBox[], gapsPt?: readonly number[]): MathBox;
+//#endregion
+export { EMPTY_BOX, concatBoxesHorizontally, placeChild, shiftItems };

package/dist/mathml/compose.js

@@ -0,0 +1,49 @@
+//#region src/mathml/compose.ts
+const EMPTY_BOX = {
+	widthPt: 0,
+	heightPt: 0,
+	ascentPt: 0,
+	descentPt: 0,
+	items: []
+};
+function shiftItems(items, dxPt, dyPt) {
+	if (dxPt === 0 && dyPt === 0) return [...items];
+	return items.map((item) => {
+		if (item.kind === "stroke") return {
+			...item,
+			points: item.points.map((p) => ({
+				xPt: p.xPt + dxPt,
+				yPt: p.yPt + dyPt
+			}))
+		};
+		return {
+			...item,
+			xPt: item.xPt + dxPt,
+			yPt: item.yPt + dyPt
+		};
+	});
+}
+function placeChild(child, dxPt, baselineOffsetPt, overallAscentPt) {
+	const dyPt = overallAscentPt + baselineOffsetPt - child.ascentPt;
+	return shiftItems(child.items, dxPt, dyPt);
+}
+function concatBoxesHorizontally(boxes, gapsPt = []) {
+	const ascentPt = boxes.reduce((max, b) => Math.max(max, b.ascentPt), 0);
+	const descentPt = boxes.reduce((max, b) => Math.max(max, b.descentPt), 0);
+	const items = [];
+	let cursorXPt = 0;
+	boxes.forEach((box, index) => {
+		cursorXPt += gapsPt[index] ?? 0;
+		items.push(...placeChild(box, cursorXPt, 0, ascentPt));
+		cursorXPt += box.widthPt;
+	});
+	return {
+		widthPt: cursorXPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+//#endregion
+export { EMPTY_BOX, concatBoxesHorizontally, placeChild, shiftItems };

package/dist/mathml/layout-types.d.cts

@@ -0,0 +1,50 @@
+//#region src/mathml/layout-types.d.ts
+interface MathColor {
+  readonly r: number;
+  readonly g: number;
+  readonly b: number;
+}
+interface MathGlyphRun {
+  readonly kind: 'glyphs';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly text: string;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+interface MathRule {
+  readonly kind: 'rule';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly color: MathColor;
+}
+interface MathStroke {
+  readonly kind: 'stroke';
+  readonly points: readonly {
+    readonly xPt: number;
+    readonly yPt: number;
+  }[];
+  readonly widthPt: number;
+  readonly color: MathColor;
+}
+type MathLayoutItem = MathGlyphRun | MathRule | MathStroke;
+interface MathBox {
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly ascentPt: number;
+  readonly descentPt: number;
+  readonly items: readonly MathLayoutItem[];
+}
+type MathDiagnosticKind = 'unsupported-element' | 'missing-glyph';
+interface MathDiagnostic {
+  readonly kind: MathDiagnosticKind;
+  readonly detail: string;
+}
+interface MathLayoutResult {
+  readonly box: MathBox;
+  readonly diagnostics: readonly MathDiagnostic[];
+}
+//#endregion
+export { MathBox, MathColor, MathDiagnostic, MathDiagnosticKind, MathGlyphRun, MathLayoutItem, MathLayoutResult, MathRule, MathStroke };

package/dist/mathml/layout-types.d.ts

@@ -0,0 +1,50 @@
+//#region src/mathml/layout-types.d.ts
+interface MathColor {
+  readonly r: number;
+  readonly g: number;
+  readonly b: number;
+}
+interface MathGlyphRun {
+  readonly kind: 'glyphs';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly text: string;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+interface MathRule {
+  readonly kind: 'rule';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly color: MathColor;
+}
+interface MathStroke {
+  readonly kind: 'stroke';
+  readonly points: readonly {
+    readonly xPt: number;
+    readonly yPt: number;
+  }[];
+  readonly widthPt: number;
+  readonly color: MathColor;
+}
+type MathLayoutItem = MathGlyphRun | MathRule | MathStroke;
+interface MathBox {
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly ascentPt: number;
+  readonly descentPt: number;
+  readonly items: readonly MathLayoutItem[];
+}
+type MathDiagnosticKind = 'unsupported-element' | 'missing-glyph';
+interface MathDiagnostic {
+  readonly kind: MathDiagnosticKind;
+  readonly detail: string;
+}
+interface MathLayoutResult {
+  readonly box: MathBox;
+  readonly diagnostics: readonly MathDiagnostic[];
+}
+//#endregion
+export { MathBox, MathColor, MathDiagnostic, MathDiagnosticKind, MathGlyphRun, MathLayoutItem, MathLayoutResult, MathRule, MathStroke };