@pdfme/converter 0.0.0

package/src/img2pdf.ts

@@ -0,0 +1,110 @@
+import { PDFDocument } from '@pdfme/pdf-lib';
+import { mm2pt } from '@pdfme/common';
+import type { ImageType } from './types.js';
+
+interface Img2PdfOptions {
+  scale?: number;
+  imageType?: ImageType;
+  size?: { height: number; width: number }; // in millimeters
+  margin?: [number, number, number, number]; // in millimeters [top, right, bottom, left]
+}
+
+function detectImageType(buffer: ArrayBuffer): 'jpeg' | 'png' | 'unknown' {
+  const bytes = new Uint8Array(buffer);
+
+  if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+    return 'jpeg';
+  }
+
+  if (
+    bytes.length >= 8 &&
+    bytes[0] === 0x89 &&
+    bytes[1] === 0x50 &&
+    bytes[2] === 0x4e &&
+    bytes[3] === 0x47 &&
+    bytes[4] === 0x0d &&
+    bytes[5] === 0x0a &&
+    bytes[6] === 0x1a &&
+    bytes[7] === 0x0a
+  ) {
+    return 'png';
+  }
+
+  return 'unknown';
+}
+
+export async function img2pdf(
+  imgs: ArrayBuffer[],
+  options: Img2PdfOptions = {},
+): Promise<ArrayBuffer> {
+  try {
+    const { scale = 1, size, margin = [0, 0, 0, 0] } = options;
+
+    if (!Array.isArray(imgs) || imgs.length === 0) {
+      throw new Error('Input must be a non-empty array of image buffers');
+    }
+
+    const doc = await PDFDocument.create();
+    for (const img of imgs) {
+      try {
+        let image;
+        const type = detectImageType(img);
+
+        if (type === 'jpeg') {
+          image = await doc.embedJpg(img);
+        } else if (type === 'png') {
+          image = await doc.embedPng(img);
+        } else {
+          try {
+            image = await doc.embedJpg(img);
+          } catch {
+            image = await doc.embedPng(img);
+          }
+        }
+
+        const page = doc.addPage();
+        const { width: imgWidth, height: imgHeight } = image.scale(scale);
+
+        // Set page size based on size option or image dimensions
+        const pageWidth = size ? mm2pt(size.width) : imgWidth;
+        const pageHeight = size ? mm2pt(size.height) : imgHeight;
+        page.setSize(pageWidth, pageHeight);
+
+        // Convert margins from mm to points
+        const [topMargin, rightMargin, bottomMargin, leftMargin] = margin.map(mm2pt);
+
+        // Calculate available space for the image after applying margins
+        const availableWidth = pageWidth - leftMargin - rightMargin;
+        const availableHeight = pageHeight - topMargin - bottomMargin;
+
+        // Calculate scaling to fit image within available space while maintaining aspect ratio
+        const widthRatio = availableWidth / imgWidth;
+        const heightRatio = availableHeight / imgHeight;
+        const ratio = Math.min(widthRatio, heightRatio, 1); // Don't upscale images
+
+        // Calculate final image dimensions and position
+        const finalWidth = imgWidth * ratio;
+        const finalHeight = imgHeight * ratio;
+        const x = leftMargin + (availableWidth - finalWidth) / 2; // Center horizontally
+        const y = bottomMargin + (availableHeight - finalHeight) / 2; // Center vertically
+
+        page.drawImage(image, {
+          x,
+          y,
+          width: finalWidth,
+          height: finalHeight,
+        });
+      } catch (error) {
+        throw new Error(`Failed to process image: ${(error as Error).message}`);
+      }
+    }
+    const pdfUint8Array = await doc.save();
+    // Create a new ArrayBuffer from the Uint8Array to ensure we return only ArrayBuffer
+    const buffer = new ArrayBuffer(pdfUint8Array.byteLength);
+    const view = new Uint8Array(buffer);
+    view.set(pdfUint8Array);
+    return buffer;
+  } catch (error) {
+    throw new Error(`[@pdfme/converter] img2pdf failed: ${(error as Error).message}`);
+  }
+}

package/src/index.browser.ts

