legal-markdown-js 0.1.0

package/dist/tracking/field-tracker.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * @fileoverview Field Tracking System for Legal Markdown Processing
+ *
+ * This module provides comprehensive field tracking functionality for Legal Markdown
+ * documents, including field status monitoring, highlighting support, and reporting
+ * capabilities. It tracks field processing state and applies appropriate CSS classes
+ * for visual feedback during document review.
+ *
+ * Features:
+ * - Field status tracking (filled, empty, logic)
+ * - CSS class application for field highlighting
+ * - Field processing state management
+ * - Mixin usage tracking for complex field logic
+ * - Reporting and analytics for field usage
+ * - Singleton pattern for consistent tracking across the application
+ *
+ * @example
+ * ```typescript
+ * import { fieldTracker, FieldStatus } from './field-tracker';
+ *
+ * // Track a field during processing
+ * fieldTracker.trackField('client.name', {
+ *   value: 'Acme Corporation',
+ *   status: FieldStatus.FILLED
+ * });
+ *
+ * // Apply field tracking to content
+ * const highlightedContent = fieldTracker.applyFieldTracking(processedContent);
+ *
+ * // Generate field report
+ * const report = fieldTracker.generateReport();
+ * console.log(`${report.filled} fields filled, ${report.empty} fields empty`);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldTracker = exports.FieldTracker = exports.FieldStatus = void 0;
+const logger_1 = require("../utils/logger");
+/**
+ * Enumeration of possible field statuses during processing
+ *
+ * @enum {string} FieldStatus
+ * @example
+ * ```typescript
+ * import { FieldStatus } from './field-tracker';
+ *
+ * // Check field status
+ * if (field.status === FieldStatus.FILLED) {
+ *   console.log('Field has a value');
+ * } else if (field.status === FieldStatus.EMPTY) {
+ *   console.log('Field needs a value');
+ * } else if (field.status === FieldStatus.LOGIC) {
+ *   console.log('Field uses conditional logic');
+ * }
+ * ```
+ */
+var FieldStatus;
+(function (FieldStatus) {
+    /** Field has been filled with a value */
+    FieldStatus["FILLED"] = "filled";
+    /** Field is empty or missing a value */
+    FieldStatus["EMPTY"] = "empty";
+    /** Field contains logic or uses mixins */
+    FieldStatus["LOGIC"] = "logic";
+})(FieldStatus || (exports.FieldStatus = FieldStatus = {}));
+/**
+ * Field tracking system for Legal Markdown processing
+ *
+ * Manages field tracking throughout the document processing lifecycle,
+ * including status monitoring, highlighting, and reporting capabilities.
+ *
+ * @class FieldTracker
+ * @example
+ * ```typescript
+ * import { FieldTracker, FieldStatus } from './field-tracker';
+ *
+ * const tracker = new FieldTracker();
+ *
+ * // Track field processing
+ * tracker.trackField('client.name', {
+ *   value: 'Acme Corp',
+ *   originalValue: '{{client.name}}',
+ *   hasLogic: false
+ * });
+ *
+ * // Apply tracking to content
+ * const highlighted = tracker.applyFieldTracking(content);
+ *
+ * // Generate report
+ * const report = tracker.generateReport();
+ * ```
+ */
+class FieldTracker {
+    /**
+     * Creates a new FieldTracker instance
+     *
+     * @constructor
+     */
+    constructor() {
+        this.fields = new Map();
+        this.processedContent = '';
+    }
+    /**
+     * Track a field that has been processed
+     *
+     * Registers a field with the tracking system, determining its status based on
+     * the provided options and storing relevant metadata for later use.
+     *
+     * @method trackField
+     * @param {string} fieldName - The name/identifier of the field to track
+     * @param {Object} options - Options for field tracking
+     * @param {any} [options.value] - The processed value of the field
+     * @param {any} [options.originalValue] - The original unprocessed value
+     * @param {boolean} [options.hasLogic=false] - Whether the field contains logical operations
+     * @param {string} [options.mixinUsed] - Name of mixin used for processing
+     * @returns {void}
+     * @example
+     * ```typescript
+     * // Track a filled field
+     * tracker.trackField('client.name', {
+     *   value: 'Acme Corporation',
+     *   originalValue: '{{client.name}}'
+     * });
+     *
+     * // Track an empty field
+     * tracker.trackField('client.address', {
+     *   value: '',
+     *   originalValue: '{{client.address}}'
+     * });
+     *
+     * // Track a field with logic
+     * tracker.trackField('warranty.clause', {
+     *   value: 'Standard warranty applies',
+     *   originalValue: '{{#if warranty.enabled}}{{warranty.text}}{{/if}}',
+     *   hasLogic: true,
+     *   mixinUsed: 'warranty-mixin'
+     * });
+     * ```
+     */
+    trackField(fieldName, options) {
+        const { value, originalValue, hasLogic = false, mixinUsed } = options;
+        let status;
+        if (hasLogic || mixinUsed) {
+            status = FieldStatus.LOGIC;
+        }
+        else if (value === undefined || value === null || value === '') {
+            status = FieldStatus.EMPTY;
+        }
+        else {
+            status = FieldStatus.FILLED;
+        }
+        const field = {
+            name: fieldName,
+            status,
+            value,
+            originalValue,
+            hasLogic,
+            mixinUsed,
+        };
+        this.fields.set(fieldName, field);
+        logger_1.logger.debug('Field tracked', { fieldName, status, hasLogic });
+    }
+    /**
+     * Apply field tracking to processed content by wrapping fields with appropriate CSS classes
+     */
+    applyFieldTracking(content) {
+        let processedContent = content;
+        this.fields.forEach((field, fieldName) => {
+            const cssClass = this.getFieldCssClass(field.status);
+            // Create regex to find field references in the content
+            // This looks for {{fieldName}} patterns that haven't been processed yet
+            const fieldPattern = new RegExp(`\\{\\{\\s*${fieldName}\\s*\\}\\}`, 'g');
+            // If the field has a value, look for the rendered value in the content
+            if (field.value !== undefined && field.value !== null && field.value !== '') {
+                const valuePattern = new RegExp(`(?<!<span[^>]*>)${this.escapeRegex(String(field.value))}(?!</span>)`, 'g');
+                processedContent = processedContent.replace(valuePattern, match => {
+                    return `<span class="${cssClass}" data-field="${fieldName}">${match}</span>`;
+                });
+            }
+            else {
+                // For empty fields, wrap the placeholder or empty space
+                processedContent = processedContent.replace(fieldPattern, match => {
+                    return `<span class="${cssClass}" data-field="${fieldName}">[${fieldName}]</span>`;
+                });
+            }
+        });
+        this.processedContent = processedContent;
+        return processedContent;
+    }
+    /**
+     * Get CSS class for field based on its status
+     */
+    getFieldCssClass(status) {
+        switch (status) {
+            case FieldStatus.FILLED:
+                return 'imported-value';
+            case FieldStatus.EMPTY:
+                return 'missing-value';
+            case FieldStatus.LOGIC:
+                return 'highlight';
+            default:
+                return '';
+        }
+    }
+    /**
+     * Escape special regex characters in a string
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Get all tracked fields
+     */
+    getFields() {
+        return new Map(this.fields);
+    }
+    /**
+     * Get fields by status
+     */
+    getFieldsByStatus(status) {
+        return Array.from(this.fields.values()).filter(field => field.status === status);
+    }
+    /**
+     * Generate a summary report of tracked fields
+     */
+    generateReport() {
+        const fields = Array.from(this.fields.values());
+        return {
+            total: fields.length,
+            filled: fields.filter(f => f.status === FieldStatus.FILLED).length,
+            empty: fields.filter(f => f.status === FieldStatus.EMPTY).length,
+            logic: fields.filter(f => f.status === FieldStatus.LOGIC).length,
+            fields,
+        };
+    }
+    /**
+     * Clear all tracked fields
+     */
+    clear() {
+        this.fields.clear();
+        this.processedContent = '';
+    }
+}
+exports.FieldTracker = FieldTracker;
+// Export singleton instance
+exports.fieldTracker = new FieldTracker();
+//# sourceMappingURL=field-tracker.js.map

package/dist/tracking/field-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-tracker.js","sourceRoot":"","sources":["../../src/tracking/field-tracker.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;;;AAEH,4CAAyC;AAEzC;;;;;;;;;;;;;;;;;GAiBG;AACH,IAAY,WAOX;AAPD,WAAY,WAAW;IACrB,yCAAyC;IACzC,gCAAiB,CAAA;IACjB,wCAAwC;IACxC,8BAAe,CAAA;IACf,0CAA0C;IAC1C,8BAAe,CAAA;AACjB,CAAC,EAPW,WAAW,2BAAX,WAAW,QAOtB;AAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,YAAY;IAIvB;;;;OAIG;IACH;QARQ,WAAM,GAA8B,IAAI,GAAG,EAAE,CAAC;QAC9C,qBAAgB,GAAW,EAAE,CAAC;IAOvB,CAAC;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,UAAU,CACR,SAAiB,EACjB,OAKC;QAED,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,GAAG,KAAK,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;QAEtE,IAAI,MAAmB,CAAC;QACxB,IAAI,QAAQ,IAAI,SAAS,EAAE,CAAC;YAC1B,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC;QAC7B,CAAC;aAAM,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;YACjE,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;QAC9B,CAAC;QAED,MAAM,KAAK,GAAiB;YAC1B,IAAI,EAAE,SAAS;YACf,MAAM;YACN,KAAK;YACL,aAAa;YACb,QAAQ;YACR,SAAS;SACV,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAClC,eAAM,CAAC,KAAK,CAAC,eAAe,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IACjE,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,OAAe;QAChC,IAAI,gBAAgB,GAAG,OAAO,CAAC;QAE/B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;YACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAErD,uDAAuD;YACvD,wEAAwE;YACxE,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,aAAa,SAAS,YAAY,EAAE,GAAG,CAAC,CAAC;YAEzE,uEAAuE;YACvE,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,KAAK,KAAK,EAAE,EAAE,CAAC;gBAC5E,MAAM,YAAY,GAAG,IAAI,MAAM,CAC7B,mBAAmB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,aAAa,EACrE,GAAG,CACJ,CAAC;gBAEF,gBAAgB,GAAG,gBAAgB,CAAC,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,EAAE;oBAChE,OAAO,gBAAgB,QAAQ,iBAAiB,SAAS,KAAK,KAAK,SAAS,CAAC;gBAC/E,CAAC,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,wDAAwD;gBACxD,gBAAgB,GAAG,gBAAgB,CAAC,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,EAAE;oBAChE,OAAO,gBAAgB,QAAQ,iBAAiB,SAAS,MAAM,SAAS,UAAU,CAAC;gBACrF,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;QACzC,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,MAAmB;QAC1C,QAAQ,MAAM,EAAE,CAAC;YACf,KAAK,WAAW,CAAC,MAAM;gBACrB,OAAO,gBAAgB,CAAC;YAC1B,KAAK,WAAW,CAAC,KAAK;gBACpB,OAAO,eAAe,CAAC;YACzB,KAAK,WAAW,CAAC,KAAK;gBACpB,OAAO,WAAW,CAAC;YACrB;gBACE,OAAO,EAAE,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,WAAW,CAAC,GAAW;QAC7B,OAAO,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,MAAmB;QACnC,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;IACnF,CAAC;IAED;;OAEG;IACH,cAAc;QAOZ,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;QAEhD,OAAO;YACL,KAAK,EAAE,MAAM,CAAC,MAAM;YACpB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC,MAAM;YAClE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,WAAW,CAAC,KAAK,CAAC,CAAC,MAAM;YAChE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,WAAW,CAAC,KAAK,CAAC,CAAC,MAAM;YAChE,MAAM;SACP,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;IAC7B,CAAC;CACF;AArLD,oCAqLC;AAED,4BAA4B;AACf,QAAA,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,186 @@
+/**
+ * @fileoverview Type Definitions for Legal Markdown Processing
+ *
+ * This module contains TypeScript interface definitions and type declarations
+ * for the Legal Markdown processing system. It defines the structure for
+ * configuration options, processing results, and internal data structures.
+ *
+ * Features:
+ * - Processing configuration interfaces
+ * - YAML front matter parsing result types
+ * - Header processing option structures
+ * - Import and export result definitions
+ * - Metadata handling type definitions
+ *
+ * @example
+ * ```typescript
+ * import { LegalMarkdownOptions, YamlParsingResult } from './types';
+ *
+ * const options: LegalMarkdownOptions = {
+ *   basePath: './documents',
+ *   enableFieldTracking: true,
+ *   exportFormat: 'yaml'
+ * };
+ *
+ * const result: YamlParsingResult = {
+ *   content: 'processed content',
+ *   metadata: { title: 'Document Title' }
+ * };
+ * ```
+ */
+/**
+ * Configuration options for processing Legal Markdown documents
+ *
+ * @interface LegalMarkdownOptions
+ */
+export interface LegalMarkdownOptions {
+    /**
+     * Base path for resolving imports
+     */
+    basePath?: string;
+    /**
+     * Process only YAML front matter
+     */
+    yamlOnly?: boolean;
+    /**
+     * Skip processing headers
+     */
+    noHeaders?: boolean;
+    /**
+     * Skip processing optional clauses
+     */
+    noClauses?: boolean;
+    /**
+     * Skip processing cross references
+     */
+    noReferences?: boolean;
+    /**
+     * Skip processing imports
+     */
+    noImports?: boolean;
+    /**
+     * Skip processing mixins
+     */
+    noMixins?: boolean;
+    /**
+     * Convert output to markdown format
+     */
+    toMarkdown?: boolean;
+    /**
+     * Export metadata to a file
+     */
+    exportMetadata?: boolean;
+    /**
+     * Format for metadata export (yaml or json)
+     */
+    exportFormat?: 'yaml' | 'json';
+    /**
+     * Path for metadata export
+     */
+    exportPath?: string;
+    /**
+     * Enable debug mode
+     */
+    debug?: boolean;
+    /**
+     * Throw errors on invalid YAML instead of handling gracefully
+     */
+    throwOnYamlError?: boolean;
+    /**
+     * Disable header numbering reset (continuous numbering)
+     */
+    noReset?: boolean;
+    /**
+     * Disable header indentation (flat formatting)
+     */
+    noIndent?: boolean;
+    /**
+     * Enable field tracking for highlighting
+     */
+    enableFieldTracking?: boolean;
+}
+/**
+ * Structure for YAML Front Matter parsing result
+ *
+ * @interface YamlParsingResult
+ */
+export interface YamlParsingResult {
+    /**
+     * Content without the YAML front matter
+     */
+    content: string;
+    /**
+     * Parsed metadata from YAML front matter
+     */
+    metadata: Record<string, any>;
+}
+/**
+ * Structure for header processing options from metadata
+ *
+ * @interface HeaderOptions
+ */
+export interface HeaderOptions {
+    /**
+     * Format for level one headers
+     */
+    levelOne?: string;
+    /**
+     * Format for level two headers
+     */
+    levelTwo?: string;
+    /**
+     * Format for level three headers
+     */
+    levelThree?: string;
+    /**
+     * Format for level four headers
+     */
+    levelFour?: string;
+    /**
+     * Format for level five headers
+     */
+    levelFive?: string;
+    /**
+     * Indentation level for headers
+     */
+    levelIndent?: number;
+    /**
+     * Disable header numbering reset (continuous numbering)
+     */
+    noReset?: boolean;
+    /**
+     * Disable header indentation (flat formatting)
+     */
+    noIndent?: boolean;
+    /**
+     * Enable field tracking for header styling
+     */
+    enableFieldTracking?: boolean;
+}
+/**
+ * Structure for import processing result
+ *
+ * @interface ImportProcessingResult
+ */
+export interface ImportProcessingResult {
+    /**
+     * Content with imports processed
+     */
+    content: string;
+    /**
+     * List of imported files
+     */
+    importedFiles: string[];
+}
+/**
+ * Structure for metadata export result
+ *
+ * @interface MetadataExportResult
+ */
+export interface MetadataExportResult {
+    /**
+     * List of exported files
+     */
+    exportedFiles: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE/B;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB"}

package/dist/types.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @fileoverview Type Definitions for Legal Markdown Processing
+ *
+ * This module contains TypeScript interface definitions and type declarations
+ * for the Legal Markdown processing system. It defines the structure for
+ * configuration options, processing results, and internal data structures.
+ *
+ * Features:
+ * - Processing configuration interfaces
+ * - YAML front matter parsing result types
+ * - Header processing option structures
+ * - Import and export result definitions
+ * - Metadata handling type definitions
+ *
+ * @example
+ * ```typescript
+ * import { LegalMarkdownOptions, YamlParsingResult } from './types';
+ *
+ * const options: LegalMarkdownOptions = {
+ *   basePath: './documents',
+ *   enableFieldTracking: true,
+ *   exportFormat: 'yaml'
+ * };
+ *
+ * const result: YamlParsingResult = {
+ *   content: 'processed content',
+ *   metadata: { title: 'Document Title' }
+ * };
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @fileoverview Lightweight Logging Utility for Legal Markdown Processing
+ *
+ * This module provides a simple, efficient logging utility for the Legal Markdown
+ * processing system. It offers structured logging with different levels and
+ * optional data context support.
+ *
+ * Features:
+ * - Multiple log levels (debug, info, warn, error)
+ * - Debug mode controlled by environment variable
+ * - Structured logging with contextual data
+ * - Console-based output with formatted prefixes
+ * - Optional data parameter for detailed logging
+ * - Lightweight with no external dependencies
+ *
+ * @example
+ * ```typescript
+ * import { logger } from './logger';
+ *
+ * // Basic logging
+ * logger.info('Processing legal document');
+ * logger.warn('Missing field detected');
+ * logger.error('Failed to parse YAML');
+ *
+ * // Logging with context data
+ * logger.debug('Field processed', { fieldName: 'client.name', value: 'Acme Corp' });
+ * logger.info('Document exported', { format: 'pdf', size: '2.3MB' });
+ * ```
+ */
+/**
+ * Simple logger utility for Legal Markdown processing
+ *
+ * Provides structured logging with different levels and optional context data.
+ * Debug logging is only enabled when DEBUG environment variable is set.
+ *
+ * @constant {Object} logger
+ * @example
+ * ```typescript
+ * import { logger } from './logger';
+ *
+ * // Set DEBUG=true in environment to see debug logs
+ * logger.debug('Processing started', { file: 'contract.md' });
+ * logger.info('Document processed successfully');
+ * logger.warn('Optional field missing', { field: 'client.address' });
+ * logger.error('Processing failed', { error: 'Invalid syntax' });
+ * ```
+ */
+export declare const logger: {
+    /**
+     * Log debug messages (only shown when DEBUG environment variable is set)
+     *
+     * @method debug
+     * @param {string} message - The debug message to log
+     * @param {any} [data] - Optional contextual data to include with the log
+     * @returns {void}
+     * @example
+     * ```typescript
+     * // Enable debug mode: DEBUG=true node app.js
+     * logger.debug('Processing field', { name: 'client.name', type: 'string' });
+     * logger.debug('Import resolved', { path: './shared/header.md' });
+     * ```
+     */
+    debug: (message: string, data?: any) => void;
+    /**
+     * Log informational messages
+     *
+     * @method info
+     * @param {string} message - The informational message to log
+     * @param {any} [data] - Optional contextual data to include with the log
+     * @returns {void}
+     * @example
+     * ```typescript
+     * logger.info('Document processing completed');
+     * logger.info('Export successful', { format: 'html', path: './output.html' });
+     * ```
+     */
+    info: (message: string, data?: any) => void;
+    /**
+     * Log warning messages
+     *
+     * @method warn
+     * @param {string} message - The warning message to log
+     * @param {any} [data] - Optional contextual data to include with the log
+     * @returns {void}
+     * @example
+     * ```typescript
+     * logger.warn('Missing optional field', { field: 'client.phone' });
+     * logger.warn('Import file not found', { path: './missing.md' });
+     * ```
+     */
+    warn: (message: string, data?: any) => void;
+    /**
+     * Log error messages
+     *
+     * @method error
+     * @param {string} message - The error message to log
+     * @param {any} [data] - Optional contextual data to include with the log
+     * @returns {void}
+     * @example
+     * ```typescript
+     * logger.error('Failed to parse YAML frontmatter', { error: 'Invalid syntax' });
+     * logger.error('Document processing failed', { file: 'contract.md', reason: 'Missing imports' });
+     * ```
+     */
+    error: (message: string, data?: any) => void;
+};
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;;;;;;;;OAaG;qBACc,MAAM,SAAS,GAAG;IAQnC;;;;;;;;;;;;OAYG;oBACa,MAAM,SAAS,GAAG;IAIlC;;;;;;;;;;;;OAYG;oBACa,MAAM,SAAS,GAAG;IAIlC;;;;;;;;;;;;OAYG;qBACc,MAAM,SAAS,GAAG;CAGpC,CAAC"}