docrev 0.8.1 → 0.8.5

package/lib/{format.js → format.ts}

@@ -5,14 +5,67 @@
 
 import chalk from 'chalk';
 
+// Type definitions for function parameters
+interface TableOptions {
+  align?: Array<'left' | 'right' | 'center'>;
+  headerStyle?: (text: string) => string;
+  borderStyle?: (text: string) => string;
+  cellStyle?: ((value: string, colIndex: number, rowIndex: number) => string) | null;
+}
+
+interface SimpleTableOptions {
+  headerStyle?: (text: string) => string;
+  indent?: string;
+}
+
+interface BoxOptions {
+  title?: string | null;
+  padding?: number;
+  borderStyle?: (text: string) => string;
+  titleStyle?: (text: string) => string;
+}
+
+interface StatsOptions {
+  title?: string | null;
+}
+
+interface ProgressOptions {
+  width?: number;
+  label?: string;
+}
+
+interface InlineDiffPreviewOptions {
+  maxLines?: number;
+  contextChars?: number;
+}
+
+interface HeaderOptions {
+  style?: (text: string) => string;
+  width?: number;
+}
+
+interface Spinner {
+  text: string;
+  start: () => Spinner;
+  stop: (finalMessage?: string | null) => Spinner;
+  success: (msg?: string) => Spinner;
+  error: (msg?: string) => Spinner;
+}
+
+interface ProgressBar {
+  update: (n: number) => ProgressBar;
+  increment: () => ProgressBar;
+  done: (message?: string) => ProgressBar;
+}
+
 /**
  * Format a table with borders and alignment
- * @param {string[]} headers - Column headers
- * @param {string[][]} rows - Row data
- * @param {object} options - Formatting options
- * @returns {string}
+ * @param headers - Column headers
+ * @param rows - Row data
+ * @param options - Formatting options
+ * @returns Formatted table string
  */
