@delma/fylo 1.1.2 → 2.0.1

package/src/core/format.ts

@@ -1,486 +1,457 @@
 import TTID from '@delma/ttid'
 
 class Format {
-  static table(docs: Record<string, any>) {
-    // Calculate the _id column width (considering both the column name and the actual keys)
-    const idColumnWidth =
-      Math.max(...Object.keys(docs).map((key) => key.length)) + 2; // Add padding
+    static table(docs: Record<string, any>) {
+        // Calculate the _id column width (considering both the column name and the actual keys)
+        const idColumnWidth = Math.max(...Object.keys(docs).map((key) => key.length)) + 2 // Add padding
 
-    const { maxWidths, maxHeight } = this.getHeaderDim(Object.values(docs));
+        const { maxWidths, maxHeight } = this.getHeaderDim(Object.values(docs))
 
-    let key = Object.keys(docs).shift()!
+        let key = Object.keys(docs).shift()!
 
-    const keys = key.split(',')
+        const keys = key.split(',')
 
-    if(TTID.isTTID(key) || keys.some(key => TTID.isTTID(key ?? ''))) {
-      key = '_id'
-    } else key = '_key'
+        if (TTID.isTTID(key) || keys.some((key) => TTID.isTTID(key ?? ''))) {
+            key = '_id'
+        } else key = '_key'
 
-    // Add the _id column to the front of maxWidths
-    const fullWidths = {
-      [key]: idColumnWidth,
-      ...maxWidths,
-    };
+        // Add the _id column to the front of maxWidths
+        const fullWidths = {
+            [key]: idColumnWidth,
+            ...maxWidths
+        }
 
-    // Render the header
-    const header = this.renderHeader(fullWidths, maxHeight, key);
-    console.log("\n" + header);
+        // Render the header
+        const header = this.renderHeader(fullWidths, maxHeight, key)
+        console.log('\n' + header)
 
-    // Render the data rows
-    const dataRows = this.renderDataRows(docs, fullWidths, key);
-    console.log(dataRows);
-  }
+        // Render the data rows
+        const dataRows = this.renderDataRows(docs, fullWidths, key)
+        console.log(dataRows)
+    }
 
-  private static getHeaderDim(docs: Record<string, any>[]) {
-    let maxWidths: Record<string, any> = {};
-    let maxHeight = 1;
+    private static getHeaderDim(docs: Record<string, any>[]) {
+        let maxWidths: Record<string, any> = {}
+        let maxHeight = 1
 
-    // Create a copy to avoid mutating the original array
-    const docsCopy = [...docs];
+        // Create a copy to avoid mutating the original array
+        const docsCopy = [...docs]
 
-    while (docsCopy.length > 0) {
-      const doc = docsCopy.shift()!;
-      const widths = this.getValueWidth(doc);
-      const height = this.getHeaderHeight(doc); // Fix: get height for this doc
-      maxHeight = Math.max(maxHeight, height); // Fix: take maximum height
-      maxWidths = this.increaseWidths(maxWidths, widths);
-    }
+        while (docsCopy.length > 0) {
+            const doc = docsCopy.shift()!
+            const widths = this.getValueWidth(doc)
+            const height = this.getHeaderHeight(doc) // Fix: get height for this doc
+            maxHeight = Math.max(maxHeight, height) // Fix: take maximum height
+            maxWidths = this.increaseWidths(maxWidths, widths)
+        }
 
-    return { maxWidths, maxHeight };
-  }
-
-  private static getValueWidth(doc: Record<string, any>) {
-    const keyWidths: Record<string, any> = {};
-
-    for (const key in doc) {
-      if (
-        typeof doc[key] === "object" &&
-        doc[key] !== null &&
-        !Array.isArray(doc[key])
-      ) {
-        keyWidths[key] = this.getValueWidth(doc[key]);
-      } else {
-        // Consider both the key name length and the value length
-        const valueWidth = JSON.stringify(doc[key]).length;
-        const keyWidth = key.length;
-        // Add padding: 1 space before + content + 1 space after
-        keyWidths[key] = Math.max(valueWidth, keyWidth) + 2;
-      }
+        return { maxWidths, maxHeight }
     }
 
-    return keyWidths;
-  }
-
-  private static increaseWidths(
-    oldWidths: Record<string, any>,
-    newWidths: Record<string, any>
-  ) {
-    const increasedWidths: Record<string, any> = { ...oldWidths };
-
-    for (const key in newWidths) {
-      if (
-        oldWidths[key] &&
-        typeof newWidths[key] === "object" &&
-        typeof oldWidths[key] === "object"
-      ) {
-        increasedWidths[key] = this.increaseWidths(
-          oldWidths[key],
-          newWidths[key]
-        );
-      } else if (
-        oldWidths[key] &&
-        typeof newWidths[key] === "number" &&
-        typeof oldWidths[key] === "number"
-      ) {
-        increasedWidths[key] = Math.max(newWidths[key], oldWidths[key]);
-      } else {
-        increasedWidths[key] = newWidths[key];
-      }
-    }
+    private static getValueWidth(doc: Record<string, any>) {
+        const keyWidths: Record<string, any> = {}
+
+        for (const key in doc) {
+            if (typeof doc[key] === 'object' && doc[key] !== null && !Array.isArray(doc[key])) {
+                keyWidths[key] = this.getValueWidth(doc[key])
+            } else {
+                // Consider both the key name length and the value length
+                const valueWidth = JSON.stringify(doc[key]).length
+                const keyWidth = key.length
+                // Add padding: 1 space before + content + 1 space after
+                keyWidths[key] = Math.max(valueWidth, keyWidth) + 2
+            }
+        }
 
-    // Handle keys that exist in newWidths but not in oldWidths
-    for (const key in newWidths) {
-      if (!(key in increasedWidths)) {
-        increasedWidths[key] = newWidths[key];
-      }
+        return keyWidths
     }
 
-    // Also ensure column family names fit within their total width
-    for (const key in increasedWidths) {
-      if (
-        typeof increasedWidths[key] === "object" &&
-        increasedWidths[key] !== null
-      ) {
-        const totalChildWidth = this.calculateTotalWidth(increasedWidths[key]);
-        const keyWidth = key.length;
-
-        // If the column family name (with padding) is longer than the total child width,
-        // we need to adjust the child column widths proportionally
-        const keyWidthWithPadding = keyWidth + 2; // Add padding for family name too
-        if (keyWidthWithPadding > totalChildWidth) {
-          const childKeys = Object.keys(increasedWidths[key]);
-          const extraWidth = keyWidthWithPadding - totalChildWidth;
-          const widthPerChild = Math.ceil(extraWidth / childKeys.length);
-
-          for (const childKey of childKeys) {
-            if (typeof increasedWidths[key][childKey] === "number") {
-              increasedWidths[key][childKey] += widthPerChild;
+    private static increaseWidths(oldWidths: Record<string, any>, newWidths: Record<string, any>) {
+        const increasedWidths: Record<string, any> = { ...oldWidths }
+
+        for (const key in newWidths) {
+            if (
+                oldWidths[key] &&
+                typeof newWidths[key] === 'object' &&
+                typeof oldWidths[key] === 'object'
+            ) {
+                increasedWidths[key] = this.increaseWidths(oldWidths[key], newWidths[key])
+            } else if (
+                oldWidths[key] &&
+                typeof newWidths[key] === 'number' &&
+                typeof oldWidths[key] === 'number'
+            ) {
+                increasedWidths[key] = Math.max(newWidths[key], oldWidths[key])
+            } else {
+                increasedWidths[key] = newWidths[key]
+            }
+        }
+
+        // Handle keys that exist in newWidths but not in oldWidths
+        for (const key in newWidths) {
+            if (!(key in increasedWidths)) {
+                increasedWidths[key] = newWidths[key]
+            }
+        }
+
+        // Also ensure column family names fit within their total width
+        for (const key in increasedWidths) {
+            if (typeof increasedWidths[key] === 'object' && increasedWidths[key] !== null) {
+                const totalChildWidth = this.calculateTotalWidth(increasedWidths[key])
+                const keyWidth = key.length
+
+                // If the column family name (with padding) is longer than the total child width,
+                // we need to adjust the child column widths proportionally
+                const keyWidthWithPadding = keyWidth + 2 // Add padding for family name too
+                if (keyWidthWithPadding > totalChildWidth) {
+                    const childKeys = Object.keys(increasedWidths[key])
+                    const extraWidth = keyWidthWithPadding - totalChildWidth
+                    const widthPerChild = Math.ceil(extraWidth / childKeys.length)
+
+                    for (const childKey of childKeys) {
+                        if (typeof increasedWidths[key][childKey] === 'number') {
+                            increasedWidths[key][childKey] += widthPerChild
+                        }
+                    }
+                }
             }
-          }
         }
-      }
+
+        return increasedWidths
     }
 
-    return increasedWidths;
-  }
-
-  private static getHeaderHeight(doc: Record<string, any>): number {
-    let maxDepth = 1; // Fix: start with 1 for current level
-
-    for (const key in doc) {
-      if (
-        typeof doc[key] === "object" &&
-        doc[key] !== null &&
-        !Array.isArray(doc[key])
-      ) {
-        const nestedDepth = 1 + this.getHeaderHeight(doc[key]); // Fix: add 1 for current level
-        maxDepth = Math.max(maxDepth, nestedDepth); // Fix: track maximum depth
-      }
+    private static getHeaderHeight(doc: Record<string, any>): number {
+        let maxDepth = 1 // Fix: start with 1 for current level
+
+        for (const key in doc) {
+            if (typeof doc[key] === 'object' && doc[key] !== null && !Array.isArray(doc[key])) {
+                const nestedDepth = 1 + this.getHeaderHeight(doc[key]) // Fix: add 1 for current level
+                maxDepth = Math.max(maxDepth, nestedDepth) // Fix: track maximum depth
+            }
+        }
+
+        return maxDepth
     }
 
-    return maxDepth;
-  }
+    private static renderHeader(
+        widths: Record<string, any>,
+        height: number,
+        idColumnKey: string
+    ): string {
+        const lines: string[] = []
 
-  private static renderHeader(
-    widths: Record<string, any>,
-    height: number,
-    idColumnKey: string
-  ): string {
-    const lines: string[] = [];
+        // Flatten the structure to get all columns
+        const columns = this.flattenColumns(widths)
 
-    // Flatten the structure to get all columns
-    const columns = this.flattenColumns(widths);
+        // Add top border
+        lines.push(this.renderTopBorder(columns))
 
-    // Add top border
-    lines.push(this.renderTopBorder(columns));
+        // Add header content rows
+        for (let level = 0; level < height; level++) {
+            lines.push(this.renderHeaderRow(widths, level, height, idColumnKey))
+
+            // Add middle border between levels (except after last level)
+            if (level < height - 1) {
+                lines.push(this.renderMiddleBorder(columns))
+            }
+        }
 
-    // Add header content rows
-    for (let level = 0; level < height; level++) {
-      lines.push(this.renderHeaderRow(widths, level, height, idColumnKey));
+        // Add bottom border
+        lines.push(this.renderBottomBorder(columns))
 
-      // Add middle border between levels (except after last level)
-      if (level < height - 1) {
-        lines.push(this.renderMiddleBorder(columns));
-      }
+        return lines.join('\n')
     }
 
-    // Add bottom border
-    lines.push(this.renderBottomBorder(columns));
-
-    return lines.join("\n");
-  }
-
-  private static renderDataRows<T extends Record<string, any>>(
-    docs: Record<string, T>,
-    widths: Record<string, any>,
-    idColumnKey: string
-  ): string {
-    const lines: string[] = [];
-    const columns = this.flattenColumns(widths);
-    const entries = Object.entries(docs);
-
-    for (let i = 0; i < entries.length; i++) {
-      const [docId, doc] = entries[i];
-      // Render data row
-      lines.push(this.renderDataRow(docId, doc, widths, columns, idColumnKey));
-
-      // Add separator between rows (except for last row)
-      if (i < entries.length - 1) {
-        lines.push(this.renderRowSeparator(columns));
-      }
+    private static renderDataRows<T extends Record<string, any>>(
+        docs: Record<string, T>,
+        widths: Record<string, any>,
+        idColumnKey: string
+    ): string {
+        const lines: string[] = []
+        const columns = this.flattenColumns(widths)
+        const entries = Object.entries(docs)
+
+        for (let i = 0; i < entries.length; i++) {
+            const [docId, doc] = entries[i]
+            // Render data row
+            lines.push(this.renderDataRow(docId, doc, widths, columns, idColumnKey))
+
+            // Add separator between rows (except for last row)
+            if (i < entries.length - 1) {
+                lines.push(this.renderRowSeparator(columns))
+            }
+        }
+
+        // Add final bottom border
+        lines.push(this.renderBottomBorder(columns))
+
+        return lines.join('\n')
     }
 
-    // Add final bottom border
-    lines.push(this.renderBottomBorder(columns));
-
-    return lines.join("\n");
-  }
-
-  private static renderDataRow(
-    docId: string,
-    doc: Record<string, any>,
-    widths: Record<string, any>,
-    columns: Array<{ name: string; width: number; path: string[] }>,
-    idColumnKey: string
-  ): string {
-    let line = "│";
-
-    // Handle the ID column (could be _id or another key)
-    if (idColumnKey in widths && typeof widths[idColumnKey] === "number") {
-      const contentWidth = widths[idColumnKey] - 2;
-      const content = docId;
-      const padding = Math.max(0, contentWidth - content.length);
-      const leftPad = Math.floor(padding / 2);
-      const rightPad = padding - leftPad;
-
-      line += " " + " ".repeat(leftPad) + content + " ".repeat(rightPad) + " │";
+    private static renderDataRow(
+        docId: string,
+        doc: Record<string, any>,
+        widths: Record<string, any>,
+        columns: Array<{ name: string; width: number; path: string[] }>,
+        idColumnKey: string
+    ): string {
+        let line = '│'
+
+        // Handle the ID column (could be _id or another key)
+        if (idColumnKey in widths && typeof widths[idColumnKey] === 'number') {
+            const contentWidth = widths[idColumnKey] - 2
+            const content = docId
+            const padding = Math.max(0, contentWidth - content.length)
+            const leftPad = Math.floor(padding / 2)
+            const rightPad = padding - leftPad
+
+            line += ' ' + ' '.repeat(leftPad) + content + ' '.repeat(rightPad) + ' │'
+        }
+
+        // Handle data columns
+        for (const column of columns) {
+            // Skip the ID column as it's handled separately
+            if (column.name === idColumnKey) continue
+
+            const value = this.getNestedValue(doc, column.path)
+            const stringValue = this.formatValue(value)
+            const contentWidth = column.width - 2 // Subtract padding
+
+            // Truncate if value is too long
+            const truncatedValue =
+                stringValue.length > contentWidth
+                    ? stringValue.substring(0, contentWidth - 3) + '...'
+                    : stringValue
+
+            const padding = Math.max(0, contentWidth - truncatedValue.length)
+            const leftPad = Math.floor(padding / 2)
+            const rightPad = padding - leftPad
+
+            line += ' ' + ' '.repeat(leftPad) + truncatedValue + ' '.repeat(rightPad) + ' │'
+        }
+
+        return line
     }
 
-    // Handle data columns
-    for (const column of columns) {
-      // Skip the ID column as it's handled separately
-      if (column.name === idColumnKey) continue;
-
-      const value = this.getNestedValue(doc, column.path);
-      const stringValue = this.formatValue(value);
-      const contentWidth = column.width - 2; // Subtract padding
-
-      // Truncate if value is too long
-      const truncatedValue =
-        stringValue.length > contentWidth
-          ? stringValue.substring(0, contentWidth - 3) + "..."
-          : stringValue;
-
-      const padding = Math.max(0, contentWidth - truncatedValue.length);
-      const leftPad = Math.floor(padding / 2);
-      const rightPad = padding - leftPad;
-
-      line +=
-        " " +
-        " ".repeat(leftPad) +
-        truncatedValue +
-        " ".repeat(rightPad) +
-        " │";
+    private static getNestedValue(obj: Record<string, any>, path: string[]): any {
+        let current = obj
+
+        for (const key of path) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return undefined
+            }
+            current = current[key]
+        }
+
+        return current
     }
 
-    return line;
-  }
-
-  private static getNestedValue(obj: Record<string, any>, path: string[]): any {
-    let current = obj;
-
-    for (const key of path) {
-      if (
-        current === null ||
-        current === undefined ||
-        typeof current !== "object"
-      ) {
-        return undefined;
-      }
-      current = current[key];
+    private static formatValue(value: any): string {
+        if (value === null) return 'null'
+        if (value === undefined) return ''
+        if (Array.isArray(value)) return JSON.stringify(value)
+        if (typeof value === 'object') return JSON.stringify(value)
+        if (typeof value === 'string') return value
+        return String(value)
     }
 
-    return current;
-  }
-
-  private static formatValue(value: any): string {
-    if (value === null) return "null";
-    if (value === undefined) return "";
-    if (Array.isArray(value)) return JSON.stringify(value);
-    if (typeof value === "object") return JSON.stringify(value);
-    if (typeof value === "string") return value;
-    return String(value);
-  }
-
-  private static renderRowSeparator(
-    columns: Array<{ name: string; width: number; path: string[] }>
-  ): string {
-    let line = "├";
-
-    for (let i = 0; i < columns.length; i++) {
-      line += "─".repeat(columns[i].width);
-      if (i < columns.length - 1) {
-        line += "┼";
-      }
+    private static renderRowSeparator(
+        columns: Array<{ name: string; width: number; path: string[] }>
+    ): string {
+        let line = '├'
+
+        for (let i = 0; i < columns.length; i++) {
+            line += '─'.repeat(columns[i].width)
+            if (i < columns.length - 1) {
+                line += '┼'
+            }
+        }
+
+        line += '┤'
+        return line
     }
 
-    line += "┤";
-    return line;
-  }
-
-  private static flattenColumns(
-    widths: Record<string, any>,
-    path: string[] = []
-  ): Array<{ name: string; width: number; path: string[] }> {
-    const columns: Array<{ name: string; width: number; path: string[] }> = [];
-
-    for (const key in widths) {
-      const currentPath = [...path, key];
-
-      if (typeof widths[key] === "object" && widths[key] !== null) {
-        // Recursively flatten nested objects
-        columns.push(...this.flattenColumns(widths[key], currentPath));
-      } else {
-        // This is a leaf column
-        columns.push({
-          name: key,
-          width: widths[key],
-          path: currentPath,
-        });
-      }
+    private static flattenColumns(
+        widths: Record<string, any>,
+        path: string[] = []
+    ): Array<{ name: string; width: number; path: string[] }> {
+        const columns: Array<{ name: string; width: number; path: string[] }> = []
+
+        for (const key in widths) {
+            const currentPath = [...path, key]
+
+            if (typeof widths[key] === 'object' && widths[key] !== null) {
+                // Recursively flatten nested objects
+                columns.push(...this.flattenColumns(widths[key], currentPath))
+            } else {
+                // This is a leaf column
+                columns.push({
+                    name: key,
+                    width: widths[key],
+                    path: currentPath
+                })
+            }
+        }
+
+        return columns
     }
 
-    return columns;
-  }
-
-  private static renderHeaderRow(
-    widths: Record<string, any>,
-    currentLevel: number,
-    totalHeight: number,
-    idColumnKey: string
-  ): string {
-    let line = "│";
-
-    // Handle the ID column specially (could be _id or another key)
-    if (idColumnKey in widths && typeof widths[idColumnKey] === "number") {
-      if (currentLevel === 0) {
-        // Show the ID column header at the top level
-        const contentWidth = widths[idColumnKey] - 2;
-        const headerText = idColumnKey === '_id' ? '_id' : idColumnKey;
-        const padding = Math.max(0, contentWidth - headerText.length);
-        const leftPad = Math.floor(padding / 2);
-        const rightPad = padding - leftPad;
-
-        line += " " + " ".repeat(leftPad) + headerText + " ".repeat(rightPad) + " │";
-      } else {
-        // Empty cell for other levels
-        line += " ".repeat(widths[idColumnKey]) + "│";
-      }
+    private static renderHeaderRow(
+        widths: Record<string, any>,
+        currentLevel: number,
+        totalHeight: number,
+        idColumnKey: string
+    ): string {
+        let line = '│'
+
+        // Handle the ID column specially (could be _id or another key)
+        if (idColumnKey in widths && typeof widths[idColumnKey] === 'number') {
+            if (currentLevel === 0) {
+                // Show the ID column header at the top level
+                const contentWidth = widths[idColumnKey] - 2
+                const headerText = idColumnKey === '_id' ? '_id' : idColumnKey
+                const padding = Math.max(0, contentWidth - headerText.length)
+                const leftPad = Math.floor(padding / 2)
+                const rightPad = padding - leftPad
+
+                line += ' ' + ' '.repeat(leftPad) + headerText + ' '.repeat(rightPad) + ' │'
+            } else {
+                // Empty cell for other levels
+                line += ' '.repeat(widths[idColumnKey]) + '│'
+            }
+        }
+
+        const processLevel = (
+            obj: Record<string, any>,
+            level: number,
+            targetLevel: number
+        ): string => {
+            let result = ''
+
+            for (const key in obj) {
+                // Skip the ID column as it's handled separately
+                if (key === idColumnKey) continue
+
+                if (typeof obj[key] === 'object' && obj[key] !== null) {
+                    if (level === targetLevel) {
+                        // This is a column family at the target level
+                        const totalWidth = this.calculateTotalWidth(obj[key])
+                        const contentWidth = totalWidth - 2 // Subtract padding
+                        const padding = Math.max(0, contentWidth - key.length)
+                        const leftPad = Math.floor(padding / 2)
+                        const rightPad = padding - leftPad
+
+                        // Add 1 space padding + centered content + 1 space padding
+                        result += ' ' + ' '.repeat(leftPad) + key + ' '.repeat(rightPad) + ' │'
+                    } else if (level < targetLevel) {
+                        // Recurse deeper
+                        result += processLevel(obj[key], level + 1, targetLevel)
+                    }
+                } else {
+                    if (level === targetLevel) {
+                        // This is a leaf column at the target level
+                        const contentWidth = obj[key] - 2 // Subtract padding
+                        const padding = Math.max(0, contentWidth - key.length)
+                        const leftPad = Math.floor(padding / 2)
+                        const rightPad = padding - leftPad
+
+                        // Add 1 space padding + centered content + 1 space padding
+                        result += ' ' + ' '.repeat(leftPad) + key + ' '.repeat(rightPad) + ' │'
+                    } else if (level < targetLevel) {
+                        // Empty cell - span the full width
+                        result += ' '.repeat(obj[key]) + '│'
+                    }
+                }
+            }
+
+            return result
+        }
+
+        line += processLevel(widths, 0, currentLevel)
+        return line
     }
 
-    const processLevel = (
-      obj: Record<string, any>,
-      level: number,
-      targetLevel: number
-    ): string => {
-      let result = "";
-
-      for (const key in obj) {
-        // Skip the ID column as it's handled separately
-        if (key === idColumnKey) continue;
-
-        if (typeof obj[key] === "object" && obj[key] !== null) {
-          if (level === targetLevel) {
-            // This is a column family at the target level
-            const totalWidth = this.calculateTotalWidth(obj[key]);
-            const contentWidth = totalWidth - 2; // Subtract padding
-            const padding = Math.max(0, contentWidth - key.length);
-            const leftPad = Math.floor(padding / 2);
-            const rightPad = padding - leftPad;
-
-            // Add 1 space padding + centered content + 1 space padding
-            result +=
-              " " + " ".repeat(leftPad) + key + " ".repeat(rightPad) + " │";
-          } else if (level < targetLevel) {
-            // Recurse deeper
-            result += processLevel(obj[key], level + 1, targetLevel);
-          }
-        } else {
-          if (level === targetLevel) {
-            // This is a leaf column at the target level
-            const contentWidth = obj[key] - 2; // Subtract padding
-            const padding = Math.max(0, contentWidth - key.length);
-            const leftPad = Math.floor(padding / 2);
-            const rightPad = padding - leftPad;
-
-            // Add 1 space padding + centered content + 1 space padding
-            result +=
-              " " + " ".repeat(leftPad) + key + " ".repeat(rightPad) + " │";
-          } else if (level < targetLevel) {
-            // Empty cell - span the full width
-            result += " ".repeat(obj[key]) + "│";
-          }
+    private static calculateTotalWidth(obj: Record<string, any>): number {
+        let total = 0
+        let columnCount = 0
+
+        for (const key in obj) {
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                total += this.calculateTotalWidth(obj[key])
+                columnCount += this.countLeafColumns(obj[key])
+            } else {
+                total += obj[key]
+                columnCount++
+            }
         }
-      }
-
-      return result;
-    };
-
-    line += processLevel(widths, 0, currentLevel);
-    return line;
-  }
-
-  private static calculateTotalWidth(obj: Record<string, any>): number {
-    let total = 0;
-    let columnCount = 0;
-
-    for (const key in obj) {
-      if (typeof obj[key] === "object" && obj[key] !== null) {
-        total += this.calculateTotalWidth(obj[key]);
-        columnCount += this.countLeafColumns(obj[key]);
-      } else {
-        total += obj[key];
-        columnCount++;
-      }
+
+        // Add space for separators between columns (one less than column count)
+        return total + Math.max(0, columnCount - 1)
     }
 
-    // Add space for separators between columns (one less than column count)
-    return total + Math.max(0, columnCount - 1);
-  }
+    private static countLeafColumns(obj: Record<string, any>): number {
+        let count = 0
 
-  private static countLeafColumns(obj: Record<string, any>): number {
-    let count = 0;
+        for (const key in obj) {
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                count += this.countLeafColumns(obj[key])
+            } else {
+                count++
+            }
+        }
 
-    for (const key in obj) {
-      if (typeof obj[key] === "object" && obj[key] !== null) {
-        count += this.countLeafColumns(obj[key]);
-      } else {
-        count++;
-      }
+        return count
     }
 
-    return count;
-  }
+    private static renderTopBorder(
+        columns: Array<{ name: string; width: number; path: string[] }>
+    ): string {
+        let line = '┌'
 
-  private static renderTopBorder(
-    columns: Array<{ name: string; width: number; path: string[] }>
-  ): string {
-    let line = "┌";
+        for (let i = 0; i < columns.length; i++) {
+            line += '─'.repeat(columns[i].width)
+            if (i < columns.length - 1) {
+                line += '┬'
+            }
+        }
 
-    for (let i = 0; i < columns.length; i++) {
-      line += "─".repeat(columns[i].width);
-      if (i < columns.length - 1) {
-        line += "┬";
-      }
+        line += '┐'
+        return line
     }
 
-    line += "┐";
-    return line;
-  }
+    private static renderMiddleBorder(
+        columns: Array<{ name: string; width: number; path: string[] }>
+    ): string {
+        let line = '├'
 
-  private static renderMiddleBorder(
-    columns: Array<{ name: string; width: number; path: string[] }>
-  ): string {
-    let line = "├";
+        for (let i = 0; i < columns.length; i++) {
+            line += '─'.repeat(columns[i].width)
+            if (i < columns.length - 1) {
+                line += '┼'
+            }
+        }
 
-    for (let i = 0; i < columns.length; i++) {
-      line += "─".repeat(columns[i].width);
-      if (i < columns.length - 1) {
-        line += "┼";
-      }
+        line += '┤'
+        return line
     }
 
-    line += "┤";
-    return line;
-  }
+    private static renderBottomBorder(
+        columns: Array<{ name: string; width: number; path: string[] }>
+    ): string {
+        let line = '└'
 
-  private static renderBottomBorder(
-    columns: Array<{ name: string; width: number; path: string[] }>
-  ): string {
-    let line = "└";
+        for (let i = 0; i < columns.length; i++) {
+            line += '─'.repeat(columns[i].width)
+            if (i < columns.length - 1) {
+                line += '┴'
+            }
+        }
 
-    for (let i = 0; i < columns.length; i++) {
-      line += "─".repeat(columns[i].width);
-      if (i < columns.length - 1) {
-        line += "┴";
-      }
+        line += '┘'
+        return line
     }
-
-    line += "┘";
-    return line;
-  }
 }
 
-console.format = function(docs: Record<string, any>) {
-  Format.table(docs)
+console.format = function (docs: Record<string, any>) {
+    Format.table(docs)
 }