ladybird/Userland/Libraries/LibWeb/WebIDL/Promise.cpp

/*
 * Copyright (c) 2022-2023, Linus Groh <linusg@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <AK/Function.h>
#include <AK/TypeCasts.h>
#include <LibJS/Heap/HeapFunction.h>
#include <LibJS/Runtime/PromiseCapability.h>
#include <LibJS/Runtime/PromiseConstructor.h>
#include <LibJS/Runtime/Realm.h>
#include <LibWeb/Bindings/ExceptionOrUtils.h>
#include <LibWeb/Bindings/HostDefined.h>
#include <LibWeb/HTML/Scripting/ExceptionReporter.h>
#include <LibWeb/WebIDL/Promise.h>

namespace Web::WebIDL {

// https://webidl.spec.whatwg.org/#a-new-promise
JS::NonnullGCPtr<Promise> create_promise(JS::Realm& realm)
{
    auto& vm = realm.vm();

    // 1. Let constructor be realm.[[Intrinsics]].[[%Promise%]].
    auto constructor = realm.intrinsics().promise_constructor();

    // Return ? NewPromiseCapability(constructor).
    // NOTE: When called with %Promise%, NewPromiseCapability can't throw.
    return MUST(JS::new_promise_capability(vm, constructor));
}

// https://webidl.spec.whatwg.org/#a-promise-resolved-with
JS::NonnullGCPtr<Promise> create_resolved_promise(JS::Realm& realm, JS::Value value)
{
    auto& vm = realm.vm();

    // 1. Let value be the result of converting x to an ECMAScript value.

    // 2. Let constructor be realm.[[Intrinsics]].[[%Promise%]].
    auto constructor = realm.intrinsics().promise_constructor();

    // 3. Let promiseCapability be ? NewPromiseCapability(constructor).
    // NOTE: When called with %Promise%, NewPromiseCapability can't throw.
    auto promise_capability = MUST(JS::new_promise_capability(vm, constructor));

    // 4. Perform ! Call(promiseCapability.[[Resolve]], undefined, « value »).
    MUST(JS::call(vm, *promise_capability->resolve(), JS::js_undefined(), value));

    // 5. Return promiseCapability.
    return promise_capability;
}

// https://webidl.spec.whatwg.org/#a-promise-rejected-with
JS::NonnullGCPtr<Promise> create_rejected_promise(JS::Realm& realm, JS::Value reason)
{
    auto& vm = realm.vm();

    // 1. Let constructor be realm.[[Intrinsics]].[[%Promise%]].
    auto constructor = realm.intrinsics().promise_constructor();

    // 2. Let promiseCapability be ? NewPromiseCapability(constructor).
    // NOTE: When called with %Promise%, NewPromiseCapability can't throw.
    auto promise_capability = MUST(JS::new_promise_capability(vm, constructor));

    // 3. Perform ! Call(promiseCapability.[[Reject]], undefined, « r »).
    MUST(JS::call(vm, *promise_capability->reject(), JS::js_undefined(), reason));

    // 4. Return promiseCapability.
    return promise_capability;
}

// https://webidl.spec.whatwg.org/#resolve
void resolve_promise(JS::Realm& realm, Promise const& promise, JS::Value value)
{
    auto& vm = realm.vm();

    // 1. If x is not given, then let it be the undefined value.
    // NOTE: This is done via the default argument.

    // 2. Let value be the result of converting x to an ECMAScript value.
    // 3. Perform ! Call(p.[[Resolve]], undefined, « value »).
    MUST(JS::call(vm, *promise.resolve(), JS::js_undefined(), value));
}

// https://webidl.spec.whatwg.org/#reject
void reject_promise(JS::Realm& realm, Promise const& promise, JS::Value reason)
{
    auto& vm = realm.vm();

    // 1. Perform ! Call(p.[[Reject]], undefined, « r »).
    MUST(JS::call(vm, *promise.reject(), JS::js_undefined(), reason));
}

// https://webidl.spec.whatwg.org/#dfn-perform-steps-once-promise-is-settled
JS::NonnullGCPtr<JS::Promise> react_to_promise(Promise const& promise, JS::GCPtr<ReactionSteps> on_fulfilled_callback, JS::GCPtr<ReactionSteps> on_rejected_callback)
{
    auto& realm = promise.promise()->shape().realm();
    auto& vm = realm.vm();

    // 1. Let onFulfilledSteps be the following steps given argument V:
    auto on_fulfilled_steps = [on_fulfilled_callback = move(on_fulfilled_callback)](JS::VM& vm) -> JS::ThrowCompletionOr<JS::Value> {
        // 1. Let value be the result of converting V to an IDL value of type T.
        auto value = vm.argument(0);

        // 2. If there is a set of steps to be run if the promise was fulfilled, then let result be the result of performing them, given value if T is not undefined. Otherwise, let result be value.
        auto result = on_fulfilled_callback
            ? TRY(Bindings::throw_dom_exception_if_needed(vm, [&] { return on_fulfilled_callback->function()(value); }))
            : value;

        // 3. Return result, converted to an ECMAScript value.
        return result;
    };

    // 2. Let onFulfilled be CreateBuiltinFunction(onFulfilledSteps, « »):
    auto on_fulfilled = JS::NativeFunction::create(realm, move(on_fulfilled_steps), 1, "");

    // 3. Let onRejectedSteps be the following steps given argument R:
    auto on_rejected_steps = [&realm, on_rejected_callback = move(on_rejected_callback)](JS::VM& vm) -> JS::ThrowCompletionOr<JS::Value> {
        // 1. Let reason be the result of converting R to an IDL value of type any.
        auto reason = vm.argument(0);

        // 2. If there is a set of steps to be run if the promise was rejected, then let result be the result of performing them, given reason. Otherwise, let result be a promise rejected with reason.
        auto result = on_rejected_callback
            ? TRY(Bindings::throw_dom_exception_if_needed(vm, [&] { return on_rejected_callback->function()(reason); }))
            : WebIDL::create_rejected_promise(realm, reason)->promise();

        // 3. Return result, converted to an ECMAScript value.
        return result;
    };

    // 4. Let onRejected be CreateBuiltinFunction(onRejectedSteps, « »):
    auto on_rejected = JS::NativeFunction::create(realm, move(on_rejected_steps), 1, "");

    // 5. Let constructor be promise.[[Promise]].[[Realm]].[[Intrinsics]].[[%Promise%]].
    auto constructor = realm.intrinsics().promise_constructor();

    // 6. Let newCapability be ? NewPromiseCapability(constructor).
    // NOTE: When called with %Promise%, NewPromiseCapability can't throw.
    auto new_capability = MUST(JS::new_promise_capability(vm, constructor));

    // 7. Return PerformPromiseThen(promise.[[Promise]], onFulfilled, onRejected, newCapability).
    auto promise_object = verify_cast<JS::Promise>(promise.promise().ptr());
    auto value = promise_object->perform_then(on_fulfilled, on_rejected, new_capability);
    return verify_cast<JS::Promise>(value.as_object());
}

// https://webidl.spec.whatwg.org/#upon-fulfillment
JS::NonnullGCPtr<JS::Promise> upon_fulfillment(Promise const& promise, JS::NonnullGCPtr<ReactionSteps> steps)
{
    // 1. Return the result of reacting to promise:
    return react_to_promise(promise,
        // - If promise was fulfilled with value v, then:
        // 1. Perform steps with v.
        steps,
        {});
}

// https://webidl.spec.whatwg.org/#upon-rejection
JS::NonnullGCPtr<JS::Promise> upon_rejection(Promise const& promise, JS::NonnullGCPtr<ReactionSteps> steps)
{
    // 1. Return the result of reacting to promise:
    return react_to_promise(promise, {},
        // - If promise was rejected with reason r, then:
        // 1. Perform steps with r.
        steps);
}

// https://webidl.spec.whatwg.org/#mark-a-promise-as-handled
void mark_promise_as_handled(Promise const& promise)
{
    // To mark as handled a Promise<T> promise, set promise.[[Promise]].[[PromiseIsHandled]] to true.
    auto promise_object = verify_cast<JS::Promise>(promise.promise().ptr());
    promise_object->set_is_handled();
}

struct WaitForAllResults : JS::Cell {
    JS_CELL(WaitForAllResults, JS::Cell);
    JS_DECLARE_ALLOCATOR(WaitForAllResults);

    WaitForAllResults(JS::NonnullGCPtr<JS::HeapFunction<void(Vector<JS::Value> const&)>> s, size_t t)
        : success_steps(s)
        , total(t)
    {
        // 8. Let result be a list containing total null values.
        result.ensure_capacity(total);
        for (size_t i = 0; i < total; ++i)
            result.unchecked_append(JS::js_null());
    }

    virtual void visit_edges(JS::Cell::Visitor& visitor) override
    {
        Base::visit_edges(visitor);
        visitor.visit(success_steps);
        visitor.visit(result);
    }

    JS::NonnullGCPtr<JS::HeapFunction<void(Vector<JS::Value> const&)>> success_steps;
    Vector<JS::Value> result;
    size_t total = 0;
    size_t fulfilled_count = 0;
};

JS_DEFINE_ALLOCATOR(WaitForAllResults);

// https://webidl.spec.whatwg.org/#wait-for-all
void wait_for_all(JS::Realm& realm, Vector<JS::NonnullGCPtr<Promise>> const& promises, Function<void(Vector<JS::Value> const&)> success_steps, Function<void(JS::Value)> failure_steps)
{
    // FIXME: Fix spec typo, fullfilled --> fulfilled
    // 1. Let fullfilledCount be 0.
    // Handled later in WaitForAllResults

    // 2. Let rejected be false.
    auto rejected = false;

    // 3. Let rejectionHandlerSteps be the following steps given arg:
    auto rejection_handler_steps = [rejected, failure_steps = JS::create_heap_function(realm.heap(), move(failure_steps))](JS::VM& vm) mutable -> JS::ThrowCompletionOr<JS::Value> {
        // 1. If rejected is true, abort these steps.
        if (rejected)
            return JS::js_undefined();

        // 2. Set rejected to true.
        rejected = true;

        // 3. Perform failureSteps given arg.
        failure_steps->function()(vm.argument(0));

        return JS::js_undefined();
    };

    // 4. Let rejectionHandler be CreateBuiltinFunction(rejectionHandlerSteps, « »):
    auto rejection_handler = JS::NativeFunction::create(realm, move(rejection_handler_steps), 1, "");

    // 5. Let total be promises’s size.
    auto total = promises.size();

    // 6. If total is 0, then:
    if (total == 0) {
        // 1. Queue a microtask to perform successSteps given « ».
        HTML::queue_a_microtask(nullptr, JS::create_heap_function(realm.heap(), [success_steps = JS::create_heap_function(realm.heap(), move(success_steps))] {
            success_steps->function()({});
        }));

        // 2. Return.
        return;
    }

    // 7. Let index be 0.
    auto index = 0;

    // 8. Let result be a list containing total null values.
    // Handled in WaitForAllResults

    auto results = realm.heap().allocate<WaitForAllResults>(realm, JS::create_heap_function(realm.heap(), move(success_steps)), total);

    // 9. For each promise of promises:
    for (auto const& promise : promises) {
        // 1. Let promiseIndex be index.
        auto promise_index = index;

        // FIXME: This should be fulfillmentHandlerSteps
        // 2. Let fulfillmentHandler be the following steps given arg:
        auto fulfillment_handler_steps = [results, promise_index](JS::VM& vm) -> JS::ThrowCompletionOr<JS::Value> {
            auto arg = vm.argument(0);

            // 1. Set result[promiseIndex] to arg.
            results->result[promise_index] = arg;

            // 2. Set fullfilledCount to fullfilledCount + 1.
            ++results->fulfilled_count;

            // 3. If fullfilledCount equals total, then perform successSteps given result.
            if (results->fulfilled_count == results->total)
                results->success_steps->function()(results->result);

            return JS::js_undefined();
        };

        // 3. Let fulfillmentHandler be CreateBuiltinFunction(fulfillmentHandler, « »):
        auto fulfillment_handler = JS::NativeFunction::create(realm, move(fulfillment_handler_steps), 1, "");

        // 4. Perform PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler).
        static_cast<JS::Promise&>(*promise->promise()).perform_then(fulfillment_handler, rejection_handler, nullptr);

        // 5. Set index to index + 1.
        ++index;
    }
}

JS::NonnullGCPtr<JS::Promise> create_rejected_promise_from_exception(JS::Realm& realm, Exception exception)
{
    auto throw_completion = Bindings::dom_exception_to_throw_completion(realm.vm(), move(exception));
    auto promise_capability = WebIDL::create_rejected_promise(realm, *throw_completion.value());
    return JS::NonnullGCPtr { verify_cast<JS::Promise>(*promise_capability->promise().ptr()) };
}

}