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

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

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

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

@@ -1,4 +1,7 @@
 import { createContext, useContext } from "react";
-export const renderContext = createContext({});
+export const renderContext = createContext({
+    renderAsJson: true,
+    apiClient: null,
+});
 export const RenderContextProvider = renderContext.Provider;
 export const useRenderContext = () => useContext(renderContext);

package/dist/esm/rendering/react/json/JsonCollectionProvider.d.ts

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

package/dist/esm/rendering/react/json/JsonCollectionProvider.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef } from "react";
+import { collectedJsonDataContext } from "./context.js";
+import { ObservableValue } from "../lib/observable-value/ObservableValue.js";
+import { JsonRenderer } from "./JsonRenderer.js";
+const ContextProvider = collectedJsonDataContext.Provider;
+export const JsonCollectionProvider = (props) => {
+    const contextValue = useRef(new ObservableValue(undefined)).current;
+    return (_jsx(ContextProvider, { value: contextValue, children: _jsx(JsonRenderer, { children: props.children }) }));
+};

package/dist/esm/rendering/react/json/JsonRenderer.d.ts

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

package/dist/esm/rendering/react/json/JsonRenderer.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "ink";
+import { useCollectedJsonData } from "./context.js";
+import { useWatchObservableValue } from "../lib/observable-value/useWatchObservableValue.js";
+import { JSONView } from "../components/JSONView.js";
+import { unpackJsonData } from "./lib/unpackJsonData.js";
+export const JsonRenderer = (props) => {
+    const { children } = props;
+    const jsonValue = useCollectedJsonData();
+    const json = useWatchObservableValue(jsonValue);
+    const display = json ? "none" : "flex";
+    const unpackedData = unpackJsonData(json);
+    return (_jsxs(Box, { children: [_jsx(Box, { display: display, children: children }), _jsx(JSONView, { json: unpackedData })] }));
+};

package/dist/esm/rendering/react/json/RenderJson.d.ts

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

package/dist/esm/rendering/react/json/RenderJson.js

@@ -0,0 +1,19 @@
+import { useEffect } from "react";
+import { useCollectedJsonData } from "./context.js";
+export const RenderJson = (props) => {
+    const { name, data } = props;
+    const jsonData = useCollectedJsonData();
+    useEffect(() => {
+        jsonData.updateValue({
+            ...jsonData.value,
+            [name]: data,
+        });
+        return () => {
+            jsonData.updateValue({
+                ...jsonData.value,
+                [name]: undefined,
+            });
+        };
+    }, [name, data, jsonData]);
+    return null;
+};

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

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { ObservableValue } from "../lib/observable-value/ObservableValue.js";
+export type CollectedJsonData = Record<string, unknown>;
+export declare const collectedJsonDataContext: import("react").Context<ObservableValue<CollectedJsonData | undefined>>;
+export declare const useCollectedJsonData: () => ObservableValue<CollectedJsonData | undefined>;

package/dist/esm/rendering/react/json/context.js

@@ -0,0 +1,4 @@
+import { createContext, useContext } from "react";
+import { ObservableValue } from "../lib/observable-value/ObservableValue.js";
+export const collectedJsonDataContext = createContext(new ObservableValue(undefined));
+export const useCollectedJsonData = () => useContext(collectedJsonDataContext);

package/dist/esm/rendering/react/json/lib/unpackJsonData.d.ts

@@ -0,0 +1 @@
+export declare const unpackJsonData: (json: unknown) => unknown;

package/dist/esm/rendering/react/json/lib/unpackJsonData.js

@@ -0,0 +1,5 @@
+export const unpackJsonData = (json) => {
+    const entries = json && typeof json === "object" ? Object.entries(json) : undefined;
+    const firstEntry = entries?.[0];
+    return entries?.length === 1 && firstEntry ? firstEntry[1] : json;
+};

package/dist/esm/rendering/react/lib/observable-value/ObservableValue.d.ts

@@ -0,0 +1,10 @@
+import { Observer, UnbindObserver } from "./types.js";
+export declare class ObservableValue<T> {
+    value: T;
+    private observers;
+    constructor(value: T);
+    private notifyObservers;
+    get observerCount(): number;
+    observe(observer: Observer<T>): UnbindObserver;
+    updateValue(newValue: T): void;
+}

package/dist/esm/rendering/react/lib/observable-value/ObservableValue.js

@@ -0,0 +1,25 @@
+export class ObservableValue {
+    value;
+    // using unknown since otherwise the ObservableValue seems to be invariant on type T
+    observers = new Set();
+    constructor(value) {
+        this.value = value;
+    }
+    notifyObservers(newValue) {
+        this.observers.forEach((o) => o(newValue));
+    }
+    get observerCount() {
+        return this.observers.size;
+    }
+    observe(observer) {
+        this.observers.add(observer);
+        return () => this.observers.delete(observer);
+    }
+    updateValue(newValue) {
+        if (this.value === newValue) {
+            return;
+        }
+        this.value = newValue;
+        this.notifyObservers(newValue);
+    }
+}

