@sundaeswap/sprinkles 0.5.0 → 0.6.0

package/src/Sprinkle/index.ts

@@ -8,12 +8,16 @@ import {
 import { CborSet, VkeyWitness, TxCBOR } from "@blaze-cardano/core";
 import {
   selectCancellable,
+  selectWithClear,
   inputCancellable,
+  inputWithClear,
   passwordCancellable,
+  passwordWithClear,
   confirmCancellable,
   searchCancellable,
   select,
 } from "./prompts.js";
+import colors from "yoctocolors-cjs";
 import { type TSchema, Type, OptionalKind } from "@sinclair/typebox";
 import * as fs from "fs";
 import * as path from "path";
@@ -29,6 +33,11 @@ export type {
   IProfileEntry,
   TxDialogResult,
   TxDialogOptions,
+  FieldState,
+  RequiredFieldCount,
+  FieldMenuResult,
+  ObjectMenuResult,
+  ArrayMenuResult,
 } from "./types.js";
 export { UserCancelledError } from "./types.js";
 import type {
@@ -67,6 +76,11 @@ import {
   isTuple,
   isUnion,
   isSensitive,
+  isNull,
+  isNullable,
+  unwrapNullable,
+  hasDefault,
+  getDefault,
 } from "./type-guards.js";
 export {
   isOptional,
@@ -81,6 +95,11 @@ export {
   isTuple,
   isUnion,
   isSensitive,
+  isNull,
+  isNullable,
+  unwrapNullable,
+  hasDefault,
+  getDefault,
 } from "./type-guards.js";
 
 // Import schemas for use in this file
@@ -122,6 +141,10 @@ import {
   mergeSignatures,
 } from "./tx-dialog.js";
 
+// Import menu modules
+import { promptObject, promptArray } from "./menus/index.js";
+import { formatPath } from "./utils/formatting.js";
+
 export interface IMenuAction<S extends TSchema> {
   title: string;
   action: (sprinkle: Sprinkle<S>) => Promise<Sprinkle<S> | void>;
@@ -503,10 +526,15 @@ export class Sprinkle<S extends TSchema> {
   // --- Menu ---
 
   async showMenu(menu: IMenu<S>): Promise<void> {
-    return this._showMenu(menu, true);
+    return this._showMenu(menu, true, [menu.title]);
   }
 
-  private async _showMenu(menu: IMenu<S>, main: boolean): Promise<void> {
+  private async _showMenu(menu: IMenu<S>, main: boolean, path: string[], clearPrevious = false): Promise<void> {
+    // Clear previous breadcrumb if coming back from action/submenu
+    if (clearPrevious) {
+      process.stdout.write("\x1b[1A\x1b[2K\x1b[G");
+    }
+
     if (menu.beforeShow) {
       await menu.beforeShow(this);
     }
@@ -523,11 +551,17 @@ export class Sprinkle<S extends TSchema> {
       choices.push({ name: "Settings & Profiles", value: -5 });
       choices.push({ name: "Exit", value: -1 });
     }
-    const selectionResult = await selectCancellable({
+
+    // Show breadcrumb
+    const breadcrumb = path.join(" > ");
+    console.log(colors.dim("🍞 " + breadcrumb));
+
+    const selectionResult = await selectWithClear({
       message: "Select an option:",
       choices: choices,
     });
     // Handle escape (null) as Back
+    // Don't clear here - let the caller's clearPrevious handle it
     if (selectionResult === null) {
       return;
     }
@@ -539,9 +573,18 @@ export class Sprinkle<S extends TSchema> {
           {
             title: "View settings",
             action: async () => {
-              console.log(
-                JSON.stringify(this.getDisplaySettings(), bigIntReplacer, 2),
-              );
+              const jsonStr = JSON.stringify(this.getDisplaySettings(), bigIntReplacer, 2);
+              const jsonLines = jsonStr.split("\n").length;
+              console.log(jsonStr);
+
+              // Wait for user to press Enter
+              await selectWithClear({
+                message: "Press Enter to continue...",
+                choices: [{ name: "Continue", value: "continue" }],
+              });
+
+              // Clear the JSON output
+              process.stdout.write("\x1b[1A\x1b[2K".repeat(jsonLines) + "\x1b[G");
             },
           },
           {
@@ -591,24 +634,29 @@ export class Sprinkle<S extends TSchema> {
           },
         ],
       };
-      await this._showMenu(settingsMenu, false);
-      await this._showMenu(menu, main);
+      await this._showMenu(settingsMenu, false, [...path, "Settings & Profiles"], true);
+      await this._showMenu(menu, main, path, true);
       return;
     }
     if (selection === -1) {
+      // Don't clear here - let the caller's clearPrevious handle it
       return;
     }
     const selectedItem = menu.items[selection]!;
     if ("action" in selectedItem) {
+      // Update breadcrumb to show current action
+      process.stdout.write("\x1b[1A\x1b[2K\x1b[G");
+      console.log(colors.dim("🍞 " + [...path, selectedItem.title].join(" > ")));
+
       const result = await selectedItem.action(this);
       if (result instanceof Sprinkle) {
         this.settings = result.settings;
         this.saveSettings();
       }
-      await this._showMenu(menu, main);
+      await this._showMenu(menu, main, path, true);
     } else {
-      await this._showMenu(selectedItem, false);
-      await this._showMenu(menu, main);
+      await this._showMenu(selectedItem, false, [...path, selectedItem.title], true);
+      await this._showMenu(menu, main, path, true);
     }
     return;
   }
@@ -789,7 +837,7 @@ export class Sprinkle<S extends TSchema> {
       choices.push({ name: "Submit transaction", value: "submit" });
       choices.push({ name: "Cancel", value: "cancel" });
 
-      const selection = await selectCancellable({
+      const selection = await selectWithClear({
         message: "Select an option:",
         choices,
       });
@@ -1002,68 +1050,20 @@ export class Sprinkle<S extends TSchema> {
     }
   }
 
+  /**
+   * Edit an existing struct value using a menu-based interface.
+   * This is now unified with FillInStruct - both use the same menu system.
+   * @param type - The TypeBox schema
+   * @param current - The current value to edit
+   * @returns The edited value
+   */
   async EditStruct<U extends TSchema>(
     type: U,
     current: TExact<U>,
   ): Promise<TExact<U>> {
-    return this._editStruct<U>(type, ["root"], current);
-  }
-
-  async _editStruct<U extends TSchema>(
-    type: U,
-    path: string[],
-    current?: TExact<U>,
-  ): Promise<TExact<U>> {
-    if (isObject(type)) {
-      const obj = {} as Record<string, unknown>;
-      const fields = type["properties"] as Record<string, U>;
-      const menuItems: TMenuItem<S>[] = [];
-      const currentRecord = current as Record<string, unknown>;
-      for (const [field, fieldType] of Object.entries(fields)) {
-        if (current && field in currentRecord) {
-          obj[field] = currentRecord[field] as TExact<U>;
-        }
-        const menuTitle = Sprinkle.ExtractMessage(
-          fieldType,
-          `Edit ${field} at ${path.join(".")}`,
-        );
-        if (
-          isOptional(fieldType) &&
-          current &&
-          currentRecord[field] !== undefined
-        ) {
-          menuItems.push({
-            title: `Clear ${field}`,
-            action: async (sprinkle: Sprinkle<S>) => {
-              obj[field] = undefined;
-              return sprinkle;
-            },
-          });
-        }
-        menuItems.push({
-          title: menuTitle,
-          action: async (sprinkle: Sprinkle<S>) => {
-            const fieldValue = await sprinkle._editStruct(
-              fieldType,
-              path.concat([field]),
-              current && field in currentRecord
-                ? (currentRecord[field] as TExact<U>)
-                : undefined,
-            );
-            obj[field] = fieldValue;
-            return sprinkle;
-          },
-        });
-      }
-      const editMenu: IMenu<S> = {
-        title: "Test",
-        items: menuItems,
-      };
-      await this._showMenu(editMenu, false);
-      return obj as TExact<U>;
-    }
-
-    return this._fillInStruct<U>(type, path, {}, current);
+    // Use FillInStruct with current values as defaults
+    // The menu system will show existing values and allow editing
+    return this.FillInStruct(type, current);
   }
 
   async FillInStruct<U extends TSchema>(
@@ -1092,10 +1092,11 @@ export class Sprinkle<S extends TSchema> {
       >;
     }
     if (isOptional(type)) {
-      const shouldSet = await selectCancellable({
+      const pathDisplay = formatPath(path) || "value";
+      const shouldSet = await selectWithClear({
         message: Sprinkle.ExtractMessage(
           type,
-          `Set value for ${path.join(".")}?`,
+          `Set value for ${pathDisplay}?`,
         ),
         choices: [
           { name: "Yes", value: true },
@@ -1116,6 +1117,7 @@ export class Sprinkle<S extends TSchema> {
     }
 
     if (isUnion(type)) {
+      const pathDisplay = formatPath(path) || "value";
       const choices = [];
       const resolved = this.resolveType(type, path, defs);
       for (const variant of resolved.anyOf) {
@@ -1124,13 +1126,12 @@ export class Sprinkle<S extends TSchema> {
           value: variant,
         });
       }
-      const selectionResult = await selectCancellable({
+      const selectionResult = await selectWithClear({
         message: Sprinkle.ExtractMessage(
           resolved,
-          `Enter a choice for ${path.join(".")}`,
+          `Enter a choice for ${pathDisplay}`,
         ),
         choices: choices,
-        default: def ? `${def}` : undefined,
       });
       if (selectionResult === null) {
         throw new UserCancelledError();
@@ -1142,7 +1143,7 @@ export class Sprinkle<S extends TSchema> {
     if (isString(type)) {
       // Special handling for hot wallet private key - offer generation option
       if (type.title === "Hot Wallet Private Key") {
-        const choice = await selectCancellable({
+        const choice = await selectWithClear({
           message: "Hot wallet setup:",
           choices: [
             { name: "Enter existing private key", value: "existing" },
@@ -1157,7 +1158,7 @@ export class Sprinkle<S extends TSchema> {
           return Sprinkle.generateWalletFromMnemonic() as Promise<TExact<U>>;
         }
         // Fall through to password prompt for "existing" choice
-        const answer = await passwordCancellable({
+        const answer = await passwordWithClear({
           message: "Enter your private key:",
         });
         if (answer === null) {
@@ -1166,18 +1167,19 @@ export class Sprinkle<S extends TSchema> {
         return answer as TExact<U>;
       }
 
+      const pathDisplay = formatPath(path) || "value";
       const defaultString = (def ? def : this.defaults["string"]) as
         | string
         | undefined;
       const message = Sprinkle.ExtractMessage(
         type,
-        `Enter a string for ${path.join(".")}`,
+        `Enter a string for ${pathDisplay}`,
       );
       let answer: string | null;
       if (isSensitive(type)) {
-        answer = await passwordCancellable({ message });
+        answer = await passwordWithClear({ message });
       } else {
-        answer = await inputCancellable({ message, default: defaultString });
+        answer = await inputWithClear({ message, default: defaultString });
         if (answer !== null) {
           this.defaults["string"] = answer;
         }
@@ -1189,10 +1191,11 @@ export class Sprinkle<S extends TSchema> {
     }
 
     if (isBigInt(type)) {
-      const answer = await inputCancellable({
+      const pathDisplay = formatPath(path) || "value";
+      const answer = await inputWithClear({
         message: Sprinkle.ExtractMessage(
           type,
-          `Enter a bigint for ${path.join(".")}`,
+          `Enter a bigint for ${pathDisplay}`,
         ),
         default: def ? (def as bigint).toString() : undefined,
         validate: (s) => {
@@ -1215,47 +1218,55 @@ export class Sprinkle<S extends TSchema> {
     }
 
     if (isObject(type)) {
-      const obj = {} as Record<string, unknown>;
-      const fields = type["properties"] as Record<string, U>;
-      for (const [field, fieldType] of Object.entries(fields)) {
-        const fieldValue = await this._fillInStruct(
-          fieldType,
-          path.concat([field]),
-          defs,
-          def
-            ? ((def as Record<string, unknown>)[field] as TExact<U>)
-            : undefined,
-        );
-        obj[field] = fieldValue;
+      // Use menu-based editing for objects
+      const defaults = def as Record<string, unknown> | undefined;
+      const sprinkle = this;
+      const result = await promptObject({
+        type,
+        path,
+        defs,
+        defaults,
+        fillField: async <T extends TSchema>(
+          fieldType: T,
+          fieldPath: string[],
+          fieldDefs: Record<string, TSchema>,
+          fieldDef?: unknown,
+        ) => {
+          return sprinkle._fillInStruct(fieldType, fieldPath, fieldDefs, fieldDef as TExact<T>);
+        },
+      });
+
+      if (result.action === "cancel") {
+        throw new UserCancelledError();
       }
-      return obj as TExact<U>;
+
+      return result.value as TExact<U>;
     }
 
-    //TODO: support starting with default values for arrays and allow removal of items
     if (isArray(type)) {
-      const arr: unknown[] = [];
-      const itemType = type.items as U;
-      let addMore = true;
-      while (addMore) {
-        const itemValue = await this._fillInStruct(
-          itemType,
-          path.concat([`[${arr.length}]`]),
-          defs,
-        );
-        arr.push(itemValue);
-        const continueAnswer = await selectCancellable({
-          message: `Add another item to ${path.join(".")}?`,
-          choices: [
-            { name: "Yes", value: true },
-            { name: "No", value: false },
-          ],
-        });
-        if (continueAnswer === null) {
-          throw new UserCancelledError();
-        }
-        addMore = continueAnswer as boolean;
+      // Use menu-based editing for arrays
+      const defaults = def as unknown[] | undefined;
+      const sprinkle = this;
+      const result = await promptArray({
+        type,
+        path,
+        defs,
+        defaults,
+        fillField: async <T extends TSchema>(
+          itemType: T,
+          itemPath: string[],
+          itemDefs: Record<string, TSchema>,
+          itemDef?: unknown,
+        ) => {
+          return sprinkle._fillInStruct(itemType, itemPath, itemDefs, itemDef as TExact<T>);
+        },
+      });
+
+      if (result.action === "back") {
+        throw new UserCancelledError();
       }
-      return arr as TExact<U>;
+
+      return result.value as TExact<U>;
     }
 
     if (isTuple(type)) {
@@ -1274,8 +1285,9 @@ export class Sprinkle<S extends TSchema> {
       return result as TExact<U>;
     }
 
+    const pathDisplay = formatPath(path) || "root";
     throw new Error(
-      `Unable to fill in struct for type at path ${path.join(".")}`,
+      `Unable to fill in struct for type at path ${pathDisplay}`,
     );
   }
 

package/src/Sprinkle/menus/array-menu.ts

@@ -0,0 +1,191 @@
+/**
+ * Array menu module for menu-based struct editing.
+ * Shows array items and allows adding/removing/editing.
+ */
+
+import { Separator } from "@inquirer/core";
+import type { TArray, TSchema } from "@sinclair/typebox";
+import { selectWithClear } from "../prompts.js";
+import type { ArrayMenuResult, FieldState } from "../types.js";
+import { UserCancelledError } from "../types.js";
+import { formatValuePreview, formatBreadcrumb } from "../utils/formatting.js";
+import { promptFieldMenu, displayFullValue } from "./field-menu.js";
+import type { FillFunction } from "./object-menu.js";
+
+/**
+ * Options for the array menu prompt.
+ */
+export interface ArrayMenuOptions {
+  /** The array schema */
+  type: TArray;
+  /** Current path for display */
+  path: string[];
+  /** Type definitions for resolving refs */
+  defs: Record<string, TSchema>;
+  /** Existing array values */
+  defaults?: unknown[];
+  /** Function to fill individual items */
+  fillField: FillFunction;
+}
+
+/**
+ * Show a menu-based editor for an array.
+ * Allows adding, removing, and editing items.
+ *
+ * @param options - Array menu options
+ * @returns The edited array or back result
+ */
+export async function promptArray<T>(
+  options: ArrayMenuOptions,
+): Promise<ArrayMenuResult<T>> {
+  const { type, path, defs, defaults = [], fillField } = options;
+
+  const itemType = type.items as TSchema;
+
+  // Initialize items from defaults
+  const items: T[] = [...(defaults as T[])];
+
+  // Main menu loop
+  while (true) {
+    // Build menu choices
+    const choices: Array<{ name: string; value: string } | Separator> = [];
+
+    // Add existing items
+    for (let i = 0; i < items.length; i++) {
+      const preview = formatValuePreview(items[i], 40);
+      choices.push({ name: `[${i}]: ${preview}`, value: `item:${i}` });
+    }
+
+    // Add separator and actions
+    choices.push(new Separator("\u2500\u2500\u2500 Actions \u2500\u2500\u2500"));
+    choices.push({ name: "Add item", value: "add" });
+
+    if (items.length > 0) {
+      choices.push({ name: "Remove item...", value: "remove" });
+    }
+
+    choices.push({ name: `Done (${items.length} item${items.length === 1 ? "" : "s"})`, value: "done" });
+    choices.push({ name: "Back", value: "back" });
+
+    // Show menu
+    const breadcrumb = formatBreadcrumb(path);
+    const message = breadcrumb
+      ? `Edit ${breadcrumb} [${items.length} items]:`
+      : `Edit array [${items.length} items]:`;
+
+    const selection = await selectWithClear({
+      message,
+      choices,
+    });
+
+    // Handle escape - same as done
+    if (selection === null) {
+      return { action: "done", value: items };
+    }
+
+    // Handle done
+    if (selection === "done") {
+      return { action: "done", value: items };
+    }
+
+    // Handle back
+    if (selection === "back") {
+      return { action: "back" };
+    }
+
+    // Handle add
+    if (selection === "add") {
+      try {
+        const newItem = await fillField(
+          itemType,
+          [...path, `[${items.length}]`],
+          defs,
+          undefined,
+        );
+        items.push(newItem as T);
+      } catch (e) {
+        if (e instanceof UserCancelledError) {
+          // Return to menu without adding
+          continue;
+        }
+        throw e;
+      }
+      continue;
+    }
+
+    // Handle remove
+    if (selection === "remove") {
+      const removeChoices = items.map((item, i) => ({
+        name: `[${i}]: ${formatValuePreview(item, 40)}`,
+        value: i,
+      }));
+      removeChoices.push({ name: "Cancel", value: -1 } as { name: string; value: number });
+
+      const indexToRemove = await selectWithClear({
+        message: "Select item to remove:",
+        choices: removeChoices,
+      });
+
+      if (indexToRemove !== null && indexToRemove !== -1) {
+        items.splice(indexToRemove as number, 1);
+      }
+      continue;
+    }
+
+    // Handle item selection
+    if (typeof selection === "string" && selection.startsWith("item:")) {
+      const index = parseInt(selection.slice(5), 10);
+      const currentValue = items[index];
+
+      // Create a FieldState for the item
+      const itemState: FieldState<T> = { status: "set", value: currentValue as T };
+
+      const menuResult = await promptFieldMenu({
+        fieldName: `[${index}]`,
+        fieldType: itemType,
+        state: itemState,
+      });
+
+      switch (menuResult.action) {
+        case "edit": {
+          try {
+            const newValue = await fillField(
+              itemType,
+              [...path, `[${index}]`],
+              defs,
+              currentValue,
+            );
+            items[index] = newValue as T;
+          } catch (e) {
+            if (e instanceof UserCancelledError) {
+              continue;
+            }
+            throw e;
+          }
+          break;
+        }
+
+        case "view": {
+          await displayFullValue(`[${index}]`, currentValue);
+          break;
+        }
+
+        case "clear": {
+          // Remove the item
+          items.splice(index, 1);
+          break;
+        }
+
+        case "setNull": {
+          items[index] = null as T;
+          break;
+        }
+
+        case "reset":
+        case "back":
+          // Do nothing
+          break;
+      }
+    }
+  }
+}