@sundaeswap/sprinkles 0.5.0 → 0.6.0

package/dist/esm/Sprinkle/index.js

@@ -3,7 +3,8 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { Core, HotWallet } from "@blaze-cardano/sdk";
 import { CborSet, VkeyWitness, TxCBOR } from "@blaze-cardano/core";
-import { selectCancellable, inputCancellable, passwordCancellable, confirmCancellable, searchCancellable } from "./prompts.js";
+import { selectCancellable, selectWithClear, inputCancellable, inputWithClear, passwordWithClear, confirmCancellable, searchCancellable } from "./prompts.js";
+import colors from "yoctocolors-cjs";
 import { OptionalKind } from "@sinclair/typebox";
 import * as fs from "fs";
 import * as path from "path";
@@ -18,7 +19,7 @@ import { UserCancelledError } from "./types.js";
 export { NetworkSchema, MultisigScriptModule, MultisigScript, ProviderSettingsSchema, WalletSettingsSchema } from "./schemas.js";
 // Import and re-export type guards
 import { isOptional, isImport, isArray, isBigInt, isLiteral, isObject, isRef, isString, isThis, isTuple, isUnion, isSensitive } from "./type-guards.js";
-export { isOptional, isImport, isArray, isBigInt, isLiteral, isObject, isRef, isString, isThis, isTuple, isUnion, isSensitive } from "./type-guards.js";
+export { isOptional, isImport, isArray, isBigInt, isLiteral, isObject, isRef, isString, isThis, isTuple, isUnion, isSensitive, isNull, isNullable, unwrapNullable, hasDefault, getDefault } from "./type-guards.js";
 
 // Import schemas for use in this file
 
