Wikipedia defines TypeScript as "an open-source programming language developed and maintained by Microsoft". Wikipedia's not perfect. But it's fairly good on these kindsa "basic facts".
And Microsoft's github repo also lists TypeScript as a language.
So, I guess that settles it??
[NOTE: I fully realize that JSX is not inherently tied to React. You can use JSX outside of React. For the purposes of this article, I'll be somewhat haphazardly transposing React & JSX. Technically speaking, it's more accurate to say that React is a framework while JSX is a bundle of additional language constructs that often run in tandem with React. I understand the distinction. But it would be needlessly verbose to try to suss out the differences every time I type "React".]
If you're not using TypeScript, but you're using React, you've no doubt imported a bunch of packages from NPM. If you look "under the covers" at what's happening in those packages, you'll find that a good number of them are written in TypeScript.
To be clear, I'm not trying to claim that, if your "language" transpiles down to another language, that you're not actually writing in a full-fledged language. PHP transpiles down to C. And I haven't heard anyone argue that PHP isn't a "language". There are numerous other examples of this where one language is built right on top of another.
And if we want to get really anal retentive about it, none of us are writing in an "original" language unless we're crafting our code in machine-level byte-code. But it still feels kinda strange to me that we call TypeScript a "language".
When I'm writing React code, you can call React a "language" or a "framework" or a "banana cream pie". Whatever. Makes no difference to me. The only time that it even (sorta) plays in my mind is when I hear the TypeScript Acolytes talking about the Magical Awesomeness of type-certainty.
So imagine this scenario: Let's say that you're cranking out C# code in your awesome C# job and some guy comes over to you and says, "Yeah, you know... All this static typing is really tough for me to deal with. So you know what I did? I created a new library that we can import right into the middle of our C# projects that will somehow make everything dynamically typed."
First, anyone who says that on a C# dev team might be in immediate danger of being terminated. Second, even if this hack isn't run out of the company, I can imagine every C# developer saying, "Why would you possibly want to do that???"
You see, when you're working in a statically-typed language like Java or C#, the static typing isn't a bug. It's not something to be washed out of your code. It's a feature. There are some times when static typing can feel like a hurdle to be cleared. Occasionally, it's oh-so-tempting to think, "Mann... I really wish that I could just change the type of this variable right here on the fly." But any C# developer worth his salt will tell you that such minor inconveniences aren't a flaw in the language - they're a strength.
To this imaginary revolutionary, I'd most likely say, "It sounds like you need to get a different job where you'll be allowed to write code in a dynamically-typed language." I wouldn't say it in a mean or snarky way. I'd just say it as a matter-of-fact observation. Because if you're working in a language that's built on Core Principle X, and you don't like Core Principle X, the answer is not to rework the entire language so that it no longer uses Core Principle X.
Here's why I sometimes obsess about the question of: Is TypeScript really a language? Because, if TypeScript is truly its own language, and one of the Core Principles of that language is that it uses strong typing (not static typing), then I'd say, "OK, sure. Whatever. If you desire strong typing, and you've chosen a language built upon a Core Principle of strong typing, then... sure. I get that."
But I suppose the dichotomy makes sense if we all accept that TypeScript is a full-fledged language in its own right. Because every language will have its own set of Core Principles. And if strong typing is a Core Principle of the TypeScript language, then... so be it.
I don't know. It's probably a pointless distinction...