@mittwald/cli 1.0.0-alpha.10

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;
+}

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[];
+}

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

@@ -0,0 +1,37 @@
+import { Cell } from "./Cell.js";
+import { ColumnName } from "./ColumnName.js";
+export class Row {
+    table;
+    cells;
+    data;
+    index;
+    constructor(table, index, dataItem) {
+        this.table = table;
+        this.index = index;
+        this.cells = this.buildCells(dataItem);
+        this.data = dataItem;
+    }
+    static fromObject(table, index, dataItem) {
+        return new Row(table, index, dataItem);
+    }
+    buildCells(object) {
+        if (typeof object === "object" && object !== null) {
+            const entries = Object.entries(object);
+            return entries.map(([name, data]) => Cell.fromObject(this, {
+                name,
+                data,
+            }));
+        }
+        return [];
+    }
+    getCell(name) {
+        const cell = this.cells.find((c) => c.name.matches(name));
+        if (!cell) {
+            return Cell.empty(this, ColumnName.getNameValue(name));
+        }
+        return cell;
+    }
+    collectColumnNamesFromCells() {
+        return this.cells.map((cell) => cell.name);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Row } from "./Row.js";
+import { Column } from "./Column.js";
+import { ObservableValue } from "../../../lib/observable-value/ObservableValue.js";
+import { ColumnOptionsInput } from "./ColumnOptions.js";
+import { TableRenderSetupOutput } from "../../../../setup/TableRenderSetup.js";
+import { ColumnName } from "./ColumnName.js";
+export type TableOptions = TableRenderSetupOutput;
+export type TableColumnsInput<TData = unknown> = Record<string, ColumnOptionsInput<TData>>;
+export declare class Table<T = unknown> {
+    readonly rows: Row<T>[];
+    readonly columns: Column[];
+    readonly overallWidth: ObservableValue<number>;
+    readonly tableOptions?: TableOptions;
+    constructor(data: T[], tableOptions?: TableOptions, columnOptionsInput?: TableColumnsInput<T>);
+    private buildRows;
+    private handleColumnWidthChanged;
+    private buildColumns;
+    getColumn(name: ColumnName | string): Column;
+}

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

@@ -0,0 +1,48 @@
+import { Row } from "./Row.js";
+import { Column } from "./Column.js";
+import { ObservableValue } from "../../../lib/observable-value/ObservableValue.js";
+export class Table {
+    rows;
+    columns;
+    overallWidth = new ObservableValue(0);
+    tableOptions;
+    constructor(data, tableOptions, columnOptionsInput) {
+        this.tableOptions = Object.freeze(tableOptions);
+        this.rows = this.buildRows(data);
+        this.columns = this.buildColumns(this.rows, columnOptionsInput);
+    }
+    buildRows(data) {
+        return data.map((item, index) => Row.fromObject(this, index, item));
+    }
+    handleColumnWidthChanged() {
+        const overallWidth = this.columns.reduce((width, col) => width + col.maxCellWidth.value, 0);
+        this.overallWidth.updateValue(overallWidth);
+    }
+    buildColumns(rows, columnOptions) {
+        const columnsMap = new Map();
+        const addColumn = (columnName) => {
+            const options = columnOptions ? columnOptions[columnName] : {};
+            const column = new Column(this, columnName, options);
+            columnsMap.set(columnName, column);
+            column.maxCellWidth.observe(() => this.handleColumnWidthChanged());
+        };
+        for (const row of rows) {
+            const columns = columnOptions
+                ? Object.entries(columnOptions).map(([name]) => name)
+                : row.collectColumnNamesFromCells().map((n) => n.value);
+            for (const column of columns) {
+                if (!columnsMap.has(column)) {
+                    addColumn(column);
+                }
+            }
+        }
+        return Array.from(columnsMap.values());
+    }
+    getColumn(name) {
+        const col = this.columns.find((col) => col.name.matches(name));
+        if (!col) {
+            throw new Error(`Could not get column with ID ${name}`);
+        }
+        return col;
+    }
+}

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

@@ -0,0 +1,5 @@
+export * from "./Cell.js";
+export * from "./Column.js";
+export * from "./Table.js";
+export * from "./Row.js";
+export { ColumnName } from "./ColumnName.js";

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

@@ -0,0 +1,5 @@
+export * from "./Cell.js";
+export * from "./Column.js";
+export * from "./Table.js";
+export * from "./Row.js";
+export { ColumnName } from "./ColumnName.js";

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

@@ -0,0 +1,5 @@
+import React, { PropsWithChildren } from "react";
+export type ValueProps = PropsWithChildren<{
+    notSet?: boolean;
+}>;
+export declare const Value: React.FC<ValueProps>;

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

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export const Value = ({ children, notSet }) => {
+    if (notSet) {
+        return _jsx(Text, { color: "gray", children: "not set" });
+    }
+    return _jsx(Text, { color: "blue", children: children });
+};

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

@@ -0,0 +1,2 @@
+import { FC, PropsWithChildren } from "react";
+export declare const WithoutLineBreaks: FC<PropsWithChildren>;

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

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text, Transform } from "ink";
+import { removeLineBreaks } from "../../../lib/viewhelpers/removeLineBreaks.js";
+export const WithoutLineBreaks = (props) => {
+    const { children } = props;
+    return (_jsx(Transform, { transform: removeLineBreaks, children: _jsx(Text, { children: children }) }));
+};

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export interface RenderContext {
+    apiClient: MittwaldAPIV2Client;
+    renderAsJson: boolean;
+}
+export declare const renderContext: import("react").Context<RenderContext>;
+export declare const RenderContextProvider: import("react").Provider<RenderContext>;
+export declare const useRenderContext: () => RenderContext;