Method loadJsModule

valdi/src/valdi/runtime/JavaScript/JavaScriptRuntime.cpp:1364–1474

    auto jsPaths = bundle->getAllJsPaths();
    auto output = callContext.getContext().newArray(jsPaths.size(), callContext.getExceptionTracker());
    CHECK_CALL_CONTEXT(callContext);

    size_t index = 0;
    for (const auto& jsPath : jsPaths) {
        auto jsPathJs =
            callContext.getContext().newStringUTF8(jsPath.toStringView(), callContext.getExceptionTracker());
        CHECK_CALL_CONTEXT(callContext);
        callContext.getContext().setObjectPropertyIndex(
            output.get(), index++, jsPathJs.get(), callContext.getExceptionTracker());
        CHECK_CALL_CONTEXT(callContext);
    }

    return output;
}

JSValueRef JavaScriptRuntime::runtimeLoadModule(JSFunctionNativeCallContext& callContext) {
    auto moduleName = callContext.getParameterAsString(0);
    CHECK_CALL_CONTEXT(callContext);

    Shared<JSValueRefHolder> callback;
    auto callbackParam = callContext.getParameter(1);
    if (callContext.getContext().isValueUndefined(callbackParam)) {
        if (!_resourceManager.isLazyModulePreloadingEnabled()) {
            // When not providing a callback, we consider it as a preload operation, which
            // we dont need if eager module preloading is enabled
            return callContext.getContext().newUndefined();
        }
    } else {
        callback = JSValueRefHolder::makeRetainedCallback(
            callContext.getContext(),
            callbackParam,
            ReferenceInfoBuilder(callContext.getReferenceInfo()).withParameter(1),
            callContext.getExceptionTracker());
    }

    _resourceManager.loadModuleAsync(
        moduleName, ResourceManagerLoadModuleType::Sources, [this, callback](const Result<Void>& result) {
            if (callback == nullptr) {
                return;
            }

            this->dispatchOnJsThreadAsync(callback->getContext(), [callback, result](JavaScriptEntryParameters& entry) {
                auto jsValue = callback->getJsValue(entry.jsContext, entry.exceptionTracker);
                if (!entry.exceptionTracker) {
                    return;
                }

                if (result) {
                    JSFunctionCallContext callContext(entry.jsContext, nullptr, 0, entry.exceptionTracker);
                    entry.jsContext.callObjectAsFunction(jsValue, callContext);
                } else {
                    auto errorString = entry.jsContext.newStringUTF8(result.error().toString(), entry.exceptionTracker);
                    if (!entry.exceptionTracker) {
                        return;
                    }

                    JSFunctionCallContext callContext(entry.jsContext, &errorString, 1, entry.exceptionTracker);