Array Validation

import { array, string, number } from 'decoders';

// Array of strings
const stringArrayDecoder = array(string);

stringArrayDecoder.verify(['hello', 'world']); // ['hello', 'world']
stringArrayDecoder.verify([]); // [] (empty arrays are valid)
stringArrayDecoder.verify(['hello', 123]); // Error: Must be string (at index 1)

// Array of numbers
const numberArrayDecoder = array(number);

numberArrayDecoder.verify([1, 2, 3, 4, 5]); // [1, 2, 3, 4, 5]
numberArrayDecoder.verify([1, 'two', 3]); // Error: Must be number (at index 1)

import { nonEmptyArray, string } from 'decoders';

const tagsDecoder = nonEmptyArray(string);

tagsDecoder.verify(['javascript', 'typescript']); // ✓ OK
tagsDecoder.verify([]); // Error: Must be non-empty array

import { poja } from 'decoders';

poja.verify([1, 'two', { three: 3 }]); // ✓ OK (mixed types)
poja.verify([]); // ✓ OK (empty array)
poja.verify('not an array'); // Error: Must be an array
poja.verify({ length: 0 }); // Error: Must be an array

import { tuple, string, number, boolean } from 'decoders';

// Tuple of [string, number]
const pairDecoder = tuple(string, number);

pairDecoder.verify(['age', 30]); // ['age', 30]
pairDecoder.verify(['name', 'Alice']); // Error: Must be number (at position 1)
pairDecoder.verify(['only one']); // Error: Must be a 2-tuple
pairDecoder.verify(['too', 'many', 'items']); // Error: Must be a 2-tuple

// More complex tuple
const recordDecoder = tuple(string, number, boolean);

recordDecoder.verify(['active', 42, true]); // ['active', 42, true]
recordDecoder.verify(['active', 42]); // Error: Must be a 3-tuple

import { tuple, string, number } from 'decoders';
import type { DecoderType } from 'decoders';

const coordinateDecoder = tuple(number, number);

type Coordinate = DecoderType<typeof coordinateDecoder>;
// Type is: [number, number]

const point = coordinateDecoder.verify([10, 20]);
// point[0] is number
// point[1] is number
// point[2] doesn't exist (TypeScript knows this)

import { array, number } from 'decoders';

// 2D array (matrix) of numbers
const matrixDecoder = array(array(number));

matrixDecoder.verify([
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
]);
// ✓ OK

matrixDecoder.verify([
  [1, 2, 3],
  [4, 'five', 6], // Error: Must be number (at index 1)
]);

import { array, object, string, number } from 'decoders';

const userDecoder = object({
  name: string,
  age: number,
});

const usersDecoder = array(userDecoder);

usersDecoder.verify([
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 25 },
]);
// ✓ OK

usersDecoder.verify([
  { name: 'Alice', age: 30 },
  { name: 'Bob' }, // Error: Missing key: "age" (at index 1)
]);

import { tuple, string, number, array, object } from 'decoders';

// API response: [status, data, metadata]
const apiResponseDecoder = tuple(
  string, // status
  array(object({ id: number, name: string })), // data
  object({ timestamp: number }) // metadata
);

apiResponseDecoder.verify([
  'success',
  [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
  ],
  { timestamp: 1234567890 },
]);
// ✓ OK

import { array, string, sized } from 'decoders';

// Exactly 3 elements
const rgbDecoder = sized(array(number), { size: 3 });

rgbDecoder.verify([255, 128, 0]); // ✓ OK
rgbDecoder.verify([255, 128]); // Error: size violation

// Minimum length
const atLeastTwoDecoder = sized(array(string), { min: 2 });

atLeastTwoDecoder.verify(['one', 'two', 'three']); // ✓ OK
atLeastTwoDecoder.verify(['one']); // Error: size violation

// Maximum length
const atMostFiveDecoder = sized(array(string), { max: 5 });

atMostFiveDecoder.verify(['a', 'b', 'c']); // ✓ OK
atMostFiveDecoder.verify(['a', 'b', 'c', 'd', 'e', 'f']); // Error: size violation

// Range
const rangeDecoder = sized(array(number), { min: 2, max: 5 });

rangeDecoder.verify([1, 2, 3]); // ✓ OK
rangeDecoder.verify([1]); // Error: size violation
rangeDecoder.verify([1, 2, 3, 4, 5, 6]); // Error: size violation

import { array, object, string, number } from 'decoders';

const productsDecoder = array(object({
  name: string,
  price: number,
}));

try {
  productsDecoder.verify([
    { name: 'Widget', price: 9.99 },
    { name: 'Gadget', price: 'free' }, // wrong type
    { name: 'Doohickey', price: 4.99 },
  ]);
} catch (error) {
  console.error(error.message);
  // Error message includes: "Must be number (at index 1)"
  // This tells you exactly which array element failed
}

import { setFromArray, string } from 'decoders';

const uniqueTagsDecoder = setFromArray(string);

uniqueTagsDecoder.verify(['javascript', 'typescript', 'javascript']);
// Returns: Set { 'javascript', 'typescript' }
// Note: duplicates are automatically removed

import { array, string } from 'decoders';

// Split comma-separated string into array
const csvDecoder = string
  .transform(s => s.split(','))
  .pipe(array(string));

csvDecoder.verify('apple,banana,orange');
// Returns: ['apple', 'banana', 'orange']

// Validate and sort array
const sortedNumbersDecoder = array(number)
  .transform(arr => [...arr].sort((a, b) => a - b));

sortedNumbersDecoder.verify([3, 1, 4, 1, 5, 9]);
// Returns: [1, 1, 3, 4, 5, 9]

import { array, object, string, number } from 'decoders';
import type { DecoderType } from 'decoders';

const todosDecoder = array(object({
  id: number,
  title: string,
  completed: boolean,
}));

type Todos = DecoderType<typeof todosDecoder>;
// Type is:
// Array<{
//   id: number;
//   title: string;
//   completed: boolean;
// }>