feat: array builder should take a singular specifier

Because arrays by default are of only one thing, we should only take a
single `Validator` to specify the type. If we want an array of multiple
types, then we should pass in a `Union`.

An array that cares about the order of the different types is a tuple,
we should consider adding `tuple` as a potential builder.

BREAKING CHANGE: The contract for `v.array` has changed from taking an
array of `Validator`s to taking a single `Validator`.

Author: andy.patterson

src/index.ts

@@ -232,8 +232,8 @@ export function partial<T extends Record<string, any>>(v: Validator<T>): Validat
     });
 }
 
-export function array<V extends Validator<any>>(v: V[]) {
-    return new Validator<Array<ValidType<V>>>({
+export function array<T>(v: Validator<T>) {
+    return new Validator<T[]>({
         type: 'array',
         items: v.map(x => x.getSchema()),
         additionalItems: true,

tests/integration/api.test.ts

@@ -65,14 +65,16 @@ test('Generates correct type for validated object', () => {
 
 test('Validates a deep object', () => {
     const validator = v.object({
-        arr: v.array([
-            v.number(),
-            v.object({
-                o: v.object({
-                    a: v.number(),
+        arr: v.array(
+            v.union([
+                v.number(),
+                v.object({
+                    o: v.object({
+                        a: v.number(),
+                    }),
                 }),
-            }),
-        ]),
+            ]),
+        ),
     });
 
     const x: any = {

tests/unit/array.test.ts

@@ -4,7 +4,7 @@ import { fail, pass, assertTypesEqual } from '../helpers/assert';
 test('Can validate an array', () => {
     const x: any = [21, 22, 23];
 
-    const validator = v.array([ v.number() ]);
+    const validator = v.array(v.number());
 
     if (validator.isValid(x)) {
         assertTypesEqual<typeof x, number[]>();
@@ -21,11 +21,7 @@ test('Can validate a deep array', () => {
         [7, 8, 9],
     ];
 
-    const validator = v.array([
-        v.array([
-            v.number(),
-        ]),
-    ]);
+    const validator = v.array(v.array(v.number()));
 
     if (validator.isValid(x)) {
         assertTypesEqual<typeof x, number[][]>();