@mittwald/cli 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/rendering/formatter/ListDateColumnFormatter.d.ts

@@ -0,0 +1,26 @@
+import { DateRenderer } from "../textformat/formatDate.js";
+import { ListColumn } from "./ListFormatter.js";
+type ResourceWithCreatedAt = {
+    createdAt: string;
+};
+export declare function isResourceWithCreatedAt(resource: Record<string, unknown>): resource is ResourceWithCreatedAt;
+/**
+ * ListDateColumnFormatter is a helper class to create a column for a list
+ * formatter that can handle date formatting.
+ */
+export default class ListDateColumnFormatter {
+    private readonly flags;
+    constructor(flags: {
+        [k: string]: unknown;
+    });
+    get renderDate(): DateRenderer;
+    buildColumn<TColumnName extends string = "createdAt">({ header, fallback, column, extended, }?: {
+        header?: string;
+        fallback?: string;
+        column?: TColumnName | "createdAt";
+        extended?: boolean;
+    }): ListColumn<{
+        [k: string]: unknown;
+    }>;
+}
+export {};

package/dist/rendering/formatter/ListDateColumnFormatter.js

@@ -0,0 +1,28 @@
+import { formatDateISO, makeDateRendererForFormat, } from "../textformat/formatDate.js";
+import { isListFormatterFlags } from "./ListFormatter.js";
+export function isResourceWithCreatedAt(resource) {
+    return "createdAt" in resource;
+}
+/**
+ * ListDateColumnFormatter is a helper class to create a column for a list
+ * formatter that can handle date formatting.
+ */
+export default class ListDateColumnFormatter {
+    flags;
+    constructor(flags) {
+        this.flags = flags;
+    }
+    get renderDate() {
+        if (isListFormatterFlags(this.flags)) {
+            return makeDateRendererForFormat(this.flags.output, !this.flags["no-relative-dates"]);
+        }
+        return formatDateISO;
+    }
+    buildColumn({ header = "Created at", fallback = "unknown", column = "createdAt", extended = false, } = {}) {
+        return {
+            header,
+            extended,
+            get: (row) => row[column] ? this.renderDate(new Date(`${row[column]}`)) : fallback,
+        };
+    }
+}

package/dist/rendering/formatter/ListFormatter.d.ts

@@ -0,0 +1,29 @@
+import { BooleanFlag, OptionFlag } from "@oclif/core/interfaces";
+import { ListColumns } from "./Table.js";
+export { ListColumn, ListColumns } from "./Table.js";
+type ListFormatterFlags = {
+    output: OptionFlag<OutputFormat>;
+    extended: BooleanFlag<boolean>;
+    "no-header": BooleanFlag<boolean>;
+    "no-truncate": BooleanFlag<boolean>;
+    "no-relative-dates": BooleanFlag<boolean>;
+    "csv-separator": OptionFlag<"," | ";">;
+};
+export type ListOptions = {
+    output: OutputFormat;
+    extended: boolean;
+    "no-header": boolean;
+    "no-truncate": boolean;
+    "no-relative-dates": boolean;
+    "csv-separator": "," | ";";
+};
+declare const outputFormats: readonly ["txt", "json", "yaml", "csv", "tsv"];
+type OutputFormat = (typeof outputFormats)[number];
+export declare function isListFormatterFlags(flags: {
+    [k: string]: unknown;
+}): flags is ListOptions;
+export declare class ListFormatter {
+    static get flags(): ListFormatterFlags;
+    private buildTableRenderer;
+    log<T extends Record<string, unknown>>(output: T[], columns: ListColumns<T>, opts?: ListOptions): void;
+}

package/dist/rendering/formatter/ListFormatter.js

