Merge remote-tracking branch 'upstream/main' into asyncify

Author: yonihemi

CHANGELOG.md

@@ -1,3 +1,34 @@
+# 0.10.0 (21 January 2021)
+
+This release contains multiple breaking changes in preparation for enabling `async`/`await`, when
+this feature is available in a stable SwiftWasm release. Namely:
+
+* `JSClosure.init(_ body: @escaping ([JSValue]) -> ())` overload is deprecated to simplify type
+checking. Its presence requires explicit type signatures at the place of use. It will be removed
+in a future version of JavaScriptKit.
+* `JSClosure` is no longer a subclass of `JSFunction`. These classes are not related enough to keep
+them in the same class hierarchy.
+As a result, you can no longer call `JSClosure` objects directly from Swift.
+* Introduced `JSOneshotClosure` for closures that are going to be called only once. You don't need
+to manage references to these closures manually, as opposed to `JSClosure`.
+However, they can only be called a single time from the JS side. Subsequent invocation attempts will raise a fatal error on the Swift side.
+* Removed generic parameters on `JSPromise`, now both success and failure values are always assumed
+to be of `JSValue` type. This also significantly simplifies type checking and allows callers to
+fully control type casting if needed.
+
+**Closed issues:**
+
+- DOMKit? ([#21](https://github.com/swiftwasm/JavaScriptKit/issues/21))
+
+**Merged pull requests:**
+
+- Simplify `JSPromise` API ([#115](https://github.com/swiftwasm/JavaScriptKit/pull/115)) via [@kateinoigakukun](https://github.com/kateinoigakukun)
+- Create `FUNDING.yml` ([#117](https://github.com/swiftwasm/JavaScriptKit/pull/117)) via [@MaxDesiatov](https://github.com/MaxDesiatov)
+- Major API change on `JSClosure` ([#113](https://github.com/swiftwasm/JavaScriptKit/pull/113)) via [@kateinoigakukun](https://github.com/kateinoigakukun)
+- Update `package.json` to lockfileVersion 2 ([#114](https://github.com/swiftwasm/JavaScriptKit/pull/114)) via [@kateinoigakukun](https://github.com/kateinoigakukun)
+- Bump `ini` from 1.3.5 to 1.3.8 in `/Example` ([#111](https://github.com/swiftwasm/JavaScriptKit/pull/111)) via [@dependabot[bot]](https://github.com/dependabot[bot])
+- Update doc comment in `JSTypedArray.swift` ([#110](https://github.com/swiftwasm/JavaScriptKit/pull/110)) via [@MaxDesiatov](https://github.com/MaxDesiatov)
+
 # 0.9.0 (27 November 2020)
 
 This release introduces support for catching `JSError` instances in Swift from throwing JavaScript

IntegrationTests/TestSuites/Sources/PrimaryTests/UnitTestUtils.swift

@@ -101,3 +101,32 @@ func expectNotNil<T>(_ value: T?, file: StaticString = #file, line: UInt = #line
         throw MessageError("Expect a non-nil value", file: file, line: line, column: column)
     }
 }
+
+class Expectation {
+    private(set) var isFulfilled: Bool = false
+    private let label: String
+    private let expectedFulfillmentCount: Int
+    private var fulfillmentCount: Int = 0
+
+    init(label: String, expectedFulfillmentCount: Int = 1) {
+        self.label = label
+        self.expectedFulfillmentCount = expectedFulfillmentCount
+    }
+
+    func fulfill() {
+        assert(!isFulfilled, "Too many fulfillment (label: \(label)): expectedFulfillmentCount is \(expectedFulfillmentCount)")
+        fulfillmentCount += 1
+        if fulfillmentCount == expectedFulfillmentCount {
+            isFulfilled = true
+        }
+    }
+
+    static func wait(_ expectations: [Expectation]) {
+        var timer: JSTimer!
+        timer = JSTimer(millisecondsDelay: 5.0, isRepeating: true) {
+            guard expectations.allSatisfy(\.isFulfilled) else { return }
+            assert(timer != nil)
+            timer = nil
+        }
+    }
+}

IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -528,22 +528,80 @@ try test("Timer") {
 }
 
 var timer: JSTimer?
-var promise: JSPromise<(), Never>?
+var expectations: [Expectation] = []
 
 try test("Promise") {
+
+    let p1 = JSPromise.resolve(JSValue.null)
+    let exp1 = Expectation(label: "Promise.then testcase", expectedFulfillmentCount: 4)
+    p1.then { value in
+        try! expectEqual(value, .null)
+        exp1.fulfill()
+        return JSValue.number(1.0)
+    }
+    .then { value in
+        try! expectEqual(value, .number(1.0))
+        exp1.fulfill()
+        return JSPromise.resolve(JSValue.boolean(true))
+    }
+    .then { value in
+        try! expectEqual(value, .boolean(true))
+        exp1.fulfill()
+        return JSValue.undefined
+    }
+    .catch { _ -> JSValue in
+        fatalError("Not fired due to no throw")
+    }
+    .finally { exp1.fulfill() }
+
+    let exp2 = Expectation(label: "Promise.catch testcase", expectedFulfillmentCount: 4)
+    let p2 = JSPromise.reject(JSValue.boolean(false))
+    p2.then { _ -> JSValue in
+        fatalError("Not fired due to no success")
+    }
+    .catch { reason in
+        try! expectEqual(reason, .boolean(false))
+        exp2.fulfill()
+        return JSValue.boolean(true)
+    }
+    .then { value in
+        try! expectEqual(value, .boolean(true))
+        exp2.fulfill()
+        return JSPromise.reject(JSValue.number(2.0))
+    }
+    .catch { reason in
+        try! expectEqual(reason, .number(2.0))
+        exp2.fulfill()
+        return JSValue.undefined
+    }
+    .finally { exp2.fulfill() }
+
+
     let start = JSDate().valueOf()
     let timeoutMilliseconds = 5.0
+    let exp3 = Expectation(label: "Promise and Timer testcae", expectedFulfillmentCount: 2)
 
-    promise = JSPromise { resolve in
+    let p3 = JSPromise { resolve in
         timer = JSTimer(millisecondsDelay: timeoutMilliseconds) {
-            resolve()
+            exp3.fulfill()
+            resolve(.success(.undefined))
         }
     }
 
-    promise!.then {
+    p3.then { _ in
         // verify that at least `timeoutMilliseconds` passed since the timer started
         try! expectEqual(start + timeoutMilliseconds <= JSDate().valueOf(), true)
+        exp3.fulfill()
+        return JSValue.undefined
     }
+
+    let exp4 = Expectation(label: "Promise lifetime")
+    // Ensure that users don't need to manage JSPromise lifetime
+    JSPromise.resolve(JSValue.boolean(true)).then { _ in
+        exp4.fulfill()
+        return JSValue.undefined
+    }
+    expectations += [exp1, exp2, exp3, exp4]
 }
 
 try test("Error") {
@@ -620,3 +678,5 @@ try test("Exception") {
     let errorObject3 = JSError(from: ageError as! JSValue)
     try expectNotNil(errorObject3)
 }
+
+Expectation.wait(expectations)