@mittwald/cli 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/esm/rendering/react/components/Project/ProjectEnabled.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+interface Props {
+    enabled: boolean;
+}
+export declare const ProjectEnabled: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Project/ProjectEnabled.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export const ProjectEnabled = (props) => {
+    const { enabled } = props;
+    if (enabled) {
+        return _jsx(Text, { color: "green", children: "enabled" });
+    }
+    return _jsx(Text, { color: "red", children: "disabled" });
+};

package/dist/esm/rendering/react/components/Project/ProjectSimpleStatus.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+interface Props {
+    status: MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+}
+export declare const ProjectSimpleStatus: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Project/ProjectSimpleStatus.js

@@ -0,0 +1,19 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+import { Value } from "../Value.js";
+export const ProjectSimpleStatus = (props) => {
+    const { status } = props;
+    switch (status) {
+        case "ready":
+            return _jsxs(Text, { color: "green", children: [status, " \uD83D\uDE80"] });
+        case "migratingVolume":
+        case "pending":
+            return _jsxs(Text, { color: "blue", children: [status, " \uD83C\uDFD7"] });
+        case "error":
+            return _jsxs(Text, { color: "red", children: [status, " \uD83D\uDC80"] });
+        case "disabled":
+            return _jsxs(Text, { color: "red", children: [status, " \uD83D\uDEAB"] });
+        default:
+            return _jsx(Value, { notSet: true });
+    }
+};

package/dist/esm/rendering/react/components/Project/ProjectStatus.d.ts

@@ -0,0 +1,18 @@
+import { FC } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import ProjectProjectReadinessStatus = MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+interface Props {
+    /**
+     * The project to display the status for.
+     *
+     * Use a custom type instead of any of the generated types, because there are
+     * multiple, slightly different types for project responses. However, all
+     * response types should implement this interface one way or another.
+     */
+    project: {
+        enabled: boolean;
+        status: ProjectProjectReadinessStatus;
+    };
+}
+export declare const ProjectStatus: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Project/ProjectStatus.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+import { ProjectEnabled } from "./ProjectEnabled.js";
+import { ProjectSimpleStatus } from "./ProjectSimpleStatus.js";
+export const ProjectStatus = (props) => {
+    const { project } = props;
+    return (_jsxs(Text, { children: [_jsx(ProjectEnabled, { enabled: project.enabled }), _jsx(Text, { children: " / " }), _jsx(ProjectSimpleStatus, { status: project.status })] }));
+};

package/dist/esm/rendering/react/components/ProjectBackup/ProjectBackupDetails.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+export declare const ProjectBackupDetails: FC<{
+    projectBackup: BackupProjectBackup;
+}>;

package/dist/esm/rendering/react/components/ProjectBackup/ProjectBackupDetails.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { SingleResult, SingleResultTable } from "../SingleResult.js";
+import { Text } from "ink";
+import { Value } from "../Value.js";
+import { useProjectBackupSchedule } from "../../../../lib/projectbackup/hooks.js";
+import { FormattedDate } from "../FormattedDate.js";
+import { ProjectBackupStatus } from "./ProjectBackupStatus.js";
+import { useProject } from "../../../../lib/project/hooks.js";
+import { IDAndShortID } from "../IDAndShortID.js";
+export const ProjectBackupDetails = ({ projectBackup }) => {
+    const project = useProject(projectBackup.projectId);
+    const schedule = projectBackup.parentId
+        ? useProjectBackupSchedule(projectBackup.parentId)
+        : undefined;
+    return (_jsx(SingleResult, { title: _jsxs(Text, { children: ["PROJECT BACKUP: ", _jsx(Value, { children: projectBackup.id })] }), rows: {
+            ID: _jsx(Value, { children: projectBackup.id }),
+            "Created at": projectBackup.createdAt ? (_jsx(Value, { children: _jsx(FormattedDate, { date: projectBackup.createdAt, relative: true, absolute: true }) })) : (_jsx(Value, { notSet: true })),
+            "Expires in": projectBackup.expiresAt ? (_jsx(Value, { children: _jsx(FormattedDate, { date: projectBackup.expiresAt, relative: true, absolute: true }) })) : (_jsx(Value, { notSet: true })),
+            Status: _jsx(ProjectBackupStatus, { projectBackup: projectBackup }),
+            Project: (_jsx(SingleResultTable, { rows: {
+                    ID: _jsx(IDAndShortID, { object: project }),
+                    Description: _jsx(Value, { children: project.description }),
+                } })),
+            Schedule: schedule ? (_jsx(SingleResultTable, { rows: {
+                    ID: _jsx(Value, { children: schedule.id }),
+                    Schedule: _jsx(Value, { children: schedule.schedule }),
+                } })) : (_jsx(Value, { notSet: true })),
+        } }));
+};

