@mittwald/cli 1.0.0-alpha.7 → 1.0.0-alpha.9

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

@@ -0,0 +1,7 @@
+import { FC } from "react";
+export declare const IDAndShortID: FC<{
+    object: {
+        id: string;
+        shortId: string;
+    };
+}>;

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

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Value } from "./Value.js";
+import { Box, Text } from "ink";
+export const IDAndShortID = ({ object, }) => {
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Value, { children: object.shortId }), _jsx(Text, { children: " / " }), _jsx(Value, { children: object.id })] }));
+};

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

@@ -0,0 +1,7 @@
+import { FC } from "react";
+interface Props {
+    json: unknown;
+    inline?: boolean;
+}
+export declare const JSONView: FC<Props>;
+export {};

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

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export const JSONView = (props) => props.json === undefined ? null : (_jsx(Text, { children: JSON.stringify(props.json, undefined, props.inline ? undefined : 2) }));

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

@@ -0,0 +1,3 @@
+import { PropsWithChildren } from "react";
+export type ListItemProps = PropsWithChildren;
+export declare function ListItem({ children }: ListItemProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function ListItem({ children }) {
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 2, marginRight: 1, children: _jsx(Text, { children: "\u2022" }) }), _jsx(Box, { children: children })] }));
+}

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

@@ -0,0 +1,10 @@
+import { FC, PropsWithChildren } from "react";
+type NoteProps = PropsWithChildren<{
+    title?: string;
+    color?: string;
+    marginY?: number;
+    raw?: boolean;
+}>;
+export declare const noteColor = "#407FF8";
+export declare const Note: FC<NoteProps>;
+export {};

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

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export const noteColor = "#407FF8";
+export const Note = (props) => {
+    const { title = "Note", color = noteColor, marginY = 0, raw = false } = props;
+    const contents = raw ? (props.children) : (_jsx(Text, { wrap: "wrap", color: color, children: props.children }));
+    return (_jsxs(Box, { width: 80, borderStyle: "round", borderColor: color, flexDirection: "column", paddingX: 2, marginY: marginY, children: [_jsx(Text, { bold: true, underline: true, color: color, children: title.toUpperCase() }), contents] }));
+};

package/dist/esm/rendering/react/components/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/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/ProjectReadiness.d.ts

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

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

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+import { Value } from "./Value.js";
+export const ProjectReadiness = (props) => {
+    const { readiness } = props;
+    switch (readiness) {
+        case "ready":
+            return _jsx(Text, { color: "green", children: "ready \uD83D\uDE80" });
+        case "creating":
+            return _jsx(Text, { color: "blue", children: "creating \uD83C\uDFD7" });
+        case "unready":
+            return _jsx(Text, { color: "red", children: "unready \uD83D\uDC80" });
+        default:
+            return _jsx(Value, { notSet: true });
+    }
+};

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

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+interface Props {
+    project: MittwaldAPIV2.Components.Schemas.ProjectProject | MittwaldAPIV2.Paths.V2Projects.Get.Responses.$200.Content.ApplicationJson[number];
+}
+export declare const ProjectStatus: FC<Props>;
+export {};

package/dist/esm/rendering/react/components/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 { ProjectReadiness } from "./ProjectReadiness.js";
+export const ProjectStatus = (props) => {
+    const { project } = props;
+    return (_jsxs(Text, { children: [_jsx(ProjectEnabled, { enabled: project.enabled }), _jsx(Text, { children: " / " }), _jsx(ProjectReadiness, { readiness: project.readiness })] }));
+};

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, display: "relative" });
+    }
+    if (typeof data === "string") {
+        const date = parseDate(data);
+        if (date) {
+            return _jsx(FormattedDate, { display: "relative", 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;
+}

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

@@ -0,0 +1,35 @@
+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 = Math.round(termWidth / 2);
+        const boundedWidth = Math.min(dimension.width, boundary);
+        if (this.maxCellWidth.value < boundedWidth) {
+            this.maxCellWidth.updateValue(boundedWidth);
+        }
+    }
+    useWidth() {
+        return useWatchObservableValue(this.proportionalWidth);
+    }
+}

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 = Math.round(termWidth / 20);
+        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;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Cell } from "./Cell.js";
+import { Table } from "./Table.js";
+import { ColumnName } from "./ColumnName.js";
+export declare class Row<T = unknown> {
+    readonly table: Table<T>;
+    readonly cells: Cell[];
+    readonly data: T;
+    readonly index: number;
+    private constructor();
+    static fromObject<T>(table: Table<T>, index: number, dataItem: T): Row<T>;
+    private buildCells;
+    getCell(name: string | ColumnName): Cell;
+    collectColumnNamesFromCells(): ColumnName[];
+}