legal-markdown-js 0.1.0

package/dist/core/exporters/metadata-exporter.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * @fileoverview Metadata Export System for Legal Markdown Documents
+ *
+ * This module provides functionality for exporting document metadata to external
+ * files in various formats. It supports YAML and JSON export formats with
+ * configurable output paths and metadata filtering.
+ *
+ * Features:
+ * - Metadata export to YAML and JSON formats
+ * - Configurable output paths and filenames
+ * - Metadata filtering and processing
+ * - Internal metadata key removal
+ * - Directory creation for output files
+ * - Error handling and logging
+ * - Support for custom export configurations
+ *
+ * @example
+ * ```typescript
+ * import { exportMetadata } from './metadata-exporter';
+ *
+ * // Export metadata to YAML
+ * const result = exportMetadata(metadata, 'yaml', './output');
+ * console.log('Exported files:', result.exportedFiles);
+ *
+ * // Export with custom configuration
+ * const metadata = {
+ *   title: 'Legal Agreement',
+ *   'meta-yaml-output': 'custom-metadata.yaml',
+ *   'meta-json-output': 'custom-metadata.json'
+ * };
+ * const result = exportMetadata(metadata);
+ * ```
+ */
+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.exportMetadata = exportMetadata;
+exports.filterMetadataForExport = filterMetadataForExport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+/**
+ * Exports document metadata to external files
+ *
+ * Processes document metadata and exports it to specified formats (YAML/JSON)
+ * with support for custom output paths and metadata filtering. Handles directory
+ * creation and provides comprehensive error handling.
+ *
+ * @async
+ * @function exportMetadata
+ * @param {Record<string, any>} metadata - Document metadata to export
+ * @param {'yaml' | 'json'} [format] - Export format (yaml or json)
+ * @param {string} [outputPath] - Optional path for export files
+ * @returns {MetadataExportResult} Result object with list of exported files
+ * @example
+ * ```typescript
+ * import { exportMetadata } from './metadata-exporter';
+ *
+ * // Basic metadata export
+ * const metadata = {
+ *   title: 'Service Agreement',
+ *   author: 'Legal Team',
+ *   version: '1.0',
+ *   date: '2023-01-01'
+ * };
+ *
+ * const result = exportMetadata(metadata, 'yaml', './output');
+ * console.log('Exported to:', result.exportedFiles);
+ *
+ * // Export with custom filenames
+ * const customMetadata = {
+ *   title: 'Contract',
+ *   'meta-yaml-output': 'contract-metadata.yaml',
+ *   'meta-json-output': 'contract-metadata.json',
+ *   'meta-output-path': './custom-output'
+ * };
+ *
+ * const customResult = exportMetadata(customMetadata);
+ * ```
+ */
+function exportMetadata(metadata, format, outputPath) {
+    const exportedFiles = [];
+    // Extract export configuration from metadata
+    const yamlOutput = metadata['meta-yaml-output'];
+    const jsonOutput = metadata['meta-json-output'];
+    const customOutputPath = metadata['meta-output-path'];
+    // Determine output directory (customOutputPath from metadata takes precedence)
+    const outputDir = customOutputPath || outputPath || process.cwd();
+    // Create output directory if it doesn't exist
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // Process metadata for export (remove internal keys)
+    const exportedMetadata = filterMetadataForExport(metadata);
+    // Process YAML output if specified
+    if (yamlOutput || format === 'yaml') {
+        const yamlPath = yamlOutput
+            ? path.resolve(outputDir, yamlOutput)
+            : path.resolve(outputDir, 'metadata.yaml');
+        try {
+            const yamlContent = yaml.dump(exportedMetadata);
+            fs.writeFileSync(yamlPath, yamlContent, 'utf8');
+            exportedFiles.push(yamlPath);
+            console.log(`Exported YAML metadata to: ${yamlPath}`);
+        }
+        catch (error) {
+            console.error('Error exporting YAML metadata:', error);
+        }
+    }
+    // Process JSON output if specified
+    if (jsonOutput || format === 'json') {
+        const jsonPath = jsonOutput
+            ? path.resolve(outputDir, jsonOutput)
+            : path.resolve(outputDir, 'metadata.json');
+        try {
+            const jsonContent = JSON.stringify(exportedMetadata, null, 2);
+            fs.writeFileSync(jsonPath, jsonContent, 'utf8');
+            exportedFiles.push(jsonPath);
+            console.log(`Exported JSON metadata to: ${jsonPath}`);
+        }
+        catch (error) {
+            console.error('Error exporting JSON metadata:', error);
+        }
+    }
+    return { exportedFiles };
+}
+/**
+ * Filters metadata based on export configuration
+ *
+ * Processes metadata to remove internal configuration keys and applies filtering
+ * rules based on export settings. This ensures that only relevant metadata is
+ * included in the exported files.
+ *
+ * @function filterMetadataForExport
+ * @param {Record<string, any>} metadata - Complete metadata object to filter
+ * @returns {Record<string, any>} Filtered metadata object suitable for export
+ * @example
+ * ```typescript
+ * import { filterMetadataForExport } from './metadata-exporter';
+ *
+ * const metadata = {
+ *   title: 'Legal Agreement',
+ *   author: 'Legal Team',
+ *   'meta-yaml-output': 'output.yaml',
+ *   'meta-json-output': 'output.json',
+ *   'meta-output-path': './exports',
+ *   'meta-include-original': false
+ * };
+ *
+ * const filtered = filterMetadataForExport(metadata);
+ * // Result: { title: 'Legal Agreement', author: 'Legal Team' }
+ * // Internal meta-* keys are removed
+ * ```
+ */
+function filterMetadataForExport(metadata) {
+    // Deep clone the metadata to avoid modifying original
+    const result = JSON.parse(JSON.stringify(metadata));
+    // Remove internal export configuration keys
+    delete result['meta-yaml-output'];
+    delete result['meta-json-output'];
+    delete result['meta-output-path'];
+    delete result['meta-include-original'];
+    // Check if we should include only keys under 'meta'
+    if (metadata['meta-include-original'] === false && metadata['meta']) {
+        return { meta: result.meta };
+    }
+    return result;
+}
+//# sourceMappingURL=metadata-exporter.js.map

