Refactor DSV parsing functions to consolidate variable ID and delimiter parsing into a single utility function

Author: danmarshall

packages/markdown/src/plugins/dsv.ts

@@ -24,65 +24,75 @@ export interface DsvSpec {
 }
 
 /**
- * Utility function to parse variable ID from fence info.
- * Supports both "pluginName variableId" and "pluginName variableId:name" formats.
- * @param info The fence info string (e.g., "csv myData" or "csv variableId:myData")
+ * Utility function to parse DSV fence info.
+ * Supports formats like:
+ * - "dsv products delimiter:|"
+ * - "dsv delimiter:| variableId:products"
+ * - "dsv delimiter: | variableId: products"
+ * @param info The fence info string
  * @param pluginName The plugin name (csv, tsv, dsv)
  * @param index The fence index for default naming
- * @returns Object with variableId and wasDefaultId flag
+ * @returns Object with variableId, delimiter, and flags
  */
-export function parseVariableId(info: string, pluginName: string, index: number): { variableId: string; wasDefaultId: boolean } {
+export function parseDsvInfo(info: string, pluginName: string, index: number): {
+    variableId: string;
+    delimiter: string;
+    wasDefaultId: boolean;
+    wasDefaultDelimiter: boolean;
+} {
     const parts = info.trim().split(/\s+/);
 
-    // Check for explicit variableId: parameter
-    for (const part of parts) {
+    let variableId: string | null = null;
+    let delimiter: string | null = null;
+    
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        
+        // Parse variableId: parameter
         if (part.startsWith('variableId:')) {
-            return { 
-                variableId: part.slice(11).trim(), // Remove 'variableId:' prefix and trim spaces
-                wasDefaultId: false 
-            };
+            const value = part.slice(11);
+            variableId = value || (i + 1 < parts.length ? parts[++i] : null);
+        }
+        // Parse delimiter: parameter
+        else if (part.startsWith('delimiter:')) {
+            const value = part.slice(10);
+            delimiter = value || (i + 1 < parts.length ? parts[++i] : null);
+        }
+        // Direct variableId format (not a parameter key)
+        else if (i > 0 && !variableId && part !== 'variableId:' && part !== 'delimiter:') {
+            variableId = part;
         }
     }
 
-    // Check for direct format (second parameter that's not a special parameter)
-    if (parts.length >= 2) {
-        const secondPart = parts[1];
-        if (!secondPart.startsWith('delimiter:') && !secondPart.startsWith('variableId:')) {
-            return { 
-                variableId: secondPart, 
-                wasDefaultId: false 
-            };
-        }
+    // Handle special delimiter characters
+    if (delimiter) {
+        if (delimiter === '\\t') delimiter = '\t';
+        if (delimiter === '\\n') delimiter = '\n';
+        if (delimiter === '\\r') delimiter = '\r';
     }
 
-    // Default variable ID
-    return { 
-        variableId: `${pluginName}Data${index}`, 
-        wasDefaultId: true 
+    return {
+        variableId: variableId || `${pluginName}Data${index}`,
+        delimiter: delimiter || ',',
+        wasDefaultId: !variableId,
+        wasDefaultDelimiter: !delimiter
     };
 }
 
 /**
- * Utility function to parse delimiter from fence info.
- * @param info The fence info string (e.g., "dsv delimiter:| variableId:myData")
- * @returns Object with delimiter and wasDefaultDelimiter flag
+ * Utility function to parse variable ID from fence info.
+ * Used by CSV and TSV plugins.
+ * @param info The fence info string (e.g., "csv myData" or "csv variableId:myData")
+ * @param pluginName The plugin name (csv, tsv, dsv)
+ * @param index The fence index for default naming
+ * @returns Object with variableId and wasDefaultId flag
  */
-export function parseDelimiter(info: string): { delimiter: string; wasDefaultDelimiter: boolean } {
-    const parts = info.trim().split(/\s+/);
-    
-    for (const part of parts) {
-        if (part.startsWith('delimiter:')) {
-            let delimiter = part.slice(10).trim(); // Remove 'delimiter:' prefix and trim spaces
-            // Handle special cases
-            if (delimiter === '\\t') delimiter = '\t';
-            if (delimiter === '\\n') delimiter = '\n';
-            if (delimiter === '\\r') delimiter = '\r';
-            return { delimiter, wasDefaultDelimiter: false };
-        }
-    }
-    
-    // Default to comma
-    return { delimiter: ',', wasDefaultDelimiter: true };
+export function parseVariableId(info: string, pluginName: string, index: number): { variableId: string; wasDefaultId: boolean } {
+    const result = parseDsvInfo(info, pluginName, index);
+    return {
+        variableId: result.variableId,
+        wasDefaultId: result.wasDefaultId
+    };
 }
 
 function inspectDsvSpec(spec: DsvSpec): RawFlaggableSpec<DsvSpec> {
@@ -115,9 +125,8 @@ export const dsvPlugin: Plugin<DsvSpec> = {
         const content = token.content.trim();
         const info = token.info.trim();
 
-        // Use utility functions to parse delimiter and variable ID
-        const { delimiter, wasDefaultDelimiter } = parseDelimiter(info);
-        const { variableId, wasDefaultId } = parseVariableId(info, 'dsv', index);
+        // Parse both delimiter and variable ID in one pass
+        const { variableId, delimiter, wasDefaultId, wasDefaultDelimiter } = parseDsvInfo(info, 'dsv', index);
 
         return sanitizedHTML('pre', { 
             id: `${pluginName}-${index}`,