adios Js.Exn

Author: aspeddro

pages/docs/manual/latest/async-await.mdx

@@ -130,15 +130,15 @@ You may use `try / catch` or `switch` to handle exceptions during async executio
 ```res
 // For simulation purposes
 let authenticate = async () => {
-  raise(Js.Exn.raiseRangeError("Authentication failed."))
+  raise(Exn.raiseRangeError("Authentication failed."))
 }
 
 let checkAuth = async () => {
   try {
     await authenticate()
   } catch {
-  | Js.Exn.Error(e) =>
-    switch Js.Exn.message(e) {
+  | Exn.Error(e) =>
+    switch Exn.message(e) {
     | Some(msg) => Console.log("JS error thrown: " ++ msg)
     | None => Console.log("Some other exception has been thrown")
     }
@@ -152,14 +152,14 @@ You may unify error and value handling in a single switch as well:
 
 ```res
 let authenticate = async () => {
-  raise(Js.Exn.raiseRangeError("Authentication failed."))
+  raise(Exn.raiseRangeError("Authentication failed."))
 }
 
 let checkAuth = async () => {
   switch await authenticate() {
   | _ => Console.log("ok")
-  | exception Js.Exn.Error(e) => 
-    switch Js.Exn.message(e) {
+  | exception Exn.Error(e) => 
+    switch Exn.message(e) {
     | Some(msg) => Console.log("JS error thrown: " ++ msg)
     | None => Console.log("Some other exception has been thrown")
     }

pages/docs/manual/latest/exception.mdx

@@ -134,7 +134,7 @@ throw {
 
 ## Catching JS Exceptions
 
-To distinguish between JavaScript exceptions and ReScript exceptions, ReScript namespaces JS exceptions under the `Js.Exn.Error(payload)` variant. To catch an exception thrown from the JS side:
+To distinguish between JavaScript exceptions and ReScript exceptions, ReScript namespaces JS exceptions under the `Exn.Error(payload)` variant. To catch an exception thrown from the JS side:
 
 
 Throw an exception from JS:
@@ -158,25 +158,25 @@ try {
   // call the external method
   someJSFunctionThatThrows()
 } catch {
-| Js.Exn.Error(obj) =>
-  switch Js.Exn.message(obj) {
+| Exn.Error(obj) =>
+  switch Exn.message(obj) {
   | Some(m) => Console.log("Caught a JS exception! Message: " ++ m)
   | None => ()
   }
 }
 ```
 
-The `obj` here is of type `Js.Exn.t`, intentionally opaque to disallow illegal operations. To operate on `obj`, do like the code above by using the standard library's [`Js.Exn`](api/js/exn) module's helpers.
+The `obj` here is of type `Exn.t`, intentionally opaque to disallow illegal operations. To operate on `obj`, do like the code above by using the standard library's [`Exn`](api/js/exn) module's helpers.
 
 ## Raise a JS Exception
 
-`raise(MyException)` raises a ReScript exception. To raise a JavaScript exception (whatever your purpose is), use `Js.Exn.raiseError`:
+`raise(MyException)` raises a ReScript exception. To raise a JavaScript exception (whatever your purpose is), use `Exn.raiseError`:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
 let myTest = () => {
-  Js.Exn.raiseError("Hello!")
+  Exn.raiseError("Hello!")
 }
 ```
 ```js
@@ -257,7 +257,7 @@ try {
 } catch {
 | Not_found => ... // catch a ReScript exception
 | Invalid_argument(_) => ... // catch a second ReScript exception
-| Js.Exn.Error(obj) => ... // catch the JS exception
+| Exn.Error(obj) => ... // catch the JS exception
 }
 ```
 

pages/docs/manual/latest/import-from-export-to-js.mdx

@@ -102,7 +102,7 @@ var studentName = Student;
 <CodeTab labels={["ReScript", "JS Output (Module)"]}>
 ```rescript
 @module({from: "./myJson.json", with: {type_: "json", \"some-exotic-identifier": "someValue"}})
-external myJson: Js.Json.t = "default"
+external myJson: JSON.t = "default"
 
 Console.log(myJson)
 ```
@@ -130,7 +130,7 @@ Also notice `type_`. Since `type` is a reserved keyword in ReScript, you can use
 Leveraging JavaScript's [dynamic `import`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import) to reduce bundle size and lazy load code as needed is easy in ReScript. It's also a little bit more convenient than in regular JavaScript because you don't need to keep track of file paths manually with ReScript's module system.
 
 ### Dynamically Importing Parts of a Module
-Use the `Js.import` function to dynamically import a specific part of a module. Put whatever `let` binding you want to import in there, and you'll get a `promise` back resolving to that specific binding.
+Use the `import` function to dynamically import a specific part of a module. Put whatever `let` binding you want to import in there, and you'll get a `promise` back resolving to that specific binding.
 
 Let's look at an example. Imagine the following file `MathUtils.res`:
 
@@ -145,7 +145,7 @@ Now let's dynamically import the add function in another module, e.g. `App.res`:
 ```rescript
 // App.res
 let main = async () => {
-  let add = await Js.import(MathUtils.add)
+  let add = await import(MathUtils.add)
   let onePlusOne = add(1, 1)
 
   Console.log(onePlusOne)
@@ -164,7 +164,7 @@ async function main() {
 </CodeTab>
 
 ### Dynamically Importing an Entire Module
-The syntax for importing a whole module looks a little different, since we are operating on the module syntax level; instead of using `Js.import`, you may simply `await` the module itself:
+The syntax for importing a whole module looks a little different, since we are operating on the module syntax level; instead of using `import`, you may simply `await` the module itself:
 <CodeTab labels={["ReScript", "JS Output (Module)"]}>
 ```rescript
 // App.res