-export function table(headers, rows, options = {}) {
+export function table(headers: string[], rows: string[][], options: TableOptions = {}): string {
   const {
     align = headers.map(() => 'left'), // 'left', 'right', 'center'
     headerStyle = chalk.bold.cyan,
@@ -22,8 +75,8 @@ export function table(headers, rows, options = {}) {
 
   // Calculate column widths
   const widths = headers.map((h, i) => {
-    const cellWidths = rows.map(row => stripAnsi(String(row[i] || '')).length);
-    return Math.max(stripAnsi(h).length, ...cellWidths);
+    const cellWidths = rows.map(row => stripAnsi(String(row[i] || '')));
+    return Math.max(stripAnsi(h), ...cellWidths);
   });
 
   // Border characters
@@ -34,7 +87,7 @@ export function table(headers, rows, options = {}) {
   };
 
   // Build lines
-  const lines = [];
+  const lines: string[] = [];
 
   // Top border
   const topBorder = border.topLeft +
@@ -44,10 +97,10 @@ export function table(headers, rows, options = {}) {
 
   // Header row
   const headerRow = border.vertical +
-    headers.map((h, i) => ' ' + pad(headerStyle(h), widths[i], align[i]) + ' ').join(border.vertical) +
+    headers.map((h, i) => ' ' + pad(headerStyle(h), widths[i] || 0, align[i] || 'left') + ' ').join(border.vertical) +
     border.vertical;
   lines.push(borderStyle(border.vertical) +
-    headers.map((h, i) => ' ' + pad(headerStyle(h), widths[i], align[i], stripAnsi(h).length) + ' ').join(borderStyle(border.vertical)) +
+    headers.map((h, i) => ' ' + pad(headerStyle(h), widths[i] || 0, align[i] || 'left', stripAnsi(h)) + ' ').join(borderStyle(border.vertical)) +
     borderStyle(border.vertical));
 
   // Header separator
@@ -59,13 +112,14 @@ export function table(headers, rows, options = {}) {
   // Data rows
   for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
     const row = rows[rowIdx];
+    if (!row) continue;
     const cells = row.map((cell, colIdx) => {
       let value = String(cell || '');
       if (cellStyle) {
         value = cellStyle(value, colIdx, rowIdx);
       }
-      const plainLen = stripAnsi(String(cell || '')).length;
-      return ' ' + pad(value, widths[colIdx], align[colIdx], plainLen) + ' ';
+      const plainLen = stripAnsi(String(cell || ''));
+      return ' ' + pad(value, widths[colIdx] || 0, align[colIdx] || 'left', plainLen) + ' ';
     });
     lines.push(borderStyle(border.vertical) + cells.join(borderStyle(border.vertical)) + borderStyle(border.vertical));
   }
@@ -82,20 +136,20 @@ export function table(headers, rows, options = {}) {
 /**
  * Simple table without borders (compact)
  */
-export function simpleTable(headers, rows, options = {}) {
+export function simpleTable(headers: string[], rows: string[][], options: SimpleTableOptions = {}): string {
   const { headerStyle = chalk.dim, indent = '  ' } = options;
 
   const widths = headers.map((h, i) => {
-    const cellWidths = rows.map(row => stripAnsi(String(row[i] || '')).length);
-    return Math.max(stripAnsi(h).length, ...cellWidths);
+    const cellWidths = rows.map(row => stripAnsi(String(row[i] || '')));
+    return Math.max(stripAnsi(h), ...cellWidths);
   });
 
-  const lines = [];
-  lines.push(indent + headers.map((h, i) => headerStyle(pad(h, widths[i], 'left'))).join('  '));
+  const lines: string[] = [];
+  lines.push(indent + headers.map((h, i) => headerStyle(pad(h, widths[i] || 0, 'left'))).join('  '));
   lines.push(indent + widths.map(w => chalk.dim('─'.repeat(w))).join('  '));
 
   for (const row of rows) {
-    lines.push(indent + row.map((cell, i) => pad(String(cell || ''), widths[i], 'left')).join('  '));
+    lines.push(indent + row.map((cell, i) => pad(String(cell || ''), widths[i] || 0, 'left')).join('  '));
   }
 
   return lines.join('\n');
@@ -104,7 +158,7 @@ export function simpleTable(headers, rows, options = {}) {
 /**
  * Format a box around content
  */
-export function box(content, options = {}) {
+export function box(content: string, options: BoxOptions = {}): string {
   const {
     title = null,
     padding = 1,
@@ -113,15 +167,15 @@ export function box(content, options = {}) {
   } = options;
 
   const lines = content.split('\n');
-  const maxWidth = Math.max(...lines.map(l => stripAnsi(l).length), title ? stripAnsi(title).length + 4 : 0);
+  const maxWidth = Math.max(...lines.map(l => stripAnsi(l)), title ? stripAnsi(title) + 4 : 0);
 
   const border = { tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│' };
-  const result = [];
+  const result: string[] = [];
 
   // Top border with optional title
   if (title) {
     const titlePart = ` ${titleStyle(title)} `;
-    const remaining = maxWidth + 2 - stripAnsi(titlePart).length;
+    const remaining = maxWidth + 2 - stripAnsi(titlePart);
     result.push(borderStyle(border.tl + border.h) + titlePart + borderStyle(border.h.repeat(remaining) + border.tr));
   } else {
     result.push(borderStyle(border.tl + border.h.repeat(maxWidth + 2) + border.tr));
@@ -134,7 +188,7 @@ export function box(content, options = {}) {
 
   // Content
   for (const line of lines) {
-    const plainLen = stripAnsi(line).length;
+    const plainLen = stripAnsi(line);
     const padded = line + ' '.repeat(maxWidth - plainLen);
     result.push(borderStyle(border.v) + ' ' + padded + ' ' + borderStyle(border.v));
   }
@@ -153,16 +207,17 @@ export function box(content, options = {}) {
 /**
  * Summary stats in a nice format
  */
-export function stats(data, options = {}) {
+export function stats(data: Record<string, string | number>, options: StatsOptions = {}): string {
   const { title = null } = options;
 
-  const lines = [];
+  const lines: string[] = [];
   if (title) {
     lines.push(chalk.bold.cyan(title));
     lines.push('');
   }
 
-  const maxKeyLen = Math.max(...Object.keys(data).map(k => k.length));
+  const keys = Object.keys(data);
+  const maxKeyLen = keys.length > 0 ? Math.max(...keys.map(k => k.length)) : 0;
 
   for (const [key, value] of Object.entries(data)) {
     const label = chalk.dim(key.padEnd(maxKeyLen) + ':');
@@ -175,7 +230,7 @@ export function stats(data, options = {}) {
 /**
  * Progress indicator
  */
-export function progress(current, total, options = {}) {
+export function progress(current: number, total: number, options: ProgressOptions = {}): string {
   const { width = 30, label = '' } = options;
   const pct = Math.round((current / total) * 100);
   const filled = Math.round((current / total) * width);
@@ -188,15 +243,15 @@ export function progress(current, total, options = {}) {
 // Global setting for emoji usage
 let useEmoji = false;
 
-export function setEmoji(enabled) {
+export function setEmoji(enabled: boolean): void {
   useEmoji = enabled;
 }
 
 /**
  * Status line with icon
  */
-export function status(type, message) {
-  const textIcons = {
+export function status(type: string, message: string): string {
+  const textIcons: Record<string, string> = {
     success: chalk.green('✓'),
     error: chalk.red('✗'),
     warning: chalk.yellow('!'),
@@ -209,7 +264,7 @@ export function status(type, message) {
     export: chalk.cyan('>'),
   };
 
-  const emojiIcons = {
+  const emojiIcons: Record<string, string> = {
     success: chalk.green('✓'),
     error: chalk.red('✗'),
     warning: chalk.yellow('⚠'),
@@ -246,21 +301,26 @@ const starColors = [
 /**
  * Create a pulsing star spinner for async operations
  */
-export function spinner(message) {
+export function spinner(message: string): Spinner {
   let frameIndex = 0;
-  let interval = null;
+  let interval: NodeJS.Timeout | null = null;
 
-  const spin = {
+  const spin: Spinner = {
+    text: message,
     start() {
       process.stdout.write('\x1B[?25l'); // Hide cursor
       interval = setInterval(() => {
-        const frame = starColors[frameIndex](starFrames[frameIndex]);
-        process.stdout.write(`\r${frame} ${message}`);
+        const colorFn = starColors[frameIndex];
+        const frameChr = starFrames[frameIndex];
+        if (colorFn && frameChr) {
+          const frame = colorFn(frameChr);
+          process.stdout.write(`\r${frame} ${spin.text}`);
+        }
         frameIndex = (frameIndex + 1) % starFrames.length;
       }, 120);
       return spin;
     },
-    stop(finalMessage = null) {
+    stop(finalMessage: string | null = null) {
       if (interval) {
         clearInterval(interval);
         interval = null;
@@ -272,10 +332,10 @@ export function spinner(message) {
       }
       return spin;
     },
-    success(msg) {
+    success(msg?: string) {
       return spin.stop(status('success', msg || message));
     },
-    error(msg) {
+    error(msg?: string) {
       return spin.stop(status('error', msg || message));
     },
   };
@@ -285,16 +345,16 @@ export function spinner(message) {
 
 /**
  * Create a progress bar for batch operations
- * @param {number} total - Total number of items
- * @param {string} label - Label for the progress bar
- * @returns {object} Progress bar controller with update(), increment(), and done()
+ * @param total - Total number of items
+ * @param label - Label for the progress bar
+ * @returns Progress bar controller with update(), increment(), and done()
  */
-export function progressBar(total, label = 'Progress') {
+export function progressBar(total: number, label: string = 'Progress'): ProgressBar {
   let current = 0;
   const barWidth = 30;
 
-  const bar = {
-    update(n) {
+  const bar: ProgressBar = {
+    update(n: number) {
       current = Math.min(n, total);
       const percent = Math.floor((current / total) * 100);
       const filled = Math.floor((current / total) * barWidth);
@@ -307,7 +367,7 @@ export function progressBar(total, label = 'Progress') {
     increment() {
       return bar.update(current + 1);
     },
-    done(message) {
+    done(message?: string) {
       process.stdout.write('\r\x1B[K'); // Clear line
       if (message) {
         console.log(status('success', message));
@@ -322,8 +382,8 @@ export function progressBar(total, label = 'Progress') {
 /**
  * Diff display with inline highlighting
  */
-export function diff(insertions, deletions, substitutions) {
-  const lines = [];
+export function diff(insertions: number, deletions: number, substitutions: number): string {
+  const lines: string[] = [];
 
   if (insertions > 0) {
     lines.push(chalk.green(`  + ${insertions} insertion${insertions !== 1 ? 's' : ''}`));
@@ -340,20 +400,27 @@ export function diff(insertions, deletions, substitutions) {
 
 /**
  * Show inline diff preview for CriticMarkup changes
- * @param {string} text - Text with CriticMarkup annotations
- * @param {object} options
- * @returns {string}
+ * @param text - Text with CriticMarkup annotations
+ * @param options - Display options
+ * @returns Formatted preview string
  */
-export function inlineDiffPreview(text, options = {}) {
+export function inlineDiffPreview(text: string, options: InlineDiffPreviewOptions = {}): string {
   const { maxLines = 10, contextChars = 40 } = options;
-  const lines = [];
+  const lines: string[] = [];
 
   // Find all changes
-  const changes = [];
+  const changes: Array<{
+    type: 'insert' | 'delete' | 'substitute';
+    content?: string;
+    oldContent?: string;
+    newContent?: string;
+    index: number;
+    fullMatch: string;
+  }> = [];
 
   // Insertions: {++text++}
   const insertPattern = /\{\+\+([^+]*)\+\+\}/g;
-  let match;
+  let match: RegExpExecArray | null;
   while ((match = insertPattern.exec(text)) !== null) {
     changes.push({
       type: 'insert',
@@ -409,8 +476,8 @@ export function inlineDiffPreview(text, options = {}) {
       lines.push(chalk.red('  - ') + truncate(preview, 80));
     } else if (change.type === 'substitute') {
       preview = chalk.dim(before) +
-        chalk.red.strikethrough(change.oldContent) +
-        chalk.green.bold(change.newContent) +
+        chalk.red.strikethrough(change.oldContent || '') +
+        chalk.green.bold(change.newContent || '') +
         chalk.dim(after);
       lines.push(chalk.yellow('  ~ ') + truncate(preview, 80));
     }
@@ -426,8 +493,8 @@ export function inlineDiffPreview(text, options = {}) {
 /**
  * Truncate string to max length
  */
-function truncate(str, maxLen) {
-  const plain = stripAnsi(str);
+function truncate(str: string, maxLen: number): string {
+  const plain = stripAnsiStr(str);
   if (plain.length <= maxLen) return str;
   // This is approximate since we have ANSI codes
   return str.slice(0, maxLen + (str.length - plain.length)) + chalk.dim('...');
@@ -436,7 +503,7 @@ function truncate(str, maxLen) {
 /**
  * Section header
  */
-export function header(text, options = {}) {
+export function header(text: string, options: HeaderOptions = {}): string {
   const { style = chalk.bold.cyan, width = 60 } = options;
   const padding = Math.max(0, width - text.length - 4);
   return style(`── ${text} ${'─'.repeat(padding)}`);
@@ -445,15 +512,22 @@ export function header(text, options = {}) {
 /**
  * Strip ANSI codes for length calculation
  */
-function stripAnsi(str) {
+function stripAnsi(str: string): number {
+  return str.replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+
+/**
+ * Strip ANSI codes and return string
+ */
+function stripAnsiStr(str: string): string {
   return str.replace(/\x1b\[[0-9;]*m/g, '');
 }
 
 /**
  * Pad string with alignment
  */
-function pad(str, width, align, strLen = null) {
-  const len = strLen !== null ? strLen : stripAnsi(str).length;
+function pad(str: string, width: number, align: 'left' | 'right' | 'center', strLen: number | null = null): string {
+  const len = strLen !== null ? strLen : stripAnsi(str);
   const padding = Math.max(0, width - len);
 
   if (align === 'right') {