Add time for compiling, edge cases, bugs and no matter how awesome it is, I can't see how it ever makes sense outside of a 1 person project.
[1] Yes, classes. As in: You can never misspell an object property and have that mistake make it into production (&c for lots of other types of bugs). Plus, you get automatic refactoring you can actually rely on. Now, your JS devs may not appreciate that, but I suspect that's just because they're inexperienced and/or haven't actually worked in a good[2] statically typed language. There's also the fact that we (as humans) unconsciously try to minimize our own mistakes; "oh well, it was just a typo and we fixed it quickly!" and for most of us mistakes tend to fade quickly from memory... thus leading to a very biased view of one's own development practices which doesn't take into account how many mistakes you really make.
[2] I'm going to do a D. F. Wallace here[3].
[3] ... and say that Scala isn't great as languages go[5], but I'll bet you it's a hell of a lot better than any statically typed language your typical JS devs have any experience with[4]. One particular gripe of mine is that they still permit "null", but that's because of Java compatibility. (Oh, how much better Scala could have been without Java compatibility.)
[4] ... which would obviously colour their perception of the trade-offs between static type checking and "verbosity", "bondage & discipline", etc.
[5] It is good, though.
I think that's enough footnotes for now.
EDIT: Sorry, I lied. Added another footnote. Really doing the DFW thing, but in Reel Time(TM).
[1] My company started out with TS, but after converting about 10% of our app from TS to Scala.JS + scala.js-react we just decided to convert the rest in a mad sprint over a few weeks. It has paid off in spades. We still struggle with the abomination that is CSS and separating styles from components, but it is what it is.
(It seems subtyping and higher-order reasoning just don't mix well. Undecidability abounds, unfortunately. I tend to prefer higher-order reasoning over subtyping.)
I would look at Elm as if it compiles you will not get a runtime error but Elm devs probably are even more scarce then Scala devs.
Scala.js solved all the problems you mention.
* Performance is on par with hand-written JavaScript.
* The compiler and optimizer are incremental so they compile your code in 1-2 seconds for significant codebases.
* Interoperability is as easy as in TypeScript: just use type definitions for external JS libraries and then transparently call them.
It's all explained from the big boxes on the page of https://www.scala-js.org/
Don't let your past experiences give you wrong impression of Scala.js.
The response from the front-end guys was mostly not pretty. Over time I've come to realise the cultures are miles apart. Scala devs really value type systems and FP and all its benefits - the JS guys value very different things. The hotchpotchness of tools and frameworks in that world is actually seen as a plus point, as diverse devs collaborating, as some community thing. I will never understand it.