@sundaeswap/sprinkles 0.8.1 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/sprinkles",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "A TypeScript library for building interactive CLI menus and TUI applications with TypeBox schema validation",
   "type": "module",
   "main": "./dist/cjs/index.js",

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

@@ -11,6 +11,7 @@ const mockConfirmCancellable = mock();
 const mockSearchCancellable = mock();
 
 mock.module("@inquirer/prompts", () => ({
+  search: mockSearchCancellable,
   select: mockSelect,
   input: mockInput,
   password: mockPassword,
@@ -28,24 +29,36 @@ mock.module("../prompts.js", () => ({
 describe("beforeShow hook (2.2)", () => {
   let sprinkle: Sprinkle<any>;
 
+  const pickExit = async (opts: any) => {
+    const choices = await opts.source(undefined);
+    return choices.find((c: any) => c.name === "Exit").value;
+  };
+
   beforeEach(() => {
     const schema = Type.Object({ name: Type.String() });
     sprinkle = new Sprinkle(schema, "/tmp/test");
     sprinkle.settings = { name: "test" } as any;
+    sprinkle.profileId = "test";
+    sprinkle.profileMeta = {
+      name: "Test",
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+    mockSearchCancellable.mockClear();
     mockSelect.mockClear();
     mockSelectCancellable.mockClear();
   });
 
-  test("calls beforeShow before rendering menu", async () => {
+  test("calls root beforeShow before rendering the search prompt", async () => {
     const callOrder: string[] = [];
 
     const beforeShowFn = mock(async () => {
       callOrder.push("beforeShow");
     });
 
-    mockSelectCancellable.mockImplementation(async () => {
-      callOrder.push("select");
-      return -1; // exit
+    mockSearchCancellable.mockImplementation(async (opts: any) => {
+      callOrder.push("search");
+      return pickExit(opts);
     });
 
     const menu: IMenu<any> = {
@@ -58,13 +71,13 @@ describe("beforeShow hook (2.2)", () => {
 
     expect(beforeShowFn).toHaveBeenCalledTimes(1);
     expect(callOrder[0]).toBe("beforeShow");
-    expect(callOrder[1]).toBe("select");
+    expect(callOrder[1]).toBe("search");
   });
 
   test("passes sprinkle instance to beforeShow", async () => {
     let receivedSprinkle: any;
 
-    mockSelectCancellable.mockResolvedValueOnce(-1);
+    mockSearchCancellable.mockImplementationOnce(pickExit);
 
     const menu: IMenu<any> = {
       title: "Test",
@@ -79,7 +92,7 @@ describe("beforeShow hook (2.2)", () => {
   });
 
   test("menu works without beforeShow", async () => {
-    mockSelectCancellable.mockResolvedValueOnce(-1);
+    mockSearchCancellable.mockImplementationOnce(pickExit);
 
     const menu: IMenu<any> = {
       title: "Test",

package/src/Sprinkle/__tests__/fill-in-struct.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test, mock, beforeEach, spyOn } from "bun:test";
-import { Sprinkle, Type, WalletSettingsSchema } from "../index.js";
+import { Sprinkle, Type, WalletSettingsSchema, MultisigScriptModule } from "../index.js";
+import { MultisigScript } from "../schemas.js";
 import { UserCancelledError } from "../types.js";
 
 // Mock @inquirer/prompts
@@ -587,6 +588,7 @@ describe("FillInStruct", () => {
     );
     expect(mockSelectCancellable.mock.calls[0][0].choices).toEqual([
       { name: "Enter existing private key", value: "existing" },
+      { name: "Import from recovery phrase", value: "mnemonic" },
       { name: "Generate new wallet", value: "generate" },
     ]);
     expect(result).toBe("my-private-key");
@@ -638,4 +640,113 @@ describe("FillInStruct", () => {
       UserCancelledError,
     );
   });
+
+  // --- Type.Module / Type.Import ($ref resolution) ---
+
+  test("resolves MultisigScript TImport $ref (Signature variant)", async () => {
+    const hash = "a".repeat(56);
+
+    // Union variant selection: pick Signature
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const sigVariant = opts.choices.find((c: any) =>
+        c.name === "Signature" || JSON.stringify(c.value).includes("Signature"),
+      );
+      return sigVariant?.value ?? opts.choices[0].value;
+    });
+    // Signature → single-field → key_hash → single-field → string prompt
+    mockInputCancellable.mockResolvedValueOnce(hash);
+    // "Save to addressbook?"
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    const result = await sprinkle.FillInStruct(MultisigScript);
+    expect(result).toEqual({ Signature: { key_hash: hash } });
+  });
+
+  test("resolves MultisigScript $ref inside a wrapping schema", async () => {
+    const schema = Type.Object({
+      script: MultisigScript,
+    });
+    const hash = "b".repeat(56);
+
+    // Object has single required field "script" → skips menu
+    // Union variant selection: pick Signature
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const sigVariant = opts.choices.find((c: any) =>
+        c.name === "Signature" || JSON.stringify(c.value).includes("Signature"),
+      );
+      return sigVariant?.value ?? opts.choices[0].value;
+    });
+    mockInputCancellable.mockResolvedValueOnce(hash);
+    // "Save to addressbook?"
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    const result = await sprinkle.FillInStruct(schema);
+    expect(result).toEqual({ script: { Signature: { key_hash: hash } } });
+  });
+
+  test("resolves MultisigScript default matching when editing existing value", async () => {
+    // When editing an existing MultisigScript value, Value.Check is called
+    // to match the default against the selected variant. Variant schemas
+    // contain $ref which requires a references array to resolve.
+    const hash = "e".repeat(56);
+    const existingValue = {
+      AllOf: {
+        scripts: [{ Signature: { key_hash: hash } }],
+      },
+    };
+
+    // Union variant selection: pick AllOf (matches the existing value)
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const variant = opts.choices.find((c: any) =>
+        c.name === "AllOf" || (c.value?.properties && "AllOf" in c.value.properties),
+      );
+      return variant?.value ?? opts.choices[1].value;
+    });
+    // AllOf → single field → scripts array → items already populated from default
+    // Array menu: Done (keep existing items)
+    mockSelectCancellable.mockResolvedValueOnce("done");
+    // "Save to addressbook?"
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    const result = await sprinkle.FillInStruct(MultisigScript, existingValue as any);
+    expect(result).toEqual(existingValue);
+  });
+
+  test("resolves recursive $ref in nested MultisigScript (AllOf with nested Signature)", async () => {
+    const hash1 = "c".repeat(56);
+
+    // Top-level union: pick AllOf
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const variant = opts.choices.find((c: any) =>
+        c.name === "AllOf" || (c.value?.properties && "AllOf" in c.value.properties),
+      );
+      return variant?.value ?? opts.choices[1].value;
+    });
+    // AllOf → single field → scripts array
+    // Array menu: Add item
+    mockSelectCancellable.mockResolvedValueOnce("add");
+    // Array item is MultisigScript ($ref) → resolves recursively → shows Union
+    // Union: pick Signature
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const sigVariant = opts.choices.find((c: any) =>
+        c.name === "Signature" || (c.value?.properties && "Signature" in c.value.properties),
+      );
+      return sigVariant?.value ?? opts.choices[0].value;
+    });
+    // Fill key_hash
+    mockInputCancellable.mockResolvedValueOnce(hash1);
+    // "Save to addressbook?" for inner MultisigScript
+    mockSelectCancellable.mockResolvedValueOnce(false);
+    // Array menu: Done
+    mockSelectCancellable.mockResolvedValueOnce("done");
+    // "Save to addressbook?" for outer MultisigScript
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    const result = await sprinkle.FillInStruct(MultisigScript);
+    expect(result).toEqual({
+      AllOf: {
+        scripts: [{ Signature: { key_hash: hash1 } }],
+      },
+    });
+  });
 });

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

@@ -2,12 +2,14 @@ import { describe, expect, test, mock, beforeEach, spyOn } from "bun:test";
 import { Sprinkle, Type, type IMenu } from "../index.js";
 import { withProfile } from "./test-helpers.js";
 
+const mockSearch = mock();
 const mockSelect = mock();
 const mockInput = mock();
 const mockSelectCancellable = mock();
 const mockInputCancellable = mock();
 
 mock.module("@inquirer/prompts", () => ({
+  search: mockSearch,
   select: mockSelect,
   input: mockInput,
 }));
@@ -17,104 +19,165 @@ mock.module("../prompts.js", () => ({
   inputCancellable: mockInputCancellable,
   passwordCancellable: mock(),
   confirmCancellable: mock(),
-  searchCancellable: mock(),
+  searchCancellable: mockSearch,
   select: mockSelectCancellable,
 }));
 
-describe("showMenu", () => {
+type SearchSource = (
+  term: string | undefined,
+) => Promise<{ name: string; value: any }[]>;
+
+async function collectChoices(call: any): Promise<{ name: string; value: any }[]> {
+  const source: SearchSource = call[0].source;
+  return source(undefined);
+}
+
+function pickByName(
+  choices: { name: string; value: any }[],
+  name: string,
+): any {
+  const match = choices.find((c) => c.name === name);
+  if (!match) {
+    throw new Error(
+      `No choice named "${name}". Available: ${choices.map((c) => c.name).join(", ")}`,
+    );
+  }
+  return match.value;
+}
+
+describe("showMenu (search-based)", () => {
   let sprinkle: Sprinkle<any>;
 
   beforeEach(() => {
     const schema = Type.Object({ name: Type.String() });
     sprinkle = withProfile(new Sprinkle(schema, "/tmp/test"));
     sprinkle.settings = { name: "test" } as any;
+    mockSearch.mockClear();
     mockSelect.mockClear();
     mockSelectCancellable.mockClear();
     mockInput.mockClear();
   });
 
-  test("exits when Exit is selected on main menu", async () => {
-    mockSelectCancellable.mockResolvedValueOnce(-1);
+  test("exits when the Exit leaf is selected", async () => {
+    mockSearch.mockImplementationOnce(async (opts: any) => {
+      const choices = await opts.source(undefined);
+      return pickByName(choices, "Exit");
+    });
 
     const menu: IMenu<any> = {
       title: "Test Menu",
-      items: [
-        {
-          title: "Action 1",
-          action: async () => {},
-        },
-      ],
+      items: [{ title: "Action 1", action: async () => {} }],
     };
 
     await sprinkle.showMenu(menu);
+    expect(mockSearch).toHaveBeenCalledTimes(1);
   });
 
-  test("executes action and re-shows menu", async () => {
+  test("executes a leaf action then loops back to the search prompt", async () => {
     const actionFn = mock(async () => {});
 
-    mockSelectCancellable.mockResolvedValueOnce(0).mockResolvedValueOnce(-1);
+    mockSearch
+      .mockImplementationOnce(async (opts: any) => {
+        const choices = await opts.source(undefined);
+        return pickByName(choices, "My Action");
+      })
+      .mockImplementationOnce(async (opts: any) => {
+        const choices = await opts.source(undefined);
+        return pickByName(choices, "Exit");
+      });
 
     const menu: IMenu<any> = {
       title: "Test Menu",
-      items: [
-        {
-          title: "My Action",
-          action: actionFn,
-        },
-      ],
+      items: [{ title: "My Action", action: actionFn }],
     };
 
     await sprinkle.showMenu(menu);
     expect(actionFn).toHaveBeenCalledTimes(1);
+    expect(mockSearch).toHaveBeenCalledTimes(2);
   });
 
-  test("main menu includes Settings & Profiles submenu and Exit", async () => {
-    mockSelectCancellable.mockResolvedValueOnce(-1);
+  test("flattens submenus into breadcrumb leaves and surfaces Settings & Profiles + Exit", async () => {
+    mockSearch.mockImplementationOnce(async (opts: any) => {
+      const choices = await opts.source(undefined);
+      return pickByName(choices, "Exit");
+    });
 
     const menu: IMenu<any> = {
-      title: "Test",
-      items: [{ title: "Action", action: async () => {} }],
+      title: "Main",
+      items: [
+        {
+          title: "Strategies",
+          items: [
+            { title: "Create limit order", action: async () => {} },
+            { title: "List strategies", action: async () => {} },
+          ],
+        },
+        { title: "Quit (custom)", action: async () => {} },
+      ],
     };
 
     await sprinkle.showMenu(menu);
 
-    const choices = mockSelectCancellable.mock.calls[0][0].choices;
-    const names = choices.map((c: any) => c.name);
-    expect(names).toContain("Settings & Profiles");
+    const choices = await collectChoices(mockSearch.mock.calls[0]);
+    const names = choices.map((c) => c.name);
+    expect(names).toContain("Strategies › Create limit order");
+    expect(names).toContain("Strategies › List strategies");
+    expect(names).toContain("Quit (custom)");
+    expect(names).toContain("Settings & Profiles › Edit settings");
+    expect(names).toContain("Settings & Profiles › Import profile from file");
     expect(names).toContain("Exit");
-    expect(names).not.toContain("Switch profile");
-    expect(names).not.toContain("Manage profiles");
-    expect(names).not.toContain("Edit settings");
   });
 
-  test("submenu includes Back instead of Exit", async () => {
-    mockSelectCancellable
-      .mockResolvedValueOnce(0)
-      .mockResolvedValueOnce(-1)
-      .mockResolvedValueOnce(-1);
+  test("filters leaves by typed term (case-insensitive, all tokens, leaf-title boost)", async () => {
+    let filtered: { name: string; value: any }[] = [];
+
+    mockSearch.mockImplementationOnce(async (opts: any) => {
+      filtered = await opts.source("strateg");
+      // pick Exit so the loop terminates
+      const exitChoice = (await opts.source(undefined)).find(
+        (c: any) => c.name === "Exit",
+      );
+      return exitChoice.value;
+    });
 
     const menu: IMenu<any> = {
       title: "Main",
       items: [
         {
-          title: "Sub",
-          items: [{ title: "Sub Action", action: async () => {} }],
+          title: "Strategies",
+          items: [
+            { title: "Create limit order", action: async () => {} },
+            { title: "Cancel strategy", action: async () => {} },
+          ],
         },
+        { title: "Send payment", action: async () => {} },
       ],
     };
 
     await sprinkle.showMenu(menu);
 
-    const subChoices = mockSelectCancellable.mock.calls[1][0].choices;
-    const subNames = subChoices.map((c: any) => c.name);
-    expect(subNames).toContain("Back");
-    expect(subNames).not.toContain("Exit");
+    const filteredNames = filtered.map((c) => c.name);
+    // Everything under "Strategies" matches via the breadcrumb token
+    expect(filteredNames).toContain("Strategies › Create limit order");
+    expect(filteredNames).toContain("Strategies › Cancel strategy");
+    // Direct leaf-title hit outranks ancestor-only match
+    expect(filteredNames[0]).toBe("Strategies › Cancel strategy");
+    // Unrelated items are filtered out
+    expect(filteredNames).not.toContain("Send payment");
   });
 
-  test("action returning sprinkle instance saves settings", async () => {
+  test("action returning a Sprinkle persists updated settings", async () => {
     sprinkle.settings = { name: "original" } as any;
 
-    mockSelectCancellable.mockResolvedValueOnce(0).mockResolvedValueOnce(-1);
+    mockSearch
+      .mockImplementationOnce(async (opts: any) => {
+        const choices = await opts.source(undefined);
+        return pickByName(choices, "Update");
+      })
+      .mockImplementationOnce(async (opts: any) => {
+        const choices = await opts.source(undefined);
+        return pickByName(choices, "Exit");
+      });
 
     const menu: IMenu<any> = {
       title: "Test",
@@ -133,85 +196,38 @@ describe("showMenu", () => {
     expect(sprinkle.settings).toEqual({ name: "updated" });
   });
 
-  test("Settings submenu includes View settings option", async () => {
-    // Select "Settings & Profiles" (-5), then "Back" (-1), then "Exit" (-1)
-    mockSelectCancellable
-      .mockResolvedValueOnce(-5)  // Settings & Profiles
-      .mockResolvedValueOnce(-1)  // Back
-      .mockResolvedValueOnce(-1); // Exit
-
-    const menu: IMenu<any> = {
-      title: "Test",
-      items: [{ title: "Action", action: async () => {} }],
-    };
-
-    await sprinkle.showMenu(menu);
-
-    // Second call is the settings submenu
-    const settingsChoices = mockSelectCancellable.mock.calls[1][0].choices;
-    const settingsNames = settingsChoices.map((c: any) => c.name);
-    expect(settingsNames).toContain("View settings");
-  });
-
-  test("View settings displays masked settings", async () => {
-    const consoleSpy = spyOn(console, "log").mockImplementation(() => {});
-
-    // 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("continue") // Press Enter to continue
-      .mockResolvedValueOnce(-1)        // Back
-      .mockResolvedValueOnce(-1);       // Exit
-
-    const menu: IMenu<any> = {
-      title: "Test",
-      items: [{ title: "Action", action: async () => {} }],
-    };
-
-    await sprinkle.showMenu(menu);
-
-    // Should have called console.log with the settings (find the JSON output among breadcrumbs)
-    expect(consoleSpy).toHaveBeenCalled();
-    const jsonOutput = consoleSpy.mock.calls.find((call: any[]) =>
-      call[0] && typeof call[0] === "string" && call[0].includes('"name"')
-    );
-    expect(jsonOutput).toBeDefined();
-
-    consoleSpy.mockRestore();
-  });
-
-  test("Create profile restores state when FillInStruct is cancelled", async () => {
-    // Capture original state
-    const originalProfileId = sprinkle.currentProfile?.id;
-    const originalSettings = { ...sprinkle.settings };
-
-    // Settings menu indices: 0=View, 1=Edit, 2=Switch, 3=Create new profile
-    mockSelectCancellable
-      .mockResolvedValueOnce(-5)  // Settings & Profiles
-      .mockResolvedValueOnce(3);  // Create new profile
-
-    // promptProfileMeta: name then description
-    mockInputCancellable
-      .mockResolvedValueOnce("New Profile")  // Profile name
-      .mockResolvedValueOnce("")             // Profile description
-      .mockResolvedValueOnce(null);          // Cancel during FillInStruct (name field)
-
-    // After cancellation, back out of menus
-    mockSelectCancellable
-      .mockResolvedValueOnce(-1)  // Back from settings
-      .mockResolvedValueOnce(-1); // Exit
+  test("submenu beforeShow fires only when a leaf under it is selected", async () => {
+    const order: string[] = [];
+    const subBeforeShow = mock(async () => {
+      order.push("sub.beforeShow");
+    });
+    const actionFn = mock(async () => {
+      order.push("action");
+    });
+
+    mockSearch
+      .mockImplementationOnce(async (opts: any) => {
+        const choices = await opts.source(undefined);
+        return pickByName(choices, "Strategies › Create");
+      })
+      .mockImplementationOnce(async (opts: any) => {
+        const choices = await opts.source(undefined);
+        return pickByName(choices, "Exit");
+      });
 
     const menu: IMenu<any> = {
-      title: "Test",
-      items: [{ title: "Action", action: async () => {} }],
+      title: "Main",
+      items: [
+        {
+          title: "Strategies",
+          beforeShow: subBeforeShow,
+          items: [{ title: "Create", action: actionFn }],
+        },
+      ],
     };
 
     await sprinkle.showMenu(menu);
-
-    // State should be restored to original
-    expect(sprinkle.currentProfile?.id).toBe(originalProfileId);
-    expect(sprinkle.settings).toEqual(originalSettings);
+    expect(subBeforeShow).toHaveBeenCalledTimes(1);
+    expect(order).toEqual(["sub.beforeShow", "action"]);
   });
 });