documents.js 1.57.0 → 1.58.0

package/dist/layout/drawing.cjs

@@ -0,0 +1,117 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_geometry = require("../model/geometry.cjs");
+const require_layout_slides = require("./slides.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/layout/drawing.ts
+function convertRectVector(vector, pageHeightPt, out) {
+	const flipped = require_model_geometry.flipY(vector.frame, pageHeightPt);
+	out.push({
+		kind: "rect",
+		xPt: flipped.xPt,
+		yPt: flipped.yPt,
+		widthPt: flipped.widthPt,
+		heightPt: flipped.heightPt,
+		fill: vector.fill,
+		stroke: vector.stroke,
+		sourcePath: vector.sourcePath
+	});
+}
+function convertEllipseVector(vector, pageHeightPt, out) {
+	const flipped = require_model_geometry.flipY(vector.frame, pageHeightPt);
+	out.push({
+		kind: "ellipse",
+		xPt: flipped.xPt,
+		yPt: flipped.yPt,
+		widthPt: flipped.widthPt,
+		heightPt: flipped.heightPt,
+		fill: vector.fill,
+		stroke: vector.stroke,
+		sourcePath: vector.sourcePath
+	});
+}
+function convertLineVector(vector, pageHeightPt, out) {
+	out.push({
+		kind: "line",
+		x1Pt: vector.from.xPt,
+		y1Pt: pageHeightPt - vector.from.yPt,
+		x2Pt: vector.to.xPt,
+		y2Pt: pageHeightPt - vector.to.yPt,
+		color: vector.stroke.color,
+		widthPt: vector.stroke.widthPt,
+		sourcePath: vector.sourcePath
+	});
+}
+function placePathPoint(frame, point, pageHeightPt) {
+	return {
+		xPt: frame.xPt + point.xPt,
+		yPt: pageHeightPt - frame.yPt - point.yPt
+	};
+}
+function convertPathVector(vector, pageHeightPt, out) {
+	const subpaths = vector.subpaths.map((subpath) => {
+		const start = placePathPoint(vector.frame, subpath.start, pageHeightPt);
+		return {
+			startXPt: start.xPt,
+			startYPt: start.yPt,
+			closed: subpath.closed,
+			segments: subpath.segments.map((segment) => {
+				if (segment.kind === "line") {
+					const to = placePathPoint(vector.frame, segment.to, pageHeightPt);
+					return {
+						kind: "line",
+						xPt: to.xPt,
+						yPt: to.yPt
+					};
+				}
+				const control1 = placePathPoint(vector.frame, segment.control1, pageHeightPt);
+				const control2 = placePathPoint(vector.frame, segment.control2, pageHeightPt);
+				const to = placePathPoint(vector.frame, segment.to, pageHeightPt);
+				return {
+					kind: "cubic",
+					c1xPt: control1.xPt,
+					c1yPt: control1.yPt,
+					c2xPt: control2.xPt,
+					c2yPt: control2.yPt,
+					xPt: to.xPt,
+					yPt: to.yPt
+				};
+			})
+		};
+	});
+	out.push({
+		kind: "path",
+		subpaths,
+		fill: vector.fill,
+		fillRule: vector.fillRule,
+		stroke: vector.stroke,
+		sourcePath: vector.sourcePath
+	});
+}
+function convertVector(vector, pageHeightPt, out) {
+	if (vector.kind === "rect") convertRectVector(vector, pageHeightPt, out);
+	else if (vector.kind === "ellipse") convertEllipseVector(vector, pageHeightPt, out);
+	else if (vector.kind === "line") convertLineVector(vector, pageHeightPt, out);
+	else convertPathVector(vector, pageHeightPt, out);
+}
+function convertPage(page, measurer, images) {
+	const items = [];
+	for (const vector of page.vectors) convertVector(vector, page.size.heightPt, items);
+	for (const shape of page.shapes) require_layout_slides.convertShape(shape, page.size.heightPt, measurer, images, items);
+	return {
+		widthPt: page.size.widthPt,
+		heightPt: page.size.heightPt,
+		items
+	};
+}
+function convertDrawingToLayout(doc, options) {
+	const images = {};
+	const pages = doc.pages.map((page) => convertPage(page, options.measurer, images));
+	return {
+		formatVersion: document_schema_js.LAYOUT_FORMAT_VERSION,
+		metadata: doc.metadata,
+		pages,
+		images
+	};
+}
+//#endregion
+exports.convertDrawingToLayout = convertDrawingToLayout;

package/dist/layout/drawing.d.cts

@@ -0,0 +1,13 @@
+import { ContentDocument } from "../model/content.cjs";
+import { LayoutDocument } from "document-schema.js";
+import { TextMeasurer } from "pdf-codec";
+//#region src/layout/drawing.d.ts
+interface DrawingLayoutOptions {
+  readonly measurer: TextMeasurer;
+}
+type DrawingContentDocument = Extract<ContentDocument, {
+  kind: 'drawing';
+}>;
+declare function convertDrawingToLayout(doc: DrawingContentDocument, options: DrawingLayoutOptions): LayoutDocument;
+//#endregion
+export { DrawingLayoutOptions, convertDrawingToLayout };

package/dist/layout/drawing.d.ts

@@ -0,0 +1,13 @@
+import { ContentDocument } from "../model/content.js";
+import { LayoutDocument } from "document-schema.js";
+import { TextMeasurer } from "pdf-codec";
+//#region src/layout/drawing.d.ts
+interface DrawingLayoutOptions {
+  readonly measurer: TextMeasurer;
+}
+type DrawingContentDocument = Extract<ContentDocument, {
+  kind: 'drawing';
+}>;
+declare function convertDrawingToLayout(doc: DrawingContentDocument, options: DrawingLayoutOptions): LayoutDocument;
+//#endregion
+export { DrawingLayoutOptions, convertDrawingToLayout };

package/dist/layout/drawing.js

@@ -0,0 +1,116 @@
+import { flipY } from "../model/geometry.js";
+import { convertShape } from "./slides.js";
+import { LAYOUT_FORMAT_VERSION } from "document-schema.js";
+//#region src/layout/drawing.ts
+function convertRectVector(vector, pageHeightPt, out) {
+	const flipped = flipY(vector.frame, pageHeightPt);
+	out.push({
+		kind: "rect",
+		xPt: flipped.xPt,
+		yPt: flipped.yPt,
+		widthPt: flipped.widthPt,
+		heightPt: flipped.heightPt,
+		fill: vector.fill,
+		stroke: vector.stroke,
+		sourcePath: vector.sourcePath
+	});
+}
+function convertEllipseVector(vector, pageHeightPt, out) {
+	const flipped = flipY(vector.frame, pageHeightPt);
+	out.push({
+		kind: "ellipse",
+		xPt: flipped.xPt,
+		yPt: flipped.yPt,
+		widthPt: flipped.widthPt,
+		heightPt: flipped.heightPt,
+		fill: vector.fill,
+		stroke: vector.stroke,
+		sourcePath: vector.sourcePath
+	});
+}
+function convertLineVector(vector, pageHeightPt, out) {
+	out.push({
+		kind: "line",
+		x1Pt: vector.from.xPt,
+		y1Pt: pageHeightPt - vector.from.yPt,
+		x2Pt: vector.to.xPt,
+		y2Pt: pageHeightPt - vector.to.yPt,
+		color: vector.stroke.color,
+		widthPt: vector.stroke.widthPt,
+		sourcePath: vector.sourcePath
+	});
+}
+function placePathPoint(frame, point, pageHeightPt) {
+	return {
+		xPt: frame.xPt + point.xPt,
+		yPt: pageHeightPt - frame.yPt - point.yPt
+	};
+}
+function convertPathVector(vector, pageHeightPt, out) {
+	const subpaths = vector.subpaths.map((subpath) => {
+		const start = placePathPoint(vector.frame, subpath.start, pageHeightPt);
+		return {
+			startXPt: start.xPt,
+			startYPt: start.yPt,
+			closed: subpath.closed,
+			segments: subpath.segments.map((segment) => {
+				if (segment.kind === "line") {
+					const to = placePathPoint(vector.frame, segment.to, pageHeightPt);
+					return {
+						kind: "line",
+						xPt: to.xPt,
+						yPt: to.yPt
+					};
+				}
+				const control1 = placePathPoint(vector.frame, segment.control1, pageHeightPt);
+				const control2 = placePathPoint(vector.frame, segment.control2, pageHeightPt);
+				const to = placePathPoint(vector.frame, segment.to, pageHeightPt);
+				return {
+					kind: "cubic",
+					c1xPt: control1.xPt,
+					c1yPt: control1.yPt,
+					c2xPt: control2.xPt,
+					c2yPt: control2.yPt,
+					xPt: to.xPt,
+					yPt: to.yPt
+				};
+			})
+		};
+	});
+	out.push({
+		kind: "path",
+		subpaths,
+		fill: vector.fill,
+		fillRule: vector.fillRule,
+		stroke: vector.stroke,
+		sourcePath: vector.sourcePath
+	});
+}
+function convertVector(vector, pageHeightPt, out) {
+	if (vector.kind === "rect") convertRectVector(vector, pageHeightPt, out);
+	else if (vector.kind === "ellipse") convertEllipseVector(vector, pageHeightPt, out);
+	else if (vector.kind === "line") convertLineVector(vector, pageHeightPt, out);
+	else convertPathVector(vector, pageHeightPt, out);
+}
+function convertPage(page, measurer, images) {
+	const items = [];
+	for (const vector of page.vectors) convertVector(vector, page.size.heightPt, items);
+	for (const shape of page.shapes) convertShape(shape, page.size.heightPt, measurer, images, items);
+	return {
+		widthPt: page.size.widthPt,
+		heightPt: page.size.heightPt,
+		items
+	};
+}
+function convertDrawingToLayout(doc, options) {
+	const images = {};
+	const pages = doc.pages.map((page) => convertPage(page, options.measurer, images));
+	return {
+		formatVersion: LAYOUT_FORMAT_VERSION,
+		metadata: doc.metadata,
+		pages,
+		images
+	};
+}
+//#endregion
+export { convertDrawingToLayout };

package/dist/layout/engine.cjs

@@ -0,0 +1,216 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_geometry = require("../model/geometry.cjs");
+const require_mathml_layout = require("../mathml/layout.cjs");
+const require_layout_shared = require("./shared.cjs");
+let document_schema_js = require("document-schema.js");
+let pdf_codec = require("pdf-codec");
+//#region src/layout/engine.ts
+const MIN_FORMULA_SIZE_PT = 8;
+function formulaSizePtFromFrame(frameHeightPt) {
+	return Math.max(MIN_FORMULA_SIZE_PT, frameHeightPt / 2);
+}
+function newFlowState(section) {
+	return {
+		items: [],
+		cursorYDown: section.margins.topPt
+	};
+}
+function flushPage(state, section, pages) {
+	pages.push({
+		widthPt: section.pageSize.widthPt,
+		heightPt: section.pageSize.heightPt,
+		items: state.items
+	});
+	state.items = [];
+	state.cursorYDown = section.margins.topPt;
+}
+function ensureRoom(state, section, pages, neededHeightPt, contentBottomYDown) {
+	if (state.items.length > 0 && state.cursorYDown + neededHeightPt > contentBottomYDown) flushPage(state, section, pages);
+}
+function layoutParagraphFlow(paragraph, section, pages, state, contentLeftXDown, contentWidthPt, contentBottomYDown, measurer) {
+	if (state.items.length > 0) state.cursorYDown += paragraph.spacingBeforePt ?? 0;
+	const effectiveRuns = require_layout_shared.effectiveStyledRuns(paragraph.runs);
+	const fallbackRun = effectiveRuns[0];
+	const paragraphLeftXDown = contentLeftXDown + (paragraph.indentLeftPt ?? 0);
+	const paragraphWidthPt = Math.max(0, contentWidthPt - (paragraph.indentLeftPt ?? 0));
+	(0, pdf_codec.wrapRunsToWidth)(effectiveRuns, measurer, paragraphWidthPt).forEach((line, lineIndex) => {
+		const lineHeightPt = require_layout_shared.lineNaturalHeightPt(line, measurer, fallbackRun) * (paragraph.lineSpacing ?? 1);
+		ensureRoom(state, section, pages, lineHeightPt, contentBottomYDown);
+		const baselineYDown = state.cursorYDown + line.ascentPt;
+		const firstLineIndentPt = lineIndex === 0 ? paragraph.indentFirstLinePt ?? 0 : 0;
+		const alignOffsetPt = require_layout_shared.alignmentOffsetPt(paragraph.alignment, paragraphWidthPt, line.widthPt);
+		for (const fragment of line.fragments) {
+			const xPt = paragraphLeftXDown + firstLineIndentPt + alignOffsetPt + fragment.xOffsetPt;
+			const yPt = section.pageSize.heightPt - baselineYDown;
+			const textItem = {
+				kind: "text",
+				text: fragment.text,
+				xPt,
+				yPt,
+				font: fragment.font,
+				sizePt: fragment.sizePt,
+				color: fragment.color,
+				underline: fragment.underline,
+				sourcePath: fragment.sourcePath
+			};
+			state.items.push(textItem);
+			if (fragment.hyperlink !== void 0) {
+				const fragmentWidthPt = measurer.widthOfTextAtSize(fragment.text, fragment.font, fragment.sizePt);
+				const link = {
+					kind: "link",
+					uri: fragment.hyperlink,
+					xPt,
+					yPt: section.pageSize.heightPt - baselineYDown + line.descentPt,
+					widthPt: fragmentWidthPt,
+					heightPt: line.ascentPt - line.descentPt,
+					sourcePath: fragment.sourcePath
+				};
+				state.items.push(link);
+			}
+		}
+		state.cursorYDown += lineHeightPt;
+	});
+	state.cursorYDown += paragraph.spacingAfterPt ?? 0;
+}
+function layoutParagraphInCell(paragraph, cellLeftXDown, cellWidthPt, startYDown, pageHeightPt, measurer, out) {
+	let cursorYDown = startYDown + (paragraph.spacingBeforePt ?? 0);
+	const effectiveRuns = require_layout_shared.effectiveStyledRuns(paragraph.runs);
+	const fallbackRun = effectiveRuns[0];
+	const paragraphLeftXDown = cellLeftXDown + (paragraph.indentLeftPt ?? 0);
+	const paragraphWidthPt = Math.max(0, cellWidthPt - (paragraph.indentLeftPt ?? 0));
+	(0, pdf_codec.wrapRunsToWidth)(effectiveRuns, measurer, paragraphWidthPt).forEach((line, lineIndex) => {
+		const lineHeightPt = require_layout_shared.lineNaturalHeightPt(line, measurer, fallbackRun) * (paragraph.lineSpacing ?? 1);
+		const baselineYDown = cursorYDown + line.ascentPt;
+		const firstLineIndentPt = lineIndex === 0 ? paragraph.indentFirstLinePt ?? 0 : 0;
+		const alignOffsetPt = require_layout_shared.alignmentOffsetPt(paragraph.alignment, paragraphWidthPt, line.widthPt);
+		for (const fragment of line.fragments) out.push({
+			kind: "text",
+			text: fragment.text,
+			xPt: paragraphLeftXDown + firstLineIndentPt + alignOffsetPt + fragment.xOffsetPt,
+			yPt: pageHeightPt - baselineYDown,
+			font: fragment.font,
+			sizePt: fragment.sizePt,
+			color: fragment.color,
+			underline: fragment.underline,
+			sourcePath: fragment.sourcePath
+		});
+		cursorYDown += lineHeightPt;
+	});
+	return cursorYDown + (paragraph.spacingAfterPt ?? 0);
+}
+function layoutTableFlow(table, section, pages, state, contentLeftXDown, contentWidthPt, contentBottomYDown, measurer) {
+	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 ?? require_layout_shared.estimateRowHeightPt(row, measurer, table.columnWidthsPt, scale);
+		ensureRoom(state, section, pages, rowHeightPt, contentBottomYDown);
+		let cellXDown = contentLeftXDown;
+		let colIndex = 0;
+		for (const cell of row.cells) {
+			const span = cell.colSpan ?? 1;
+			const cellWidthPt = require_layout_shared.sumColumnWidthsPt(table.columnWidthsPt, colIndex, span) * scale;
+			if (cell.background !== void 0) {
+				const cellFrame = require_model_geometry.flipY({
+					xPt: cellXDown,
+					yPt: state.cursorYDown,
+					widthPt: cellWidthPt,
+					heightPt: rowHeightPt
+				}, section.pageSize.heightPt);
+				state.items.push({
+					kind: "rect",
+					xPt: cellFrame.xPt,
+					yPt: cellFrame.yPt,
+					widthPt: cellFrame.widthPt,
+					heightPt: cellFrame.heightPt,
+					fill: cell.background,
+					sourcePath: table.sourcePath
+				});
+			}
+			let cellCursorYDown = state.cursorYDown;
+			for (const block of cell.blocks) if (block.kind === "paragraph") cellCursorYDown = layoutParagraphInCell(block, cellXDown, cellWidthPt, cellCursorYDown, section.pageSize.heightPt, measurer, state.items);
+			cellXDown += cellWidthPt;
+			colIndex += span;
+		}
+		state.cursorYDown += rowHeightPt;
+	}
+}
+function layoutImageFlow(block, section, pages, state, contentLeftXDown, contentBottomYDown, images) {
+	ensureRoom(state, section, pages, block.heightPt, contentBottomYDown);
+	const imageId = require_layout_shared.registerImage(block, images);
+	const flippedFrame = require_model_geometry.flipY({
+		xPt: contentLeftXDown,
+		yPt: state.cursorYDown,
+		widthPt: block.widthPt,
+		heightPt: block.heightPt
+	}, section.pageSize.heightPt);
+	const imageItem = {
+		kind: "image",
+		imageId,
+		xPt: flippedFrame.xPt,
+		yPt: flippedFrame.yPt,
+		widthPt: flippedFrame.widthPt,
+		heightPt: flippedFrame.heightPt,
+		sourcePath: block.sourcePath
+	};
+	state.items.push(imageItem);
+	state.cursorYDown += block.heightPt;
+}
+function layoutFormulaFlow(block, section, pages, state, contentLeftXDown, contentWidthPt, contentBottomYDown, measurer, options, formulas) {
+	const embedded = block.sourcePath === void 0 ? void 0 : options.formulas?.get(block.sourcePath);
+	if (embedded === void 0) {
+		const fallbackParagraph = block.document.kind === "wordprocessing" ? block.document.sections[0]?.blocks[0] : void 0;
+		if (fallbackParagraph?.kind === "paragraph") layoutParagraphFlow(fallbackParagraph, section, pages, state, contentLeftXDown, contentWidthPt, contentBottomYDown, measurer);
+		return;
+	}
+	const sizePt = formulaSizePtFromFrame(block.frame.heightPt);
+	const metrics = (0, pdf_codec.loadMathFont)().metricsAt(sizePt);
+	const { box } = require_mathml_layout.layoutFormula(embedded.mathml, {
+		metrics,
+		sizePt,
+		color: document_schema_js.COLOR_BLACK
+	});
+	ensureRoom(state, section, pages, box.heightPt, contentBottomYDown);
+	const flippedFrame = require_model_geometry.flipY({
+		xPt: contentLeftXDown,
+		yPt: state.cursorYDown,
+		widthPt: box.widthPt,
+		heightPt: box.heightPt
+	}, section.pageSize.heightPt);
+	formulas.push({
+		pageIndex: pages.length,
+		xPt: flippedFrame.xPt,
+		yPt: flippedFrame.yPt,
+		box
+	});
+	state.cursorYDown += box.heightPt;
+}
+function paginateSection(section, measurer, images, pages, options, formulas) {
+	const contentLeftXDown = section.margins.leftPt;
+	const contentWidthPt = Math.max(0, section.pageSize.widthPt - section.margins.leftPt - section.margins.rightPt);
+	const contentBottomYDown = section.pageSize.heightPt - section.margins.bottomPt;
+	const state = newFlowState(section);
+	for (const block of section.blocks) if (block.kind === "pageBreak") {
+		if (state.items.length > 0) flushPage(state, section, pages);
+	} else if (block.kind === "paragraph") layoutParagraphFlow(block, section, pages, state, contentLeftXDown, contentWidthPt, contentBottomYDown, measurer);
+	else if (block.kind === "table") layoutTableFlow(block, section, pages, state, contentLeftXDown, contentWidthPt, contentBottomYDown, measurer);
+	else if (block.kind === "image") layoutImageFlow(block, section, pages, state, contentLeftXDown, contentBottomYDown, images);
+	else if (block.kind === "embeddedObject" && block.objectKind === "formula") layoutFormulaFlow(block, section, pages, state, contentLeftXDown, contentWidthPt, contentBottomYDown, measurer, options, formulas);
+	flushPage(state, section, pages);
+}
+function convertWordprocessingToLayout(doc, options) {
+	const images = {};
+	const pages = [];
+	const formulas = [];
+	for (const section of doc.sections) paginateSection(section, options.measurer, images, pages, options, formulas);
+	return {
+		document: {
+			formatVersion: document_schema_js.LAYOUT_FORMAT_VERSION,
+			metadata: doc.metadata,
+			pages,
+			images
+		},
+		formulas
+	};
+}
+//#endregion
+exports.convertWordprocessingToLayout = convertWordprocessingToLayout;