@@ -0,0 +1,85 @@
+import { Flags } from "@oclif/core";
+import { PrinterFactory } from "../Printer.js";
+import { stdout } from "@oclif/core/ux";
+import Table from "./Table.js";
+import { getTerminalWidth } from "../lib/getTerminalWidth.js";
+import TableColumnRenderer from "./TableColumnRenderer.js";
+import TableCSVRenderer from "./TableCSVRenderer.js";
+const outputFormats = ["txt", "json", "yaml", "csv", "tsv"];
+export function isListFormatterFlags(flags) {
+    return "output" in flags;
+}
+export class ListFormatter {
+    static get flags() {
+        return {
+            output: Flags.option({
+                required: true,
+                description: "output in a more machine friendly format",
+                options: outputFormats,
+                char: "o",
+                default: "txt",
+                multiple: false,
+            })(),
+            extended: Flags.boolean({
+                description: "show extended information",
+                char: "x",
+                required: false,
+                default: false,
+            }),
+            "no-header": Flags.boolean({
+                description: "hide table header",
+                required: false,
+                default: false,
+            }),
+            "no-truncate": Flags.boolean({
+                description: "do not truncate output (only relevant for txt output)",
+                required: false,
+                default: false,
+            }),
+            "no-relative-dates": Flags.boolean({
+                description: "show dates in absolute format, not relative (only relevant for txt output)",
+                required: false,
+                default: false,
+            }),
+            "csv-separator": Flags.custom({
+                description: "separator for CSV output (only relevant for CSV output)",
+                required: false,
+                default: ",",
+                options: [",", ";"],
+            })(),
+        };
+    }
+    buildTableRenderer(opts) {
+        if (opts?.output === "csv") {
+            return new TableCSVRenderer({
+                header: !opts?.["no-header"],
+                columnSeparator: opts?.["csv-separator"],
+            });
+        }
+        if (opts?.output === "tsv") {
+            return new TableCSVRenderer({
+                header: !opts?.["no-header"],
+                columnSeparator: "\t",
+            });
+        }
+        return new TableColumnRenderer({
+            maxWidth: getTerminalWidth(),
+            truncate: !opts?.["no-truncate"],
+            header: !opts?.["no-header"],
+        });
+    }
+    log(output, columns, opts) {
+        if (opts?.output === "json" || opts?.output === "yaml") {
+            PrinterFactory.build(opts.output).log(output);
+            return;
+        }
+        if (output.length === 0) {
+            return;
+        }
+        const tableRenderer = this.buildTableRenderer(opts);
+        const table = new Table(columns, tableRenderer, {
+            extended: opts?.extended,
+        });
+        stdout(table.render(output));
+    }
+}

package/dist/rendering/formatter/Table.d.ts

@@ -0,0 +1,48 @@
+import { TableRenderer } from "./TableRenderer.js";
+export type ListColumn<TItem> = {
+    /** The header to display for this column. */
+    header?: string;
+    /**
+     * Whether this column counts as an extended column. Extended columns are only
+     * displayed when the `extended` option is set to `true`.
+     */
+    extended?: boolean;
+    /**
+     * A function to extract the value to display for this column from the item.
+     * If not set, the column will be extracted from the item by its key.
+     */
+    get?: (row: TItem) => string | undefined;
+    /**
+     * The minimum width of this column. If the content is smaller, the column
+     * will be padded with spaces. If the content is larger, the column might be
+     * expanded based on the available remaining space, or truncated.
+     */
+    minWidth?: number;
+    /**
+     * The exact width of this column. If set, the column will be exactly this
+     * wide, regardless of the content.
+     */
+    exactWidth?: number;
+    /**
+     * Whether this column should expand to fill the remaining space. Currently,
+     * only one column can be set to expand.
+     */
+    expand?: boolean;
+};
+export type ListColumns<TItem> = {
+    [key: string]: ListColumn<TItem>;
+};
+export interface TableOptions {
+    /** Whether to include extended columns in the output. */
+    extended: boolean;
+}
+export default class Table<TItem> {
+    private readonly columns;
+    private readonly opts;
+    private readonly renderer;
+    constructor(columns: ListColumns<TItem>, renderer: TableRenderer<TItem>, opts?: Partial<TableOptions>);
+    render(data: TItem[]): string;
+    /** The columns with their names as an array of tuples. */
+    get columnsWithNames(): [string, ListColumn<TItem>][];
+    extractRowValues(data: TItem[]): string[][];
+}

package/dist/rendering/formatter/Table.js

