Assert Js{,Fn}Component arguments are valid

Author: japgolly

core/src/main/scala/japgolly/scalajs/react/component/InspectRaw.scala

@@ -0,0 +1,30 @@
+package japgolly.scalajs.react.component
+
+import scala.annotation.elidable
+import scala.scalajs.js
+import japgolly.scalajs.react.internal.JsUtil
+
+object InspectRaw {
+
+  def isComponent(a: js.Any): Boolean =
+    a match {
+      case _: js.Function => true
+      case _              => false
+    }
+
+  def invalidComponentDesc(a: js.Any): String =
+    a.asInstanceOf[Any] match {
+      case s: String    => '"' + s + "\". Strings are no longer supported; either create a facade or use js.Dynamic. See docs for detail."
+      case o: js.Object => JsUtil.inspectObject(o)
+      case ()           => a.toString
+      case _            => s"$a (type=${js.typeOf(a)})"
+    }
+
+  @elidable(elidable.ASSERTION)
+  @inline
+  def assertIsComponent(aa: => js.Any, name: => String): Unit = {
+    val a = aa
+    assert(isComponent(a), s"Invalid $name: ${invalidComponentDesc(a)}")
+  }
+
+}

core/src/main/scala/japgolly/scalajs/react/component/Js.scala

@@ -7,7 +7,11 @@ import japgolly.scalajs.react.{Callback, Children, CtorType, PropsChildren, vdom
 object Js extends JsBaseComponentTemplate[RAW.ReactClassUntyped] {
 
   def apply[P <: js.Object, C <: Children, S <: js.Object](raw: js.Any)(implicit s: CtorType.Summoner[P, C]): Component[P, S, s.CT] = {
-    assert(raw.isInstanceOf[js.Object], s"Invalid JsComponent: $raw")
+    InspectRaw.assertIsComponent(raw, "JsComponent")
+    force[P, C, S](raw)(s)
+  }
+
+  def force[P <: js.Object, C <: Children, S <: js.Object](raw: js.Any)(implicit s: CtorType.Summoner[P, C]): Component[P, S, s.CT] = {
     val rc = raw.asInstanceOf[RAW.ReactClass[P, S]]
     component[P, C, S](rc)(s)
   }

core/src/main/scala/japgolly/scalajs/react/component/JsFn.scala

@@ -11,7 +11,11 @@ object JsFn extends JsBaseComponentTemplate[RAW.ReactFunctionalComponent] {
   type Mounted                                                 = Unit
 
   def apply[P <: js.Object, C <: Children](raw: js.Any)(implicit s: CtorType.Summoner[P, C]): Component[P, s.CT] = {
-    assert(raw.isInstanceOf[js.Object], s"Invalid JsFnComponent: $raw")
+    InspectRaw.assertIsComponent(raw, "JsFnComponent")
+    force[P, C](raw)(s)
+  }
+
+  def force[P <: js.Object, C <: Children](raw: js.Any)(implicit s: CtorType.Summoner[P, C]): Component[P, s.CT] = {
     val rc = raw.asInstanceOf[RAW.ReactFunctionalComponent]
     componentRoot[P, s.CT, Unmounted[P]](rc, s.pf.rmap(s.summon(rc))(unmountedRoot))(s.pf)
   }

doc/changelog/1.0.0-RC.md

@@ -15,6 +15,7 @@ See https://github.com/japgolly/scalajs-react/blob/v1.0.0-RC1/doc/changelog/1.0.
   * Allow `JsComponent#withRawType` to expose the raw ES6 class
 * Add `WebpackRequire` objects for webpack/scalajs-bundler users
 * Replace all overloaded `Js{,Fn}Component` `.apply` methods with `.apply(js.Any)` which expects a raw value.
+* Provide useful debug info when a `Js{,Fn}Component` is constructed with an invalid value.
 * There's now a Cats module, analogous to the Scalaz module.
 
 #### Migration:

test/src/test/scala/japgolly/scalajs/react/core/JsLikeComponentTest.scala

@@ -0,0 +1,47 @@
+package japgolly.scalajs.react.core
+
+import scala.scalajs.js
+import utest._
+import japgolly.scalajs.react._
+import japgolly.scalajs.react.test.TestUtil._
+
+object JsLikeComponentTest extends TestSuite {
+
+  def RawJs3 = JsComponentPTest.RawComp
+  def RawJs6a = JsComponentEs6PTest.RawComp // nullary ctor
+  def RawJs6b = JsComponentEs6STest.RawComp // unary ctor
+  def RawJsFn = JsFnComponentTest.RawComp
+
+  def assertNoError[A](a: => A): Unit = {
+    a
+    ()
+  }
+
+  val o = js.Dynamic.literal("hello" -> 123)
+
+  override def tests = TestSuite {
+
+    'js {
+      'undefined - expectErrorContaining("undefined")(JsComponent[Null, Children.None, Null](js.undefined))
+      'string - expectErrorContaining("tring")(JsComponent[Null, Children.None, Null]("what"))
+      'num - expectErrorContaining("123")(JsComponent[Null, Children.None, Null](123))
+      'obj - expectErrorContaining("hello")(JsComponent[Null, Children.None, Null](o))
+      // 'fn - expectErrorContaining("a raw JsFnComponent")(JsComponent[Null, Children.None, Null](RawJsFn))
+      'es3 - assertNoError(JsComponent[Null, Children.None, Null](RawJs3))
+      'es60 - assertNoError(JsComponent[Null, Children.None, Null](RawJs6a))
+      'es61 - assertNoError(JsComponent[Null, Children.None, Null](RawJs6b))
+    }
+
+    'jsFn {
+      'undefined - expectErrorContaining("undefined")(JsFnComponent[Null, Children.None](js.undefined))
+      'string - expectErrorContaining("tring")(JsFnComponent[Null, Children.None]("what"))
+      'num - expectErrorContaining("123")(JsFnComponent[Null, Children.None](123))
+      'obj - expectErrorContaining("hello")(JsFnComponent[Null, Children.None](o))
+      'fn - assertNoError(JsFnComponent[Null, Children.None](RawJsFn))
+      // 'es3 - expectErrorContaining("a raw JsComponent")(JsFnComponent[Null, Children.None](RawJs3))
+      // 'es60 - expectErrorContaining("a raw JsComponent")(JsFnComponent[Null, Children.None](RawJs6a))
+      // 'es61 - expectErrorContaining("a raw JsComponent")(JsFnComponent[Null, Children.None](RawJs6b))
+    }
+
+  }
+}

test/src/test/scala/japgolly/scalajs/react/test/TestUtil.scala

@@ -135,5 +135,23 @@ trait TestUtil
 
   def yesItsMounted: Option[Boolean] = Some(true)
   def nopeNotMounted: Option[Boolean] = Some(false)
+
+  def catchError[A](a: => A): Option[Throwable] =
+    try {
+      a
+      None
+    }
+    catch {
+      case t: Throwable => Some(t)
+    }
+
+  def expectError[A](a: => A): Throwable =
+    catchError(a).getOrElse(fail("Error expected but code succeeded."))
+
+  def expectErrorContaining[A](errFrag: String)(a: => A): String = {
+    val err = expectError(a).getMessage
+    assertContains(err, errFrag)
+    err
+  }
 }