@pablozaiden/terminatui 0.5.3 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pablozaiden/terminatui",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Terminal UI and Command Line Application Framework",
   "repository": {
     "url": "https://github.com/PabloZaiden/terminatui"

package/src/tui/adapters/ink/SemanticInkRenderer.tsx

@@ -107,6 +107,9 @@ export class SemanticInkRenderer {
                 />
                 <Box flexDirection="column" paddingTop={1}>
                     <Label color="mutedText">CLI: {props.cliCommand}</Label>
+                    {props.validationError ? (
+                        <Label color="error" bold>{props.validationError}</Label>
+                    ) : null}
                 </Box>
             </Box>
         );

package/src/tui/adapters/opentui/SemanticOpenTuiRenderer.tsx

@@ -98,7 +98,14 @@ export class SemanticOpenTuiRenderer {
                     }
                 />
                 <box flexDirection="column" paddingTop={1}>
-                    <Label color="mutedText">CLI: {props.cliCommand}</Label>
+                    <box>
+                        <Label color="mutedText">CLI: {props.cliCommand}</Label>
+                    </box>
+                    {props.validationError ? (
+                        <box>
+                            <Label color="error" bold>{props.validationError}</Label>
+                        </box>
+                    ) : null}
                 </box>
             </box>
         );

package/src/tui/controllers/ConfigController.tsx

@@ -6,6 +6,7 @@ import { RenderConfigScreen } from "../semantic/render.tsx";
 
 import { buildCliCommand } from "../utils/buildCliCommand.ts";
 import { loadPersistedParameters, savePersistedParameters } from "../utils/parameterPersistence.ts";
+import { validateTuiOptions } from "../utils/validateTuiOptions.ts";
 
 import type { OptionDef, OptionSchema } from "../../types/command.ts";
 import type {
@@ -112,6 +113,7 @@ export class ConfigController {
                     values={params.values}
                     cliCommand={cliCommand}
                     selectedFieldIndex={clampedIndex}
+                    validationError={params.validationError}
                     onSelectionChange={(index) => {
                         const maxIndex = params.fieldConfigs.length;
                         const nextIndex = Math.max(0, Math.min(index, maxIndex));
@@ -152,6 +154,30 @@ export class ConfigController {
                         });
                     }}
                     onRun={() => {
+                        const schema = params.command.options as OptionSchema;
+                        const errors = validateTuiOptions(schema, params.values);
+
+                        if (errors.length > 0) {
+                            // Show validation error and stay on config screen
+                            const firstError = errors[0];
+                            this.navigation.replace("config" satisfies TuiRoute, {
+                                ...params,
+                                validationError: firstError?.message ?? "Validation error",
+                            });
+
+                            // Clear error after 3 seconds
+                            setTimeout(() => {
+                                const currentParams = this.navigation.current.params as ConfigRouteParams | undefined;
+                                if (currentParams?.validationError) {
+                                    this.navigation.replace("config" satisfies TuiRoute, {
+                                        ...currentParams,
+                                        validationError: null,
+                                    });
+                                }
+                            }, 3000);
+                            return;
+                        }
+
                         void this.run(params);
                     }}
                 />

package/src/tui/driver/types.ts

@@ -25,6 +25,7 @@ export type ConfigRouteParams = {
     values: Record<string, unknown>;
     fieldConfigs: ReturnType<typeof schemaToFieldConfigs>;
     selectedFieldIndex?: number;
+    validationError?: string | null;
 };
 
 export type CommandBrowserRouteParams = {

package/src/tui/semantic/ConfigScreen.tsx

@@ -15,6 +15,9 @@ export interface ConfigScreenProps {
 
     onEditField: (fieldId: string) => void;
     onRun: () => void;
+
+    /** Validation error message to display */
+    validationError?: string | null;
 }
 
 export function ConfigScreen(_props: ConfigScreenProps) {

package/src/tui/semantic/types.ts

@@ -125,4 +125,5 @@ export interface FieldConfig {
     label: string;
     type: FieldType;
     options?: FieldOption[];
+    required?: boolean;
 }

package/src/tui/utils/schemaToFields.ts

@@ -75,6 +75,7 @@ export function schemaToFieldConfigs(schema: OptionSchema): FieldConfig[] {
             label: def.label ?? keyToLabel(key),
             type: optionTypeToFieldType(def),
             options: createFieldOptions(def),
+            required: def.required,
         };
 
         fields.push(fieldConfig);

package/src/tui/utils/validateTuiOptions.ts

@@ -0,0 +1,60 @@
+import type { OptionSchema } from "../../types/command.ts";
+import type { ParseError } from "../../cli/parser.ts";
+
+/**
+ * Validate option values for TUI execution.
+ * 
+ * This differs from CLI validation in that:
+ * - Empty strings are treated as missing for required string fields
+ * - Empty arrays are treated as missing for required array fields
+ * 
+ * @param schema - The option schema to validate against
+ * @param values - The current option values
+ * @returns Array of validation errors (empty if valid)
+ */
+export function validateTuiOptions(
+    schema: OptionSchema,
+    values: Record<string, unknown>
+): ParseError[] {
+    const errors: ParseError[] = [];
+
+    for (const [name, def] of Object.entries(schema)) {
+        const value = values[name];
+
+        // For required fields: check undefined AND empty values
+        if (def.required) {
+            const isMissing =
+                value === undefined ||
+                (def.type === "string" && value === "") ||
+                (def.type === "array" && Array.isArray(value) && value.length === 0);
+
+            if (isMissing) {
+                errors.push({
+                    type: "missing_required",
+                    message: `Missing required option: ${name}`,
+                    field: name,
+                });
+            }
+        }
+
+        // Number range validation
+        if (def.type === "number" && typeof value === "number") {
+            if (def.min !== undefined && value < def.min) {
+                errors.push({
+                    type: "validation",
+                    message: `Option "${name}" must be at least ${def.min}`,
+                    field: name,
+                });
+            }
+            if (def.max !== undefined && value > def.max) {
+                errors.push({
+                    type: "validation",
+                    message: `Option "${name}" must be at most ${def.max}`,
+                    field: name,
+                });
+            }
+        }
+    }
+
+    return errors;
+}