package/dist/esm/rendering/react/components/ProjectBackup/ProjectBackupStatus.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+export declare const ProjectBackupStatus: FC<{
+    projectBackup: BackupProjectBackup;
+}>;

package/dist/esm/rendering/react/components/ProjectBackup/ProjectBackupStatus.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export const ProjectBackupStatus = ({ projectBackup }) => {
+    if (projectBackup.status === "Completed") {
+        return _jsx(Text, { color: "green", children: "\u2705 completed" });
+    }
+    return _jsx(Text, { color: "yellow", children: projectBackup.status });
+};

package/dist/esm/rendering/react/components/Render.d.ts

@@ -0,0 +1,6 @@
+import { ComponentType, FC } from "react";
+interface Props {
+    render: ComponentType;
+}
+export declare const Render: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Render.js

@@ -0,0 +1,5 @@
+import { createElement } from "react";
+export const Render = (props) => {
+    const { render } = props;
+    return createElement(render);
+};

package/dist/esm/rendering/react/components/SingleResult.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+export interface SingleResultProps {
+    title: ReactNode;
+    rows: Record<string, ReactNode>;
+}
+export interface SingleResultTableProps {
+    rows: Record<string, ReactNode>;
+}
+export declare function SingleResultTable({ rows }: SingleResultTableProps): import("react/jsx-runtime").JSX.Element;
+export declare function SingleResult({ title, rows }: SingleResultProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/rendering/react/components/SingleResult.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Header } from "./Header.js";
+import { Box, Text } from "ink";
+export function SingleResultTable({ rows }) {
+    const maxColumnWidth = Object.keys(rows)
+        .map((r) => r.length)
+        .reduce((a, b) => Math.max(a, b), 0);
+    const renderedRows = Object.keys(rows).map((key, idx) => {
+        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: maxColumnWidth + 3, children: _jsx(Text, { children: key }) }), _jsx(Box, { children: rows[key] })] }, idx));
+    });
+    return _jsx(Box, { flexDirection: "column", children: renderedRows });
+}
+export function SingleResult({ title, rows }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginY: 1, children: _jsx(Header, { title: title }) }), _jsx(SingleResultTable, { rows: rows })] }));
+}

package/dist/esm/rendering/react/components/Success.d.ts

@@ -0,0 +1,9 @@
+import React, { FC } from "react";
+interface Props {
+    title?: string;
+    children?: React.ReactNode;
+    color?: string;
+    width?: number;
+}
+export declare const Success: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Success.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export const Success = (props) => {
+    const { title = "Success", color = "#00B785", width = 80 } = props;
+    return (_jsxs(Box, { width: width, borderStyle: "round", borderColor: color, flexDirection: "column", paddingX: 2, children: [_jsx(Text, { bold: true, underline: true, color: color, children: title.toUpperCase() }), _jsx(Text, { wrap: "wrap", color: color, children: props.children })] }));
+};

package/dist/esm/rendering/react/components/Table/BodyCell.d.ts

@@ -0,0 +1,7 @@
+import * as Model from "./model/index.js";
+import { FC } from "react";
+interface Props {
+    cell: Model.Cell;
+}
+export declare const BodyCell: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Table/BodyCell.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CellLayout } from "./CellLayout.js";
+import { CellData } from "./CellData.js";
+export const BodyCell = (props) => {
+    const { cell } = props;
+    return (_jsx(CellLayout, { col: cell.column, children: _jsx(CellData, { data: cell.getData() }) }));
+};

