@unlev/exeq 0.5.7 → 0.6.1

package/dist/chunk-OLRWRBLO.mjs

@@ -0,0 +1,650 @@
+// src/types/pdf-builder.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var DEFAULT_SIGNER_ROLES = ["Sender", "Signer 1"];
+var SIGNER_ROLE_COLORS = {
+  "Sender": "#6366f1",
+  "Signer 1": "#22c55e",
+  "Signer 2": "#f59e0b",
+  "Signer 3": "#ef4444",
+  "Signer 4": "#06b6d4",
+  "Signer 5": "#d946ef"
+};
+function getSignerColor(role) {
+  return SIGNER_ROLE_COLORS[role] || "#888888";
+}
+function isRedactField(f) {
+  return f.type === "blackout" || f.type === "whiteout";
+}
+function isSignatureField(f) {
+  return f.type === "signature" || f.type === "initials";
+}
+function isTextLikeField(f) {
+  return f.type === "text" || f.type === "dropdown" || f.type === "signed-date";
+}
+function getInputType(subtype) {
+  switch (subtype) {
+    case "email":
+      return "email";
+    case "number":
+      return "number";
+    case "phone":
+      return "tel";
+    case "date":
+      return "date";
+    default:
+      return "text";
+  }
+}
+var CSS_FONT_MAP = {
+  Courier: '"Courier New", Courier, monospace',
+  TimesRoman: '"Times New Roman", Times, serif',
+  Helvetica: "Helvetica, Arial, sans-serif"
+};
+function getCssFontFamily(fontFamily) {
+  return fontFamily ? CSS_FONT_MAP[fontFamily] : void 0;
+}
+function getCssTextStyle(field) {
+  const decorations = [];
+  if (field.underline) decorations.push("underline");
+  if (field.strikethrough) decorations.push("line-through");
+  const align = field.align ?? "left";
+  return {
+    fontFamily: getCssFontFamily(field.fontFamily),
+    fontWeight: field.bold ? "bold" : void 0,
+    fontStyle: field.italic ? "italic" : void 0,
+    textDecorationLine: decorations.length ? decorations.join(" ") : void 0,
+    textAlign: field.align,
+    // Hug the alignment edge — no padding on the trailing side — so text reaches
+    // the container edge (matches the PDF's 2pt offsets).
+    paddingLeft: align === "right" ? "0px" : "2px",
+    paddingRight: align === "left" ? "0px" : "2px"
+  };
+}
+function sortFieldsByPosition(fields) {
+  return [...fields].sort((a, b) => {
+    if (a.page !== b.page) return a.page - b.page;
+    const bandThreshold = 2;
+    if (Math.abs(a.y - b.y) > bandThreshold) return a.y - b.y;
+    return a.x - b.x;
+  });
+}
+function preserveFieldValues(oldFields, newFields) {
+  const valueMap = new Map(oldFields.filter((f) => f.value).map((f) => [f.id, f.value]));
+  return newFields.map((f) => valueMap.has(f.id) ? { ...f, value: valueMap.get(f.id) } : f);
+}
+function getFieldValues(fields) {
+  const values = {};
+  fields.forEach((f) => {
+    if (!isRedactField(f)) values[f.label] = f.value || "";
+  });
+  return values;
+}
+var FONT_FAMILIES = [
+  { value: "Helvetica", label: "Helvetica" },
+  { value: "Courier", label: "Courier New" },
+  { value: "TimesRoman", label: "Times New Roman" }
+];
+var FIELD_DEFAULTS = {
+  text: {
+    width: 20,
+    height: 3,
+    fontSize: 12,
+    placeholder: "Enter text",
+    textSubtype: "freeform"
+  },
+  dropdown: {
+    width: 20,
+    height: 3,
+    fontSize: 12,
+    placeholder: "Select..."
+  },
+  signature: {
+    width: 20,
+    height: 6,
+    fontSize: 12,
+    placeholder: "Sign here"
+  },
+  "signed-date": {
+    width: 15,
+    height: 3,
+    fontSize: 12,
+    placeholder: "Date"
+  },
+  checkbox: {
+    width: 2.5,
+    height: 2.5,
+    fontSize: 12,
+    placeholder: ""
+  },
+  initials: {
+    width: 8,
+    height: 5,
+    fontSize: 12,
+    placeholder: "Initials"
+  },
+  blackout: {
+    width: 20,
+    height: 3,
+    fontSize: 12,
+    placeholder: ""
+  },
+  whiteout: {
+    width: 20,
+    height: 3,
+    fontSize: 12,
+    placeholder: ""
+  }
+};
+var TYPE_LABELS = {
+  text: "Text Field",
+  dropdown: "Dropdown",
+  signature: "Signature",
+  "signed-date": "Signed Date",
+  checkbox: "Checkbox",
+  initials: "Initials",
+  blackout: "Blackout",
+  whiteout: "Whiteout"
+};
+function uniqueLabel(desired, existingLabels) {
+  const lower = desired.toLowerCase();
+  if (!existingLabels.some((l) => l.toLowerCase() === lower)) return desired;
+  let i = 2;
+  while (existingLabels.some((l) => l.toLowerCase() === `${lower} ${i}`)) i++;
+  return `${desired} ${i}`;
+}
+function createField(type, assignee, page, x, y, existingFields) {
+  const defaults = FIELD_DEFAULTS[type];
+  const baseLabel = TYPE_LABELS[type];
+  const existingLabels = existingFields?.map((f) => f.label) ?? [];
+  return {
+    id: generateId(),
+    type,
+    label: uniqueLabel(baseLabel, existingLabels),
+    placeholder: defaults.placeholder || "",
+    required: type === "checkbox" || type === "blackout" || type === "whiteout" ? false : true,
+    assignee,
+    page,
+    x,
+    y,
+    width: defaults.width || 20,
+    height: defaults.height || 3,
+    fontSize: defaults.fontSize || 12,
+    value: "",
+    ...type === "text" ? { textSubtype: defaults.textSubtype } : {}
+  };
+}
+
+// src/utils/formulaResolver.ts
+function parseDate(value) {
+  const s = value.trim();
+  if (!s) return null;
+  if (/^\d+(\.\d+)?$/.test(s)) {
+    const serial = parseFloat(s);
+    if (serial > 59) {
+      const utc = new Date(Math.round((serial - 25569) * 864e5));
+      if (!isNaN(utc.getTime())) {
+        return new Date(utc.getUTCFullYear(), utc.getUTCMonth(), utc.getUTCDate());
+      }
+    }
+  }
+  const iso = s.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (iso) return new Date(+iso[1], +iso[2] - 1, +iso[3]);
+  const d = new Date(s);
+  return isNaN(d.getTime()) ? null : d;
+}
+var BUILTIN_TRANSFORMS = {
+  // Date transforms (expects a parseable date string)
+  month: (v) => {
+    const d = parseDate(v);
+    return d ? String(d.getMonth() + 1) : "";
+  },
+  month2: (v) => {
+    const d = parseDate(v);
+    return d ? String(d.getMonth() + 1).padStart(2, "0") : "";
+  },
+  monthname: (v) => {
+    const d = parseDate(v);
+    return d ? d.toLocaleString("en", { month: "long" }) : "";
+  },
+  monthshort: (v) => {
+    const d = parseDate(v);
+    return d ? d.toLocaleString("en", { month: "short" }) : "";
+  },
+  day: (v) => {
+    const d = parseDate(v);
+    return d ? String(d.getDate()) : "";
+  },
+  day2: (v) => {
+    const d = parseDate(v);
+    return d ? String(d.getDate()).padStart(2, "0") : "";
+  },
+  year: (v) => {
+    const d = parseDate(v);
+    return d ? String(d.getFullYear()) : "";
+  },
+  year2: (v) => {
+    const d = parseDate(v);
+    return d ? String(d.getFullYear()).slice(-2) : "";
+  },
+  // String transforms
+  upper: (v) => v.toUpperCase(),
+  lower: (v) => v.toLowerCase(),
+  trim: (v) => v.trim(),
+  first: (v) => v.split(/\s+/)[0] || "",
+  last: (v) => {
+    const parts = v.split(/\s+/);
+    return parts[parts.length - 1] || "";
+  },
+  initials: (v) => v.split(/\s+/).map((w) => w[0] || "").join("").toUpperCase(),
+  // Name parts. Handles "Last, First [Middle]" (comma form) and "First [Middle]
+  // Last" (no comma). firstName → the given name(s); lastName → the surname.
+  firstName: (v) => {
+    const c = v.indexOf(",");
+    if (c >= 0) return v.slice(c + 1).trim();
+    const parts = v.trim().split(/\s+/).filter(Boolean);
+    return parts.length > 1 ? parts.slice(0, -1).join(" ") : parts[0] || "";
+  },
+  lastName: (v) => {
+    const c = v.indexOf(",");
+    if (c >= 0) return v.slice(0, c).trim();
+    const parts = v.trim().split(/\s+/).filter(Boolean);
+    return parts.length > 1 ? parts[parts.length - 1] : parts[0] || "";
+  },
+  // Numeric / substring
+  last4: (v) => v.slice(-4),
+  last2: (v) => v.slice(-2),
+  first4: (v) => v.slice(0, 4),
+  first2: (v) => v.slice(0, 2),
+  digits: (v) => v.replace(/\D/g, ""),
+  number: (v) => {
+    const n = parseFloat(v);
+    return isNaN(n) ? "" : String(n);
+  },
+  currency: (v) => {
+    const n = parseFloat(v.replace(/[^0-9.-]/g, ""));
+    return isNaN(n) ? "" : `$${n.toFixed(2)}`;
+  }
+};
+var FORMULA_RE = /\{\{(.+?)\}\}/g;
+var PIPE_RE = /^(.+?)\s*\|\s*(.+)$/;
+function todayIso() {
+  const d = /* @__PURE__ */ new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function resolveFormula(formula, fields, customTransforms, values) {
+  const transforms = { ...BUILTIN_TRANSFORMS, ...customTransforms };
+  return formula.replace(FORMULA_RE, (_match, expr) => {
+    const pipeMatch = expr.match(PIPE_RE);
+    const sourceLabel = (pipeMatch ? pipeMatch[1] : expr).trim();
+    const transformName = pipeMatch ? pipeMatch[2].trim() : null;
+    const lowerLabel = sourceLabel.toLowerCase();
+    const sourceField = fields.find((f) => f.label.toLowerCase() === lowerLabel) || fields.find((f) => f.id === sourceLabel);
+    let rawValue;
+    if (sourceField && sourceField.value) {
+      rawValue = sourceField.value;
+    }
+    if (rawValue === void 0 && values) {
+      const key = Object.keys(values).find((k) => k.toLowerCase() === lowerLabel);
+      if (key !== void 0) rawValue = values[key] || "";
+    }
+    if (rawValue === void 0 && sourceField) {
+      rawValue = sourceField.value || "";
+    }
+    if (rawValue === void 0 && (lowerLabel === "today" || lowerLabel === "now")) {
+      rawValue = todayIso();
+    }
+    if (rawValue === void 0) return "";
+    if (!transformName) return rawValue;
+    const fn = transforms[transformName];
+    if (!fn) return rawValue;
+    try {
+      return fn(rawValue);
+    } catch {
+      return rawValue;
+    }
+  });
+}
+function resolveAllFormulas(fields, customTransforms, values) {
+  return fields.map((f) => {
+    if (!f.formula) return f;
+    const computed = resolveFormula(f.formula, fields, customTransforms, values);
+    return computed !== f.value ? { ...f, value: computed } : f;
+  });
+}
+
+// src/utils/fitText.ts
+function fitFontSize(o) {
+  let size = o.autoShrink ? Math.min(o.fontSize, o.fieldHeightPt * 0.7) : o.fontSize;
+  if (o.autoShrink && o.value) {
+    const padding = 4;
+    while (size > 4) {
+      if (o.measure(o.value, size) <= o.fieldWidthPt - padding) break;
+      size -= 0.5;
+    }
+  }
+  return size;
+}
+
+// src/utils/pdfFiller.ts
+import {
+  PDFDocument,
+  rgb,
+  StandardFonts
+} from "pdf-lib";
+var FONT_VARIANTS = {
+  Helvetica: [StandardFonts.Helvetica, StandardFonts.HelveticaBold, StandardFonts.HelveticaOblique, StandardFonts.HelveticaBoldOblique],
+  Courier: [StandardFonts.Courier, StandardFonts.CourierBold, StandardFonts.CourierOblique, StandardFonts.CourierBoldOblique],
+  TimesRoman: [StandardFonts.TimesRoman, StandardFonts.TimesRomanBold, StandardFonts.TimesRomanItalic, StandardFonts.TimesRomanBoldItalic]
+};
+function resolveStandardFont(family, bold, italic) {
+  const variants = FONT_VARIANTS[family] || FONT_VARIANTS.Helvetica;
+  const idx = (bold ? 1 : 0) + (italic ? 2 : 0);
+  return variants[idx];
+}
+function fontKey(family, bold, italic) {
+  return `${family}|${bold ? "b" : ""}|${italic ? "i" : ""}`;
+}
+var US_LETTER = [612, 792];
+var US_LEGAL = [612, 1008];
+var A4 = [595.28, 841.89];
+var DEFAULT_CALIBRATION = {
+  xOffset: 0,
+  yOffset: 0,
+  xScale: 1,
+  yScale: 1
+};
+function applyCalibration(fields, calibration, pageSize = US_LETTER) {
+  if (calibration.xOffset === 0 && calibration.yOffset === 0 && calibration.xScale === 1 && calibration.yScale === 1) {
+    return fields;
+  }
+  const xPctOff = calibration.xOffset / pageSize[0] * 100;
+  const yPctOff = calibration.yOffset / pageSize[1] * 100;
+  return fields.map((f) => ({
+    ...f,
+    x: f.x * calibration.xScale + xPctOff,
+    y: f.y * calibration.yScale + yPctOff,
+    width: f.width * calibration.xScale,
+    height: f.height * calibration.yScale
+  }));
+}
+function hexToRgb(hex) {
+  const r = parseInt(hex.slice(1, 3), 16) / 255;
+  const g = parseInt(hex.slice(3, 5), 16) / 255;
+  const b = parseInt(hex.slice(5, 7), 16) / 255;
+  return rgb(r, g, b);
+}
+async function renderFieldsOnPages(pages, fields, getFont, getSignature) {
+  for (const field of fields) {
+    const page = pages[field.page];
+    if (!page) continue;
+    const pageWidth = page.getWidth();
+    const pageHeight = page.getHeight();
+    const x = field.x / 100 * pageWidth;
+    const y = pageHeight - field.y / 100 * pageHeight - field.height / 100 * pageHeight;
+    const w = field.width / 100 * pageWidth;
+    const h = field.height / 100 * pageHeight;
+    if (isRedactField(field)) {
+      page.drawRectangle({
+        x,
+        y,
+        width: w,
+        height: h,
+        color: field.type === "blackout" ? rgb(0, 0, 0) : rgb(1, 1, 1)
+      });
+      continue;
+    }
+    if (!field.value) continue;
+    const inkColor = field.inkColor ? hexToRgb(field.inkColor) : rgb(0, 0, 0);
+    if (field.type === "checkbox") {
+      if (field.value === "true") {
+        const inset = Math.min(w, h) * 0.2;
+        const lineWidth = Math.min(w, h) * 0.08;
+        page.drawLine({
+          start: { x: x + inset, y: y + inset },
+          end: { x: x + w - inset, y: y + h - inset },
+          thickness: lineWidth,
+          color: inkColor
+        });
+        page.drawLine({
+          start: { x: x + w - inset, y: y + inset },
+          end: { x: x + inset, y: y + h - inset },
+          thickness: lineWidth,
+          color: inkColor
+        });
+      }
+    } else if (isSignatureField(field)) {
+      if (field.value.startsWith("data:image/png")) {
+        const img = await getSignature(field.value);
+        page.drawImage(img, { x, y, width: w, height: h });
+      }
+    } else {
+      const font = await getFont(field.fontFamily || "Helvetica", field.bold, field.italic);
+      const spacing = field.letterSpacing || 0;
+      const textWidthAtSize = (text, size) => font.widthOfTextAtSize(text, size) + spacing * (text.length - 1);
+      const fontSize = fitFontSize({
+        value: field.value,
+        fontSize: field.fontSize,
+        autoShrink: field.autoShrink,
+        fieldWidthPt: w,
+        fieldHeightPt: h,
+        measure: textWidthAtSize
+      });
+      const fullTextWidth = textWidthAtSize(field.value, fontSize);
+      const pad = 2;
+      const textX = field.align === "center" ? x + Math.max(pad, (w - fullTextWidth) / 2) : field.align === "right" ? x + Math.max(pad, w - fullTextWidth - pad) : x + pad;
+      const baselineY = y + h * 0.3;
+      if (spacing > 0) {
+        let cx = textX;
+        for (const char of field.value) {
+          page.drawText(char, {
+            x: cx,
+            y: baselineY,
+            size: fontSize,
+            font,
+            color: inkColor
+          });
+          cx += font.widthOfTextAtSize(char, fontSize) + spacing;
+        }
+      } else {
+        page.drawText(field.value, {
+          x: textX,
+          y: baselineY,
+          size: fontSize,
+          font,
+          color: inkColor
+        });
+      }
+      if (field.underline || field.strikethrough) {
+        const textWidth = textWidthAtSize(field.value, fontSize);
+        const lineThickness = Math.max(0.5, fontSize * 0.06);
+        if (field.underline) {
+          const uy = baselineY - fontSize * 0.12;
+          page.drawLine({
+            start: { x: textX, y: uy },
+            end: { x: textX + textWidth, y: uy },
+            thickness: lineThickness,
+            color: inkColor
+          });
+        }
+        if (field.strikethrough) {
+          const sy = baselineY + fontSize * 0.3;
+          page.drawLine({
+            start: { x: textX, y: sy },
+            end: { x: textX + textWidth, y: sy },
+            thickness: lineThickness,
+            color: inkColor
+          });
+        }
+      }
+    }
+  }
+}
+async function generateFilledPdf(opts, builderOptions) {
+  const builder = await createPdfBuilder({
+    pageSize: opts.pageSize,
+    metadata: builderOptions?.metadata
+  });
+  await builder.addRecord(opts);
+  return builder.save();
+}
+function applyMetadata(doc, m) {
+  if (!m) return;
+  if (m.title !== void 0) doc.setTitle(m.title);
+  if (m.author !== void 0) doc.setAuthor(m.author);
+  if (m.subject !== void 0) doc.setSubject(m.subject);
+  if (m.creator !== void 0) doc.setCreator(m.creator);
+  if (m.producer !== void 0) doc.setProducer(m.producer);
+  if (m.creationDate !== void 0) doc.setCreationDate(m.creationDate);
+  if (m.modificationDate !== void 0) doc.setModificationDate(m.modificationDate);
+}
+async function createPdfBuilder(defaults = {}) {
+  const doc = await PDFDocument.create();
+  const fontCache = /* @__PURE__ */ new Map();
+  const embeddedPagesByUrl = /* @__PURE__ */ new Map();
+  const signatureCache = /* @__PURE__ */ new Map();
+  async function getFont(family, bold, italic) {
+    const key = fontKey(family, bold, italic);
+    let f = fontCache.get(key);
+    if (!f) {
+      f = await doc.embedFont(resolveStandardFont(family, bold, italic));
+      fontCache.set(key, f);
+    }
+    return f;
+  }
+  async function ensureFonts(fields) {
+    const keys = /* @__PURE__ */ new Map();
+    for (const f of fields) keys.set(fontKey(f.fontFamily || "Helvetica", f.bold, f.italic), f);
+    for (const f of keys.values()) await getFont(f.fontFamily || "Helvetica", f.bold, f.italic);
+  }
+  async function embedSource(source) {
+    if (typeof source === "string") {
+      let pages = embeddedPagesByUrl.get(source);
+      if (!pages) {
+        const res = await fetch(source);
+        const bytes = await res.arrayBuffer();
+        const srcDoc2 = await PDFDocument.load(bytes);
+        pages = await Promise.all(
+          srcDoc2.getPages().map((p) => doc.embedPage(p))
+        );
+        embeddedPagesByUrl.set(source, pages);
+      }
+      return pages;
+    }
+    const srcDoc = await PDFDocument.load(source);
+    return Promise.all(srcDoc.getPages().map((p) => doc.embedPage(p)));
+  }
+  async function getSignature(dataUrl) {
+    let img = signatureCache.get(dataUrl);
+    if (!img) {
+      const b64 = dataUrl.split(",")[1] ?? "";
+      const pngBytes = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+      img = await doc.embedPng(pngBytes);
+      signatureCache.set(dataUrl, img);
+    }
+    return img;
+  }
+  return {
+    doc,
+    async addRecord(opts) {
+      const pageSize = opts.pageSize ?? defaults.pageSize;
+      let fields = opts.resolveFormulas ? resolveAllFormulas(opts.fields, opts.customTransforms, opts.formulaValues) : opts.fields;
+      if (opts.calibration) {
+        fields = applyCalibration(
+          fields,
+          opts.calibration,
+          pageSize ?? US_LETTER
+        );
+      }
+      await ensureFonts(fields);
+      let sourcePages = [];
+      let pageCount;
+      if (opts.pdfSource !== null) {
+        sourcePages = await embedSource(opts.pdfSource);
+        pageCount = sourcePages.length;
+      } else {
+        pageCount = opts.pageCount ?? 1;
+      }
+      const newPages = [];
+      for (let i = 0; i < pageCount; i++) {
+        const size = pageSize ? pageSize : sourcePages[i] ? [sourcePages[i].width, sourcePages[i].height] : US_LETTER;
+        const page = doc.addPage(size);
+        newPages.push(page);
+        if (sourcePages[i]) {
+          page.drawPage(sourcePages[i], {
+            x: 0,
+            y: 0,
+            width: size[0],
+            height: size[1]
+          });
+        }
+      }
+      await renderFieldsOnPages(newPages, fields, getFont, getSignature);
+    },
+    async save() {
+      applyMetadata(doc, defaults.metadata);
+      return doc.save();
+    }
+  };
+}
+function downloadPdf(bytes, filename) {
+  const blob = new Blob([bytes.slice().buffer], { type: "application/pdf" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+async function postPdfToCallback(bytes, callbackUrl, filename) {
+  const blob = new Blob([bytes.slice().buffer], { type: "application/pdf" });
+  const formData = new FormData();
+  formData.append("file", blob, filename);
+  await fetch(callbackUrl, {
+    method: "POST",
+    body: formData
+  });
+}
+
+export {
+  generateId,
+  DEFAULT_SIGNER_ROLES,
+  SIGNER_ROLE_COLORS,
+  getSignerColor,
+  isRedactField,
+  isSignatureField,
+  isTextLikeField,
+  getInputType,
+  getCssFontFamily,
+  getCssTextStyle,
+  sortFieldsByPosition,
+  preserveFieldValues,
+  getFieldValues,
+  FONT_FAMILIES,
+  FIELD_DEFAULTS,
+  uniqueLabel,
+  createField,
+  parseDate,
+  BUILTIN_TRANSFORMS,
+  resolveFormula,
+  resolveAllFormulas,
+  fitFontSize,
+  US_LETTER,
+  US_LEGAL,
+  A4,
+  DEFAULT_CALIBRATION,
+  applyCalibration,
+  generateFilledPdf,
+  createPdfBuilder,
+  downloadPdf,
+  postPdfToCallback
+};
+//# sourceMappingURL=chunk-OLRWRBLO.mjs.map