@signiphi/pdf-signer 0.2.0-beta.21 → 0.2.0-beta.22

package/dist/utils/audit-trail.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Audit Trail Utilities
+ * Captures device metadata, IP address, and geolocation for compliance and forensics
+ */
+import type { AuditTrailMetadata } from '../types';
+/**
+ * Synchronously capture device and browser metadata
+ */
+export declare function captureDeviceMetadata(): Partial<AuditTrailMetadata>;
+/**
+ * Capture IP address using public API
+ */
+export declare function captureIpAddress(): Promise<string>;
+/**
+ * Capture geolocation using browser geolocation API
+ */
+export declare function captureGeolocation(): Promise<{
+    latitude: number;
+    longitude: number;
+    accuracy?: number;
+} | null>;
+/**
+ * Capture complete audit trail metadata
+ * Combines device metadata, IP address, and geolocation
+ */
+export declare function captureAuditTrail(): Promise<AuditTrailMetadata>;
+//# sourceMappingURL=audit-trail.d.ts.map

package/dist/utils/audit-trail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-trail.d.ts","sourceRoot":"","sources":["../../src/utils/audit-trail.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGnD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAsCnE;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,CAuBxD;AAED;;GAEG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,IAAI,CAAC,CAiCR;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAgCrE"}

package/dist/utils/date-validation-iso.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ISO Date Validation Utility
+ * Lightweight validation for ISO 8601 date strings (YYYY-MM-DD)
+ * Separated from full date-validation to avoid pulling in the heavier `parse` dependency
+ * from date-fns when only ISO validation is needed.
+ */
+/**
+ * Validate if a string is a valid ISO date (YYYY-MM-DD)
+ */
+export declare function isValidISODate(value: string | null | undefined): boolean;
+//# sourceMappingURL=date-validation-iso.d.ts.map

package/dist/utils/date-validation-iso.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-validation-iso.d.ts","sourceRoot":"","sources":["../../src/utils/date-validation-iso.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAgBxE"}

package/dist/utils/date-validation.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Date Validation and Parsing Utility
+ * Handles parsing of various date formats and validation
+ */
+export { isValidISODate } from './date-validation-iso';
+export interface DateValidationResult {
+    isValid: boolean;
+    date: Date | null;
+    isoString: string | null;
+    originalValue: string;
+    error?: string;
+}
+/**
+ * Parse and validate a date string from various formats
+ * Attempts to parse common formats: ISO, US, EU, timestamps
+ *
+ * Format priority:
+ * 1. ISO 8601 (YYYY-MM-DD)
+ * 2. US format (MM/DD/YYYY) - assumes US format for ambiguous dates
+ * 3. EU format (DD/MM/YYYY)
+ * 4. Timestamp (numeric string)
+ *
+ * @param value - The date string to parse
+ * @returns Validation result with parsed date or error
+ */
+export declare function parseAndValidateDate(value: string | null | undefined): DateValidationResult;
+//# sourceMappingURL=date-validation.d.ts.map

package/dist/utils/date-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-validation.d.ts","sourceRoot":"","sources":["../../src/utils/date-validation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AASD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,oBAAoB,CAoJ3F"}

