cito

Check types at runtime

• Small: 1/4 of superstruct, 1/15 of zod
• Support recursive type declarations
• Descriptive error messages
• Full TypeScript support
• JIT compilation for fast validation checks
• Only loose assertions: does not warn on extra keys

npm install cito

Usage

import {assert, is, object, number, string, array} from 'cito'

type Post = typeof Post.infer
const Post = object({
  id: number,
  title: string,
  link: string.optional,
  author: object({id: number}),
  tags: array(string)
})

const data = {
  id: 42,
  title: 'Hello world',
  author: {id: 42},
  tags: ['hello']
}

// Throws if data is invalid, data is type as Post
assert(data, Post)

// data is typed as Post in the block, does not throw
if (is(data, Post)) {
  // use data
}

// Assert and name the input data
const post = Post(data)

Defining objects using a class

Object types can be declared using a class, which has the following advantages over plain objects:

• Optional properties

  It is possible to mark properties as optional which will be reflected in the inferred type:

  import {object, string} from 'cito'
  const WithOptional = object(
    class {
      required = string
      present = string.optional
      optional? = string.optional
    }
  )
  type WithOptional = typeof WithOptional.infer
  //   ^? {required: string, present: string | undefined, optional?: string | undefined}
  

• Recursive types

  Declare recursive types with full type inference without having to resort to manual type definition.

  > Note: recursive types cannot be JIT compiled

  import {any, object} from 'cito'
  type Node = typeof Node.infer
  const Node = object(
    class Node {
      next = object(Node)
      prev = object(Node)
      data = any
    }
  )
  type List = typeof List.infer
  const List = object({
    head: Node.optional
  })
  

Api

Cito exports the following public members.

const string: Type
const number: Type
const bigint: Type
const boolean: Type
const symbol: Type