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

package/dist/index.d.mts

@@ -238,15 +238,34 @@ declare function createPdfBlobUrl(pdfBytes: Uint8Array): string;
  */
 declare function downloadPdf(pdfBytes: Uint8Array, filename: string): void;
 
-declare class PdfPasswordRequiredError extends Error {
+interface PdfPasswordRequiredErrorConstructor {
+    new (): PdfPasswordRequiredError;
+    readonly prototype: PdfPasswordRequiredError;
+}
+/**
+ * Thrown when the PDF needs a non-empty user password, which this package
+ * cannot supply. Match it with {@link isPdfPasswordRequiredError} rather than
+ * `instanceof` — see the header note on copies.
+ */
+interface PdfPasswordRequiredError extends Error {
+    /** Always `'PDF_PASSWORD_REQUIRED'`. The check that survives package boundaries. */
     code: string;
     recoverable: boolean;
     userMessage: string;
-    constructor();
 }
-declare class UnsupportedPdfEncryptionError extends Error {
-    constructor(detail: string);
+declare const PdfPasswordRequiredError: PdfPasswordRequiredErrorConstructor;
+interface UnsupportedPdfEncryptionErrorConstructor {
+    new (detail: string): UnsupportedPdfEncryptionError;
+    readonly prototype: UnsupportedPdfEncryptionError;
+}
+/** Thrown for security handlers this decryptor does not implement. */
+interface UnsupportedPdfEncryptionError extends Error {
+    /** Always `'UnsupportedPdfEncryptionError'`. */
+    name: string;
+    /** The scheme that is not supported, e.g. `'V5 /R6'`. */
+    readonly detail: string;
 }
+declare const UnsupportedPdfEncryptionError: UnsupportedPdfEncryptionErrorConstructor;
 /**
  * Decrypt an encrypted PDF that opens with an empty user password.
  * Returns re-saved, fully decrypted bytes with `/Encrypt` removed.
@@ -254,11 +273,15 @@ declare class UnsupportedPdfEncryptionError extends Error {
  * @throws {PdfPasswordRequiredError} when a non-empty password is required
  * @throws {UnsupportedPdfEncryptionError} for non-standard security handlers
  */
-declare function decryptPdf(pdfBytes: Uint8Array): Promise<Uint8Array>;
+declare const decryptPdf: (pdfBytes: Uint8Array) => Promise<Uint8Array>;
 /**
- * Ingestion gate: returns the bytes untouched for regular PDFs, and a
- * decrypted re-save for encrypted ones so every downstream `PDFDocument.load`
- * (page assembly, field extraction) sees a normal document.
+ * Ingestion gate — see `@signiphi/pdf-crypto`'s `normalizePdfEncryption`.
+ * Returns the bytes untouched (same reference) for ordinary PDFs; decrypts and
+ * re-saves encrypted ones so every downstream `PDFDocument.load` (page
+ * assembly, field extraction) sees a normal document.
+ *
+ * @throws {PdfPasswordRequiredError} when a non-empty password is required
+ * @throws {UnsupportedPdfEncryptionError} for non-standard security handlers
  */
 declare function normalizePdfEncryption(pdfBytes: Uint8Array): Promise<Uint8Array>;
 

package/dist/index.d.ts

@@ -238,15 +238,34 @@ declare function createPdfBlobUrl(pdfBytes: Uint8Array): string;
  */
 declare function downloadPdf(pdfBytes: Uint8Array, filename: string): void;
 
-declare class PdfPasswordRequiredError extends Error {
+interface PdfPasswordRequiredErrorConstructor {
+    new (): PdfPasswordRequiredError;
+    readonly prototype: PdfPasswordRequiredError;
+}
+/**
+ * Thrown when the PDF needs a non-empty user password, which this package
+ * cannot supply. Match it with {@link isPdfPasswordRequiredError} rather than
+ * `instanceof` — see the header note on copies.
+ */
+interface PdfPasswordRequiredError extends Error {
+    /** Always `'PDF_PASSWORD_REQUIRED'`. The check that survives package boundaries. */
     code: string;
     recoverable: boolean;
     userMessage: string;
-    constructor();
 }
-declare class UnsupportedPdfEncryptionError extends Error {
-    constructor(detail: string);
+declare const PdfPasswordRequiredError: PdfPasswordRequiredErrorConstructor;
+interface UnsupportedPdfEncryptionErrorConstructor {
+    new (detail: string): UnsupportedPdfEncryptionError;
+    readonly prototype: UnsupportedPdfEncryptionError;
+}
+/** Thrown for security handlers this decryptor does not implement. */
+interface UnsupportedPdfEncryptionError extends Error {
+    /** Always `'UnsupportedPdfEncryptionError'`. */
+    name: string;
+    /** The scheme that is not supported, e.g. `'V5 /R6'`. */
+    readonly detail: string;
 }
+declare const UnsupportedPdfEncryptionError: UnsupportedPdfEncryptionErrorConstructor;
 /**
  * Decrypt an encrypted PDF that opens with an empty user password.
  * Returns re-saved, fully decrypted bytes with `/Encrypt` removed.
@@ -254,11 +273,15 @@ declare class UnsupportedPdfEncryptionError extends Error {
  * @throws {PdfPasswordRequiredError} when a non-empty password is required
  * @throws {UnsupportedPdfEncryptionError} for non-standard security handlers
  */
-declare function decryptPdf(pdfBytes: Uint8Array): Promise<Uint8Array>;
+declare const decryptPdf: (pdfBytes: Uint8Array) => Promise<Uint8Array>;
 /**
- * Ingestion gate: returns the bytes untouched for regular PDFs, and a
- * decrypted re-save for encrypted ones so every downstream `PDFDocument.load`
- * (page assembly, field extraction) sees a normal document.
+ * Ingestion gate — see `@signiphi/pdf-crypto`'s `normalizePdfEncryption`.
+ * Returns the bytes untouched (same reference) for ordinary PDFs; decrypts and
+ * re-saves encrypted ones so every downstream `PDFDocument.load` (page
+ * assembly, field extraction) sees a normal document.
+ *
+ * @throws {PdfPasswordRequiredError} when a non-empty password is required
+ * @throws {UnsupportedPdfEncryptionError} for non-standard security handlers
  */
 declare function normalizePdfEncryption(pdfBytes: Uint8Array): Promise<Uint8Array>;
 

package/dist/index.js

@@ -43,9 +43,7 @@ var DropdownMenuPrimitive__namespace = /*#__PURE__*/_interopNamespace(DropdownMe
 var TooltipPrimitive__namespace = /*#__PURE__*/_interopNamespace(TooltipPrimitive);
 var pdfjsLib__namespace = /*#__PURE__*/_interopNamespace(pdfjsLib);
 
-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 tailwindMerge.twMerge(clsx.clsx(inputs));
 }
@@ -580,9 +578,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;
   }
@@ -591,6 +588,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) {
@@ -1128,30 +1126,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 pdfLib.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__namespace.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
@@ -1243,7 +1281,7 @@ async function rasterizePdfToPdf(pdfBytes) {
     sourceDoc = await pdfjsLib__namespace.getDocument({ data: pdfBytes.slice(0), verbosity: 0 }).promise;
   } catch (error) {
     if (error?.name === "PasswordException") {
-      throw new PdfPasswordRequiredError();
+      throw new PdfPasswordRequiredError2();
     }
     throw error;
   }
@@ -1275,10 +1313,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
@@ -1403,11 +1441,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;
@@ -2751,7 +2795,7 @@ var PageAssembler = React7.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.`);
@@ -3336,17 +3380,17 @@ function debounce(func, wait) {
 exports.Button = Button;
 exports.FormFieldType = FormFieldType;
 exports.PageAssembler = PageAssembler;
-exports.PdfPasswordRequiredError = PdfPasswordRequiredError;
-exports.UnsupportedPdfEncryptionError = UnsupportedPdfEncryptionError;
+exports.PdfPasswordRequiredError = PdfPasswordRequiredError2;
+exports.UnsupportedPdfEncryptionError = UnsupportedPdfEncryptionError2;
 exports.addFormFieldsToPdf = addFormFieldsToPdf;
 exports.createPdfBlobUrl = createPdfBlobUrl;
-exports.decryptPdf = decryptPdf;
+exports.decryptPdf = decryptPdf2;
 exports.downloadPdf = downloadPdf;
 exports.extractFieldsFromPdf = extractFieldsFromPdf;
 exports.getSigniphiMetadata = getSigniphiMetadata;
 exports.imageToPdf = imageToPdf;
 exports.mapFieldPositionsAfterAssembly = mapFieldPositionsAfterAssembly;
-exports.normalizePdfEncryption = normalizePdfEncryption;
+exports.normalizePdfEncryption = normalizePdfEncryption2;
 exports.normalizeUploadedPdfBytes = normalizeUploadedPdfBytes;
 exports.pdfToImages = pdfToImages;
 exports.rasterizePdfToPdf = rasterizePdfToPdf;