package/dist/esm/rendering/react/lib/observable-value/types.d.ts

@@ -0,0 +1,2 @@
+export type Observer<T> = (newValue: T) => void;
+export type UnbindObserver = () => void;

package/dist/esm/rendering/react/lib/observable-value/types.js

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

package/dist/esm/rendering/react/lib/observable-value/useWatchObservableValue.d.ts

@@ -0,0 +1,2 @@
+import { ObservableValue } from "./ObservableValue.js";
+export declare const useWatchObservableValue: <T>(observable: ObservableValue<T>) => T;

package/dist/esm/rendering/react/lib/observable-value/useWatchObservableValue.js

@@ -0,0 +1,9 @@
+import { useEffect, useState } from "react";
+export const useWatchObservableValue = (observable) => {
+    const [watchedValue, setWatchedValue] = useState(observable.value);
+    useEffect(() => {
+        setWatchedValue(observable.value);
+        return observable.observe(setWatchedValue);
+    }, [observable]);
+    return watchedValue;
+};

package/dist/esm/rendering/react/measure/MeasureChildren.d.ts

@@ -0,0 +1,8 @@
+import { FC, PropsWithChildren } from "react";
+import { Dimension } from "./context.js";
+export type OnDimensionChangedHandler = (dimension: Dimension) => void;
+interface Props {
+    onDimensionChange?: OnDimensionChangedHandler;
+}
+export declare const MeasureChildren: FC<PropsWithChildren<Props>>;
+export {};

package/dist/esm/rendering/react/measure/MeasureChildren.js

@@ -0,0 +1,19 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useId } from "react";
+import { useMeasureContext } from "./context.js";
+export const MeasureChildren = (props) => {
+    const { children, onDimensionChange } = props;
+    const id = useId();
+    const context = useMeasureContext();
+    useEffect(() => {
+        context.addNode(id, children);
+        return () => {
+            context.removeNode(id);
+        };
+    }, [context, children]);
+    useEffect(() => context.getDimension(id).observe(onDimensionChange ??
+        (() => {
+            // not handling
+        })), [id, context, onDimensionChange]);
+    return _jsx(_Fragment, { children: children });
+};

package/dist/esm/rendering/react/measure/MeasureContextProvider.d.ts

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

package/dist/esm/rendering/react/measure/MeasureContextProvider.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "ink";
+import { useRef } from "react";
+import { createMeasureContext, measureContext } from "./context.js";
+import { MeasureRenderer } from "./MeasureRenderer.js";
+export const MeasureContextProvider = (props) => {
+    const { children } = props;
+    const context = useRef(createMeasureContext()).current;
+    return (_jsx(measureContext.Provider, { value: context, children: _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Box, { children: _jsx(MeasureRenderer, {}) }), _jsx(Box, { children: children })] }) }));
+};

package/dist/esm/rendering/react/measure/MeasureRenderer.d.ts

@@ -0,0 +1,2 @@
+import { FC } from "react";
+export declare const MeasureRenderer: FC;

package/dist/esm/rendering/react/measure/MeasureRenderer.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, measureElement } from "ink";
+import { useEffect, useRef } from "react";
+import { useWatchObservableValue } from "../lib/observable-value/useWatchObservableValue.js";
+import { useMeasureContext } from "./context.js";
+const M = (props) => {
+    const { children, id } = props;
+    const measureContext = useMeasureContext();
+    const ref = useRef(null);
+    useEffect(() => {
+        if (ref.current) {
+            const dimension = measureElement(ref.current);
+            measureContext.updateDimension(id, dimension);
+        }
+    }, [id, measureContext, ref.current]);
+    return (_jsx(Box, { height: 0, overflow: "hidden", flexShrink: 1, ref: ref, children: children }));
+};
+export const MeasureRenderer = () => {
+    const context = useMeasureContext();
+    const watchedNodes = useWatchObservableValue(context.nodes);
+    return (_jsx(Box, { flexDirection: "row", flexWrap: "wrap", children: Object.entries(watchedNodes).map(([id, node]) => (_jsx(M, { id: id, children: node }, id))) }));
+};

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

@@ -0,0 +1,18 @@
+import { measureElement } from "ink";
+import { ReactNode } from "react";
+import { ObservableValue } from "../lib/observable-value/ObservableValue.js";
+export type MeasureContextNodes = Record<string, ReactNode>;
+export type Dimension = ReturnType<typeof measureElement>;
+export type Dimensions = Record<string, ObservableValue<Dimension>>;
+interface Context {
+    nodes: ObservableValue<MeasureContextNodes>;
+    dimensions: Dimensions;
+    addNode: (id: string, node: ReactNode) => void;
+    removeNode: (id: string) => void;
+    getDimension: (id: string) => ObservableValue<Dimension>;
+    updateDimension: (id: string, dimension: Dimension) => void;
+}
+export declare const createMeasureContext: () => Context;
+export declare const measureContext: import("react").Context<Context>;
+export declare const useMeasureContext: () => Context;
+export {};

