@udx/mq 0.1.1

package/lib/utils/parser.js

@@ -0,0 +1,165 @@
+/**
+ * Parser utilities for Markdown Query
+ * 
+ * Provides utilities for parsing queries and transforming expressions
+ */
+
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import _ from 'lodash';
+
+/**
+ * Parse a query into parts
+ * Splits a query string by pipe character and trims each part
+ * 
+ * @param {string} query - Query string to parse
+ * @returns {Array} Array of query parts
+ */
+function parseQuery(query) {
+  return query.split('|').map(part => part.trim());
+}
+
+/**
+ * Parse a transform query
+ * Splits a transformation query string by pipe character and parses each part
+ * 
+ * @param {string} query - Transform query string to parse
+ * @returns {Array} Array of transform operations
+ */
+function parseTransformQuery(query) {
+  const parts = [];
+  let currentPart = '';
+  let depth = 0;
+  
+  // Parse the query, handling nested parentheses
+  for (let i = 0; i < query.length; i++) {
+    const char = query[i];
+    
+    if (char === '(') {
+      depth++;
+    } else if (char === ')') {
+      depth--;
+    }
+    
+    if (char === '|' && depth === 0) {
+      parts.push(currentPart.trim());
+      currentPart = '';
+    } else {
+      currentPart += char;
+    }
+  }
+  
+  if (currentPart.trim()) {
+    parts.push(currentPart.trim());
+  }
+  
+  // Parse each part into selector and operation
+  return parts.map(part => {
+    const match = part.match(/(.+?)\s+\|=\s+(.+)/);
+    if (match) {
+      return {
+        selector: match[1].trim(),
+        operation: match[2].trim()
+      };
+    }
+    return { selector: part.trim() };
+  });
+}
+
+/**
+ * Parse markdown to AST with error handling for malformed markdown
+ * 
+ * @param {string} markdown - Markdown content to parse
+ * @param {boolean} verbose - Whether to output verbose logs
+ * @returns {Object} Markdown AST
+ */
+function parseMarkdown(markdown, verbose = false) {
+  try {
+    return fromMarkdown(markdown);
+  } catch (parseError) {
+    if (verbose) {
+      console.error(`Warning: Error parsing markdown: ${parseError.message}`);
+    }
+    
+    // Create a simplified AST for basic operations
+    const ast = {
+      type: 'root',
+      children: []
+    };
+    
+    // Try to extract headings and content even from malformed markdown
+    const lines = markdown.split('\n');
+    let inCodeBlock = false;
+    let currentCodeBlock = null;
+    
+    for (const line of lines) {
+      // Handle code blocks
+      if (line.trim().startsWith('```')) {
+        if (!inCodeBlock) {
+          // Start of code block
+          inCodeBlock = true;
+          currentCodeBlock = {
+            type: 'code',
+            lang: line.trim().substring(3).trim(),
+            value: ''
+          };
+        } else {
+          // End of code block
+          inCodeBlock = false;
+          if (currentCodeBlock) {
+            ast.children.push(currentCodeBlock);
+            currentCodeBlock = null;
+          }
+        }
+        continue;
+      }
+      
+      // Add content to code block if we're in one
+      if (inCodeBlock && currentCodeBlock) {
+        currentCodeBlock.value += line + '\n';
+        continue;
+      }
+      
+      // Handle headings
+      if (line.startsWith('#')) {
+        // Count leading # characters for heading level
+        let level = 0;
+        for (let i = 0; i < line.length; i++) {
+          if (line[i] === '#') level++;
+          else break;
+        }
+        
+        const text = line.substring(level).trim();
+        
+        // Add heading to AST
+        ast.children.push({
+          type: 'heading',
+          depth: level,
+          children: [{ type: 'text', value: text }]
+        });
+      } else if (line.trim().length > 0) {
+        // Handle links in paragraphs
+        const linkMatch = line.match(/\[([^\]]+)\]\(([^)]+)\)/);
+        if (linkMatch) {
+          ast.children.push({
+            type: 'paragraph',
+            children: [{
+              type: 'link',
+              url: linkMatch[2],
+              children: [{ type: 'text', value: linkMatch[1] }]
+            }]
+          });
+        } else {
+          // Add paragraph for non-empty lines
+          ast.children.push({
+            type: 'paragraph',
+            children: [{ type: 'text', value: line.trim() }]
+          });
+        }
+      }
+    }
+    
+    return ast;
+  }
+}
+
+export { parseQuery, parseTransformQuery, parseMarkdown };