@sundaeswap/sprinkles 0.5.0 → 0.6.1

package/src/Sprinkle/__tests__/formatting.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from "bun:test";
+import {
+  formatValuePreview,
+  formatPath,
+  formatBreadcrumb,
+} from "../utils/formatting.js";
+
+describe("formatValuePreview", () => {
+  test("returns [not set] for undefined", () => {
+    expect(formatValuePreview(undefined)).toBe("[not set]");
+  });
+
+  test("returns null for null", () => {
+    expect(formatValuePreview(null)).toBe("null");
+  });
+
+  test("formats short strings with quotes", () => {
+    expect(formatValuePreview("hello")).toBe('"hello"');
+  });
+
+  test("truncates long strings", () => {
+    const longString = "a".repeat(50);
+    const result = formatValuePreview(longString, 40);
+    expect(result.length).toBeLessThanOrEqual(40);
+    expect(result).toContain("...");
+  });
+
+  test("formats numbers", () => {
+    expect(formatValuePreview(42)).toBe("42");
+    expect(formatValuePreview(3.14)).toBe("3.14");
+  });
+
+  test("formats bigints", () => {
+    expect(formatValuePreview(42n)).toBe("42");
+  });
+
+  test("formats booleans", () => {
+    expect(formatValuePreview(true)).toBe("true");
+    expect(formatValuePreview(false)).toBe("false");
+  });
+
+  test("formats arrays with item count", () => {
+    expect(formatValuePreview([])).toBe("[0 items]");
+    expect(formatValuePreview([1])).toBe("[1 item]");
+    expect(formatValuePreview([1, 2, 3])).toBe("[3 items]");
+  });
+
+  test("formats empty objects", () => {
+    expect(formatValuePreview({})).toBe("{}");
+  });
+
+  test("formats single-key objects", () => {
+    const result = formatValuePreview({ Signature: "abc123" });
+    expect(result).toContain("Signature");
+    expect(result).toContain("abc123");
+  });
+
+  test("formats multi-key objects with abbreviation", () => {
+    const result = formatValuePreview({ a: 1, b: 2, c: 3 });
+    expect(result).toContain("a");
+    expect(result).toContain("+2");
+  });
+});
+
+describe("formatPath", () => {
+  test("returns empty string for root-only path", () => {
+    expect(formatPath(["root"])).toBe("");
+  });
+
+  test("strips root prefix", () => {
+    expect(formatPath(["root", "name"])).toBe("name");
+  });
+
+  test("joins multiple segments with dots", () => {
+    expect(formatPath(["root", "settings", "permissions"])).toBe(
+      "settings.permissions",
+    );
+  });
+
+  test("handles paths without root", () => {
+    expect(formatPath(["settings", "name"])).toBe("settings.name");
+  });
+
+  test("handles empty path", () => {
+    expect(formatPath([])).toBe("");
+  });
+});
+
+describe("formatBreadcrumb", () => {
+  test("returns empty string for root-only path", () => {
+    expect(formatBreadcrumb(["root"])).toBe("");
+  });
+
+  test("strips root prefix", () => {
+    expect(formatBreadcrumb(["root", "name"])).toBe("name");
+  });
+
+  test("joins segments with arrow", () => {
+    const result = formatBreadcrumb(["root", "settings", "permissions"]);
+    expect(result).toContain("settings");
+    expect(result).toContain("\u2192"); // Unicode right arrow
+    expect(result).toContain("permissions");
+  });
+
+  test("truncates long paths from left", () => {
+    const path = ["root", "a", "b", "c", "d", "e", "final"];
+    const result = formatBreadcrumb(path, 20);
+    expect(result).toContain("...");
+    expect(result).toContain("final");
+  });
+
+  test("handles empty path", () => {
+    expect(formatBreadcrumb([])).toBe("");
+  });
+});

package/src/Sprinkle/__tests__/show-menu.test.ts

