legal-markdown-js 0.1.0

package/dist/core/processors/reference-processor.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * @fileoverview Cross-Reference Processing Module for Legal Markdown Documents
+ *
+ * This module provides functionality to process cross-references in Legal Markdown
+ * documents, replacing reference placeholders with actual values from metadata.
+ * It supports various formatting options including date formatting, currency
+ * formatting, and nested metadata access through dot notation.
+ *
+ * Features:
+ * - Cross-reference syntax: |reference_key|
+ * - Date reference processing with @today support
+ * - Automatic currency formatting for amount fields
+ * - Nested metadata value access with dot notation
+ * - Type-aware value formatting (dates, numbers, strings)
+ * - Fallback to original reference if value not found
+ * - Integration with date-processor for date handling
+ *
+ * @example
+ * ```typescript
+ * import { processCrossReferences } from './reference-processor';
+ *
+ * const content = `
+ * This agreement is between |client.name| and |provider.name|.
+ * The total amount is |contract.amount| due on |contract.due_date|.
+ * Document generated on |@today|.
+ * `;
+ *
+ * const metadata = {
+ *   client: { name: "Acme Corp" },
+ *   provider: { name: "Service Ltd" },
+ *   contract: {
+ *     amount: 25000,
+ *     due_date: new Date("2024-12-31")
+ *   },
+ *   payment_currency: "USD"
+ * };
+ *
+ * const processed = processCrossReferences(content, metadata);
+ * console.log(processed);
+ * // Output:
+ * // This agreement is between Acme Corp and Service Ltd.
+ * // The total amount is $25,000.00 due on 2024-12-31.
+ * // Document generated on 2024-01-15.
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processCrossReferences = processCrossReferences;
+exports.formatReferenceValue = formatReferenceValue;
+const date_processor_1 = require("./date-processor");
+/**
+ * Processes cross-references in a LegalMarkdown document
+ *
+ * This is the main function that processes cross-references using the |reference_key|
+ * syntax. It first processes date references, then handles regular cross-references
+ * with automatic formatting based on value type and field names.
+ *
+ * @param {string} content - The document content containing cross-references
+ * @param {Record<string, any>} metadata - Document metadata with reference values
+ * @returns {string} Processed content with references replaced by their values
+ * @example
+ * ```typescript
+ * // Basic reference processing
+ * const content = "Payment due: |payment.amount| on |payment.date|";
+ * const metadata = {
+ *   payment: {
+ *     amount: 1500,
+ *     date: new Date("2024-03-15")
+ *   },
+ *   payment_currency: "EUR"
+ * };
+ *
+ * const result = processCrossReferences(content, metadata);
+ * // Output: "Payment due: €1,500.00 on 2024-03-15"
+ *
+ * // Nested reference access
+ * const content2 = "Contact: |client.contact.email| (|client.contact.phone|)";
+ * const metadata2 = {
+ *   client: {
+ *     contact: {
+ *       email: "info@client.com",
+ *       phone: "+1-555-0123"
+ *     }
+ *   }
+ * };
+ *
+ * const result2 = processCrossReferences(content2, metadata2);
+ * // Output: "Contact: info@client.com (+1-555-0123)"
+ * ```
+ */
+function processCrossReferences(content, metadata) {
+    // First process date references (@today)
+    const processedContent = (0, date_processor_1.processDateReferences)(content, metadata);
+    // Then process regular cross-references
+    // Format: |reference_key|
+    const referencePattern = /\|(.*?)\|/g;
+    return processedContent.replace(referencePattern, (match, key) => {
+        // Get the reference value from metadata
+        const value = getNestedValue(metadata, key.trim());
+        if (value === undefined) {
+            return match;
+        }
+        // Format value based on type
+        if (value instanceof Date) {
+            return formatDate(value);
+        }
+        else if (typeof value === 'number' && key.includes('amount')) {
+            // Format currency if key contains 'amount'
+            const currency = metadata.payment_currency || 'USD';
+            return formatCurrency(value, `currency:${currency}`);
+        }
+        // Default string conversion
+        return String(value);
+    });
+}
+/**
+ * Gets a potentially nested value from an object
+ *
+ * Traverses an object using dot notation to access nested properties safely.
+ * Returns undefined if any part of the path doesn't exist, preventing errors
+ * when accessing deeply nested properties.
+ *
+ * @private
+ * @param {Record<string, any>} obj - Object to extract value from
+ * @param {string} path - Dot-separated path to the value (e.g., "user.profile.name")
+ * @returns {any} The value at the specified path, or undefined if not found
+ * @example
+ * ```typescript
+ * const obj = {
+ *   contract: {
+ *     parties: {
+ *       client: { name: "Acme Corp", id: 12345 },
+ *       provider: { name: "Service Ltd" }
+ *     },
+ *     terms: { duration: 12 }
+ *   }
+ * };
+ *
+ * console.log(getNestedValue(obj, "contract.parties.client.name")); // "Acme Corp"
+ * console.log(getNestedValue(obj, "contract.terms.duration"));      // 12
+ * console.log(getNestedValue(obj, "contract.nonexistent"));         // undefined
+ * ```
+ */
+function getNestedValue(obj, path) {
+    const keys = path.split('.');
+    let value = obj;
+    for (const key of keys) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        value = value[key];
+    }
+    return value;
+}
+/**
+ * Processes special reference formats like dates and currency amounts
+ *
+ * Applies appropriate formatting to reference values based on their type and
+ * optional format specifiers. Handles dates, currency amounts, and falls back
+ * to string conversion for other types.
+ *
+ * @param {any} value - The reference value to format
+ * @param {string} [format] - Optional format specifier (e.g., "currency:USD:en-US")
+ * @returns {string} Formatted value as string
+ * @example
+ * ```typescript
+ * // Date formatting
+ * const date = new Date("2024-03-15");
+ * console.log(formatReferenceValue(date));           // "2024-03-15"
+ * console.log(formatReferenceValue(date, "long"));   // "March 15, 2024"
+ * console.log(formatReferenceValue(date, "short"));  // "3/15/2024"
+ *
+ * // Currency formatting
+ * console.log(formatReferenceValue(1500, "currency:USD"));       // "$1,500.00"
+ * console.log(formatReferenceValue(1500, "currency:EUR:de-DE")); // "1.500,00 €"
+ *
+ * // Default string conversion
+ * console.log(formatReferenceValue("Hello World"));  // "Hello World"
+ * console.log(formatReferenceValue(12345));          // "12345"
+ * ```
+ */
+function formatReferenceValue(value, format) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    // Handle different types
+    if (typeof value === 'object' && value instanceof Date) {
+        return formatDate(value, format);
+    }
+    if (typeof value === 'number' && format?.startsWith('currency')) {
+        return formatCurrency(value, format);
+    }
+    // Default: convert to string
+    return String(value);
+}
+/**
+ * Formats a date value
+ *
+ * Converts a Date object to a formatted string using various format options.
+ * Supports ISO format (default), short format, and long format for different
+ * document presentation needs.
+ *
+ * @private
+ * @param {Date} date - Date to format
+ * @param {string} [format] - Date format specification ("short", "long", or default ISO)
+ * @returns {string} Formatted date string
+ * @example
+ * ```typescript
+ * const date = new Date("2024-03-15T10:30:00Z");
+ *
+ * console.log(formatDate(date));         // "2024-03-15" (ISO format)
+ * console.log(formatDate(date, "short")); // "3/15/2024" (locale-specific)
+ * console.log(formatDate(date, "long"));  // "March 15, 2024" (long format)
+ * ```
+ */
+function formatDate(date, format) {
+    if (!format) {
+        // Default format: YYYY-MM-DD
+        return date.toISOString().split('T')[0];
+    }
+    // Custom date formatting
+    if (format === 'short') {
+        return date.toLocaleDateString();
+    }
+    else if (format === 'long') {
+        return date.toLocaleDateString(undefined, {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+        });
+    }
+    return date.toISOString().split('T')[0]; // Default to ISO format
+}
+/**
+ * Formats a number as currency
+ *
+ * Converts a numeric amount to a formatted currency string using the
+ * Intl.NumberFormat API. Supports different currencies and locales
+ * based on the format specification.
+ *
+ * @private
+ * @param {number} amount - Amount to format
+ * @param {string} [format] - Currency format specification ("currency:CODE:locale")
+ * @returns {string} Formatted currency string
+ * @example
+ * ```typescript
+ * console.log(formatCurrency(1500));                          // "$1,500.00" (default USD)
+ * console.log(formatCurrency(1500, "currency:EUR"));         // "€1,500.00"
+ * console.log(formatCurrency(1500, "currency:GBP:en-GB"));   // "£1,500.00"
+ * console.log(formatCurrency(1500, "currency:JPY:ja-JP"));   // "¥1,500"
+ * console.log(formatCurrency(1500, "currency:EUR:de-DE"));   // "1.500,00 €"
+ * ```
+ */
+function formatCurrency(amount, format) {
+    let currency = 'USD';
+    let locale = 'en-US';
+    // Parse format specification
+    if (format) {
+        const parts = format.split(':');
+        if (parts.length > 1) {
+            currency = parts[1].trim().toUpperCase();
+        }
+        if (parts.length > 2) {
+            locale = parts[2].trim();
+        }
+    }
+    // Format using Intl.NumberFormat
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency,
+    }).format(amount);
+}
+//# sourceMappingURL=reference-processor.js.map

package/dist/core/processors/reference-processor.js.map

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

package/dist/errors/index.d.ts

@@ -0,0 +1,234 @@
+/**
+ * @fileoverview Custom Error Classes for Legal Markdown Processing
+ *
+ * This module provides a comprehensive set of custom error classes for the Legal Markdown
+ * processing system. All errors inherit from a base LegalMarkdownError class that provides
+ * structured error handling with error codes and contextual information.
+ *
+ * Features:
+ * - Base LegalMarkdownError class with error codes and context
+ * - Specialized error classes for different failure scenarios
+ * - Structured error information for debugging and user feedback
+ * - Proper stack trace preservation
+ * - Contextual data attachment for detailed error reporting
+ * - Type-safe error handling throughout the system
+ *
+ * @example
+ * ```typescript
+ * import { YamlParsingError, FileNotFoundError, ValidationError } from './errors';
+ *
+ * // YAML parsing error
+ * throw new YamlParsingError('Invalid YAML syntax', { line: 5, column: 12 });
+ *
+ * // File not found error
+ * throw new FileNotFoundError('./missing-file.md', { operation: 'import' });
+ *
+ * // Validation error
+ * throw new ValidationError('Field is required', 'client.name', { value: '' });
+ * ```
+ */
+/**
+ * Base error class for all Legal Markdown processing errors
+ *
+ * Provides structured error handling with error codes and contextual information.
+ * All other error types in the system inherit from this base class.
+ *
+ * @class LegalMarkdownError
+ * @extends {Error}
+ * @example
+ * ```typescript
+ * import { LegalMarkdownError } from './errors';
+ *
+ * // Create a custom error with context
+ * const error = new LegalMarkdownError(
+ *   'Processing failed',
+ *   'PROCESSING_ERROR',
+ *   { file: 'contract.md', step: 'field-resolution' }
+ * );
+ *
+ * console.log(error.code); // 'PROCESSING_ERROR'
+ * console.log(error.context); // { file: 'contract.md', step: 'field-resolution' }
+ * ```
+ */
+export declare class LegalMarkdownError extends Error {
+    /** Error code for programmatic error handling */
+    readonly code: string;
+    /** Optional contextual data about the error */
+    readonly context?: Record<string, unknown>;
+    /**
+     * Creates a new LegalMarkdownError instance
+     *
+     * @param {string} message - Human-readable error message
+     * @param {string} code - Error code for programmatic handling
+     * @param {Record<string, unknown>} [context] - Optional contextual data
+     * @example
+     * ```typescript
+     * const error = new LegalMarkdownError(
+     *   'Field resolution failed',
+     *   'FIELD_RESOLUTION_ERROR',
+     *   { fieldName: 'client.name', value: undefined }
+     * );
+     * ```
+     */
+    constructor(message: string, code: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when YAML frontmatter parsing fails
+ *
+ * @class YamlParsingError
+ * @extends {LegalMarkdownError}
+ * @example
+ * ```typescript
+ * import { YamlParsingError } from './errors';
+ *
+ * // YAML parsing error with context
+ * throw new YamlParsingError('Invalid YAML syntax at line 5', {
+ *   line: 5,
+ *   column: 12,
+ *   yamlContent: 'title: "Unterminated string...'
+ * });
+ * ```
+ */
+export declare class YamlParsingError extends LegalMarkdownError {
+    /**
+     * Creates a new YamlParsingError instance
+     *
+     * @param {string} message - Human-readable error message describing the YAML parsing issue
+     * @param {Record<string, unknown>} [context] - Optional contextual data like line number, column, etc.
+     */
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when a required file cannot be found
+ *
+ * @class FileNotFoundError
+ * @extends {LegalMarkdownError}
+ * @example
+ * ```typescript
+ * import { FileNotFoundError } from './errors';
+ *
+ * // File not found during import
+ * throw new FileNotFoundError('./imports/header.md', {
+ *   operation: 'import',
+ *   basePath: './documents'
+ * });
+ * ```
+ */
+export declare class FileNotFoundError extends LegalMarkdownError {
+    /**
+     * Creates a new FileNotFoundError instance
+     *
+     * @param {string} filePath - The path of the file that could not be found
+     * @param {Record<string, unknown>} [context] - Optional contextual data like operation type, base path, etc.
+     */
+    constructor(filePath: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when import processing fails
+ *
+ * @class ImportProcessingError
+ * @extends {LegalMarkdownError}
+ * @example
+ * ```typescript
+ * import { ImportProcessingError } from './errors';
+ *
+ * // Import processing error
+ * throw new ImportProcessingError(
+ *   'Circular import detected',
+ *   './imports/header.md',
+ *   { importChain: ['main.md', 'header.md', 'header.md'] }
+ * );
+ * ```
+ */
+export declare class ImportProcessingError extends LegalMarkdownError {
+    /**
+     * Creates a new ImportProcessingError instance
+     *
+     * @param {string} message - Human-readable error message describing the import processing issue
+     * @param {string} [filePath] - Optional file path where the import error occurred
+     * @param {Record<string, unknown>} [context] - Optional contextual data like import chain, operation details, etc.
+     */
+    constructor(message: string, filePath?: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when metadata export operations fail
+ *
+ * @class MetadataExportError
+ * @extends {LegalMarkdownError}
+ * @example
+ * ```typescript
+ * import { MetadataExportError } from './errors';
+ *
+ * // Metadata export error
+ * throw new MetadataExportError(
+ *   'Failed to write metadata file',
+ *   './output/metadata.yaml',
+ *   { format: 'yaml', permissions: 'denied' }
+ * );
+ * ```
+ */
+export declare class MetadataExportError extends LegalMarkdownError {
+    /**
+     * Creates a new MetadataExportError instance
+     *
+     * @param {string} message - Human-readable error message describing the metadata export issue
+     * @param {string} [exportPath] - Optional path where the export was attempted
+     * @param {Record<string, unknown>} [context] - Optional contextual data like export format, permissions, etc.
+     */
+    constructor(message: string, exportPath?: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when document validation fails
+ *
+ * @class ValidationError
+ * @extends {LegalMarkdownError}
+ * @example
+ * ```typescript
+ * import { ValidationError } from './errors';
+ *
+ * // Validation error for a specific field
+ * throw new ValidationError(
+ *   'Field value is required',
+ *   'client.name',
+ *   { value: '', required: true, type: 'string' }
+ * );
+ * ```
+ */
+export declare class ValidationError extends LegalMarkdownError {
+    /**
+     * Creates a new ValidationError instance
+     *
+     * @param {string} message - Human-readable error message describing the validation issue
+     * @param {string} [field] - Optional field name that failed validation
+     * @param {Record<string, unknown>} [context] - Optional contextual data like expected value, validation rules, etc.
+     */
+    constructor(message: string, field?: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when general processing operations fail
+ *
+ * @class ProcessingError
+ * @extends {LegalMarkdownError}
+ * @example
+ * ```typescript
+ * import { ProcessingError } from './errors';
+ *
+ * // Processing error with processor information
+ * throw new ProcessingError(
+ *   'Field resolution failed',
+ *   'field-processor',
+ *   { fieldCount: 25, failedFields: ['client.name', 'date'] }
+ * );
+ * ```
+ */
+export declare class ProcessingError extends LegalMarkdownError {
+    /**
+     * Creates a new ProcessingError instance
+     *
+     * @param {string} message - Human-readable error message describing the processing issue
+     * @param {string} [processor] - Optional name of the processor that failed
+     * @param {Record<string, unknown>} [context] - Optional contextual data like processing stage, affected items, etc.
+     */
+    constructor(message: string, processor?: string, context?: Record<string, unknown>);
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,iDAAiD;IACjD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,+CAA+C;IAC/C,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElD;;;;;;;;;;;;;;OAcG;gBACS,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAW7E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAiB,SAAQ,kBAAkB;IACtD;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAI/D;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAkB,SAAQ,kBAAkB;IACvD;;;;;OAKG;gBACS,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAIhE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,qBAAsB,SAAQ,kBAAkB;IAC3D;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAIlF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,mBAAoB,SAAQ,kBAAkB;IACzD;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAIpF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,eAAgB,SAAQ,kBAAkB;IACrD;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAI/E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,eAAgB,SAAQ,kBAAkB;IACrD;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAInF"}