@zxsylph/dbml-formatter 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zxsylph/dbml-formatter",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "",
   "files": [
     "bin",

package/src/cli.ts

@@ -55,7 +55,7 @@ if (folderIndex !== -1) {
         files.forEach(file => {
              try {
                 const content = fs.readFileSync(file, 'utf-8');
-                const formatted = format(content, { orderField });
+                const formatted = format(content, { orderField, addNote: args.includes('--add-note') });
                 
                 if (isDryRun) {
                     console.log(`\n--- Dry Run: ${file} ---`);
@@ -88,7 +88,7 @@ if (folderIndex !== -1) {
 
     try {
         const content = fs.readFileSync(absPath, 'utf-8');
-        const formatted = format(content, { orderField });
+        const formatted = format(content, { orderField, addNote: args.includes('--add-note') });
         console.log(formatted);
     } catch (error) {
         console.error('Error formatting file:', error);

package/src/formatter/formatter.ts

@@ -4,6 +4,7 @@ export interface FormatterOptions {
     indentSize?: number;
     useTabs?: boolean;
     orderField?: boolean;
+    addNote?: boolean;
 }
 
 export function format(input: string, options: FormatterOptions = {}): string {
@@ -144,6 +145,21 @@ export function format(input: string, options: FormatterOptions = {}): string {
                          otherLinesGroups.push(currentGroup);
                      }
                  }
+
+                 // NEW: Trim leading and trailing empty lines (whitespace-only groups) from otherLinesGroups
+                 // Note: we do not touch tableNoteTokens here.
+                 
+                 const isWhitespaceGroup = (g: Token[]) => g.every(t => t.type === TokenType.Whitespace);
+                 
+                 // Trim start
+                 while (otherLinesGroups.length > 0 && isWhitespaceGroup(otherLinesGroups[0])) {
+                     otherLinesGroups.shift();
+                 }
+                 
+                 // Trim end
+                 while (otherLinesGroups.length > 0 && isWhitespaceGroup(otherLinesGroups[otherLinesGroups.length - 1])) {
+                     otherLinesGroups.pop();
+                 }
                  
                  // 4. Print Table Note first (if exists)
                  if (tableNoteTokens.length > 0) {
@@ -164,7 +180,9 @@ export function format(input: string, options: FormatterOptions = {}): string {
                      }
                  } else {
                      // NEW: If no table note, add empty Note: ""
-                     output += getIndent() + 'Note: ""\n\n';
+                     if (options.addNote) {
+                        output += getIndent() + 'Note: ""\n\n';
+                     }
                  }
 
                  // OPTIONAL: Sort Fields within groups
@@ -249,7 +267,9 @@ export function format(input: string, options: FormatterOptions = {}): string {
                      }
                  }
                  
-                 // 5. Print other lines (Process Fields)
+                 // 5. Process Fields (Transform -> Align -> Print)
+                 
+                 // 5a. Transformation Pass
                  for (let lgIdx = 0; lgIdx < otherLinesGroups.length; lgIdx++) {
                      const lineTokens = otherLinesGroups[lgIdx];
                      // Check for Field Settings `[...]` reordering
@@ -307,7 +327,7 @@ export function format(input: string, options: FormatterOptions = {}): string {
                          }
                      }
                      
-                     // 6. Apply "Empty Field Note" logic
+                     // Apply "Empty Field Note" logic
                      const meaningful = lineTokens.filter(t => t.type !== TokenType.Whitespace && t.type !== TokenType.Comment);
                      // Heuristic: Is this a field? 
                      // It should have at least 2 tokens (Name, Type). 
@@ -326,69 +346,66 @@ export function format(input: string, options: FormatterOptions = {}): string {
                          }
                      }
                      
-                     if (isField) {
-                         // Find settings block
-                         let openBracketIdx = -1;
-                         let closeBracketIdx = -1;
-                         for(let idx=0; idx<lineTokens.length; idx++) {
-                             if (lineTokens[idx].type === TokenType.Symbol && lineTokens[idx].value === '[') openBracketIdx = idx;
-                             if (lineTokens[idx].type === TokenType.Symbol && lineTokens[idx].value === ']') closeBracketIdx = idx;
-                         }
-                         
-                         if (openBracketIdx !== -1 && closeBracketIdx !== -1 && closeBracketIdx > openBracketIdx) {
-                             // Settings exist. Check if 'note' is present.
-                             const inside = lineTokens.slice(openBracketIdx + 1, closeBracketIdx);
-                             let hasNote = false;
-                             
-                             // Simple token scan for 'note' word
-                             // Ideally we should parse comma groups, but 'note' keyword is reserved in settings.
-                             for (const t of inside) {
-                                 if (t.type === TokenType.Word && t.value.toLowerCase() === 'note') {
-                                     hasNote = true;
-                                     break;
-                                 }
-                             }
-                             
-                             if (!hasNote) {
-                                 // Insert `note: ""` at the beginning of settings
-                                 // We need to insert: "note", ":", "\"\"", ","
-                                 // REMOVED explicit spaces
-                                 const newTokens: Token[] = [
-                                     { type: TokenType.Word, value: 'note', line: 0, column: 0 },
-                                     { type: TokenType.Symbol, value: ':', line: 0, column: 0 },
-                                     { type: TokenType.String, value: '""', line: 0, column: 0 },
-                                     { type: TokenType.Symbol, value: ',', line: 0, column: 0 }
-                                 ];
-                                 lineTokens.splice(openBracketIdx + 1, 0, ...newTokens);
-                             }
-                         } else {
-                             // No settings exist. Append ` [note: ""]`.
-                             // REMOVED explicit spaces
-                             
-                             // Find last meaningful token index
-                             let lastMeaningfulIdx = -1;
-                             for (let idx = lineTokens.length - 1; idx >= 0; idx--) {
-                                 if (lineTokens[idx].type !== TokenType.Whitespace && lineTokens[idx].type !== TokenType.Comment) {
-                                     lastMeaningfulIdx = idx;
-                                     break;
-                                 }
-                             }
-                             
-                             if (lastMeaningfulIdx !== -1) {
-                                 const appendTokens: Token[] = [
-                                     { type: TokenType.Symbol, value: '[', line: 0, column: 0 },
-                                     { type: TokenType.Word, value: 'note', line: 0, column: 0 },
-                                     { type: TokenType.Symbol, value: ':', line: 0, column: 0 },
-                                     { type: TokenType.String, value: '""', line: 0, column: 0 },
-                                     { type: TokenType.Symbol, value: ']', line: 0, column: 0 }
-                                 ];
-                                 lineTokens.splice(lastMeaningfulIdx + 1, 0, ...appendTokens);
-                             }
-                         }
-                     }
-
-                     // 7. Apply "Quote Data Types" logic
+                     if (isField && options.addNote) {
+                          // Find settings block
+                          let openBracketIdx = -1;
+                          let closeBracketIdx = -1;
+                          for(let idx=0; idx<lineTokens.length; idx++) {
+                              if (lineTokens[idx].type === TokenType.Symbol && lineTokens[idx].value === '[') openBracketIdx = idx;
+                              if (lineTokens[idx].type === TokenType.Symbol && lineTokens[idx].value === ']') closeBracketIdx = idx;
+                          }
+                          
+                          if (openBracketIdx !== -1 && closeBracketIdx !== -1 && closeBracketIdx > openBracketIdx) {
+                              // Settings exist. Check if 'note' is present.
+                              const inside = lineTokens.slice(openBracketIdx + 1, closeBracketIdx);
+                              let hasNote = false;
+                              
+                              // Simple token scan for 'note' word
+                              // Ideally we should parse comma groups, but 'note' keyword is reserved in settings.
+                              for (const t of inside) {
+                                  if (t.type === TokenType.Word && t.value.toLowerCase() === 'note') {
+                                      hasNote = true;
+                                      break;
+                                  }
+                              }
+                              
+                              if (!hasNote) {
+                                  // Insert `note: ""` at the beginning of settings
+                                  // We need to insert: "note", ":", "\"\"", ","
+                                  const newTokens: Token[] = [
+                                      { type: TokenType.Word, value: 'note', line: 0, column: 0 },
+                                      { type: TokenType.Symbol, value: ':', line: 0, column: 0 },
+                                      { type: TokenType.String, value: '""', line: 0, column: 0 },
+                                      { type: TokenType.Symbol, value: ',', line: 0, column: 0 }
+                                  ];
+                                  lineTokens.splice(openBracketIdx + 1, 0, ...newTokens);
+                              }
+                          } else {
+                              // No settings exist. Append ` [note: ""]`.
+                              
+                              // Find last meaningful token index
+                              let lastMeaningfulIdx = -1;
+                              for (let idx = lineTokens.length - 1; idx >= 0; idx--) {
+                                  if (lineTokens[idx].type !== TokenType.Whitespace && lineTokens[idx].type !== TokenType.Comment) {
+                                      lastMeaningfulIdx = idx;
+                                      break;
+                                  }
+                              }
+                              
+                              if (lastMeaningfulIdx !== -1) {
+                                  const appendTokens: Token[] = [
+                                      { type: TokenType.Symbol, value: '[', line: 0, column: 0 },
+                                      { type: TokenType.Word, value: 'note', line: 0, column: 0 },
+                                      { type: TokenType.Symbol, value: ':', line: 0, column: 0 },
+                                      { type: TokenType.String, value: '""', line: 0, column: 0 },
+                                      { type: TokenType.Symbol, value: ']', line: 0, column: 0 }
+                                  ];
+                                  lineTokens.splice(lastMeaningfulIdx + 1, 0, ...appendTokens);
+                              }
+                          }
+                      }
 
+                     // Apply "Quote Data Types" logic
                     let wordCount = 0;
                     for (const t of lineTokens) {
                          // Only count words before `[`?
@@ -398,39 +415,148 @@ export function format(input: string, options: FormatterOptions = {}): string {
                              if (wordCount === 2) {
                                  // Quote this token!
                                  t.value = `"${t.value}"`; 
-                                 // Note: we are modifying the token object directly in the buffer.
                              }
                          }
                          if (t.type === TokenType.String && wordCount < 2) { 
-                             // Strings count as words/tokens for position?
-                             // Example `name "varchar"` -> "varchar" IS the string.
                              wordCount++; 
                          }
                     }
+                 }
 
-                    // Ensure previous line enforced newline if missing?
-                    // processTokens appends tokens. If tokens lack newline, it might merge?
-                    // `lineTokens` usually comes from `currentGroup` which ended with newline token (except last one).
-                    // If last group lacks newline, and we print next group...
-                    
-                    // Check if output buffer needs separation?
-                    // processTokens logic respects local newlines inside `lineTokens`.
-                    // But if `lineTokens` (last group) didn't have newline, we append.
-                    
-                    output += processTokens(lineTokens, indentLevel, indentChar, indentSize, true);
-                    
-                    // Heuristic: If we just printed a line group, and it didn't generate a newline at end,
-                    // AND there is another group coming, insert newline?
-                    // But `processTokens` output might end with proper indent? No.
+                 // 5b. Alignment Pass
+                 const isFieldLine = (tokens: Token[]) => {
+                     const m = tokens.filter(t => t.type !== TokenType.Whitespace && t.type !== TokenType.Comment);
+                     if (m.length < 2) return false;
+                     const first = m[0].value.toLowerCase();
+                     if (first === 'indexes' || first === 'note') return false;
+                     if (tokens.some(t => t.type === TokenType.Symbol && t.value === '{')) return false;
+                     return true;
+                 };
+
+                 const alignFieldBlock = (blockLines: Token[][]) => {
+                     // 1. Collect info suitable for alignment
+                     interface RowInfo {
+                         lineTokens: Token[];
+                         nameTokenIdx: number;
+                         typeStartIdx: number;
+                         typeEndIdx: number; // exclusive
+                         settingsStartIdx: number;
+                         
+                         nameWidth: number;
+                         typeWidth: number;
+                     }
+                     
+                     const rows: RowInfo[] = [];
+                     
+                     for (const line of blockLines) {
+                         // Find Name Token (First meaningful)
+                         let nameIdx = -1;
+                         for(let k=0; k<line.length; k++) {
+                             if (line[k].type !== TokenType.Whitespace && line[k].type !== TokenType.Comment) {
+                                 nameIdx = k;
+                                 break;
+                             }
+                         }
+                         if (nameIdx === -1) continue;
+                         
+                         // Find Settings Start `[`
+                         let settingsIdx = -1;
+                         for(let k=0; k<line.length; k++) {
+                             if (line[k].type === TokenType.Symbol && line[k].value === '[') {
+                                 settingsIdx = k;
+                                 break;
+                             }
+                         }
+                         
+                         // Determine Type Range
+                         // Type is between Name and Settings (or End of Line)
+                         let typeStart = nameIdx + 1;
+                         while(typeStart < line.length && (line[typeStart].type === TokenType.Whitespace || line[typeStart].type === TokenType.Comment)) {
+                             typeStart++;
+                         }
+
+                         let typeEnd = settingsIdx;
+                         if (typeEnd === -1) {
+                             // No settings, type ends at the last meaningful token of the line
+                             let lastMeaningful = -1;
+                             for(let k=line.length-1; k >= 0; k--) {
+                                 if (line[k].type !== TokenType.Whitespace && line[k].type !== TokenType.Comment) {
+                                     lastMeaningful = k;
+                                     break;
+                                 }
+                             }
+                             
+                             if (lastMeaningful > nameIdx) {
+                                 typeEnd = lastMeaningful + 1; // exclusive
+                             } else {
+                                 continue; 
+                             }
+                         }
+                         
+                         if (typeStart >= typeEnd) continue;
+                          
+                         // Calculate Widths
+                         const nameWidth = line[nameIdx].value.length;
+                         
+                         // Dry run type width
+                         const typeTokens = line.slice(typeStart, typeEnd);
+                         const typeStr = processTokens(typeTokens, 0, ' ', 2, false); 
+                         const typeWidth = typeStr.length;
+                         
+                         rows.push({
+                             lineTokens: line,
+                             nameTokenIdx: nameIdx,
+                             typeStartIdx: typeStart,
+                             typeEndIdx: typeEnd,
+                             settingsStartIdx: settingsIdx,
+                             nameWidth,
+                             typeWidth
+                         });
+                     }
+                     
+                     if (rows.length === 0) return;
+                     
+                     // 2. Calc Max Widths
+                     const maxNameWidth = Math.max(...rows.map(r => r.nameWidth));
+                     const maxTypeWidth = Math.max(...rows.map(r => r.typeWidth));
+                     
+                     // 3. Apply Padding
+                     for (const row of rows) {
+                         // Pad Name
+                         const namePad = (maxNameWidth - row.nameWidth) + 1; // +1 for minimum space
+                         const nameTok = row.lineTokens[row.nameTokenIdx];
+                         nameTok.padRight = namePad;
+                         
+                         // Pad Type (Last token of type sequence)
+                         // Only needed if there is something after (settings)
+                         if (row.settingsStartIdx !== -1) {
+                             const typePad = (maxTypeWidth - row.typeWidth) + 1;
+                             // Find the last meaningful token of Type sequence
+                             let lastTypeTokIdx = row.typeEndIdx - 1;
+                             while(lastTypeTokIdx >= row.typeStartIdx && (row.lineTokens[lastTypeTokIdx].type === TokenType.Whitespace || row.lineTokens[lastTypeTokIdx].type === TokenType.Comment)) {
+                                 lastTypeTokIdx--;
+                             }
+                             
+                             if (lastTypeTokIdx >= row.typeStartIdx) {
+                                 row.lineTokens[lastTypeTokIdx].padRight = typePad;
+                             }
+                         }
+                     }
+                 };
+
+                 // Align globally across all lines in the table (ignoring inter-field grouping)
+                 alignFieldBlock(otherLinesGroups);
+
+                 // 5c. Print Pass
+                 for (let lgIdx = 0; lgIdx < otherLinesGroups.length; lgIdx++) {
+                     const lineTokens = otherLinesGroups[lgIdx];
+                     output += processTokens(lineTokens, indentLevel, indentChar, indentSize, true);
                     
-                    // Let's check `output`.
-                    if (lgIdx < otherLinesGroups.length - 1) {
-                        if (!output.endsWith('\n')) {
-                             // This implies the group didn't end with newline token.
-                             // Force it.
-                             output += '\n';
-                        }
-                    }
+                     if (lgIdx < otherLinesGroups.length - 1) {
+                         if (!output.endsWith('\n')) {
+                              output += '\n';
+                         }
+                     }
                  }
                  
                  // End block
@@ -596,12 +722,15 @@ function processTokens(
 ): string {
     
     let localOutput = '';
-    let currentIndentLevel = baseIndentLevel;
     const oneIndent = indentChar.repeat(indentSize);
-    const getLocalIndent = () => oneIndent.repeat(Math.max(0, currentIndentLevel));
     
-    // ... multiline stack and checkArrayMultiline ...
-     const checkArrayMultiline = (startIdx: number): boolean => {
+    // Stack of indentation strings. Start with base indent.
+    const indentStack: string[] = [oneIndent.repeat(Math.max(0, baseIndentLevel))];
+    
+    // Helper to get current indentation
+    const getCurrentIndent = () => indentStack[indentStack.length - 1];
+    
+    const checkArrayMultiline = (startIdx: number): boolean => {
          let depth = 1;
          let hasComma = false;
          for (let k = startIdx + 1; k < tokens.length; k++) {
@@ -634,10 +763,10 @@ function processTokens(
             continue;
         }
 
-        // Corrected Spacing/Indent Logic for processTokens:
+        // Spacing/Indent Logic
         if (localOutput.length === 0 || localOutput.endsWith('\n')) {
              if (token.value !== '}') {
-                 localOutput += getLocalIndent();
+                 localOutput += getCurrentIndent();
              }
         } else {
              // Not start of line
@@ -658,27 +787,69 @@ function processTokens(
              case TokenType.Symbol:
                  if (token.value === '{') {
                       localOutput += '{\n';
-                      currentIndentLevel++;
+                      indentStack.push(getCurrentIndent() + oneIndent);
                  } else if (token.value === '}') {
                       if (!localOutput.endsWith('\n')) localOutput += '\n';
-                      currentIndentLevel--;
-                      localOutput += getLocalIndent() + '}';
+                      if (indentStack.length > 1) indentStack.pop();
+                      localOutput += getCurrentIndent() + '}';
                  } else if (token.value === '[') {
                       const isMultiline = checkArrayMultiline(i);
                       multilineArrayStack.push(isMultiline);
+                      
+                      const preBracketLength = localOutput.length;
+                      const lastNewline = localOutput.lastIndexOf('\n');
+                      
                       localOutput += '[';
+                      
                       if (isMultiline) {
-                          localOutput += '\n';
-                          currentIndentLevel++;
+                          // Calculate visual column for Anchor
+                          let visualColOfBracket = 0;
+                          for(let c=lastNewline + 1; c < preBracketLength; c++) {
+                               if (localOutput[c] === '\t') visualColOfBracket += (indentSize - (visualColOfBracket % indentSize));
+                               else visualColOfBracket += 1;
+                          }
+                          
+                          const anchorIndent = ' '.repeat(visualColOfBracket);
+                          // Push Anchor first (for the closing bracket)
+                          indentStack.push(anchorIndent);
+                          // Push Anchor + Indent (for the content)
+                          indentStack.push(anchorIndent + oneIndent);
+                          
+                          localOutput += '\n'; 
                       }
                  } else if (token.value === ']') {
-                      const isMultiline = multilineArrayStack.pop();
-                      if (isMultiline) {
-                          if (!localOutput.endsWith('\n')) localOutput += '\n';
-                          currentIndentLevel--;
-                          if (localOutput.endsWith('\n')) localOutput += getLocalIndent();
-                      }
-                      localOutput += ']';
+                       const isMultiline = multilineArrayStack.pop();
+                       if (isMultiline) {
+                           // We are currently at Content Indent level (top of stack).
+                           // But for the closing bracket, we want to go back to Anchor Indent level.
+                           
+                           // First, remove Content Indent from stack
+                           indentStack.pop();
+                           
+                           // Now top of stack is Anchor Indent.
+                           const anchorIndent = getCurrentIndent();
+                           
+                           // Check what's currently on the last line.
+                           // The main loop might have already added indentation (Content Indent).
+                           const lastNewline = localOutput.lastIndexOf('\n');
+                           const lastLineFormatted = localOutput.substring(lastNewline + 1);
+                           
+                           if (lastLineFormatted.trim().length === 0) {
+                               // usage-case: The line is empty or just contains the indentation added by the loop.
+                               // We should replace that indentation with our Anchor Indent.
+                               localOutput = localOutput.substring(0, lastNewline + 1) + anchorIndent;
+                           } else {
+                               // There is content on this line. We need a new line.
+                               localOutput += '\n' + anchorIndent;
+                           }
+                           
+                           localOutput += ']';
+                           
+                           // Finally, pop the Anchor Indent so we return to previous base indent
+                           indentStack.pop();
+                       } else {
+                           localOutput += ']';
+                       }
                  } else if (token.value === ',') {
                       localOutput += ',';
                       const currentMultiline = multilineArrayStack.length > 0 && multilineArrayStack[multilineArrayStack.length - 1];
@@ -689,21 +860,21 @@ function processTokens(
                  break;
              
              case TokenType.Word:
-                  // Handle keyword PascalCase in buffer
-                  if (token.value.toLowerCase() === 'table') token.value = 'Table';
-                  if (token.value.toLowerCase() === 'ref') token.value = 'Ref';
-                  if (token.value.toLowerCase() === 'note') {
-                       // Peek locally inside tokens list
-                        let nextIdx = i + 1;
-                        while(nextIdx < tokens.length && (tokens[nextIdx].type === TokenType.Whitespace || tokens[nextIdx].type === TokenType.Comment)) {
-                            nextIdx++;
-                        }
-                        if (nextIdx < tokens.length && tokens[nextIdx].type === TokenType.Symbol && tokens[nextIdx].value === ':') {
-                            token.value = 'Note';
-                        }
-                  }
-                  localOutput += token.value;
-                  break;
+                   // Handle keyword PascalCase
+                   if (token.value.toLowerCase() === 'table') token.value = 'Table';
+                   if (token.value.toLowerCase() === 'ref') token.value = 'Ref';
+                   if (token.value.toLowerCase() === 'note') {
+                        // Peek locally inside tokens list
+                         let nextIdx = i + 1;
+                         while(nextIdx < tokens.length && (tokens[nextIdx].type === TokenType.Whitespace || tokens[nextIdx].type === TokenType.Comment)) {
+                             nextIdx++;
+                         }
+                         if (nextIdx < tokens.length && tokens[nextIdx].type === TokenType.Symbol && tokens[nextIdx].value === ':') {
+                             token.value = 'Note';
+                         }
+                   }
+                   localOutput += token.value;
+                   break;
 
              case TokenType.String:
                 let val = token.value;
@@ -716,8 +887,12 @@ function processTokens(
                 break;
                 
              default:
-                localOutput += token.value;
-                break;
+                  localOutput += token.value;
+                  break;
+        }
+        
+        if (token.padRight) {
+             localOutput += ' '.repeat(token.padRight);
         }
     }
     

package/src/formatter/tokenizer.ts

@@ -12,6 +12,7 @@ export interface Token {
     value: string;
     line: number;
     column: number;
+    padRight?: number;
 }
 
 export function tokenize(input: string): Token[] {