lint

Author: dmonad

schema.js

@@ -146,6 +146,7 @@ export class $ConstructedBy extends $Schema {
     super()
     this.v = c
   }
+
   /**
    * @param {any} o
    * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
@@ -184,7 +185,6 @@ export class $Literal extends $Schema {
   }
 }
 
-
 /**
  * @template {LiteralType[]} T
  * @param {T} literals
@@ -439,7 +439,7 @@ export const string = constructedBy(String)
 /**
  * @type {$Schema<undefined>}
  */
-const undefined_ = literal(void 0)
+const undefined_ = literal(undefined)
 
 /**
  * @type {$Schema<void>}
@@ -451,18 +451,20 @@ const void_ = undefined_
  */
 const null_ = literal(null)
 
-export {null_ as null, void_ as void, undefined_ as undefined, }
+export { null_ as null, void_ as void, undefined_ as undefined }
 
-/* c8 ignore start*/
+/* c8 ignore start */
 /**
  * Assert that a variable is of this specific type.
  * The assertion check is only performed in non-production environments.
  *
  * @type {<T>(o:any,schema:$Schema<T>) => asserts o is T}
  */
-export const assert = env.production ? () => {} : (o, schema) => {
-  if (!schema.check(o)) {
-    throw error.create(`Expected value to be of type ${schema.constructor.name}.`)
-  }
-}
+export const assert = env.production
+  ? () => {}
+  : (o, schema) => {
+      if (!schema.check(o)) {
+        throw error.create(`Expected value to be of type ${schema.constructor.name}.`)
+      }
+    }
 /* c8 ignore end */

schema.test.js

@@ -25,7 +25,7 @@ export const testSchemas = _tc => {
     t.assert(!s.bigint.validate(new Date()))
   })
   t.group('symbol', () => {
-    t.assert(s.symbol.validate(Symbol()))
+    t.assert(s.symbol.validate(Symbol('random symbol')))
     // @ts-expect-error
     t.assert(!s.symbol.validate({}))
     // @ts-expect-error
@@ -45,15 +45,15 @@ export const testSchemas = _tc => {
     const myobject = s.object({
       num: s.number
     })
-    const q = /** @type {number} */ (/** @type {any} */ ({ num: 42, x:9 }))
+    const q = /** @type {number} */ (/** @type {any} */ ({ num: 42, x: 9 }))
     if (myobject.check(q)) {
       s.number.validate(q)
       myobject.validate(q)
     } else {
       // q is a number now
       s.number.validate(q)
     }
-    t.assert(myobject.check({ num: 42, x:9 }))
+    t.assert(myobject.check({ num: 42, x: 9 }))
     // @ts-expect-error
     t.assert(!myobject.validate(undefined))
     // @ts-expect-error
@@ -92,7 +92,7 @@ export const testSchemas = _tc => {
     class BetterString extends String { }
     // @ts-expect-error
     t.assert(!s.string.validate(new BetterString()))
-    t.assert(s.string.validate("hi"))
+    t.assert(s.string.validate('hi'))
     // @ts-expect-error
     t.assert(!s.string.validate(undefined))
     // @ts-expect-error
@@ -111,7 +111,7 @@ export const testSchemas = _tc => {
     {
       const mysimplearray = s.array(s.object({}))
       // @ts-expect-error
-      if (env.production) t.fails(() => t.assert(mysimplearray.ensure({x: 4})))
+      if (env.production) t.fails(() => t.assert(mysimplearray.ensure({ x: 4 })))
       mysimplearray.cast([{}])
     }
   })
@@ -132,7 +132,7 @@ export const testSchemas = _tc => {
     t.assert(!myintersectionNever.validate(42))
     // @ts-expect-error
     t.assert(!myintersectionNever.validate('str'))
-    const myintersection = s.intersect(s.object({a: s.number}), s.object({ b: s.number }))
+    const myintersection = s.intersect(s.object({ a: s.number }), s.object({ b: s.number }))
     t.assert(myintersection.validate({ a: 42, b: 42 }))
     // @ts-expect-error
     t.assert(!myintersection.validate({ a: 42 }))
@@ -208,12 +208,12 @@ export const testSchemas = _tc => {
     $fun.validate(/** @param {number} n */ (n) => n) // expected string result
     const $fun2 = s.lambda(s.number, s.string, s.void)
     t.assert($fun2.validate(() => ''))
-    t.assert($fun2.validate(/** @param {number} n */ (n) => n+''))
+    t.assert($fun2.validate(/** @param {number} n */ (n) => n + ''))
     t.assert($fun2.validate(/** @param {number} n */ (n) => n)) // this works now, because void is the absense of value
     const $fun3 = s.lambda(s.number, s.undefined)
     // @ts-expect-error
     $fun3.validate(/** @param {number} n */ (n) => n) // this doesn't work, because expected the literal undefined.
     // @ts-expect-error
-    t.assert(!$fun3.validate(/** @type {(a: number, b: number) => undefined} */ ((a, b) => undefined))) // too many parameters
+    t.assert(!$fun3.validate(/** @type {(a: number, b: number) => undefined} */ (a, b) => undefined)) // too many parameters
   })
 }