@signiphi/page-assembly 0.2.0-beta.2 → 0.2.0-beta.4

package/dist/index.js

@@ -722,6 +722,580 @@ function downloadPdf(pdfBytes, filename) {
   a.click();
   URL.revokeObjectURL(url);
 }
+function getSigniphiMetadata(pdfDoc) {
+  try {
+    const infoRef = pdfDoc.context.trailerInfo.Info;
+    if (!infoRef) {
+      return null;
+    }
+    const infoObj = pdfDoc.context.lookup(infoRef);
+    if (!infoObj || typeof infoObj.get !== "function") {
+      return null;
+    }
+    const infoDict = infoObj;
+    const metadataObj = infoDict.get(pdfLib.PDFName.of("SigniphiMetadata"));
+    if (!metadataObj) {
+      return null;
+    }
+    const metadataStr = metadataObj.toString();
+    let jsonStr = metadataStr;
+    if (metadataStr.startsWith("(") && metadataStr.endsWith(")")) {
+      jsonStr = metadataStr.slice(1, -1);
+    } else if (metadataStr.startsWith("<") && metadataStr.endsWith(">")) {
+      jsonStr = metadataStr.slice(1, -1);
+    }
+    const metadata = JSON.parse(jsonStr);
+    return metadata;
+  } catch (error) {
+    console.error("Failed to load Signiphi metadata:", error);
+    return null;
+  }
+}
+function getBaseFieldName(encodedName) {
+  let baseName = encodedName;
+  if (baseName.includes("__SIGNER__")) {
+    baseName = baseName.split("__SIGNER__")[0];
+  }
+  if (baseName.includes("__LABEL__")) {
+    baseName = baseName.split("__LABEL__")[0];
+  }
+  if (baseName.includes("__PLACEHOLDER__")) {
+    baseName = baseName.split("__PLACEHOLDER__")[0];
+  }
+  return baseName;
+}
+function getSignerFromFieldName(encodedName) {
+  if (encodedName.includes("__SIGNER__")) {
+    const parts = encodedName.split("__SIGNER__");
+    if (parts[1]) {
+      return parts[1].split("__")[0] || parts[1];
+    }
+  }
+  return void 0;
+}
+function determineFieldType(fieldName, widgetType) {
+  const baseName = getBaseFieldName(fieldName);
+  const nameLower = baseName.toLowerCase();
+  if (nameLower.includes("_signature") || nameLower.includes("signature")) {
+    return "signature";
+  }
+  if (nameLower.includes("_initials") || nameLower.includes("initials")) {
+    return "initials";
+  }
+  if (nameLower.includes("_date") || nameLower.includes("date")) {
+    return "date";
+  }
+  if (widgetType === "checkbox" || nameLower.includes("checkbox")) {
+    return "checkbox";
+  }
+  if (widgetType === "radio" || nameLower.includes("radio")) {
+    return "radio";
+  }
+  if (widgetType === "dropdown" || widgetType === "select" || nameLower.includes("dropdown")) {
+    return "dropdown";
+  }
+  return "text";
+}
+async function extractFieldsFromPdf(pdfBytes) {
+  const pdfDoc = await pdfLib.PDFDocument.load(pdfBytes);
+  const fields = [];
+  const metadata = getSigniphiMetadata(pdfDoc);
+  const form = pdfDoc.getForm();
+  const pdfFields = form.getFields();
+  for (const field of pdfFields) {
+    const fieldName = field.getName();
+    const widgets = field.acroField.getWidgets();
+    const baseName = getBaseFieldName(fieldName);
+    const signerFromName = getSignerFromFieldName(fieldName);
+    let required = false;
+    let options;
+    let widgetType;
+    if (field instanceof pdfLib.PDFTextField) {
+      required = field.isRequired();
+      console.log(`[field-extraction] PDFTextField "${fieldName}" isRequired=${required}`);
+    } else if (field instanceof pdfLib.PDFCheckBox) {
+      widgetType = "checkbox";
+      required = field.isRequired();
+      console.log(`[field-extraction] PDFCheckBox "${fieldName}" isRequired=${required}`);
+    } else if (field instanceof pdfLib.PDFDropdown) {
+      widgetType = "dropdown";
+      required = field.isRequired();
+      options = field.getOptions();
+      console.log(`[field-extraction] PDFDropdown "${fieldName}" isRequired=${required}`);
+    } else if (field instanceof pdfLib.PDFRadioGroup) {
+      widgetType = "radio";
+      required = field.isRequired();
+      options = field.getOptions();
+      console.log(`[field-extraction] PDFRadioGroup "${fieldName}" isRequired=${required}`);
+    } else {
+      console.log(`[field-extraction] Unknown field type "${fieldName}" - defaulting required=false`);
+    }
+    for (const widget of widgets) {
+      const rect = widget.getRectangle();
+      const pageRef = widget.P();
+      let pageNumber = 1;
+      if (pageRef) {
+        const pages = pdfDoc.getPages();
+        for (let i = 0; i < pages.length; i++) {
+          if (pages[i].ref === pageRef) {
+            pageNumber = i + 1;
+            break;
+          }
+        }
+      }
+      const pageQualifiedKey = `${baseName}_p${pageNumber}`;
+      let fieldMetadata = metadata?.fields?.[pageQualifiedKey];
+      if (!fieldMetadata) {
+        fieldMetadata = metadata?.fields?.[fieldName];
+      }
+      if (!fieldMetadata && baseName !== fieldName) {
+        fieldMetadata = metadata?.fields?.[baseName];
+      }
+      let fieldRequired = required;
+      let fieldOptions = options;
+      if (fieldMetadata?.required !== void 0) {
+        fieldRequired = fieldMetadata.required;
+      }
+      if (fieldMetadata?.options?.length) {
+        fieldOptions = fieldMetadata.options;
+      }
+      const page = pdfDoc.getPage(pageNumber - 1);
+      const pageHeight = page.getHeight();
+      const extractedField = {
+        name: baseName,
+        // Use clean base name without __SIGNER__ encoding (signer stored in signer property)
+        type: determineFieldType(fieldName, widgetType),
+        // Uses base name internally
+        page: pageNumber,
+        x: rect.x,
+        y: pageHeight - rect.y - rect.height,
+        // Convert from PDF coords (bottom-left) to top-left
+        width: rect.width,
+        height: rect.height,
+        required: fieldRequired,
+        options: fieldOptions,
+        signer: signerFromName
+        // Extract signer from encoded name
+      };
+      if (fieldMetadata) {
+        if (fieldMetadata.fieldId) {
+          extractedField.fieldId = fieldMetadata.fieldId;
+        }
+        if (fieldMetadata.label) {
+          extractedField.label = fieldMetadata.label;
+        }
+        if (!extractedField.signer && fieldMetadata.signer) {
+          extractedField.signer = fieldMetadata.signer;
+        }
+        if (fieldMetadata.placeholder) {
+          extractedField.placeholder = fieldMetadata.placeholder;
+        }
+      }
+      fields.push(extractedField);
+    }
+  }
+  const deduplicatedFields = fields.reduce((acc, field) => {
+    const newBaseName = getBaseFieldName(field.name);
+    const existingIndex = acc.findIndex((f) => {
+      const existingBaseName = getBaseFieldName(f.name);
+      return existingBaseName === newBaseName && f.page === field.page;
+    });
+    if (existingIndex === -1) {
+      acc.push(field);
+    } else {
+      const existing = acc[existingIndex];
+      acc[existingIndex] = {
+        ...existing,
+        // Prefer non-empty values from either field
+        label: existing.label || field.label,
+        placeholder: existing.placeholder || field.placeholder,
+        required: existing.required || field.required,
+        options: existing.options?.length ? existing.options : field.options,
+        fieldId: existing.fieldId || field.fieldId,
+        // Prefer signer from the field that has it
+        signer: existing.signer || field.signer
+      };
+    }
+    return acc;
+  }, []);
+  return deduplicatedFields;
+}
+function setSigniphiMetadata(pdfDoc, metadata) {
+  try {
+    const infoRef = pdfDoc.context.trailerInfo.Info;
+    const infoObj = pdfDoc.context.lookup(infoRef);
+    if (!infoObj || typeof infoObj.set !== "function") {
+      throw new Error("Info object is not a PDFDict or does not have set method");
+    }
+    const infoDict = infoObj;
+    const metadataString = JSON.stringify(metadata);
+    infoDict.set(pdfLib.PDFName.of("SigniphiMetadata"), pdfLib.PDFString.of(metadataString));
+  } catch (error) {
+    console.error("Failed to set Signiphi metadata:", error);
+    throw error;
+  }
+}
+var FormFieldType = /* @__PURE__ */ ((FormFieldType2) => {
+  FormFieldType2["TEXT"] = "text";
+  FormFieldType2["SIGNATURE"] = "signature";
+  FormFieldType2["INITIALS"] = "initials";
+  FormFieldType2["DATE"] = "date";
+  FormFieldType2["CHECKBOX"] = "checkbox";
+  FormFieldType2["RADIO"] = "radio";
+  FormFieldType2["DROPDOWN"] = "dropdown";
+  FormFieldType2["TEXT_LABEL"] = "text_label";
+  return FormFieldType2;
+})(FormFieldType || {});
+function parseEncodedFieldName(encodedName) {
+  let baseName = encodedName;
+  let label;
+  let signer;
+  if (baseName.includes("__SIGNER__")) {
+    const parts = baseName.split("__SIGNER__");
+    baseName = parts[0];
+    signer = parts[1];
+  }
+  if (baseName.includes("__LABEL__")) {
+    const parts = baseName.split("__LABEL__");
+    baseName = parts[0];
+    label = parts[1];
+  }
+  if (baseName.includes("__PLACEHOLDER__")) {
+    const parts = baseName.split("__PLACEHOLDER__");
+    baseName = parts[0];
+  }
+  return { baseName, label, signer };
+}
+function encodeFieldNameWithSigner(fieldName, signerEmail) {
+  const { baseName, signer: existingSigner } = parseEncodedFieldName(fieldName);
+  const finalSigner = existingSigner || signerEmail;
+  if (!finalSigner) return baseName;
+  return `${baseName}__SIGNER__${finalSigner}`;
+}
+function encodeFieldNameWithLabelAndSigner(fieldName, label, signerEmail) {
+  const { baseName, label: existingLabel, signer: existingSigner } = parseEncodedFieldName(fieldName);
+  const finalLabel = existingLabel || label;
+  const finalSigner = existingSigner || signerEmail;
+  let name = baseName;
+  if (finalLabel && finalLabel.trim()) {
+    name = `${name}__LABEL__${finalLabel.trim()}`;
+  }
+  if (finalSigner) {
+    name = `${name}__SIGNER__${finalSigner}`;
+  }
+  return name;
+}
+async function addFormFieldsToPdf(pdfBytes, formFields, options = {}) {
+  const { removeExistingFields = false, drawLabels = false } = options;
+  const pdfDoc = await pdfLib.PDFDocument.load(pdfBytes);
+  const form = pdfDoc.getForm();
+  const pages = pdfDoc.getPages();
+  if (removeExistingFields) {
+    const existingFields = form.getFields();
+    for (const field of existingFields) {
+      try {
+        const acroField = field.acroField;
+        if (acroField && typeof acroField.getWidgets === "function") {
+          let widgets = acroField.getWidgets();
+          let safetyCounter = 0;
+          const maxIterations = widgets.length + 5;
+          while (widgets.length > 0 && safetyCounter < maxIterations) {
+            try {
+              acroField.removeWidget(widgets.length - 1);
+              widgets = acroField.getWidgets();
+            } catch {
+              break;
+            }
+            safetyCounter++;
+          }
+        }
+        form.removeField(field);
+      } catch (error) {
+        console.warn(`Failed to remove field ${field.getName()}:`, error);
+        try {
+          form.removeField(field);
+        } catch {
+        }
+      }
+    }
+  }
+  const font = await pdfDoc.embedFont(pdfLib.StandardFonts.Helvetica);
+  const fieldNamePages = /* @__PURE__ */ new Map();
+  for (const field of formFields) {
+    const baseName = field.name;
+    if (!fieldNamePages.has(baseName)) {
+      fieldNamePages.set(baseName, /* @__PURE__ */ new Set());
+    }
+    fieldNamePages.get(baseName).add(field.position.page);
+  }
+  const conflictingNames = /* @__PURE__ */ new Set();
+  for (const [name, pages2] of fieldNamePages) {
+    if (pages2.size > 1) {
+      conflictingNames.add(name);
+    }
+  }
+  for (const field of formFields) {
+    const pageIndex = field.position.page - 1;
+    if (pageIndex < 0 || pageIndex >= pages.length) {
+      console.warn(`Field ${field.name} references page ${field.position.page} but PDF only has ${pages.length} pages`);
+      continue;
+    }
+    const page = pages[pageIndex];
+    const { height: pageHeight } = page.getSize();
+    const pdfX = field.position.x;
+    const pdfY = pageHeight - field.position.y - field.position.height;
+    const uniqueFieldName = conflictingNames.has(field.name) ? `${field.name}_p${field.position.page}` : field.name;
+    try {
+      const fieldType = typeof field.type === "string" ? field.type : field.type;
+      switch (fieldType) {
+        case "text" /* TEXT */:
+        case "text": {
+          const encodedName = encodeFieldNameWithSigner(uniqueFieldName, field.assignedSignerEmail);
+          const textField = form.createTextField(encodedName);
+          textField.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+            backgroundColor: pdfLib.rgb(1, 1, 1)
+          });
+          if (field.label && field.label.trim()) {
+            textField.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+            if (drawLabels) {
+              const fontSize = Math.min(10, field.position.height * 0.4);
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, { x: pdfX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+            }
+          }
+          if (field.defaultValue && field.defaultValue.trim()) {
+            textField.setText(field.defaultValue);
+          }
+          if (field.fontSize && field.fontSize >= 8 && field.fontSize <= 72) {
+            try {
+              textField.setFontSize(field.fontSize);
+            } catch {
+            }
+          }
+          if (field.multiline) {
+            try {
+              textField.enableMultiline();
+            } catch {
+            }
+          }
+          if (field.maxLength && field.maxLength > 0) {
+            try {
+              textField.setMaxLength(field.maxLength);
+            } catch {
+            }
+          }
+          if (field.required) {
+            textField.enableRequired();
+          }
+          break;
+        }
+        case "checkbox" /* CHECKBOX */:
+        case "checkbox": {
+          const encodedName = encodeFieldNameWithSigner(uniqueFieldName, field.assignedSignerEmail);
+          const checkBox = form.createCheckBox(encodedName);
+          checkBox.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+            backgroundColor: pdfLib.rgb(1, 1, 1)
+          });
+          if (field.defaultValue === "true" || field.defaultValue === "checked") {
+            checkBox.check();
+          }
+          if (field.required) {
+            checkBox.enableRequired();
+          }
+          if (field.label && field.label.trim()) {
+            try {
+              checkBox.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+            } catch {
+            }
+            if (drawLabels) {
+              const fontSize = Math.min(12, field.position.height * 0.6);
+              const labelX = pdfX + field.position.width + 5;
+              const labelY = pdfY + (field.position.height - fontSize) / 2;
+              page.drawText(field.label, { x: labelX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+            }
+          }
+          break;
+        }
+        case "signature" /* SIGNATURE */:
+        case "signature": {
+          const baseWithSuffix = field.name.endsWith("_signature") ? field.name : `${field.name}_signature`;
+          const finalName = conflictingNames.has(field.name) ? `${baseWithSuffix}_p${field.position.page}` : baseWithSuffix;
+          const encodedName = encodeFieldNameWithLabelAndSigner(finalName, field.label, field.assignedSignerEmail);
+          const sigField = form.createTextField(encodedName);
+          sigField.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0, 0, 1),
+            backgroundColor: pdfLib.rgb(0.9, 0.9, 1)
+          });
+          if (field.label && field.label.trim()) {
+            sigField.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+          }
+          sigField.enableReadOnly();
+          if (field.required) {
+            sigField.enableRequired();
+          }
+          break;
+        }
+        case "initials" /* INITIALS */:
+        case "initials": {
+          const baseWithSuffix = field.name.endsWith("_initials") ? field.name : `${field.name}_initials`;
+          const finalName = conflictingNames.has(field.name) ? `${baseWithSuffix}_p${field.position.page}` : baseWithSuffix;
+          const encodedName = encodeFieldNameWithLabelAndSigner(finalName, field.label, field.assignedSignerEmail);
+          const initField = form.createTextField(encodedName);
+          initField.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0.5, 0, 0.5),
+            backgroundColor: pdfLib.rgb(1, 0.95, 1)
+          });
+          if (field.label && field.label.trim()) {
+            initField.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+          }
+          initField.enableReadOnly();
+          if (field.required) {
+            initField.enableRequired();
+          }
+          break;
+        }
+        case "date" /* DATE */:
+        case "date": {
+          const baseWithSuffix = field.name.endsWith("_date") ? field.name : `${field.name}_date`;
+          const finalName = conflictingNames.has(field.name) ? `${baseWithSuffix}_p${field.position.page}` : baseWithSuffix;
+          const encodedName = encodeFieldNameWithLabelAndSigner(finalName, field.label, field.assignedSignerEmail);
+          const dateField = form.createTextField(encodedName);
+          dateField.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0, 0.5, 0),
+            backgroundColor: pdfLib.rgb(0.95, 1, 0.95)
+          });
+          if (field.label && field.label.trim()) {
+            dateField.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+          }
+          if (field.required) {
+            dateField.enableRequired();
+          }
+          break;
+        }
+        case "dropdown" /* DROPDOWN */:
+        case "dropdown": {
+          const encodedName = encodeFieldNameWithSigner(uniqueFieldName, field.assignedSignerEmail);
+          const dropdown = form.createDropdown(encodedName);
+          dropdown.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+            backgroundColor: pdfLib.rgb(1, 1, 1)
+          });
+          if (field.options && field.options.length > 0) {
+            dropdown.addOptions(field.options);
+            if (field.defaultValue && field.options.includes(field.defaultValue)) {
+              dropdown.select(field.defaultValue);
+            }
+          }
+          if (field.label && field.label.trim()) {
+            try {
+              dropdown.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+            } catch {
+            }
+            if (drawLabels) {
+              const fontSize = Math.min(10, field.position.height * 0.4);
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, { x: pdfX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+            }
+          }
+          if (field.required) {
+            dropdown.enableRequired();
+          }
+          break;
+        }
+        case "radio" /* RADIO */:
+        case "radio": {
+          const encodedName = encodeFieldNameWithSigner(uniqueFieldName, field.assignedSignerEmail);
+          const radioGroup = form.createRadioGroup(encodedName);
+          if (field.options && field.options.length > 0) {
+            const optionHeight = Math.min(20, field.position.height / field.options.length);
+            const spacing = field.position.height / field.options.length;
+            field.options.forEach((option, index) => {
+              const optionY = pdfY + field.position.height - (index + 1) * spacing + (spacing - optionHeight) / 2;
+              radioGroup.addOptionToPage(option, page, {
+                x: pdfX,
+                y: optionY,
+                width: optionHeight,
+                height: optionHeight,
+                borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+                backgroundColor: pdfLib.rgb(1, 1, 1)
+              });
+              if (drawLabels) {
+                const labelX = pdfX + optionHeight + 5;
+                const labelY = optionY + optionHeight / 4;
+                page.drawText(option, { x: labelX, y: labelY, size: 10, font, color: pdfLib.rgb(0, 0, 0) });
+              }
+            });
+            if (field.defaultValue && field.options.includes(field.defaultValue)) {
+              radioGroup.select(field.defaultValue);
+            }
+          }
+          if (field.label && field.label.trim()) {
+            try {
+              radioGroup.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+            } catch {
+            }
+            if (drawLabels) {
+              const fontSize = 10;
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, { x: pdfX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+            }
+          }
+          if (field.required) {
+            radioGroup.enableRequired();
+          }
+          break;
+        }
+        default:
+          console.warn(`Unknown field type: ${fieldType} for field ${field.name}`);
+      }
+    } catch (error) {
+      console.error(`Error adding field ${field.name}:`, error);
+    }
+  }
+  return await pdfDoc.save();
+}
+function mapFieldPositionsAfterAssembly(fields, pageMapping) {
+  return fields.map((field) => {
+    const mappingKey = String(field.position.page - 1);
+    const newPageNumber = pageMapping.get(mappingKey);
+    if (newPageNumber !== void 0) {
+      return {
+        ...field,
+        position: { ...field.position, page: newPageNumber }
+      };
+    }
+    return field;
+  }).filter((field) => {
+    const mappingKey = String(field.position.page - 1);
+    return pageMapping.has(mappingKey) || pageMapping.size === 0;
+  });
+}
 var isMultiSelectModifier = (event) => {
   return event.ctrlKey || event.metaKey;
 };
