ᯓ𝘁𝗿𝗮𝘃𝗲𝗿𝘀𝗮𝗯𝗹𝗲/𝗮𝗿𝗸𝘁𝘆𝗽𝗲

@traversable/arktype is a schema rewriter for ArkType schemas.

       

     

Getting started

$ pnpm add @traversable/arktype
Copy

Here's an example of importing the library:

import { type } from 'arktype'
import { ark } from '@traversable/arktype'

// or, if you prefer, you can use named imports:
import { deepClone, deepEqual } from '@traversable/arktype'

// see below for specific examples
Copy

Table of contents

Fuzz-tested, production ready

• ark.deepClone
• ark.deepClone.writeable
• ark.deepEqual
• ark.deepEqual.writeable

Features

ark.deepClone

ark.deepClone lets users derive a specialized "deep copy" function that works with values that have been already validated.

Because the values have already been validated, clone times are significantly faster than alternatives like window.structuredClone and Lodash.cloneDeep.

Performance comparison

Here's a Bolt sandbox if you'd like to run the benchmarks yourself.

                           ┌─────────────────┐
                           │        Average  │
┌──────────────────────────┼─────────────────┤
│  window.structuredClone  │  14.82x faster  │
├──────────────────────────┼─────────────────┤
│  Lodash.cloneDeep        │  18.86x faster  │
└──────────────────────────┴─────────────────┘
Copy

This article goes into more detail about what makes ark.deepClone so fast.

Example

import { type } from 'arktype'
import { deepClone, deepEqual } from '@traversable/arktype'

const Address = type({
  street1: 'string',
  "street2?": 'string',
  city: 'string'
})

const cloneAddress = deepClone(Address)
const addressEquals = deepEqual(Address)

const sherlock = { street1: '221 Baker St', street2: '#B', city: 'London' }
const harry = { street1: '4 Privet Dr', city: 'Little Whinging' }

const sherlockCloned = cloneAddress(sherlock)
const harryCloned = cloneAddress(harry)

addressEquals(sherlockCloned, sherlock) // => true
sherlock === sherlockCloned             // => false

addressEquals(harryCloned, harry)       // => true
harry === harryCloned                   // => false
Copy

See also

• ark.deepClone.writeable

ark.deepClone.writeable

ark.deepClone.writeable lets users derive a specialized "deep clone" function that works with values that have been already validated.

Compared to ark.deepClone, ark.deepClone.writeable returns the clone function in stringified ("writeable") form.

Example

import { type } from 'arktype'
import { deepClone } from '@traversable/arktype'

const cloneAddress = deepClone.writeable(
  type({
    street1: 'string',
    "street2?": 'string',
    city: 'string'
  }),
  { typeName: 'Address' }
)

console.log(cloneAddress)
// =>
// type Address = { street1: string; street2?: string; city: string; }
// function deepClone(prev: Address): Address {
//   return {
//     street1: prev.street1,
//     ...prev.street2 !== undefined && { street2: prev.street2 },
//     city: prev.city
//   }
// }
Copy

See also

• ark.deepClone

ark.deepEqual

ark.deepEqual lets users derive a specialized "deep equal" function that works with values that have been already validated.

Because the values have already been validated, comparison times are significantly faster than alternatives like NodeJS.isDeepStrictEqual and Lodash.isEqual.

Performance comparison

Here's a Bolt sandbox if you'd like to run the benchmarks yourself.

                             ┌─────────────────┐
                             │        Average  │
┌────────────────────────────┼─────────────────┤
│  NodeJS.isDeepStrictEqual  │  23.45x faster  │
├────────────────────────────┼─────────────────┤
│  Lodash.isEqual            │  49.29x faster  │
└────────────────────────────┴─────────────────┘
Copy

This article goes into more detail about what makes ark.deepEqual so fast.

Notes

• Best performance
• Works in any environment that supports defining functions using the Function constructor, including (as of May 2025) Cloudflare workers 🎉

Example

import { type } from 'arktype'
import { deepEqual } from '@traversable/arktype'

const addressEquals = deepEqual(
  type({
    street1: 'string',
    "street2?": 'string',
    city: 'string'
  })
)

addressEquals(
  { street1: '221 Baker St', street2: '#B', city: 'London' },
  { street1: '221 Baker St', street2: '#B', city: 'London' }
) // => true

addressEquals(
  { street1: '221 Baker St', street2: '#B', city: 'London' },
  { street1: '4 Privet Dr', city: 'Little Whinging' }
) // => false
Copy

See also

• ark.deepEqual.writeable

ark.deepEqual.writeable

ark.deepEqual.writeable lets users derive a specialized "deep equal" function that works with values that have been already validated.

Compared to ark.deepEqual, ark.deepEqual.writeable returns the deep equal function in stringified ("writeable") form.

Notes

• Useful when you're consuming a set of ArkType schemas and writing all them to disc somewhere
• Also useful for testing purposes or for troubleshooting, since it gives you a way to "see" exactly what the deepEqual functions are doing

Example

import { type } from 'arktype'
import { deepEqual } from '@traversable/arktype'

const addressEquals = deepEqual.writeable(
  type({
    street1: 'string',
    "street2?": 'string',
    city: 'string'
  }), 
  { typeName: 'Address' }
)

console.log(addressEquals)
// =>
// type Address = { street1: string; street2?: string; city: string; }
// function deepEqual(x: Address, y: Address) {
//   if (x === y) return true;
//   if (x.street1 !== y.street1) return false;
//   if (x.street2 !== y.street2) return false;
//   if (x.city !== y.city) return false;
//   return true;
// }
Copy

See also

• ark.deepEqual