@@ -0,0 +1,44 @@
+/** Default options for the table formatter. */
+const defaultOptions = {
+    extended: false,
+};
+export default class Table {
+    columns;
+    opts;
+    renderer;
+    constructor(columns, renderer, opts = {}) {
+        this.columns = columns;
+        this.renderer = renderer;
+        this.opts = {
+            ...defaultOptions,
+            ...opts,
+        };
+    }
+    render(data) {
+        return this.renderer.render(this, data);
+    }
+    /** The columns with their names as an array of tuples. */
+    get columnsWithNames() {
+        let columns = Object.entries(this.columns);
+        if (!this.opts.extended) {
+            columns = columns.filter(([, spec]) => !spec.extended);
+        }
+        return columns;
+    }
+    extractRowValues(data) {
+        const columns = this.columnsWithNames;
+        const renderedItems = [];
+        for (let idx = 0; idx < data.length; idx++) {
+            const rendered = columns.map(([key, spec]) => {
+                if (spec.get) {
+                    return spec.get(data[idx]) ?? "";
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const value = data[idx][key] ?? "";
+                return String(value);
+            });
+            renderedItems.push(rendered);
+        }
+        return renderedItems;
+    }
+}

package/dist/rendering/formatter/Table.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rendering/formatter/Table.test.js

@@ -0,0 +1,105 @@
+import Table from "./Table.js";
+import { describe, expect, it } from "@jest/globals";
+import TableColumnRenderer from "./TableColumnRenderer.js";
+function effectiveStringLength(str) {
+    const backspaceCount = (str.match(/[\b]/g) ?? []).length;
+    return str.length - backspaceCount * 2;
+}
+describe("Table", () => {
+    it("should spread a single column across the max width", () => {
+        const t = new Table({
+            a: {
+                header: "A",
+            },
+        }, new TableColumnRenderer({ maxWidth: 20, chalkOptions: { level: 0 } }));
+        const rendered = t.render([{ a: "Foo" }, { a: "Bar" }]);
+        expect(rendered).toMatchSnapshot();
+        expect(rendered.split("\n")[0].length).toBe(20);
+    });
+    it("should truncate too long values", () => {
+        const t = new Table({
+            a: {
+                header: "A",
+            },
+        }, new TableColumnRenderer({ maxWidth: 20, chalkOptions: { level: 0 } }));
+        const rendered = t.render([
+            { a: "Foo".repeat(10) },
+            { a: "Bar".repeat(10) },
+        ]);
+        const lines = rendered.split("\n");
+        expect(rendered).toMatchSnapshot();
+        expect(lines[0].length).toBe(20);
+        expect(effectiveStringLength(lines[2])).toBe(20);
+    });
+    it("should not truncate too long values when truncation is disabled", () => {
+        const t = new Table({
+            a: {
+                header: "A",
+            },
+        }, new TableColumnRenderer({
+            maxWidth: 20,
+            chalkOptions: { level: 0 },
+            truncate: false,
+        }));
+        const rendered = t.render([
+            { a: "Foo".repeat(20) },
+            { a: "Bar".repeat(20) },
+        ]);
+        const lines = rendered.split("\n");
+        expect(rendered).toMatchSnapshot();
+        expect(lines[0].length).toBeGreaterThan(20);
+        expect(effectiveStringLength(lines[2])).toBeGreaterThan(20);
+    });
+    it("should respect the minimum column width", () => {
+        const t = new Table({
+            a: { minWidth: 15 },
+            b: {},
+        }, new TableColumnRenderer({ maxWidth: 20, chalkOptions: { level: 0 } }));
+        const rendered = t.render([
+            { a: "a", b: "b".repeat(20) },
+            { a: "a", b: "b".repeat(20) },
+        ]);
+        expect(rendered).toMatchSnapshot();
+    });
+    it("should give expanding columns the remaining space", () => {
+        const t = new Table({
+            a: { minWidth: 3 },
+            b: { expand: true },
+            c: { minWidth: 3 },
+        }, new TableColumnRenderer({ maxWidth: 20, chalkOptions: { level: 0 } }));
+        const rendered = t.render([
+            { a: "aaa", b: "b".repeat(20), c: "ccc" },
+            { a: "aaa", b: "b".repeat(20), c: "ccc" },
+        ]);
+        expect(rendered).toMatchSnapshot();
+    });
+    it("should still give non-expanding columns a bit more space if available", () => {
+        const t = new Table({
+            a: { minWidth: 3 },
+            b: { expand: true },
+            c: {},
+        }, new TableColumnRenderer({ maxWidth: 40, chalkOptions: { level: 0 } }));
+        const rendered = t.render([
+            { a: "aaa", b: "b".repeat(40), c: "ccc" },
+            { a: "aaa", b: "b".repeat(40), c: "ccc" },
+        ]);
+        expect(rendered).toMatchSnapshot();
+    });
+    describe("without max width", () => {
+        it("should give each column the maximum content width when no max width ", () => {
+            const t = new Table({
+                a: { minWidth: 3 },
+                b: { expand: true },
+                c: {},
+            }, new TableColumnRenderer({
+                maxWidth: undefined,
+                chalkOptions: { level: 0 },
+            }));
+            const rendered = t.render([
+                { a: "aaa", b: "b".repeat(40), c: "ccc" },
+                { a: "aaa", b: "b".repeat(40), c: "ccc" },
+            ]);
+            expect(rendered).toMatchSnapshot();
+        });
+    });
+});

package/dist/rendering/formatter/TableCSVRenderer.d.ts

@@ -0,0 +1,12 @@
+import { TableRenderer, TableRendererOptions } from "./TableRenderer.js";
+import Table from "./Table.js";
+export interface TableCSVRendererOptions extends TableRendererOptions {
+    columnSeparator: ";" | "," | "\t";
+    rowSeparator: "\r\n" | "\n";
+    quote: "'" | '"';
+}
+export default class TableCSVRenderer<TItem> implements TableRenderer<TItem> {
+    private readonly opts;
+    constructor(opts: Partial<TableCSVRendererOptions>);
+    render(table: Table<TItem>, items: TItem[]): string;
+}

package/dist/rendering/formatter/TableCSVRenderer.js

@@ -0,0 +1,41 @@
+const defaultOptions = {
+    header: true,
+    headerRenderer: (s) => s,
+    quote: '"',
+    columnSeparator: ",",
+    rowSeparator: "\r\n",
+};
+export default class TableCSVRenderer {
+    opts;
+    constructor(opts) {
+        this.opts = {
+            ...defaultOptions,
+            ...opts,
+        };
+    }
+    render(table, items) {
+        const columns = table.columnsWithNames;
+        const values = table.extractRowValues(items);
+        const { header, rowSeparator, columnSeparator, quote } = this.opts;
+        let output = "";
+        if (header) {
+            const headerNames = columns.map(([key, spec]) => spec.header ?? key);
+            const headerLabels = headerNames
+                .map(this.opts.headerRenderer)
+                .map((v) => quoteForCSV(v, quote, columnSeparator));
+            const headerRow = headerLabels.join(columnSeparator);
+            output += headerRow + rowSeparator;
+        }
+        const rows = values.map((row) => row
+            .map((value) => quoteForCSV(value, quote, columnSeparator))
+            .join(columnSeparator));
+        output += rows.join(rowSeparator);
+        return output;
+    }
+}
+function quoteForCSV(value, quote, separator) {
+    if (value.includes(quote) || value.includes(separator)) {
+        return quote + value.replace(quote, "\\" + quote) + quote;
+    }
+    return value;
+}

package/dist/rendering/formatter/TableColumnRenderer.d.ts

@@ -0,0 +1,38 @@
+import { TableRenderer, TableRendererOptions } from "./TableRenderer.js";
+import Table from "./Table.js";
+import { Options as ChalkOptions } from "chalk";
+export interface TableColumnRendererOptions extends TableRendererOptions {
+    /**
+     * The maximum width of the table in characters. If columns exceed this width,
+     * they will be truncated. If omitted, the table will be as wide as necessary
+     * (but not wider).
+     */
+    maxWidth: number | undefined;
+    /** Whether to truncate columns that exceed the maximum width. */
+    truncate: boolean;
+    /** The gap between columns in characters. */
+    gap: number;
+    /** Options to pass to the Chalk instance used for rendering. */
+    chalkOptions: ChalkOptions;
+    /**
+     * When columns were truncated and some space is still left, the remaining
+     * space is distributed among the columns. This factor determines how much
+     * smaller columns are favored over larger columns.
+     *
+     * Default is 0.2.
+     */
+    favorSmallColumnsFactor: number;
+}
+export default class TableColumnRenderer<TItem> implements TableRenderer<TItem> {
+    private opts;
+    private readonly chalk;
+    constructor(opts: Partial<TableColumnRendererOptions>);
+    render(table: Table<TItem>, data: TItem[]): string;
+    private renderItems;
+    private renderHeader;
+    private widenColumnsToFitAvailableSpace;
+    private widenColumnsProportionally;
+    private widenColumnsToFitTruncatedContent;
+    /** The total width reserved for column gaps. */
+    private totalColumnGapReservation;
+}

package/dist/rendering/formatter/TableColumnRenderer.js

@@ -0,0 +1,128 @@
+import smartPadOrTruncate from "./smartPadOrTruncate.js";
+import debug from "debug";
+import { Chalk } from "chalk";
+import stringWidth from "string-width";
+const d = debug("mw:renderer:table:columns");
+const defaultOptions = {
+    headerRenderer: (label) => label.toUpperCase(),
+    maxWidth: undefined,
+    truncate: true,
+    header: true,
+    gap: 2,
+    chalkOptions: {},
+    favorSmallColumnsFactor: 0.2,
+};
+export default class TableColumnRenderer {
+    opts;
+    chalk;
+    constructor(opts) {
+        this.chalk = new Chalk(opts.chalkOptions);
+        this.opts = {
+            ...defaultOptions,
+            ...opts,
+        };
+    }
+    render(table, data) {
+        const availableWidth = this.opts.maxWidth;
+        const { columnsWithNames } = table;
+        const reservedWidths = columnsWithNames.map(([key, spec]) => minWidthForColumn(key, spec));
+        const initialDynamicWidths = columnsWithNames.map(([, spec]) => spec.minWidth || spec.header?.length || 0);
+        const [renderedItems, dynamicWidths] = this.renderItems(table, initialDynamicWidths, data);
+        let definiteColWidths = [...reservedWidths];
+        if (availableWidth && this.opts.truncate) {
+            definiteColWidths = addColumWidths(definiteColWidths, this.widenColumnsToFitAvailableSpace(table, availableWidth, columnsWithNames, definiteColWidths, dynamicWidths));
+        }
+        else {
+            // when no maximum width is given, just use the maximum content width
+            definiteColWidths.forEach((width, idx) => {
+                definiteColWidths[idx] = Math.max(width, dynamicWidths[idx]);
+            });
+        }
+        d("table options: %o", this.opts);
+        d("definite column widths: %o (sum: %o)", definiteColWidths, sum(definiteColWidths));
+        let output = "";
+        const gap = " ".repeat(this.opts.gap);
+        if (this.opts.header) {
+            output += this.renderHeader(columnsWithNames, definiteColWidths);
+        }
+        for (let idx = 0; idx < renderedItems.length; idx++) {
+            const truncatedRows = renderedItems[idx].map((val, idx) => smartPadOrTruncate(val, definiteColWidths[idx]));
+            output += truncatedRows.join(gap) + "\n";
+        }
+        return output;
+    }
+    renderItems(table, columnWidths, data) {
+        const renderedItems = table.extractRowValues(data);
+        const newColumnWidths = columnWidths.map((w, idx) => {
+            const renderedWidths = renderedItems.map((r) => stringWidth(r[idx]));
+            return Math.max(w, ...renderedWidths);
+        });
+        return [renderedItems, newColumnWidths];
+    }
+    renderHeader(columns, columnWidths) {
+        const headerNames = columns.map(([key, value]) => value.header ?? key);
+        const renderedHeaderTitles = headerNames.map(this.opts.headerRenderer);
+        const truncatedHeaderColumns = renderedHeaderTitles.map((val, idx) => smartPadOrTruncate(val, columnWidths[idx]));
+        const dividerColumns = columnWidths.map((w) => "─".repeat(w));
+        const gap = " ".repeat(this.opts.gap);
+        return ([
+            this.chalk.bold(truncatedHeaderColumns.join(gap)),
+            this.chalk.bold(dividerColumns.join(gap)),
+        ].join("\n") + "\n");
+    }
+    widenColumnsToFitAvailableSpace(table, availableWidth, columnsWithNames, definiteColWidths, maximumColWidths) {
+        const totalColumnGapReservation = this.totalColumnGapReservation(table);
+        const computeRemainingWidth = () => availableWidth - sum(definiteColWidths) - totalColumnGapReservation;
+        const remainingInitially = computeRemainingWidth();
+        const expandingColumn = columnsWithNames.findIndex(([_, spec]) => spec.expand);
+        const hasExpandingColumn = expandingColumn >= 0;
+        const additionalColumnWidths = this.widenColumnsToFitTruncatedContent(remainingInitially, definiteColWidths, maximumColWidths);
+        definiteColWidths = addColumWidths(definiteColWidths, additionalColumnWidths);
+        const remainingAfterExpansionForTruncated = computeRemainingWidth();
+        // If a column is set to expand, give it all the remaining space; otherwise,
+        // distribute it proportionally to requested content width among all columns
+        if (hasExpandingColumn) {
+            additionalColumnWidths[expandingColumn] +=
+                remainingAfterExpansionForTruncated;
+            return additionalColumnWidths;
+        }
+        return addColumWidths(additionalColumnWidths, this.widenColumnsProportionally(remainingAfterExpansionForTruncated, columnsWithNames, definiteColWidths));
+    }
+    widenColumnsProportionally(remaining, columnsWithNames, maximumColWidths) {
+        const growableRequestedWidth = sum(columnsWithNames.map(([_, spec], idx) => spec.exactWidth === undefined ? maximumColWidths[idx] : 0));
+        const growableProportions = columnsWithNames.map(([_, spec], idx) => spec.exactWidth === undefined
+            ? maximumColWidths[idx] / growableRequestedWidth
+            : 0);
+        return growableProportions.map((p) => Math.floor(p * remaining));
+    }
+    widenColumnsToFitTruncatedContent(remaining, definiteColWidths, maximumColWidths) {
+        const truncatedWidths = maximumColWidths.map((w, idx) => w - definiteColWidths[idx]);
+        const totalTruncated = sum(truncatedWidths);
+        if (totalTruncated < remaining) {
+            return truncatedWidths;
+        }
+        const { favorSmallColumnsFactor } = this.opts;
+        const [a, b] = [1 - favorSmallColumnsFactor, favorSmallColumnsFactor];
+        const availableForTruncatedContent = remaining / 2;
+        const additionalSpaceForTruncatedWeights = truncatedWidths
+            .map((w) => w / totalTruncated)
+            .map((w) => w * a + b); // slightly favor smaller columns
+        return additionalSpaceForTruncatedWeights.map((w, idx) => Math.min(truncatedWidths[idx], Math.floor(w * availableForTruncatedContent)));
+    }
+    /** The total width reserved for column gaps. */
+    totalColumnGapReservation(table) {
+        return (table.columnsWithNames.length - 1) * this.opts.gap;
+    }
+}
+function minWidthForColumn(key, c) {
+    return c.minWidth ?? c.exactWidth ?? c.header?.length ?? key.length;
+}
+function sum(x) {
+    return x.reduce((a, b) => a + b, 0);
+}
+function addColumWidths(x, y) {
+    if (x.length !== y.length) {
+        throw new Error("Column width arrays must have the same length");
+    }
+    return x.map((v, idx) => v + y[idx]);
+}

package/dist/rendering/formatter/TableRenderer.d.ts

@@ -0,0 +1,15 @@
+import Table from "./Table.js";
+export interface TableRendererOptions {
+    /**
+     * Renderer function for the header labels. By default, the labels are
+     * uppercased.
+     *
+     * @param label
+     */
+    headerRenderer: (label: string) => string;
+    /** Whether to include a header row in the output. */
+    header: boolean;
+}
+export interface TableRenderer<TItem> {
+    render(table: Table<TItem>, items: TItem[]): string;
+}

package/dist/rendering/formatter/TableRenderer.js

@@ -0,0 +1 @@
+export {};

package/dist/rendering/formatter/printHeader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prints a header with a predefined style.
+ *
+ * @deprecated Use React components instead!
+ * @param heading
+ */
+export declare function printHeader(heading: string): void;

package/dist/rendering/formatter/printHeader.js

@@ -0,0 +1,12 @@
+import chalk from "chalk";
+/**
+ * Prints a header with a predefined style.
+ *
+ * @deprecated Use React components instead!
+ * @param heading
+ */
+export function printHeader(heading) {
+    console.log(chalk.bold.white(heading));
+    console.log(chalk.bold.white("─".repeat(heading.length)));
+    console.log();
+}

package/dist/rendering/formatter/printKeyValues.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prints a list of key-value pairs.
+ *
+ * @deprecated Use React components instead!
+ * @param tableContents
+ */
+export declare function printKeyValues(tableContents: Record<string, string>): void;

package/dist/rendering/formatter/printKeyValues.js

@@ -0,0 +1,14 @@
+import chalk from "chalk";
+/**
+ * Prints a list of key-value pairs.
+ *
+ * @deprecated Use React components instead!
+ * @param tableContents
+ */
+export function printKeyValues(tableContents) {
+    const keys = Object.keys(tableContents);
+    const l = Math.max(...keys.map((k) => k.length));
+    for (const key of keys) {
+        console.log(chalk.blueBright(key.padEnd(l, " ")), " ", tableContents[key]);
+    }
+}

package/dist/rendering/formatter/smartPad.d.ts

@@ -0,0 +1 @@
+export default function smartPad(str: string, length: number): string;