package/dist/esm/rendering/react/components/Table/BodyRow.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import * as Model from "./model/index.js";
+interface Props {
+    row: Model.Row;
+}
+export declare const BodyRow: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Table/BodyRow.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BodyCell } from "./BodyCell.js";
+import { RowLayout } from "./RowLayout.js";
+export const BodyRow = (props) => {
+    const { row } = props;
+    return (_jsx(RowLayout, { children: row.table.columns.map((col) => (_jsx(BodyCell, { cell: row.getCell(col.name) }, col.name.value))) }));
+};

package/dist/esm/rendering/react/components/Table/BodyRows.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import * as Model from "./model/index.js";
+interface Props {
+    table: Model.Table;
+}
+export declare const BodyRows: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Table/BodyRows.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { BodyRow } from "./BodyRow.js";
+export const BodyRows = (props) => {
+    const { table } = props;
+    return (_jsx(_Fragment, { children: table.rows.map((row) => (_jsx(BodyRow, { row: row }, row.index))) }));
+};

package/dist/esm/rendering/react/components/Table/CellData.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+interface Props {
+    data: unknown;
+}
+export declare const CellData: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Table/CellData.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { isValidElement } from "react";
+import { FormattedDate } from "../FormattedDate.js";
+import { JSONView } from "../JSONView.js";
+import { parseDate } from "../../../../lib/viewhelpers/date.js";
+import { Value } from "../Value.js";
+export const CellData = (props) => {
+    const { data } = props;
+    if (data === null || data === undefined) {
+        return _jsx(Value, { notSet: true });
+    }
+    if (isValidElement(data)) {
+        return data;
+    }
+    if (data instanceof Date) {
+        return _jsx(FormattedDate, { date: data, relative: true });
+    }
+    if (typeof data === "string") {
+        const date = parseDate(data);
+        if (date) {
+            return _jsx(FormattedDate, { relative: true, date: data });
+        }
+        return data;
+    }
+    if (typeof data === "object") {
+        return _jsx(JSONView, { inline: true, json: data });
+    }
+    if (typeof data === "boolean") {
+        return data ? "yes" : "no";
+    }
+    return "";
+};

package/dist/esm/rendering/react/components/Table/CellLayout.d.ts

@@ -0,0 +1,8 @@
+import * as Model from "./model/index.js";
+import { Box } from "ink";
+import { ComponentProps, FC, PropsWithChildren } from "react";
+interface Props extends ComponentProps<typeof Box> {
+    col: Model.Column;
+}
+export declare const CellLayout: FC<PropsWithChildren<Props>>;
+export {};

package/dist/esm/rendering/react/components/Table/CellLayout.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { MeasureChildren } from "../../measure/MeasureChildren.js";
+import { WithoutLineBreaks } from "../WithoutLineBreaks.js";
+import { useTableContext } from "./context.js";
+export const CellLayout = (props) => {
+    const { col, children, ...boxProps } = props;
+    const { setup } = useTableContext();
+    const { noTruncate } = setup;
+    const width = col.useWidth();
+    const minWidth = col.options.minWidth;
+    if (!col.options.isVisible) {
+        return null;
+    }
+    const wrap = noTruncate ? "wrap" : "truncate";
+    return (_jsx(Box, { width: width, minWidth: minWidth, ...boxProps, children: _jsx(MeasureChildren, { onDimensionChange: (dim) => col.onCellMeasured(dim), children: _jsx(Text, { wrap: wrap, children: _jsx(WithoutLineBreaks, { children: children }) }) }) }));
+};

package/dist/esm/rendering/react/components/Table/HeaderCell.d.ts

