legal-markdown-js 0.1.0

package/dist/generators/pdf-generator.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * @fileoverview PDF Generation Module for Legal Markdown Documents
+ *
+ * This module provides functionality to convert processed Legal Markdown content
+ * into professional PDF documents using Puppeteer for HTML-to-PDF conversion.
+ * It builds upon the HTML generator to create print-ready documents with
+ * customizable formatting, page layouts, and styling options.
+ *
+ * Features:
+ * - HTML-to-PDF conversion using Puppeteer
+ * - Multiple page formats (A4, Letter, Legal)
+ * - Customizable margins and page orientation
+ * - Header and footer template support
+ * - Field highlighting for document review
+ * - Temporary file management and cleanup
+ * - Error handling and logging
+ * - Dual PDF generation (normal and highlighted versions)
+ *
+ * @example
+ * ```typescript
+ * import { pdfGenerator } from './pdf-generator';
+ *
+ * const pdf = await pdfGenerator.generatePdf(markdownContent, './output.pdf', {
+ *   format: 'A4',
+ *   landscape: false,
+ *   includeHighlighting: true,
+ *   margin: { top: '2cm', bottom: '2cm' }
+ * });
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pdfGenerator = exports.PdfGenerator = void 0;
+const puppeteer = __importStar(require("puppeteer"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+const html_generator_1 = require("./html-generator");
+/**
+ * PDF Generator for Legal Markdown Documents
+ *
+ * Converts processed Legal Markdown content into PDF documents using Puppeteer
+ * for HTML-to-PDF conversion. Provides comprehensive formatting options and
+ * supports both normal and highlighted document versions.
+ *
+ * @class PdfGenerator
+ * @example
+ * ```typescript
+ * const generator = new PdfGenerator();
+ * const pdf = await generator.generatePdf(content, './output.pdf', {
+ *   format: 'A4',
+ *   includeHighlighting: true
+ * });
+ * ```
+ */
+class PdfGenerator {
+    /**
+     * Creates a new PDF generator instance
+     *
+     * @constructor
+     */
+    constructor() {
+        this.puppeteerOptions = {
+            headless: true,
+            args: [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-accelerated-2d-canvas',
+                '--no-first-run',
+                '--no-zygote',
+                '--single-process',
+                '--disable-gpu',
+            ],
+        };
+    }
+    /**
+     * Generates a PDF document from Legal Markdown content
+     *
+     * This method orchestrates the complete PDF generation process:
+     * 1. Converts markdown to HTML using the HTML generator
+     * 2. Creates a temporary HTML file for Puppeteer
+     * 3. Launches a headless Chrome browser
+     * 4. Loads the HTML and generates PDF with specified options
+     * 5. Cleans up temporary files and browser resources
+     *
+     * @async
+     * @param {string} markdownContent - The processed Legal Markdown content
+     * @param {string} outputPath - Path where the PDF will be saved
+     * @param {PdfGeneratorOptions} [options={}] - Configuration options for PDF generation
+     * @returns {Promise<Buffer>} A promise that resolves to the PDF buffer
+     * @throws {Error} When PDF generation fails due to browser, file system, or processing errors
+     * @example
+     * ```typescript
+     * const pdf = await generator.generatePdf(
+     *   markdownContent,
+     *   './contract.pdf',
+     *   {
+     *     format: 'A4',
+     *     landscape: false,
+     *     includeHighlighting: true,
+     *     margin: { top: '2cm', bottom: '2cm' }
+     *   }
+     * );
+     * ```
+     */
+    async generatePdf(markdownContent, outputPath, options = {}) {
+        let browser = null;
+        let tempHtmlPath = null;
+        try {
+            logger_1.logger.debug('Starting PDF generation', {
+                outputPath,
+                options,
+            });
+            // Generate HTML content first
+            const htmlContent = await html_generator_1.htmlGenerator.generateHtml(markdownContent, options);
+            // Create temporary HTML file
+            const tempDir = path.join(process.cwd(), '.temp');
+            await fs.mkdir(tempDir, { recursive: true });
+            tempHtmlPath = path.join(tempDir, `temp-${Date.now()}.html`);
+            await fs.writeFile(tempHtmlPath, htmlContent, 'utf-8');
+            // Launch browser
+            logger_1.logger.debug('Launching Puppeteer browser');
+            browser = await puppeteer.launch(this.puppeteerOptions);
+            const page = await browser.newPage();
+            // Load the HTML file
+            const fileUrl = `file://${path.resolve(tempHtmlPath)}`;
+            await page.goto(fileUrl, {
+                waitUntil: ['load', 'networkidle0'],
+                timeout: 30000,
+            });
+            // Configure PDF options
+            const pdfOptions = {
+                path: outputPath,
+                format: options.format || 'A4',
+                landscape: options.landscape || false,
+                printBackground: options.printBackground !== false,
+                displayHeaderFooter: options.displayHeaderFooter || false,
+                preferCSSPageSize: options.preferCSSPageSize || false,
+                margin: options.margin || {
+                    top: '1cm',
+                    right: '1cm',
+                    bottom: '1cm',
+                    left: '1cm',
+                },
+            };
+            // Add header and footer if provided
+            if (options.headerTemplate) {
+                pdfOptions.headerTemplate = options.headerTemplate;
+            }
+            if (options.footerTemplate) {
+                pdfOptions.footerTemplate = options.footerTemplate;
+            }
+            // Generate PDF
+            logger_1.logger.debug('Generating PDF with options', { pdfOptions });
+            const pdfBuffer = await page.pdf(pdfOptions);
+            // Ensure output directory exists
+            const outputDir = path.dirname(outputPath);
+            await fs.mkdir(outputDir, { recursive: true });
+            // Write PDF file
+            await fs.writeFile(outputPath, pdfBuffer);
+            logger_1.logger.info('PDF generated successfully', {
+                outputPath,
+                size: pdfBuffer.length,
+            });
+            return Buffer.from(pdfBuffer);
+        }
+        catch (error) {
+            logger_1.logger.error('Error generating PDF', { error });
+            throw new Error(`Failed to generate PDF: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            // Cleanup
+            if (browser) {
+                await browser.close();
+            }
+            if (tempHtmlPath) {
+                try {
+                    await fs.unlink(tempHtmlPath);
+                }
+                catch (error) {
+                    logger_1.logger.warn('Failed to delete temporary HTML file', { error });
+                }
+            }
+        }
+    }
+    /**
+     * Generate two PDF versions: one normal and one with highlighting
+     *
+     * This method creates two PDF versions of the same document:
+     * 1. A normal version without field highlighting
+     * 2. A highlighted version with field annotations
+     *
+     * This is useful for document review processes where both clean and
+     * annotated versions are needed for different purposes.
+     *
+     * @async
+     * @param {string} markdownContent - The processed Legal Markdown content
+     * @param {string} outputPath - Base path for PDF files (will be modified for each version)
+     * @param {PdfGeneratorOptions} [options={}] - Configuration options for PDF generation
+     * @returns {Promise<Object>} A promise that resolves to both PDF buffers
+     * @returns {Buffer} returns.normal - The normal PDF without highlighting
+     * @returns {Buffer} returns.highlighted - The highlighted PDF with field annotations
+     * @throws {Error} When PDF generation fails for either version
+     * @example
+     * ```typescript
+     * const { normal, highlighted } = await generator.generatePdfVersions(
+     *   markdownContent,
+     *   './contract.pdf',
+     *   { format: 'A4' }
+     * );
+     * // Creates: contract.normal.pdf and contract.highlighted.pdf
+     * ```
+     */
+    async generatePdfVersions(markdownContent, outputPath, options = {}) {
+        // Generate normal PDF
+        const normalPath = outputPath.replace('.pdf', '.normal.pdf');
+        const normalOptions = { ...options, includeHighlighting: false };
+        const normalPdf = await this.generatePdf(markdownContent, normalPath, normalOptions);
+        // Generate highlighted PDF
+        const highlightedPath = outputPath.replace('.pdf', '.highlighted.pdf');
+        const highlightedOptions = { ...options, includeHighlighting: true };
+        const highlightedPdf = await this.generatePdf(markdownContent, highlightedPath, highlightedOptions);
+        return {
+            normal: normalPdf,
+            highlighted: highlightedPdf,
+        };
+    }
+}
+exports.PdfGenerator = PdfGenerator;
+/**
+ * Singleton instance of PdfGenerator for convenient importing
+ *
+ * @constant {PdfGenerator} pdfGenerator
+ * @example
+ * ```typescript
+ * import { pdfGenerator } from './pdf-generator';
+ * const pdf = await pdfGenerator.generatePdf(content, './output.pdf');
+ * ```
+ */
+exports.pdfGenerator = new PdfGenerator();
+//# sourceMappingURL=pdf-generator.js.map

package/dist/generators/pdf-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-generator.js","sourceRoot":"","sources":["../../src/generators/pdf-generator.ts"],"names":[],"mappings":"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"}

package/dist/helpers/date-helpers.d.ts

@@ -0,0 +1,216 @@
+/**
+ * @fileoverview Date Manipulation and Formatting Helpers
+ *
+ * This module provides comprehensive date manipulation and formatting utilities
+ * specifically designed for legal documents. It includes functions for date
+ * arithmetic, parsing, and formatting with legal-specific date formats.
+ *
+ * Features:
+ * - Date arithmetic (add years, months, days)
+ * - Flexible date formatting with multiple format options
+ * - Legal-specific date formats (formal, ordinal, etc.)
+ * - Date parsing with format detection
+ * - Comprehensive error handling for invalid dates
+ *
+ * @example
+ * ```typescript
+ * import { formatDate, addYears, DateFormats } from './date-helpers';
+ *
+ * // Format a date for legal documents
+ * const legalDate = formatDate(new Date(), DateFormats.LEGAL);
+ * // Result: "16th day of July, 2025"
+ *
+ * // Add years to a contract date
+ * const expiryDate = addYears('2025-01-01', 5);
+ * ```
+ */
+/**
+ * Adds a specified number of years to a date
+ *
+ * This function handles both Date objects and ISO date strings, making it
+ * useful for contract calculations and legal document date processing.
+ *
+ * @param {Date | string} date - The base date as a Date object or ISO string
+ * @param {number} years - The number of years to add (can be negative)
+ * @returns {Date} A new Date object with the years added
+ * @throws {Error} If the input date is invalid
+ *
+ * @example
+ * ```typescript
+ * // Add 5 years to a contract start date
+ * const startDate = new Date('2025-01-01');
+ * const endDate = addYears(startDate, 5);
+ * // Result: Date object for 2030-01-01
+ *
+ * // Using with string input
+ * const futureDate = addYears('2025-07-16', 2);
+ * // Result: Date object for 2027-07-16
+ *
+ * // Subtract years (negative input)
+ * const pastDate = addYears(new Date(), -3);
+ * ```
+ */
+export declare function addYears(date: Date | string, years: number): Date;
+/**
+ * Adds a specified number of days to a date
+ *
+ * Useful for calculating deadlines, notice periods, and other time-sensitive
+ * legal requirements in contracts and legal documents.
+ *
+ * @param {Date | string} date - The base date as a Date object or ISO string
+ * @param {number} days - The number of days to add (can be negative)
+ * @returns {Date} A new Date object with the days added
+ * @throws {Error} If the input date is invalid
+ *
+ * @example
+ * ```typescript
+ * // Add 30 days for a notice period
+ * const noticeDate = addDays(new Date(), 30);
+ *
+ * // Calculate deadline from string date
+ * const deadline = addDays('2025-07-16', 14);
+ * // Result: Date object for 2025-07-30
+ *
+ * // Go back in time (negative days)
+ * const pastDate = addDays(new Date(), -7);
+ * ```
+ */
+export declare function addDays(date: Date | string, days: number): Date;
+/**
+ * Adds a specified number of months to a date
+ *
+ * Handles month boundaries intelligently, useful for calculating quarterly
+ * reports, monthly payments, and other periodic legal obligations.
+ *
+ * @param {Date | string} date - The base date as a Date object or ISO string
+ * @param {number} months - The number of months to add (can be negative)
+ * @returns {Date} A new Date object with the months added
+ * @throws {Error} If the input date is invalid
+ *
+ * @example
+ * ```typescript
+ * // Add 6 months for a review period
+ * const reviewDate = addMonths(new Date('2025-01-31'), 6);
+ * // Result: Date object for 2025-07-31
+ *
+ * // Calculate quarterly dates
+ * const quarterlyDate = addMonths('2025-01-01', 3);
+ * // Result: Date object for 2025-04-01
+ *
+ * // Previous months (negative input)
+ * const previousQuarter = addMonths(new Date(), -3);
+ * ```
+ */
+export declare function addMonths(date: Date | string, months: number): Date;
+/**
+ * Formats a date using customizable format strings
+ *
+ * Provides flexible date formatting with support for multiple format tokens.
+ * Particularly useful for legal documents that require specific date formats
+ * for different jurisdictions and document types.
+ *
+ * @param {Date | string} date - The date to format as a Date object or ISO string
+ * @param {string} format - The format string (default: 'YYYY-MM-DD')
+ * @returns {string} The formatted date string
+ * @throws {Error} If the input date is invalid
+ *
+ * Format tokens:
+ * - YYYY: 4-digit year (2025)
+ * - YY: 2-digit year (25)
+ * - MMMM: Full month name (January)
+ * - MMM: Abbreviated month name (Jan)
+ * - MM: 2-digit month (01)
+ * - M: Month number (1)
+ * - DD: 2-digit day (01)
+ * - D: Day number (1)
+ * - Do: Ordinal day (1st, 2nd, 3rd)
+ * - dddd: Full day name (Monday)
+ * - ddd: Abbreviated day name (Mon)
+ *
+ * @example
+ * ```typescript
+ * const date = new Date('2025-07-16');
+ *
+ * // Standard formats
+ * formatDate(date, 'YYYY-MM-DD');        // "2025-07-16"
+ * formatDate(date, 'MM/DD/YYYY');        // "07/16/2025"
+ * formatDate(date, 'DD/MM/YYYY');        // "16/07/2025"
+ *
+ * // Legal document formats
+ * formatDate(date, DateFormats.LEGAL);   // "16th day of July, 2025"
+ * formatDate(date, DateFormats.FORMAL);  // "Wednesday, July 16th, 2025"
+ *
+ * // Custom format
+ * formatDate(date, 'MMMM Do, YYYY');     // "July 16th, 2025"
+ * ```
+ */
+export declare function formatDate(date: Date | string, format?: string): string;
+/**
+ * Predefined date format constants for common legal document formats
+ *
+ * This object provides commonly used date formats in legal documents,
+ * making it easy to maintain consistency across different document types.
+ *
+ * @constant {Object} DateFormats
+ * @example
+ * ```typescript
+ * import { formatDate, DateFormats } from './date-helpers';
+ *
+ * const date = new Date('2025-07-16');
+ *
+ * // Use predefined formats
+ * formatDate(date, DateFormats.LEGAL);   // "16th day of July, 2025"
+ * formatDate(date, DateFormats.FORMAL);  // "Wednesday, July 16th, 2025"
+ * formatDate(date, DateFormats.US);      // "07/16/2025"
+ * formatDate(date, DateFormats.EU);      // "16/07/2025"
+ * ```
+ */
+export declare const DateFormats: {
+    readonly ISO: "YYYY-MM-DD";
+    readonly US: "MM/DD/YYYY";
+    readonly EU: "DD/MM/YYYY";
+    readonly UK: "DD/MM/YYYY";
+    readonly FULL: "MMMM Do, YYYY";
+    readonly FULL_US: "MMMM D, YYYY";
+    readonly SHORT: "MMM D, YYYY";
+    readonly LEGAL: "Do day of MMMM, YYYY";
+    readonly FORMAL: "dddd, MMMM Do, YYYY";
+};
+/**
+ * Parses date strings in various formats and returns a Date object
+ *
+ * Attempts to parse date strings in multiple common formats with intelligent
+ * format detection. Useful for processing user input or parsing dates from
+ * various document formats.
+ *
+ * @param {string} dateStr - The date string to parse
+ * @returns {Date | null} The parsed Date object, or null if parsing fails
+ *
+ * Supported formats:
+ * - ISO format: YYYY-MM-DD
+ * - US format: MM/DD/YYYY
+ * - European format: DD/MM/YYYY
+ * - Alternative separators: MM-DD-YYYY, DD-MM-YYYY
+ * - Natural language formats (via Date constructor)
+ *
+ * @example
+ * ```typescript
+ * // ISO format
+ * const date1 = parseDate('2025-07-16');
+ * // Result: Date object for July 16, 2025
+ *
+ * // US format (MM/DD/YYYY)
+ * const date2 = parseDate('07/16/2025');
+ * // Result: Date object for July 16, 2025
+ *
+ * // European format (DD/MM/YYYY)
+ * const date3 = parseDate('16/07/2025');
+ * // Result: Date object for July 16, 2025
+ *
+ * // Invalid date
+ * const invalid = parseDate('not a date');
+ * // Result: null
+ * ```
+ */
+export declare function parseDate(dateStr: string): Date | null;
+//# sourceMappingURL=date-helpers.d.ts.map

package/dist/helpers/date-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-helpers.d.ts","sourceRoot":"","sources":["../../src/helpers/date-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYjE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAY/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAYnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,MAAM,GAAE,MAAqB,GAAG,MAAM,CA+GrF;AA2BD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;CAUd,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAgCtD"}