@@ -17,6 +17,8 @@ mock.module("../prompts.js", () => ({
   inputCancellable: mockInputCancellable,
   passwordCancellable: mock(),
   confirmCancellable: mock(),
+  searchCancellable: mock(),
+  select: mockSelectCancellable,
 }));
 
 describe("showMenu", () => {
@@ -154,12 +156,14 @@ describe("showMenu", () => {
   test("View settings displays masked settings", async () => {
     const consoleSpy = spyOn(console, "log").mockImplementation(() => {});
 
-    // Select "Settings & Profiles" (-5), then "View settings" (0), then "Back" (-1), then "Exit" (-1)
+    // Select "Settings & Profiles" (-5), then "View settings" (0),
+    // then "Continue" for the press Enter prompt, then "Back" (-1), then "Exit" (-1)
     mockSelectCancellable
-      .mockResolvedValueOnce(-5)  // Settings & Profiles
-      .mockResolvedValueOnce(0)   // View settings (first item)
-      .mockResolvedValueOnce(-1)  // Back
-      .mockResolvedValueOnce(-1); // Exit
+      .mockResolvedValueOnce(-5)        // Settings & Profiles
+      .mockResolvedValueOnce(0)         // View settings (first item)
+      .mockResolvedValueOnce("continue") // Press Enter to continue
+      .mockResolvedValueOnce(-1)        // Back
+      .mockResolvedValueOnce(-1);       // Exit
 
     const menu: IMenu<any> = {
       title: "Test",
@@ -168,10 +172,12 @@ describe("showMenu", () => {
 
     await sprinkle.showMenu(menu);
 
-    // Should have called console.log with the settings
+    // Should have called console.log with the settings (find the JSON output among breadcrumbs)
     expect(consoleSpy).toHaveBeenCalled();
-    const output = consoleSpy.mock.calls[0][0];
-    expect(output).toContain("name");
+    const jsonOutput = consoleSpy.mock.calls.find((call: any[]) =>
+      call[0] && typeof call[0] === "string" && call[0].includes('"name"')
+    );
+    expect(jsonOutput).toBeDefined();
 
     consoleSpy.mockRestore();
   });

package/src/Sprinkle/__tests__/tx-dialog.test.ts

@@ -48,6 +48,15 @@ mock.module("../prompts.js", () => ({
     const response = confirmResponses.shift();
     return response ?? false;
   }),
+  searchCancellable: mock(async () => "result"),
+  select: mock(async (opts: any) => {
+    selectCalls.push(opts);
+    const response = selectResponses.shift();
+    if (response === undefined) {
+      return "cancel";
+    }
+    return response;
+  }),
 }));
 
 // Mock clipboardy

package/src/Sprinkle/index.ts

@@ -8,13 +8,18 @@ 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 { Value } from "@sinclair/typebox/value";
 import * as fs from "fs";
 import * as path from "path";
 export * from "@sinclair/typebox";
@@ -29,6 +34,11 @@ export type {
   IProfileEntry,
   TxDialogResult,
   TxDialogOptions,
+  FieldState,
+  RequiredFieldCount,
+  FieldMenuResult,
+  ObjectMenuResult,
+  ArrayMenuResult,
 } from "./types.js";
 export { UserCancelledError } from "./types.js";
 import type {
@@ -67,6 +77,11 @@ import {
   isTuple,
   isUnion,
   isSensitive,
+  isNull,
+  isNullable,
+  unwrapNullable,
+  hasDefault,
+  getDefault,
 } from "./type-guards.js";
 export {
   isOptional,
@@ -81,6 +96,11 @@ export {
   isTuple,
   isUnion,
   isSensitive,
+  isNull,
+  isNullable,
+  unwrapNullable,
+  hasDefault,
+  getDefault,
 } from "./type-guards.js";
 
 // Import schemas for use in this file
@@ -122,6 +142,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 +527,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 +552,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,16 +574,32 @@ 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");
             },
           },
           {
             title: "Edit settings",
             action: async () => {
-              this.settings = await this.EditStruct(this.type, this.settings);
-              this.saveSettings();
+              try {
+                this.settings = await this.EditStruct(this.type, this.settings);
+                this.saveSettings();
+              } catch (e) {
+                if (e instanceof UserCancelledError) {
+                  return; // User cancelled, return to menu
+                }
+                throw e;
+              }
             },
           },
           {
@@ -591,24 +642,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 +845,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 +1058,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 +1100,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 +1125,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,25 +1134,57 @@ 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();
       }
       const selection = selectionResult as TSchema;
-      return this._fillInStruct(selection, path, defs) as Promise<TExact<U>>;
+      // Determine if the provided default value matches the selected variant.
+      // For discriminated unions (objects with literal fields like `type`), check
+      // if the literal field values in the selected variant match those in `def`.
+      // For non-discriminated unions, fall back to structural matching with Value.Check.
+      let matchedDef: unknown = undefined;
+      if (def !== undefined) {
+        if (isObject(selection)) {
+          // Check if all literal fields in the selected variant match def
+          const literalFields = Object.entries(selection.properties ?? {}).filter(
+            ([, fieldSchema]) => isLiteral(fieldSchema as TSchema),
+          );
+          if (literalFields.length > 0) {
+            const defRecord = def as Record<string, unknown>;
+            const allLiteralsMatch = literalFields.every(
+              ([fieldName, fieldSchema]) =>
+                defRecord[fieldName] === (fieldSchema as unknown as { const: unknown }).const,
+            );
+            if (allLiteralsMatch) {
+              matchedDef = def;
+            }
+          } else {
+            // No literal discriminators - use structural check
+            if (Value.Check(selection, def)) {
+              matchedDef = def;
+            }
+          }
+        } else {
+          // Non-object variant - use structural check
+          if (Value.Check(selection, def)) {
+            matchedDef = def;
+          }
+        }
+      }
+      return this._fillInStruct(selection, path, defs, matchedDef as TExact<typeof selection>) as Promise<TExact<U>>;
     }
 
     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 +1199,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 +1208,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 +1232,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 +1259,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 +1326,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}`,
     );
   }