documents.js 1.60.3 → 1.62.0

package/dist/layout/cell-typing.d.ts

@@ -0,0 +1,22 @@
+import { ContentCellValue } from "document-schema.js";
+//#region src/layout/cell-typing.d.ts
+type CellTypeRule = 'boolean-literal' | 'iso-date' | 'named-month-date' | 'plain-number' | 'grouped-number' | 'percentage' | 'currency';
+type CellTypeDeclineReason = 'ambiguous-boolean-word' | 'ambiguous-date-order' | 'ambiguous-grouping-separator' | 'leading-zero-digits' | 'precision-loss';
+type CellTypeInferenceResult = {
+  readonly outcome: 'retyped';
+  readonly value: ContentCellValue;
+  readonly rule: CellTypeRule;
+} | {
+  readonly outcome: 'declined';
+  readonly reason: CellTypeDeclineReason;
+};
+type CellTypeInference = {
+  readonly sheetIndex: number;
+  readonly row: number;
+  readonly column: number;
+  readonly displayText: string;
+} & CellTypeInferenceResult;
+type CellTypeInferenceSink = (inference: CellTypeInference) => void;
+declare function inferCellValue(displayText: string): CellTypeInferenceResult | undefined;
+//#endregion
+export { CellTypeDeclineReason, CellTypeInference, CellTypeInferenceResult, CellTypeInferenceSink, CellTypeRule, inferCellValue };

package/dist/layout/cell-typing.js

