@ic-reactor/candid 3.0.11-beta.2 → 3.0.12-beta.0

package/src/visitor/arguments/README.md

@@ -0,0 +1,230 @@
+# Argument Field Visitor
+
+The `ArgumentFieldVisitor` traverses Candid IDL types to generate two things:
+
+1. **Field Metadata**: Structure, labels, names (for form binding), and default values for rendering form fields.
+2. **Validation Schema**: A Zod schema for validating form inputs.
+
+## Usage
+
+### 1. Initialize the Visitor
+
+```typescript
+import { ArgumentFieldVisitor } from "@ic-reactor/candid"
+import { IDL } from "@icp-sdk/core/candid"
+
+const visitor = new ArgumentFieldVisitor()
+```
+
+### 2. Generate Metadata & Schema
+
+You can visit a single function or an entire service.
+
+#### For a Service
+
+```typescript
+const serviceMeta = visitor.visitService(idlFactory({ IDL }))
+const transferMeta = serviceMeta["icrc1_transfer"]
+
+console.log(transferMeta)
+// Output:
+// {
+//   functionName: "icrc1_transfer",
+//   functionType: "update",
+//   fields: [...],        // Field definitions for rendering
+//   defaultValues: [...], // Default values for the form (array of argument defaults)
+//   schema: ZodSchema,    // Zod schema for validation
+//   argCount: 1,          // Number of arguments
+//   isNoArgs: false       // Whether the function takes no arguments
+// }
+```
+
+#### For a Single Function
+
+```typescript
+const funcType = IDL.Func([IDL.Text, IDL.Nat], [], [])
+const meta = visitor.visitFunc(funcType, "myMethod")
+```
+
+### 3. Field Properties
+
+Each field in `meta.fields` has the following properties:
+
+```typescript
+{
+  type: "text" | "number" | "boolean" | "principal" | "record" | "variant" | ...,
+  label: "fieldName",           // Human-readable label
+  name: "[0].field.nested",     // TanStack Form compatible path
+  defaultValue: ...,            // Default value for this field
+  schema: ZodSchema,            // Zod schema for this field
+  candidType: "text",           // Original Candid type
+  ui: {                         // Optional UI hints
+    placeholder: "e.g. 100",
+  },
+  // Type-specific properties:
+  // - For "number" fields (Nat8, Int32, Float): min, max, unsigned, isFloat, bits
+  // - For "text" fields (Nat, Int, Nat64): (handled as text for BigInt support)
+  // - For variants: options, optionMap, getOptionDefault()
+  // - For vectors: itemField, getItemDefault()
+  // - For optionals: innerField, getInnerDefault()
+  // - For records: fields, fieldMap
+}
+```
+
+### 4. Special Handling & Validation
+
+#### BigInts as Text
+
+Large integer types (`Nat`, `Int`, `Nat64`, `Int64`, `Nat32` > 32-bit representations) are generated with `type: "text"`.
+
+- **Reason**: Standard JavaScript numbers lose precision for values > `2^53 - 1`. HTML number inputs can be unreliable for large integers.
+- **Validation**: The Zod schema strictly validates these as **strings containing only digits** (or sign for signed types).
+- **Label**: They retain their `candidType` (e.g. `nat`) for reference.
+
+#### Strict Validation
+
+- **Required Fields**: Text and Number fields include `.min(1, "Required")`. Empty strings are rejected.
+  - **Integers**: Regex validation ensures only digits (no decimals).
+  - **Floats**: Float32/Float64 allow decimal points (e.g., `123.1`) and are validated using standard `!isNaN(Number(val))`.
+- **Principals**: Validated using `Principal.fromText()`. Empty strings are rejected.
+
+#### Optional Fields
+
+- **Behavior**: Optional fields (`Opt`) wrap the inner schema.
+- **Empty Handling**: An empty string input (`""`) is automatically transformed to `null` (Candid `null` / `None`), ensuring optional fields can be cleared.
+
+### 5. Integration with TanStack Form
+
+The visitor is optimized for standard form libraries like TanStack Form.
+
+```tsx
+import { useForm } from "@tanstack/react-form"
+
+function MethodForm({ meta }) {
+  const form = useForm({
+    defaultValues: meta.defaultValues,
+    validators: {
+      onChange: meta.schema, // Use generated Zod schema for validation
+    },
+    onSubmit: async ({ value }) => {
+      console.log("Structured Data:", value)
+      // value is ready to be passed to strict Candid adapters
+    },
+  })
+
+  return (
+    <form
+      onSubmit={(e) => {
+        e.preventDefault()
+        e.stopPropagation()
+        form.handleSubmit()
+      }}
+    >
+      {meta.fields.map((field) => (
+        <form.Field key={field.name} name={field.name}>
+          {(fieldApi) => (
+            <div>
+              <label>{field.label}</label>
+              <input
+                type={
+                  field.type === "text" || field.type === "principal"
+                    ? "text"
+                    : field.type
+                }
+                value={fieldApi.state.value}
+                onChange={(e) => fieldApi.handleChange(e.target.value)}
+                placeholder={field.ui?.placeholder}
+              />
+              {fieldApi.state.meta.errors.map((err) => (
+                <span key={err} className="error">
+                  {err}
+                </span>
+              ))}
+            </div>
+          )}
+        </form.Field>
+      ))}
+      <button type="submit">Submit</button>
+    </form>
+  )
+}
+```
+
+### 6. Dynamic Fields
+
+For **Vectors** and **Variants**, you can access helper paths dynamically:
+
+- **Vector**: Field name `items` -> Item name `items[0]`, `items[1]`.
+- **Record**: Field name `user` -> Nested `user.name`.
+
+The `name` property in the metadata is pre-calculated to match this structure (e.g., `[0].args.user.name` if it's the first argument).
+
+### 7. Working with Vectors (Arrays)
+
+Use helper methods like `getItemDefault()` to manage array items.
+
+```tsx
+function VectorField({ field, form }) {
+  return (
+    <form.Field name={field.name} mode="array">
+      {(arrayFieldApi) => (
+        <div>
+          {arrayFieldApi.state.value.map((_, index) => (
+             /* Render items using field.name + [index] */
+          ))}
+          <button
+             onClick={() => arrayFieldApi.pushValue(field.getItemDefault())}
+          >
+             Add Item
+          </button>
+        </div>
+      )}
+    </form.Field>
+  )
+}
+```
+
+### 8. Working with Variants
+
+Use `optionMap` for lookup and `getOptionDefault()` for switching types.
+
+```tsx
+<select
+  onChange={(e) => {
+    // Switch variant type and default value
+    const newValue = field.getOptionDefault(e.target.value)
+    form.setFieldValue(field.name, newValue)
+  }}
+>
+  {field.options.map((opt) => (
+    <option key={opt}>{opt}</option>
+  ))}
+</select>
+```
+
+### 9. Type Guards
+
+The library exports type guard utilities for safer type narrowing:
+
+```typescript
+import {
+  isFieldType,
+  isCompoundField,
+  isPrimitiveField,
+} from "@ic-reactor/candid"
+
+if (isFieldType(field, "record")) {
+  // field is RecordArgumentField
+}
+```
+
+### 10. Recursive Types
+
+Recursive types (like linked lists) use `z.lazy()` schemas. Use `field.extract()` to get the inner definition when rendering.
+
+```tsx
+function RecursiveField({ field }) {
+  const innerField = useMemo(() => field.extract(), [field])
+  return <DynamicField field={innerField} ... />
+}
+```

package/src/visitor/arguments/index.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest"
 import { IDL } from "@icp-sdk/core/candid"
-import { ArgumentFieldVisitor } from "./index"
+import { ArgumentFieldVisitor, VectorField } from "./index"
 
 describe("ArgumentFieldVisitor", () => {
   const visitor = new ArgumentFieldVisitor()
@@ -53,51 +53,70 @@ describe("ArgumentFieldVisitor", () => {
     it("should handle nat type", () => {
       const field = visitor.visitNat(IDL.Nat, "amount")
 
-      expect(field.type).toBe("number")
+      expect(field.type).toBe("text")
       expect(field.label).toBe("amount")
       expect(field.candidType).toBe("nat")
       expect(field.defaultValue).toBe("")
+      // TextField doesn't have isFloat or unsigned properties in the types
     })
 
     it("should handle int type", () => {
       const field = visitor.visitInt(IDL.Int, "balance")
 
-      expect(field.type).toBe("number")
+      expect(field.type).toBe("text")
       expect(field.candidType).toBe("int")
     })
 
-    it("should handle nat8 type", () => {
+    it("should handle nat8 type with min/max", () => {
       const field = visitor.visitFixedNat(IDL.Nat8 as IDL.FixedNatClass, "byte")
 
-      expect(field.type).toBe("number")
-      expect(field.candidType).toBe("nat8")
+      if (field.type === "number") {
+        expect(field.type).toBe("number")
+        expect(field.candidType).toBe("nat8")
+        expect(field.bits).toBe(8)
+        expect(field.min).toBe("0")
+        expect(field.max).toBe("255")
+      } else {
+        throw new Error("Expected number field for nat8")
+      }
     })
 
-    it("should handle nat64 type", () => {
+    it("should handle nat64 type with min/max", () => {
       const field = visitor.visitFixedNat(
         IDL.Nat64 as IDL.FixedNatClass,
         "timestamp"
       )
 
-      expect(field.type).toBe("number")
+      expect(field.type).toBe("text")
       expect(field.candidType).toBe("nat64")
+      // Large numbers are now text fields and don't carry bit/min/max metadata in the same way
     })
 
-    it("should handle int32 type", () => {
+    it("should handle int32 type with min/max", () => {
       const field = visitor.visitFixedInt(
         IDL.Int32 as IDL.FixedIntClass,
         "count"
       )
 
-      expect(field.type).toBe("number")
-      expect(field.candidType).toBe("int32")
+      if (field.type === "number") {
+        expect(field.type).toBe("number")
+        expect(field.candidType).toBe("int32")
+        expect(field.bits).toBe(32)
+        expect(field.min).toBe("-2147483648")
+        expect(field.max).toBe("2147483647")
+      } else {
+        throw new Error("Expected number field for int32")
+      }
     })
 
     it("should handle float64 type", () => {
       const field = visitor.visitFloat(IDL.Float64 as IDL.FloatClass, "price")
 
       expect(field.type).toBe("number")
-      expect(field.candidType).toBe("float")
+      expect(field.candidType).toBe("float64")
+      if (field.type === "number") {
+        expect(field.isFloat).toBe(true)
+      }
     })
   })
 
@@ -123,6 +142,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.type).toBe("record")
       expect(field.label).toBe("person")
       expect(field.fields).toHaveLength(2)
+      expect(field.fieldMap.has("name")).toBe(true)
+      expect(field.fieldMap.has("age")).toBe(true)
 
       const nameField = field.fields.find((f) => f.label === "name")
       if (!nameField || nameField.type !== "text") {
@@ -132,13 +153,13 @@ describe("ArgumentFieldVisitor", () => {
       expect(nameField.defaultValue).toBe("")
 
       const ageField = field.fields.find((f) => f.label === "age")
-      if (!ageField || ageField.type !== "number") {
-        throw new Error("Age field not found or not number")
+      if (!ageField || ageField.type !== "text") {
+        throw new Error("Age field not found or not text")
       }
-      expect(ageField.type).toBe("number")
+      expect(ageField.type).toBe("text")
       expect(ageField.candidType).toBe("nat")
 
-      expect(field.defaultValues).toEqual({
+      expect(field.defaultValue).toEqual({
         name: "",
         age: "",
       })
@@ -172,7 +193,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(addressField.type).toBe("record")
       expect(addressField.fields).toHaveLength(2)
 
-      expect(field.defaultValues).toEqual({
+      expect(field.defaultValue).toEqual({
         name: "",
         address: {
           street: "",
@@ -223,10 +244,10 @@ describe("ArgumentFieldVisitor", () => {
 
       // Check 'amount' field
       const amountField = field.fields.find((f) => f.label === "amount")
-      if (!amountField || amountField.type !== "number") {
-        throw new Error("Amount field not found or not number")
+      if (!amountField || amountField.type !== "text") {
+        throw new Error("Amount field not found or not text")
       }
-      expect(amountField.type).toBe("number")
+      expect(amountField.type).toBe("text")
       expect(amountField.candidType).toBe("nat")
 
       // Check optional 'fee' field
@@ -235,7 +256,7 @@ describe("ArgumentFieldVisitor", () => {
         throw new Error("Fee field not found or not optional")
       }
       expect(feeField.type).toBe("optional")
-      expect(feeField.innerField.type).toBe("number")
+      expect(feeField.innerField.type).toBe("text")
     })
   })
 
@@ -261,10 +282,15 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.options).toEqual(["Inactive", "Active", "Pending"])
       expect(field.defaultOption).toBe("Inactive")
       expect(field.fields).toHaveLength(3)
+      expect(field.optionMap.has("Active")).toBe(true)
 
       field.fields.forEach((f) => {
         expect(f.type).toBe("null")
       })
+
+      // Test getOptionDefault helper
+      expect(field.getOptionDefault("Active")).toEqual({ Active: null })
+      expect(field.getOptionDefault("Pending")).toEqual({ Pending: null })
     })
 
     it("should handle variant with payloads", () => {
@@ -312,10 +338,10 @@ describe("ArgumentFieldVisitor", () => {
       expect(transferField.fields).toHaveLength(2)
 
       const burnField = field.fields.find((f) => f.label === "Burn")
-      if (!burnField || burnField.type !== "number") {
-        throw new Error("Burn field not found or not number")
+      if (!burnField || burnField.type !== "text") {
+        throw new Error("Burn field not found or not text")
       }
-      expect(burnField.type).toBe("number")
+      expect(burnField.type).toBe("text")
     })
 
     it("should handle Result variant (Ok/Err)", () => {
@@ -337,10 +363,10 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.options).toContain("Err")
 
       const okField = field.fields.find((f) => f.label === "Ok")
-      if (!okField || okField.type !== "number") {
-        throw new Error("Ok field not found or not number")
+      if (!okField || okField.type !== "text") {
+        throw new Error("Ok field not found or not text")
       }
-      expect(okField.type).toBe("number")
+      expect(okField.type).toBe("text")
 
       const errField = field.fields.find((f) => f.label === "Err")
       if (!errField || errField.type !== "text") {
@@ -359,8 +385,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.label).toBe("pair")
       expect(field.fields).toHaveLength(2)
       expect(field.fields[0].type).toBe("text")
-      expect(field.fields[1].type).toBe("number")
-      expect(field.defaultValues).toEqual(["", ""])
+      expect(field.fields[1].type).toBe("text")
+      expect(field.defaultValue).toEqual(["", ""])
     })
 
     it("triple tuple", () => {
@@ -374,9 +400,9 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.type).toBe("tuple")
       expect(field.fields).toHaveLength(3)
       expect(field.fields[0].type).toBe("principal")
-      expect(field.fields[1].type).toBe("number")
+      expect(field.fields[1].type).toBe("text")
       expect(field.fields[2].type).toBe("boolean")
-      expect(field.defaultValues).toEqual(["", "", false])
+      expect(field.defaultValue).toEqual(["", "", false])
     })
   })
 
@@ -389,6 +415,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.label).toBe("nickname")
       expect(field.defaultValue).toBe(null)
       expect(field.innerField.type).toBe("text")
+      expect(field.getInnerDefault()).toBe("")
     })
 
     it("should handle optional record", () => {
@@ -408,6 +435,9 @@ describe("ArgumentFieldVisitor", () => {
       } else {
         throw new Error("Inner field is not record")
       }
+
+      // Test getInnerDefault helper
+      expect(field.getInnerDefault()).toEqual({ name: "", value: "" })
     })
 
     it("should handle nested optional", () => {
@@ -420,7 +450,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.innerField.type).toBe("optional")
       const inner = field.innerField
       if (inner.type === "optional") {
-        expect(inner.innerField.type).toBe("number")
+        expect(inner.innerField.type).toBe("text")
       } else {
         throw new Error("Inner field is not optional")
       }
@@ -430,12 +460,13 @@ describe("ArgumentFieldVisitor", () => {
   describe("Vector Types", () => {
     it("should handle vector of primitives", () => {
       const vecType = IDL.Vec(IDL.Text)
-      const field = visitor.visitVec(vecType, IDL.Text, "tags")
+      const field = visitor.visitVec(vecType, IDL.Text, "tags") as VectorField
 
       expect(field.type).toBe("vector")
       expect(field.label).toBe("tags")
       expect(field.defaultValue).toEqual([])
       expect(field.itemField.type).toBe("text")
+      expect(field.getItemDefault()).toBe("")
     })
 
     it("should handle vector of records", () => {
@@ -444,7 +475,7 @@ describe("ArgumentFieldVisitor", () => {
         name: IDL.Text,
       })
       const vecType = IDL.Vec(recType)
-      const field = visitor.visitVec(vecType, recType, "items")
+      const field = visitor.visitVec(vecType, recType, "items") as VectorField
 
       expect(field.type).toBe("vector")
       expect(field.itemField.type).toBe("record")
@@ -454,6 +485,9 @@ describe("ArgumentFieldVisitor", () => {
       } else {
         throw new Error("Item field is not record")
       }
+
+      // Test getItemDefault helper
+      expect(field.getItemDefault()).toEqual({ id: "", name: "" })
     })
 
     it("blob (vec nat8)", () => {
@@ -463,6 +497,9 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.type).toBe("blob")
       expect(field.label).toBe("data")
       expect(field.defaultValue).toBe("")
+      if (field.type === "blob") {
+        expect(field.acceptedFormats).toEqual(["hex", "base64", "file"])
+      }
     })
 
     it("should handle nested vectors", () => {
@@ -474,7 +511,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.itemField.type).toBe("vector")
       const item = field.itemField
       if (item.type === "vector") {
-        expect(item.itemField.type).toBe("number")
+        expect(item.itemField.type).toBe("text")
       } else {
         throw new Error("Item field is not vector")
       }
@@ -508,7 +545,9 @@ describe("ArgumentFieldVisitor", () => {
 
       expect(field.type).toBe("recursive")
       expect(field.label).toBe("tree")
+      expect(field.typeName).toBeDefined()
       expect(typeof field.extract).toBe("function")
+      expect(typeof field.getInnerDefault).toBe("function")
 
       // Extract should return a variant
       const extracted = field.extract()
@@ -576,6 +615,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(meta.fields).toHaveLength(1)
       expect(meta.fields[0].type).toBe("text")
       expect(meta.defaultValues).toEqual([""])
+      expect(meta.argCount).toBe(1)
+      expect(meta.isNoArgs).toBe(false)
     })
 
     it("should handle update function", () => {
@@ -618,8 +659,9 @@ describe("ArgumentFieldVisitor", () => {
 
       expect(meta.fields).toHaveLength(3)
       expect(meta.fields[0].type).toBe("principal")
-      expect(meta.fields[1].type).toBe("number")
+      expect(meta.fields[1].type).toBe("text")
       expect(meta.fields[2].type).toBe("optional")
+      expect(meta.argCount).toBe(3)
     })
 
     it("should handle function with no arguments", () => {
@@ -629,6 +671,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(meta.functionType).toBe("query")
       expect(meta.fields).toHaveLength(0)
       expect(meta.defaultValues).toEqual([])
+      expect(meta.argCount).toBe(0)
+      expect(meta.isNoArgs).toBe(true)
     })
   })
 
@@ -685,15 +729,16 @@ describe("ArgumentFieldVisitor", () => {
       const getMetadataMeta = serviceMeta["get_metadata"]
       expect(getMetadataMeta.functionType).toBe("query")
       expect(getMetadataMeta.fields).toHaveLength(0)
+      expect(getMetadataMeta.isNoArgs).toBe(true)
     })
   })
 
   // ════════════════════════════════════════════════════════════════════════
-  // Path Generation
+  // Name (Path) Generation
   // ════════════════════════════════════════════════════════════════════════
 
-  describe("Path Generation", () => {
-    it("should generate correct paths for nested records", () => {
+  describe("Name Generation", () => {
+    it("should generate correct names for nested records", () => {
       const funcType = IDL.Func(
         [
           IDL.Record({
@@ -713,28 +758,28 @@ describe("ArgumentFieldVisitor", () => {
       if (argRecord.type !== "record") {
         throw new Error("Expected record field")
       }
-      expect(argRecord.path).toBe("[0]")
+      expect(argRecord.name).toBe("[0]")
 
       const userRecord = argRecord.fields.find((f) => f.label === "user")
       if (!userRecord || userRecord.type !== "record") {
         throw new Error("User record not found or not record")
       }
-      expect(userRecord.path).toBe("[0].user")
+      expect(userRecord.name).toBe("[0].user")
 
       const nameField = userRecord.fields.find((f) => f.label === "name")
       if (!nameField || nameField.type !== "text") {
         throw new Error("Name field not found or not text")
       }
-      expect(nameField.path).toBe("[0].user.name")
+      expect(nameField.name).toBe("[0].user.name")
 
       const ageField = userRecord.fields.find((f) => f.label === "age")
-      if (!ageField || ageField.type !== "number") {
-        throw new Error("Age field not found or not number")
+      if (!ageField || ageField.type !== "text") {
+        throw new Error("Age field not found or not text")
       }
-      expect(ageField.path).toBe("[0].user.age")
+      expect(ageField.name).toBe("[0].user.age")
     })
 
-    it("should generate correct paths for vectors", () => {
+    it("should generate correct names for vectors", () => {
       const funcType = IDL.Func([IDL.Vec(IDL.Text)], [], [])
       const meta = visitor.visitFunc(funcType, "addTags")
 
@@ -742,8 +787,8 @@ describe("ArgumentFieldVisitor", () => {
       if (vecField.type !== "vector") {
         throw new Error("Expected vector field")
       }
-      expect(vecField.path).toBe("[0]")
-      expect(vecField.itemField.path).toBe("[0][0]")
+      expect(vecField.name).toBe("[0]")
+      expect(vecField.itemField.name).toBe("[0][0]")
     })
   })
 
@@ -801,10 +846,10 @@ describe("ArgumentFieldVisitor", () => {
 
       // Check amount field
       const amountField = field.fields.find((f) => f.label === "amount")
-      if (!amountField || amountField.type !== "number") {
-        throw new Error("Amount field not found or not number")
+      if (!amountField || amountField.type !== "text") {
+        throw new Error("Amount field not found or not text")
       }
-      expect(amountField.type).toBe("number")
+      expect(amountField.type).toBe("text")
       expect(amountField.candidType).toBe("nat")
     })
 
@@ -879,4 +924,52 @@ describe("ArgumentFieldVisitor", () => {
       expect(transferField.fields.length).toBeGreaterThan(3)
     })
   })
+
+  // ════════════════════════════════════════════════════════════════════════
+  // Helper Methods
+  // ════════════════════════════════════════════════════════════════════════
+
+  describe("Helper Methods", () => {
+    it("variant getOptionDefault should return correct defaults", () => {
+      const statusType = IDL.Variant({
+        Active: IDL.Null,
+        Pending: IDL.Record({ reason: IDL.Text }),
+      })
+      const field = visitor.visitVariant(
+        statusType,
+        [
+          ["Active", IDL.Null],
+          ["Pending", IDL.Record({ reason: IDL.Text })],
+        ],
+        "status"
+      )
+
+      expect(field.getOptionDefault("Active")).toEqual({ Active: null })
+      expect(field.getOptionDefault("Pending")).toEqual({
+        Pending: { reason: "" },
+      })
+    })
+
+    it("vector getItemDefault should return item default", () => {
+      const vecType = IDL.Vec(IDL.Record({ name: IDL.Text }))
+      const field = visitor.visitVec(
+        vecType,
+        IDL.Record({ name: IDL.Text }),
+        "items"
+      ) as VectorField
+
+      expect(field.getItemDefault()).toEqual({ name: "" })
+    })
+
+    it("optional getInnerDefault should return inner default", () => {
+      const optType = IDL.Opt(IDL.Record({ value: IDL.Nat }))
+      const field = visitor.visitOpt(
+        optType,
+        IDL.Record({ value: IDL.Nat }),
+        "config"
+      )
+
+      expect(field.getInnerDefault()).toEqual({ value: "" })
+    })
+  })
 })