@@ -0,0 +1,51 @@
+import * as pdfjsLib from 'pdfjs-dist';
+// @ts-expect-error - PDFJSWorker import is not properly typed but required for functionality
+import PDFJSWorker from 'pdfjs-dist/build/pdf.worker.entry.js';
+import { pdf2img as _pdf2img, Pdf2ImgOptions } from './pdf2img.js';
+import { pdf2size as _pdf2size, Pdf2SizeOptions } from './pdf2size.js';
+
+pdfjsLib.GlobalWorkerOptions.workerSrc = PDFJSWorker as unknown as string;
+
+function dataURLToArrayBuffer(dataURL: string): ArrayBuffer {
+  // Split out the actual base64 string from the data URL scheme
+  const base64String = dataURL.split(',')[1];
+
+  // Decode the Base64 string to get the binary data
+  const byteString = atob(base64String);
+
+  // Create a typed array from the binary string
+  const arrayBuffer = new ArrayBuffer(byteString.length);
+  const uintArray = new Uint8Array(arrayBuffer);
+
+  for (let i = 0; i < byteString.length; i++) {
+    uintArray[i] = byteString.charCodeAt(i);
+  }
+
+  return arrayBuffer;
+}
+
+export const pdf2img = async (
+  pdf: ArrayBuffer | Uint8Array,
+  options: Pdf2ImgOptions = {},
+): Promise<ArrayBuffer[]> =>
+  _pdf2img(pdf, options, {
+    getDocument: (pdf) => pdfjsLib.getDocument({ data: pdf, isEvalSupported: false }).promise,
+    createCanvas: (width, height) => {
+      const canvas = document.createElement('canvas');
+      canvas.width = width;
+      canvas.height = height;
+      return canvas;
+    },
+    canvasToArrayBuffer: (canvas, imageType) => {
+      // Using type assertion to handle the canvas method
+      const dataUrl = (canvas as HTMLCanvasElement).toDataURL(`image/${imageType}`);
+      return dataURLToArrayBuffer(dataUrl);
+    },
+  });
+
+export const pdf2size = async (pdf: ArrayBuffer | Uint8Array, options: Pdf2SizeOptions = {}) =>
+  _pdf2size(pdf, options, {
+    getDocument: (pdf) => pdfjsLib.getDocument({ data: pdf, isEvalSupported: false }).promise,
+  });
+
+export { img2pdf } from './img2pdf.js';

package/src/index.node.ts

@@ -0,0 +1,33 @@
+import * as pdfjsLib from 'pdfjs-dist/legacy/build/pdf';
+// @ts-expect-error - PDFJSWorker import is not properly typed but required for functionality
+import PDFJSWorker from 'pdfjs-dist/legacy/build/pdf.worker.js';
+import { createCanvas } from 'canvas';
+import { pdf2img as _pdf2img, Pdf2ImgOptions } from './pdf2img.js';
+import { pdf2size as _pdf2size, Pdf2SizeOptions } from './pdf2size.js';
+
+pdfjsLib.GlobalWorkerOptions.workerSrc = PDFJSWorker as unknown as string;
+
+export const pdf2img = async (
+  pdf: ArrayBuffer | Uint8Array,
+  options: Pdf2ImgOptions = {},
+): Promise<ArrayBuffer[]> =>
+  _pdf2img(pdf, options, {
+    getDocument: (pdf) => pdfjsLib.getDocument({ data: pdf, isEvalSupported: false }).promise,
+    createCanvas: (width, height) => createCanvas(width, height) as unknown as HTMLCanvasElement,
+    canvasToArrayBuffer: (canvas) => {
+      // Using a more specific type for the canvas from the 'canvas' package
+      const nodeCanvas = canvas as unknown as import('canvas').Canvas;
+      // Get buffer from the canvas - using the synchronous version without parameters
+      // This will use the default PNG format
+      const buffer = nodeCanvas.toBuffer();
+      // Convert to ArrayBuffer
+      return new Uint8Array(buffer).buffer;
+    },
+  });
+
+export const pdf2size = async (pdf: ArrayBuffer | Uint8Array, options: Pdf2SizeOptions = {}) =>
+  _pdf2size(pdf, options, {
+    getDocument: (pdf) => pdfjsLib.getDocument({ data: pdf, isEvalSupported: false }).promise,
+  });
+
+export { img2pdf } from './img2pdf.js';

