├── .md
├── .github
    └── FUNDING.yml
├── bun.lockb
├── src
    ├── index.ts
    ├── zu.ts
    ├── lib
    │   ├── pick.ts
    │   ├── omit.ts
    │   ├── omit.test.ts
    │   ├── pick.test.ts
    │   └── mapValues.ts
    ├── SPR.test.ts
    ├── stringToJSON.ts
    ├── SPR.ts
    ├── json.ts
    ├── json.test.ts
    ├── useTypedParsers.ts
    ├── stringToJSON.test.ts
    ├── partialSafeParse.ts
    ├── useTypedParsers.test.ts
    ├── makeErrorMap.ts
    ├── useFormLike.ts
    ├── partialSafeParse.test.ts
    ├── coerce.ts
    ├── makeErrorMap.test.ts
    ├── useFormLike.test.ts
    └── coerce.test.ts
├── tsconfig.json
├── scripts
    ├── publish.ts
    └── build.ts
├── package.json
├── LICENSE
├── .gitignore
├── README.md
└── logo.svg


/.md:
--------------------------------------------------------------------------------
1 | 
2 | 
3 | ```ts
4 | ```


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: JacobWeisenburger
2 | 


--------------------------------------------------------------------------------
/bun.lockb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JacobWeisenburger/zod_utilz/HEAD/bun.lockb


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
1 | export * from './zu'
2 | export * as zu from './zu'
3 | import * as zu from './zu'
4 | export default zu 


--------------------------------------------------------------------------------
/src/zu.ts:
--------------------------------------------------------------------------------
1 | export * from './SPR'
2 | export * from './makeErrorMap'
3 | export * from './useTypedParsers'
4 | export * from './coerce'
5 | export * from './json'
6 | export * from './stringToJSON'
7 | export * from './useFormLike'
8 | export * from './partialSafeParse'


--------------------------------------------------------------------------------
/src/lib/pick.ts:
--------------------------------------------------------------------------------
1 | export const pick = <Obj extends Record<string, unknown>>
2 |     ( obj: Obj, keys: ( keyof Obj )[] ) => {
3 |     if ( keys.length === 0 ) return {}
4 |     const entries = Object.entries( obj ) as [ keyof Obj, unknown ][]
5 |     return Object.fromEntries(
6 |         entries.filter( ( [ key ] ) => keys.includes( key ) )
7 |     )
8 | }


--------------------------------------------------------------------------------
/src/lib/omit.ts:
--------------------------------------------------------------------------------
1 | export const omit = <Obj extends Record<string, unknown>>
2 |     ( obj: Obj, keys: ( keyof Obj | string )[] ) => {
3 |     if ( keys.length === 0 ) return obj
4 |     const entries = Object.entries( obj ) as [ keyof Obj, unknown ][]
5 |     return Object.fromEntries(
6 |         entries.filter( ( [ key ] ) => !keys.includes( key ) )
7 |     )
8 | }


--------------------------------------------------------------------------------
/src/lib/omit.test.ts:
--------------------------------------------------------------------------------
 1 | import { expect, test } from 'bun:test'
 2 | import { omit } from './omit'
 3 | 
 4 | const obj = {
 5 |     foo: 'foo',
 6 |     bar: 42,
 7 |     baz: true,
 8 | }
 9 | 
10 | test( 'omit', () => {
11 |     expect( omit( obj, [] ) ).toMatchObject( obj )
12 |     expect( omit( obj, [ 'foo' ] ) ).toMatchObject( { bar: 42, baz: true } )
13 |     expect( omit( obj, [ 'foo', 'bar' ] ) ).toMatchObject( { baz: true } )
14 | } )


--------------------------------------------------------------------------------
/src/lib/pick.test.ts:
--------------------------------------------------------------------------------
 1 | import { expect, test } from 'bun:test'
 2 | import { pick } from './pick'
 3 | 
 4 | const obj = {
 5 |     foo: 'foo',
 6 |     bar: 42,
 7 |     baz: true,
 8 | }
 9 | 
10 | test( 'pick', () => {
11 |     expect( pick( obj, [] ) ).toMatchObject( {} )
12 |     expect( pick( obj, [ 'foo' ] ) ).toMatchObject( { foo: 'foo' } )
13 |     expect( pick( obj, [ 'foo', 'bar' ] ) ).toMatchObject( { foo: 'foo', bar: 42 } )
14 | } )


--------------------------------------------------------------------------------
/src/SPR.test.ts:
--------------------------------------------------------------------------------
 1 | import { expect, test } from 'bun:test'
 2 | import { z } from 'zod'
 3 | import { zu } from '.'
 4 | 
 5 | test( 'README Example', () => {
 6 |     const schema = z.object( { foo: z.string() } )
 7 |     const result = zu.SPR( schema.safeParse( { foo: 42 } ) )
 8 |     const fooDataOrErrors = result.data?.foo ?? result.error?.format().foo?._errors
 9 | 
10 |     expect( { fooDataOrErrors } )
11 |         .toMatchObject( { fooDataOrErrors: [ 'Expected string, received number' ] } )
12 | } )


--------------------------------------------------------------------------------
/src/lib/mapValues.ts:
--------------------------------------------------------------------------------
 1 | type ObjectIterator<Obj, Result> =
 2 |     ( value: Obj[ keyof Obj ], key: string, collection: Obj ) => Result
 3 | 
 4 | export const mapValues = <Obj extends Record<string, any>, Result>
 5 |     ( fn: ObjectIterator<Obj, Result> ) => ( obj?: Obj ) => {
 6 |         if ( !obj ) return {}
 7 |         const map = Object.keys( obj ).reduce( ( map, key ) => {
 8 |             map.set( key, fn( obj[ key ], key, obj ) )
 9 |             return map
10 |         }, new Map )
11 |         return Object.fromEntries( map )
12 |     }


--------------------------------------------------------------------------------
/src/stringToJSON.ts:
--------------------------------------------------------------------------------
 1 | import { z } from 'zod'
 2 | import type { json } from './json'
 3 | 
 4 | const stringToJSONSchema = z.string()
 5 |     .transform( ( str, ctx ): z.infer<ReturnType<typeof json>> => {
 6 |         try {
 7 |             return JSON.parse( str )
 8 |         } catch ( e ) {
 9 |             ctx.addIssue( { code: 'custom', message: 'Invalid JSON' } )
10 |             return z.NEVER
11 |         }
12 |     } )
13 | 
14 | /**
15 | zu.stringToJSON() is a schema that validates JSON encoded as a string, then returns the parsed value
16 | 
17 | @example
18 | import { zu } from 'zod_utilz'
19 | const schema = zu.stringToJSON()
20 | schema.parse( 'true' ) // true
21 | schema.parse( 'null' ) // null
22 | schema.parse( '["one", "two", "three"]' ) // ['one', 'two', 'three']
23 | schema.parse( '<html>not a JSON string</html>' ) // throws
24 | */
25 | export const stringToJSON = () => stringToJSONSchema


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |         "lib": [
 4 |             "ESNext",
 5 |             "dom",
 6 |             "dom.iterable",
 7 |             "esnext"
 8 |         ],
 9 |         "target": "ESNext",
10 |         "module": "ESNext",
11 |         "moduleDetection": "force",
12 |         "jsx": "react-jsx",
13 |         "allowJs": true,
14 |         "moduleResolution": "bundler",
15 |         "allowImportingTsExtensions": true,
16 |         "noEmit": true,
17 |         "skipLibCheck": true,
18 |         "strict": true,
19 |         "noFallthroughCasesInSwitch": true,
20 |         "forceConsistentCasingInFileNames": true,
21 |         "composite": true,
22 |         "downlevelIteration": true,
23 |         "allowSyntheticDefaultImports": true,
24 |         "types": [
25 |             "bun-types"
26 |         ],
27 |     },
28 |     "include": [
29 |         "./src/**/*",
30 |         "package.json"
31 |     ]
32 | }


--------------------------------------------------------------------------------
/scripts/publish.ts:
--------------------------------------------------------------------------------
 1 | import { $ } from 'bun'
 2 | import * as Path from 'node:path'
 3 | 
 4 | // https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
 5 | // https://dev.to/astagi/publish-to-npm-using-github-actions-23fn
 6 | 
 7 | const logError = ( ctx?: object ) => ( { message }: Error ) => {
 8 |     const data = { message, ...ctx }
 9 |     console.error( 'Error:', JSON.stringify( data, null, 2 ) )
10 | }
11 | 
12 | const root = Path.join( import.meta.dir, '..' )
13 | const dist = Path.join( root, 'dist' )
14 | 
15 | await Promise.resolve()
16 |     .then( () => console.log( 'Publishing...' ) )
17 | 
18 |     .then( async () => {
19 |         const section = 'npm publish'
20 |         await $`cd ${ dist } && npm publish --access public`
21 |             .then( () => console.log( 'npm publish: ran' ) )
22 |             .catch( logError( { section } ) )
23 |     } )
24 | 
25 |     .then( () => console.log( 'Publish: done' ) )
26 |     .catch( logError( { path: import.meta.path } ) )


