legal-markdown-js 0.1.0

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

@@ -0,0 +1,378 @@
+"use strict";
+/**
+ * @fileoverview Mixin Processing Module for Legal Markdown Documents
+ *
+ * This module provides comprehensive mixin processing functionality for Legal Markdown
+ * documents, supporting variable substitution, helper functions, conditional logic,
+ * and nested value access. It integrates with the field tracking system to monitor
+ * variable usage and provides robust error handling for complex document templates.
+ *
+ * Features:
+ * - Variable substitution syntax: {{variable}}
+ * - Helper function calls: {{helperName(arg1, arg2)}}
+ * - Conditional mixins: {{condition ? trueValue : falseValue}}
+ * - Nested metadata access with dot notation
+ * - Array access with bracket notation: {{parties[0].name}}
+ * - Recursive mixin processing for nested substitutions
+ * - Field tracking integration for highlighting and validation
+ * - Special value handling (@today, booleans, numbers, strings)
+ * - Graceful error handling and fallback behavior
+ *
+ * @example
+ * ```typescript
+ * import { processMixins } from './mixin-processor';
+ *
+ * const content = `
+ * This agreement is between {{client.name}} and {{provider.name}}.
+ * {{confidentiality ? "This includes confidentiality provisions." : ""}}
+ * Total amount: {{formatCurrency(contract.amount, "USD")}}
+ * Generated on: {{formatDate(@today, "long")}}
+ * `;
+ *
+ * const metadata = {
+ *   client: { name: "Acme Corp" },
+ *   provider: { name: "Service Ltd" },
+ *   confidentiality: true,
+ *   contract: { amount: 25000 }
+ * };
+ *
+ * const processed = processMixins(content, metadata);
+ * console.log(processed);
+ * // Output:
+ * // This agreement is between Acme Corp and Service Ltd.
+ * // This includes confidentiality provisions.
+ * // Total amount: $25,000.00
+ * // Generated on: January 15, 2024
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processMixins = processMixins;
+const field_tracker_1 = require("../../tracking/field-tracker");
+const helpers_1 = require("../../helpers");
+const template_loops_1 = require("../../extensions/template-loops");
+/**
+ * Escapes HTML attribute values to prevent breaking HTML structure
+ * @param value - The value to escape
+ * @returns Escaped value safe for HTML attributes
+ */
+function escapeHtmlAttribute(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/"/g, '"')
+        .replace(/'/g, ''')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+/**
+ * Processes mixin references in legal documents
+ *
+ * This is the main function that processes mixin references using the {{variable}}
+ * syntax. It supports variable substitution, helper functions, conditional logic,
+ * and integrates with field tracking for document validation and highlighting.
+ *
+ * @param {string} content - The document content containing mixin references
+ * @param {Record<string, any>} metadata - Document metadata with variable values
+ * @param {LegalMarkdownOptions} [options={}] - Processing options
+ * @returns {string} Processed content with mixins resolved
+ * @example
+ * ```typescript
+ * // Basic variable substitution
+ * const content1 = "Hello {{user.name}}, welcome to {{company.name}}!";
+ * const metadata1 = {
+ *   user: { name: "John" },
+ *   company: { name: "Acme Corp" }
+ * };
+ * const result1 = processMixins(content1, metadata1);
+ * // Output: "Hello John, welcome to Acme Corp!"
+ *
+ * // Helper function usage
+ * const content2 = "Today is {{formatDate(@today, 'long')}}";
+ * const result2 = processMixins(content2, {});
+ * // Output: "Today is January 15, 2024"
+ *
+ * // Conditional mixins
+ * const content3 = "{{premium ? 'Premium features enabled' : 'Standard features'}}";
+ * const metadata3 = { premium: true };
+ * const result3 = processMixins(content3, metadata3);
+ * // Output: "Premium features enabled"
+ *
+ * // Array access
+ * const content4 = "Primary contact: {{contacts[0].name}} ({{contacts[0].email}})";
+ * const metadata4 = {
+ *   contacts: [
+ *     { name: "Jane Doe", email: "jane@example.com" }
+ *   ]
+ * };
+ * const result4 = processMixins(content4, metadata4);
+ * // Output: "Primary contact: Jane Doe (jane@example.com)"
+ * ```
+ */
+function processMixins(content, metadata, options = {}) {
+    if (options.noMixins) {
+        return content;
+    }
+    // Regular expression to match {{variable}} patterns
+    const mixinPattern = /\{\{([^}]+)\}\}/g;
+    /**
+     * Resolves a dot-notation path in an object, with support for array indices
+     *
+     * @private
+     * @param {any} obj - The object to traverse
+     * @param {string} path - Dot-notation path with optional array indices
+     * @returns {any} The resolved value or undefined if not found
+     * @example
+     * ```typescript
+     * const obj = {
+     *   parties: [
+     *     { name: "Company A", contact: { email: "a@example.com" } },
+     *     { name: "Company B", contact: { email: "b@example.com" } }
+     *   ]
+     * };
+     *
+     * console.log(resolvePath(obj, "parties[0].name"));           // "Company A"
+     * console.log(resolvePath(obj, "parties[1].contact.email"));  // "b@example.com"
+     * ```
+     */
+    function resolvePath(obj, path) {
+        return path.split('.').reduce((current, part) => {
+            // Handle array indices like parties.0.name
+            const match = part.match(/^(\w+)\[(\d+)\]$/);
+            if (match) {
+                const [, key, index] = match;
+                return current?.[key]?.[parseInt(index, 10)];
+            }
+            return current?.[part];
+        }, obj);
+    }
+    /**
+     * Evaluates a helper function expression with arguments
+     *
+     * @private
+     * @param {string} expression - The helper function expression (e.g., "formatDate(@today, 'long')")
+     * @param {Record<string, any>} metadata - Metadata context for argument resolution
+     * @returns {any} The result of the helper function call, or undefined if invalid
+     * @example
+     * ```typescript
+     * const result1 = evaluateHelperExpression("formatDate(@today, 'long')", {});
+     * const result2 = evaluateHelperExpression("formatCurrency(amount, 'USD')", { amount: 1500 });
+     * ```
+     */
+    function evaluateHelperExpression(expression, metadata) {
+        try {
+            // Parse helper function call: helperName(arg1, arg2, ...)
+            const match = expression.match(/^(\w+)\((.*)\)$/);
+            if (!match)
+                return undefined;
+            const [, helperName, argsString] = match;
+            const helper = helpers_1.helpers[helperName];
+            if (!helper || typeof helper !== 'function') {
+                return undefined;
+            }
+            // Parse arguments
+            const args = parseArguments(argsString, metadata);
+            // Call the helper function
+            return helper(...args);
+        }
+        catch (error) {
+            console.warn(`Error evaluating helper expression: ${expression}`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Parses comma-separated arguments from a helper function call
+     *
+     * @private
+     * @param {string} argsString - The arguments string to parse
+     * @param {Record<string, any>} metadata - Metadata context for variable resolution
+     * @returns {any[]} Array of parsed arguments
+     * @example
+     * ```typescript
+     * const args = parseArguments("'USD', amount, true", { amount: 1500 });
+     * // Returns: ["USD", 1500, true]
+     * ```
+     */
+    function parseArguments(argsString, metadata) {
+        if (!argsString.trim())
+            return [];
+        // Simple argument parsing - split by comma but handle quoted strings
+        const args = [];
+        let current = '';
+        let inQuotes = false;
+        let quoteChar = '';
+        for (let i = 0; i < argsString.length; i++) {
+            const char = argsString[i];
+            if (!inQuotes && (char === '"' || char === "'")) {
+                inQuotes = true;
+                quoteChar = char;
+                continue;
+            }
+            if (inQuotes && char === quoteChar) {
+                inQuotes = false;
+                quoteChar = '';
+                continue;
+            }
+            if (!inQuotes && char === ',') {
+                args.push(parseArgument(current.trim(), metadata));
+                current = '';
+                continue;
+            }
+            current += char;
+        }
+        if (current.trim()) {
+            args.push(parseArgument(current.trim(), metadata));
+        }
+        return args;
+    }
+    /**
+     * Parses a single argument, handling different data types and special values
+     *
+     * @private
+     * @param {string} arg - The argument string to parse
+     * @param {Record<string, any>} metadata - Metadata context for variable resolution
+     * @returns {any} The parsed argument value
+     * @example
+     * ```typescript
+     * console.log(parseArgument("'hello'", {}));     // "hello"
+     * console.log(parseArgument("123", {}));        // 123
+     * console.log(parseArgument("true", {}));       // true
+     * console.log(parseArgument("@today", {}));     // Date object
+     * console.log(parseArgument("user.name", { user: { name: "John" } })); // "John"
+     * ```
+     */
+    function parseArgument(arg, metadata) {
+        // Handle quoted strings
+        if ((arg.startsWith('"') && arg.endsWith('"')) || (arg.startsWith("'") && arg.endsWith("'"))) {
+            return arg.slice(1, -1);
+        }
+        // Handle numbers
+        if (/^-?\d+(\.\d+)?$/.test(arg)) {
+            return parseFloat(arg);
+        }
+        // Handle booleans
+        if (arg === 'true')
+            return true;
+        if (arg === 'false')
+            return false;
+        // Handle null/undefined
+        if (arg === 'null')
+            return null;
+        if (arg === 'undefined')
+            return undefined;
+        // Handle @today special value
+        if (arg === '@today') {
+            return new Date();
+        }
+        // Handle variable references
+        return resolvePath(metadata, arg);
+    }
+    /**
+     * Recursively replaces mixins in text with their resolved values
+     *
+     * @private
+     * @param {string} text - The text containing mixins to replace
+     * @param {number} [depth=0] - Current recursion depth to prevent infinite loops
+     * @returns {string} Text with mixins replaced by their values
+     * @example
+     * ```typescript
+     * const text = "Hello {{user.name}}, {{greeting ? 'Good morning' : 'Hello'}}";
+     * const result = replaceMixins(text, 0);
+     * // Processes all mixins and returns resolved text
+     * ```
+     */
+    function replaceMixins(text, depth = 0) {
+        // Prevent infinite recursion
+        if (depth > 10) {
+            return text;
+        }
+        return text.replace(mixinPattern, (match, variable) => {
+            const trimmedVar = variable.trim();
+            // Check if it's a helper function call
+            if (trimmedVar.includes('(') && trimmedVar.includes(')')) {
+                const result = evaluateHelperExpression(trimmedVar, metadata);
+                if (result !== undefined) {
+                    // Track field with helper
+                    field_tracker_1.fieldTracker.trackField(trimmedVar, {
+                        value: result,
+                        hasLogic: true,
+                        mixinUsed: 'helper',
+                    });
+                    if (options.enableFieldTracking) {
+                        return `<span class="highlight"><span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${String(result)}</span></span>`;
+                    }
+                    return String(result);
+                }
+                // Helper failed - treat as missing value
+                if (options.enableFieldTracking) {
+                    return `<span class="highlight"><span class="missing-value" data-field="${escapeHtmlAttribute(trimmedVar)}">[[${trimmedVar}]]</span></span>`;
+                }
+                return `{{${trimmedVar}}}`;
+            }
+            // Check if it's a conditional mixin
+            if (trimmedVar.includes('?')) {
+                const questionIndex = trimmedVar.indexOf('?');
+                const colonIndex = trimmedVar.indexOf(':', questionIndex);
+                if (colonIndex !== -1) {
+                    const condition = trimmedVar.substring(0, questionIndex).trim();
+                    const truePart = trimmedVar.substring(questionIndex + 1, colonIndex).trim();
+                    const falsePart = trimmedVar.substring(colonIndex + 1).trim();
+                    const conditionValue = resolvePath(metadata, condition);
+                    const selectedPart = conditionValue ? truePart : falsePart;
+                    // Track field with logic
+                    field_tracker_1.fieldTracker.trackField(condition, {
+                        value: conditionValue,
+                        hasLogic: true,
+                        mixinUsed: 'conditional',
+                    });
+                    if (selectedPart) {
+                        const processedPart = replaceMixins(selectedPart, depth + 1);
+                        if (options.enableFieldTracking) {
+                            return `<span class="highlight"><span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${processedPart}</span></span>`;
+                        }
+                        return processedPart;
+                    }
+                }
+                if (options.enableFieldTracking) {
+                    return `<span class="highlight"><span class="missing-value" data-field="${escapeHtmlAttribute(trimmedVar)}">[[${trimmedVar}]]</span></span>`;
+                }
+                return `{{${trimmedVar}}}`;
+            }
+            // Regular variable substitution
+            const value = resolvePath(metadata, trimmedVar);
+            if (value === undefined || value === null) {
+                // Track empty field
+                field_tracker_1.fieldTracker.trackField(trimmedVar, {
+                    value: undefined,
+                    hasLogic: false,
+                });
+                // Return wrapped missing value or original mixin
+                if (options.enableFieldTracking) {
+                    return `<span class="missing-value" data-field="${escapeHtmlAttribute(trimmedVar)}">[[${trimmedVar}]]</span>`;
+                }
+                return `{{${trimmedVar}}}`;
+            }
+            // Track filled field
+            field_tracker_1.fieldTracker.trackField(trimmedVar, {
+                value: value,
+                hasLogic: false,
+            });
+            // Convert value to string
+            const stringValue = String(value);
+            // Check if the result contains more mixins (nested mixins)
+            if (mixinPattern.test(stringValue)) {
+                const nestedResult = replaceMixins(stringValue, depth + 1);
+                if (options.enableFieldTracking) {
+                    return `<span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${nestedResult}</span>`;
+                }
+                return nestedResult;
+            }
+            if (options.enableFieldTracking) {
+                return `<span class="imported-value" data-field="${escapeHtmlAttribute(trimmedVar)}">${stringValue}</span>`;
+            }
+            return stringValue;
+        });
+    }
+    // First process template loops, then regular mixins
+    const loopProcessedContent = (0, template_loops_1.processTemplateLoops)(content, metadata, undefined, options.enableFieldTracking);
+    return replaceMixins(loopProcessedContent);
+}
+//# sourceMappingURL=mixin-processor.js.map

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

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

package/dist/core/processors/reference-processor.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @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.
+ * ```
+ */
+/**
+ * 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)"
+ * ```
+ */
+export declare function processCrossReferences(content: string, metadata: Record<string, any>): string;
+/**
+ * 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"
+ * ```
+ */
+export declare function formatReferenceValue(value: any, format?: string): string;
+//# sourceMappingURL=reference-processor.d.ts.map

package/dist/core/processors/reference-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-processor.d.ts","sourceRoot":"","sources":["../../../src/core/processors/reference-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CA4B7F;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBxE"}