@sundaeswap/sprinkles 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/sprinkles",
-  "version": "0.5.0",
+  "version": "0.6.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__/encryption.test.ts

@@ -23,6 +23,8 @@ mock.module("../prompts.js", () => ({
   inputCancellable: mockInputCancellable,
   passwordCancellable: mockPasswordCancellable,
   confirmCancellable: mock(),
+  searchCancellable: mock(),
+  select: mockSelectCancellable,
 }));
 
 describe("Encryption & Sensitive Fields", () => {

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

@@ -136,45 +136,6 @@ describe("SearchSelect (2.3)", () => {
   });
 });
 
-describe("Optional type support (2.4)", () => {
-  let sprinkle: Sprinkle<any>;
-
-  beforeEach(() => {
-    const schema = Type.Object({ placeholder: Type.String() });
-    sprinkle = new Sprinkle(schema, "/tmp/test");
-    mockSelect.mockClear();
-    mockInput.mockClear();
-    mockSelectCancellable.mockClear();
-    mockInputCancellable.mockClear();
-  });
-
-  test("skips optional field when user selects Skip", async () => {
-    const schema = Type.Object({
-      name: Type.String(),
-      nickname: Type.Optional(Type.String()),
-    });
-
-    mockInputCancellable.mockResolvedValueOnce("Alice"); // name
-    mockSelectCancellable.mockResolvedValueOnce(false); // skip nickname
-
-    const result = await sprinkle.FillInStruct(schema);
-    expect(result.name).toBe("Alice");
-    expect(result.nickname).toBeUndefined();
-  });
-
-  test("fills optional field when user selects Yes", async () => {
-    const schema = Type.Object({
-      name: Type.String(),
-      nickname: Type.Optional(Type.String()),
-    });
-
-    mockInputCancellable
-      .mockResolvedValueOnce("Alice") // name
-      .mockResolvedValueOnce("Ali"); // nickname
-    mockSelectCancellable.mockResolvedValueOnce(true); // fill nickname
-
-    const result = await sprinkle.FillInStruct(schema);
-    expect(result.name).toBe("Alice");
-    expect(result.nickname).toBe("Ali");
-  });
-});
+// Note: "Optional type support (2.4)" tests removed - they tested the old sequential
+// FillInStruct behavior. The new menu-based FillInStruct handles optional fields
+// differently (via menu selection). See fill-in-struct.test.ts for comprehensive tests.

package/src/Sprinkle/__tests__/field-utils.test.ts

