Upgrade for v0.27.0

3 files changed, 61 insertions, 58 deletions

diff --git a/test/gleam/javascript/array_test.gleam b/test/gleam/javascript/array_test.gleam
index fd609ea..682ba2e 100644
--- a/test/gleam/javascript/array_test.gleam
+++ b/test/gleam/javascript/array_test.gleam
@@ -1,35 +1,35 @@
 import gleam/javascript/array
 
 pub fn to_and_from_list_test() {
-  assert [] =
+  let assert [] =
     []
     |> array.from_list
     |> array.to_list
 
-  assert [1, 2, 3] =
+  let assert [1, 2, 3] =
     [1, 2, 3]
     |> array.from_list
     |> array.to_list
 }
 
 pub fn size_test() {
-  assert 0 =
+  let assert 0 =
     array.from_list([])
     |> array.size
 
-  assert 2 =
+  let assert 2 =
     array.from_list([1, 2])
     |> array.size
 }
 
 pub fn map_test() {
-  assert [] =
+  let assert [] =
     []
     |> array.from_list
     |> array.map(fn(a) { a + 1 })
     |> array.to_list
 
-  assert [2, 3, 4] =
+  let assert [2, 3, 4] =
     [1, 2, 3]
     |> array.from_list
     |> array.map(fn(a) { a + 1 })
@@ -37,56 +37,56 @@ pub fn map_test() {
 }
 
 pub fn fold_test() {
-  assert [] =
+  let assert [] =
     []
     |> array.from_list
     |> array.fold([], fn(a, e) { [e, ..a] })
 
-  assert [4, 3, 2, 1] =
+  let assert [4, 3, 2, 1] =
     [1, 2, 3, 4]
     |> array.from_list
     |> array.fold([], fn(a, e) { [e, ..a] })
 
-  assert [1, 2, 3, 4] =
+  let assert [1, 2, 3, 4] =
     [4, 3, 2, 1]
     |> array.from_list
     |> array.fold([], fn(a, e) { [e, ..a] })
 }
 
 pub fn fold_right_test() {
-  assert [] =
+  let assert [] =
     []
     |> array.from_list
     |> array.fold_right([], fn(a, e) { [e, ..a] })
 
-  assert [1, 2, 3, 4] =
+  let assert [1, 2, 3, 4] =
     [1, 2, 3, 4]
     |> array.from_list
     |> array.fold_right([], fn(a, e) { [e, ..a] })
 
-  assert [4, 3, 2, 1] =
+  let assert [4, 3, 2, 1] =
     [4, 3, 2, 1]
     |> array.from_list
     |> array.fold_right([], fn(a, e) { [e, ..a] })
 }
 
 pub fn index_test() {
-  assert Ok(1) =
+  let assert Ok(1) =
     [1, 2]
     |> array.from_list
     |> array.get(0)
 
-  assert Ok(2) =
+  let assert Ok(2) =
     [1, 2]
     |> array.from_list
     |> array.get(1)
 
-  assert Error(Nil) =
+  let assert Error(Nil) =
     [1, 2]
     |> array.from_list
     |> array.get(2)
 
-  assert Error(Nil) =
+  let assert Error(Nil) =
     [1, 2]
     |> array.from_list
     |> array.get(-1)
diff --git a/test/gleam/javascript/promise_test.gleam b/test/gleam/javascript/promise_test.gleam
index 77c80df..1645d10 100644
--- a/test/gleam/javascript/promise_test.gleam
+++ b/test/gleam/javascript/promise_test.gleam
@@ -9,91 +9,91 @@ pub fn map_does_not_collapse_nested_promise_test() -> Promise(Promise(Int)) {
     // If the `Promise(Promise(Int))` collapsed into `Promise(Int)` (as they
     // do for normal JS promises) then this would fail as the value would be the
     // int value `1`.
-    assert ObjectType = javascript.type_of(value)
+    let assert ObjectType = javascript.type_of(value)
   })
 }
 
 pub fn await_test() -> Promise(Int) {
   promise.resolve(1)
   |> promise.await(fn(a) { promise.resolve(a + 1) })
-  |> promise.tap(fn(a) { assert 2 = a })
+  |> promise.tap(fn(a) { let assert 2 = a })
 }
 
 pub fn await_does_not_collapse_nested_promise_test() -> Promise(Int) {
   promise.resolve(1)
   |> promise.await(promise.resolve)
-  |> promise.tap(fn(value) { assert 1 = value })
+  |> promise.tap(fn(value) { let assert 1 = value })
 }
 
 pub fn map_test() -> Promise(Int) {
   promise.resolve(1)
   |> promise.map(fn(a) { a + 1 })
-  |> promise.tap(fn(a) { assert 2 = a })
+  |> promise.tap(fn(a) { let assert 2 = a })
 }
 
 pub fn tap_test() -> Promise(Int) {
   promise.resolve(1)
   |> promise.tap(fn(a) { a + 1 })
-  |> promise.tap(fn(a) { assert 1 = a })
+  |> promise.tap(fn(a) { let assert 1 = a })
 }
 
 pub fn map_try_ok_ok_test() -> Promise(Result(Int, Int)) {
   promise.resolve(Ok(1))
   |> promise.map_try(fn(a) { Ok(a + 1) })
-  |> promise.tap(fn(a) { assert Ok(2) = a })
+  |> promise.tap(fn(a) { let assert Ok(2) = a })
 }
 
 pub fn map_try_ok_error_test() -> Promise(Result(Int, Int)) {
   promise.resolve(Ok(1))
   |> promise.map_try(fn(a) { Error(a + 1) })
-  |> promise.tap(fn(a) { assert Error(2) = a })
+  |> promise.tap(fn(a) { let assert Error(2) = a })
 }
 
 pub fn map_try_error_test() -> Promise(Result(Int, Int)) {
   promise.resolve(Error(1))
   |> promise.map_try(fn(a) { Ok(a + 1) })
-  |> promise.tap(fn(a) { assert Error(1) = a })
+  |> promise.tap(fn(a) { let assert Error(1) = a })
 }
 
 pub fn try_await_ok_ok_test() -> Promise(Result(Int, Int)) {
   promise.resolve(Ok(1))
   |> promise.try_await(fn(a) { promise.resolve(Ok(a + 1)) })
-  |> promise.tap(fn(a) { assert Ok(2) = a })
+  |> promise.tap(fn(a) { let assert Ok(2) = a })
 }
 
 pub fn try_await_ok_error_test() -> Promise(Result(Int, Int)) {
   promise.resolve(Ok(1))
   |> promise.try_await(fn(a) { promise.resolve(Error(a + 1)) })
-  |> promise.tap(fn(a) { assert Error(2) = a })
+  |> promise.tap(fn(a) { let assert Error(2) = a })
 }
 
 pub fn try_await_error_test() -> Promise(Result(Int, Int)) {
   promise.resolve(Error(1))
   |> promise.try_await(fn(a) { promise.resolve(Ok(a + 1)) })
-  |> promise.tap(fn(a) { assert Error(1) = a })
+  |> promise.tap(fn(a) { let assert Error(1) = a })
 }
 
 pub fn rescue_healthy_test() {
   promise.resolve(1)
   |> promise.rescue(fn(_) { 100 })
-  |> promise.tap(fn(a) { assert 1 = a })
+  |> promise.tap(fn(a) { let assert 1 = a })
 }
 
 pub fn rescue_poisoned_test() {
   promise.resolve(1)
-  |> promise.map(fn(_) { assert 1 = 2 })
+  |> promise.map(fn(_) { let assert 1 = 2 })
   |> promise.rescue(fn(_) { 100 })
-  |> promise.tap(fn(a) { assert 100 = a })
+  |> promise.tap(fn(a) { let assert 100 = a })
 }
 
 pub fn await2_test() {
   promise.await2(promise.resolve(1), promise.resolve(3))
-  |> promise.tap(fn(x) { assert #(1, 3) = x })
+  |> promise.tap(fn(x) { let assert #(1, 3) = x })
 }
 
 pub fn await3_test() {
   promise.await3(promise.resolve(1), promise.resolve(3), promise.resolve(4))
-  |> promise.tap(fn(x) { assert #(1, 3, 4) = x })
+  |> promise.tap(fn(x) { let assert #(1, 3, 4) = x })
 }
 
 pub fn await4_test() {
@@ -103,7 +103,7 @@ pub fn await4_test() {
     promise.resolve(4),
     promise.resolve(6),
   )
-  |> promise.tap(fn(x) { assert #(1, 3, 4, 6) = x })
+  |> promise.tap(fn(x) { let assert #(1, 3, 4, 6) = x })
 }
 
 pub fn await5_test() {
@@ -114,7 +114,7 @@ pub fn await5_test() {
     promise.resolve(6),
     promise.resolve(10),
   )
-  |> promise.tap(fn(x) { assert #(1, 3, 4, 6, 10) = x })
+  |> promise.tap(fn(x) { let assert #(1, 3, 4, 6, 10) = x })
 }
 
 pub fn await6_test() {
@@ -126,7 +126,7 @@ pub fn await6_test() {
     promise.resolve(10),
     promise.resolve(13),
   )
-  |> promise.tap(fn(x) { assert #(1, 3, 4, 6, 10, 13) = x })
+  |> promise.tap(fn(x) { let assert #(1, 3, 4, 6, 10, 13) = x })
 }
 
 pub fn await_array_test() {
@@ -138,7 +138,7 @@ pub fn await_array_test() {
     promise.resolve(10),
     promise.resolve(13),
   ]))
-  |> promise.tap(fn(x) { assert [1, 3, 4, 6, 10, 13] = array.to_list(x) })
+  |> promise.tap(fn(x) { let assert [1, 3, 4, 6, 10, 13] = array.to_list(x) })
 }
 
 pub fn await_list_test() {
@@ -150,5 +150,5 @@ pub fn await_list_test() {
     promise.resolve(10),
     promise.resolve(13),
   ])
-  |> promise.tap(fn(x) { assert [1, 3, 4, 6, 10, 13] = x })
+  |> promise.tap(fn(x) { let assert [1, 3, 4, 6, 10, 13] = x })
 }
diff --git a/test/gleam/javascript_test.gleam b/test/gleam/javascript_test.gleam
index 4b0fc9e..c15186f 100644
--- a/test/gleam/javascript_test.gleam
+++ b/test/gleam/javascript_test.gleam
@@ -1,33 +1,36 @@
 import gleam/javascript.{
-  BooleanType, FunctionType, NumberType, ObjectType, StringType, SymbolType, UndefinedType,
+  BooleanType, FunctionType, NumberType, ObjectType, StringType, SymbolType,
+  UndefinedType,
 }
 
 pub fn type_of_test() {
-  assert UndefinedType = javascript.type_of(Nil)
-  assert NumberType = javascript.type_of(1)
-  assert NumberType = javascript.type_of(1.1)
-  assert BooleanType = javascript.type_of(True)
-  assert BooleanType = javascript.type_of(False)
-  assert StringType = javascript.type_of("ok")
-  assert StringType = javascript.type_of("")
-  assert FunctionType = javascript.type_of(fn() { 1 })
-  assert FunctionType = javascript.type_of(fn(x) { x })
-  assert FunctionType = javascript.type_of(type_of_test)
-  assert FunctionType = javascript.type_of(Ok)
-  assert ObjectType = javascript.type_of(Ok(1))
-  assert ObjectType = javascript.type_of(Error("ok"))
-  assert SymbolType = javascript.type_of(javascript.get_symbol("Gleam"))
+  let assert UndefinedType = javascript.type_of(Nil)
+  let assert NumberType = javascript.type_of(1)
+  let assert NumberType = javascript.type_of(1.1)
+  let assert BooleanType = javascript.type_of(True)
+  let assert BooleanType = javascript.type_of(False)
+  let assert StringType = javascript.type_of("ok")
+  let assert StringType = javascript.type_of("")
+  let assert FunctionType = javascript.type_of(fn() { 1 })
+  let assert FunctionType = javascript.type_of(fn(x) { x })
+  let assert FunctionType = javascript.type_of(type_of_test)
+  let assert FunctionType = javascript.type_of(Ok)
+  let assert ObjectType = javascript.type_of(Ok(1))
+  let assert ObjectType = javascript.type_of(Error("ok"))
+  let assert SymbolType = javascript.type_of(javascript.get_symbol("Gleam"))
 }
 
 pub fn find_symbol_test() {
-  assert True = javascript.get_symbol("Gleam") == javascript.get_symbol("Gleam")
-  assert False = javascript.get_symbol("Gleam") == javascript.get_symbol("Lua")
+  let assert True =
+    javascript.get_symbol("Gleam") == javascript.get_symbol("Gleam")
+  let assert False =
+    javascript.get_symbol("Gleam") == javascript.get_symbol("Lua")
 }
 
 pub fn reference_test() {
   let ref = javascript.make_reference(1)
-  assert 1 = javascript.update_reference(ref, fn(a) { a + 1 })
-  assert 2 = javascript.dereference(ref)
-  assert 2 = javascript.set_reference(ref, 3)
-  assert 3 = javascript.dereference(ref)
+  let assert 1 = javascript.update_reference(ref, fn(a) { a + 1 })
+  let assert 2 = javascript.dereference(ref)
+  let assert 2 = javascript.set_reference(ref, 3)
+  let assert 3 = javascript.dereference(ref)
 }