legal-markdown-js 0.1.0

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

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview Import Processing Module for Legal Markdown Documents
+ *
+ * This module provides functionality to process partial imports in Legal Markdown
+ * documents, allowing for modular document construction by including external
+ * files. It supports both absolute and relative import paths, recursive import
+ * processing, and comprehensive error handling for missing files.
+ *
+ * Features:
+ * - Import syntax: @import filename
+ * - Relative and absolute path resolution
+ * - Recursive import processing (nested imports)
+ * - Import tracking and cycle detection
+ * - Error handling with fallback content
+ * - Base path resolution for project organization
+ * - Import validation and file existence checking
+ *
+ * @example
+ * ```typescript
+ * import { processPartialImports } from './import-processor';
+ *
+ * // Main document content
+ * const content = `
+ * # Service Agreement
+ *
+ * @import ./clauses/standard-terms.md
+ *
+ * ## Specific Terms
+ * @import ./clauses/payment-terms.md
+ * @import ./clauses/termination.md
+ *
+ * @import ./signatures/signature-block.md
+ * `;
+ *
+ * const result = processPartialImports(content, './contracts');
+ * console.log(result.content);      // Processed content with imports resolved
+ * console.log(result.importedFiles); // Array of imported file paths
+ * ```
+ */
+import { ImportProcessingResult } from '@types';
+/**
+ * Processes partial imports in a LegalMarkdown document
+ *
+ * This is the main function that processes import statements using the @import syntax.
+ * It recursively resolves and includes external files, tracking all imported files
+ * and handling errors gracefully when files cannot be found or loaded.
+ *
+ * @param {string} content - The document content containing import statements
+ * @param {string} [basePath] - Optional base path for resolving relative imports
+ * @returns {ImportProcessingResult} Object containing processed content and list of imported files
+ * @example
+ * ```typescript
+ * // Basic import processing
+ * const content = `
+ * # Main Document
+ * @import ./introduction.md
+ * @import ./body.md
+ * @import ./conclusion.md
+ * `;
+ *
+ * const result = processPartialImports(content, './documents');
+ * console.log(result.content);      // Content with imports resolved
+ * console.log(result.importedFiles); // ['./documents/introduction.md', './documents/body.md', './documents/conclusion.md']
+ *
+ * // Nested imports example
+ * // main.md: @import ./sections/terms.md
+ * // terms.md: @import ./subsections/payment.md
+ * // Result will include content from all three files
+ *
+ * // Error handling
+ * const contentWithMissingFile = `
+ * # Document
+ * @import ./existing.md
+ * @import ./missing.md
+ * `;
+ *
+ * const result2 = processPartialImports(contentWithMissingFile);
+ * // Result will include content from existing.md and error comment for missing.md
+ * ```
+ */
+export declare function processPartialImports(content: string, basePath?: string): ImportProcessingResult;
+/**
+ * Validates that all import paths in a document exist
+ *
+ * Checks all import statements in a document to ensure the referenced files exist
+ * on the filesystem. Returns an array of error messages for any missing files,
+ * or an empty array if all imports are valid.
+ *
+ * @param {string} content - The document content containing import statements to validate
+ * @param {string} [basePath] - Optional base path for resolving relative imports
+ * @returns {string[]} Array of validation errors, empty if all imports are valid
+ * @example
+ * ```typescript
+ * const content = `
+ * # Document
+ * @import ./existing-file.md
+ * @import ./missing-file.md
+ * @import /absolute/path/to/file.md
+ * `;
+ *
+ * const errors = validateImports(content, './documents');
+ * console.log(errors);
+ * // Output (if files are missing):
+ * // [
+ * //   "Import file not found: ./documents/missing-file.md",
+ * //   "Import file not found: /absolute/path/to/file.md"
+ * // ]
+ *
+ * // For valid imports
+ * const validContent = `@import ./existing-file.md`;
+ * const noErrors = validateImports(validContent, './documents');
+ * console.log(noErrors); // [] (empty array)
+ * ```
+ */
+export declare function validateImports(content: string, basePath?: string): string[];
+//# sourceMappingURL=import-processor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"import-processor.d.ts","sourceRoot":"","sources":["../../../src/core/processors/import-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAIH,OAAO,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,sBAAsB,CAmChG;AAwCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAqB5E"}

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

