@sundaeswap/sprinkles 0.5.0 → 0.6.1

package/dist/cjs/Sprinkle/index.js

@@ -23,6 +23,11 @@ var _exportNames = {
   isTuple: true,
   isUnion: true,
   isSensitive: true,
+  isNull: true,
+  isNullable: true,
+  unwrapNullable: true,
+  hasDefault: true,
+  getDefault: true,
   GetProvider: true,
   GetWallet: true,
   GetBlaze: true
@@ -82,6 +87,18 @@ Object.defineProperty(exports, "WalletSettingsSchema", {
     return _schemas.WalletSettingsSchema;
   }
 });
+Object.defineProperty(exports, "getDefault", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.getDefault;
+  }
+});
+Object.defineProperty(exports, "hasDefault", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.hasDefault;
+  }
+});
 Object.defineProperty(exports, "isArray", {
   enumerable: true,
   get: function () {
@@ -106,6 +123,18 @@ Object.defineProperty(exports, "isLiteral", {
     return _typeGuards.isLiteral;
   }
 });
+Object.defineProperty(exports, "isNull", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isNull;
+  }
+});
+Object.defineProperty(exports, "isNullable", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isNullable;
+  }
+});
 Object.defineProperty(exports, "isObject", {
   enumerable: true,
   get: function () {
@@ -154,9 +183,16 @@ Object.defineProperty(exports, "isUnion", {
     return _typeGuards.isUnion;
   }
 });
+Object.defineProperty(exports, "unwrapNullable", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.unwrapNullable;
+  }
+});
 var _sdk = require("@blaze-cardano/sdk");
 var _core = require("@blaze-cardano/core");
 var _prompts = require("./prompts.js");
+var _yoctocolorsCjs = _interopRequireDefault(require("yoctocolors-cjs"));
 var _typebox = require("@sinclair/typebox");
 Object.keys(_typebox).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -169,6 +205,7 @@ Object.keys(_typebox).forEach(function (key) {
     }
   });
 });
+var _value = require("@sinclair/typebox/value");
 var fs = _interopRequireWildcard(require("fs"));
 var path = _interopRequireWildcard(require("path"));
 var _types = require("./types.js");
@@ -177,6 +214,9 @@ var _typeGuards = require("./type-guards.js");
 var _wallet = require("./wallet.js");
 var _encryption = require("./encryption.js");
 var _txDialog = require("./tx-dialog.js");
+var _index = require("./menus/index.js");
+var _formatting = require("./utils/formatting.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
@@ -187,6 +227,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 // Import and re-export wallet utilities
 // Import encryption utilities
 // Import tx-dialog utilities
+// Import menu modules
 class Sprinkle {
   constructor(type, storagePath, options) {
     _defineProperty(this, "storagePath", void 0);
@@ -509,9 +550,13 @@ 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);
     }
@@ -543,11 +588,16 @@ class Sprinkle {
         value: -1
       });
     }