@@ -1354,6 +1928,7 @@ var PageAssembler = React7.forwardRef(
     const processedInitialPdfRef = React7.useRef(null);
     const isDraggingPage = React7.useRef(false);
     const onChangeRef = React7.useRef(onChange);
+    const originalBytesCache = React7.useRef(/* @__PURE__ */ new Map());
     const summary = React7.useMemo(() => ({
       totalFiles: state.files.length,
       totalPages: state.files.reduce((sum, file) => sum + file.pages.length, 0)
@@ -1423,6 +1998,7 @@ var PageAssembler = React7.forwardRef(
             originalFileId: fileId
           }))
         };
+        originalBytesCache.current.set(fileId, originalBytes);
         dispatch({ type: "ADD_FILE", payload: file });
       } catch (error) {
         console.error("Error processing initial PDF:", error);
@@ -1475,6 +2051,7 @@ var PageAssembler = React7.forwardRef(
             const arrayBuffer = await file.arrayBuffer();
             const pdfBytes = new Uint8Array(arrayBuffer);
             fileInfo.originalBytes = new Uint8Array(pdfBytes);
+            originalBytesCache.current.set(fileInfo.id, fileInfo.originalBytes);
             const defensiveCopy = new Uint8Array(pdfBytes);
             const pages = await pdfToImages(defensiveCopy, { hideFormFields: true });
             fileInfo.pages = pages.map((page, index) => ({
@@ -1491,6 +2068,7 @@ var PageAssembler = React7.forwardRef(
             const arrayBuffer = await file.arrayBuffer();
             const imageBytes = new Uint8Array(arrayBuffer);
             fileInfo.originalBytes = new Uint8Array(imageBytes);
+            originalBytesCache.current.set(fileInfo.id, fileInfo.originalBytes);
             const thumbUrl = URL.createObjectURL(file);
             const img = new Image();
             const dimensions = await new Promise((resolve) => {
@@ -1618,21 +2196,205 @@ var PageAssembler = React7.forwardRef(
         setIsLoading(true);
         setProcessingStatus("Assembling PDF...");
         try {
-          const { PDFDocument: PDFDocument2 } = await import('pdf-lib');
-          const combinedDoc = await PDFDocument2.create();
+          const { PDFDocument: PDFDocument4, PDFName: PDFName3, PDFString: PDFString3 } = await import('pdf-lib');
           const loadedPdfs = /* @__PURE__ */ new Map();
           const fileMap = /* @__PURE__ */ new Map();
+          const pdfFiles = state.files.filter((f) => f.type === "pdf" && f.originalBytes?.length > 0);
+          const imageFiles = state.files.filter((f) => f.type === "image");
+          const isSinglePdfScenario = pdfFiles.length === 1 && imageFiles.length === 0;
           for (const file of state.files) {
             fileMap.set(file.id, file);
             if (file.type === "pdf" && file.originalBytes && file.originalBytes.length > 0) {
               try {
-                const sourcePdf = await PDFDocument2.load(file.originalBytes);
+                const sourcePdf = await PDFDocument4.load(file.originalBytes);
                 loadedPdfs.set(file.id, sourcePdf);
               } catch (error) {
                 console.error(`Error loading PDF for file ${file.id}:`, error);
               }
             }
           }
+          const referencedFileIds = /* @__PURE__ */ new Set();
+          for (const file of state.files) {
+            for (const page of file.pages) {
+              const originalFileId = page.originalFileId || file.id;
+              if (!loadedPdfs.has(originalFileId)) {
+                referencedFileIds.add(originalFileId);
+              }
+            }
+          }
+          for (const fileId of referencedFileIds) {
+            const cachedBytes = originalBytesCache.current.get(fileId);
+            if (cachedBytes && cachedBytes.length > 0) {
+              try {
+                console.log(`[PageAssembler] Loading PDF from cache for deleted file ${fileId}`);
+                const sourcePdf = await PDFDocument4.load(cachedBytes);
+                loadedPdfs.set(fileId, sourcePdf);
+              } catch (error) {
+                console.error(`Error loading cached PDF for file ${fileId}:`, error);
+              }
+            }
+          }
+          console.log("[PageAssembler] Checking single PDF scenario:", {
+            isSinglePdfScenario,
+            pdfFilesCount: pdfFiles.length,
+            imageFilesCount: imageFiles.length
+          });
+          if (isSinglePdfScenario && pdfFiles[0]) {
+            const sourceFile = pdfFiles[0];
+            const sourcePdf = loadedPdfs.get(sourceFile.id);
+            console.log("[PageAssembler] Single PDF check:", {
+              sourcePdfLoaded: !!sourcePdf,
+              pagesCount: sourceFile.pages.length,
+              originalBytesLength: sourceFile.originalBytes?.length
+            });
+            if (sourcePdf) {
+              const desiredPageIndices = sourceFile.pages.map((p) => p.srcIndex);
+              const originalPageCount = sourcePdf.getPageCount();
+              const allPagesFromSameFile = sourceFile.pages.every(
+                (p) => (p.originalFileId || sourceFile.id) === sourceFile.id
+              );
+              const isOriginalOrder = desiredPageIndices.length === originalPageCount && desiredPageIndices.every((idx, i) => idx === i);
+              console.log("[PageAssembler] Original bytes check:", {
+                allPagesFromSameFile,
+                isOriginalOrder,
+                desiredPageIndices,
+                originalPageCount
+              });
+              if (allPagesFromSameFile && isOriginalOrder) {
+                console.log("[PageAssembler] \u2705 Returning ORIGINAL bytes (form fields preserved)");
+                const arrayBuffer2 = sourceFile.originalBytes.buffer.slice(
+                  sourceFile.originalBytes.byteOffset,
+                  sourceFile.originalBytes.byteOffset + sourceFile.originalBytes.byteLength
+                );
+                const blob2 = new Blob([arrayBuffer2], { type: "application/pdf" });
+                return blob2;
+              } else {
+                console.log("[PageAssembler] \u26A0\uFE0F Pages modified, will use copyPages (form fields may be lost)");
+              }
+            }
+          }
+          console.log("[PageAssembler] Starting multi-PDF assembly with field preservation");
+          const allExtractedFields = [];
+          const mergedMetadata = {
+            version: "1.0",
+            fields: {},
+            fieldIdIndex: {}
+          };
+          const filePageUsage = /* @__PURE__ */ new Map();
+          for (const file of state.files) {
+            for (const page of file.pages) {
+              const originalFileId = page.originalFileId || file.id;
+              if (!filePageUsage.has(originalFileId)) {
+                filePageUsage.set(originalFileId, /* @__PURE__ */ new Map());
+              }
+              const pageUsage = filePageUsage.get(originalFileId);
+              if (!pageUsage.has(page.srcIndex)) {
+                pageUsage.set(page.srcIndex, []);
+              }
+              pageUsage.get(page.srcIndex).push(page);
+            }
+          }
+          let combinedPageIndex = 0;
+          const pageIdToNewPageNumber = /* @__PURE__ */ new Map();
+          for (const file of state.files) {
+            for (const page of file.pages) {
+              combinedPageIndex++;
+              pageIdToNewPageNumber.set(page.id, combinedPageIndex);
+            }
+          }
+          console.log("[PageAssembler] Page mapping:", Object.fromEntries(pageIdToNewPageNumber));
+          const extractAndMapFields = async (fileId, fileName, pdfBytes2, sourcePdf) => {
+            let sourceMetadata = null;
+            if (sourcePdf) {
+              try {
+                const sourceInfoRef = sourcePdf.context.trailerInfo.Info;
+                if (sourceInfoRef) {
+                  const sourceInfoDict = sourcePdf.context.lookup(sourceInfoRef);
+                  if (sourceInfoDict && typeof sourceInfoDict.get === "function") {
+                    const metadataObj = sourceInfoDict.get(PDFName3.of("SigniphiMetadata"));
+                    if (metadataObj) {
+                      const metadataStr = metadataObj.toString();
+                      let jsonStr = metadataStr;
+                      if (metadataStr.startsWith("(") && metadataStr.endsWith(")")) {
+                        jsonStr = metadataStr.slice(1, -1);
+                      }
+                      sourceMetadata = JSON.parse(jsonStr);
+                    }
+                  }
+                }
+              } catch (metadataError) {
+                console.warn(`Could not read metadata from PDF ${fileName}:`, metadataError);
+              }
+            }
+            console.log(`[PageAssembler] Extracting fields from "${fileName}"`);
+            const extractedFields = await extractFieldsFromPdf(pdfBytes2);
+            console.log(`[PageAssembler] Found ${extractedFields.length} fields in "${fileName}"`);
+            const pageUsageForFile = filePageUsage.get(fileId) || /* @__PURE__ */ new Map();
+            for (const field of extractedFields) {
+              const originalPage = field.page;
+              const srcIndex = originalPage - 1;
+              const pageInstances = pageUsageForFile.get(srcIndex) || [];
+              for (const pageInstance of pageInstances) {
+                const newPageNumber = pageIdToNewPageNumber.get(pageInstance.id);
+                if (newPageNumber !== void 0) {
+                  const trackedField = {
+                    name: field.name,
+                    type: field.type,
+                    position: {
+                      x: field.x,
+                      y: field.y,
+                      width: field.width,
+                      height: field.height,
+                      page: newPageNumber
+                      // Updated to new page number
+                    },
+                    pageId: pageInstance.id,
+                    originalFileId: fileId,
+                    label: field.label,
+                    required: field.required,
+                    options: field.options,
+                    placeholder: field.placeholder,
+                    fieldId: field.fieldId,
+                    assignedSignerEmail: field.signer
+                  };
+                  allExtractedFields.push(trackedField);
+                  console.log(`[PageAssembler] Mapped field "${field.name}" from page ${originalPage} to page ${newPageNumber}`);
+                  const metadataKey = `${field.name}_p${newPageNumber}`;
+                  if (sourceMetadata?.fields?.[field.name]) {
+                    mergedMetadata.fields[metadataKey] = sourceMetadata.fields[field.name];
+                  }
+                  if (sourceMetadata?.fieldIdIndex?.[field.name]) {
+                    mergedMetadata.fieldIdIndex[metadataKey] = sourceMetadata.fieldIdIndex[field.name];
+                  }
+                }
+              }
+            }
+          };
+          const processedFileIds = /* @__PURE__ */ new Set();
+          for (const file of state.files) {
+            if (file.type !== "pdf" || !file.originalBytes || file.originalBytes.length === 0) continue;
+            try {
+              await extractAndMapFields(file.id, file.name, file.originalBytes, loadedPdfs.get(file.id));
+              processedFileIds.add(file.id);
+            } catch (extractError) {
+              console.error(`Error extracting fields from ${file.name}:`, extractError);
+            }
+          }
+          for (const fileId of referencedFileIds) {
+            if (processedFileIds.has(fileId)) continue;
+            const cachedBytes = originalBytesCache.current.get(fileId);
+            if (cachedBytes && cachedBytes.length > 0) {
+              try {
+                console.log(`[PageAssembler] Extracting fields from cached file ${fileId}`);
+                await extractAndMapFields(fileId, `Cached file ${fileId}`, cachedBytes, loadedPdfs.get(fileId));
+              } catch (extractError) {
+                console.error(`Error extracting fields from cached file ${fileId}:`, extractError);
+              }
+            }
+          }
+          console.log(`[PageAssembler] Total extracted fields: ${allExtractedFields.length}`);
+          console.log(`[PageAssembler] Field names:`, allExtractedFields.map((f) => `${f.name} (page ${f.position.page})`));
+          const combinedDoc = await PDFDocument4.create();
           for (const file of state.files) {
             if (file.pages.length === 0) continue;
             for (const page of file.pages) {
@@ -1652,7 +2414,17 @@ var PageAssembler = React7.forwardRef(
                 if (page.srcIndex >= 0 && page.srcIndex < sourcePageCount) {
                   try {
                     const copiedPages = await combinedDoc.copyPages(sourcePdf, [page.srcIndex]);
-                    copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
+                    copiedPages.forEach((copiedPage) => {
+                      try {
+                        const annotsRef = copiedPage.node.get(PDFName3.of("Annots"));
+                        if (annotsRef) {
+                          copiedPage.node.delete(PDFName3.of("Annots"));
+                        }
+                      } catch (annotError) {
+                        console.warn("Could not remove annotations from copied page:", annotError);
+                      }
+                      combinedDoc.addPage(copiedPage);
+                    });
                   } catch (copyError) {
                     console.error(`Error copying page ${page.srcIndex}:`, copyError);
                     throw new Error(`Failed to copy page: ${copyError instanceof Error ? copyError.message : String(copyError)}`);
@@ -1661,7 +2433,7 @@ var PageAssembler = React7.forwardRef(
               } else if (sourceFile.type === "image" && sourceFile.originalFile) {
                 try {
                   const imagePdfBytes = await imageToPdf(sourceFile.originalFile);
-                  const imagePdf = await PDFDocument2.load(imagePdfBytes);
+                  const imagePdf = await PDFDocument4.load(imagePdfBytes);
                   const copiedPages = await combinedDoc.copyPages(imagePdf, [0]);
                   copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
                 } catch (imageError) {
@@ -1671,7 +2443,46 @@ var PageAssembler = React7.forwardRef(
               }
             }
           }
-          const pdfBytes = await combinedDoc.save();
+          if (Object.keys(mergedMetadata.fields).length > 0) {
+            try {
+              const newInfoRef = combinedDoc.context.trailerInfo.Info;
+              if (newInfoRef) {
+                const newInfoDict = combinedDoc.context.lookup(newInfoRef);
+                if (newInfoDict && typeof newInfoDict.set === "function") {
+                  newInfoDict.set(
+                    PDFName3.of("SigniphiMetadata"),
+                    PDFString3.of(JSON.stringify(mergedMetadata))
+                  );
+                }
+              }
+            } catch (metadataError) {
+              console.warn("Could not write merged metadata:", metadataError);
+            }
+          }
+          let pdfBytes = await combinedDoc.save();
+          if (allExtractedFields.length > 0) {
+            console.log(`[PageAssembler] Re-adding ${allExtractedFields.length} fields to combined document`);
+            const fieldsForPdf = allExtractedFields.map((field) => ({
+              name: field.name,
+              type: field.type,
+              position: field.position,
+              label: field.label,
+              required: field.required,
+              options: field.options,
+              placeholder: field.placeholder,
+              assignedSignerEmail: field.assignedSignerEmail
+            }));
+            try {
+              pdfBytes = await addFormFieldsToPdf(pdfBytes, fieldsForPdf, {
+                removeExistingFields: true,
+                // Remove any orphaned field references
+                drawLabels: false
+              });
+              console.log("[PageAssembler] \u2705 Successfully re-added form fields to combined PDF");
+            } catch (addFieldsError) {
+              console.error("[PageAssembler] Error re-adding fields:", addFieldsError);
+            }
+          }
           const arrayBuffer = pdfBytes.buffer.slice(pdfBytes.byteOffset, pdfBytes.byteOffset + pdfBytes.byteLength);
           const blob = new Blob([arrayBuffer], { type: "application/pdf" });
           return blob;
@@ -1863,11 +2674,17 @@ function debounce(func, wait) {
 var PageAssembler_default = PageAssembler;
 
 exports.Button = Button;
+exports.FormFieldType = FormFieldType;
 exports.PageAssembler = PageAssembler;
+exports.addFormFieldsToPdf = addFormFieldsToPdf;
 exports.createPdfBlobUrl = createPdfBlobUrl;
 exports.default = PageAssembler_default;
 exports.downloadPdf = downloadPdf;
+exports.extractFieldsFromPdf = extractFieldsFromPdf;
+exports.getSigniphiMetadata = getSigniphiMetadata;
 exports.imageToPdf = imageToPdf;
+exports.mapFieldPositionsAfterAssembly = mapFieldPositionsAfterAssembly;
 exports.pdfToImages = pdfToImages;
+exports.setSigniphiMetadata = setSigniphiMetadata;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map