@@ -0,0 +1,208 @@
+//#region src/layout/cell-typing.ts
+const CURRENCY_SYMBOLS = /* @__PURE__ */ new Map([
+	["$", void 0],
+	["¥", void 0],
+	["£", "GBP"],
+	["€", "EUR"],
+	["₹", "INR"],
+	["₩", "KRW"],
+	["₽", "RUB"]
+]);
+const MONTH_NAMES = new Map([
+	"january",
+	"february",
+	"march",
+	"april",
+	"may",
+	"june",
+	"july",
+	"august",
+	"september",
+	"october",
+	"november",
+	"december"
+].flatMap((name, index) => [[name, index + 1], [name.slice(0, 3), index + 1]]));
+const BOOLEAN_LITERALS = /* @__PURE__ */ new Map([["true", true], ["false", false]]);
+const AMBIGUOUS_BOOLEAN_WORDS = /* @__PURE__ */ new Set([
+	"yes",
+	"no",
+	"y",
+	"n",
+	"on",
+	"off"
+]);
+function normalizeWhitespace(text) {
+	return text.replace(/[\u00A0\u202F]/gu, " ").trim();
+}
+function exactlyRepresentable(canonicalDecimal) {
+	const parsed = Number(canonicalDecimal);
+	if (!Number.isFinite(parsed)) return;
+	const trimmed = canonicalDecimal.includes(".") ? canonicalDecimal.replace(/0+$/u, "").replace(/\.$/u, "") : canonicalDecimal;
+	return String(parsed) === trimmed ? parsed : void 0;
+}
+const PLAIN_NUMBER_PATTERN = /^(?<sign>[-+])?(?<integer>\d+)(?:\.(?<fraction>\d+))?$/u;
+const GROUPED_NUMBER_PATTERN = /^(?<sign>[-+])?(?<lead>\d{1,3})(?<groups>(?:,\d{3})+)(?:\.(?<fraction>\d+))?$/u;
+function parseNumericLiteral(text) {
+	const grouped = GROUPED_NUMBER_PATTERN.exec(text);
+	if (grouped?.groups !== void 0) {
+		const { sign, lead, groups, fraction } = grouped.groups;
+		if (lead.length > 1 && lead.startsWith("0")) return { declined: "leading-zero-digits" };
+		if (groups.length / 4 === 1 && fraction === void 0) return { declined: "ambiguous-grouping-separator" };
+		return {
+			canonicalDecimal: `${sign === "-" ? "-" : ""}${lead}${groups.replaceAll(",", "")}${fraction === void 0 ? "" : `.${fraction}`}`,
+			grouped: true
+		};
+	}
+	const plain = PLAIN_NUMBER_PATTERN.exec(text);
+	if (plain?.groups === void 0) return;
+	const { sign, integer, fraction } = plain.groups;
+	if (integer.length > 1 && integer.startsWith("0")) return { declined: "leading-zero-digits" };
+	return {
+		canonicalDecimal: `${sign === "-" ? "-" : ""}${integer}${fraction === void 0 ? "" : `.${fraction}`}`,
+		grouped: false
+	};
+}
+function isDecline(value) {
+	return value !== void 0 && "declined" in value;
+}
+const CURRENCY_PREFIX_PATTERN = /^(?<sign>-)?(?<symbol>[$£€¥₹₩₽])\s?(?<rest>.+)$/u;
+function inferCurrency(text) {
+	const match = CURRENCY_PREFIX_PATTERN.exec(text);
+	if (match?.groups === void 0) return;
+	const { sign, symbol, rest } = match.groups;
+	const literal = parseNumericLiteral(rest);
+	if (isDecline(literal)) return {
+		outcome: "declined",
+		reason: literal.declined
+	};
+	if (literal === void 0) return;
+	const magnitude = exactlyRepresentable(literal.canonicalDecimal);
+	if (magnitude === void 0) return {
+		outcome: "declined",
+		reason: "precision-loss"
+	};
+	return {
+		outcome: "retyped",
+		value: {
+			kind: "currency",
+			value: sign === "-" ? -magnitude : magnitude,
+			currency: CURRENCY_SYMBOLS.get(symbol)
+		},
+		rule: "currency"
+	};
+}
+const PERCENT_HUNDREDTHS = 100;
+function inferPercentage(text) {
+	if (!text.endsWith("%")) return;
+	const literal = parseNumericLiteral(text.slice(0, -1).trimEnd());
+	if (isDecline(literal)) return {
+		outcome: "declined",
+		reason: literal.declined
+	};
+	if (literal === void 0) return;
+	const magnitude = exactlyRepresentable(literal.canonicalDecimal);
+	if (magnitude === void 0) return {
+		outcome: "declined",
+		reason: "precision-loss"
+	};
+	return {
+		outcome: "retyped",
+		value: {
+			kind: "percentage",
+			value: magnitude / PERCENT_HUNDREDTHS
+		},
+		rule: "percentage"
+	};
+}
+const ISO_DATE_PATTERN = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/u;
+const DAY_MONTH_YEAR_PATTERN = /^(?<day>\d{1,2})[\s-](?<month>[A-Za-z]{3,9})\.?[\s-](?<year>\d{4})$/u;
+const MONTH_DAY_YEAR_PATTERN = /^(?<month>[A-Za-z]{3,9})\.?[\s-](?<day>\d{1,2}),?[\s-](?<year>\d{4})$/u;
+const NUMERIC_SEPARATED_DATE_PATTERN = /^\d{1,4}[/.]\d{1,2}[/.]\d{1,4}$/u;
+const MONTHS_PER_YEAR = 12;
+function isRealCalendarDate(year, month, day) {
+	if (month < 1 || month > MONTHS_PER_YEAR || day < 1) return false;
+	const probe = new Date(Date.UTC(year, month - 1, day));
+	return probe.getUTCFullYear() === year && probe.getUTCMonth() === month - 1 && probe.getUTCDate() === day;
+}
+function isoDateValue(year, month, day) {
+	return `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+function inferDate(text) {
+	const iso = ISO_DATE_PATTERN.exec(text);
+	if (iso?.groups !== void 0) {
+		const year = Number(iso.groups.year);
+		const month = Number(iso.groups.month);
+		const day = Number(iso.groups.day);
+		return isRealCalendarDate(year, month, day) ? {
+			outcome: "retyped",
+			value: {
+				kind: "date",
+				value: isoDateValue(year, month, day)
+			},
+			rule: "iso-date"
+		} : void 0;
+	}
+	const named = DAY_MONTH_YEAR_PATTERN.exec(text) ?? MONTH_DAY_YEAR_PATTERN.exec(text);
+	if (named?.groups !== void 0) {
+		const month = MONTH_NAMES.get(named.groups.month.toLowerCase());
+		if (month === void 0) return;
+		const year = Number(named.groups.year);
+		const day = Number(named.groups.day);
+		return isRealCalendarDate(year, month, day) ? {
+			outcome: "retyped",
+			value: {
+				kind: "date",
+				value: isoDateValue(year, month, day)
+			},
+			rule: "named-month-date"
+		} : void 0;
+	}
+	return NUMERIC_SEPARATED_DATE_PATTERN.test(text) ? {
+		outcome: "declined",
+		reason: "ambiguous-date-order"
+	} : void 0;
+}
+function inferBoolean(text) {
+	const lowered = text.toLowerCase();
+	const literal = BOOLEAN_LITERALS.get(lowered);
+	if (literal !== void 0) return {
+		outcome: "retyped",
+		value: {
+			kind: "boolean",
+			value: literal
+		},
+		rule: "boolean-literal"
+	};
+	return AMBIGUOUS_BOOLEAN_WORDS.has(lowered) ? {
+		outcome: "declined",
+		reason: "ambiguous-boolean-word"
+	} : void 0;
+}
+function inferNumber(text) {
+	const literal = parseNumericLiteral(text);
+	if (isDecline(literal)) return {
+		outcome: "declined",
+		reason: literal.declined
+	};
+	if (literal === void 0) return;
+	const value = exactlyRepresentable(literal.canonicalDecimal);
+	if (value === void 0) return {
+		outcome: "declined",
+		reason: "precision-loss"
+	};
+	return {
+		outcome: "retyped",
+		value: {
+			kind: "number",
+			value
+		},
+		rule: literal.grouped ? "grouped-number" : "plain-number"
+	};
+}
+function inferCellValue(displayText) {
+	const text = normalizeWhitespace(displayText);
+	if (text.length === 0) return;
+	return inferBoolean(text) ?? inferDate(text) ?? inferCurrency(text) ?? inferPercentage(text) ?? inferNumber(text);
+}
+//#endregion
+export { inferCellValue };

package/dist/layout/drawing.cjs

@@ -1,29 +1,192 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_model_geometry = require("../model/geometry.cjs");
+const require_model_paint_order = require("../model/paint-order.cjs");
 const require_layout_slides = require("./slides.cjs");
 let document_schema_js = require("document-schema.js");
+let pdf_codec = require("pdf-codec");
 //#region src/layout/drawing.ts
+function isRotated(rotationDeg) {
+	return rotationDeg !== void 0 && rotationDeg !== 0;
+}
+function boxCenter(box) {
+	return {
+		x: box.xPt + box.widthPt / 2,
+		y: box.yPt + box.heightPt / 2
+	};
+}
+function rotator(flipped, rotationDeg) {
+	const center = boxCenter(flipped);
+	const ccwDeg = -rotationDeg;
+	return (point) => (0, pdf_codec.rotatePointAboutCenter)(point, center, ccwDeg);
+}
+function boxCorners(box) {
+	return [
+		{
+			x: box.xPt,
+			y: box.yPt
+		},
+		{
+			x: box.xPt + box.widthPt,
+			y: box.yPt
+		},
+		{
+			x: box.xPt + box.widthPt,
+			y: box.yPt + box.heightPt
+		},
+		{
+			x: box.xPt,
+			y: box.yPt + box.heightPt
+		}
+	];
+}
 function convertRectVector(vector, pageHeightPt, out) {
 	const flipped = require_model_geometry.flipY(vector.frame, pageHeightPt);
+	if (!isRotated(vector.rotationDeg)) {
+		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
+		});
+		return;
+	}
+	const rotate = rotator(flipped, vector.rotationDeg);
+	const [start, ...rest] = boxCorners(flipped).map(rotate);
+	const subpath = {
+		startXPt: start.x,
+		startYPt: start.y,
+		closed: true,
+		segments: rest.map((corner) => ({
+			kind: "line",
+			xPt: corner.x,
+			yPt: corner.y
+		}))
+	};
 	out.push({
-		kind: "rect",
-		xPt: flipped.xPt,
-		yPt: flipped.yPt,
-		widthPt: flipped.widthPt,
-		heightPt: flipped.heightPt,
+		kind: "path",
+		subpaths: [subpath],
 		fill: vector.fill,
 		stroke: vector.stroke,
 		sourcePath: vector.sourcePath
 	});
 }
+const CIRCLE_CUBIC_RATIO = 4 / 3 * (Math.SQRT2 - 1);
+function ellipseCubicPoints(flipped) {
+	const cx = flipped.xPt + flipped.widthPt / 2;
+	const cy = flipped.yPt + flipped.heightPt / 2;
+	const rx = flipped.widthPt / 2;
+	const ry = flipped.heightPt / 2;
+	const kx = rx * CIRCLE_CUBIC_RATIO;
+	const ky = ry * CIRCLE_CUBIC_RATIO;
+	return {
+		start: {
+			x: cx + rx,
+			y: cy
+		},
+		arcs: [
+			{
+				c1: {
+					x: cx + rx,
+					y: cy + ky
+				},
+				c2: {
+					x: cx + kx,
+					y: cy + ry
+				},
+				to: {
+					x: cx,
+					y: cy + ry
+				}
+			},
+			{
+				c1: {
+					x: cx - kx,
+					y: cy + ry
+				},
+				c2: {
+					x: cx - rx,
+					y: cy + ky
+				},
+				to: {
+					x: cx - rx,
+					y: cy
+				}
+			},
+			{
+				c1: {
+					x: cx - rx,
+					y: cy - ky
+				},
+				c2: {
+					x: cx - kx,
+					y: cy - ry
+				},
+				to: {
+					x: cx,
+					y: cy - ry
+				}
+			},
+			{
+				c1: {
+					x: cx + kx,
+					y: cy - ry
+				},
+				c2: {
+					x: cx + rx,
+					y: cy - ky
+				},
+				to: {
+					x: cx + rx,
+					y: cy
+				}
+			}
+		]
+	};
+}
 function convertEllipseVector(vector, pageHeightPt, out) {
 	const flipped = require_model_geometry.flipY(vector.frame, pageHeightPt);
+	if (!isRotated(vector.rotationDeg)) {
+		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
+		});
+		return;
+	}
+	const rotate = rotator(flipped, vector.rotationDeg);
+	const { start, arcs } = ellipseCubicPoints(flipped);
+	const rotatedStart = rotate(start);
+	const segments = arcs.map((arc) => {
+		const c1 = rotate(arc.c1);
+		const c2 = rotate(arc.c2);
+		const to = rotate(arc.to);
+		return {
+			kind: "cubic",
+			c1xPt: c1.x,
+			c1yPt: c1.y,
+			c2xPt: c2.x,
+			c2yPt: c2.y,
+			xPt: to.x,
+			yPt: to.y
+		};
+	});
 	out.push({
-		kind: "ellipse",
-		xPt: flipped.xPt,
-		yPt: flipped.yPt,
-		widthPt: flipped.widthPt,
-		heightPt: flipped.heightPt,
+		kind: "path",
+		subpaths: [{
+			startXPt: rotatedStart.x,
+			startYPt: rotatedStart.y,
+			closed: true,
+			segments
+		}],
 		fill: vector.fill,
 		stroke: vector.stroke,
 		sourcePath: vector.sourcePath
@@ -48,24 +211,37 @@ function placePathPoint(frame, point, pageHeightPt) {
 	};
 }
 function convertPathVector(vector, pageHeightPt, out) {
+	const rotate = isRotated(vector.rotationDeg) ? rotator(require_model_geometry.flipY(vector.frame, pageHeightPt), vector.rotationDeg) : void 0;
+	const place = (point) => {
+		const placed = placePathPoint(vector.frame, point, pageHeightPt);
+		if (rotate === void 0) return placed;
+		const rotated = rotate({
+			x: placed.xPt,
+			y: placed.yPt
+		});
+		return {
+			xPt: rotated.x,
+			yPt: rotated.y
+		};
+	};
 	const subpaths = vector.subpaths.map((subpath) => {
-		const start = placePathPoint(vector.frame, subpath.start, pageHeightPt);
+		const start = place(subpath.start);
 		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);
+					const to = place(segment.to);
 					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);
+				const control1 = place(segment.control1);
+				const control2 = place(segment.control2);
+				const to = place(segment.to);
 				return {
 					kind: "cubic",
 					c1xPt: control1.xPt,
@@ -95,8 +271,8 @@ function convertVector(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);
+	for (const entry of require_model_paint_order.mergeByPaintOrder(page.vectors, page.shapes)) if (entry.kind === "vector") convertVector(entry.value, page.size.heightPt, items);
+	else require_layout_slides.convertShape(entry.value, page.size.heightPt, measurer, images, items);
 	return {
 		widthPt: page.size.widthPt,
 		heightPt: page.size.heightPt,