@signiphi/page-assembly 0.2.0-beta.10 → 0.2.0-beta.12

package/dist/index.mjs

@@ -16,9 +16,7 @@ import * as TooltipPrimitive from '@radix-ui/react-tooltip';
 import * as pdfjsLib from 'pdfjs-dist';
 import { PDFDocument, PDFTextField, PDFCheckBox, PDFDropdown, PDFRadioGroup, StandardFonts, rgb, PDFName, PDFString, PDFDict, PDFArray, PDFHexString, PDFInvalidObject, PDFObjectParser, PDFRawStream, PDFObjectStreamParser, PDFRef, PDFBool, PDFNumber } from 'pdf-lib';
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+// src/components/PageAssembler.tsx
 function cn(...inputs) {
   return twMerge(clsx(inputs));
 }
@@ -553,9 +551,8 @@ var PdfPasswordRequiredError = class extends Error {
   constructor() {
     const message = "This PDF is password-protected. Please remove the password and upload it again.";
     super(message);
-    __publicField(this, "code", "PDF_PASSWORD_REQUIRED");
-    __publicField(this, "recoverable", true);
-    __publicField(this, "userMessage");
+    this.code = "PDF_PASSWORD_REQUIRED";
+    this.recoverable = true;
     this.name = "PdfPasswordRequiredError";
     this.userMessage = message;
   }
@@ -564,6 +561,7 @@ var UnsupportedPdfEncryptionError = class extends Error {
   constructor(detail) {
     super(`This PDF uses an unsupported encryption scheme (${detail}).`);
     this.name = "UnsupportedPdfEncryptionError";
+    this.detail = detail;
   }
 };
 function concatBytes(...parts) {
@@ -1101,30 +1099,70 @@ async function decryptPdf(pdfBytes) {
   if (!doc.isEncrypted) return pdfBytes;
   return decryptLoadedDocument(doc);
 }
-var ENCRYPT_MARKER = new Uint8Array([47, 69, 110, 99, 114, 121, 112, 116]);
-function containsEncryptMarker(bytes) {
-  const last = bytes.length - ENCRYPT_MARKER.length;
-  outer: for (let i = 0; i <= last; i++) {
-    for (let j = 0; j < ENCRYPT_MARKER.length; j++) {
-      if (bytes[i + j] !== ENCRYPT_MARKER[j]) continue outer;
+var SLASH = 47;
+var HASH = 35;
+var ENCRYPT_NAME = "Encrypt";
+function hexDigit(byte) {
+  if (byte === void 0) return -1;
+  if (byte >= 48 && byte <= 57) return byte - 48;
+  if (byte >= 65 && byte <= 70) return byte - 65 + 10;
+  if (byte >= 97 && byte <= 102) return byte - 97 + 10;
+  return -1;
+}
+function matchesEncryptNameAt(bytes, start) {
+  let at = start;
+  for (let k = 0; k < ENCRYPT_NAME.length; k++) {
+    const want = ENCRYPT_NAME.charCodeAt(k);
+    const byte = bytes[at];
+    if (byte === want) {
+      at += 1;
+      continue;
     }
-    return true;
+    if (byte === HASH) {
+      const high = hexDigit(bytes[at + 1]);
+      const low = hexDigit(bytes[at + 2]);
+      if (high >= 0 && low >= 0 && (high << 4 | low) === want) {
+        at += 3;
+        continue;
+      }
+    }
+    return false;
+  }
+  return true;
+}
+function containsEncryptMarker(bytes) {
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] !== SLASH) continue;
+    if (matchesEncryptNameAt(bytes, i + 1)) return true;
   }
   return false;
 }
-async function normalizePdfEncryption(pdfBytes) {
+async function normalizePdfEncryption(pdfBytes, options) {
   if (!containsEncryptMarker(pdfBytes)) return pdfBytes;
   const doc = await PDFDocument.load(pdfBytes.slice(), {
     ignoreEncryption: true,
     updateMetadata: false
   });
   if (!doc.isEncrypted) return pdfBytes;
-  if (typeof process === "undefined" || process.env?.NODE_ENV !== "production") {
-    console.info("[PageAssembler] Encrypted PDF detected during ingestion; decrypting");
-  }
+  options?.logger?.info("[PDF_DECRYPT] Encrypted PDF detected during ingestion; decrypting");
   return decryptLoadedDocument(doc);
 }
 
+// src/utils/pdf-decrypt.ts
+var PdfPasswordRequiredError2 = PdfPasswordRequiredError;
+var UnsupportedPdfEncryptionError2 = UnsupportedPdfEncryptionError;
+var decryptPdf2 = decryptPdf;
+var consoleLogger = {
+  info(message, ...args) {
+    if (typeof process === "undefined" || process.env?.NODE_ENV !== "production") {
+      console.info(`[PageAssembler] ${message}`, ...args);
+    }
+  }
+};
+function normalizePdfEncryption2(pdfBytes) {
+  return normalizePdfEncryption(pdfBytes, { logger: consoleLogger });
+}
+
 // src/utils/pdf-helpers.ts
 if (typeof window !== "undefined") {
   pdfjsLib.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
@@ -1216,7 +1254,7 @@ async function rasterizePdfToPdf(pdfBytes) {
     sourceDoc = await pdfjsLib.getDocument({ data: pdfBytes.slice(0), verbosity: 0 }).promise;
   } catch (error) {
     if (error?.name === "PasswordException") {
-      throw new PdfPasswordRequiredError();
+      throw new PdfPasswordRequiredError2();
     }
     throw error;
   }
@@ -1248,10 +1286,10 @@ async function rasterizePdfToPdf(pdfBytes) {
 }
 async function normalizeUploadedPdfBytes(pdfBytes) {
   try {
-    const normalized = await normalizePdfEncryption(pdfBytes);
+    const normalized = await normalizePdfEncryption2(pdfBytes);
     return normalized === pdfBytes ? pdfBytes : new Uint8Array(normalized);
   } catch (error) {
-    if (error instanceof PdfPasswordRequiredError) throw error;
+    if (error instanceof PdfPasswordRequiredError2) throw error;
     console.warn(
       "[PageAssembler] Structural decryption failed; rebuilding document from rendered pages:",
       error
@@ -1376,11 +1414,17 @@ function getBaseFieldName(encodedName) {
   }
   return baseName;
 }
+function stripFieldTypeSuffix(value) {
+  const stripped = value.replace(/_(signature|initials|date)$/i, "");
+  return stripped || value;
+}
 function getSignerFromFieldName(encodedName) {
   if (encodedName.includes("__SIGNER__")) {
     const parts = encodedName.split("__SIGNER__");
     if (parts[1]) {
-      return parts[1].split("__")[0] || parts[1];
+      const segment = parts[1].split("__")[0] || parts[1];
+      const isTerminal = segment === parts[1];
+      return isTerminal ? stripFieldTypeSuffix(segment) : segment;
     }
   }
   return void 0;
@@ -2724,7 +2768,7 @@ var PageAssembler = forwardRef(
           dispatch({ type: "ADD_FILE", payload: fileInfo });
         } catch (error) {
           console.error(`Error processing file ${file.name}:`, error);
-          if (error instanceof PdfPasswordRequiredError) {
+          if (error instanceof PdfPasswordRequiredError2) {
             setUploadError(`${file.name}: ${error.userMessage}`);
           } else {
             setUploadError(`Failed to process "${file.name}". The file may be corrupted or unsupported.`);
@@ -3306,6 +3350,6 @@ function debounce(func, wait) {
   });
 }
 
-export { Button, FormFieldType, PageAssembler, PdfPasswordRequiredError, UnsupportedPdfEncryptionError, addFormFieldsToPdf, createPdfBlobUrl, decryptPdf, downloadPdf, extractFieldsFromPdf, getSigniphiMetadata, imageToPdf, mapFieldPositionsAfterAssembly, normalizePdfEncryption, normalizeUploadedPdfBytes, pdfToImages, rasterizePdfToPdf, setSigniphiMetadata };
+export { Button, FormFieldType, PageAssembler, PdfPasswordRequiredError2 as PdfPasswordRequiredError, UnsupportedPdfEncryptionError2 as UnsupportedPdfEncryptionError, addFormFieldsToPdf, createPdfBlobUrl, decryptPdf2 as decryptPdf, downloadPdf, extractFieldsFromPdf, getSigniphiMetadata, imageToPdf, mapFieldPositionsAfterAssembly, normalizePdfEncryption2 as normalizePdfEncryption, normalizeUploadedPdfBytes, pdfToImages, rasterizePdfToPdf, setSigniphiMetadata };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map