package/dist/core/exporters/metadata-exporter.js.map

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

package/dist/core/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Core Legal Markdown Processing Module
+ *
+ * This module provides the core functionality for Legal Markdown processing,
+ * maintaining parity with the original legal-markdown implementation. It exports
+ * all essential parsers, processors, and exporters needed for document processing.
+ *
+ * Features:
+ * - YAML front matter parsing
+ * - Header processing and numbering
+ * - Optional clause conditional processing
+ * - Cross-reference resolution
+ * - Import processing for partial documents
+ * - Mixin system for reusable content
+ * - Date processing utilities
+ * - Metadata export capabilities
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   parseYamlFrontMatter,
+ *   processHeaders,
+ *   processOptionalClauses,
+ *   processCrossReferences
+ * } from './core';
+ *
+ * // Use core processors in a custom pipeline
+ * const { content, metadata } = parseYamlFrontMatter(rawContent);
+ * const processed = processHeaders(content, metadata);
+ * ```
+ */
+export * from './parsers/yaml-parser';
+export * from './processors/header-processor';
+export * from './processors/clause-processor';
+export * from './processors/reference-processor';
+export * from './processors/import-processor';
+export * from './processors/mixin-processor';
+export * from './processors/date-processor';
+export * from './exporters/metadata-exporter';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * @fileoverview Core Legal Markdown Processing Module
+ *
+ * This module provides the core functionality for Legal Markdown processing,
+ * maintaining parity with the original legal-markdown implementation. It exports
+ * all essential parsers, processors, and exporters needed for document processing.
+ *
+ * Features:
+ * - YAML front matter parsing
+ * - Header processing and numbering
+ * - Optional clause conditional processing
+ * - Cross-reference resolution
+ * - Import processing for partial documents
+ * - Mixin system for reusable content
+ * - Date processing utilities
+ * - Metadata export capabilities
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   parseYamlFrontMatter,
+ *   processHeaders,
+ *   processOptionalClauses,
+ *   processCrossReferences
+ * } from './core';
+ *
+ * // Use core processors in a custom pipeline
+ * const { content, metadata } = parseYamlFrontMatter(rawContent);
+ * const processed = processHeaders(content, metadata);
+ * ```
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parsers/yaml-parser"), exports);
+__exportStar(require("./processors/header-processor"), exports);
+__exportStar(require("./processors/clause-processor"), exports);
+__exportStar(require("./processors/reference-processor"), exports);
+__exportStar(require("./processors/import-processor"), exports);
+__exportStar(require("./processors/mixin-processor"), exports);
+__exportStar(require("./processors/date-processor"), exports);
+__exportStar(require("./exporters/metadata-exporter"), exports);
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;;;;;;;;;;;;;;AAEH,wDAAsC;AACtC,gEAA8C;AAC9C,gEAA8C;AAC9C,mEAAiD;AACjD,gEAA8C;AAC9C,+DAA6C;AAC7C,8DAA4C;AAC5C,gEAA8C"}