package/src/pdf2img.ts

@@ -0,0 +1,64 @@
+import type { PDFDocumentProxy } from 'pdfjs-dist';
+import type { ImageType } from './types.js';
+
+interface Environment {
+  getDocument: (pdf: ArrayBuffer | Uint8Array) => Promise<PDFDocumentProxy>;
+  createCanvas: (width: number, height: number) => HTMLCanvasElement | OffscreenCanvas;
+  canvasToArrayBuffer: (
+    canvas: HTMLCanvasElement | OffscreenCanvas,
+    imageType: ImageType,
+  ) => ArrayBuffer;
+}
+
+export interface Pdf2ImgOptions {
+  scale?: number;
+  imageType?: ImageType;
+  range?: {
+    start?: number;
+    end?: number;
+  };
+}
+
+export async function pdf2img(
+  pdf: ArrayBuffer | Uint8Array,
+  options: Pdf2ImgOptions = {},
+  env: Environment,
+): Promise<ArrayBuffer[]> {
+  try {
+    const { scale = 1, imageType = 'jpeg', range = {} } = options;
+    const { start = 0, end = Infinity } = range;
+
+    const { getDocument, createCanvas, canvasToArrayBuffer } = env;
+
+    const pdfDoc = await getDocument(pdf);
+    const numPages = pdfDoc.numPages;
+
+    const startPage = Math.max(start + 1, 1);
+    const endPage = Math.min(end + 1, numPages);
+
+    const results: ArrayBuffer[] = [];
+
+    for (let pageNum = startPage; pageNum <= endPage; pageNum++) {
+      const page = await pdfDoc.getPage(pageNum);
+      const viewport = page.getViewport({ scale });
+
+      const canvas = createCanvas(viewport.width, viewport.height);
+      if (!canvas) {
+        throw new Error('Failed to create canvas');
+      }
+
+      const context = canvas.getContext('2d') as CanvasRenderingContext2D;
+      if (!context) {
+        throw new Error('Failed to get canvas context');
+      }
+
+      await page.render({ canvasContext: context, viewport }).promise;
+      const arrayBuffer = canvasToArrayBuffer(canvas, imageType);
+      results.push(arrayBuffer);
+    }
+
+    return results;
+  } catch (error) {
+    throw new Error(`[@pdfme/converter] pdf2img failed: ${(error as Error).message}`);
+  }
+}

package/src/pdf2size.ts

@@ -0,0 +1,33 @@
+import type { PDFDocumentProxy } from 'pdfjs-dist';
+import { Size, pt2mm } from '@pdfme/common';
+
+interface Environment {
+  getDocument: (pdf: ArrayBuffer | Uint8Array) => Promise<PDFDocumentProxy>;
+}
+
+export interface Pdf2SizeOptions {
+  scale?: number;
+}
+
+export async function pdf2size(
+  pdf: ArrayBuffer | Uint8Array,
+  options: Pdf2SizeOptions = {},
+  env: Environment,
+): Promise<Size[]> {
+  const { scale = 1 } = options;
+  const { getDocument } = env;
+
+  const pdfDoc = await getDocument(pdf);
+
+  const promises = Promise.all(
+    new Array(pdfDoc.numPages).fill('').map(async (_, i) => {
+      return await pdfDoc.getPage(i + 1).then((page) => {
+        const { height, width } = page.getViewport({ scale, rotation: 0 });
+
+        return { height: pt2mm(height), width: pt2mm(width) };
+      });
+    }),
+  );
+
+  return promises;
+}

package/src/types.d.ts

@@ -0,0 +1 @@
+export type ImageType = 'jpeg' | 'png';

package/tsconfig.cjs.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "./dist/cjs",
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "skipLibCheck": true
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist/esm",
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "skipLibCheck": true
+  }
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.esm",
+  "compilerOptions": {
+    "outDir": "./dist",
+  }
+}