@@ -0,0 +1,7 @@
+import * as Model from "./model/index.js";
+import { FC } from "react";
+interface Props {
+    col: Model.Column;
+}
+export declare const HeaderCell: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Table/HeaderCell.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+import { CellLayout } from "./CellLayout.js";
+export const HeaderCell = (props) => {
+    const { col } = props;
+    return (_jsx(CellLayout, { col: col, borderStyle: "single", borderTop: false, borderLeft: false, borderRight: false, children: _jsx(Text, { bold: true, children: col.options.header ?? col.name.humanizedName }) }));
+};

package/dist/esm/rendering/react/components/Table/HeaderRow.d.ts

@@ -0,0 +1,8 @@
+import * as Model from "./model/index.js";
+import { Box } from "ink";
+import { ComponentProps, FC } from "react";
+interface Props extends ComponentProps<typeof Box> {
+    table: Model.Table;
+}
+export declare const HeaderRow: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Table/HeaderRow.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RowLayout } from "./RowLayout.js";
+import { HeaderCell } from "./HeaderCell.js";
+export const HeaderRow = (props) => {
+    const { table, ...boxProps } = props;
+    return (_jsx(RowLayout, { ...boxProps, children: table.columns.map((col) => (_jsx(HeaderCell, { col: col }, col.name.value))) }));
+};

package/dist/esm/rendering/react/components/Table/RowLayout.d.ts

@@ -0,0 +1,5 @@
+import { ComponentProps, FC, PropsWithChildren } from "react";
+import { Box } from "ink";
+type Props = PropsWithChildren<ComponentProps<typeof Box>>;
+export declare const RowLayout: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/Table/RowLayout.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from "ink";
+export const RowLayout = (props) => (_jsx(Box, { flexDirection: "row", gap: 1, ...props }));

package/dist/esm/rendering/react/components/Table/Table.d.ts

@@ -0,0 +1,10 @@
+import { TableColumnsInput } from "./model/index.js";
+import { ReactNode } from "react";
+import { TableRenderSetupOutput } from "../../../setup/TableRenderSetup.js";
+interface Props<TData> {
+    data: TData[];
+    setup: TableRenderSetupOutput;
+    columns?: TableColumnsInput<TData>;
+}
+export declare function Table<TData>(props: Props<TData>): ReactNode;
+export {};

package/dist/esm/rendering/react/components/Table/Table.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as Model from "./model/index.js";
+import { useRef } from "react";
+import { Box } from "ink";
+import { useRenderContext } from "../../context.js";
+import { RenderJson } from "../../json/RenderJson.js";
+import { MeasureContextProvider } from "../../measure/MeasureContextProvider.js";
+import { HeaderRow } from "./HeaderRow.js";
+import { BodyRows } from "./BodyRows.js";
+import { buildTableContext, TableContextProvider } from "./context.js";
+export function Table(props) {
+    const { data, columns, setup } = props;
+    const { renderAsJson } = useRenderContext();
+    if (renderAsJson) {
+        return _jsx(RenderJson, { name: "data", data: data });
+    }
+    const table = useRef(new Model.Table(data, setup, columns)).current;
+    return (_jsx(TableContextProvider, { value: buildTableContext({
+            setup,
+        }), children: _jsx(MeasureContextProvider, { children: _jsxs(Box, { flexDirection: "column", children: [_jsx(HeaderRow, { marginBottom: 1, table: table }), _jsx(BodyRows, { table: table })] }) }) }));
+}

package/dist/esm/rendering/react/components/Table/context.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { TableRenderSetupOutput } from "../../../setup/TableRenderSetup.js";
+interface TableContext {
+    setup: TableRenderSetupOutput;
+}
+export declare const buildTableContext: (ctx?: Partial<TableContext>) => TableContext;
+export declare const useTableContext: () => TableContext;
+export declare const TableContextProvider: import("react").Provider<TableContext>;
+export {};

package/dist/esm/rendering/react/components/Table/context.js

@@ -0,0 +1,7 @@
+import { createContext, useContext } from "react";
+export const buildTableContext = (ctx = {}) => ({
+    ...ctx,
+});
+const context = createContext(buildTableContext());
+export const useTableContext = () => useContext(context);
+export const TableContextProvider = context.Provider;

