@signiphi/pdf-signer 0.1.1

package/dist/core/index.js

@@ -0,0 +1,907 @@
+'use strict';
+
+var react = require('react');
+var pdfjsLib = require('pdfjs-dist');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var pdfjsLib__namespace = /*#__PURE__*/_interopNamespace(pdfjsLib);
+
+// src/core/PdfViewerCore.tsx
+var _workerSrcComputed = false;
+var _cachedWorkerSrc = null;
+function getDefaultWorkerSrc() {
+  if (_workerSrcComputed && _cachedWorkerSrc !== null) {
+    return _cachedWorkerSrc;
+  }
+  let workerSrc = "/pdfjs/build/pdf.worker.mjs";
+  if (typeof window !== "undefined" && typeof URL !== "undefined") {
+    try {
+      const meta = (function() {
+        try {
+          return new Function("return import.meta")();
+        } catch {
+          return null;
+        }
+      })();
+      if (meta && meta.url) {
+        workerSrc = new URL("pdfjs-dist/build/pdf.worker.mjs", meta.url).href;
+      }
+    } catch {
+    }
+  }
+  _workerSrcComputed = true;
+  _cachedWorkerSrc = workerSrc;
+  return workerSrc;
+}
+var globalConfig = {
+  viewerBasePath: "/pdfjs",
+  workerSrc: ""
+  // Lazy-initialized below
+};
+var _configInitialized = false;
+function ensureConfigInitialized() {
+  if (!_configInitialized) {
+    globalConfig.workerSrc = getDefaultWorkerSrc();
+    _configInitialized = true;
+    if (typeof window !== "undefined") {
+      pdfjsLib__namespace.GlobalWorkerOptions.workerSrc = globalConfig.workerSrc;
+    }
+  }
+}
+function getPdfJsConfig() {
+  ensureConfigInitialized();
+  return { ...globalConfig };
+}
+function initializePdfJs() {
+  ensureConfigInitialized();
+}
+async function checkPdfJsVersion(viewerBasePath = "/pdfjs") {
+  const workerVersion = pdfjsLib__namespace.version;
+  try {
+    const versionUrl = `${viewerBasePath}/.version`;
+    const response = await fetch(versionUrl);
+    if (!response.ok) {
+      return {
+        viewerExists: false,
+        versionMatch: false,
+        workerVersion,
+        errorMessage: "PDF.js viewer files not found. Run: npx signiphi-setup"
+      };
+    }
+    const viewerVersion = (await response.text()).trim();
+    const versionMatch = viewerVersion === workerVersion;
+    if (!versionMatch) {
+      return {
+        viewerExists: true,
+        versionMatch: false,
+        viewerVersion,
+        workerVersion,
+        errorMessage: `Version mismatch: viewer=${viewerVersion}, worker=${workerVersion}. Run: npx signiphi-setup`
+      };
+    }
+    return {
+      viewerExists: true,
+      versionMatch: true,
+      viewerVersion,
+      workerVersion
+    };
+  } catch (error) {
+    return {
+      viewerExists: false,
+      versionMatch: false,
+      workerVersion,
+      errorMessage: "Unable to check PDF.js version. Viewer files may not be installed."
+    };
+  }
+}
+
+// src/utils/logger.ts
+function isProduction() {
+  return typeof process !== "undefined" && process.env.NODE_ENV === "production";
+}
+function createPrefix(level) {
+  return `[@signiphi/pdf-signer] [${level.toUpperCase()}]`;
+}
+function createLogger() {
+  const isProd = isProduction();
+  return {
+    debug(message, ...args) {
+      if (!isProd) {
+        console.log(createPrefix("debug"), message, ...args);
+      }
+    },
+    info(message, ...args) {
+      if (!isProd) {
+        console.log(createPrefix("info"), message, ...args);
+      }
+    },
+    warn(message, ...args) {
+      if (!isProd) {
+        console.warn(createPrefix("warn"), message, ...args);
+      }
+    },
+    error(message, ...args) {
+      console.error(createPrefix("error"), message, ...args);
+    }
+  };
+}
+var logger = createLogger();
+var PdfViewerCore = react.forwardRef(
+  ({ onLoad, onError, pdfjsBasePath, children }, ref) => {
+    const iframeRef = react.useRef(null);
+    const loadedPdfUrl = react.useRef(null);
+    const initializationPromise = react.useRef(null);
+    const isLoadingRef = react.useRef(false);
+    const [versionChecked, setVersionChecked] = react.useState(false);
+    const [setupError, setSetupError] = react.useState(null);
+    const getPDFViewerApplication = react.useCallback(() => {
+      try {
+        const iframe = iframeRef.current;
+        if (!iframe || !iframe.contentWindow) {
+          return null;
+        }
+        const PDFViewerApplication = iframe.contentWindow.PDFViewerApplication;
+        if (!PDFViewerApplication) {
+          return null;
+        }
+        return PDFViewerApplication;
+      } catch (error) {
+        logger.error("Error accessing PDFViewerApplication:", error);
+        return null;
+      }
+    }, []);
+    const waitForInitialization = react.useCallback(async () => {
+      const PDFViewerApplication = getPDFViewerApplication();
+      if (!PDFViewerApplication) {
+        throw new Error("PDFViewerApplication not available");
+      }
+      if (PDFViewerApplication.initializedPromise) {
+        await PDFViewerApplication.initializedPromise;
+      }
+      if (PDFViewerApplication.pdfLoadingTask) {
+        await PDFViewerApplication.pdfLoadingTask.promise;
+      }
+      return PDFViewerApplication;
+    }, [getPDFViewerApplication]);
+    const loadPdf = react.useCallback(
+      async (pdfUrl) => {
+        const iframe = iframeRef.current;
+        if (!iframe) {
+          logger.error("PDF viewer iframe not available");
+          return;
+        }
+        if (isLoadingRef.current || loadedPdfUrl.current === pdfUrl) {
+          return;
+        }
+        isLoadingRef.current = true;
+        loadedPdfUrl.current = pdfUrl;
+        try {
+          initializePdfJs();
+          const response = await fetch(pdfUrl);
+          if (!response.ok) {
+            throw new Error(`Failed to fetch PDF: ${response.status}`);
+          }
+          const pdfBytes = await response.arrayBuffer();
+          const blob = new Blob([pdfBytes], { type: "application/pdf" });
+          const blobUrl = URL.createObjectURL(blob);
+          const config = getPdfJsConfig();
+          const basePath = pdfjsBasePath ?? config.viewerBasePath;
+          const viewerUrl = `${basePath}/web/viewer.html?file=${encodeURIComponent(blobUrl)}`;
+          iframe.src = viewerUrl;
+          initializationPromise.current = new Promise((resolve, reject) => {
+            const checkInitialization = () => {
+              try {
+                const PDFViewerApplication = getPDFViewerApplication();
+                if (PDFViewerApplication && PDFViewerApplication.initializedPromise) {
+                  PDFViewerApplication.initializedPromise.then(() => {
+                    resolve();
+                  }).catch(reject);
+                } else {
+                  setTimeout(checkInitialization, 100);
+                }
+              } catch (error) {
+                reject(error);
+              }
+            };
+            setTimeout(checkInitialization, 500);
+          });
+        } catch (error) {
+          logger.error("Error fetching PDF:", error);
+          isLoadingRef.current = false;
+          onError?.(error instanceof Error ? error.message : "Unknown error");
+        }
+      },
+      [getPDFViewerApplication, onError, pdfjsBasePath]
+    );
+    const getFormFieldValues = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (!PDFViewerApplication.pdfDocument) {
+          return {};
+        }
+        const pdfDocument = PDFViewerApplication.pdfDocument;
+        const values = {};
+        if (pdfDocument.annotationStorage) {
+          const annotationStorage = pdfDocument.annotationStorage;
+          let fieldObjects = {};
+          try {
+            if (pdfDocument.getFieldObjects) {
+              const result = await pdfDocument.getFieldObjects();
+              fieldObjects = result || {};
+            }
+          } catch (error) {
+            logger.warn("Error getting field objects:", error);
+          }
+          const idToNameMap = {};
+          const fieldInfo = {};
+          for (const [name, fields] of Object.entries(fieldObjects)) {
+            const fieldArray = fields;
+            fieldInfo[name] = {
+              type: fieldArray[0]?.type || "",
+              widgets: fieldArray
+            };
+            for (const field of fieldArray) {
+              if (field.id) {
+                idToNameMap[field.id] = name;
+              }
+            }
+          }
+          let storedData = {};
+          if (annotationStorage.serializable && annotationStorage.serializable.map) {
+            const storageMap = annotationStorage.serializable.map;
+            for (const [key, value] of storageMap.entries()) {
+              storedData[key] = value;
+            }
+          } else if (typeof annotationStorage.getAll === "function") {
+            storedData = annotationStorage.getAll();
+          }
+          const radioGroups = {};
+          for (const [id, data] of Object.entries(storedData)) {
+            const fieldName = idToNameMap[id];
+            if (!fieldName) continue;
+            const fieldType = fieldInfo[fieldName]?.type;
+            const isRadioButton = fieldType && (fieldType.toLowerCase().includes("radio") || fieldType.toLowerCase().includes("radiobutton") || fieldType === "radiobutton");
+            const widgetCount = fieldInfo[fieldName]?.widgets?.length || 0;
+            const isLikelyRadioGroup = widgetCount > 1 && fieldName.toLowerCase().includes("radio");
+            if (fieldName && (isRadioButton || isLikelyRadioGroup)) {
+              if (!radioGroups[fieldName]) {
+                radioGroups[fieldName] = [];
+              }
+              const widget = fieldInfo[fieldName]?.widgets?.find((w) => w.id === id);
+              radioGroups[fieldName].push({ id, data, widget });
+            }
+          }
+          for (const [fieldName, radioButtons] of Object.entries(radioGroups)) {
+            const selectedRadio = radioButtons.find(
+              (rb) => rb.data && typeof rb.data === "object" && rb.data.value === true
+            );
+            if (selectedRadio) {
+              const sortedRadioButtons = [...radioButtons].sort((a, b) => {
+                const aNum = parseInt(a.id.replace(/\D/g, ""), 10) || 0;
+                const bNum = parseInt(b.id.replace(/\D/g, ""), 10) || 0;
+                return aNum - bNum;
+              });
+              const selectedIndex = sortedRadioButtons.findIndex((rb) => rb.id === selectedRadio.id);
+              if (selectedIndex >= 0) {
+                const exportValue = `__RADIO_OPTION_INDEX_${selectedIndex}__`;
+                values[fieldName] = exportValue;
+              } else {
+                values[fieldName] = "true";
+              }
+            }
+          }
+          for (const [id, data] of Object.entries(storedData)) {
+            const fieldName = idToNameMap[id];
+            if (fieldName && values[fieldName]) {
+              continue;
+            }
+            if (fieldName) {
+              let extractedValue;
+              if (data && typeof data === "object") {
+                const dataObj = data;
+                if ("value" in dataObj) {
+                  extractedValue = String(dataObj.value);
+                } else if ("formValue" in dataObj) {
+                  extractedValue = String(dataObj.formValue);
+                } else if ("textContent" in dataObj) {
+                  extractedValue = String(dataObj.textContent);
+                }
+              } else if (data !== void 0 && data !== null) {
+                extractedValue = String(data);
+              }
+              if (extractedValue !== void 0 && extractedValue !== "") {
+                values[fieldName] = extractedValue;
+              }
+            }
+          }
+          for (const [name, fields] of Object.entries(fieldObjects)) {
+            if (!values[name]) {
+              const fieldArray = fields;
+              const field = fieldArray[0];
+              if (field && field.value !== void 0 && field.value !== null) {
+                const fieldValue = String(field.value);
+                const fieldType = fieldInfo[name]?.type;
+                const isRadioButton = fieldType && (fieldType.toLowerCase().includes("radio") || fieldType === "radiobutton");
+                if (isRadioButton && fieldValue !== "true" && fieldValue !== "false") {
+                  const widgets = fieldInfo[name]?.widgets || [];
+                  if (widgets.length > 0) {
+                    const sortedWidgets = [...widgets].sort((a, b) => {
+                      const aNum = parseInt((a.id || "").replace(/\D/g, ""), 10) || 0;
+                      const bNum = parseInt((b.id || "").replace(/\D/g, ""), 10) || 0;
+                      return aNum - bNum;
+                    });
+                    const selectedIndex = sortedWidgets.findIndex(
+                      (widget) => widget.exportValue === fieldValue || widget.buttonValue === fieldValue
+                    );
+                    if (selectedIndex >= 0) {
+                      values[name] = `__RADIO_OPTION_INDEX_${selectedIndex}__`;
+                    } else {
+                    }
+                  }
+                } else {
+                  values[name] = fieldValue;
+                }
+              }
+            }
+          }
+        }
+        return values;
+      } catch (error) {
+        logger.error("Error extracting form field values:", error);
+        return {};
+      }
+    }, [waitForInitialization]);
+    const setFormFieldValues = react.useCallback(async (values) => {
+      const iframe = iframeRef.current;
+      if (!iframe || !iframe.contentWindow) {
+        logger.warn("Cannot set field values: iframe not available");
+        return;
+      }
+      try {
+        await waitForInitialization();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const iframeDoc = iframe.contentWindow.document;
+        for (const [fieldName, value] of Object.entries(values)) {
+          try {
+            let decodedFieldName = fieldName;
+            if (fieldName.includes("__LABEL__")) {
+              decodedFieldName = fieldName.substring(0, fieldName.indexOf("__LABEL__"));
+            } else if (fieldName.includes("__SIGNER__")) {
+              decodedFieldName = fieldName.substring(0, fieldName.indexOf("__SIGNER__"));
+            } else if (fieldName.includes("__PLACEHOLDER__")) {
+              decodedFieldName = fieldName.substring(0, fieldName.indexOf("__PLACEHOLDER__"));
+            }
+            let elements = iframeDoc.querySelectorAll(
+              `[data-element-id="${fieldName}"], [name="${fieldName}"], [data-element-id="${decodedFieldName}"], [name="${decodedFieldName}"]`
+            );
+            if (elements.length === 0) {
+              logger.warn(`Field element not found for: ${fieldName}`);
+              continue;
+            }
+            const firstElement = elements[0];
+            const isRadioGroup = elements.length > 1 && (firstElement.tagName || "").toLowerCase() === "input" && (firstElement.type || "") === "radio";
+            if (isRadioGroup) {
+              if (value.includes("__RADIO_OPTION_INDEX_")) {
+                const match = value.match(/__RADIO_OPTION_INDEX_(\d+)__/);
+                if (match && match[1]) {
+                  const selectedIndex = parseInt(match[1], 10);
+                  if (selectedIndex < elements.length) {
+                    const radioElement = elements[selectedIndex];
+                    radioElement.checked = true;
+                    radioElement.dispatchEvent(new Event("change", { bubbles: true }));
+                    radioElement.dispatchEvent(new Event("input", { bubbles: true }));
+                    radioElement.dispatchEvent(new Event("click", { bubbles: true }));
+                  } else {
+                    logger.warn(`Radio button index ${selectedIndex} out of range for ${fieldName}`);
+                  }
+                }
+              }
+            } else {
+              const element = elements[0];
+              const tagName = (element.tagName || "").toLowerCase();
+              if (tagName === "input") {
+                const inputType = element.type || "text";
+                if (inputType === "checkbox") {
+                  const boolValue = value === "true" || value === "Yes" || value === "On";
+                  element.checked = boolValue;
+                  element.dispatchEvent(new Event("change", { bubbles: true }));
+                  element.dispatchEvent(new Event("input", { bubbles: true }));
+                  element.dispatchEvent(new Event("click", { bubbles: true }));
+                } else if (inputType === "radio") {
+                  element.checked = value === "true" || value === element.value;
+                  element.dispatchEvent(new Event("change", { bubbles: true }));
+                  element.dispatchEvent(new Event("input", { bubbles: true }));
+                  element.dispatchEvent(new Event("click", { bubbles: true }));
+                } else {
+                  element.value = value;
+                  element.dispatchEvent(new Event("input", { bubbles: true }));
+                  element.dispatchEvent(new Event("change", { bubbles: true }));
+                }
+              } else if (tagName === "select") {
+                element.value = value;
+                element.dispatchEvent(new Event("change", { bubbles: true }));
+                element.dispatchEvent(new Event("input", { bubbles: true }));
+              } else if (tagName === "textarea") {
+                element.value = value;
+                element.dispatchEvent(new Event("input", { bubbles: true }));
+                element.dispatchEvent(new Event("change", { bubbles: true }));
+              } else {
+                logger.warn(`Unknown element type for field ${fieldName}: ${tagName}`);
+              }
+            }
+          } catch (fieldError) {
+            logger.error(`Error setting value for field ${fieldName}:`, fieldError);
+          }
+        }
+      } catch (error) {
+        logger.error("Error setting form field values:", error);
+      }
+    }, [waitForInitialization]);
+    const getAllFieldNames = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (!PDFViewerApplication.pdfDocument) {
+          return [];
+        }
+        const pdfDocument = PDFViewerApplication.pdfDocument;
+        let fieldObjects = {};
+        try {
+          if (pdfDocument.getFieldObjects) {
+            const result = await pdfDocument.getFieldObjects();
+            fieldObjects = result || {};
+          }
+        } catch (error) {
+          return [];
+        }
+        return Object.keys(fieldObjects);
+      } catch (error) {
+        logger.error("Error getting all field names:", error);
+        return [];
+      }
+    }, [waitForInitialization]);
+    const saveDocument = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (!PDFViewerApplication.pdfDocument) {
+          return null;
+        }
+        const pdfDocument = PDFViewerApplication.pdfDocument;
+        if (typeof pdfDocument.saveDocument === "function") {
+          const savedBytes = await pdfDocument.saveDocument();
+          return new Uint8Array(savedBytes);
+        } else if (pdfDocument.getData) {
+          const originalData = await pdfDocument.getData();
+          return new Uint8Array(originalData);
+        }
+        return null;
+      } catch (error) {
+        logger.error("Error saving PDF document:", error);
+        return null;
+      }
+    }, [waitForInitialization]);
+    const injectPlaceholders = react.useCallback((fields) => {
+      const iframe = iframeRef.current;
+      if (!iframe || !iframe.contentWindow) {
+        return;
+      }
+      setTimeout(() => {
+        try {
+          const iframeDoc = iframe.contentWindow.document;
+          const placeholderMap = /* @__PURE__ */ new Map();
+          fields.forEach((field) => {
+            if (field.placeholder) {
+              placeholderMap.set(field.name, field.placeholder);
+              placeholderMap.set(field.id, field.placeholder);
+            }
+          });
+          const inputs = iframeDoc.querySelectorAll("input[data-element-id], input[name]");
+          inputs.forEach((input) => {
+            const htmlInput = input;
+            const fieldId = htmlInput.getAttribute("data-element-id") || htmlInput.name;
+            if (fieldId) {
+              const placeholder = placeholderMap.get(fieldId);
+              if (placeholder) {
+                htmlInput.placeholder = placeholder;
+              }
+            }
+          });
+        } catch (error) {
+          logger.error("Error injecting placeholders:", error);
+        }
+      }, 1e3);
+    }, []);
+    const zoomIn = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (PDFViewerApplication.pdfViewer && typeof PDFViewerApplication.pdfViewer.increaseScale === "function") {
+          PDFViewerApplication.pdfViewer.increaseScale();
+        }
+      } catch (error) {
+        logger.error("Error zooming in:", error);
+      }
+    }, [waitForInitialization]);
+    const zoomOut = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (PDFViewerApplication.pdfViewer && typeof PDFViewerApplication.pdfViewer.decreaseScale === "function") {
+          PDFViewerApplication.pdfViewer.decreaseScale();
+        }
+      } catch (error) {
+        logger.error("Error zooming out:", error);
+      }
+    }, [waitForInitialization]);
+    const nextPage = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (PDFViewerApplication.pdfViewer && typeof PDFViewerApplication.pdfViewer.nextPage === "function") {
+          PDFViewerApplication.pdfViewer.nextPage();
+        }
+      } catch (error) {
+        logger.error("Error going to next page:", error);
+      }
+    }, [waitForInitialization]);
+    const previousPage = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (PDFViewerApplication.pdfViewer && typeof PDFViewerApplication.pdfViewer.previousPage === "function") {
+          PDFViewerApplication.pdfViewer.previousPage();
+        }
+      } catch (error) {
+        logger.error("Error going to previous page:", error);
+      }
+    }, [waitForInitialization]);
+    const getCurrentPage = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (PDFViewerApplication.pdfViewer && typeof PDFViewerApplication.pdfViewer.currentPageNumber === "number") {
+          return PDFViewerApplication.pdfViewer.currentPageNumber;
+        }
+        return null;
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (!errorMsg.includes("not available") && !errorMsg.includes("not yet initialized")) {
+          logger.error("Error getting current page:", error);
+        }
+        return null;
+      }
+    }, [waitForInitialization]);
+    const getTotalPages = react.useCallback(async () => {
+      try {
+        const PDFViewerApplication = await waitForInitialization();
+        if (PDFViewerApplication.pdfViewer && typeof PDFViewerApplication.pdfViewer.pagesCount === "number") {
+          return PDFViewerApplication.pdfViewer.pagesCount;
+        }
+        return null;
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (!errorMsg.includes("not available") && !errorMsg.includes("not yet initialized")) {
+          logger.error("Error getting total pages:", error);
+        }
+        return null;
+      }
+    }, [waitForInitialization]);
+    react.useEffect(() => {
+      if (!versionChecked) {
+        const config = getPdfJsConfig();
+        const basePath = pdfjsBasePath ?? config.viewerBasePath;
+        checkPdfJsVersion(basePath).then((result) => {
+          setVersionChecked(true);
+          if (!result.viewerExists) {
+            const errorMsg = `\u26A0\uFE0F PDF.js files not found
+
+The PDF viewer requires PDF.js files to be installed.
+This should happen automatically, but you can run:
+
+  npx signiphi-setup
+
+Or reinstall the package:
+
+  npm install @signiphi/pdf-signer`;
+            setSetupError(errorMsg);
+            logger.error(errorMsg);
+          } else if (!result.versionMatch) {
+            logger.warn(
+              `\u26A0\uFE0F PDF.js version mismatch:
+  Viewer: ${result.viewerVersion}
+  Worker: ${result.workerVersion}
+Run: npx signiphi-setup to sync versions`
+            );
+          }
+        }).catch((error) => {
+          logger.error("Failed to check PDF.js version:", error);
+          setVersionChecked(true);
+        });
+      }
+    }, [pdfjsBasePath, versionChecked]);
+    const handleIframeLoad = react.useCallback(() => {
+      const iframe = iframeRef.current;
+      if (!iframe || !iframe.contentWindow) {
+        return;
+      }
+      try {
+        if (iframe.contentDocument) {
+          const title = iframe.contentDocument.title;
+          const body = iframe.contentDocument.body;
+          if (title?.includes("404") || title?.includes("Not Found") || body?.textContent?.includes("404") || body?.textContent?.includes("Cannot GET")) {
+            const errorMsg = setupError || `\u26A0\uFE0F PDF.js viewer not found
+
+The viewer.html file could not be loaded from the configured path.
+Run: npx signiphi-setup
+
+Or check your configuration.`;
+            logger.error(errorMsg);
+            isLoadingRef.current = false;
+            onError?.(errorMsg);
+            return;
+          }
+        }
+        setTimeout(async () => {
+          try {
+            if (initializationPromise.current) {
+              await initializationPromise.current;
+              isLoadingRef.current = false;
+              onLoad?.();
+            } else {
+              const PDFViewerApplication = getPDFViewerApplication();
+              if (PDFViewerApplication) {
+                isLoadingRef.current = false;
+                onLoad?.();
+              } else {
+                throw new Error("PDFViewerApplication not found after iframe load");
+              }
+            }
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error loading PDF viewer";
+            logger.error("Error in PDF.js initialization:", error);
+            isLoadingRef.current = false;
+            onError?.(errorMessage);
+          }
+        }, 1e3);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error in iframe load handler";
+        logger.error("Error in iframe load handler:", error);
+        isLoadingRef.current = false;
+        onError?.(errorMessage);
+      }
+    }, [getPDFViewerApplication, onLoad, onError, setupError]);
+    react.useImperativeHandle(
+      ref,
+      () => ({
+        loadPdf,
+        getFormFieldValues,
+        setFormFieldValues,
+        getAllFieldNames,
+        saveDocument,
+        getPDFViewerApplication,
+        injectPlaceholders,
+        zoomIn,
+        zoomOut,
+        nextPage,
+        previousPage,
+        getCurrentPage,
+        getTotalPages
+      }),
+      [loadPdf, getFormFieldValues, setFormFieldValues, getAllFieldNames, saveDocument, getPDFViewerApplication, injectPlaceholders, zoomIn, zoomOut, nextPage, previousPage, getCurrentPage, getTotalPages]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children({ iframeRef, handleIframeLoad }) });
+  }
+);
+PdfViewerCore.displayName = "PdfViewerCore";
+var SignatureCaptureCore = react.forwardRef(
+  ({ width = 400, height = 200, onSignature, children }, ref) => {
+    const canvasRef = react.useRef(null);
+    const containerRef = react.useRef(null);
+    const [isDrawing, setIsDrawing] = react.useState(false);
+    const [isEmpty, setIsEmpty] = react.useState(true);
+    const [lastPoint, setLastPoint] = react.useState(null);
+    const [canvasSize, setCanvasSize] = react.useState({ width, height });
+    react.useEffect(() => {
+      const updateCanvasSize = () => {
+        if (containerRef.current) {
+          const containerWidth = containerRef.current.offsetWidth;
+          const maxWidth = Math.max(containerWidth - 16, width);
+          const aspectRatio = width / height;
+          const newHeight = maxWidth / aspectRatio;
+          setCanvasSize({
+            width: maxWidth,
+            height: newHeight
+          });
+        }
+      };
+      setTimeout(updateCanvasSize, 100);
+      window.addEventListener("resize", updateCanvasSize);
+      return () => window.removeEventListener("resize", updateCanvasSize);
+    }, [width, height]);
+    const getCanvasContext = react.useCallback(() => {
+      const canvas = canvasRef.current;
+      if (!canvas) return null;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return null;
+      return { canvas, ctx };
+    }, []);
+    const setupCanvas = react.useCallback(() => {
+      const result = getCanvasContext();
+      if (!result) return;
+      const { canvas, ctx } = result;
+      canvas.width = canvasSize.width;
+      canvas.height = canvasSize.height;
+      ctx.strokeStyle = "#000000";
+      ctx.lineWidth = window.innerWidth < 768 ? 3 : 2;
+      ctx.lineCap = "round";
+      ctx.lineJoin = "round";
+      ctx.imageSmoothingEnabled = true;
+      ctx.fillStyle = "#ffffff";
+      ctx.fillRect(0, 0, canvasSize.width, canvasSize.height);
+    }, [canvasSize, getCanvasContext]);
+    const clear = react.useCallback(() => {
+      const result = getCanvasContext();
+      if (!result) return;
+      const { ctx } = result;
+      ctx.fillStyle = "#ffffff";
+      ctx.fillRect(0, 0, canvasSize.width, canvasSize.height);
+      queueMicrotask(() => setIsEmpty(true));
+    }, [canvasSize, getCanvasContext]);
+    const getSignatureDataUrl = react.useCallback(() => {
+      const canvas = canvasRef.current;
+      if (!canvas || isEmpty) return null;
+      return canvas.toDataURL("image/png");
+    }, [isEmpty]);
+    const getRelativePosition = react.useCallback(
+      (e) => {
+        const canvas = canvasRef.current;
+        if (!canvas) return null;
+        const rect = canvas.getBoundingClientRect();
+        const scaleX = canvas.width / rect.width;
+        const scaleY = canvas.height / rect.height;
+        let clientX, clientY;
+        if ("touches" in e) {
+          const touch = e.touches[0] || e.changedTouches[0];
+          if (!touch) return null;
+          clientX = touch.clientX;
+          clientY = touch.clientY;
+        } else {
+          clientX = e.clientX;
+          clientY = e.clientY;
+        }
+        return {
+          x: (clientX - rect.left) * scaleX,
+          y: (clientY - rect.top) * scaleY
+        };
+      },
+      []
+    );
+    const drawLine = react.useCallback(
+      (from, to) => {
+        const result = getCanvasContext();
+        if (!result) return;
+        const { ctx } = result;
+        ctx.beginPath();
+        ctx.moveTo(from.x, from.y);
+        ctx.lineTo(to.x, to.y);
+        ctx.stroke();
+        queueMicrotask(() => setIsEmpty(false));
+      },
+      [getCanvasContext]
+    );
+    const startDrawing = react.useCallback(
+      (e) => {
+        e.preventDefault();
+        const point = getRelativePosition(e);
+        if (!point) return;
+        setIsDrawing(true);
+        setLastPoint(point);
+      },
+      [getRelativePosition]
+    );
+    const draw = react.useCallback(
+      (e) => {
+        if (!isDrawing || !lastPoint) return;
+        e.preventDefault();
+        const point = getRelativePosition(e);
+        if (!point) return;
+        drawLine(lastPoint, point);
+        setLastPoint(point);
+      },
+      [isDrawing, lastPoint, getRelativePosition, drawLine]
+    );
+    const stopDrawing = react.useCallback(() => {
+      setIsDrawing(false);
+      setLastPoint(null);
+    }, []);
+    const handleSave = react.useCallback(() => {
+      if (isEmpty) return;
+      const dataUrl = getSignatureDataUrl();
+      if (dataUrl && onSignature) {
+        onSignature(dataUrl);
+      }
+    }, [isEmpty, getSignatureDataUrl, onSignature]);
+    react.useEffect(() => {
+      setupCanvas();
+    }, [setupCanvas]);
+    const handleMouseDown = react.useCallback(
+      (e) => {
+        startDrawing(e);
+      },
+      [startDrawing]
+    );
+    const handleMouseMove = react.useCallback(
+      (e) => {
+        draw(e);
+      },
+      [draw]
+    );
+    const handleMouseUp = react.useCallback(() => {
+      stopDrawing();
+    }, [stopDrawing]);
+    const handleMouseLeave = react.useCallback(() => {
+      stopDrawing();
+    }, [stopDrawing]);
+    const handleTouchStart = react.useCallback(
+      (e) => {
+        startDrawing(e);
+      },
+      [startDrawing]
+    );
+    const handleTouchMove = react.useCallback(
+      (e) => {
+        draw(e);
+      },
+      [draw]
+    );
+    const handleTouchEnd = react.useCallback(() => {
+      stopDrawing();
+    }, [stopDrawing]);
+    react.useImperativeHandle(
+      ref,
+      () => ({
+        clear,
+        getSignatureDataUrl,
+        isEmpty: () => isEmpty
+      }),
+      [clear, getSignatureDataUrl, isEmpty]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children({
+      canvasRef,
+      containerRef,
+      isEmpty,
+      canvasSize,
+      handlers: {
+        onMouseDown: handleMouseDown,
+        onMouseMove: handleMouseMove,
+        onMouseUp: handleMouseUp,
+        onMouseLeave: handleMouseLeave,
+        onTouchStart: handleTouchStart,
+        onTouchMove: handleTouchMove,
+        onTouchEnd: handleTouchEnd
+      },
+      actions: {
+        clear,
+        save: handleSave
+      }
+    }) });
+  }
+);
+SignatureCaptureCore.displayName = "SignatureCaptureCore";
+
+exports.PdfViewerCore = PdfViewerCore;
+exports.SignatureCaptureCore = SignatureCaptureCore;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map