package/dist/utils/errors.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Custom Error Classes
+ * Domain-specific error types for better error handling and debugging
+ */
+/**
+ * Error thrown when PDF validation fails
+ *
+ * @example
+ * ```ts
+ * const validation = validatePdfBytes(bytes);
+ * if (!validation.valid) {
+ *   throw new PdfValidationError(validation.error || 'Invalid PDF');
+ * }
+ * ```
+ */
+export declare class PdfValidationError extends Error {
+    readonly details?: unknown | undefined;
+    constructor(message: string, details?: unknown | undefined);
+}
+/**
+ * Error thrown during PDF processing operations
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const pdfDoc = await PDFDocument.load(bytes);
+ * } catch (err) {
+ *   throw new PdfProcessingError('Failed to load PDF document', err);
+ * }
+ * ```
+ */
+export declare class PdfProcessingError extends Error {
+    readonly details?: unknown | undefined;
+    constructor(message: string, details?: unknown | undefined);
+}
+/**
+ * Error thrown for form field related issues
+ *
+ * @example
+ * ```ts
+ * if (!field.value && field.required) {
+ *   throw new FormFieldError(
+ *     'Required field is empty',
+ *     field.name
+ *   );
+ * }
+ * ```
+ */
+export declare class FormFieldError extends Error {
+    readonly fieldName?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(message: string, fieldName?: string | undefined, details?: unknown | undefined);
+}
+/**
+ * Error thrown for attachment validation failures
+ *
+ * @example
+ * ```ts
+ * if (file.size > maxFileSize) {
+ *   throw new AttachmentValidationError(
+ *     `File size exceeds limit: ${file.name}`,
+ *     file.name
+ *   );
+ * }
+ * ```
+ */
+export declare class AttachmentValidationError extends Error {
+    readonly fileName?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(message: string, fileName?: string | undefined, details?: unknown | undefined);
+}
+/**
+ * Type guard to check if an error is a PdfValidationError
+ */
+export declare function isPdfValidationError(error: unknown): error is PdfValidationError;
+/**
+ * Type guard to check if an error is a PdfProcessingError
+ */
+export declare function isPdfProcessingError(error: unknown): error is PdfProcessingError;
+/**
+ * Type guard to check if an error is a FormFieldError
+ */
+export declare function isFormFieldError(error: unknown): error is FormFieldError;
+/**
+ * Type guard to check if an error is an AttachmentValidationError
+ */
+export declare function isAttachmentValidationError(error: unknown): error is AttachmentValidationError;
+/**
+ * Extract error message from unknown error type
+ *
+ * @param error - The error to extract message from
+ * @param defaultMessage - Default message if extraction fails
+ * @returns Error message string
+ *
+ * @example
+ * ```ts
+ * try {
+ *   // ... operation
+ * } catch (err) {
+ *   const message = getErrorMessage(err, 'Operation failed');
+ *   logger.error(message);
+ * }
+ * ```
+ */
+export declare function getErrorMessage(error: unknown, defaultMessage?: string): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,OAAO,CAAC,EAAE,OAAO;gBADjC,OAAO,EAAE,MAAM,EACC,OAAO,CAAC,EAAE,OAAO,YAAA;CASpC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,OAAO,CAAC,EAAE,OAAO;gBADjC,OAAO,EAAE,MAAM,EACC,OAAO,CAAC,EAAE,OAAO,YAAA;CAQpC;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAe,SAAQ,KAAK;aAGrB,SAAS,CAAC,EAAE,MAAM;aAClB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,SAAS,CAAC,EAAE,MAAM,YAAA,EAClB,OAAO,CAAC,EAAE,OAAO,YAAA;CAQpC;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;aAGhC,QAAQ,CAAC,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,MAAM,YAAA,EACjB,OAAO,CAAC,EAAE,OAAO,YAAA;CAQpC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEhF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEhF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAExE;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,yBAAyB,CAE9F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,SAAkB,GAAG,MAAM,CAQxF"}

package/dist/utils/field-extraction.d.ts

@@ -0,0 +1,59 @@
+/**
+ * PDF Form Field Extraction Utilities
+ * Functions for extracting and decoding form fields from PDFs
+ */
+import { EsignFormField, FormFieldType } from '../types';
+/**
+ * Extract visible form fields from a PDF document
+ * @param pdfBytes - The PDF bytes to extract fields from
+ * @param currentSignerEmail - Optional email of the current signer (for multi-signer filtering)
+ * @returns Array of extracted form fields
+ */
+export declare function extractVisibleFormFields(pdfBytes: Uint8Array, currentSignerEmail?: string): Promise<EsignFormField[]>;
+/**
+ * Decode a field name to extract label, signer email, and placeholder
+ * Format: fieldName__LABEL__labelText__SIGNER__email__PLACEHOLDER__placeholderText
+ *
+ * @deprecated This function is deprecated and kept only for backward compatibility with old PDFs.
+ * New PDFs store metadata in the PDF's document information dictionary instead of encoding it in field names.
+ * Use getSigniphiMetadata() for new PDFs.
+ */
+export declare function decodeFieldName(fieldName: string): {
+    decodedFieldName: string;
+    displayLabel: string;
+    assignedSignerEmail?: string;
+    fieldPlaceholder: string;
+    acknowledgements?: Array<{
+        id: string;
+        title: string;
+        description: string;
+    }>;
+};
+/**
+ * Generate a fallback label from a decoded field name
+ */
+export declare function generateFallbackLabel(decodedFieldName: string, fieldType: FormFieldType): string;
+/**
+ * Find field by UUID using the fieldIdIndex
+ * This is the SECURE way to lookup fields in multi-signer workflows
+ * @param fields - Array of fields to search
+ * @param uuid - The UUID to find
+ * @returns The field or undefined
+ */
+export declare function findFieldByUuid(fields: EsignFormField[], uuid: string): EsignFormField | undefined;
+/**
+ * Resolve a field name or UUID to the actual field
+ * Priority: UUID lookup first (secure), then field name fallback
+ * @param fields - Array of fields
+ * @param identifier - Either a UUID or field name
+ * @returns The field or undefined
+ */
+export declare function resolveField(fields: EsignFormField[], identifier: string): EsignFormField | undefined;
+/**
+ * Get all fields assigned to a specific signer by UUID
+ * @param fields - Array of fields
+ * @param signerEmail - Email of the signer
+ * @returns Array of field UUIDs assigned to this signer
+ */
+export declare function getFieldUuidsForSigner(fields: EsignFormField[], signerEmail: string): string[];
+//# sourceMappingURL=field-extraction.d.ts.map