package/dist/esm/rendering/react/components/Table/index.d.ts

@@ -0,0 +1 @@
+export { Table } from "./Table.js";

package/dist/esm/rendering/react/components/Table/index.js

@@ -0,0 +1 @@
+export { Table } from "./Table.js";

package/dist/esm/rendering/react/components/Table/model/Cell.d.ts

@@ -0,0 +1,19 @@
+import { Row } from "./Row.js";
+import { Column } from "./Column.js";
+import { ColumnName } from "./ColumnName.js";
+export type TableCellMapper<T> = (data: T) => string;
+export interface CellDataObject<T> {
+    name: string;
+    data: T;
+    mapper?: TableCellMapper<T>;
+}
+export declare class Cell<T = unknown> {
+    readonly name: ColumnName;
+    private readonly data;
+    readonly row: Row;
+    private constructor();
+    static fromObject<T>(row: Row, object: CellDataObject<T>): Cell<T>;
+    static empty(row: Row, name: string): Cell<undefined>;
+    get column(): Column;
+    getData(): unknown;
+}

package/dist/esm/rendering/react/components/Table/model/Cell.js

@@ -0,0 +1,24 @@
+import { ColumnName } from "./ColumnName.js";
+export class Cell {
+    name;
+    data;
+    row;
+    constructor(row, name, data) {
+        this.row = row;
+        this.name = new ColumnName(name);
+        this.data = data;
+    }
+    static fromObject(row, object) {
+        return new Cell(row, object.name, object.data);
+    }
+    static empty(row, name) {
+        return new Cell(row, name, undefined);
+    }
+    get column() {
+        return this.row.table.getColumn(this.name);
+    }
+    getData() {
+        const renderer = this.column.options.cellRenderer;
+        return renderer ? renderer(this.row.data) : this.data;
+    }
+}

package/dist/esm/rendering/react/components/Table/model/Column.d.ts

@@ -0,0 +1,16 @@
+import { ObservableValue } from "../../../lib/observable-value/ObservableValue.js";
+import { Table } from "./Table.js";
+import { Dimension } from "../../../measure/context.js";
+import { ColumnOptions, ColumnOptionsInput } from "./ColumnOptions.js";
+import { ColumnName } from "./ColumnName.js";
+export declare class Column {
+    readonly table: Table;
+    readonly name: ColumnName;
+    readonly options: ColumnOptions;
+    readonly maxCellWidth: ObservableValue<number>;
+    private readonly proportionalWidth;
+    constructor(table: Table, name: string, optionsInput?: ColumnOptionsInput<any>);
+    private updateProportionalWidth;
+    onCellMeasured(dimension: Dimension): void;
+    useWidth(): string | number;
+}

package/dist/esm/rendering/react/components/Table/model/Column.js

@@ -0,0 +1,38 @@
+import { stdout } from "@oclif/core";
+import { ObservableValue } from "../../../lib/observable-value/ObservableValue.js";
+import { ColumnOptions } from "./ColumnOptions.js";
+import { ColumnName } from "./ColumnName.js";
+import { useWatchObservableValue } from "../../../lib/observable-value/useWatchObservableValue.js";
+import { getTerminalWidth } from "../../../../lib/getTerminalWidth.js";
+export class Column {
+    table;
+    name;
+    options;
+    maxCellWidth = new ObservableValue(0);
+    proportionalWidth = new ObservableValue("0%");
+    constructor(table, name, optionsInput) {
+        this.table = table;
+        this.name = new ColumnName(name);
+        this.table.overallWidth.observe((width) => this.updateProportionalWidth(width));
+        this.options = new ColumnOptions(this, optionsInput);
+    }
+    updateProportionalWidth(overallWidth) {
+        const thisWidth = this.maxCellWidth.value;
+        const quotient = thisWidth / overallWidth;
+        const percentage = Math.round(quotient * 100);
+        this.proportionalWidth.updateValue(`${percentage}%`);
+    }
+    onCellMeasured(dimension) {
+        const termWidth = getTerminalWidth();
+        const boundary = termWidth
+            ? Math.round(termWidth / 2)
+            : Number.MAX_SAFE_INTEGER;
+        const boundedWidth = Math.min(dimension.width, boundary);
+        if (this.maxCellWidth.value < boundedWidth) {
+            this.maxCellWidth.updateValue(boundedWidth);
+        }
+    }
+    useWidth() {
+        return useWatchObservableValue(stdout.isTTY ? this.proportionalWidth : this.maxCellWidth);
+    }
+}