-    const selectionResult = await (0, _prompts.selectCancellable)({
+
+    // Show breadcrumb
+    const breadcrumb = path.join(" > ");
+    console.log(_yoctocolorsCjs.default.dim("🍞 " + breadcrumb));
+    const selectionResult = await (0, _prompts.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;
     }
@@ -558,13 +608,34 @@ class Sprinkle {
         items: [{
           title: "View settings",
           action: async () => {
-            console.log(JSON.stringify(this.getDisplaySettings(), _encryption.bigIntReplacer, 2));
+            const jsonStr = JSON.stringify(this.getDisplaySettings(), _encryption.bigIntReplacer, 2);
+            const jsonLines = jsonStr.split("\n").length;
+            console.log(jsonStr);
+
+            // Wait for user to press Enter
+            await (0, _prompts.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 _types.UserCancelledError) {
+                return; // User cancelled, return to menu
+              }
+              throw e;
+            }
           }
         }, {
           title: "Switch profile",
@@ -599,24 +670,28 @@ 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(_yoctocolorsCjs.default.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;
   }
@@ -771,7 +846,7 @@ class Sprinkle {
         name: "Cancel",
         value: "cancel"
       });
-      const selection = await (0, _prompts.selectCancellable)({
+      const selection = await (0, _prompts.selectWithClear)({
         message: "Select an option:",
         choices
       });
@@ -969,46 +1044,18 @@ 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 ((0, _typeGuards.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 ((0, _typeGuards.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);
@@ -1026,8 +1073,9 @@ class Sprinkle {
       return this._fillInStruct(resolvedType, path, defs, def);
     }
     if ((0, _typeGuards.isOptional)(type)) {
-      const shouldSet = await (0, _prompts.selectCancellable)({
-        message: Sprinkle.ExtractMessage(type, `Set value for ${path.join(".")}?`),
+      const pathDisplay = (0, _formatting.formatPath)(path) || "value";
+      const shouldSet = await (0, _prompts.selectWithClear)({
+        message: Sprinkle.ExtractMessage(type, `Set value for ${pathDisplay}?`),
         choices: [{
           name: "Yes",
           value: true
@@ -1051,6 +1099,7 @@ class Sprinkle {
       return this._fillInStruct(innerType, path, defs, def);
     }
     if ((0, _typeGuards.isUnion)(type)) {
+      const pathDisplay = (0, _formatting.formatPath)(path) || "value";
       const choices = [];
       const resolved = this.resolveType(type, path, defs);
       for (const variant of resolved.anyOf) {
@@ -1059,21 +1108,48 @@ class Sprinkle {
           value: variant
         });
       }
-      const selectionResult = await (0, _prompts.selectCancellable)({
-        message: Sprinkle.ExtractMessage(resolved, `Enter a choice for ${path.join(".")}`),
-        choices: choices,
-        default: def ? `${def}` : undefined
+      const selectionResult = await (0, _prompts.selectWithClear)({
+        message: Sprinkle.ExtractMessage(resolved, `Enter a choice for ${pathDisplay}`),
+        choices: choices
       });
       if (selectionResult === null) {
         throw new _types.UserCancelledError();
       }
       const selection = selectionResult;
-      return this._fillInStruct(selection, path, defs);
+      // 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 = undefined;
+      if (def !== undefined) {
+        if ((0, _typeGuards.isObject)(selection)) {
+          // Check if all literal fields in the selected variant match def
+          const literalFields = Object.entries(selection.properties ?? {}).filter(([, fieldSchema]) => (0, _typeGuards.isLiteral)(fieldSchema));
+          if (literalFields.length > 0) {
+            const defRecord = def;
+            const allLiteralsMatch = literalFields.every(([fieldName, fieldSchema]) => defRecord[fieldName] === fieldSchema.const);
+            if (allLiteralsMatch) {
+              matchedDef = def;
+            }
+          } else {
+            // No literal discriminators - use structural check
+            if (_value.Value.Check(selection, def)) {
+              matchedDef = def;
+            }
+          }
+        } else {
+          // Non-object variant - use structural check
+          if (_value.Value.Check(selection, def)) {
+            matchedDef = def;
+          }
+        }
+      }
+      return this._fillInStruct(selection, path, defs, matchedDef);
     }
     if ((0, _typeGuards.isString)(type)) {
       // Special handling for hot wallet private key - offer generation option
       if (type.title === "Hot Wallet Private Key") {
-        const choice = await (0, _prompts.selectCancellable)({
+        const choice = await (0, _prompts.selectWithClear)({
           message: "Hot wallet setup:",
           choices: [{
             name: "Enter existing private key",
@@ -1090,7 +1166,7 @@ class Sprinkle {
           return Sprinkle.generateWalletFromMnemonic();
         }
         // Fall through to password prompt for "existing" choice
-        const answer = await (0, _prompts.passwordCancellable)({
+        const answer = await (0, _prompts.passwordWithClear)({
           message: "Enter your private key:"
         });
         if (answer === null) {
@@ -1098,15 +1174,16 @@ class Sprinkle {
         }
         return answer;
       }
+      const pathDisplay = (0, _formatting.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 ((0, _typeGuards.isSensitive)(type)) {
-        answer = await (0, _prompts.passwordCancellable)({
+        answer = await (0, _prompts.passwordWithClear)({
           message
         });
       } else {
-        answer = await (0, _prompts.inputCancellable)({
+        answer = await (0, _prompts.inputWithClear)({
           message,
           default: defaultString
         });
@@ -1120,8 +1197,9 @@ class Sprinkle {
       return answer;
     }
     if ((0, _typeGuards.isBigInt)(type)) {
-      const answer = await (0, _prompts.inputCancellable)({
-        message: Sprinkle.ExtractMessage(type, `Enter a bigint for ${path.join(".")}`),
+      const pathDisplay = (0, _formatting.formatPath)(path) || "value";
+      const answer = await (0, _prompts.inputWithClear)({
+        message: Sprinkle.ExtractMessage(type, `Enter a bigint for ${pathDisplay}`),
         default: def ? def.toString() : undefined,
         validate: s => {
           try {
@@ -1141,39 +1219,40 @@ class Sprinkle {
       return type.const;
     }
     if ((0, _typeGuards.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 (0, _index.promptObject)({
+        type,
+        path,
+        defs,
+        defaults,
+        fillField: async (fieldType, fieldPath, fieldDefs, fieldDef) => {
+          return sprinkle._fillInStruct(fieldType, fieldPath, fieldDefs, fieldDef);
+        }
+      });
+      if (result.action === "cancel") {
+        throw new _types.UserCancelledError();
       }
-      return obj;
+      return result.value;
     }
-
-    //TODO: support starting with default values for arrays and allow removal of items
     if ((0, _typeGuards.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 (0, _prompts.selectCancellable)({
-          message: `Add another item to ${path.join(".")}?`,
-          choices: [{
-            name: "Yes",
-            value: true
-          }, {
-            name: "No",
-            value: false
-          }]
-        });
-        if (continueAnswer === null) {
-          throw new _types.UserCancelledError();
+      // Use menu-based editing for arrays
+      const defaults = def;
+      const sprinkle = this;
+      const result = await (0, _index.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 _types.UserCancelledError();
       }
-      return arr;
+      return result.value;
     }
     if ((0, _typeGuards.isTuple)(type)) {
       const items = type.items ?? [];
@@ -1185,7 +1264,8 @@ class Sprinkle {
       }
       return result;
     }
-    throw new Error(`Unable to fill in struct for type at path ${path.join(".")}`);
+    const pathDisplay = (0, _formatting.formatPath)(path) || "root";
+    throw new Error(`Unable to fill in struct for type at path ${pathDisplay}`);
   }
   resolveType(type, path, defs) {
     if ((0, _typeGuards.isRef)(type) || (0, _typeGuards.isThis)(type) || (0, _typeGuards.isImport)(type)) {