@@ -31,6 +32,10 @@ import { bigIntReplacer, bigIntReviver, encryptSensitiveFields, decryptSensitive
 
 // Import tx-dialog utilities
 import { countSignatures, getRequiredSigners, getTxBodyHash, formatHash, mergeSignatures } from "./tx-dialog.js";
+
+// Import menu modules
+import { promptObject, promptArray } from "./menus/index.js";
+import { formatPath } from "./utils/formatting.js";
 export class Sprinkle {
   constructor(type, storagePath, options) {
     _defineProperty(this, "storagePath", void 0);
@@ -353,9 +358,13 @@ export class Sprinkle {
   // --- Menu ---
 
   async showMenu(menu) {
-    return this._showMenu(menu, true);
+    return this._showMenu(menu, true, [menu.title]);
   }
-  async _showMenu(menu, main) {
+  async _showMenu(menu, main, path, clearPrevious = false) {
+    // 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);
     }
@@ -387,11 +396,16 @@ export class Sprinkle {
         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;
     }
@@ -402,7 +416,21 @@ export class Sprinkle {
         items: [{
           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",
@@ -443,24 +471,28 @@ export class Sprinkle {
           }
         }]
       };
-      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;
   }
@@ -615,7 +647,7 @@ export class Sprinkle {
         name: "Cancel",
         value: "cancel"
       });
-      const selection = await selectCancellable({
+      const selection = await selectWithClear({
         message: "Select an option:",
         choices
       });
@@ -813,46 +845,18 @@ export class Sprinkle {
       }
     }
   }
+
+  /**
+   * 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(type, current) {
-    return this._editStruct(type, ["root"], current);
-  }
-  async _editStruct(type, path, current) {
-    if (isObject(type)) {
-      const obj = {};
-      const fields = type["properties"];
-      const menuItems = [];
-      const currentRecord = current;
-      for (const [field, fieldType] of Object.entries(fields)) {
-        if (current && field in currentRecord) {
-          obj[field] = currentRecord[field];
-        }
-        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 => {
-              obj[field] = undefined;
-              return sprinkle;
-            }
-          });
-        }
-        menuItems.push({
-          title: menuTitle,
-          action: async sprinkle => {
-            const fieldValue = await sprinkle._editStruct(fieldType, path.concat([field]), current && field in currentRecord ? currentRecord[field] : undefined);
-            obj[field] = fieldValue;
-            return sprinkle;
-          }
-        });
-      }
-      const editMenu = {
-        title: "Test",
-        items: menuItems
-      };
-      await this._showMenu(editMenu, false);
-      return obj;
-    }
-    return this._fillInStruct(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(type, def) {
     return this._fillInStruct(type, ["root"], {}, def);
@@ -870,8 +874,9 @@ export class Sprinkle {
       return this._fillInStruct(resolvedType, path, defs, def);
     }
     if (isOptional(type)) {
-      const shouldSet = await selectCancellable({
-        message: Sprinkle.ExtractMessage(type, `Set value for ${path.join(".")}?`),
+      const pathDisplay = formatPath(path) || "value";
+      const shouldSet = await selectWithClear({
+        message: Sprinkle.ExtractMessage(type, `Set value for ${pathDisplay}?`),
         choices: [{
           name: "Yes",
           value: true
@@ -895,6 +900,7 @@ export class Sprinkle {
       return this._fillInStruct(innerType, path, defs, def);
     }
     if (isUnion(type)) {
+      const pathDisplay = formatPath(path) || "value";
       const choices = [];
       const resolved = this.resolveType(type, path, defs);
       for (const variant of resolved.anyOf) {
@@ -903,10 +909,9 @@ export class Sprinkle {
           value: variant
         });
       }
-      const selectionResult = await selectCancellable({
-        message: Sprinkle.ExtractMessage(resolved, `Enter a choice for ${path.join(".")}`),
-        choices: choices,
-        default: def ? `${def}` : undefined
+      const selectionResult = await selectWithClear({
+        message: Sprinkle.ExtractMessage(resolved, `Enter a choice for ${pathDisplay}`),
+        choices: choices
       });
       if (selectionResult === null) {
         throw new UserCancelledError();
@@ -917,7 +922,7 @@ export class Sprinkle {
     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",
@@ -934,7 +939,7 @@ export class Sprinkle {
           return Sprinkle.generateWalletFromMnemonic();
         }
         // Fall through to password prompt for "existing" choice
-        const answer = await passwordCancellable({
+        const answer = await passwordWithClear({
           message: "Enter your private key:"
         });
         if (answer === null) {
@@ -942,15 +947,16 @@ export class Sprinkle {
         }
         return answer;
       }
+      const pathDisplay = formatPath(path) || "value";
       const defaultString = def ? def : this.defaults["string"];
-      const message = Sprinkle.ExtractMessage(type, `Enter a string for ${path.join(".")}`);
+      const message = Sprinkle.ExtractMessage(type, `Enter a string for ${pathDisplay}`);
       let answer;
       if (isSensitive(type)) {
-        answer = await passwordCancellable({
+        answer = await passwordWithClear({
           message
         });
       } else {
-        answer = await inputCancellable({
+        answer = await inputWithClear({
           message,
           default: defaultString
         });
@@ -964,8 +970,9 @@ export class Sprinkle {
       return answer;
     }
     if (isBigInt(type)) {
-      const answer = await inputCancellable({
-        message: Sprinkle.ExtractMessage(type, `Enter a bigint for ${path.join(".")}`),
+      const pathDisplay = formatPath(path) || "value";
+      const answer = await inputWithClear({
+        message: Sprinkle.ExtractMessage(type, `Enter a bigint for ${pathDisplay}`),
         default: def ? def.toString() : undefined,
         validate: s => {
           try {
@@ -985,39 +992,40 @@ export class Sprinkle {
       return type.const;
     }
     if (isObject(type)) {
-      const obj = {};
-      const fields = type["properties"];
-      for (const [field, fieldType] of Object.entries(fields)) {
-        const fieldValue = await this._fillInStruct(fieldType, path.concat([field]), defs, def ? def[field] : undefined);
-        obj[field] = fieldValue;
+      // Use menu-based editing for objects
+      const defaults = def;
+      const sprinkle = this;
+      const result = await promptObject({
+        type,
+        path,
+        defs,
+        defaults,
+        fillField: async (fieldType, fieldPath, fieldDefs, fieldDef) => {
+          return sprinkle._fillInStruct(fieldType, fieldPath, fieldDefs, fieldDef);
+        }
+      });
+      if (result.action === "cancel") {
+        throw new UserCancelledError();
       }
-      return obj;
+      return result.value;
     }
-
-    //TODO: support starting with default values for arrays and allow removal of items
     if (isArray(type)) {
-      const arr = [];
-      const itemType = type.items;
-      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();
+      // Use menu-based editing for arrays
+      const defaults = def;
+      const sprinkle = this;
+      const result = await promptArray({
+        type,
+        path,
+        defs,
+        defaults,
+        fillField: async (itemType, itemPath, itemDefs, itemDef) => {
+          return sprinkle._fillInStruct(itemType, itemPath, itemDefs, itemDef);
         }
-        addMore = continueAnswer;
+      });
+      if (result.action === "back") {
+        throw new UserCancelledError();
       }
-      return arr;
+      return result.value;
     }
     if (isTuple(type)) {
       const items = type.items ?? [];
@@ -1029,7 +1037,8 @@ export class Sprinkle {
       }
       return result;
     }
-    throw new Error(`Unable to fill in struct for type at path ${path.join(".")}`);
+    const pathDisplay = formatPath(path) || "root";
+    throw new Error(`Unable to fill in struct for type at path ${pathDisplay}`);
   }
   resolveType(type, path, defs) {
     if (isRef(type) || isThis(type) || isImport(type)) {