| import { PDFDocument, degrees, rgb, StandardFonts } from 'pdf-lib'; |
|
|
| export async function mergePdfs( |
| pdfBytesList: Uint8Array[] |
| ): Promise<Uint8Array> { |
| const mergedDoc = await PDFDocument.create(); |
| for (const bytes of pdfBytesList) { |
| const srcDoc = await PDFDocument.load(bytes); |
| const copiedPages = await mergedDoc.copyPages( |
| srcDoc, |
| srcDoc.getPageIndices() |
| ); |
| copiedPages.forEach((page) => mergedDoc.addPage(page)); |
| } |
| return new Uint8Array(await mergedDoc.save()); |
| } |
|
|
| export async function splitPdf( |
| pdfBytes: Uint8Array, |
| pageIndices: number[] |
| ): Promise<Uint8Array> { |
| const srcDoc = await PDFDocument.load(pdfBytes); |
| const newPdf = await PDFDocument.create(); |
| const copiedPages = await newPdf.copyPages(srcDoc, pageIndices); |
| copiedPages.forEach((page) => newPdf.addPage(page)); |
| return new Uint8Array(await newPdf.save()); |
| } |
|
|
| export async function rotatePdfUniform( |
| pdfBytes: Uint8Array, |
| angle: number |
| ): Promise<Uint8Array> { |
| const srcDoc = await PDFDocument.load(pdfBytes); |
| const newPdfDoc = await PDFDocument.create(); |
| const pageCount = srcDoc.getPageCount(); |
|
|
| for (let i = 0; i < pageCount; i++) { |
| const originalPage = srcDoc.getPage(i); |
| const currentRotation = originalPage.getRotation().angle; |
| const totalRotation = currentRotation + angle; |
|
|
| if (totalRotation % 90 === 0) { |
| const [copiedPage] = await newPdfDoc.copyPages(srcDoc, [i]); |
| copiedPage.setRotation(degrees(totalRotation)); |
| newPdfDoc.addPage(copiedPage); |
| } else { |
| const embeddedPage = await newPdfDoc.embedPage(originalPage); |
| const { width, height } = embeddedPage.scale(1); |
| const angleRad = (totalRotation * Math.PI) / 180; |
| const absCos = Math.abs(Math.cos(angleRad)); |
| const absSin = Math.abs(Math.sin(angleRad)); |
| const newWidth = width * absCos + height * absSin; |
| const newHeight = width * absSin + height * absCos; |
| const newPage = newPdfDoc.addPage([newWidth, newHeight]); |
| const x = |
| newWidth / 2 - |
| ((width / 2) * Math.cos(angleRad) - (height / 2) * Math.sin(angleRad)); |
| const y = |
| newHeight / 2 - |
| ((width / 2) * Math.sin(angleRad) + (height / 2) * Math.cos(angleRad)); |
| newPage.drawPage(embeddedPage, { |
| x, |
| y, |
| width, |
| height, |
| rotate: degrees(totalRotation), |
| }); |
| } |
| } |
|
|
| return new Uint8Array(await newPdfDoc.save()); |
| } |
|
|
| export async function rotatePdfPages( |
| pdfBytes: Uint8Array, |
| rotations: number[] |
| ): Promise<Uint8Array> { |
| const srcDoc = await PDFDocument.load(pdfBytes); |
| const newPdfDoc = await PDFDocument.create(); |
| const pageCount = srcDoc.getPageCount(); |
|
|
| for (let i = 0; i < pageCount; i++) { |
| const rotation = rotations[i] || 0; |
| const originalPage = srcDoc.getPage(i); |
| const currentRotation = originalPage.getRotation().angle; |
| const totalRotation = currentRotation + rotation; |
|
|
| if (totalRotation % 90 === 0) { |
| const [copiedPage] = await newPdfDoc.copyPages(srcDoc, [i]); |
| copiedPage.setRotation(degrees(totalRotation)); |
| newPdfDoc.addPage(copiedPage); |
| } else { |
| const embeddedPage = await newPdfDoc.embedPage(originalPage); |
| const { width, height } = embeddedPage.scale(1); |
| const angleRad = (totalRotation * Math.PI) / 180; |
| const absCos = Math.abs(Math.cos(angleRad)); |
| const absSin = Math.abs(Math.sin(angleRad)); |
| const newWidth = width * absCos + height * absSin; |
| const newHeight = width * absSin + height * absCos; |
| const newPage = newPdfDoc.addPage([newWidth, newHeight]); |
| const x = |
| newWidth / 2 - |
| ((width / 2) * Math.cos(angleRad) - (height / 2) * Math.sin(angleRad)); |
| const y = |
| newHeight / 2 - |
| ((width / 2) * Math.sin(angleRad) + (height / 2) * Math.cos(angleRad)); |
| newPage.drawPage(embeddedPage, { |
| x, |
| y, |
| width, |
| height, |
| rotate: degrees(totalRotation), |
| }); |
| } |
| } |
|
|
| return new Uint8Array(await newPdfDoc.save()); |
| } |
|
|
| export async function deletePdfPages( |
| pdfBytes: Uint8Array, |
| pagesToDelete: Set<number> |
| ): Promise<Uint8Array> { |
| const srcDoc = await PDFDocument.load(pdfBytes); |
| const totalPages = srcDoc.getPageCount(); |
|
|
| const pagesToKeep: number[] = []; |
| for (let i = 0; i < totalPages; i++) { |
| if (!pagesToDelete.has(i + 1)) { |
| pagesToKeep.push(i); |
| } |
| } |
|
|
| if (pagesToKeep.length === 0) throw new Error('Cannot delete all pages'); |
|
|
| const newPdf = await PDFDocument.create(); |
| const copiedPages = await newPdf.copyPages(srcDoc, pagesToKeep); |
| copiedPages.forEach((page) => newPdf.addPage(page)); |
| return new Uint8Array(await newPdf.save()); |
| } |
|
|
| export function parsePageRange(rangeStr: string, totalPages: number): number[] { |
| const indices: Set<number> = new Set(); |
| const parts = rangeStr.split(',').map((s) => s.trim()); |
|
|
| for (const part of parts) { |
| if (part.includes('-')) { |
| const [startStr, endStr] = part.split('-'); |
| const start = Math.max(1, parseInt(startStr, 10) || 1); |
| const end = Math.min(totalPages, parseInt(endStr, 10) || totalPages); |
| for (let i = start; i <= end; i++) { |
| indices.add(i - 1); |
| } |
| } else { |
| const page = parseInt(part, 10); |
| if (page >= 1 && page <= totalPages) { |
| indices.add(page - 1); |
| } |
| } |
| } |
|
|
| return Array.from(indices).sort((a, b) => a - b); |
| } |
|
|
| export function parseDeletePages(str: string, totalPages: number): Set<number> { |
| const pages = new Set<number>(); |
| const parts = str.split(',').map((s) => s.trim()); |
|
|
| for (const part of parts) { |
| if (part.includes('-')) { |
| const [startStr, endStr] = part.split('-'); |
| const start = Math.max(1, parseInt(startStr, 10) || 1); |
| const end = Math.min(totalPages, parseInt(endStr, 10) || totalPages); |
| for (let i = start; i <= end; i++) pages.add(i); |
| } else { |
| const page = parseInt(part, 10); |
| if (page >= 1 && page <= totalPages) pages.add(page); |
| } |
| } |
|
|
| return pages; |
| } |
|
|
| export interface TextWatermarkOptions { |
| text: string; |
| fontSize: number; |
| color: { r: number; g: number; b: number }; |
| opacity: number; |
| angle: number; |
| } |
|
|
| export async function addTextWatermark( |
| pdfBytes: Uint8Array, |
| options: TextWatermarkOptions |
| ): Promise<Uint8Array> { |
| const pdfDoc = await PDFDocument.load(pdfBytes); |
| const font = await pdfDoc.embedFont(StandardFonts.Helvetica); |
| const pages = pdfDoc.getPages(); |
|
|
| for (const page of pages) { |
| const { width, height } = page.getSize(); |
| const textWidth = font.widthOfTextAtSize(options.text, options.fontSize); |
|
|
| page.drawText(options.text, { |
| x: (width - textWidth) / 2, |
| y: height / 2, |
| font, |
| size: options.fontSize, |
| color: rgb(options.color.r, options.color.g, options.color.b), |
| opacity: options.opacity, |
| rotate: degrees(options.angle), |
| }); |
| } |
|
|
| return new Uint8Array(await pdfDoc.save()); |
| } |
|
|
| export interface ImageWatermarkOptions { |
| imageBytes: Uint8Array; |
| imageType: 'png' | 'jpg'; |
| opacity: number; |
| angle: number; |
| scale: number; |
| } |
|
|
| export async function addImageWatermark( |
| pdfBytes: Uint8Array, |
| options: ImageWatermarkOptions |
| ): Promise<Uint8Array> { |
| const pdfDoc = await PDFDocument.load(pdfBytes); |
| const image = |
| options.imageType === 'png' |
| ? await pdfDoc.embedPng(options.imageBytes) |
| : await pdfDoc.embedJpg(options.imageBytes); |
| const pages = pdfDoc.getPages(); |
|
|
| for (const page of pages) { |
| const { width, height } = page.getSize(); |
| const imgWidth = image.width * options.scale; |
| const imgHeight = image.height * options.scale; |
|
|
| page.drawImage(image, { |
| x: (width - imgWidth) / 2, |
| y: (height - imgHeight) / 2, |
| width: imgWidth, |
| height: imgHeight, |
| opacity: options.opacity, |
| rotate: degrees(options.angle), |
| }); |
| } |
|
|
| return new Uint8Array(await pdfDoc.save()); |
| } |
|
|
| export type PageNumberPosition = |
| | 'bottom-center' |
| | 'bottom-left' |
| | 'bottom-right' |
| | 'top-center' |
| | 'top-left' |
| | 'top-right'; |
| export type PageNumberFormat = 'simple' | 'page_x_of_y'; |
|
|
| export interface PageNumberOptions { |
| position: PageNumberPosition; |
| fontSize: number; |
| format: PageNumberFormat; |
| color: { r: number; g: number; b: number }; |
| } |
|
|
| export async function addPageNumbers( |
| pdfBytes: Uint8Array, |
| options: PageNumberOptions |
| ): Promise<Uint8Array> { |
| const pdfDoc = await PDFDocument.load(pdfBytes); |
| const helveticaFont = await pdfDoc.embedFont(StandardFonts.Helvetica); |
| const pages = pdfDoc.getPages(); |
| const totalPages = pages.length; |
|
|
| for (let i = 0; i < totalPages; i++) { |
| const page = pages[i]; |
| const mediaBox = page.getMediaBox(); |
| const cropBox = page.getCropBox(); |
| const bounds = cropBox || mediaBox; |
| const width = bounds.width; |
| const height = bounds.height; |
| const xOffset = bounds.x || 0; |
| const yOffset = bounds.y || 0; |
|
|
| const pageNumText = |
| options.format === 'page_x_of_y' |
| ? `${i + 1} / ${totalPages}` |
| : `${i + 1}`; |
|
|
| const textWidth = helveticaFont.widthOfTextAtSize( |
| pageNumText, |
| options.fontSize |
| ); |
| const textHeight = options.fontSize; |
|
|
| const minMargin = 8; |
| const maxMargin = 40; |
| const marginPercentage = 0.04; |
|
|
| const horizontalMargin = Math.max( |
| minMargin, |
| Math.min(maxMargin, width * marginPercentage) |
| ); |
| const verticalMargin = Math.max( |
| minMargin, |
| Math.min(maxMargin, height * marginPercentage) |
| ); |
|
|
| const safeHorizontalMargin = Math.max(horizontalMargin, textWidth / 2 + 3); |
| const safeVerticalMargin = Math.max(verticalMargin, textHeight + 3); |
|
|
| let x = 0, |
| y = 0; |
|
|
| switch (options.position) { |
| case 'bottom-center': |
| x = |
| Math.max( |
| safeHorizontalMargin, |
| Math.min( |
| width - safeHorizontalMargin - textWidth, |
| (width - textWidth) / 2 |
| ) |
| ) + xOffset; |
| y = safeVerticalMargin + yOffset; |
| break; |
| case 'bottom-left': |
| x = safeHorizontalMargin + xOffset; |
| y = safeVerticalMargin + yOffset; |
| break; |
| case 'bottom-right': |
| x = |
| Math.max( |
| safeHorizontalMargin, |
| width - safeHorizontalMargin - textWidth |
| ) + xOffset; |
| y = safeVerticalMargin + yOffset; |
| break; |
| case 'top-center': |
| x = |
| Math.max( |
| safeHorizontalMargin, |
| Math.min( |
| width - safeHorizontalMargin - textWidth, |
| (width - textWidth) / 2 |
| ) |
| ) + xOffset; |
| y = height - safeVerticalMargin - textHeight + yOffset; |
| break; |
| case 'top-left': |
| x = safeHorizontalMargin + xOffset; |
| y = height - safeVerticalMargin - textHeight + yOffset; |
| break; |
| case 'top-right': |
| x = |
| Math.max( |
| safeHorizontalMargin, |
| width - safeHorizontalMargin - textWidth |
| ) + xOffset; |
| y = height - safeVerticalMargin - textHeight + yOffset; |
| break; |
| } |
|
|
| x = Math.max(xOffset + 3, Math.min(xOffset + width - textWidth - 3, x)); |
| y = Math.max(yOffset + 3, Math.min(yOffset + height - textHeight - 3, y)); |
|
|
| page.drawText(pageNumText, { |
| x, |
| y, |
| font: helveticaFont, |
| size: options.fontSize, |
| color: rgb(options.color.r, options.color.g, options.color.b), |
| }); |
| } |
|
|
| return new Uint8Array(await pdfDoc.save()); |
| } |
|
|
