@pdfme/schemas 6.1.13-dev.25 → 6.1.13-dev.26

package/dist/graphics/orientation.d.ts

@@ -0,0 +1,31 @@
+export type ImageFormat = 'jpeg' | 'png' | 'other';
+export declare const detectImageFormat: (bytes: Uint8Array) => ImageFormat;
+/** TIFF/IFD0: returns 1..8 or undefined. Never throws. */
+export declare const parseTiffOrientation: (tiff: Uint8Array) => number | undefined;
+/**
+ * JPEG: scan APP1 'Exif\0\0' segments; stop at SOS/EOI.
+ * Skips 0xFF fill/padding and standalone markers. If an Exif APP1 has no
+ * valid Orientation, keep scanning for a later one.
+ */
+export declare const getJpegOrientation: (bytes: Uint8Array) => number | undefined;
+/**
+ * PNG: scan chunks for eXIf (raw TIFF payload). Skip IDAT and other
+ * ancillary chunks; eXIf may appear after image data. Stop at IEND.
+ */
+export declare const getPngOrientation: (bytes: Uint8Array) => number | undefined;
+export declare const orientationSwapsDimensions: (orientation: number) => boolean;
+/**
+ * Map source (x, y) into destination (dx, dy) for EXIF orientations 2–8.
+ * Orientations 5–8 swap width and height.
+ */
+export declare const transformRgba: (src: Uint8Array, width: number, height: number, orientation: number) => {
+    data: Uint8Array;
+    width: number;
+    height: number;
+};
+/**
+ * One normalize path for JPEG and PNG. Tag absent/1 is a byte-identical
+ * passthrough. Tag 2–8 decodes, transforms pixels, and re-encodes without
+ * an orientation tag. May throw on decode/encode failure — callers fall back.
+ */
+export declare const normalizeImageOrientation: (bytes: Uint8Array) => Uint8Array;

package/dist/index.js