@@ -0,0 +1,236 @@
+"use strict";
+/**
+ * @fileoverview Import Processing Module for Legal Markdown Documents
+ *
+ * This module provides functionality to process partial imports in Legal Markdown
+ * documents, allowing for modular document construction by including external
+ * files. It supports both absolute and relative import paths, recursive import
+ * processing, and comprehensive error handling for missing files.
+ *
+ * Features:
+ * - Import syntax: @import filename
+ * - Relative and absolute path resolution
+ * - Recursive import processing (nested imports)
+ * - Import tracking and cycle detection
+ * - Error handling with fallback content
+ * - Base path resolution for project organization
+ * - Import validation and file existence checking
+ *
+ * @example
+ * ```typescript
+ * import { processPartialImports } from './import-processor';
+ *
+ * // Main document content
+ * const content = `
+ * # Service Agreement
+ *
+ * @import ./clauses/standard-terms.md
+ *
+ * ## Specific Terms
+ * @import ./clauses/payment-terms.md
+ * @import ./clauses/termination.md
+ *
+ * @import ./signatures/signature-block.md
+ * `;
+ *
+ * const result = processPartialImports(content, './contracts');
+ * console.log(result.content);      // Processed content with imports resolved
+ * console.log(result.importedFiles); // Array of imported file paths
+ * ```
+ */
+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.processPartialImports = processPartialImports;
+exports.validateImports = validateImports;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Processes partial imports in a LegalMarkdown document
+ *
+ * This is the main function that processes import statements using the @import syntax.
+ * It recursively resolves and includes external files, tracking all imported files
+ * and handling errors gracefully when files cannot be found or loaded.
+ *
+ * @param {string} content - The document content containing import statements
+ * @param {string} [basePath] - Optional base path for resolving relative imports
+ * @returns {ImportProcessingResult} Object containing processed content and list of imported files
+ * @example
+ * ```typescript
+ * // Basic import processing
+ * const content = `
+ * # Main Document
+ * @import ./introduction.md
+ * @import ./body.md
+ * @import ./conclusion.md
+ * `;
+ *
+ * const result = processPartialImports(content, './documents');
+ * console.log(result.content);      // Content with imports resolved
+ * console.log(result.importedFiles); // ['./documents/introduction.md', './documents/body.md', './documents/conclusion.md']
+ *
+ * // Nested imports example
+ * // main.md: @import ./sections/terms.md
+ * // terms.md: @import ./subsections/payment.md
+ * // Result will include content from all three files
+ *
+ * // Error handling
+ * const contentWithMissingFile = `
+ * # Document
+ * @import ./existing.md
+ * @import ./missing.md
+ * `;
+ *
+ * const result2 = processPartialImports(contentWithMissingFile);
+ * // Result will include content from existing.md and error comment for missing.md
+ * ```
+ */
+function processPartialImports(content, basePath) {
+    // Regular expression to match import statements
+    // Format: @import [filename]
+    const importPattern = /@import\s+(.+?)(?:\s|$)/g;
+    const importedFiles = [];
+    const processedContent = content.replace(importPattern, (match, filename) => {
+        // Clean up filename (remove quotes, etc.)
+        const cleanFilename = filename.trim().replace(/['"]/g, '');
+        try {
+            // Resolve the import path
+            const importPath = resolveImportPath(cleanFilename, basePath);
+            // Read the imported file
+            const importedContent = fs.readFileSync(importPath, 'utf8');
+            // Track imported files
+            importedFiles.push(importPath);
+            // Process nested imports
+            const nestedResult = processPartialImports(importedContent, path.dirname(importPath));
+            importedFiles.push(...nestedResult.importedFiles);
+            return nestedResult.content;
+        }
+        catch (error) {
+            console.error(`Error importing file ${cleanFilename}:`, error);
+            return `<!-- Error importing ${cleanFilename} -->`;
+        }
+    });
+    return {
+        content: processedContent,
+        importedFiles,
+    };
+}
+/**
+ * Resolves the absolute path of an import
+ *
+ * Converts relative import paths to absolute paths using the provided base path
+ * or current working directory. Handles both relative and absolute paths correctly.
+ *
+ * @private
+ * @param {string} importPath - Relative or absolute import path to resolve
+ * @param {string} [basePath] - Base path for resolving relative imports
+ * @returns {string} Absolute path to the imported file
+ * @example
+ * ```typescript
+ * // Relative path resolution
+ * const absolutePath = resolveImportPath("./clauses/terms.md", "/contracts");
+ * // Returns: "/contracts/clauses/terms.md"
+ *
+ * // Absolute path (unchanged)
+ * const absolutePath2 = resolveImportPath("/full/path/to/file.md");
+ * // Returns: "/full/path/to/file.md"
+ *
+ * // Relative to current directory
+ * const absolutePath3 = resolveImportPath("./local-file.md");
+ * // Returns: "/current/working/directory/local-file.md"
+ * ```
+ */
+function resolveImportPath(importPath, basePath) {
+    // If the import path is absolute, use it directly
+    if (path.isAbsolute(importPath)) {
+        return importPath;
+    }
+    // If no base path provided, use current working directory
+    const base = basePath || process.cwd();
+    // Resolve relative to base path
+    return path.resolve(base, importPath);
+}
+/**
+ * Validates that all import paths in a document exist
+ *
+ * Checks all import statements in a document to ensure the referenced files exist
+ * on the filesystem. Returns an array of error messages for any missing files,
+ * or an empty array if all imports are valid.
+ *
+ * @param {string} content - The document content containing import statements to validate
+ * @param {string} [basePath] - Optional base path for resolving relative imports
+ * @returns {string[]} Array of validation errors, empty if all imports are valid
+ * @example
+ * ```typescript
+ * const content = `
+ * # Document
+ * @import ./existing-file.md
+ * @import ./missing-file.md
+ * @import /absolute/path/to/file.md
+ * `;
+ *
+ * const errors = validateImports(content, './documents');
+ * console.log(errors);
+ * // Output (if files are missing):
+ * // [
+ * //   "Import file not found: ./documents/missing-file.md",
+ * //   "Import file not found: /absolute/path/to/file.md"
+ * // ]
+ *
+ * // For valid imports
+ * const validContent = `@import ./existing-file.md`;
+ * const noErrors = validateImports(validContent, './documents');
+ * console.log(noErrors); // [] (empty array)
+ * ```
+ */
+function validateImports(content, basePath) {
+    const importPattern = /@import\s+(.+?)(?:\s|$)/g;
+    const errors = [];
+    let match;
+    while ((match = importPattern.exec(content)) !== null) {
+        const filename = match[1].trim().replace(/['"]/g, '');
+        try {
+            const importPath = resolveImportPath(filename, basePath);
+            // Check if file exists
+            if (!fs.existsSync(importPath)) {
+                errors.push(`Import file not found: ${importPath}`);
+            }
+        }
+        catch (error) {
+            errors.push(`Error resolving import: ${filename}`);
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=import-processor.js.map

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

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

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

@@ -0,0 +1,93 @@
+/**
+ * @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
+ * ```
+ */
+import { LegalMarkdownOptions } from '@types';
+/**
+ * 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)"
+ * ```
+ */
+export declare function processMixins(content: string, metadata: Record<string, any>, options?: LegalMarkdownOptions): string;
+//# sourceMappingURL=mixin-processor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mixin-processor.d.ts","sourceRoot":"","sources":["../../../src/core/processors/mixin-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAmB9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,OAAO,GAAE,oBAAyB,GACjC,MAAM,CA8SR"}