Allow primitives in objects.

Author: mirek

src/object.test.ts

@@ -8,3 +8,13 @@ test('object', () => {
 test('error', () => {
   expect(() => $.object({ foo: $.string, bar: $.number })(JSON.parse('{"foo":"a","bar":"2"}'))).toThrow('[bar] Expected number, got \'2\'.')
 })
+
+test('primitive', () => {
+  const assert = $.object({
+    foo: 'FOO' as const,
+    bar: 1 as const,
+    baz: true as const
+  })
+  expect(() => assert({ foo: 'FOO', bar: 1, baz: true, xyz: 'yes' })).not.toThrow()
+  expect(() => assert({ foo: 1 })).toThrow('Expected \'foo\' to be \'FOO\', got 1 in { foo: 1 } object.')
+})

src/object.ts

@@ -1,8 +1,8 @@
 import { inspect } from 'util'
-import type { Assert, Asserted } from './prelude.js'
+import type { Assert, Asserted, Primitive } from './prelude.js'
 
 const object =
-  <T extends Record<string, Assert<unknown>>>(kvs: T): Assert<{ [k in keyof T]: Asserted<T[k]> }> =>
+  <T extends Record<string, Primitive | Assert<unknown>>>(kvs: T): Assert<{ [k in keyof T]: Asserted<T[k]> }> =>
     value => {
       if (typeof value !== 'object' || value === null) {
         throw new TypeError(`Expected object, got ${inspect(value)}.`)

src/partial.ts

@@ -1,7 +1,8 @@
-import type { Assert, Asserted } from './prelude.js'
+import { inspect } from 'util'
+import type { Assert, Asserted, Primitive } from './prelude.js'
 
 const partial =
-  <T extends Record<string, Assert<unknown>>>(kvs: T): Assert<{ [k in keyof T]?: Asserted<T[k]> }> =>
+  <T extends Record<string, Primitive | Assert<unknown>>>(kvs: T): Assert<{ [k in keyof T]?: Asserted<T[k]> }> =>
     value => {
       if (typeof value !== 'object' || value == null) {
         throw new TypeError('Expected object.')
@@ -10,7 +11,16 @@ const partial =
         if (typeof (value as Record<string, unknown>)[k] === 'undefined') {
           continue
         }
-        kvs[k]((value as Record<string, unknown>)[k])
+        const v = kvs[k]
+        if (typeof v === 'function') {
+          try {
+            v((value as Record<string, unknown>)[k])
+          } catch (err: unknown) {
+            throw new TypeError(`[${k}] ${err instanceof Error ? err.message : err}`)
+          }
+        } else if (v !== (value as Record<string, unknown>)[k]) {
+          throw new TypeError(`Expected ${inspect(k)} to be ${inspect(v)}, got ${inspect((value as Record<string, unknown>)[k])} in ${inspect(value)} object.`)
+        }
       }
       return value
     }

src/prelude.ts

@@ -10,7 +10,9 @@ export type Assert<R> =
 export type Asserted<A> =
   A extends (value: unknown) => infer U ?
     U :
-    never
+    A extends Primitive ?
+      A :
+      never
 
 export type Awaited<T> =
   T extends PromiseLike<infer U> ?