package/dist/utils/field-extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-extraction.d.ts","sourceRoot":"","sources":["../../src/utils/field-extraction.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAyBzD;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,UAAU,EACpB,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,cAAc,EAAE,CAAC,CA2N3B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG;IAClD,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,KAAK,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;CAC5E,CAmFA;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,gBAAgB,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,MAAM,CAyChG;AAwCD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAElG;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAsBrG;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAI9F"}

package/dist/utils/field-visibility.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Field Visibility Utilities
+ * Core logic for determining which fields are visible/editable in multi-signer mode
+ *
+ * XIGNIPHI MODEL: All signers are equal - no primary/secondary hierarchy
+ * Signers are ordered by signOrder for sequential signing only
+ *
+ * CRITICAL: This logic must work identically in both flows:
+ * - Single-signer flow: isMultiSigner = false, all fields visible
+ * - Multi-signer flow: isMultiSigner = true, filtered by assignment rules
+ */
+import type { EsignFormField, MultiSignerContext } from '../types';
+/**
+ * Determine if a field should be visible to the current signer
+ *
+ * Implements signiphi's simple 4-rule visibility logic:
+ * - Rule 1: Unassigned fields → visible to all signers
+ * - Rule 2: Direct assignment → show if assigned to current signer
+ * - Rule 3: Grouped assignments ("to-recipients", "additional-signers") → visible to all signers
+ * - Rule 4: Assigned to different specific signer → hide
+ *
+ * @param field - The form field to check
+ * @param multiSignerContext - Multi-signer context with current signer info
+ * @returns true if field should be visible, false if hidden
+ *
+ * @example Single-signer flow
+ * ```ts
+ * const context = { isMultiSigner: false, ... };
+ * isFieldVisibleToSigner(anyField, context); // always returns true
+ * ```
+ *
+ * @example Multi-signer flow
+ * ```ts
+ * const context = {
+ *   isMultiSigner: true,
+ *   currentSignerEmail: 'signer1@example.com',
+ *   isPrimarySigner: false, // Not used in signiphi
+ *   isFinalSigner: false    // Not used in signiphi
+ * };
+ *
+ * // Unassigned field - all signers see it
+ * isFieldVisibleToSigner({ assignedSignerEmail: undefined, ... }, context); // true
+ *
+ * // Direct assignment to current signer
+ * isFieldVisibleToSigner({ assignedSignerEmail: 'signer1@example.com', ... }, context); // true
+ *
+ * // Grouped assignment - all signers see it
+ * isFieldVisibleToSigner({ assignedSignerEmail: 'to-recipients', ... }, context); // true
+ * ```
+ */
+export declare function isFieldVisibleToSigner(field: EsignFormField, multiSignerContext: MultiSignerContext): boolean;
+/**
+ * Filter an array of fields to only those visible to the current signer
+ *
+ * @param fields - All form fields
+ * @param multiSignerContext - Multi-signer context
+ * @returns Filtered array of visible fields
+ *
+ * @example
+ * ```ts
+ * const allFields = [...]; // 10 fields
+ * const context = { isMultiSigner: true, isPrimarySigner: true, ... };
+ * const visible = filterFieldsBySigner(allFields, context); // 5 fields (only primary signer's)
+ * ```
+ */
+export declare function filterFieldsBySigner(fields: EsignFormField[], multiSignerContext: MultiSignerContext): EsignFormField[];
+/**
+ * Determine if a field should be flattened (made non-editable) by the current signer
+ *
+ * Used during PDF submission to determine which fields to flatten.
+ * In multi-signer mode, only flatten fields assigned to current signer.
+ * In single-signer mode, flatten all fields.
+ *
+ * XIGNIPHI MODEL: Flatten fields visible/assigned to current signer
+ *
+ * CRITICAL: This affects PDF flattening behavior - must preserve exact logic!
+ *
+ * @param field - The form field to check
+ * @param multiSignerContext - Multi-signer context
+ * @returns true if current signer should flatten this field
+ *
+ * @example Single-signer flow
+ * ```ts
+ * const context = { isMultiSigner: false, ... };
+ * shouldFlattenField(anyField, context); // always returns true
+ * ```
+ *
+ * @example Multi-signer flow
+ * ```ts
+ * const context = {
+ *   isMultiSigner: true,
+ *   currentSignerEmail: 'signer1@example.com',
+ *   isPrimarySigner: false, // Not used in signiphi
+ *   isFinalSigner: false    // Not used in signiphi
+ * };
+ *
+ * // Current signer's field - flatten it
+ * shouldFlattenField({ assignedSignerEmail: 'signer1@example.com', ... }, context); // true
+ *
+ * // Different signer's field - don't flatten (keep editable for them)
+ * shouldFlattenField({ assignedSignerEmail: 'signer2@example.com', ... }, context); // false
+ *
+ * // Unassigned field - all signers flatten (visible to all)
+ * shouldFlattenField({ assignedSignerEmail: undefined, ... }, context); // true
+ * ```
+ */
+export declare function shouldFlattenField(field: EsignFormField, multiSignerContext: MultiSignerContext): boolean;
+//# sourceMappingURL=field-visibility.d.ts.map

