@signiphi/pdf-signer 0.2.0-beta.25 → 0.2.0-beta.26

package/dist/components/index.js

@@ -617,6 +617,118 @@ function isRequiredField(field, fieldName, fieldType) {
   return false;
 }
 
+// src/utils/pdf-text-wrapping.ts
+function wrapTextToLines(text, font, fontSize, maxWidth) {
+  if (!text) return [];
+  if (maxWidth <= 0) return [text];
+  const measure = (s) => {
+    try {
+      return font.widthOfTextAtSize(s, fontSize);
+    } catch {
+      return s.length * fontSize * 0.5;
+    }
+  };
+  const breakLongWord = (word) => {
+    const chunks = [];
+    let current = "";
+    for (const ch of word) {
+      const candidate = current + ch;
+      if (measure(candidate) > maxWidth && current.length > 0) {
+        chunks.push(current);
+        current = ch;
+      } else {
+        current = candidate;
+      }
+    }
+    if (current.length > 0) chunks.push(current);
+    return chunks;
+  };
+  const segments = text.split("\n");
+  const lines = [];
+  for (const segment of segments) {
+    if (segment.length === 0) {
+      lines.push("");
+      continue;
+    }
+    const words = segment.split(/(\s+)/).filter((token) => token.length > 0);
+    let current = "";
+    for (const token of words) {
+      const candidate = current + token;
+      if (measure(candidate) <= maxWidth) {
+        current = candidate;
+        continue;
+      }
+      if (current.trim().length > 0) {
+        lines.push(current.trimEnd());
+        current = "";
+      }
+      const trimmedToken = token.trimStart();
+      if (measure(trimmedToken) <= maxWidth) {
+        current = trimmedToken;
+      } else {
+        const broken = breakLongWord(trimmedToken);
+        for (let i = 0; i < broken.length - 1; i++) {
+          const piece = broken[i];
+          if (piece !== void 0) lines.push(piece);
+        }
+        current = broken[broken.length - 1] ?? "";
+      }
+    }
+    lines.push(current.trimEnd());
+  }
+  return lines;
+}
+var MIN_MULTILINE_FONT_SIZE = 8;
+function findFittingFontSize(text, font, preferredSize, maxWidth, maxHeight) {
+  if (preferredSize <= MIN_MULTILINE_FONT_SIZE) return preferredSize;
+  for (let size = preferredSize; size >= MIN_MULTILINE_FONT_SIZE; size -= 1) {
+    const lines = wrapTextToLines(text, font, size, maxWidth);
+    if (lines.length * size * 1.2 <= maxHeight) return size;
+  }
+  return MIN_MULTILINE_FONT_SIZE;
+}
+function drawWrappedText(page, text, opts) {
+  if (!text) return;
+  const { x, y, width, height, fontSize, font, color, multiline } = opts;
+  const padding = opts.padding ?? 2;
+  const innerWidth = Math.max(0, width - padding * 2);
+  if (!multiline) {
+    let display = text.replace(/\n/g, " ");
+    if (font.widthOfTextAtSize(display, fontSize) > innerWidth) {
+      let truncated = "";
+      for (const ch of display) {
+        if (font.widthOfTextAtSize(truncated + ch, fontSize) > innerWidth) break;
+        truncated += ch;
+      }
+      display = truncated;
+    }
+    page.drawText(display, {
+      x: x + padding,
+      y: y + (height - fontSize) / 2,
+      size: fontSize,
+      font,
+      color
+    });
+    return;
+  }
+  const innerHeight = Math.max(0, height - padding * 2);
+  const fittedSize = findFittingFontSize(text, font, fontSize, innerWidth, innerHeight);
+  const lineHeight = fittedSize * 1.2;
+  const allLines = wrapTextToLines(text, font, fittedSize, innerWidth);
+  for (let i = 0; i < allLines.length; i++) {
+    const line = allLines[i];
+    if (!line) continue;
+    const lineY = y + height - padding - fittedSize - i * lineHeight;
+    page.drawText(line, {
+      x: x + padding,
+      y: lineY,
+      size: fittedSize,
+      font,
+      color
+    });
+  }
+}
+
 // src/utils/pdf-manipulation.ts
 async function readPdfFormFields(pdfBytes) {
   try {
@@ -1261,6 +1373,21 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
           const labelFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
           const isDateField = fieldName.toLowerCase().includes("date") || fieldName.toLowerCase().includes("_date");
           const fontSize = isDateField ? 14 : extractFieldFontSize(fieldName, field, extractedFormFields);
+          let isMultiline = false;
+          if (!isDateField) {
+            try {
+              const textFieldField = field;
+              if (typeof textFieldField.isMultiline === "function") {
+                isMultiline = textFieldField.isMultiline() === true;
+              }
+            } catch {
+              isMultiline = false;
+            }
+            if (!isMultiline) {
+              isMultiline = fieldInfo?.multiline === true;
+            }
+          }
+          const valueFont = await pdfDoc.embedFont(StandardFonts.Helvetica);
           for (const widget of widgets) {
             const result = getWidgetRectangleAndPage(widget, pages);
             if (!result) continue;
@@ -1278,12 +1405,15 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
               });
             }
             if (fieldValue && fieldValue.trim()) {
-              page.drawText(fieldValue, {
-                x: rect.x + 2,
-                y: rect.y + 2,
-                size: fontSize,
-                font: await pdfDoc.embedFont(StandardFonts.Helvetica),
-                color: rgb(0, 0, 0)
+              drawWrappedText(page, fieldValue, {
+                x: rect.x,
+                y: rect.y,
+                width: rect.width,
+                height: rect.height,
+                fontSize,
+                font: valueFont,
+                color: rgb(0, 0, 0),
+                multiline: isMultiline
               });
             }
           }
@@ -2043,14 +2173,17 @@ function parseAndValidateDate(value) {
     } catch {
     }
   }
-  const nativeParsed = new Date(sanitizedValue);
-  if (dateFns.isValid(nativeParsed) && !isNaN(nativeParsed.getTime())) {
-    return {
-      isValid: true,
-      date: nativeParsed,
-      isoString: toIsoDateString(nativeParsed),
-      originalValue
-    };
+  const looksLikeNumericDate = /^\d{1,4}[\/.\-]\d{1,2}[\/.\-]\d{1,4}$/.test(sanitizedValue);
+  if (!looksLikeNumericDate) {
+    const nativeParsed = new Date(sanitizedValue);
+    if (dateFns.isValid(nativeParsed) && !isNaN(nativeParsed.getTime())) {
+      return {
+        isValid: true,
+        date: nativeParsed,
+        isoString: toIsoDateString(nativeParsed),
+        originalValue
+      };
+    }
   }
   return {
     isValid: false,