package/dist/core/parsers/yaml-parser.d.ts

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview YAML Front Matter Parser for Legal Markdown Documents
+ *
+ * This module provides functionality to parse YAML front matter from Legal Markdown
+ * documents, extracting metadata and configuration options for document processing.
+ * It handles both valid and invalid YAML gracefully, with options for strict error
+ * handling when needed.
+ *
+ * Features:
+ * - YAML front matter parsing with js-yaml library
+ * - Graceful error handling for malformed YAML
+ * - Metadata extraction and validation
+ * - Content separation from front matter
+ * - YAML serialization utilities
+ * - Metadata output configuration extraction
+ *
+ * @example
+ * ```typescript
+ * import { parseYamlFrontMatter } from './yaml-parser';
+ *
+ * const content = `---
+ * title: Legal Agreement
+ * date: 2024-01-01
+ * parties:
+ *   - name: Company A
+ *     role: Provider
+ * ---
+ * # Agreement Content
+ * This is the document content.`;
+ *
+ * const result = parseYamlFrontMatter(content);
+ * console.log(result.metadata.title); // "Legal Agreement"
+ * console.log(result.content); // "# Agreement Content\nThis is the document content."
+ * ```
+ */
+import { YamlParsingResult } from '@types';
+/**
+ * Parses YAML Front Matter from a markdown document
+ *
+ * Extracts and parses YAML metadata from the beginning of a document,
+ * separated by triple dashes (---). The parser handles malformed YAML
+ * gracefully unless strict error handling is enabled.
+ *
+ * @param {string} content - The content of the document to parse
+ * @param {boolean} [throwOnError=false] - Whether to throw errors on invalid YAML
+ * @returns {YamlParsingResult} Object containing the content without YAML and the parsed metadata
+ * @throws {Error} When throwOnError is true and YAML parsing fails
+ * @example
+ * ```typescript
+ * // Basic usage with valid YAML
+ * const content = `---
+ * title: Contract
+ * version: 1.0
+ * ---
+ * # Contract Content`;
+ *
+ * const result = parseYamlFrontMatter(content);
+ * // result.metadata = { title: "Contract", version: 1.0 }
+ * // result.content = "# Contract Content"
+ *
+ * // Usage with error handling
+ * const malformedContent = `---
+ * title: Contract
+ * invalid: yaml: content
+ * ---
+ * # Content`;
+ *
+ * const safeResult = parseYamlFrontMatter(malformedContent, false);
+ * // Returns original content with empty metadata
+ *
+ * const strictResult = parseYamlFrontMatter(malformedContent, true);
+ * // Throws Error: "Invalid YAML Front Matter: ..."
+ * ```
+ */
+export declare function parseYamlFrontMatter(content: string, throwOnError?: boolean): YamlParsingResult;
+/**
+ * Serializes metadata to YAML format
+ *
+ * Converts a JavaScript object to YAML string format using js-yaml library.
+ * Handles serialization errors gracefully by returning an empty string and
+ * logging the error to the console.
+ *
+ * @param {Record<string, any>} metadata - The metadata object to serialize
+ * @returns {string} YAML string representation of the metadata
+ * @example
+ * ```typescript
+ * const metadata = {
+ *   title: "Legal Agreement",
+ *   date: "2024-01-01",
+ *   parties: [
+ *     { name: "Company A", role: "Provider" },
+ *     { name: "Company B", role: "Client" }
+ *   ]
+ * };
+ *
+ * const yamlString = serializeToYaml(metadata);
+ * console.log(yamlString);
+ * // Output:
+ * // title: Legal Agreement
+ * // date: '2024-01-01'
+ * // parties:
+ * //   - name: Company A
+ * //     role: Provider
+ * //   - name: Company B
+ * //     role: Client
+ * ```
+ */
+export declare function serializeToYaml(metadata: Record<string, any>): string;
+/**
+ * Extracts specific metadata output configuration
+ *
+ * Parses document metadata to extract configuration options for metadata output,
+ * including file paths, formats, and inclusion settings. This function looks for
+ * specially named metadata fields that control how processed metadata is exported.
+ *
+ * @param {Record<string, any>} metadata - The document metadata to extract configuration from
+ * @returns {Object} Configuration object for metadata output
+ * @returns {string} [returns.yamlOutput] - Path for YAML metadata output file
+ * @returns {string} [returns.jsonOutput] - Path for JSON metadata output file
+ * @returns {string} [returns.outputPath] - General output path for metadata files
+ * @returns {boolean} [returns.includeOriginal] - Whether to include original metadata in output
+ * @example
+ * ```typescript
+ * const metadata = {
+ *   title: "Contract",
+ *   "meta-yaml-output": "contract-metadata.yml",
+ *   "meta-json-output": "contract-metadata.json",
+ *   "meta-output-path": "./output/",
+ *   "meta-include-original": true
+ * };
+ *
+ * const config = extractMetadataOutputConfig(metadata);
+ * console.log(config);
+ * // Output:
+ * // {
+ * //   yamlOutput: "contract-metadata.yml",
+ * //   jsonOutput: "contract-metadata.json",
+ * //   outputPath: "./output/",
+ * //   includeOriginal: true
+ * // }
+ * ```
+ */
+export declare function extractMetadataOutputConfig(metadata: Record<string, any>): {
+    yamlOutput?: string;
+    jsonOutput?: string;
+    outputPath?: string;
+    includeOriginal?: boolean;
+};
+//# sourceMappingURL=yaml-parser.d.ts.map

package/dist/core/parsers/yaml-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-parser.d.ts","sourceRoot":"","sources":["../../../src/core/parsers/yaml-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,YAAY,GAAE,OAAe,GAC5B,iBAAiB,CAqDnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAOrE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAOA"}