package/dist/utils/field-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-visibility.d.ts","sourceRoot":"","sources":["../../src/utils/field-visibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,cAAc,EACrB,kBAAkB,EAAE,kBAAkB,GACrC,OAAO,CA4BT;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,cAAc,EAAE,EACxB,kBAAkB,EAAE,kBAAkB,GACrC,cAAc,EAAE,CAQlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,kBAAkB,EAAE,kBAAkB,GACrC,OAAO,CA0BT"}

package/dist/utils/font-loader.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Font loading and text-to-signature generation utilities
+ * Uses Google Fonts for cursive/handwritten signature styles
+ */
+export interface SignatureFont {
+    name: string;
+    family: string;
+    label: string;
+}
+/**
+ * Available signature fonts from Google Fonts
+ */
+export declare const SIGNATURE_FONTS: SignatureFont[];
+/**
+ * Default font to use
+ */
+export declare const DEFAULT_SIGNATURE_FONT: SignatureFont;
+/**
+ * Load all signature fonts from Google Fonts
+ * This function is idempotent - it will only load fonts once
+ */
+export declare function loadSignatureFonts(): Promise<void>;
+/**
+ * Check if a specific font is available/loaded
+ */
+export declare function isFontLoaded(fontFamily: string): boolean;
+/**
+ * Wait for a specific font to be ready
+ */
+export declare function waitForFont(fontFamily: string): Promise<boolean>;
+export interface GenerateSignatureOptions {
+    text: string;
+    fontFamily: string;
+    width?: number;
+    height?: number;
+    fontSize?: number;
+    color?: string;
+    backgroundColor?: string | null;
+}
+/**
+ * Generate a signature image from text using a canvas
+ * @returns PNG data URL (data:image/png;base64,...)
+ */
+export declare function generateSignatureFromText(options: GenerateSignatureOptions): string;
+/**
+ * Generate signature with automatic font loading
+ * Ensures the font is loaded before rendering
+ */
+export declare function generateSignatureFromTextAsync(options: GenerateSignatureOptions): Promise<string>;
+//# sourceMappingURL=font-loader.d.ts.map

package/dist/utils/font-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-loader.d.ts","sourceRoot":"","sources":["../../src/utils/font-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,aAAa,EAM1C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAIpC,CAAC;AAWF;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAsCxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAMxD;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAWtE;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,wBAAwB,GAChC,MAAM,CAkDR;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,MAAM,CAAC,CAQjB"}

