@sundaeswap/sprinkles 0.6.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/sprinkles",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "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__/fill-in-struct.test.ts

@@ -150,6 +150,150 @@ describe("FillInStruct", () => {
     );
   });
 
+  test("discriminated union propagates default when variant matches", async () => {
+    // When default has type "a" and user selects variant A, the default values
+    // for non-literal fields should be pre-populated (field starts as "set" status).
+    // Submitting without editing should return the default values.
+    const schema = Type.Union([
+      Type.Object({
+        type: Type.Literal("a"),
+        value: Type.String(),
+      }),
+      Type.Object({
+        type: Type.Literal("b"),
+        count: Type.BigInt(),
+      }),
+    ]);
+
+    const defaultValue = { type: "a" as const, value: "existing-value" };
+
+    // Select the first variant (type "a") - matches the default
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      return opts.choices[0].value;
+    });
+    // Both fields are "set" (type auto-filled, value pre-populated from default).
+    // allRequiredFieldsFilled is true so Submit is enabled. Submit immediately.
+    mockSelectCancellable.mockResolvedValueOnce("submit");
+
+    const result = await sprinkle.FillInStruct(schema, defaultValue as any);
+
+    // The default value for the "value" field should be included in the result
+    expect(result).toEqual({ type: "a", value: "existing-value" });
+  });
+
+  test("discriminated union with nested object propagates nested defaults", async () => {
+    // When a discriminated union default has a nested settings object, the nested
+    // fields should also be pre-populated from the default.
+    const schema = Type.Union([
+      Type.Object({
+        type: Type.Literal("config"),
+        settings: Type.Object({
+          timeout: Type.BigInt(),
+          retries: Type.BigInt(),
+        }),
+      }),
+      Type.Object({
+        type: Type.Literal("other"),
+        name: Type.String(),
+      }),
+    ]);
+
+    const defaultValue = {
+      type: "config" as const,
+      settings: { timeout: 30n, retries: 3n },
+    };
+
+    // Select the first variant (type "config") - matches the default
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      return opts.choices[0].value;
+    });
+    // Outer object: "type" is auto-filled literal, "settings" is pre-populated from default.
+    // Both required fields are "set", so Submit is available.
+    mockSelectCancellable.mockResolvedValueOnce("submit");
+
+    const result = await sprinkle.FillInStruct(schema, defaultValue as any);
+
+    // Both the outer and nested default values should be returned
+    expect(result).toEqual({
+      type: "config",
+      settings: { timeout: 30n, retries: 3n },
+    });
+  });
+
+  test("discriminated union does not propagate default when variant does not match", async () => {
+    // When default has type "a" but user selects variant B, no default should be passed.
+    // The variant B field should start as "unset" and require user input.
+    const schema = Type.Union([
+      Type.Object({
+        type: Type.Literal("a"),
+        value: Type.String(),
+      }),
+      Type.Object({
+        type: Type.Literal("b"),
+        name: Type.String(),
+      }),
+    ]);
+
+    // Default has type "a" but user selects variant "b"
+    const defaultValue = { type: "a" as const, value: "should-not-appear" };
+
+    // Select the second variant (type "b") - does NOT match the default
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      return opts.choices[1].value;
+    });
+    // Variant B: "type" is auto-filled, "name" starts as unset (no default propagated).
+    // Select "name" field and fill it in.
+    mockSelectCancellable.mockResolvedValueOnce("field:name");
+    mockInputCancellable.mockResolvedValueOnce("new-name");
+    mockSelectCancellable.mockResolvedValueOnce("submit");
+
+    const result = await sprinkle.FillInStruct(schema, defaultValue as any);
+
+    expect(result).toEqual({ type: "b", name: "new-name" });
+    // The input prompt for "name" should have no default (default from variant A was not passed)
+    expect(mockInputCancellable.mock.calls[0][0].default).toBeUndefined();
+  });
+
+  test("non-discriminated union propagates default when value structurally matches selected variant", async () => {
+    // For a union of simple types, when the default matches the selected variant
+    // structurally (via Value.Check), it should be passed through.
+    const schema = Type.Union([Type.String(), Type.BigInt()]);
+
+    const defaultValue = "default-string";
+
+    // Select the first variant (String)
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      return opts.choices[0].value;
+    });
+    mockInputCancellable.mockResolvedValueOnce("new-value");
+
+    await sprinkle.FillInStruct(schema, defaultValue as any);
+
+    // The input prompt should show the string default
+    expect(mockInputCancellable.mock.calls[0][0].default).toBe("default-string");
+  });
+
+  test("non-discriminated union does not propagate default when value does not match selected variant", async () => {
+    // When a string default is provided but BigInt variant is selected,
+    // the default must not be passed (it would fail structural validation).
+    const schema = Type.Union([Type.String(), Type.BigInt()]);
+
+    // Default is a string but user selects BigInt variant
+    const defaultValue = "not-a-bigint";
+
+    // Select the second variant (BigInt)
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      return opts.choices[1].value;
+    });
+    mockInputCancellable.mockResolvedValueOnce("42");
+
+    const result = await sprinkle.FillInStruct(schema, defaultValue as any);
+
+    expect(result).toBe(42n);
+    // The string default must not be passed to the BigInt prompt
+    expect(mockInputCancellable.mock.calls[0][0].default).toBeUndefined();
+  });
+
   // --- Object types (menu-based) ---
 
   test("fills an object with multiple fields", async () => {

package/src/Sprinkle/index.ts

@@ -19,6 +19,7 @@ import {
 } 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";
@@ -590,8 +591,15 @@ export class Sprinkle<S extends TSchema> {
           {
             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;
+              }
             },
           },
           {
@@ -1137,7 +1145,40 @@ export class Sprinkle<S extends TSchema> {
         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)) {