more progress, needs more reviewing

Author: gsimone

packages/leva/src/plugins/Select/select-plugin.test.ts

@@ -245,33 +245,88 @@ describe('Select Plugin - normalize function', () => {
       expect(result.settings.keys).toEqual(['', 'a', 'b'])
       expect(result.settings.values).toEqual(['', 'a', 'b'])
     })
+
+    it('should handle invalid mixed-type arrays (fallback scenario)', () => {
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      // This tests the fallback case where options contain invalid types like nested arrays
+      const input = { options: ['x', 'y', ['x', 'y']] as any }
+      const result = normalize(input)
+
+      // Falls through to empty fallback
+      expect(result.value).toBe(undefined)
+      expect(result.settings.keys).toEqual([])
+      expect(result.settings.values).toEqual([])
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[Leva] Invalid Select options format'),
+        input.options
+      )
+
+      consoleWarnSpy.mockRestore()
+    })
+
+    it('should handle completely invalid options (not array or object)', () => {
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      const input = { options: null as any }
+      const result = normalize(input)
+
+      expect(result.value).toBe(undefined)
+      expect(result.settings.keys).toEqual([])
+      expect(result.settings.values).toEqual([])
+      expect(consoleWarnSpy).toHaveBeenCalled()
+
+      consoleWarnSpy.mockRestore()
+    })
   })
 })
 
 describe('Select Plugin - schema validation', () => {
   it('should accept array of primitives', () => {
-    const result = schema(null, ['x', 'y', 'z'])
-    expect(result.success).toBe(true)
+    const result = schema(null, { options: ['x', 'y', 'z'] })
+    expect(result).toBe(true)
   })
 
   it('should accept object with primitive values', () => {
-    const result = schema(null, { foo: 'bar', baz: 1 })
-    expect(result.success).toBe(true)
+    const result = schema(null, { options: { foo: 'bar', baz: 1 } })
+    expect(result).toBe(true)
   })
 
   it('should accept array of value/label objects', () => {
-    const result = schema(null, [{ value: 'x', label: 'X' }, { value: 'y' }])
-    expect(result.success).toBe(true)
+    const result = schema(null, { options: [{ value: 'x', label: 'X' }, { value: 'y' }] })
+    expect(result).toBe(true)
   })
 
-  it('should reject invalid input', () => {
+  it('should reject invalid input (missing options)', () => {
+    const result = schema(null, {})
+    expect(result).toBe(false)
+  })
+
+  it('should reject null', () => {
     const result = schema(null, null)
-    expect(result.success).toBe(false)
+    expect(result).toBe(false)
+  })
+
+  it('should accept array with non-primitive values (validation happens in normalize)', () => {
+    // Schema only checks if 'options' exists and is an array/object
+    // Detailed validation of options content happens in normalize() with better warnings
+    const result = schema(null, { options: [{ nested: 'object' }, 'string'] })
+    expect(result).toBe(true)
+  })
+
+  it('should reject boolean primitives', () => {
+    const result = schema(null, true)
+    expect(result).toBe(false)
+  })
+
+  it('should reject number primitives', () => {
+    const result = schema(null, 10)
+    expect(result).toBe(false)
   })
 
-  it('should reject array with non-primitive values', () => {
-    const result = schema(null, [{ nested: 'object' }, 'string'])
-    expect(result.success).toBe(false)
+  it('should reject settings without options key', () => {
+    const result = schema(null, { value: 'x' })
+    expect(result).toBe(false)
   })
 })
 

packages/leva/src/plugins/Select/select-plugin.ts

@@ -37,8 +37,20 @@ const arrayOfValueLabelObjectsSchema = z.array(valueLabelObjectSchema)
 
 const allUsecases = z.union([arrayOfPrimitivesSchema, keyAsLabelObjectSchema, arrayOfValueLabelObjectsSchema])
 
+/**
+ * Schema for the settings object - checks if it has an 'options' key
+ * We accept any array or any object (excluding arrays) for the options value
+ * Detailed validation of options content happens in normalize() with better error messages
+ */
+const selectInputSchema = z.object({
+  options: z.union([
+    z.array(z.any()), // Any array
+    z.object({}).passthrough(), // Any object with any keys
+  ]),
+})
+
 // the options attribute is either a key value object, an array, or an array of {value, label} objects
-export const schema = (_o: any, s: any) => allUsecases.safeParse(s)
+export const schema = (_o: any, s: any) => selectInputSchema.safeParse(s).success
 
 export const sanitize = (value: any, { values }: InternalSelectSettings) => {
   if (values.indexOf(value) < 0) throw Error(`Selected value doesn't match Select options`)
@@ -77,6 +89,14 @@ export const normalize = (input: SelectInput) => {
         gatheredKeys = Object.keys(isKeyAsLabelObject.data)
       } else {
         // Fallback (shouldn't happen if schema validation is correct)
+        console.warn(
+          '[Leva] Invalid Select options format. Expected one of:\n' +
+            '  - Array of primitives: ["x", "y", 1, true]\n' +
+            '  - Object with key-value pairs: { x: 1, foo: "bar" }\n' +
+            '  - Array of {value, label} objects: [{ value: "x", label: "X" }]\n' +
+            'Received:',
+          options
+        )
         gatheredValues = []
         gatheredKeys = []
       }

packages/leva/stories/advanced/Busy.stories.tsx

@@ -55,7 +55,7 @@ function BusyControls() {
     string: { value: 'something', optional: true, order: -2 },
     range: { value: 0, min: -10, max: 10, order: -3 },
     image: { image: undefined },
-    select: { options: ['x', 'y', ['x', 'y']] },
+    select: { options: ['x', 'y', 'x,y'] },
     interval: { min: -100, max: 100, value: [-10, 10] },
     color: '#ffffff',
     refMonitor: monitor(noise ? frame : () => 0, { graph: true, interval: 30 }),