package/dist/utils/index.d.ts

@@ -0,0 +1,20 @@
+export * from './pdf-helpers';
+export * from './pdf-metadata';
+export * from './font-loader';
+export * from './pdf-manipulation';
+export * from './pdf-signer-utils';
+export * from './field-extraction';
+export * from './pdfjs-config';
+export * from './pdfjs-version-check';
+export * from './audit-trail';
+export * from './pdf-validators';
+export * from './field-visibility';
+export * from './pdf-widget-helpers';
+export * from './pdf-field-type-helpers';
+export * from './errors';
+export * from './attachment-validators';
+export { logger } from './logger';
+export * from './performance-monitor';
+export * from './date-validation';
+export * from './tracking';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,UAAU,CAAC;AACzB,cAAc,yBAAyB,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Logger Utility
+ * Centralized logging system with environment-based log level control
+ */
+interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Singleton logger instance
+ */
+export declare const logger: Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,UAAU,MAAM;IACd,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACjD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CAClD;AAgDD;;GAEG;AACH,eAAO,MAAM,MAAM,QAAiB,CAAC"}

package/dist/utils/pdf-field-type-helpers.d.ts

@@ -0,0 +1,87 @@
+/**
+ * PDF Field Type Helper Utilities
+ * Common utilities for detecting field types and extracting values
+ *
+ * Used across pdf-manipulation.ts for consistent field processing
+ *
+ * IMPORTANT: Uses duck typing (method detection) instead of constructor.name
+ * to ensure minification-safe field type detection. Constructor names are
+ * renamed during minification, breaking string comparisons.
+ */
+/**
+ * PDF form field type for operations
+ */
+interface PDFFormField {
+    getName(): string;
+    getText?(): string;
+    setText?(text: string): void;
+    isRequired?(): boolean;
+    isChecked?(): boolean;
+    check?(): void;
+    uncheck?(): void;
+    getSelected?(): string[];
+    getOptions?(): string[];
+    select?(value: string): void;
+    setOptions?(options: string[]): void;
+    addOptions?(options: string[]): void;
+    enableReadOnly?(): void;
+}
+/**
+ * Detect the field type from a PDF field using duck typing
+ *
+ * Uses method presence detection instead of constructor.name to ensure
+ * minification-safe field type detection. Each pdf-lib field type has
+ * unique methods that can be used to identify it.
+ *
+ * @param field - The PDF form field
+ * @returns Standardized field type string
+ *
+ * @example
+ * ```ts
+ * const fieldType = detectFieldType(field);
+ * // Returns: 'text', 'checkbox', 'dropdown', 'radiogroup', 'signature', etc.
+ * ```
+ */
+export declare function detectFieldType(field: PDFFormField): string;
+/**
+ * Extract the current value from a PDF field based on its type
+ *
+ * Handles different field types appropriately:
+ * - Text fields: getText()
+ * - Checkboxes: isChecked() → 'true'/'false'
+ * - Dropdowns: getSelected()[0]
+ * - Radio groups: getSelected()[0]
+ *
+ * @param field - The PDF form field
+ * @param fieldType - The field type (from detectFieldType)
+ * @returns The field value as a string, or empty string if no value
+ *
+ * @example
+ * ```ts
+ * const fieldType = detectFieldType(field);
+ * const value = extractFieldValue(field, fieldType);
+ * ```
+ */
+export declare function extractFieldValue(field: PDFFormField, fieldType: string): string;
+/**
+ * Check if a field is required based on field metadata and name patterns
+ *
+ * Attempts to determine required status through:
+ * 1. field.isRequired() method (if available)
+ * 2. Field name patterns (signature, initials, required)
+ * 3. Field type (signatures are always required)
+ *
+ * @param field - The PDF form field
+ * @param fieldName - The field name
+ * @param fieldType - The field type (from detectFieldType)
+ * @returns true if field is required
+ *
+ * @example
+ * ```ts
+ * const isRequired = isRequiredField(field, 'signature_1', 'text');
+ * // Returns: true (signature fields are required)
+ * ```
+ */
+export declare function isRequiredField(field: PDFFormField, fieldName: string, fieldType: string): boolean;
+export {};
+//# sourceMappingURL=pdf-field-type-helpers.d.ts.map