--------------------------------------------------------------------------------
/src/SPR.ts:
--------------------------------------------------------------------------------
 1 | import { z } from 'zod'
 2 | 
 3 | /**
 4 |  * SPR stands for SafeParseResult
 5 |  * 
 6 |  * This enables [optional chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining) or [nullish coalescing](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing) for `z.SafeParseReturnType`.
 7 |  * 
 8 |  * ### Usage:
 9 |  * ```
10 |  * import { zu } from 'zod_utilz'
11 |  * const schema = z.object( { foo: z.string() } )
12 |  * const result = zu.SPR( schema.safeParse( { foo: 42 } ) )
13 |  * const fooDataOrErrors = result.data?.foo ?? result.error?.format().foo?._errors
14 |  * ```
15 | */
16 | export function SPR<Input, Output> ( result: z.SafeParseReturnType<Input, Output> ): {
17 |     success: typeof result[ 'success' ]
18 |     data: z.SafeParseSuccess<Output>[ 'data' ] | undefined
19 |     error: z.SafeParseError<Input>[ 'error' ] | undefined
20 | } {
21 |     return result.success
22 |         ? { ...result, error: undefined }
23 |         : { ...result, data: undefined }
24 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "zod_utilz",
 3 |     "version": "0.8.4",
 4 |     "author": "JacobWeisenburger",
 5 |     "description": "Framework agnostic utilities for Zod",
 6 |     "license": "MIT",
 7 |     "npm": "https://www.npmjs.com/package/zod_utilz",
 8 |     "repository": "https://github.com/JacobWeisenburger/zod_utilz",
 9 |     "homepage": "https://github.com/JacobWeisenburger/zod_utilz",
10 |     "module": "index.js",
11 |     "main": "index.js",
12 |     "type": "module",
13 |     "keywords": [
14 |         "typescript"
15 |     ],
16 |     "scripts": {
17 |         "test": "clear && bun test --watch",
18 |         "test.cmd": "cmd.exe /c start cmd /k bun run test",
19 |         "build": "clear && bun --watch run scripts/build.ts",
20 |         "publish": "clear && bun run scripts/publish.ts"
21 |     },
22 |     "peerDependencies": {
23 |         "typescript": "^5.0.0",
24 |         "zod": "^3.22.4"
25 |     },
26 |     "devDependencies": {
27 |         "@types/bun": "latest",
28 |         "bun-plugin-dts": "^0.2.1",
29 |         "dts-bundle-generator": "^9.3.1",
30 |         "@type-challenges/utils": "^0.1.1"
31 |     }
32 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Jacob Weisenburger
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/src/json.ts:
--------------------------------------------------------------------------------
 1 | import { z } from 'zod'
 2 | 
 3 | const literalSchema = z.union( [
 4 |     z.string(),
 5 |     z.number(),
 6 |     z.boolean(),
 7 |     z.null()
 8 | ] )
 9 | 
10 | type Literal = z.infer<typeof literalSchema>
11 | 
12 | type Json = Literal | { [ key: string ]: Json } | Json[]
13 | 
14 | const jsonSchema: z.ZodType<Json> = z.lazy( () =>
15 |     z.union( [
16 |         literalSchema,
17 |         z.array( jsonSchema ),
18 |         z.record( jsonSchema )
19 |     ] )
20 | )
21 | 
22 | /**
23 | zu.json() is a schema that validates that a JavaScript object is JSON-compatible. This includes `string`, `number`, `boolean`, and `null`, plus `Array`s and `Object`s containing JSON-compatible types as values.
24 | Note: `JSON.stringify()` enforces non-circularity, but this can't be easily checked without actually stringifying the results, which can be slow.
25 | @example
26 | import { zu } from 'zod_utilz'
27 | const schema = zu.json()
28 | schema.parse( false ) // false
29 | schema.parse( 8675309 ) // 8675309
30 | schema.parse( { a: 'deeply', nested: [ 'JSON', 'object' ] } )
31 | // { a: 'deeply', nested: [ 'JSON', 'object' ] }
32 | */
33 | export const json = () => jsonSchema


--------------------------------------------------------------------------------
/src/json.test.ts:
--------------------------------------------------------------------------------
 1 | import { expect, test } from 'bun:test'
 2 | import { zu } from '.'
 3 | 
 4 | test( 'json', () => {
 5 |     const schema = zu.json()
 6 | 
 7 |     /* allowed primitives */
 8 |     expect( schema.parse( 'foo' ) ).toBe( 'foo' )
 9 |     expect( schema.parse( 42 ) ).toBe( 42 )
10 |     expect( schema.parse( true ) ).toBe( true )
11 |     expect( schema.parse( false ) ).toBe( false )
12 |     expect( schema.parse( null ) ).toBe( null )
13 | 
14 |     /* disallowed primitives */
15 |     expect( () => schema.parse( 42n ) ).toThrow()
16 |     expect( () => schema.parse( Symbol( 'symbol' ) ) ).toThrow()
17 |     expect( () => schema.parse( undefined ) ).toThrow()
18 |     expect( () => schema.parse( new Date() ) ).toThrow()
19 | 
20 |     /* objects */
21 |     const nested = { one: [ 'two', { three: 4 } ] }
22 |     expect( schema.parse( nested ) ).toMatchObject( nested )
23 | } )
24 | 
25 | test( 'README Example', () => {
26 |     const schema = zu.json()
27 |     expect( schema.parse( false ) ).toBe( false )
28 |     expect( schema.parse( 8675309 ) ).toBe( 8675309 )
29 |     expect( schema.parse( { a: 'deeply', nested: [ 'JSON', 'object' ] } ) )
30 |         .toMatchObject( { a: 'deeply', nested: [ 'JSON', 'object' ] } )
31 | } )


--------------------------------------------------------------------------------
/src/useTypedParsers.ts:
--------------------------------------------------------------------------------
 1 | import { z } from 'zod'
 2 | 
 3 | type ParseMethods = 'parse' | 'parseAsync' | 'safeParse' | 'safeParseAsync'
 4 | 
 5 | /**
 6 |  * Enables compile time type checking for zod parsers.
 7 |  * 
 8 |  * ### Usage:
 9 |  * ```
10 |  * import { zu } from 'zod_utilz'
11 |  * const schemaWithTypedParsers = zu.useTypedParsers( z.literal( 'foo' ) )
12 |  * 
13 |  * schemaWithTypedParsers.parse( 'foo' )
14 |  * // no ts errors
15 |  * 
16 |  * schemaWithTypedParsers.parse( 'bar' )
17 |  * //                            ^^^^^
18 |  * // Argument of type '"bar"' is not assignable to parameter of type '"foo"'
19 |  * ```
20 |  */
21 | export const useTypedParsers = <Schema extends z.ZodType>
22 |     ( schema: Schema ) => schema as any as TypedParsersSchema<Schema>
23 | 
24 | type ParametersExceptFirst<Func> =
25 |     Func extends ( arg0: any, ...rest: infer R ) => any ? R : never
26 | 
27 | type Params<Schema extends z.ZodType, Method extends ParseMethods> = [
28 |     data: z.input<Schema>,
29 |     ...rest: ParametersExceptFirst<Schema[ Method ]>
30 | ]
31 | 
32 | type TypedParsersSchema<Schema extends z.ZodType> = Omit<Schema, ParseMethods> & {
33 |     [ Method in ParseMethods ]: ( ...args: Params<Schema, Method> ) => ReturnType<Schema[ Method ]>
34 | }


--------------------------------------------------------------------------------
/src/stringToJSON.test.ts:
--------------------------------------------------------------------------------
 1 | import { expect, test } from 'bun:test'
 2 | import { z } from 'zod'
 3 | import { zu } from '.'
 4 | 
 5 | test( 'stringToJSON', () => {
 6 |     const schema = zu.stringToJSON()
 7 | 
 8 |     /* allowed primitives */
 9 |     expect( schema.parse( '"foo"' ) ).toBe( 'foo' )
10 |     expect( schema.parse( '42' ) ).toBe( 42 )
11 |     expect( schema.parse( 'true' ) ).toBe( true )
12 |     expect( schema.parse( 'false' ) ).toBe( false )
13 |     expect( schema.parse( 'null' ) ).toBe( null )
14 | 
15 |     /* disallowed primitives */
16 |     expect( () => schema.parse( '42n' ) ).toThrow()
17 |     expect( () => schema.parse( 'undefined' ) ).toThrow()
18 | 
19 |     /* valid objects */
20 |     const nested = { one: [ 'two', { three: 4 } ] }
21 |     expect( schema.parse( JSON.stringify( nested ) ) ).toMatchObject( nested )
22 | 
23 |     /* invalid JSON */
24 |     expect( () => schema.parse( '{ keys: "must be quoted" }' ) ).toThrow()
25 |     expect( () => schema.parse( '{ "objects": "must be closed"' ) ).toThrow()
26 |     expect( () => schema.parse( '"arrays", "must", "be", "opened" ]' ) ).toThrow()
27 |     expect( () => schema.parse( '<html>is not JSON</html>' ) ).toThrow()
28 | 
29 |     /* piping */
30 |     const jsonNumberSchema = zu.stringToJSON().pipe( z.number() )
31 |     expect( jsonNumberSchema.parse( '500' ) ).toBe( 500 )
32 |     expect( () => jsonNumberSchema.parse( '"JSON, but not a number"' ) ).toThrow()
33 | } )
34 | 
35 | test( 'stringToJSON', () => {
36 |     const schema = zu.stringToJSON()
37 | 
38 |     expect( schema.parse( 'true' ) ).toBe( true )
39 |     expect( schema.parse( 'null' ) ).toBe( null )
40 |     expect( schema.parse( '["one", "two", "three"]' ) )
41 |         .toMatchObject( [ 'one', 'two', 'three' ] )
42 |     expect( () => schema.parse( '<html>not a JSON string</html>' ) ).toThrow()
43 | } )


--------------------------------------------------------------------------------
/src/partialSafeParse.ts:
--------------------------------------------------------------------------------
 1 | import { z } from 'zod'
 2 | import { zu } from '.'
 3 | import { mapValues } from './lib/mapValues'
 4 | import { pick } from './lib/pick'
 5 | import { omit } from './lib/omit'
 6 | 
 7 | /**
 8 | partialSafeParse allows you to get the valid fields even if there was an error in another field
 9 | 
10 | @example
11 | import { zu } from 'zod_utilz'
12 | const userSchema = z.object( { name: z.string(), age: z.number() } )
13 | const result = zu.partialSafeParse( userSchema, { name: null, age: 42 } )
14 | // {
15 | //     successType: 'partial',
16 | //     validData: { age: 42 },
17 | //     invalidData: { name: null },
18 | // }
19 | result.error?.flatten().fieldErrors
20 | // {
21 | //     name: [ 'Expected string, received null' ],
22 | // }
23 | */
24 | export function partialSafeParse<Schema extends z.AnyZodObject> (
25 |     schema: Schema, input: unknown
26 | ): ReturnType<typeof zu.SPR> & {
27 |     successType: 'full' | 'partial' | 'none',
28 |     validData: Partial<z.infer<Schema>>,
29 |     invalidData: Partial<z.infer<Schema>>,
30 | } {
31 |     const result = zu.SPR( schema.safeParse( input ) )
32 |     if ( result.success ) return {
33 |         ...result,
34 |         successType: 'full',
35 |         validData: result.data as Partial<z.infer<Schema>>,
36 |         invalidData: {},
37 |     } as const
38 | 
39 |     const { fieldErrors, formErrors } = result.error?.flatten() ?? {}
40 |     if ( formErrors?.length ) return {
41 |         ...result,
42 |         successType: 'none',
43 |         validData: {},
44 |         invalidData: {},
45 |     }
46 | 
47 |     const inputObj = input as z.infer<Schema>
48 |     const keysWithInvalidData = Object.keys( fieldErrors ?? {} )
49 |     const validInput = omit( inputObj, keysWithInvalidData )
50 |     const invalidData = pick( inputObj, keysWithInvalidData ) as Partial<z.infer<Schema>>
51 | 
52 |     const validData = schema
53 |         .omit( mapValues( () => true )( fieldErrors ) )
54 |         .parse( validInput ) as Partial<z.infer<Schema>>
55 | 
56 |     return {
57 |         ...result,
58 |         successType: 'partial',
59 |         validData,
60 |         invalidData,
61 |     }
62 | }


--------------------------------------------------------------------------------
/src/useTypedParsers.test.ts:
--------------------------------------------------------------------------------
 1 | import { Equal, Expect, NotEqual } from '@type-challenges/utils'
 2 | import { expect, test } from 'bun:test'
 3 | import { z } from 'zod'
 4 | import { zu } from '.'
 5 | 
 6 | test( 'useTypedParsers type tests', () => {
 7 |     const schemaWithTypedParse = zu.useTypedParsers( z.object( {
 8 |         foo: z.literal( 'foo' ),
 9 |     } ) )
10 | 
11 |     type parseTest = Expect<Equal<
12 |         Parameters<typeof schemaWithTypedParse.parse>[ 0 ],
13 |         z.infer<typeof schemaWithTypedParse>
14 |     >>
15 |     type safeParseTest = Expect<Equal<
16 |         Parameters<typeof schemaWithTypedParse.safeParse>[ 0 ],
17 |         z.infer<typeof schemaWithTypedParse>
18 |     >>
19 |     type parseAsyncTest = Expect<Equal<
20 |         Parameters<typeof schemaWithTypedParse.parseAsync>[ 0 ],
21 |         z.infer<typeof schemaWithTypedParse>
22 |     >>
23 |     type safeParseAsyncTest = Expect<Equal<
24 |         Parameters<typeof schemaWithTypedParse.safeParseAsync>[ 0 ],
25 |         z.infer<typeof schemaWithTypedParse>
26 |     >>
27 | 
28 |     type parseTestError = Expect<NotEqual<
29 |         Parameters<typeof schemaWithTypedParse.parse>[ 0 ],
30 |         'hello'
31 |     >>
32 |     type safeParseTestError = Expect<NotEqual<
33 |         Parameters<typeof schemaWithTypedParse.safeParse>[ 0 ],
34 |         'hello'
35 |     >>
36 |     type parseAsyncTestError = Expect<NotEqual<
37 |         Parameters<typeof schemaWithTypedParse.parseAsync>[ 0 ],
38 |         'hello'
39 |     >>
40 |     type safeParseAsyncTestError = Expect<NotEqual<
41 |         Parameters<typeof schemaWithTypedParse.safeParseAsync>[ 0 ],
42 |         'hello'
43 |     >>
44 | } )
45 | 
46 | test( 'README Example', () => {
47 |     const schemaWithTypedParsers = zu.useTypedParsers( z.literal( 'foo' ) )
48 | 
49 |     // no ts errors
50 |     expect( schemaWithTypedParsers.parse( 'foo' ) ).toBe( 'foo' )
51 | 
52 |     expect( () =>
53 |         // @ts-expect-error
54 |         schemaWithTypedParsers.parse( 'bar' )
55 |         //                            ^^^^^
56 |         // Argument of type '"bar"' is not assignable to parameter of type '"foo"'
57 |     ).toThrow()
58 | } )
59 | 
60 | test( 'https://github.com/JacobWeisenburger/zod_utilz/issues/13', () => {
61 |     const DEFAULT_CONCURRENCY = 1
62 |     const schema = z.number().int().min( 1 ).default( DEFAULT_CONCURRENCY )
63 |     const typedSchema = zu.useTypedParsers( schema )
64 |     type Input = z.input<typeof typedSchema>
65 |     // type Input = number | undefined
66 |     type Output = z.output<typeof typedSchema>
67 |     // type Output = number
68 |     typedSchema.parse( undefined )
69 | } )


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Based on https://raw.githubusercontent.com/github/gitignore/main/Node.gitignore
  2 | 
  3 | # Logs
  4 | 
  5 | logs
  6 | _.log
  7 | npm-debug.log_
  8 | yarn-debug.log*
  9 | yarn-error.log*
 10 | lerna-debug.log*
 11 | .pnpm-debug.log*
 12 | 
 13 | # Caches 
 14 | 
 15 | .cache
 16 | 
 17 | # Diagnostic reports (https://nodejs.org/api/report.html)
 18 | 
 19 | report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
 20 | 
 21 | # Runtime data
 22 | 
 23 | pids
 24 | _.pid
 25 | _.seed
 26 | *.pid.lock
 27 | 
 28 | # Directory for instrumented libs generated by jscoverage/JSCover
 29 | 
 30 | lib-cov
 31 | 
 32 | # Coverage directory used by tools like istanbul
 33 | 
 34 | coverage
 35 | *.lcov
 36 | 
 37 | # nyc test coverage
 38 | 
 39 | .nyc_output
 40 | 
 41 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
 42 | 
 43 | .grunt
 44 | 
 45 | # Bower dependency directory (https://bower.io/)
 46 | 
 47 | bower_components
 48 | 
 49 | # node-waf configuration
 50 | 
 51 | .lock-wscript
 52 | 
 53 | # Compiled binary addons (https://nodejs.org/api/addons.html)
 54 | 
 55 | build/Release
 56 | 
 57 | # Dependency directories
 58 | 
 59 | node_modules/
 60 | jspm_packages/
 61 | 
 62 | # Snowpack dependency directory (https://snowpack.dev/)
 63 | 
 64 | web_modules/
 65 | 
 66 | # TypeScript cache
 67 | 
 68 | *.tsbuildinfo
 69 | 
 70 | # Optional npm cache directory
 71 | 
 72 | .npm
 73 | 
 74 | # Optional eslint cache
 75 | 
 76 | .eslintcache
 77 | 
 78 | # Optional stylelint cache
 79 | 
 80 | .stylelintcache
 81 | 
 82 | # Microbundle cache
 83 | 
 84 | .rpt2_cache/
 85 | .rts2_cache_cjs/
 86 | .rts2_cache_es/
 87 | .rts2_cache_umd/
 88 | 
 89 | # Optional REPL history
 90 | 
 91 | .node_repl_history
 92 | 
 93 | # Output of 'npm pack'
 94 | 
 95 | *.tgz
 96 | 
 97 | # Yarn Integrity file
 98 | 
 99 | .yarn-integrity
100 | 
101 | # dotenv environment variable files
102 | 
103 | .env
104 | .env.development.local
105 | .env.test.local
106 | .env.production.local
107 | .env.local
108 | 
109 | # parcel-bundler cache (https://parceljs.org/)
110 | 
111 | .parcel-cache
112 | 
113 | # Next.js build output
114 | 
115 | .next
116 | out
117 | 
118 | # Nuxt.js build / generate output
119 | 
120 | .nuxt
121 | dist
122 | 
123 | # Gatsby files
124 | 
125 | # Comment in the public line in if your project uses Gatsby and not Next.js
126 | 
127 | # https://nextjs.org/blog/next-9-1#public-directory-support
128 | 
129 | # public
130 | 
131 | # vuepress build output
132 | 
133 | .vuepress/dist
134 | 
135 | # vuepress v2.x temp and cache directory
136 | 
137 | .temp
138 | 
139 | # Docusaurus cache and generated files
140 | 
141 | .docusaurus
142 | 
143 | # Serverless directories
144 | 
145 | .serverless/
146 | 
147 | # FuseBox cache
148 | 
149 | .fusebox/
150 | 
151 | # DynamoDB Local files
152 | 
153 | .dynamodb/
154 | 
155 | # TernJS port file
156 | 
157 | .tern-port
158 | 
159 | # Stores VSCode versions used for testing VSCode extensions
160 | 
161 | .vscode-test
162 | 
163 | # yarn v2
164 | 
165 | .yarn/cache
166 | .yarn/unplugged
167 | .yarn/build-state.yml
168 | .yarn/install-state.gz
169 | .pnp.*
170 | 
171 | # IntelliJ based IDEs
172 | .idea
173 | 
174 | # Finder (MacOS) folder config
175 | .DS_Store
176 | 


--------------------------------------------------------------------------------
/src/makeErrorMap.ts:
--------------------------------------------------------------------------------
 1 | import { z } from 'zod'
 2 | 
 3 | export const ExtraErrorCode = z.util.arrayToEnum( [
 4 |     'required',
 5 | ] )
 6 | 
 7 | type RequiredIssue = z.ZodIssueBase & {
 8 |     code: typeof ExtraErrorCode.required
 9 |     expected: z.ZodParsedType
10 |     received: 'undefined'
11 | }
12 | 
13 | type ExtraErrorCode = keyof typeof ExtraErrorCode
14 | 
15 | export type ErrorCode = ExtraErrorCode | z.ZodIssueCode
16 | 
17 | type Issue<Code extends ErrorCode> =
18 |     Code extends RequiredIssue[ 'code' ]
19 |     ? RequiredIssue
20 |     : Code extends z.ZodIssueCode
21 |     ? z.ZodIssueOptionalMessage & { code: Code }
22 |     : never
23 | 
24 | export type ErrorMapMessageBuilderContext<Code extends ErrorCode> =
25 |     z.ErrorMapCtx & Issue<Code>
26 | 
27 | export type ErrorMapMessage = string
28 | 
29 | export type ErrorMapMessageBuilder<Code extends ErrorCode> =
30 |     ( context: ErrorMapMessageBuilderContext<Code> ) => ErrorMapMessage
31 | 
32 | export type ErrorMapConfig = {
33 |     [ Code in ErrorCode ]?: ErrorMapMessage | ErrorMapMessageBuilder<Code>
34 | }
35 | // type ErrorMapConfigRecord = Record<ErrorCode, ErrorMapMessage | ErrorMapMessageBuilder>
36 | // export type ErrorMapConfig = Partial<ErrorMapConfigRecord>
37 | 
38 | /**
39 |  * Simplifies the process of making a `ZodErrorMap`
40 |  * 
41 |  * ### Usage:
42 |  * ```
43 |  * import { zu } from 'zod_utilz'
44 |  * const errorMap = zu.makeErrorMap( {
45 |  *     required: 'Custom required message',
46 |  *     invalid_type: ( { data } ) => `${ data } is an invalid type`,
47 |  *     too_big: ( { maximum } ) => `Maximum length is ${ maximum }`,
48 |  *     invalid_enum_value: ( { data, options } ) =>
49 |  *         `${ data } is not a valid enum value. Valid options: ${ options?.join( ' | ' ) } `,
50 |  * } )
51 |  * 
52 |  * const stringSchema = z.string( { errorMap } ).max( 32 )
53 |  * 
54 |  * zu.SPR( stringSchema.safeParse( undefined ) ).error?.issues[ 0 ].message
55 |  * // Custom required message
56 |  * 
57 |  * zu.SPR( stringSchema.safeParse( 42 ) ).error?.issues[ 0 ].message
58 |  * // 42 is an invalid type
59 |  * 
60 |  * zu.SPR( stringSchema.safeParse(
61 |  *     'this string is over the maximum length'
62 |  * ) ).error?.issues[ 0 ].message
63 |  * // Maximum length is 32
64 |  * 
65 |  * const enumSchema = z.enum( [ 'foo', 'bar' ], { errorMap } )
66 |  * 
67 |  * zu.SPR( enumSchema.safeParse( 'baz' ) ).error?.issues[ 0 ].message
68 |  * // baz is not a valid enum value. Valid options: foo | bar
69 |  * ```
70 |  */
71 | export function makeErrorMap ( config: ErrorMapConfig ): z.ZodErrorMap {
72 |     return ( issue, ctx ) => {
73 |         const errorCode: ErrorCode =
74 |             issue.code === 'invalid_type' && ctx.data === undefined
75 |                 ? 'required' : issue.code
76 | 
77 |         const messageOrBuilder = config[ errorCode ]
78 |         const context = { ...ctx, ...issue, code: errorCode }
79 | 
80 |         const message = typeof messageOrBuilder === 'function'
81 |             /* @ts-ignore */
82 |             // TODO figure out how to deal with:
83 |             // Expression produces a union type that is too complex to represent.
84 |             ? messageOrBuilder( context )
85 |             : messageOrBuilder
86 | 
87 |         return message ? { message } : { message: ctx.defaultError }
88 |     }
89 | }


--------------------------------------------------------------------------------
/src/useFormLike.ts:
--------------------------------------------------------------------------------
  1 | import { z } from 'zod'
  2 | 
  3 | function safeParseJSON ( string: string ): any {
  4 |     try { return JSON.parse( string ) }
  5 |     catch { return string }
  6 | }
  7 | 
  8 | const formLikeToRecord = ( keys?: string[] ) =>
  9 |     ( formLike: FormData | URLSearchParams ): Record<string, any> => {
 10 |         return Array.from( keys ?? formLike.keys() ).reduce( ( record, key ) => {
 11 |             const values = formLike.getAll( key )
 12 |                 .map( x => x instanceof File ? x : safeParseJSON( x ) )
 13 |             record[ key ] = values.length > 1 ? values : values[ 0 ]
 14 |             return record
 15 |         }, {} as Record<string, any> )
 16 |     }
 17 | 
 18 | const useFormLike = ( type: typeof FormData | typeof URLSearchParams ) => <
 19 |     Schema extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam>
 20 | > ( schema: Schema ) => {
 21 |     const { unknownKeys } = schema._def
 22 |     const keys = unknownKeys == 'strip' ? Object.keys( schema.shape ) : undefined
 23 |     return z.instanceof( type )
 24 |         .transform( formLikeToRecord( keys ) )
 25 |         .pipe( schema )
 26 | }
 27 | 
 28 | /**
 29 |  * A way to parse URLSearchParams
 30 |  * 
 31 |  * ### Usage:
 32 |  * ```
 33 |  * import { zu } from 'zod_utilz'
 34 |  * const schema = zu.useURLSearchParams(
 35 |  *     z.object( {
 36 |  *         string: z.string(),
 37 |  *         number: z.number(),
 38 |  *         boolean: z.boolean(),
 39 |  *     } )
 40 |  * )
 41 |  * 
 42 |  * zu.SPR( schema.safeParse(
 43 |  *     new URLSearchParams( {
 44 |  *         string: 'foo',
 45 |  *         number: '42',
 46 |  *         boolean: 'false',
 47 |  *     } )
 48 |  * ) ).data
 49 |  * // { string: 'foo', number: 42, boolean: false }
 50 |  * 
 51 |  * zu.SPR( schema.safeParse(
 52 |  *     new URLSearchParams( {
 53 |  *         string: '42',
 54 |  *         number: 'false',
 55 |  *         boolean: 'foo',
 56 |  *     } )
 57 |  * ) ).error?.flatten().fieldErrors
 58 |  * // {
 59 |  * //     string: [ 'Expected string, received number' ],
 60 |  * //     number: [ 'Expected number, received boolean' ],
 61 |  * //     boolean: [ 'Expected boolean, received string' ],
 62 |  * // }
 63 |  * ```
 64 |  */
 65 | export const useURLSearchParams = <Schema extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam>>
 66 |     ( schema: Schema ) => useFormLike( URLSearchParams )( schema )
 67 | 
 68 | /**
 69 | A way to parse FormData
 70 | 
 71 | ```
 72 | const schema = zu.useFormData(
 73 |     z.object( {
 74 |         string: z.string(),
 75 |         number: z.number(),
 76 |         boolean: z.boolean(),
 77 |         file: z.instanceof( File ),
 78 |     } )
 79 | )
 80 | ```
 81 | 
 82 | @example
 83 | import { zu } from 'zod_utilz'
 84 | const file = new File( [], 'filename.ext' )
 85 | const formData = new FormData()
 86 | formData.append( 'string', 'foo' )
 87 | formData.append( 'number', '42' )
 88 | formData.append( 'boolean', 'false' )
 89 | formData.append( 'file', file )
 90 | 
 91 | zu.SPR( schema.safeParse( formData ) ).data,
 92 | // { string: 'foo', number: 42, boolean: false, file }
 93 | 
 94 | @example
 95 | import { zu } from 'zod_utilz'
 96 | const formData = new FormData()
 97 | formData.append( 'string', '42' )
 98 | formData.append( 'number', 'false' )
 99 | formData.append( 'boolean', 'foo' )
100 | formData.append( 'file', 'filename.ext' )
101 | 
102 | zu.SPR( schema.safeParse( formData ) ).error?.flatten().fieldErrors,
103 | // {
104 | //     string: [ 'Expected string, received number' ],
105 | //     number: [ 'Expected number, received boolean' ],
106 | //     boolean: [ 'Expected boolean, received string' ],
107 | //     file: [ 'Input not instance of File' ],
108 | // }
109 | */
110 | export const useFormData = <Schema extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam>>
111 |     ( schema: Schema ) => useFormLike( FormData )( schema )


--------------------------------------------------------------------------------
/src/partialSafeParse.test.ts:
--------------------------------------------------------------------------------
  1 | import { expect, test } from 'bun:test'
  2 | import { z } from 'zod'
  3 | import { zu } from '.'
  4 | 
  5 | const userSchema = z.object( { name: z.string(), age: z.number() } )
  6 | 
  7 | test( `successType: 'full'`, () => {
  8 |     const result = zu.partialSafeParse( userSchema, { name: 'foo', age: 42 } )
  9 |     expect( result ).toMatchObject( {
 10 |         successType: 'full',
 11 |         data: { name: 'foo', age: 42 },
 12 |         validData: { name: 'foo', age: 42 },
 13 |         invalidData: {},
 14 |     } )
 15 | 
 16 |     // @ts-ignore
 17 |     expect( result.error ).toBe( undefined )
 18 | } )
 19 | 
 20 | test( `successType: 'partial': { name: null, age: 42 }`, () => {
 21 |     const result = zu.partialSafeParse( userSchema, { name: null, age: 42 } )
 22 |     expect( result ).toMatchObject( {
 23 |         successType: 'partial',
 24 |         validData: { age: 42 },
 25 |         invalidData: { name: null },
 26 |     } )
 27 |     expect( result.error?.flatten().fieldErrors ?? {} ).toMatchObject( {
 28 |         name: [ 'Expected string, received null' ]
 29 |     } )
 30 | } )
 31 | 
 32 | test( `successType: 'partial': { name: null }`, () => {
 33 |     const result = zu.partialSafeParse( userSchema, { name: null } )
 34 |     expect( result ).toMatchObject( {
 35 |         successType: 'partial',
 36 |         validData: {},
 37 |         invalidData: { name: null },
 38 |     } )
 39 |     expect( result.error?.flatten().fieldErrors ?? {} ).toMatchObject( {
 40 |         name: [ 'Expected string, received null' ],
 41 |         age: [ 'Required' ],
 42 |     } )
 43 | } )
 44 | 
 45 | test( `successType: 'partial': {}`, () => {
 46 |     const result = zu.partialSafeParse( userSchema, {} )
 47 |     expect( result ).toMatchObject( {
 48 |         successType: 'partial',
 49 |         validData: {},
 50 |         invalidData: {},
 51 |     } )
 52 |     expect( result.error?.flatten().fieldErrors ?? {} ).toMatchObject( {
 53 |         name: [ 'Required' ],
 54 |         age: [ 'Required' ],
 55 |     } )
 56 | } )
 57 | 
 58 | test( `successType: 'none'`, () => {
 59 |     const result = zu.partialSafeParse( userSchema, null )
 60 |     expect( result ).toMatchObject( {
 61 |         successType: 'none',
 62 |         validData: {},
 63 |         invalidData: {},
 64 |     } )
 65 |     expect( result.error?.flatten().formErrors ?? [] ).toMatchObject( [
 66 |         'Expected object, received null'
 67 |     ] )
 68 | } )
 69 | 
 70 | test( `Readme Example`, () => {
 71 |     const userSchema = z.object( { name: z.string(), age: z.number() } )
 72 |     const result = zu.partialSafeParse( userSchema, { name: null, age: 42 } )
 73 |     expect( result ).toMatchObject( {
 74 |         successType: 'partial',
 75 |         validData: { age: 42 },
 76 |         invalidData: { name: null },
 77 |     } )
 78 |     expect( result.error?.flatten().fieldErrors ?? {} ).toMatchObject( {
 79 |         name: [ 'Expected string, received null' ]
 80 |     } )
 81 | } )
 82 | 
 83 | // test( `with useURLSearchParams`, () => {
 84 | //     const params = new URLSearchParams( 'foo=foo&bar=42' )
 85 | //     const schema = zu.useURLSearchParams(
 86 | //         z.object( { foo: z.string(), bar: z.string() } )
 87 | //     )
 88 | //     // const schema: z.ZodPipeline<z.ZodEffects<z.ZodType<FormData | URLSearchParams, z.ZodTypeDef, FormData | URLSearchParams>, Record<string, any>, FormData | URLSearchParams>, z.ZodObject<...>>
 89 | 
 90 | 
 91 | //     //@ts-ignore
 92 | //     const result = zu.partialSafeParse( schema, params )
 93 | //     console.log( result )
 94 | //     // expect(
 95 | //     //     result,
 96 | //     //     {
 97 | //     //         successType: 'partial',
 98 | //     //         validData: { age: 42 },
 99 | //     //         invalidData: { name: null },
100 | //     //     }
101 | //     // )
102 | //     // expect(
103 | //     //     result.error?.flatten().fieldErrors ?? {},
104 | //     //     {
105 | //     //         name: [ 'Expected string, received null' ],
106 | //     //     }
107 | //     // )
108 | // } )


--------------------------------------------------------------------------------
/scripts/build.ts:
--------------------------------------------------------------------------------
  1 | import type { BuildConfig, BunPlugin } from 'bun'
  2 | import { EntryPointConfig, generateDtsBundle } from 'dts-bundle-generator'
  3 | import { copyFile, rm } from 'node:fs/promises'
  4 | import * as Path from 'node:path'
  5 | import packageJSON from '../package.json'
  6 | 
  7 | // https://bun.sh/docs/bundler
  8 | // https://github.com/wobsoriano/bun-plugin-dts
  9 | // https://github.com/timocov/dts-bundle-generator
 10 | 
 11 | const logError = ( ctx?: object ) => ( { message }: Error ) => {
 12 |     const data = { message, ...ctx }
 13 |     console.error( 'Error:', JSON.stringify( data, null, 2 ) )
 14 | }
 15 | 
 16 | const root = Path.join( import.meta.dir, '..' )
 17 | const dist = Path.join( root, 'dist' )
 18 | 
 19 | function customDtsPlugin (): BunPlugin {
 20 |     const output: EntryPointConfig[ 'output' ] = { noBanner: true }
 21 |     return {
 22 |         name: 'customDtsPlugin',
 23 |         target: 'node',
 24 |         setup ( build ) {
 25 |             const outDir = build.config.outdir || './dist'
 26 | 
 27 |             build.config.entrypoints
 28 |                 .map( filePath => ( { filePath, output } ) )
 29 |                 .forEach( config => {
 30 |                     const [ output ] = generateDtsBundle( [ config ] )
 31 |                     const dtsFileName = config.filePath
 32 |                         .replace( /^.*\//, '' )
 33 |                         .replace( /\.[jtm]s$/, '.d.ts' )
 34 |                     const outFile = Path.join( outDir, dtsFileName )
 35 |                     return Bun.write( outFile, output )
 36 |                 } )
 37 |         },
 38 |     }
 39 | }
 40 | 
 41 | await Promise.resolve()
 42 |     .then( () => console.log( 'Building...' ) )
 43 |     .then( () =>
 44 |         console.log( {
 45 |             root,
 46 |             dist,
 47 |         } )
 48 |     )
 49 | 
 50 |     .then( async () => {
 51 |         await rm( dist, { recursive: true } )
 52 |             .then( () => console.log( 'dist: deleted' ) )
 53 |             .catch( logError( { dist } ) )
 54 |     } )
 55 | 
 56 |     .then( async () => {
 57 |         const section = 'Bun.build'
 58 |         const config: BuildConfig = {
 59 |             entrypoints: [ './src/index.ts' ],
 60 |             format: 'esm',
 61 |             sourcemap: 'inline',
 62 |             target: 'node',
 63 |             plugins: [
 64 |                 customDtsPlugin()
 65 |             ],
 66 |         }
 67 |         await Bun.build( config )
 68 |             .then( buildResult => Promise.all(
 69 |                 buildResult.outputs.map( res => Bun.write( Path.join( dist, res.path ), res ) )
 70 |             ) )
 71 |             .then( () => console.log( 'Bun.build: ran' ) )
 72 |             .catch( logError( { section, config } ) )
 73 |     } )
 74 | 
 75 |     .then( async () => {
 76 |         const section = 'Reduced package.json: written'
 77 |         const distPath = Path.join( dist, 'package.json' )
 78 |         const { scripts, devDependencies, ...reduced } = packageJSON
 79 | 
 80 |         await Bun.write( distPath, JSON.stringify( reduced, null, 4 ) )
 81 |             .then( () => console.log( section ) )
 82 |             .catch( logError( { section, distPath, reduced } ) )
 83 |     } )
 84 | 
 85 |     .then( async () => {
 86 |         const section = 'Reduced README: written'
 87 |         const srcPath = Path.join( root, 'README.md' )
 88 |         const distPath = Path.join( dist, 'README.md' )
 89 |         const contents = await Bun.file( srcPath ).text()
 90 |         const newContents = contents
 91 |             .split( '<!-- Dist Readme Stops Here -->' )[ 0 ]
 92 |             .trim()
 93 | 
 94 |         await Bun.write( distPath, newContents )
 95 |             .then( () => console.log( section ) )
 96 |             .catch( logError( { section, distPath, contents } ) )
 97 |     } )
 98 | 
 99 |     .then( async () => {
100 |         const section = 'LICENSE'
101 |         const srcPath = Path.join( root, 'LICENSE' )
102 |         const distPath = Path.join( dist, 'LICENSE' )
103 |         await copyFile( srcPath, distPath )
104 |             .then( () => console.log( 'LICENSE: copied' ) )
105 |             .catch( logError( { section, srcPath, distPath } ) )
106 |     } )
107 | 
108 |     .then( () => console.log( 'Build: done' ) )
109 |     .catch( logError( { path: import.meta.path } ) )


--------------------------------------------------------------------------------
/src/coerce.ts:
--------------------------------------------------------------------------------
  1 | import { z } from 'zod'
  2 | 
  3 | // https://developer.mozilla.org/en-US/docs/Glossary/Primitive
  4 | // string
  5 | // number
  6 | // bigint
  7 | // boolean
  8 | // undefined
  9 | // symbol
 10 | // null
 11 | 
 12 | type AllowedZodTypes =
 13 |     | z.ZodAny
 14 |     | z.ZodString
 15 |     | z.ZodNumber
 16 |     | z.ZodBoolean
 17 |     | z.ZodBigInt
 18 |     // | z.ZodDate // TODO
 19 |     | z.ZodArray<z.ZodTypeAny>
 20 | // | z.ZodObject<z.ZodRawShape> // TODO
 21 | 
 22 | /**
 23 |  * Treats coercion errors like normal zod errors. Prevents throwing errors when using `safeParse`.
 24 |  * 
 25 |  * @example
 26 |  * import { zu } from 'zod_utilz'
 27 |  * const bigintSchema = zu.coerce( z.bigint() )
 28 |  * bigintSchema.parse( '42' ) // 42n
 29 |  * bigintSchema.parse( '42n' ) // 42n
 30 |  * zu.SPR( bigintSchema.safeParse( 'foo' ) ).error?.issues[ 0 ].message
 31 |  * // 'Expected bigint, received string'
 32 |  * 
 33 |  * @example
 34 |  * import { zu } from 'zod_utilz'
 35 |  * const booleanSchema = zu.coerce( z.boolean() )
 36 |  * 
 37 |  * // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 38 |  * // only exception to normal boolean coercion rules
 39 |  * booleanSchema.parse( 'false' ) // false
 40 |  * 
 41 |  * // https://developer.mozilla.org/en-US/docs/Glossary/Falsy
 42 |  * // falsy => false
 43 |  * booleanSchema.parse( false ) // false
 44 |  * booleanSchema.parse( 0 ) // false
 45 |  * booleanSchema.parse( -0 ) // false
 46 |  * booleanSchema.parse( 0n ) // false
 47 |  * booleanSchema.parse( '' ) // false
 48 |  * booleanSchema.parse( null ) // false
 49 |  * booleanSchema.parse( undefined ) // false
 50 |  * booleanSchema.parse( NaN ) // false
 51 |  * 
 52 |  * // truthy => true
 53 |  * booleanSchema.parse( 'foo' ) // true
 54 |  * booleanSchema.parse( 42 ) // true
 55 |  * booleanSchema.parse( [] ) // true
 56 |  * booleanSchema.parse( {} ) // true
 57 |  * 
 58 |  * @example
 59 |  * import { zu } from 'zod_utilz'
 60 |  * const numberArraySchema = zu.coerce( z.number().array() )
 61 |  * 
 62 |  * // if the value is not an array, it is coerced to an array with one coerced item
 63 |  * numberArraySchema.parse( 42 ) // [ 42 ]
 64 |  * numberArraySchema.parse( '42' ) // [ 42 ]
 65 |  * 
 66 |  * // if the value is an array, it coerces each item in the array
 67 |  * numberArraySchema.parse( [] ) // []
 68 |  * numberArraySchema.parse( [ '42', 42 ] ) // [ 42, 42 ]
 69 |  * 
 70 |  * zu.SPR( numberArraySchema.safeParse( 'foo' ) ).error?.issues[ 0 ].message
 71 |  * // 'Expected number, received nan'
 72 |  */
 73 | export function coerce<Schema extends AllowedZodTypes> ( schema: Schema ) {
 74 |     return z.any()
 75 |         .transform<z.infer<Schema>>( getTransformer( schema ) )
 76 |         .pipe( schema ) as z.ZodPipeline<z.ZodEffects<z.ZodAny, z.infer<Schema>, any>, Schema>
 77 | }
 78 | 
 79 | function getTransformer<Schema extends AllowedZodTypes> ( schema: Schema ) {
 80 |     if ( schema._def.typeName === 'ZodAny' ) return ( value: any ) => value
 81 |     if ( schema._def.typeName === 'ZodString' ) return toString
 82 |     if ( schema._def.typeName === 'ZodNumber' ) return toNumber
 83 |     if ( schema._def.typeName === 'ZodBoolean' ) return toBoolean
 84 | 
 85 |     if ( schema._def.typeName === 'ZodBigInt' ) return toBigInt
 86 |     if ( schema._def.typeName === 'ZodArray' ) return toArray( schema as z.ZodArray<any> )
 87 | 
 88 |     throw new Error( `${ schema!.constructor.name } is not supported by zu.coerce` )
 89 | }
 90 | 
 91 | function toString ( value: any ): string {
 92 |     if ( typeof value === 'string' ) return value
 93 | 
 94 |     try {
 95 |         const newValue = JSON.stringify( value )
 96 |         if ( newValue == undefined ) throw 'JSON.stringify returned undefined'
 97 |         return newValue
 98 |     } catch ( error ) { }
 99 |     try {
100 |         return String( value )
101 |     } catch ( error ) { }
102 | 
103 |     return value
104 | }
105 | 
106 | function toNumber ( value: any ): number {
107 |     if ( typeof value === 'number' ) return value
108 |     if ( typeof value === 'object' ) return NaN
109 |     if ( value == null ) return NaN
110 | 
111 |     try {
112 |         return Number( value )
113 |     } catch ( error ) { }
114 | 
115 |     return NaN
116 | }
117 | 
118 | function toBigInt ( value: any ): bigint {
119 |     if ( typeof value === 'bigint' ) return value
120 | 
121 |     if ( typeof value === 'string' && value.endsWith( 'n' ) ) {
122 |         try {
123 |             const parsed = BigInt( value.slice( 0, -1 ) )
124 |             if ( value == `${ parsed.toString() }n` ) return parsed
125 |         } catch { }
126 |     }
127 | 
128 |     try { return BigInt( toNumber( value ) ) }
129 |     catch ( error ) { }
130 | 
131 |     return value
132 | }
133 | 
134 | function toBoolean ( value: any ): boolean {
135 |     if ( typeof value === 'boolean' ) return value
136 | 
137 |     try {
138 |         return Boolean( JSON.parse( value ) )
139 |     } catch ( error ) { }
140 |     try {
141 |         return Boolean( value )
142 |     } catch ( error ) { }
143 | 
144 |     return false
145 | }
146 | 
147 | function toArray<Schema extends z.ZodArray<z.ZodTypeAny>> ( schema: Schema ) {
148 |     const itemTransformer = getTransformer( schema._def.type )
149 |     return ( value: z.input<Schema> ): z.output<Schema>[] => {
150 |         if ( Array.isArray( value ) ) return value.map( itemTransformer )
151 |         return [ value ].map( itemTransformer )
152 |     }
153 | }


--------------------------------------------------------------------------------
/src/makeErrorMap.test.ts:
--------------------------------------------------------------------------------
  1 | import { expect, test } from 'bun:test'
  2 | import { z } from 'zod'
  3 | import { zu } from '.'
  4 | 
  5 | const config = {
  6 |     required: ctx => 'required',
  7 |     invalid_type: ctx => 'invalid_type',
  8 |     too_small: ctx => 'too_small',
  9 |     too_big: ctx => 'too_big',
 10 |     invalid_string: ctx => 'invalid_string',
 11 |     not_multiple_of: ctx => 'not_multiple_of',
 12 |     not_finite: ctx => 'not_finite',
 13 |     invalid_enum_value: ctx => 'invalid_enum_value',
 14 |     invalid_union_discriminator: ctx => 'invalid_union_discriminator',
 15 | } satisfies Parameters<typeof zu.makeErrorMap>[ 0 ]
 16 | 
 17 | const errorMap = zu.makeErrorMap( config )
 18 | 
 19 | const errorCtxMock = {
 20 |     data: 'unknown',
 21 |     defaultError: 'Invalid',
 22 |     code: 'invalid_type',
 23 |     expected: 'unknown',
 24 |     received: 'unknown',
 25 |     path: [],
 26 | } satisfies zu.ErrorMapMessageBuilderContext<zu.ErrorCode>
 27 | 
 28 | test( 'z.string( { errorMap } )', () => {
 29 |     const schema = z.string( { errorMap } ).min( 3 ).max( 5 )
 30 | 
 31 |     expect( zu.SPR( schema.safeParse( 'foo' ) ).data ).toBe( 'foo' )
 32 | 
 33 |     expect( zu.SPR( schema.safeParse( undefined ) ).error?.issues[ 0 ].message )
 34 |         .toBe(
 35 |             config.required( {
 36 |                 ...errorCtxMock,
 37 |                 code: 'required',
 38 |                 received: 'undefined',
 39 |             } )
 40 |         )
 41 | 
 42 |     expect( zu.SPR( schema.safeParse( 42 ) ).error?.issues[ 0 ].message )
 43 |         .toBe( config.invalid_type( errorCtxMock ) )
 44 | 
 45 |     expect( zu.SPR( schema.safeParse( [ 'foo' ] ) ).error?.issues[ 0 ].message )
 46 |         .toBe( config.invalid_type( errorCtxMock ) )
 47 | 
 48 |     expect( zu.SPR( schema.safeParse( 'ha' ) ).error?.issues[ 0 ].message )
 49 |         .toBe(
 50 |             config.too_small( {
 51 |                 ...errorCtxMock,
 52 |                 code: 'too_small',
 53 |                 type: 'string',
 54 |                 inclusive: true,
 55 |                 minimum: 3,
 56 |             } )
 57 |         )
 58 | 
 59 |     expect( zu.SPR( schema.safeParse( 'hello world' ) ).error?.issues[ 0 ].message )
 60 |         .toBe(
 61 |             config.too_big( {
 62 |                 ...errorCtxMock,
 63 |                 code: 'too_big',
 64 |                 type: 'string',
 65 |                 inclusive: true,
 66 |                 maximum: 5,
 67 |             } )
 68 |         )
 69 | } )
 70 | 
 71 | test( 'z.number( { errorMap } )', () => {
 72 |     const schema = z.number( { errorMap } ).min( 3 ).max( 5 )
 73 | 
 74 |     expect( zu.SPR( schema.safeParse( 3 ) ).data ).toBe( 3 )
 75 | 
 76 |     expect( zu.SPR( schema.safeParse( undefined ) ).error?.issues[ 0 ].message )
 77 |         .toBe(
 78 |             config.required( {
 79 |                 ...errorCtxMock,
 80 |                 code: 'required',
 81 |                 received: 'undefined',
 82 |             } )
 83 |         )
 84 | 
 85 |     expect( zu.SPR( schema.safeParse( 'foo' ) ).error?.issues[ 0 ].message )
 86 |         .toBe( config.invalid_type( errorCtxMock ) )
 87 | 
 88 |     expect( zu.SPR( schema.safeParse( [ 42 ] ) ).error?.issues[ 0 ].message )
 89 |         .toBe( config.invalid_type( errorCtxMock ) )
 90 | 
 91 |     expect( zu.SPR( schema.safeParse( 2 ) ).error?.issues[ 0 ].message )
 92 |         .toBe(
 93 |             config.too_small( {
 94 |                 ...errorCtxMock,
 95 |                 code: 'too_small',
 96 |                 type: 'number',
 97 |                 inclusive: true,
 98 |                 minimum: 3,
 99 |             } )
100 |         )
101 | 
102 |     expect( zu.SPR( schema.safeParse( 6 ) ).error?.issues[ 0 ].message )
103 |         .toBe(
104 |             config.too_big( {
105 |                 ...errorCtxMock,
106 |                 code: 'too_big',
107 |                 type: 'number',
108 |                 inclusive: true,
109 |                 maximum: 5,
110 |             } )
111 |         )
112 | } )
113 | 
114 | test( `z.enum( [ 'foo', 'bar', 'baz' ], { errorMap } )`, () => {
115 |     const schema = z.enum( [ 'foo', 'bar', 'baz' ], { errorMap } )
116 | 
117 |     expect( zu.SPR( schema.safeParse( 'foo' ) ).data ).toBe( 'foo' )
118 | 
119 |     expect( zu.SPR( schema.safeParse( undefined ) ).error?.issues[ 0 ].message )
120 |         .toBe(
121 |             config.required( {
122 |                 ...errorCtxMock,
123 |                 code: 'required',
124 |                 received: 'undefined',
125 |             } )
126 |         )
127 | 
128 |     expect( zu.SPR( schema.safeParse( 42 ) ).error?.issues[ 0 ].message )
129 |         .toBe( config.invalid_type( errorCtxMock ) )
130 | 
131 |     expect( zu.SPR( schema.safeParse( [ 'foo' ] ) ).error?.issues[ 0 ].message )
132 |         .toBe( config.invalid_type( errorCtxMock ) )
133 | } )
134 | 
135 | test( 'z.date( { errorMap } )', () => {
136 |     const schema = z.date( { errorMap } )
137 | 
138 |     const now = new Date
139 |     expect( zu.SPR( schema.safeParse( now ) ).data ).toMatchObject( now )
140 | 
141 |     expect( zu.SPR( schema.safeParse( undefined ) ).error?.issues[ 0 ].message )
142 |         .toBe(
143 |             config.required( {
144 |                 ...errorCtxMock,
145 |                 code: 'required',
146 |                 received: 'undefined',
147 |             } )
148 |         )
149 | 
150 |     expect( zu.SPR( schema.safeParse( '2023-01-13' ) ).error?.issues[ 0 ].message )
151 |         .toBe( config.invalid_type( errorCtxMock ) )
152 | 
153 |     expect( zu.SPR( schema.safeParse( null ) ).error?.issues[ 0 ].message )
154 |         .toBe( config.invalid_type( errorCtxMock ) )
155 | } )
156 | 
157 | test( 'README Example', () => {
158 |     const config = {
159 |         required: 'Custom required message',
160 |         invalid_type: ( { data } ) => `${ data } is an invalid type`,
161 |         too_big: ( { maximum } ) => `Maximum length is ${ maximum }`,
162 |         invalid_enum_value: ( { data, options } ) =>
163 |             `${ data } is not a valid enum value. Valid options: ${ options?.join( ' | ' ) } `,
164 |     } satisfies Parameters<typeof zu.makeErrorMap>[ 0 ]
165 | 
166 |     const errorMap = zu.makeErrorMap( config )
167 | 
168 |     const maximum = 32
169 |     const stringSchema = z.string( { errorMap } ).max( maximum )
170 | 
171 |     expect( zu.SPR( stringSchema.safeParse( undefined ) ).error?.issues[ 0 ].message )
172 |         .toBe( config.required )
173 | 
174 |     expect( zu.SPR( stringSchema.safeParse( 42 ) ).error?.issues[ 0 ].message )
175 |         .toBe(
176 |             config.invalid_type( {
177 |                 ...errorCtxMock,
178 |                 data: 42
179 |             } )
180 |         )
181 | 
182 |     expect(
183 |         zu.SPR(
184 |             stringSchema.safeParse( 'this string is over the maximum length' )
185 |         ).error?.issues[ 0 ].message
186 |     ).toBe(
187 |         config.too_big( {
188 |             ...errorCtxMock,
189 |             code: 'too_big',
190 |             type: 'string',
191 |             maximum,
192 |             inclusive: true,
193 |         } )
194 |     )
195 | 
196 |     const enumSchema = z.enum( [ 'foo', 'bar' ], { errorMap } )
197 | 
198 |     expect( zu.SPR( enumSchema.safeParse( 'baz' ) ).error?.issues[ 0 ].message )
199 |         .toBe(
200 |             config.invalid_enum_value( {
201 |                 ...errorCtxMock,
202 |                 data: 'baz',
203 |                 code: 'invalid_enum_value',
204 |                 options: enumSchema.options
205 |             } )
206 |         )
207 | } )


--------------------------------------------------------------------------------
/src/useFormLike.test.ts:
--------------------------------------------------------------------------------
  1 | import { expect, test } from 'bun:test'
  2 | import { z } from 'zod'
  3 | import { zu } from '.'
  4 | 
  5 | const schema = z.object( {
  6 |     manyStrings: zu.coerce( z.string().array().min( 1 ) ),
  7 |     manyNumbers: zu.coerce( z.number().array().min( 1 ) ),
  8 |     oneStringInArray: zu.coerce( z.string().array().length( 1 ) ),
  9 |     oneNumberInArray: zu.coerce( z.number().array().length( 1 ) ),
 10 |     stringMin1: z.string().min( 1 ),
 11 |     posNumber: z.number().positive(),
 12 |     range: z.number().min( 0 ).max( 5 ),
 13 |     boolean: z.boolean(),
 14 |     true: z.literal( true ),
 15 |     false: z.literal( false ),
 16 |     null: z.null(),
 17 |     date: z.coerce.date(),
 18 |     plainDate: z.string().refine(
 19 |         value => /\d{4}-\d{2}-\d{2}/.test( value ),
 20 |         value => ( { message: `Invalid plain date: ${ value }` } ),
 21 |     ),
 22 |     tuple: z.tuple( [ z.string(), z.number() ] ),
 23 |     object: z.object( {
 24 |         foo: z.string(),
 25 |         bar: z.number(),
 26 |     } ),
 27 | } )
 28 | 
 29 | const searchParamsSchema = zu.useURLSearchParams( schema )
 30 | 
 31 | test( 'useURLSearchParams happy path', () => {
 32 | 
 33 |     const searchParams = new URLSearchParams( {
 34 |         oneStringInArray: 'Leeeeeeeeeroyyyyyyy Jenkiiiiiins!',
 35 |         oneNumberInArray: '42',
 36 |         boolean: 'true',
 37 |         true: 'true',
 38 |         false: 'false',
 39 |         stringMin1: 'foo',
 40 |         posNumber: '42.42',
 41 |         range: '4',
 42 |         null: 'null',
 43 |         date: '2023-01-01',
 44 |         plainDate: '2023-01-01',
 45 |         tuple: '["foo",42]',
 46 |         object: '{"foo":"foo","bar":42}',
 47 |     } )
 48 | 
 49 |     searchParams.append( 'manyStrings', 'hello' )
 50 |     searchParams.append( 'manyStrings', 'world' )
 51 |     searchParams.append( 'manyNumbers', '123' )
 52 |     searchParams.append( 'manyNumbers', '456' )
 53 | 
 54 |     const result = zu.SPR( searchParamsSchema.safeParse( searchParams ) )
 55 | 
 56 |     expect( result.data ).toMatchObject( {
 57 |         manyStrings: [ 'hello', 'world' ],
 58 |         manyNumbers: [ 123, 456 ],
 59 |         oneStringInArray: [ 'Leeeeeeeeeroyyyyyyy Jenkiiiiiins!' ],
 60 |         oneNumberInArray: [ 42 ],
 61 |         stringMin1: 'foo',
 62 |         posNumber: 42.42,
 63 |         range: 4,
 64 |         boolean: true,
 65 |         true: true,
 66 |         false: false,
 67 |         null: null,
 68 |         date: new Date( '2023-01-01' ),
 69 |         plainDate: '2023-01-01',
 70 |         tuple: [ 'foo', 42 ],
 71 |         object: { foo: 'foo', bar: 42 }
 72 |     } )
 73 | } )
 74 | 
 75 | test( 'useURLSearchParams sad path', () => {
 76 | 
 77 |     const searchParams = new URLSearchParams( {
 78 |         manyStrings: 'hello',
 79 |         manyNumbers: '123',
 80 |         oneStringInArray: 'Leeeeeeeeeroyyyyyyy',
 81 |         oneNumberInArray: 'foo',
 82 |         boolean: 'foo',
 83 |         true: 'foo',
 84 |         false: 'foo',
 85 |         stringMin1: '',
 86 |         posNumber: '-42',
 87 |         range: '6',
 88 |         null: 'undefined',
 89 |         date: '0000-00-00',
 90 |         plainDate: '0000-00-00',
 91 |         tuple: '[42,"foo"]',
 92 |         object: '{"foo":42,"bar":"foo"}',
 93 |     } )
 94 | 
 95 |     searchParams.append( 'oneStringInArray', 'Jenkiiiiiins!' )
 96 | 
 97 |     const result = zu.SPR( searchParamsSchema.safeParse( searchParams ) )
 98 | 
 99 |     expect( result.error?.flatten() ).toMatchObject(
100 |         {
101 |             formErrors: [],
102 |             fieldErrors: {
103 |                 oneStringInArray: [ 'Array must contain exactly 1 element(s)' ],
104 |                 oneNumberInArray: [ 'Expected number, received nan' ],
105 |                 stringMin1: [ 'String must contain at least 1 character(s)' ],
106 |                 posNumber: [ 'Number must be greater than 0' ],
107 |                 range: [ 'Number must be less than or equal to 5' ],
108 |                 boolean: [ 'Expected boolean, received string' ],
109 |                 true: [ 'Invalid literal value, expected true' ],
110 |                 false: [ 'Invalid literal value, expected false' ],
111 |                 null: [ 'Expected null, received string' ],
112 |                 date: [ 'Invalid date' ],
113 |                 tuple: [ 'Expected string, received number', 'Expected number, received string' ],
114 |                 object: [ 'Expected string, received number', 'Expected number, received string' ]
115 |             }
116 |         } as any
117 |     )
118 | } )
119 | 
120 | test( 'passthrough', () => {
121 |     const objSchema = z.object( {
122 |         string: z.string(),
123 |         number: z.number(),
124 |         boolean: z.boolean(),
125 |     } ).passthrough()
126 | 
127 |     const schema = zu.useURLSearchParams( objSchema )
128 | 
129 |     expect(
130 |         zu.SPR( schema.safeParse(
131 |             new URLSearchParams( {
132 |                 string: 'foo',
133 |                 number: '42',
134 |                 boolean: 'false',
135 |                 extraKey: 'extraValue',
136 |             } )
137 |         ) ).data
138 |     ).toMatchObject(
139 |         {
140 |             string: 'foo',
141 |             number: 42,
142 |             boolean: false,
143 |             extraKey: 'extraValue'
144 |         } as any
145 |     )
146 | } )
147 | 
148 | test( 'strict', () => {
149 |     const objSchema = z.object( {} ).strict()
150 |     const schema = zu.useURLSearchParams( objSchema )
151 |     expect(
152 |         zu.SPR( schema.safeParse(
153 |             new URLSearchParams( {
154 |                 extraKey: 'extraValue',
155 |             } )
156 |         ) ).error?.flatten().formErrors
157 |     ).toMatchObject(
158 |         [ "Unrecognized key(s) in object: 'extraKey'" ]
159 |     )
160 | }
161 | )
162 | 
163 | test( 'README Example', () => {
164 |     const schema = zu.useURLSearchParams(
165 |         z.object( {
166 |             string: z.string(),
167 |             number: z.number(),
168 |             boolean: z.boolean(),
169 |         } )
170 |     )
171 | 
172 |     expect(
173 |         zu.SPR( schema.safeParse(
174 |             new URLSearchParams( {
175 |                 string: 'foo',
176 |                 number: '42',
177 |                 boolean: 'false',
178 |             } )
179 |         ) ).data
180 |     ).toMatchObject(
181 |         { string: 'foo', number: 42, boolean: false }
182 |     )
183 | 
184 |     expect(
185 |         zu.SPR( schema.safeParse(
186 |             new URLSearchParams( {
187 |                 string: '42',
188 |                 number: 'false',
189 |                 boolean: 'foo',
190 |             } )
191 |         ) ).error?.flatten().fieldErrors
192 |     ).toMatchObject(
193 |         {
194 |             string: [ 'Expected string, received number' ],
195 |             number: [ 'Expected number, received boolean' ],
196 |             boolean: [ 'Expected boolean, received string' ],
197 |         } as any
198 |     )
199 | } )
200 | 
201 | test( 'README Example', () => {
202 |     const schema = zu.useFormData(
203 |         z.object( {
204 |             string: z.string(),
205 |             number: z.number(),
206 |             boolean: z.boolean(),
207 |             file: z.instanceof( File ),
208 |         } )
209 |     )
210 | 
211 |     {
212 |         const file = new File( [], 'filename.ext' )
213 |         const formData = new FormData()
214 |         formData.append( 'string', 'foo' )
215 |         formData.append( 'number', '42' )
216 |         formData.append( 'boolean', 'false' )
217 |         formData.append( 'file', file )
218 | 
219 |         expect(
220 |             zu.SPR( schema.safeParse( formData ) ).data
221 |         ).toMatchObject(
222 |             { string: 'foo', number: 42, boolean: false, file }
223 |         )
224 |     }
225 | 
226 |     {
227 |         const formData = new FormData()
228 |         formData.append( 'string', '42' )
229 |         formData.append( 'number', 'false' )
230 |         formData.append( 'boolean', 'foo' )
231 |         formData.append( 'file', 'filename.ext' )
232 | 
233 |         expect(
234 |             zu.SPR( schema.safeParse( formData ) ).error?.flatten().fieldErrors
235 |         ).toMatchObject(
236 |             {
237 |                 string: [ 'Expected string, received number' ],
238 |                 number: [ 'Expected number, received boolean' ],
239 |                 boolean: [ 'Expected boolean, received string' ],
240 |                 file: [ 'Input not instance of File' ],
241 |             } as any
242 |         )
243 |     }
244 | } )


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <div align='center'>
  2 |     <img src='logo.svg' width='200px' alt='Zod Utilz logo' />
  3 |     <h1>Zod Utilz</h1>
  4 |     <h3>
  5 |         Framework agnostic utilities for
  6 |         <a href='https://github.com/colinhacks/zod' rel='nofollow'>
  7 |             Zod
  8 |         </a>
  9 |     </h3>
 10 | </div>
 11 | 
 12 | <div align='center'>
 13 |     <a href='https://github.com/JacobWeisenburger' rel='nofollow'>
 14 |         <img alt='Created by Jacob Weisenburger'
 15 |             src='https://img.shields.io/badge/created%20by-Jacob%20Weisenburger-274D82.svg'>
 16 |     </a>
 17 |     <a href='https://github.com/JacobWeisenburger/zod_utilz/stargazers' rel='nofollow'>
 18 |         <img alt='stars' src='https://img.shields.io/github/stars/weis-guys/result?color=blue'>
 19 |     </a>
 20 | </div>
 21 | 
 22 | <div align='center'>
 23 |     <a href='https://www.npmjs.com/package/zod_utilz' rel='nofollow'>
 24 |         <img alt='npm' src='https://img.shields.io/npm/v/zod_utilz?color=blue'>
 25 |     </a>
 26 |     <a href='https://www.npmjs.com/package/zod_utilz' rel='nofollow'>
 27 |         <img alt='downloads' src='https://img.shields.io/npm/dw/zod_utilz?color=blue'>
 28 |     </a>
 29 | </div>
 30 | 
 31 | <div align="center">
 32 |     <a href="https://github.com/JacobWeisenburger/zod_utilz#zod-utilz">Docs</a>
 33 |     <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
 34 |     <a href="https://github.com/JacobWeisenburger/zod_utilz">github</a>
 35 |     <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
 36 |     <a href="https://www.npmjs.com/package/zod_utilz">npm</a>
 37 | </div>
 38 | 
 39 | <!-- Dist Readme Stops Here -->
 40 | 
 41 | <br />
 42 | 
 43 | ## Table of contents
 44 | - [Purpose](#purpose)
 45 | - [Contribute](#contribute)
 46 | - [Yet another library](#yet-another-library)
 47 | - [Installation](#installation)
 48 |     - [From npm (Node/Bun)](#from-npm-nodebun)
 49 | - [Getting Started](#getting-started)
 50 |     - [import](#import)
 51 | - [Utilz](#utilz)
 52 |     - [SPR (SafeParseResult)](#spr)
 53 |     - [makeErrorMap](#makeerrormap)
 54 |     - [useTypedParsers](#usetypedparsers)
 55 |     - [coerce](#coerce)
 56 |     - [useURLSearchParams](#useurlsearchparams)
 57 |     - [useFormData](#useformdata)
 58 |     - [partialSafeParse](#partialsafeparse)
 59 |     - [json](#json)
 60 |     - [stringToJSON](#stringtojson)
 61 | - [TODO](#todo)
 62 | 
 63 | ## Purpose
 64 | - Simplify common tasks in [Zod](https://github.com/colinhacks/zod)
 65 | - Fill the gap of features that might be missing in [Zod](https://github.com/colinhacks/zod)
 66 | - Provide implementations for potential new features in [Zod](https://github.com/colinhacks/zod)
 67 | 
 68 | ## Contribute
 69 | Always open to ideas. Positive or negative, all are welcome. Feel free to contribute an [issue](https://github.com/JacobWeisenburger/zod_utilz/issues) or [PR](https://github.com/JacobWeisenburger/zod_utilz/pulls).
 70 | 
 71 | ## Yet another library
 72 | You might not want to install yet another library only to get access to that one [Util](#utilz) you need. No worries. Feel free to copy and paste the code you need into your project. It won't get updated when this library gets updated, but it will reduce your bundle size. :D
 73 | 
 74 | Perhaps in the future there will be a way to install only the [Utilz](#utilz) you need. If you know how to do this, please [let me know](https://github.com/JacobWeisenburger/zod_utilz/issues).
 75 | 
 76 | ## Installation
 77 | 
 78 | ### From npm (Node/Bun)
 79 | ```sh
 80 | npm install zod_utilz
 81 | yarn add zod_utilz
 82 | pnpm add zod_utilz
 83 | bun add zod_utilz
 84 | ```
 85 | 
 86 | ## Getting Started
 87 | 
 88 | ### import
 89 | #### [Node/Bun](https://www.npmjs.com/package/zod_utilz)
 90 | ```ts
 91 | import { zu } from 'zod_utilz'
 92 | ```
 93 | 
 94 | #### [Deno](https://deno.land/x/zod_utilz)
 95 | ```ts
 96 | import { zu } from 'npm:zod_utilz'
 97 | ```
 98 | 
 99 | ## Utilz
100 | 
101 | ### SPR
102 | SPR stands for SafeParseResult
103 | 
104 | This enables [optional chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining) or [nullish coalescing](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing) for `z.SafeParseReturnType`.
105 | 
106 | ```ts
107 | import { zu } from 'zod_utilz'
108 | const schema = z.object( { foo: z.string() } )
109 | const result = zu.SPR( schema.safeParse( { foo: 42 } ) )
110 | const fooDataOrErrors = result.data?.foo ?? result.error?.format().foo?._errors
111 | ```
112 | 
113 | ### makeErrorMap
114 | Simplifies the process of making a `ZodErrorMap`
115 | ```ts
116 | import { zu } from 'zod_utilz'
117 | 
118 | const errorMap = zu.makeErrorMap( {
119 |     required: 'Custom required message',
120 |     invalid_type: ( { data } ) => `${ data } is an invalid type`,
121 |     too_big: ( { maximum } ) => `Maximum length is ${ maximum }`,
122 |     invalid_enum_value: ( { data, options } ) =>
123 |         `${ data } is not a valid enum value. Valid options: ${ options?.join( ' | ' ) } `,
124 | } )
125 | 
126 | const stringSchema = z.string( { errorMap } ).max( 32 )
127 | 
128 | zu.SPR( stringSchema.safeParse( undefined ) ).error?.issues[ 0 ].message
129 | // Custom required message
130 | 
131 | zu.SPR( stringSchema.safeParse( 42 ) ).error?.issues[ 0 ].message
132 | // 42 is an invalid type
133 | 
134 | zu.SPR( stringSchema.safeParse( 'this string is over the maximum length' ) ).error?.issues[ 0 ].message
135 | // Maximum length is 32
136 | 
137 | const enumSchema = z.enum( [ 'foo', 'bar' ], { errorMap } )
138 | 
139 | zu.SPR( enumSchema.safeParse( 'baz' ) ).error?.issues[ 0 ].message
140 | // baz is not a valid enum value. Valid options: foo | bar
141 | ```
142 | 
143 | ### useTypedParsers
144 | Enables compile time type checking for zod parsers.
145 | ```ts
146 | import { zu } from 'zod_utilz'
147 | const schemaWithTypedParsers = zu.useTypedParsers( z.literal( 'foo' ) )
148 | 
149 | schemaWithTypedParsers.parse( 'foo' )
150 | // no ts errors
151 | 
152 | schemaWithTypedParsers.parse( 'bar' )
153 | //                            ^^^^^
154 | // Argument of type '"bar"' is not assignable to parameter of type '"foo"'
155 | ```
156 | 
157 | ### coerce
158 | Coercion that treats errors like normal zod errors. Prevents throwing errors when using `safeParse`.
159 | 
160 | #### z.bigint()
161 | ```ts
162 | import { zu } from 'zod_utilz'
163 | const bigintSchema = zu.coerce( z.bigint() )
164 | bigintSchema.parse( '42' ) // 42n
165 | bigintSchema.parse( '42n' ) // 42n
166 | zu.SPR( bigintSchema.safeParse( 'foo' ) ).error?.issues[ 0 ].message
167 | // 'Expected bigint, received string'
168 | ```
169 | 
170 | #### z.boolean()
171 | ```ts
172 | import { zu } from 'zod_utilz'
173 | const booleanSchema = zu.coerce( z.boolean() )
174 | 
175 | // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean
176 | // only exception to normal boolean coercion rules
177 | booleanSchema.parse( 'false' ) // false
178 | 
179 | // https://developer.mozilla.org/en-US/docs/Glossary/Falsy
180 | // falsy => false
181 | booleanSchema.parse( false ) // false
182 | booleanSchema.parse( 0 ) // false
183 | booleanSchema.parse( -0 ) // false
184 | booleanSchema.parse( 0n ) // false
185 | booleanSchema.parse( '' ) // false
186 | booleanSchema.parse( null ) // false
187 | booleanSchema.parse( undefined ) // false
188 | booleanSchema.parse( NaN ) // false
189 | 
190 | // truthy => true
191 | booleanSchema.parse( 'foo' ) // true
192 | booleanSchema.parse( 42 ) // true
193 | booleanSchema.parse( [] ) // true
194 | booleanSchema.parse( {} ) // true
195 | ```
196 | 
197 | #### z.number().array()
198 | ```ts
199 | import { zu } from 'zod_utilz'
200 | const numberArraySchema = zu.coerce( z.number().array() )
201 | 
202 | // if the value is not an array, it is coerced to an array with one coerced item
203 | numberArraySchema.parse( 42 ) // [ 42 ]
204 | numberArraySchema.parse( '42' ) // [ 42 ]
205 | 
206 | // if the value is an array, it coerces each item in the array
207 | numberArraySchema.parse( [] ) // []
208 | numberArraySchema.parse( [ '42', 42 ] ) // [ 42, 42 ]
209 | 
210 | zu.SPR( numberArraySchema.safeParse( 'foo' ) ).error?.issues[ 0 ].message
211 | // 'Expected number, received nan'
212 | ```
213 | 
214 | ### useURLSearchParams
215 | A way to parse URLSearchParams
216 | ```ts
217 | import { zu } from 'zod_utilz'
218 | const schema = zu.useURLSearchParams(
219 |     z.object( {
220 |         string: z.string(),
221 |         number: z.number(),
222 |         boolean: z.boolean(),
223 |     } )
224 | )
225 | 
226 | zu.SPR( schema.safeParse(
227 |     new URLSearchParams( {
228 |         string: 'foo',
229 |         number: '42',
230 |         boolean: 'false',
231 |     } )
232 | ) ).data
233 | // { string: 'foo', number: 42, boolean: false }
234 | 
235 | zu.SPR( schema.safeParse(
236 |     new URLSearchParams( {
237 |         string: '42',
238 |         number: 'false',
239 |         boolean: 'foo',
240 |     } )
241 | ) ).error?.flatten().fieldErrors
242 | // {
243 | //     string: [ 'Expected string, received number' ],
244 | //     number: [ 'Expected number, received boolean' ],
245 | //     boolean: [ 'Expected boolean, received string' ],
246 | // }
247 | ```
248 | 
249 | ### useFormData
250 | A way to parse FormData
251 | ```ts
252 | import { zu } from 'zod_utilz'
253 | const schema = zu.useFormData(
254 |     z.object( {
255 |         string: z.string(),
256 |         number: z.number(),
257 |         boolean: z.boolean(),
258 |         file: z.instanceof( File ),
259 |     } )
260 | )
261 | ```
262 | ```ts
263 | const formData = new FormData()
264 | formData.append( 'string', 'foo' )
265 | formData.append( 'number', '42' )
266 | formData.append( 'boolean', 'false' )
267 | formData.append( 'file', new File( [], 'filename.ext' ) )
268 | 
269 | zu.SPR( schema.safeParse( formData ) ).data,
270 | // { string: 'foo', number: 42, boolean: false, file: File }
271 | ```
272 | ```ts
273 | const formData = new FormData()
274 | formData.append( 'string', '42' )
275 | formData.append( 'number', 'false' )
276 | formData.append( 'boolean', 'foo' )
277 | formData.append( 'file', 'filename.ext' )
278 | 
279 | zu.SPR( schema.safeParse( formData ) ).error?.flatten().fieldErrors,
280 | // {
281 | //     string: [ 'Expected string, received number' ],
282 | //     number: [ 'Expected number, received boolean' ],
283 | //     boolean: [ 'Expected boolean, received string' ],
284 | //     file: [ 'Input not instance of File' ],
285 | // }
286 | ```
287 | 
288 | ### partialSafeParse
289 | partialSafeParse allows you to get the valid fields even if there was an error in another field
290 | ```ts
291 | import { zu } from 'zod_utilz'
292 | const userSchema = z.object( { name: z.string(), age: z.number() } )
293 | const result = zu.partialSafeParse( userSchema, { name: null, age: 42 } )
294 | // {
295 | //     successType: 'partial',
296 | //     validData: { age: 42 },
297 | //     invalidData: { name: null },
298 | // }
299 | result.error?.flatten().fieldErrors
300 | // { name: [ 'Expected string, received null' ] }
301 | ```
302 | 
303 | ### json
304 | zu.json() is a schema that validates that a JavaScript object is JSON-compatible. This includes `string`, `number`, `boolean`, and `null`, plus `Array`s and `Object`s containing JSON-compatible types as values
305 | ```ts
306 | import { zu } from 'zod_utilz'
307 | const schema = zu.json()
308 | schema.parse( false ) // false
309 | schema.parse( 8675309 ) // 8675309
310 | schema.parse( { a: 'deeply', nested: [ 'JSON', 'object' ] } )
311 | // { a: 'deeply', nested: [ 'JSON', 'object' ] }
312 | ```
313 | 
314 | ### stringToJSON
315 | zu.stringToJSON() is a schema that validates JSON encoded as a string, then returns the parsed value
316 | ```ts
317 | import { zu } from 'zod_utilz'
318 | const schema = zu.stringToJSON()
319 | schema.parse( 'true' ) // true
320 | schema.parse( 'null' ) // null
321 | schema.parse( '["one", "two", "three"]' ) // ['one', 'two', 'three']
322 | schema.parse( '<html>not a JSON string</html>' ) // throws
323 | ```
324 | 
325 | ## TODO
326 | Always open to ideas. Positive or negative, all are welcome. Feel free to contribute an [issue](https://github.com/JacobWeisenburger/zod_utilz/issues) or [PR](https://github.com/JacobWeisenburger/zod_utilz/pulls).
327 | - tests for `lib/mapValues`
328 | - Shrink Bundle Size
329 |     - tree-shaking deps
330 |         - lodash
331 | - zu.coerce
332 |     - z.date()
333 |     - z.object()
334 |         - recursively coerce props
335 |         - https://github.com/colinhacks/zod/discussions/1910
336 | - enum pick/omit
337 |     - https://github.com/colinhacks/zod/discussions/1922
338 | - BaseType (Recursively get the base type of a Zod type)
339 |   - zu.baseType( z.string() ) => z.string()
340 |   - zu.baseType( z.string().optional() ) => z.string()
341 |   - zu.baseType( z.string().optional().refine() ) => z.string()
342 |   - zu.baseType( z.string().array().optional().refine() ) => z.string().array()
343 | - Make process for minifying
344 | - GitHub Actions
345 |     - Auto publish to npm


--------------------------------------------------------------------------------
/src/coerce.test.ts:
--------------------------------------------------------------------------------
  1 | import { expect, test } from 'bun:test'
  2 | import { z } from 'zod'
  3 | import { zu } from '.'
  4 | 
  5 | test( 'coerce( z.string() )', () => {
  6 |     const schema = zu.coerce( z.string() )
  7 | 
  8 |     /* primitives */
  9 |     expect( schema.parse( 'foo' ) ).toBe( 'foo' )
 10 |     expect( schema.parse( 42 ) ).toBe( '42' )
 11 |     expect( schema.parse( 42n ) ).toBe( '42' )
 12 |     expect( schema.parse( true ) ).toBe( 'true' )
 13 |     expect( schema.parse( false ) ).toBe( 'false' )
 14 |     expect( schema.parse( undefined ) ).toBe( 'undefined' )
 15 |     expect( schema.parse( Symbol( 'symbol' ) ) ).toBe( 'Symbol(symbol)' )
 16 |     expect( schema.parse( null ) ).toBe( 'null' )
 17 | 
 18 |     /* objects */
 19 |     expect( schema.parse( {} ) ).toBe( '{}' )
 20 |     expect( schema.parse( { foo: 'foo' } ) ).toBe( '{"foo":"foo"}' )
 21 |     expect( schema.parse( { foo: 'foo', bar: 'bar' } ) ).toBe( '{"foo":"foo","bar":"bar"}' )
 22 |     expect( schema.parse( [] ) ).toBe( '[]' )
 23 |     expect( schema.parse( [ 'foo' ] ) ).toBe( '["foo"]' )
 24 |     expect( schema.parse( [ 'foo', 'bar' ] ) ).toBe( '["foo","bar"]' )
 25 |     expect( schema.parse( () => { } ) ).toBeTruthy()
 26 |     expect( schema.parse( ( arg: any ) => { } ) ).toBeTruthy()
 27 |     expect( schema.parse( ( arg1: any, arg2: any ) => { } ) ).toBeTruthy()
 28 | } )
 29 | 
 30 | test( 'coerce( z.number() )', () => {
 31 |     const schema = zu.coerce( z.number() )
 32 | 
 33 |     /* primitives */
 34 |     expect( () => schema.parse( 'foo' ) ).toThrow()
 35 |     expect( schema.parse( '42' ) ).toBe( 42 )
 36 |     expect( schema.parse( 42 ) ).toBe( 42 )
 37 |     expect( schema.parse( 42n ) ).toBe( 42 )
 38 |     expect( schema.parse( true ) ).toBe( 1 )
 39 |     expect( schema.parse( false ) ).toBe( 0 )
 40 |     expect( () => schema.parse( undefined ) ).toThrow()
 41 |     expect( () => schema.parse( Symbol( 'symbol' ) ) ).toThrow()
 42 |     expect( () => schema.parse( null ) ).toThrow()
 43 | 
 44 |     /* objects */
 45 |     expect( () => schema.parse( {} ) ).toThrow()
 46 |     expect( () => schema.parse( { foo: 'foo' } ) ).toThrow()
 47 |     expect( () => schema.parse( { foo: 'foo', bar: 'bar' } ) ).toThrow()
 48 |     expect( () => schema.parse( [] ) ).toThrow()
 49 |     expect( () => schema.parse( [ 'foo' ] ) ).toThrow()
 50 |     expect( () => schema.parse( [ 'foo', 'bar' ] ) ).toThrow()
 51 |     expect( () => schema.parse( () => { } ) ).toThrow()
 52 |     expect( () => schema.parse( ( arg: any ) => { } ) ).toThrow()
 53 |     expect( () => schema.parse( ( arg1: any, arg2: any ) => { } ) ).toThrow()
 54 | } )
 55 | 
 56 | test( 'coerce( z.bigint() )', () => {
 57 |     const schema = zu.coerce( z.bigint() )
 58 | 
 59 |     /* primitives */
 60 |     expect( () => schema.parse( 'foo' ) ).toThrow()
 61 |     expect( schema.parse( '42' ) ).toBe( 42n )
 62 |     expect( schema.parse( '42n' ) ).toBe( 42n )
 63 |     expect( schema.parse( 42 ) ).toBe( 42n )
 64 |     expect( schema.parse( 42n ) ).toBe( 42n )
 65 |     expect( schema.parse( true ) ).toBe( 1n )
 66 |     expect( schema.parse( false ) ).toBe( 0n )
 67 |     expect( () => schema.parse( undefined ) ).toThrow()
 68 |     expect( () => schema.parse( Symbol( 'symbol' ) ) ).toThrow()
 69 |     expect( () => schema.parse( null ) ).toThrow()
 70 | 
 71 |     /* objects */
 72 |     expect( () => schema.parse( {} ) ).toThrow()
 73 |     expect( () => schema.parse( { foo: 'foo' } ) ).toThrow()
 74 |     expect( () => schema.parse( { foo: 'foo', bar: 'bar' } ) ).toThrow()
 75 |     expect( () => schema.parse( [] ) ).toThrow()
 76 |     expect( () => schema.parse( [ 'foo' ] ) ).toThrow()
 77 |     expect( () => schema.parse( [ 'foo', 'bar' ] ) ).toThrow()
 78 |     expect( () => schema.parse( () => { } ) ).toThrow()
 79 |     expect( () => schema.parse( ( arg: any ) => { } ) ).toThrow()
 80 |     expect( () => schema.parse( ( arg1: any, arg2: any ) => { } ) ).toThrow()
 81 | } )
 82 | 
 83 | test( 'coerce( z.boolean() )', () => {
 84 |     const schema = zu.coerce( z.boolean() )
 85 | 
 86 |     /* primitives */
 87 |     expect( schema.parse( 'false' ) ).toBe( false )
 88 |     expect( schema.parse( 'true' ) ).toBe( true )
 89 |     expect( schema.parse( 'foo' ) ).toBe( true )
 90 |     expect( schema.parse( 0 ) ).toBe( false )
 91 |     expect( schema.parse( 42 ) ).toBe( true )
 92 |     expect( schema.parse( 42n ) ).toBe( true )
 93 |     expect( schema.parse( true ) ).toBe( true )
 94 |     expect( schema.parse( false ) ).toBe( false )
 95 |     expect( schema.parse( undefined ) ).toBe( false )
 96 |     expect( schema.parse( Symbol( 'symbol' ) ) ).toBe( true )
 97 |     expect( schema.parse( null ) ).toBe( false )
 98 | 
 99 |     /* objects */
100 |     expect( schema.parse( {} ) ).toBe( true )
101 |     expect( schema.parse( { foo: 'foo' } ) ).toBe( true )
102 |     expect( schema.parse( { foo: 'foo', bar: 'bar' } ) ).toBe( true )
103 |     expect( schema.parse( [] ) ).toBe( true )
104 |     expect( schema.parse( [ 'foo' ] ) ).toBe( true )
105 |     expect( schema.parse( [ 'foo', 'bar' ] ) ).toBe( true )
106 |     expect( schema.parse( () => { } ) ).toBe( true )
107 |     expect( schema.parse( ( arg: any ) => { } ) ).toBe( true )
108 |     expect( schema.parse( ( arg1: any, arg2: any ) => { } ) ).toBe( true )
109 | } )
110 | 
111 | test( 'coerce( z.any().array() )', () => {
112 |     const schema = zu.coerce( z.any().array() )
113 | 
114 |     /* primitives */
115 |     expect( schema.parse( 'foo' ) ).toEqual( [ 'foo' ] )
116 |     expect( schema.parse( 42 ) ).toEqual( [ 42 ] )
117 |     expect( schema.parse( 42n ) ).toEqual( [ 42n ] )
118 |     expect( schema.parse( true ) ).toEqual( [ true ] )
119 |     expect( schema.parse( false ) ).toEqual( [ false ] )
120 |     expect( schema.parse( undefined ) ).toEqual( [ undefined ] )
121 |     expect( schema.parse( null ) ).toEqual( [ null ] )
122 | 
123 |     const symbol = Symbol( 'symbol' )
124 |     expect( schema.parse( symbol ) ).toEqual( [ symbol ] )
125 | 
126 |     /* objects */
127 |     expect( schema.parse( {} ) ).toEqual( [ {} ] )
128 |     expect( schema.parse( { foo: 'foo' } ) ).toEqual( [ { foo: 'foo' } ] )
129 |     expect( schema.parse( { foo: 'foo', bar: 'bar' } ) ).toEqual( [ { foo: 'foo', bar: 'bar' } ] )
130 |     expect( schema.parse( [] ) ).toEqual( [] )
131 |     expect( schema.parse( [ 'foo' ] ) ).toEqual( [ 'foo' ] )
132 |     expect( schema.parse( [ 'foo', 'bar' ] ) ).toEqual( [ 'foo', 'bar' ] )
133 | 
134 |     const fn1 = () => { }
135 |     expect( schema.parse( fn1 ) ).toEqual( [ fn1 ] )
136 | 
137 |     const fn2 = ( arg: any ) => { }
138 |     expect( schema.parse( fn2 ) ).toEqual( [ fn2 ] )
139 | 
140 |     const fn3 = ( arg1: any, arg2: any ) => { }
141 |     expect( schema.parse( fn3 ) ).toEqual( [ fn3 ] )
142 | } )
143 | 
144 | test( 'coerce( z.string().array() )', () => {
145 |     const schema = zu.coerce( z.string().array() )
146 | 
147 |     /* primitives */
148 |     expect( schema.parse( 'foo' ) ).toMatchObject( [ 'foo' ] )
149 |     expect( schema.parse( 42 ) ).toMatchObject( [ '42' ] )
150 |     expect( schema.parse( 42n ) ).toMatchObject( [ '42' ] )
151 |     expect( schema.parse( true ) ).toMatchObject( [ 'true' ] )
152 |     expect( schema.parse( false ) ).toMatchObject( [ 'false' ] )
153 |     expect( schema.parse( undefined ) ).toMatchObject( [ 'undefined' ] )
154 |     expect( schema.parse( null ) ).toMatchObject( [ 'null' ] )
155 | 
156 |     const symbol = Symbol( 'symbol' )
157 |     expect( schema.parse( symbol ) ).toMatchObject( [ symbol.toString() ] )
158 | 
159 |     /* objects */
160 |     expect( schema.parse( {} ) ).toMatchObject( [ '{}' ] )
161 |     expect( schema.parse( { foo: 'foo' } ) ).toMatchObject( [ '{"foo":"foo"}' ] )
162 |     expect( schema.parse( { foo: 'foo', bar: 'bar' } ) ).toMatchObject( [ '{"foo":"foo","bar":"bar"}' ] )
163 |     expect( schema.parse( [] ) ).toMatchObject( [] )
164 |     expect( schema.parse( [ 'foo' ] ) ).toMatchObject( [ 'foo' ] )
165 |     expect( schema.parse( [ 'foo', 'bar' ] ) ).toMatchObject( [ 'foo', 'bar' ] )
166 |     expect( schema.parse( [ 'foo', '42' ] ) ).toMatchObject( [ 'foo', '42' ] )
167 |     expect( schema.parse( [ '42', '42' ] ) ).toMatchObject( [ '42', '42' ] )
168 |     expect( schema.parse( () => { } ) ).toBeTruthy()
169 |     expect( schema.parse( ( arg: any ) => { } ) ).toBeTruthy()
170 |     expect( schema.parse( ( arg1: any, arg2: any ) => { } ) ).toBeTruthy()
171 | } )
172 | 
173 | test( 'coerce( z.number().array() )', () => {
174 |     const schema = zu.coerce( z.number().array() )
175 | 
176 |     /* primitives */
177 |     expect( () => schema.parse( 'foo' ) ).toThrow()
178 |     expect( schema.parse( '42' ) ).toMatchObject( [ 42 ] )
179 |     expect( schema.parse( 42 ) ).toMatchObject( [ 42 ] )
180 |     expect( schema.parse( 42n ) ).toMatchObject( [ 42 ] )
181 |     expect( schema.parse( true ) ).toMatchObject( [ 1 ] )
182 |     expect( schema.parse( false ) ).toMatchObject( [ 0 ] )
183 |     expect( () => schema.parse( undefined ) ).toThrow()
184 |     expect( () => schema.parse( Symbol( 'symbol' ) ) ).toThrow()
185 |     expect( () => schema.parse( null ) ).toThrow()
186 | 
187 |     /* objects */
188 |     expect( () => schema.parse( {} ) ).toThrow()
189 |     expect( () => schema.parse( { foo: 'foo' } ) ).toThrow()
190 |     expect( () => schema.parse( { foo: 'foo', bar: 'bar' } ) ).toThrow()
191 |     expect( schema.parse( [] ) ).toEqual( [] )
192 |     expect( () => schema.parse( [ 'foo' ] ) ).toThrow()
193 |     expect( () => schema.parse( [ 'foo', 'bar' ] ) ).toThrow()
194 |     expect( () => schema.parse( [ 'foo', '42' ] ) ).toThrow()
195 |     expect( schema.parse( [ '42', '42' ] ) ).toEqual( [ 42, 42 ] )
196 |     expect( () => schema.parse( () => { } ) ).toThrow()
197 |     expect( () => schema.parse( ( arg: any ) => { } ) ).toThrow()
198 |     expect( () => schema.parse( ( arg1: any, arg2: any ) => { } ) ).toThrow()
199 | } )
200 | 
201 | test( 'coerce( z.bigint().array() )', () => {
202 |     const schema = zu.coerce( z.bigint().array() )
203 | 
204 |     /* primitives */
205 |     expect( () => schema.parse( 'foo' ) ).toThrow()
206 |     expect( schema.parse( '42' ) ).toMatchObject( [ 42n ] )
207 |     expect( schema.parse( '42n' ) ).toMatchObject( [ 42n ] )
208 |     expect( schema.parse( 42 ) ).toMatchObject( [ 42n ] )
209 |     expect( schema.parse( 42n ) ).toMatchObject( [ 42n ] )
210 |     expect( schema.parse( true ) ).toMatchObject( [ 1n ] )
211 |     expect( schema.parse( false ) ).toMatchObject( [ 0n ] )
212 |     expect( () => schema.parse( undefined ) ).toThrow()
213 |     expect( () => schema.parse( Symbol( 'symbol' ) ) ).toThrow()
214 |     expect( () => schema.parse( null ) ).toThrow()
215 | 
216 |     /* objects */
217 |     expect( () => schema.parse( {} ) ).toThrow()
218 |     expect( () => schema.parse( { foo: 'foo' } ) ).toThrow()
219 |     expect( () => schema.parse( { foo: 'foo', bar: 'bar' } ) ).toThrow()
220 |     expect( schema.parse( [] ) ).toMatchObject( [] )
221 |     expect( () => schema.parse( [ 'foo' ] ) ).toThrow()
222 |     expect( () => schema.parse( [ 'foo', 'bar' ] ) ).toThrow()
223 |     expect( () => schema.parse( [ 'foo', '42' ] ) ).toThrow()
224 |     expect( schema.parse( [ '42', '42' ] ) ).toMatchObject( [ 42n, 42n ] )
225 |     expect( () => schema.parse( () => { } ) ).toThrow()
226 |     expect( () => schema.parse( ( arg: any ) => { } ) ).toThrow()
227 |     expect( () => schema.parse( ( arg1: any, arg2: any ) => { } ) ).toThrow()
228 | } )
229 | 
230 | test( 'coerce( z.boolean().array() )', () => {
231 |     const schema = zu.coerce( z.boolean().array() )
232 | 
233 |     /* primitives */
234 |     expect( schema.parse( 'false' ) ).toMatchObject( [ false ] )
235 |     expect( schema.parse( 'true' ) ).toMatchObject( [ true ] )
236 |     expect( schema.parse( 'foo' ) ).toMatchObject( [ true ] )
237 |     expect( schema.parse( 0 ) ).toMatchObject( [ false ] )
238 |     expect( schema.parse( 42 ) ).toMatchObject( [ true ] )
239 |     expect( schema.parse( 42n ) ).toMatchObject( [ true ] )
240 |     expect( schema.parse( true ) ).toMatchObject( [ true ] )
241 |     expect( schema.parse( false ) ).toMatchObject( [ false ] )
242 |     expect( schema.parse( undefined ) ).toMatchObject( [ false ] )
243 |     expect( schema.parse( Symbol( 'symbol' ) ) ).toMatchObject( [ true ] )
244 |     expect( schema.parse( null ) ).toMatchObject( [ false ] )
245 | 
246 |     /* objects */
247 |     expect( schema.parse( {} ) ).toMatchObject( [ true ] )
248 |     expect( schema.parse( { foo: 'foo' } ) ).toMatchObject( [ true ] )
249 |     expect( schema.parse( { foo: 'foo', bar: 'bar' } ) ).toMatchObject( [ true ] )
250 |     expect( schema.parse( [] ) ).toMatchObject( [] )
251 |     expect( schema.parse( [ 'foo' ] ) ).toMatchObject( [ true ] )
252 |     expect( schema.parse( [ 'foo', 'bar' ] ) ).toMatchObject( [ true, true ] )
253 |     expect( schema.parse( [ 'foo', 'false' ] ) ).toMatchObject( [ true, false ] )
254 |     expect( schema.parse( [ 'false', 'false' ] ) ).toMatchObject( [ false, false ] )
255 |     expect( schema.parse( () => { } ) ).toMatchObject( [ true ] )
256 |     expect( schema.parse( ( arg: any ) => { } ) ).toMatchObject( [ true ] )
257 |     expect( schema.parse( ( arg1: any, arg2: any ) => { } ) ).toMatchObject( [ true ] )
258 | } )
259 | 
260 | test( 'README Example: z.bigint()', () => {
261 |     const bigintSchema = zu.coerce( z.bigint() )
262 |     expect( bigintSchema.parse( '42' ) ).toBe( 42n )
263 |     expect( bigintSchema.parse( '42n' ) ).toBe( 42n )
264 |     expect( zu.SPR( bigintSchema.safeParse( 'foo' ) ).error?.issues[ 0 ].message )
265 |         .toBe( 'Expected bigint, received string' )
266 | } )
267 | 
268 | test( 'README Example: z.boolean()', () => {
269 |     const booleanSchema = zu.coerce( z.boolean() )
270 | 
271 |     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean
272 |     // only exception to normal boolean coercion rules
273 |     expect( booleanSchema.parse( 'false' ) ).toBe( false )
274 | 
275 |     // https://developer.mozilla.org/en-US/docs/Glossary/Falsy
276 |     // falsy => false
277 |     expect( booleanSchema.parse( false ) ).toBe( false )
278 |     expect( booleanSchema.parse( 0 ) ).toBe( false )
279 |     expect( booleanSchema.parse( -0 ) ).toBe( false )
280 |     expect( booleanSchema.parse( 0n ) ).toBe( false )
281 |     expect( booleanSchema.parse( '' ) ).toBe( false )
282 |     expect( booleanSchema.parse( null ) ).toBe( false )
283 |     expect( booleanSchema.parse( undefined ) ).toBe( false )
284 |     expect( booleanSchema.parse( NaN ) ).toBe( false )
285 | 
286 |     // truthy => true
287 |     expect( booleanSchema.parse( 'foo' ) ).toBe( true )
288 |     expect( booleanSchema.parse( 42 ) ).toBe( true )
289 |     expect( booleanSchema.parse( [] ) ).toBe( true )
290 |     expect( booleanSchema.parse( {} ) ).toBe( true )
291 | } )
292 | 
293 | test( 'README Example: z.number().array()', () => {
294 |     const numberArraySchema = zu.coerce( z.number().array() )
295 | 
296 |     // if the value is not an array, it is coerced to an array with one coerced item
297 |     expect( numberArraySchema.parse( 42 ) ).toMatchObject( [ 42 ] )
298 |     expect( numberArraySchema.parse( '42' ) ).toMatchObject( [ 42 ] )
299 | 
300 |     // if the value is an array, it coerces each item in the array
301 |     expect( numberArraySchema.parse( [] ) ).toMatchObject( [] )
302 |     expect( numberArraySchema.parse( [ '42', 42 ] ) ).toMatchObject( [ 42, 42 ] )
303 | 
304 |     expect( zu.SPR( numberArraySchema.safeParse( 'foo' ) ).error?.issues[ 0 ].message )
305 |         .toBe( 'Expected number, received nan' )
306 | } )
307 | 
308 | // TODO
309 | // test( 'README Example: z.date()', () => {
310 | //     const schema = zu.coerce( z.date() )
311 | // } )
312 | 
313 | // TODO
314 | // test( 'README Example: z.object()', () => {
315 | //     const schema = zu.coerce( z.object() )
316 | // } )


--------------------------------------------------------------------------------
/logo.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg width="100%" height="100%" viewBox="0 0 1080 1080" version="1.1" xmlns="http://www.w3.org/2000/svg"
 4 |     xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/"
 5 |     style="fill-rule:evenodd;clip-rule:evenodd;stroke-miterlimit:5;">
 6 | 
 7 |     <use xlink:href="#_Image1" x="112.458" y="229.1" width="867.625px" height="669.651px"
 8 |         transform="matrix(0.999568,0,0,0.999479,0,0)" />
 9 |     <use xlink:href="#_Image2" x="30" y="160" width="1045px" height="842px" />
10 |     <g transform="matrix(1.01688,0,-5.64483e-17,1.01688,-1013.22,-4627.54)">
11 |         <path
12 |             d="M1825.05,4726.89L1250.49,4726.89L1040.57,4935.73L1517.16,5509.64L1555.18,5466.98L2026.94,4937.69L1825.05,4726.89ZM1804.06,4776.06L1960,4938.89L1518.48,5434.26L1107.11,4938.89L1270.78,4776.06L1804.06,4776.06Z"
13 |             style="fill:#3068b7;" />
14 |     </g>
15 |     <defs>
16 |         <image id="_Image1" width="868px" height="670px"
17 |             xlink:href="data:image/png;base64,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" />
18 | 
19 |         <image id="_Image2" width="1045px" height="842px"
20 |             xlink:href="data:image/png;base64,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" />
21 |     </defs>
22 | 
23 |     <svg xmlns="http://www.w3.org/2000/svg" viewBox="-6 -3 55 55">
24 |         <!-- <svg xmlns="http://www.w3.org/2000/svg" viewBox="-8.5 -6 60 60"> -->
25 |         <title>tools</title>
26 | 
27 |         <filter id="shadow">
28 |             <feDropShadow dx=".5" dy=".5" stdDeviation="0" flood-opacity=".5" />
29 |         </filter>
30 | 
31 |         <g filter="url(#shadow)">
32 |             <path
33 |                 d="M23.826,20.454l1.5-1.5a4.335,4.335,0,0,0,3.382-.08.413.413,0,0,0,.121-.668l-2.679-2.679a.833.833,0,0,1,0-1.179l2.676-2.676A.415.415,0,0,0,28.709,11a4.32,4.32,0,0,0-5.83,5.443l-1.534,1.534Z"
34 |                 style="fill:#3068b7aa" stroke="#000000aa" stroke-width=".35" />
35 |             <path
36 |                 d="M29.956,13.068,27.734,15.29a.455.455,0,0,0,0,.643l1.713,1.713a.454.454,0,0,0,.676-.036,4.325,4.325,0,0,0,.571-4.406A.454.454,0,0,0,29.956,13.068Z"
37 |                 style="fill:#3068b7aa" stroke="#000000aa" stroke-width=".35" />
38 |             <path
39 |                 d="M12.94,23.6l2.679,2.679a.833.833,0,0,1,0,1.179l-2.676,2.676a.415.415,0,0,0,.122.672A4.32,4.32,0,0,0,18.9,25.379l1.657-1.657-2.481-2.481L16.46,22.858a4.335,4.335,0,0,0-3.4.074A.413.413,0,0,0,12.94,23.6Z"
40 |                 style="fill:#3068b7aa" stroke="#000000aa" stroke-width=".35" />
41 |             <path
42 |                 d="M11.651,24.235a4.325,4.325,0,0,0-.571,4.406.454.454,0,0,0,.737.136l2.222-2.222a.455.455,0,0,0,0-.643L12.327,24.2A.454.454,0,0,0,11.651,24.235Z"
43 |                 style="fill:#3068b7aa" stroke="#000000aa" stroke-width=".35" />
44 | 
45 |             <path
46 |                 d="M20.952,18.366l-2.079-2.079-2.481,2.481,2.079,2.079,2.481,2.481,7.6,7.6a.556.556,0,0,0,.786,0l1.695-1.695a.556.556,0,0,0,0-.786l-7.6-7.6Z"
47 |                 style="fill:#3068b7aa" stroke="#000000aa" stroke-width=".35" />
48 |             <path
49 |                 d="M12.923,20.488a.681.681,0,0,0,.963,0l.128-.128a.681.681,0,0,0,0-.963l-.257-.257.506-.506-2.376-2.376-.506.506-.257-.257a.681.681,0,0,0-.963,0l-.128.128a.681.681,0,0,0,0,.963Z"
50 |                 style="fill:#3068b7aa" stroke="#000000aa" stroke-width=".35" />
51 |             <path d="M16.6,11.688l2.347,2.347c2.705-1.8,4.218-.291,2.138-2.37C19.645,10.226,17.828,10.906,16.6,11.688Z"
52 |                 style="fill:#3068b7aa" stroke="#000000aa" stroke-width=".35" />
53 |             <path
54 |                 d="M15.877,11.753a.681.681,0,0,0-.963,0l-2.89,2.89a.681.681,0,0,0,0,.963l.257.257,2.376,2.376.257.257a.681.681,0,0,0,.882.069.692.692,0,0,0,.081-.069L16,18.375l2.481-2.481.2-.2.091-.091a.681.681,0,0,0,0-.963l-.28-.28-2.356-2.356Z"
55 |                 style="fill:#3068b7aa" stroke="#000000aa" stroke-width=".35" />
56 |         </g>
57 | 
58 |     </svg>
59 | </svg>


--------------------------------------------------------------------------------