@@ -0,0 +1,191 @@
+import { describe, expect, test } from "bun:test";
+import { Type } from "@sinclair/typebox";
+import {
+  countRequiredFields,
+  isFieldRequired,
+  buildFieldLabel,
+  getInitialFieldState,
+  allRequiredFieldsFilled,
+} from "../utils/field-utils.js";
+import type { FieldState } from "../types.js";
+
+describe("isFieldRequired", () => {
+  test("returns true for plain required field", () => {
+    expect(isFieldRequired(Type.String())).toBe(true);
+  });
+
+  test("returns false for optional field", () => {
+    expect(isFieldRequired(Type.Optional(Type.String()))).toBe(false);
+  });
+
+  test("returns false for field with default", () => {
+    expect(isFieldRequired(Type.String({ default: "hello" }))).toBe(false);
+  });
+
+  test("returns true for nullable field with default", () => {
+    // Nullable fields with defaults are required because the user should
+    // explicitly choose whether to use the value or set null
+    const schema = Type.Union([Type.String({ default: "hello" }), Type.Null()]);
+    expect(isFieldRequired(schema)).toBe(true);
+  });
+});
+
+describe("countRequiredFields", () => {
+  test("counts fields in simple object", () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      age: Type.BigInt(),
+    });
+    const state = new Map<string, FieldState>();
+
+    const result = countRequiredFields(schema, state);
+    expect(result.total).toBe(2);
+    expect(result.filled).toBe(0);
+  });
+
+  test("skips optional fields", () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      nickname: Type.Optional(Type.String()),
+    });
+    const state = new Map<string, FieldState>();
+
+    const result = countRequiredFields(schema, state);
+    expect(result.total).toBe(1);
+  });
+
+  test("skips fields with defaults", () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      timeout: Type.BigInt({ default: 30n }),
+    });
+    const state = new Map<string, FieldState>();
+
+    const result = countRequiredFields(schema, state);
+    expect(result.total).toBe(1);
+  });
+
+  test("counts filled fields", () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      age: Type.BigInt(),
+    });
+    const state = new Map<string, FieldState>([
+      ["name", { status: "set", value: "Alice" }],
+    ]);
+
+    const result = countRequiredFields(schema, state);
+    expect(result.total).toBe(2);
+    expect(result.filled).toBe(1);
+  });
+
+  test("counts null as filled for nullable fields", () => {
+    const schema = Type.Object({
+      name: Type.Union([Type.String(), Type.Null()]),
+    });
+    const state = new Map<string, FieldState>([["name", { status: "null" }]]);
+
+    const result = countRequiredFields(schema, state);
+    expect(result.filled).toBe(1);
+  });
+});
+
+describe("buildFieldLabel", () => {
+  test("shows [not set] with asterisk for required unset field", () => {
+    const label = buildFieldLabel("name", Type.String(), { status: "unset" });
+    expect(label).toContain("name");
+    expect(label).toContain("[not set]");
+    expect(label).toContain("*");
+  });
+
+  test("shows [not set] without asterisk for optional field", () => {
+    const label = buildFieldLabel("nickname", Type.Optional(Type.String()), {
+      status: "unset",
+    });
+    expect(label).toContain("[not set]");
+    expect(label).not.toContain("*");
+  });
+
+  test("shows default value for unset field with default", () => {
+    const label = buildFieldLabel(
+      "timeout",
+      Type.BigInt({ default: 30n }),
+      { status: "unset" },
+    );
+    expect(label).toContain("default");
+    expect(label).toContain("30");
+  });
+
+  test("shows null for null state", () => {
+    const label = buildFieldLabel(
+      "value",
+      Type.Union([Type.String(), Type.Null()]),
+      { status: "null" },
+    );
+    expect(label).toContain("null");
+  });
+
+  test("shows value preview for set field", () => {
+    const label = buildFieldLabel("name", Type.String(), {
+      status: "set",
+      value: "Alice",
+    });
+    expect(label).toContain("Alice");
+  });
+});
+
+describe("getInitialFieldState", () => {
+  test("returns unset for undefined", () => {
+    expect(getInitialFieldState(Type.String(), undefined)).toEqual({
+      status: "unset",
+    });
+  });
+
+  test("returns null for null value", () => {
+    expect(getInitialFieldState(Type.String(), null)).toEqual({
+      status: "null",
+    });
+  });
+
+  test("returns set with value", () => {
+    expect(getInitialFieldState(Type.String(), "hello")).toEqual({
+      status: "set",
+      value: "hello",
+    });
+  });
+});
+
+describe("allRequiredFieldsFilled", () => {
+  test("returns true when all required fields filled", () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      nickname: Type.Optional(Type.String()),
+    });
+    const state = new Map<string, FieldState>([
+      ["name", { status: "set", value: "Alice" }],
+    ]);
+
+    expect(allRequiredFieldsFilled(schema, state)).toBe(true);
+  });
+
+  test("returns false when required field missing", () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      age: Type.BigInt(),
+    });
+    const state = new Map<string, FieldState>([
+      ["name", { status: "set", value: "Alice" }],
+    ]);
+
+    expect(allRequiredFieldsFilled(schema, state)).toBe(false);
+  });
+
+  test("returns true for all-optional schema", () => {
+    const schema = Type.Object({
+      nickname: Type.Optional(Type.String()),
+    });
+    const state = new Map<string, FieldState>();
+
+    expect(allRequiredFieldsFilled(schema, state)).toBe(true);
+  });
+});