Method callPromise

valdi/src/valdi/runtime/JavaScript/ValueFunctionWithJSValue.cpp:281–313

}

Value ValueFunctionWithJSValue::callPromise(const Ref<JavaScriptTaskScheduler>& taskScheduler,
                                            const ValueFunctionCallContext& callContext) {
    auto promise = makeShared<ResolvablePromise>();

    taskScheduler->dispatchOnJsThreadAsync(
        getContext(),
        [self = strongSmallRef(this), promise, parameters = captureParameters(callContext)](auto& jsEntry) {
            Value result = self->doJsCall(jsEntry, parameters.data(), parameters.size(), nullptr, false);
            if (!jsEntry.exceptionTracker) {
                promise->fulfill(jsEntry.exceptionTracker.extractError());
                return;
            }

            // When an interruptible callback is skipped (Valdi context destroyed), doJsCall returns
            // undefined. Fulfilling the promise with undefined would cause native unmarshalling to
            // fail (e.g. expected NativeSnapDoc). Reject the promise so the caller can handle it.
            if (result.getType() == ValueType::Undefined && self->_ignoreIfValdiContextIsDestroyed &&
                self->getContext() != nullptr && self->getContext()->isDestroyed()) {
                promise->fulfill(Result<Value>(Error("Valdi context destroyed")));
                return;
            }

            auto nestedPromise = result.getTypedRef<Promise>();
            if (nestedPromise != nullptr) {
                // Flatten one level of promise, since we already returned a promise to the caller
                promise->fulfillWithPromiseResult(nestedPromise);
            } else {
                promise->fulfill(result);
            }
        });

    return Value(promise);
}

std::string_view ValueFunctionWithJSValue::getFunctionType() const {
    return "JSFunction";