package/dist/esm/rendering/react/components/Table/model/ColumnName.d.ts

@@ -0,0 +1,7 @@
+export declare class ColumnName {
+    readonly value: string;
+    constructor(value: string);
+    matches(name: string | ColumnName): boolean;
+    get humanizedName(): string;
+    static getNameValue(name: string | ColumnName): string;
+}

package/dist/esm/rendering/react/components/Table/model/ColumnName.js

@@ -0,0 +1,17 @@
+import humanizeString from "humanize-string";
+export class ColumnName {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    matches(name) {
+        return (this.value.toLowerCase().trim() ===
+            ColumnName.getNameValue(name).toLowerCase().trim());
+    }
+    get humanizedName() {
+        return humanizeString(this.value);
+    }
+    static getNameValue(name) {
+        return name instanceof ColumnName ? name.value : name;
+    }
+}

package/dist/esm/rendering/react/components/Table/model/ColumnOptions.d.ts

@@ -0,0 +1,25 @@
+import { Column } from "./Column.js";
+import { ReactNode } from "react";
+type CellRenderer<TData = unknown> = (data: TData) => ReactNode;
+export interface ColumnOptionsInput<TData = unknown> {
+    isVisible?: boolean;
+    isUuid?: boolean;
+    minWidth?: number;
+    header?: ReactNode;
+    extended?: boolean;
+    render?: CellRenderer<TData>;
+}
+export declare class ColumnOptions {
+    private static absoluteMinWidth;
+    readonly column: Column;
+    readonly input?: ColumnOptionsInput;
+    readonly minWidth: number;
+    readonly header?: ReactNode;
+    readonly isVisible: boolean;
+    readonly isExtended: boolean;
+    readonly cellRenderer?: CellRenderer;
+    constructor(column: Column, input?: ColumnOptionsInput);
+    private calculateMinWidth;
+    private getIsVisible;
+}
+export {};

package/dist/esm/rendering/react/components/Table/model/ColumnOptions.js

@@ -0,0 +1,41 @@
+import { getTerminalWidth } from "../../../../lib/getTerminalWidth.js";
+export class ColumnOptions {
+    static absoluteMinWidth = 5;
+    column;
+    input;
+    minWidth;
+    header;
+    isVisible;
+    isExtended;
+    cellRenderer;
+    constructor(column, input) {
+        this.column = column;
+        this.input = input;
+        this.minWidth = this.calculateMinWidth();
+        this.header = input?.header;
+        this.isExtended = input?.extended ?? false;
+        this.isVisible = this.getIsVisible();
+        this.cellRenderer = input?.render;
+    }
+    calculateMinWidth() {
+        if (this.input?.minWidth) {
+            return this.input.minWidth;
+        }
+        if (this.input?.isUuid) {
+            return 36;
+        }
+        const termWidth = getTerminalWidth();
+        const relativeMinWidth = termWidth ? Math.round(termWidth / 20) : 0;
+        return Math.max(ColumnOptions.absoluteMinWidth, relativeMinWidth);
+    }
+    getIsVisible() {
+        if (this.input === undefined) {
+            return false;
+        }
+        const { extended: extendTableOption, visibleColumns } = this.column.table.tableOptions ?? {};
+        const fulfillsExtended = !this.isExtended || extendTableOption === true;
+        const isHidden = !!visibleColumns &&
+            !visibleColumns.some((name) => this.column.name.matches(name));
+        return !isHidden && fulfillsExtended;
+    }
+}