package/dist/esm/rendering/react/measure/context.js

@@ -0,0 +1,48 @@
+import { createContext, useContext } from "react";
+import { ObservableValue } from "../lib/observable-value/ObservableValue.js";
+export const createMeasureContext = () => {
+    const context = {
+        nodes: new ObservableValue({}),
+        dimensions: {},
+        addNode: (id, node) => {
+            const existing = context.nodes.value[id];
+            if (existing === node) {
+                return;
+            }
+            context.dimensions[id] = new ObservableValue({
+                height: 0,
+                width: 0,
+            });
+            context.nodes.updateValue({
+                ...context.nodes.value,
+                [id]: node,
+            });
+        },
+        removeNode: (id) => {
+            if (id in context.nodes) {
+                const updatedNodes = {
+                    ...context.nodes.value,
+                };
+                delete updatedNodes[id];
+                context.nodes.updateValue(updatedNodes);
+            }
+        },
+        getDimension: (id) => {
+            const dimension = context.dimensions[id];
+            if (!dimension) {
+                throw new Error(`Could not get dimension for ${id}`);
+            }
+            return dimension;
+        },
+        updateDimension: (id, updatedDimension) => {
+            const dimension = context.getDimension(id);
+            if (dimension.value.width !== updatedDimension.width ||
+                dimension.value.height !== updatedDimension.height) {
+                dimension.updateValue(updatedDimension);
+            }
+        },
+    };
+    return context;
+};
+export const measureContext = createContext(createMeasureContext());
+export const useMeasureContext = () => useContext(measureContext);

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

@@ -0,0 +1,42 @@
+import { ReactElement, ReactNode } from "react";
+export type ProcessStepInfo = {
+    type: "info";
+    title: ReactElement;
+};
+export type ProcessStepRunnable = {
+    type: "step";
+    title: ReactElement;
+    phase: "running" | "completed" | "failed" | "aborted";
+    error?: unknown;
+};
+export type ProcessStepConfirm = {
+    type: "confirm";
+    title: ReactElement;
+    confirmed: boolean | undefined;
+};
+export type ProcessStepInput = {
+    type: "input";
+    title: ReactElement;
+    mask?: boolean;
+    value?: string;
+};
+export type ProcessStep = ProcessStepInfo | ProcessStepRunnable | ProcessStepConfirm | ProcessStepInput;
+export declare class RunnableHandler {
+    private readonly listener;
+    private readonly processStep;
+    constructor(state: ProcessStepRunnable, l: () => void);
+    get done(): boolean;
+    abort(): void;
+    complete(): void;
+    error(err: unknown): void;
+}
+export interface ProcessRenderer {
+    start(): void;
+    addStep(title: ReactNode): RunnableHandler;
+    runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
+    addInfo(title: ReactElement): void;
+    addConfirmation(question: ReactElement): Promise<boolean>;
+    addInput(question: ReactElement, mask?: boolean): Promise<string>;
+    complete(summary: ReactElement): void;
+    error(err: unknown): void;
+}

package/dist/esm/rendering/react/process.js

@@ -0,0 +1,24 @@
+export class RunnableHandler {
+    listener;
+    processStep;
+    constructor(state, l) {
+        this.processStep = state;
+        this.listener = l;
+    }
+    get done() {
+        return this.processStep.phase !== "running";
+    }
+    abort() {
+        this.processStep.phase = "aborted";
+        this.listener();
+    }
+    complete() {
+        this.processStep.phase = "completed";
+        this.listener();
+    }
+    error(err) {
+        this.processStep.phase = "failed";
+        this.processStep.error = err;
+        this.listener();
+    }
+}

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

@@ -0,0 +1,28 @@
+import React, { ReactElement, ReactNode } from "react";
+import { ProcessRenderer, ProcessStep, ProcessStepInput, RunnableHandler } from "./process.js";
+export declare class FancyProcessRenderer implements ProcessRenderer {
+    private readonly title;
+    private started;
+    private currentHandler;
+    constructor(title: string);
+    start(): void;
+    addStep(title: ReactNode): RunnableHandler;
+    runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
+    addInfo(title: ReactElement): void;
+    addInput(question: React.ReactElement, mask?: boolean): Promise<string>;
+    addConfirmation(question: ReactElement): Promise<boolean>;
+    complete(summary: ReactElement): void;
+    error(err: unknown): void;
+    private renderStart;
+}
+export declare const ProcessState: React.FC<{
+    step: ProcessStep;
+}>;
+export declare const ProcessConfirmation: React.FC<{
+    step: ProcessStep;
+    onConfirm: (confirmed: boolean) => void;
+}>;
+export declare const ProcessInput: React.FC<{
+    step: ProcessStepInput;
+    onSubmit: (value: string) => void;
+}>;