package/dist/layout/engine.d.cts

@@ -0,0 +1,19 @@
+import { ContentDocument } from "../model/content.cjs";
+import { EmbeddedFormula } from "../model/formula.cjs";
+import { LayoutDocument } from "document-schema.js";
+import { PositionedFormula, TextMeasurer } from "pdf-codec";
+//#region src/layout/engine.d.ts
+interface EngineLayoutOptions {
+  readonly measurer: TextMeasurer;
+  readonly formulas?: ReadonlyMap<string, EmbeddedFormula>;
+}
+interface WordprocessingLayoutResult {
+  readonly document: LayoutDocument;
+  readonly formulas: readonly PositionedFormula[];
+}
+type WordprocessingContentDocument = Extract<ContentDocument, {
+  kind: 'wordprocessing';
+}>;
+declare function convertWordprocessingToLayout(doc: WordprocessingContentDocument, options: EngineLayoutOptions): WordprocessingLayoutResult;
+//#endregion
+export { EngineLayoutOptions, WordprocessingLayoutResult, convertWordprocessingToLayout };

package/dist/layout/engine.d.ts

@@ -0,0 +1,19 @@
+import { ContentDocument } from "../model/content.js";
+import { EmbeddedFormula } from "../model/formula.js";
+import { LayoutDocument } from "document-schema.js";
+import { PositionedFormula, TextMeasurer } from "pdf-codec";
+//#region src/layout/engine.d.ts
+interface EngineLayoutOptions {
+  readonly measurer: TextMeasurer;
+  readonly formulas?: ReadonlyMap<string, EmbeddedFormula>;
+}
+interface WordprocessingLayoutResult {
+  readonly document: LayoutDocument;
+  readonly formulas: readonly PositionedFormula[];
+}
+type WordprocessingContentDocument = Extract<ContentDocument, {
+  kind: 'wordprocessing';
+}>;
+declare function convertWordprocessingToLayout(doc: WordprocessingContentDocument, options: EngineLayoutOptions): WordprocessingLayoutResult;
+//#endregion
+export { EngineLayoutOptions, WordprocessingLayoutResult, convertWordprocessingToLayout };