package/dist/utils/pdf-field-type-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-field-type-helpers.d.ts","sourceRoot":"","sources":["../../src/utils/pdf-field-type-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;GAEG;AACH,UAAU,YAAY;IACpB,OAAO,IAAI,MAAM,CAAC;IAClB,OAAO,CAAC,IAAI,MAAM,CAAC;IACnB,OAAO,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,CAAC,IAAI,OAAO,CAAC;IACvB,SAAS,CAAC,IAAI,OAAO,CAAC;IACtB,KAAK,CAAC,IAAI,IAAI,CAAC;IACf,OAAO,CAAC,IAAI,IAAI,CAAC;IACjB,WAAW,CAAC,IAAI,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,IAAI,MAAM,EAAE,CAAC;IACxB,MAAM,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACrC,UAAU,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACrC,cAAc,CAAC,IAAI,IAAI,CAAC;CACzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CA4C3D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CA8BhF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAyBT"}

package/dist/utils/pdf-helpers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * PDF utility helper functions
+ */
+/**
+ * Create a blob URL from PDF bytes for preview
+ */
+export declare function createPdfBlobUrl(pdfBytes: Uint8Array): string;
+/**
+ * Download PDF file
+ */
+export declare function downloadPdf(pdfBytes: Uint8Array, filename: string): void;
+/**
+ * Convert URL to PDF bytes
+ * @param url - The URL to fetch the PDF from
+ * @returns PDF bytes as Uint8Array
+ */
+export declare function urlToPdfBytes(url: string): Promise<Uint8Array>;
+/**
+ * Validate that data is a valid PDF
+ */
+export declare function isValidPdf(pdfBytes: Uint8Array): boolean;
+/**
+ * Convert base64 data URL to image bytes
+ */
+export declare function dataUrlToBytes(dataUrl: string): Uint8Array;
+/**
+ * Format field name for display
+ */
+export declare function formatFieldName(fieldName: string): string;
+/**
+ * Check if a field is a signature field
+ */
+export declare function isSignatureField(fieldName: string): boolean;
+/**
+ * Check if a field is an initials field
+ */
+export declare function isInitialsField(fieldName: string): boolean;
+//# sourceMappingURL=pdf-helpers.d.ts.map

package/dist/utils/pdf-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-helpers.d.ts","sourceRoot":"","sources":["../../src/utils/pdf-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAG7D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAOxE;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAyBpE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAGxD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAM1D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAOzD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE1D"}

package/dist/utils/pdf-lib-loader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Lazy loader for pdf-lib
+ *
+ * This module provides a lazy loading mechanism for the pdf-lib library (~150KB).
+ * By deferring the import until actually needed, we can significantly reduce
+ * the initial bundle size for consumers who only view PDFs without filling forms.
+ *
+ * The pdf-lib library is only loaded when:
+ * - fillPdf() is called
+ * - combinePdfs() is called
+ * - Other PDF manipulation functions are used
+ */
+/**
+ * Dynamically import pdf-lib library
+ *
+ * This function lazily loads pdf-lib only when needed. The import is cached
+ * so subsequent calls return the same promise, avoiding multiple imports.
+ *
+ * @returns Promise resolving to the pdf-lib module
+ *
+ * @example
+ * ```typescript
+ * const { PDFDocument, rgb, StandardFonts } = await loadPdfLib();
+ * const pdfDoc = await PDFDocument.load(pdfBytes);
+ * ```
+ */
+export declare function loadPdfLib(): Promise<typeof import("pdf-lib")>;
+/**
+ * Check if pdf-lib has been loaded
+ *
+ * Useful for debugging and testing to verify lazy loading behavior.
+ *
+ * @returns true if pdf-lib has been loaded, false otherwise
+ */
+export declare function isPdfLibLoaded(): boolean;
+/**
+ * Reset the pdf-lib cache (primarily for testing)
+ *
+ * This should only be used in test environments to reset state
+ * between tests.
+ *
+ * @internal
+ */
+export declare function resetPdfLibCache(): void;
+//# sourceMappingURL=pdf-lib-loader.d.ts.map

package/dist/utils/pdf-lib-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-lib-loader.d.ts","sourceRoot":"","sources":["../../src/utils/pdf-lib-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,sCAK/B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}