@@ -11,6 +11,8 @@ import { DEFAULT_FONT_NAME, ZOOM, b64toUint8Array, getDefaultFont, getFallbackFo
 import { Buffer as Buffer$1 } from "buffer";
 import { toRadians } from "@pdfme/pdf-lib";
 import { Barcode, Calendar, CalendarClock, ChevronDown, Circle, CircleDot, Clock, Image, List, Minus, QrCode, Route, Square, SquareCheck, Table, Type } from "lucide";
+import jpegJsModule from "jpeg-js";
+import UPNGModule from "@pdf-lib/upng";
 import DOMPurify from "dompurify";
 import bwipjs from "bwip-js";
 import AirDatepicker from "air-datepicker";
@@ -1406,88 +1408,208 @@ var listSchema = {
 	icon: createSvgStr(List)
 };
 //#endregion
-//#region src/graphics/imagehelper.ts
-var decoder = new TextDecoder();
-var toUTF8String = (input, start = 0, end = input.length) => decoder.decode(input.slice(start, end));
-var toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + ("0" + i.toString(16)).slice(-2), "");
-var readUInt16BE = (input, offset = 0) => input[offset] * 256 + input[offset + 1];
-var readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 + input[offset + 1] * 2 ** 16 + input[offset + 2] * 256 + input[offset + 3];
-var extractSize = (input, index) => {
-	return {
-		height: readUInt16BE(input, index),
-		width: readUInt16BE(input, index + 2)
-	};
+//#region src/graphics/orientation.ts
+var isJpegJsApi = (value) => !!value && typeof value === "object" && typeof value.decode === "function" && typeof value.encode === "function";
+var isUPNGApi = (value) => !!value && typeof value === "object" && typeof value.decode === "function" && typeof value.toRGBA8 === "function" && typeof value.encode === "function";
+var resolveExport = (value, guard, label) => {
+	let current = value;
+	while (current && typeof current === "object") {
+		if (guard(current)) return current;
+		current = current.default;
+	}
+	throw new TypeError(`Failed to resolve ${label} exports`);
+};
+var jpegJs = resolveExport(jpegJsModule, isJpegJsApi, "jpeg-js");
+var UPNG = resolveExport(UPNGModule, isUPNGApi, "@pdf-lib/upng");
+var JPEG_ENCODE_QUALITY = 90;
+var JPEG_MAX_MEMORY_MB = 512;
+var JPEG_SOI_0 = 255;
+var JPEG_SOI_1 = 216;
+var PNG_SIGNATURE = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+var toArrayBuffer = (bytes) => {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+};
+var isPngSignature = (bytes) => {
+	if (bytes.length < PNG_SIGNATURE.length) return false;
+	for (let i = 0; i < PNG_SIGNATURE.length; i++) if (bytes[i] !== PNG_SIGNATURE[i]) return false;
+	return true;
 };
-var validateInput = (input, index) => {
-	if (index > input.length) throw new TypeError("Corrupt JPG, exceeded buffer limits");
-	if (input[index] !== 255) throw new TypeError("Invalid JPG, marker table corrupted");
+var detectImageFormat = (bytes) => {
+	if (bytes.length >= 2 && bytes[0] === JPEG_SOI_0 && bytes[1] === JPEG_SOI_1) return "jpeg";
+	if (isPngSignature(bytes)) return "png";
+	return "other";
 };
-var JPG = {
-	validate: (input) => toHexString(input, 0, 2) === "ffd8",
-	calculate(input) {
-		input = input.slice(4);
-		let next;
-		while (input.length) {
-			const i = readUInt16BE(input, 0);
-			validateInput(input, i);
-			next = input[i + 1];
-			if (next === 192 || next === 193 || next === 194) return extractSize(input, i + 5);
-			input = input.slice(i + 2);
+/** TIFF/IFD0: returns 1..8 or undefined. Never throws. */
+var parseTiffOrientation = (tiff) => {
+	try {
+		if (tiff.length < 8) return void 0;
+		const le = tiff[0] === 73 && tiff[1] === 73;
+		if (!le && !(tiff[0] === 77 && tiff[1] === 77)) return void 0;
+		const view = new DataView(tiff.buffer, tiff.byteOffset, tiff.byteLength);
+		if (view.getUint16(2, le) !== 42) return void 0;
+		const ifd = view.getUint32(4, le);
+		if (ifd + 2 > tiff.length) return void 0;
+		const n = view.getUint16(ifd, le);
+		for (let i = 0; i < n; i++) {
+			const entry = ifd + 2 + i * 12;
+			if (entry + 12 > tiff.length) return void 0;
+			if (view.getUint16(entry, le) !== 274) continue;
+			if (view.getUint16(entry + 2, le) !== 3) return void 0;
+			if (view.getUint32(entry + 4, le) !== 1) return void 0;
+			const val = view.getUint16(entry + 8, le);
+			return val >= 1 && val <= 8 ? val : void 0;
 		}
-		throw new TypeError("Invalid JPG, no size found");
+		return;
+	} catch {
+		return;
 	}
 };
-var pngSignature = "PNG\r\n\n";
-var pngImageHeaderChunkName = "IHDR";
-var pngFriedChunkName = "CgBI";
-var typeHandlers = {
-	jpg: JPG,
-	png: {
-		validate(input) {
-			if (pngSignature === toUTF8String(input, 1, 8)) {
-				let chunkName = toUTF8String(input, 12, 16);
-				if (chunkName === pngFriedChunkName) chunkName = toUTF8String(input, 28, 32);
-				if (chunkName !== pngImageHeaderChunkName) throw new TypeError("Invalid PNG");
-				return true;
+var isExifApp1Payload = (segment) => segment.length >= 6 && segment[0] === 69 && segment[1] === 120 && segment[2] === 105 && segment[3] === 102 && segment[4] === 0 && segment[5] === 0;
+/** Standalone JPEG markers have no length field (TEM, RST0–7, SOI). */
+var isStandaloneJpegMarker = (marker) => marker === 1 || marker >= 208 && marker <= 216;
+/**
+* JPEG: scan APP1 'Exif\0\0' segments; stop at SOS/EOI.
+* Skips 0xFF fill/padding and standalone markers. If an Exif APP1 has no
+* valid Orientation, keep scanning for a later one.
+*/
+var getJpegOrientation = (bytes) => {
+	if (bytes.length < 2 || bytes[0] !== JPEG_SOI_0 || bytes[1] !== JPEG_SOI_1) return void 0;
+	let pos = 2;
+	while (pos < bytes.length) {
+		if (bytes[pos] !== 255) return void 0;
+		while (pos < bytes.length && bytes[pos] === 255) pos++;
+		if (pos >= bytes.length) return void 0;
+		const marker = bytes[pos++];
+		if (isStandaloneJpegMarker(marker)) continue;
+		if (marker === 218 || marker === 217) return void 0;
+		if (pos + 2 > bytes.length) return void 0;
+		const size = bytes[pos] << 8 | bytes[pos + 1];
+		if (size < 2 || pos + size > bytes.length) return void 0;
+		if (marker === 225 && size >= 8) {
+			const segment = bytes.subarray(pos + 2, pos + size);
+			if (isExifApp1Payload(segment)) {
+				const orientation = parseTiffOrientation(segment.subarray(6));
+				if (orientation !== void 0) return orientation;
 			}
-			return false;
-		},
-		calculate(input) {
-			if (toUTF8String(input, 12, 16) === pngFriedChunkName) return {
-				height: readUInt32BE(input, 36),
-				width: readUInt32BE(input, 32)
-			};
-			return {
-				height: readUInt32BE(input, 20),
-				width: readUInt32BE(input, 16)
-			};
 		}
+		pos += size;
 	}
 };
-function detector(input) {
-	const firstBytes = {
-		137: "png",
-		255: "jpg"
-	};
-	const byte = input[0];
-	if (byte in firstBytes) {
-		const type = firstBytes[byte];
-		if (type && typeHandlers[type].validate(input)) return type;
+/**
+* PNG: scan chunks for eXIf (raw TIFF payload). Skip IDAT and other
+* ancillary chunks; eXIf may appear after image data. Stop at IEND.
+*/
+var getPngOrientation = (bytes) => {
+	if (!isPngSignature(bytes)) return void 0;
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let pos = 8;
+	while (pos + 12 <= bytes.length) {
+		const length = view.getUint32(pos);
+		if (pos + 12 + length > bytes.length) return void 0;
+		const type = String.fromCharCode(bytes[pos + 4], bytes[pos + 5], bytes[pos + 6], bytes[pos + 7]);
+		if (type === "eXIf") return parseTiffOrientation(bytes.subarray(pos + 8, pos + 8 + length));
+		if (type === "IEND") return void 0;
+		pos += 12 + length;
 	}
-	return Object.keys(typeHandlers).find((key) => typeHandlers[key].validate(input));
-}
-var getImageDimension = (value) => {
-	const idx = value.indexOf(";base64,");
-	const imgBase64 = value.substring(idx + 8, value.length);
-	return imageSize(Buffer$1.from(imgBase64, "base64"));
 };
-var imageSize = (imgBuffer) => {
-	const type = detector(imgBuffer);
-	if (typeof type !== "undefined" && type in typeHandlers) {
-		const size = typeHandlers[type].calculate(imgBuffer);
-		if (size !== void 0) return size;
+var orientationSwapsDimensions = (orientation) => orientation >= 5;
+/**
+* Map source (x, y) into destination (dx, dy) for EXIF orientations 2–8.
+* Orientations 5–8 swap width and height.
+*/
+var transformRgba = (src, width, height, orientation) => {
+	const swap = orientationSwapsDimensions(orientation);
+	const destWidth = swap ? height : width;
+	const destHeight = swap ? width : height;
+	const dest = new Uint8Array(destWidth * destHeight * 4);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		let dx = x;
+		let dy = y;
+		switch (orientation) {
+			case 2:
+				dx = width - 1 - x;
+				dy = y;
+				break;
+			case 3:
+				dx = width - 1 - x;
+				dy = height - 1 - y;
+				break;
+			case 4:
+				dx = x;
+				dy = height - 1 - y;
+				break;
+			case 5:
+				dx = y;
+				dy = x;
+				break;
+			case 6:
+				dx = height - 1 - y;
+				dy = x;
+				break;
+			case 7:
+				dx = height - 1 - y;
+				dy = width - 1 - x;
+				break;
+			case 8:
+				dx = y;
+				dy = width - 1 - x;
+		}
+		const srcIndex = (y * width + x) * 4;
+		const destIndex = (dy * destWidth + dx) * 4;
+		dest[destIndex] = src[srcIndex];
+		dest[destIndex + 1] = src[srcIndex + 1];
+		dest[destIndex + 2] = src[srcIndex + 2];
+		dest[destIndex + 3] = src[srcIndex + 3];
 	}
-	throw new TypeError("[@pdfme/schemas/images] Unsupported file type: " + (type === void 0 ? "undefined" : type));
+	return {
+		data: dest,
+		width: destWidth,
+		height: destHeight
+	};
+};
+var bakeJpegOrientation = (bytes) => {
+	const orientation = getJpegOrientation(bytes);
+	if (!orientation || orientation === 1) return bytes;
+	const raw = jpegJs.decode(bytes, {
+		useTArray: true,
+		formatAsRGBA: true,
+		maxMemoryUsageInMB: JPEG_MAX_MEMORY_MB
+	});
+	const transformed = transformRgba(raw.data, raw.width, raw.height, orientation);
+	return new Uint8Array(jpegJs.encode({
+		data: transformed.data,
+		width: transformed.width,
+		height: transformed.height
+	}, JPEG_ENCODE_QUALITY).data);
+};
+var bakePngOrientation = (bytes) => {
+	const orientation = getPngOrientation(bytes);
+	if (!orientation || orientation === 1) return bytes;
+	const img = UPNG.decode(toArrayBuffer(bytes));
+	const transformed = transformRgba(new Uint8Array(UPNG.toRGBA8(img)[0]), img.width, img.height, orientation);
+	return new Uint8Array(UPNG.encode([toArrayBuffer(transformed.data)], transformed.width, transformed.height, 0));
+};
+/**
+* One normalize path for JPEG and PNG. Tag absent/1 is a byte-identical
+* passthrough. Tag 2–8 decodes, transforms pixels, and re-encodes without
+* an orientation tag. May throw on decode/encode failure — callers fall back.
+*/
+var normalizeImageOrientation = (bytes) => {
+	const kind = detectImageFormat(bytes);
+	if (kind === "jpeg") return bakeJpegOrientation(bytes);
+	if (kind === "png") return bakePngOrientation(bytes);
+	return bytes;
 };
 //#endregion
 //#region src/graphics/image.ts
@@ -1515,6 +1637,11 @@ var getCacheKey = (schema, input) => {
 	const hex = (hash >>> 0).toString(16).padStart(8, "0");
 	return `${schema.type}:${input.length}:${hex}`;
 };
+var dataUrlToBytes = (value) => {
+	const idx = value.indexOf(";base64,");
+	const base64 = idx >= 0 ? value.slice(idx + 8) : value;
+	return new Uint8Array(Buffer$1.from(base64, "base64"));
+};
 var fullSize$1 = {
 	width: "100%",
 	height: "100%"
@@ -1527,16 +1654,24 @@ var imageSchema = {
 		const inputImageCacheKey = getCacheKey(schema, value);
 		let image = _cache.get(inputImageCacheKey);
 		if (!image) {
-			image = await (value.startsWith("data:image/png;") ? pdfDoc.embedPng(value) : pdfDoc.embedJpg(value));
+			const originalBytes = dataUrlToBytes(value);
+			const kind = detectImageFormat(originalBytes);
+			let bytes = originalBytes;
+			try {
+				if (kind === "jpeg" || kind === "png") bytes = normalizeImageOrientation(originalBytes);
+			} catch (error) {
+				console.warn("[@pdfme/schemas] EXIF orientation bake failed; embedding original bytes:", error);
+				bytes = originalBytes;
+			}
+			image = await (kind === "png" ? pdfDoc.embedPng(bytes) : pdfDoc.embedJpg(bytes));
 			_cache.set(inputImageCacheKey, image);
 		}
 		const _schema = {
 			...schema,
 			position: { ...schema.position }
 		};
-		const dimension = getImageDimension(value);
-		const imageWidth = px2mm(dimension.width);
-		const imageHeight = px2mm(dimension.height);
+		const imageWidth = px2mm(image.width);
+		const imageHeight = px2mm(image.height);
 		const boxWidth = _schema.width;
 		const boxHeight = _schema.height;
 		const imageRatio = imageWidth / imageHeight;