#import "config.h"

#import "JSAPIGlobalObject.h"

#if JSC_OBJC_API_ENABLED

#import "APICast.h"

#import "CallFrameInlines.h"

#import "Completion.h"

#import "Error.h"

#import "Exception.h"

#import "GlobalObjectMethodTable.h"

#import "IdentifierInlines.h"

#import "JSContextInternal.h"

#import "JSModuleLoader.h"

#import "JSNativeStdFunction.h"

#import "JSObjectInlines.h"

#import "JSPromise.h"

#import "JSScriptInternal.h"

#import "JSSourceCode.h"

#import "JSValueInternal.h"

#import "JSVirtualMachineInternal.h"

#import "JavaScriptCore.h"

#import "ObjectConstructor.h"

#import "SourceOrigin.h"

#import "StrongInlines.h"

#import "TopExceptionScope.h"

#import <wtf/URL.h>

#import <wtf/text/MakeString.h>

namespace JSC {

const GlobalObjectMethodTable* JSAPIGlobalObject::globalObjectMethodTable()

{

static constexpr GlobalObjectMethodTable table = {

&supportsRichSourceInfo,

&shouldInterruptScript,

&javaScriptRuntimeFlags,

&shouldInterruptScriptBeforeTimeout,

nullptr, // moduleTypeIsAllowed

&moduleLoaderImportModule, // moduleLoaderImportModule

&moduleLoaderResolve, // moduleLoaderResolve

&moduleLoaderFetch, // moduleLoaderFetch

&moduleLoaderCreateImportMetaProperties, // moduleLoaderCreateImportMetaProperties

&moduleLoaderEvaluate, // moduleLoaderEvaluate

&promiseRejectionTracker,

&reportUncaughtExceptionAtEventLoop,

&currentScriptExecutionOwner,

&scriptExecutionStatus,

&reportViolationForUnsafeEval,

nullptr, // defaultLanguage

nullptr, // compileStreaming

nullptr, // instantiateStreaming

&codeForEval,

&canCompileStrings,

&trustedScriptStructure,

};

return &table;

};

void JSAPIGlobalObject::reportUncaughtExceptionAtEventLoop(JSGlobalObject* globalObject, Exception* exception)

{

JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];

[context notifyException:toRef(globalObject->vm(), exception->value())];

}

static std::expected<URL, String> computeValidImportSpecifier(const URL& base, const String& specifier)

{

URL absoluteURL(specifier);

if (absoluteURL.isValid())

return absoluteURL;

if (!specifier.startsWith('/') && !specifier.startsWith("./"_s) && !specifier.startsWith("../"_s))

return makeUnexpected(makeString("Module specifier: "_s, specifier, " does not start with \"/\", \"./\", or \"../\". Referenced from: "_s, base.string()));

if (specifier.startsWith('/')) {

absoluteURL = URL(URL("file://"_s), specifier);

if (absoluteURL.isValid())

return absoluteURL;

}

if (base == URL())

return makeUnexpected("Could not determine the base URL for loading."_s);

if (!base.isValid())

return makeUnexpected(makeString("Referrering script's url is not valid: "_s, base.string()));

absoluteURL = URL(base, specifier);

if (absoluteURL.isValid())

return absoluteURL;

return makeUnexpected(makeString("Could not form valid URL from identifier and base. Tried:"_s, absoluteURL.string()));

}

Identifier JSAPIGlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, JSModuleLoader*, JSValue key, JSValue referrer, RefPtr<ScriptFetcher>, bool)

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

ASSERT_UNUSED(globalObject, globalObject == globalObject);

ASSERT(key.isString() || key.isSymbol());

String name = key.toWTFString(globalObject);

RETURN_IF_EXCEPTION(scope, { });

URL base;

if (JSString* referrerString = dynamicDowncast<JSString>(referrer)) {

String value = referrerString->value(globalObject);

RETURN_IF_EXCEPTION(scope, { });

// It can be invalid URL because dynamic-import will be resolved with caller's source origin (this becomes referrer), and it can be non valid URL.

// But this is handled well in computeValidImportSpecifier.

base = URL { { }, value };

}

auto result = computeValidImportSpecifier(base, name);

if (result)

return Identifier::fromString(vm, result.value().string());

throwVMError(globalObject, scope, createError(globalObject, result.error()));

return { };

}

JSPromise* JSAPIGlobalObject::moduleLoaderImportModule(JSGlobalObject* globalObject, JSModuleLoader*, JSString* specifierValue, RefPtr<ScriptFetchParameters> fetchParams, const SourceOrigin& sourceOrigin, bool deferred)

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

auto reject = [&] (ThrowScope& scope) -> JSPromise* {

auto* promise = JSPromise::create(vm, globalObject->promiseStructure());

return promise->rejectWithCaughtException(vm, scope);

};

auto specifier = specifierValue->value(globalObject);

RETURN_IF_EXCEPTION(scope, reject(scope));

Identifier originURL;

if (const String& originString = sourceOrigin.string(); !originString.isNull())

originURL = Identifier::fromString(vm, originString);

auto result = importModule(globalObject, Identifier::fromString(vm, specifier), originURL, WTF::move(fetchParams), nullptr, deferred);

RETURN_IF_EXCEPTION(scope, reject(scope));

return result;

}

JSPromise* JSAPIGlobalObject::moduleLoaderFetch(JSGlobalObject* globalObject, JSModuleLoader*, JSValue key, const String&, RefPtr<ScriptFetchParameters>, RefPtr<ScriptFetcher>)

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

ASSERT(globalObject == globalObject);

JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];

JSPromise* promise = JSPromise::create(vm, globalObject->promiseStructure());

Identifier moduleKey = key.toPropertyKey(globalObject);

RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(vm, scope));

if (![context moduleLoaderDelegate]) [[unlikely]] {

scope.release();

promise->reject(vm, createError(globalObject, "No module loader provided."_s));

return promise;

}

auto* resolve = JSNativeStdFunction::create(vm, globalObject, 1, "resolve"_s, [promise, moduleKey] (JSGlobalObject* globalObject, CallFrame* callFrame) {

// This captures the globalObject but that's ok because our structure keeps it alive anyway.

VM& vm = globalObject->vm();

JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];

id script = valueToObject(context, toRef(globalObject, callFrame->argument(0)));

auto rejectPromise = [&] (String message) {

promise->reject(vm, createTypeError(globalObject, message));

return encodedJSUndefined();

};

if (![script isKindOfClass:[JSScript class]]) [[unlikely]]

return rejectPromise("First argument of resolution callback is not a JSScript"_s);

RetainPtr jsScript = static_cast<JSScript *>(script);

JSSourceCode* source = [jsScript.get() jsSourceCode];

if ([jsScript.get() type] != kJSScriptTypeModule) [[unlikely]]

return rejectPromise("The JSScript that was provided did not have expected type of kJSScriptTypeModule."_s);

NSURL *sourceURL = [jsScript.get() sourceURL];

String oldModuleKey { [sourceURL absoluteString] };

if (Identifier::fromString(vm, oldModuleKey) != moduleKey) [[unlikely]]

return rejectPromise(makeString("The same JSScript was provided for two different identifiers, previously: "_s, oldModuleKey, " and now: "_s, moduleKey.string()));

promise->resolve(globalObject, vm, source);

return encodedJSUndefined();

}, promise);

auto* reject = JSNativeStdFunction::create(vm, globalObject, 1, "reject"_s, [promise] (JSGlobalObject* globalObject, CallFrame* callFrame) {

promise->reject(globalObject->vm(), callFrame->argument(0));

return encodedJSUndefined();

}, promise);

[[context moduleLoaderDelegate] context:context fetchModuleForIdentifier:[::JSValue valueWithJSValueRef:toRef(globalObject, key) inContext:context] withResolveHandler:[::JSValue valueWithJSValueRef:toRef(globalObject, resolve) inContext:context] andRejectHandler:[::JSValue valueWithJSValueRef:toRef(globalObject, reject) inContext:context]];

if (context.exception) {

scope.release();

promise->reject(vm, toJS(globalObject, [context.exception JSValueRef]));

context.exception = nil;

}

return promise;

}

JSObject* JSAPIGlobalObject::moduleLoaderCreateImportMetaProperties(JSGlobalObject* globalObject, JSModuleLoader*, JSValue key, JSModuleRecord*, RefPtr<ScriptFetcher>)

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

JSObject* metaProperties = constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());

RETURN_IF_EXCEPTION(scope, nullptr);

metaProperties->putDirect(vm, Identifier::fromString(vm, "filename"_s), key);

RETURN_IF_EXCEPTION(scope, nullptr);

metaProperties->putDirect(vm, JSC::Identifier::fromString(vm, "url"_s), key);

RETURN_IF_EXCEPTION(scope, nullptr);

return metaProperties;

}

JSValue JSAPIGlobalObject::moduleLoaderEvaluate(JSGlobalObject* globalObject, JSModuleLoader* moduleLoader, JSValue key, JSValue moduleRecordValue, RefPtr<ScriptFetcher> scriptFetcher, JSValue sentValue, JSValue resumeMode)

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];

id <JSModuleLoaderDelegate> moduleLoaderDelegate = [context moduleLoaderDelegate];

NSURL *url = nil;

if ([moduleLoaderDelegate respondsToSelector:@selector(willEvaluateModule:)] || [moduleLoaderDelegate respondsToSelector:@selector(didEvaluateModule:)]) {

String moduleKey = key.toWTFString(globalObject);

RETURN_IF_EXCEPTION(scope, { });

url = [NSURL URLWithString:moduleKey.createNSString().get()];

}

if ([moduleLoaderDelegate respondsToSelector:@selector(willEvaluateModule:)])

[moduleLoaderDelegate willEvaluateModule:url];

scope.release();

// FIXME: We should update the delegate callbacks for async modules. https://bugs.webkit.org/show_bug.cgi?id=222253

JSValue result = moduleLoader->evaluateNonVirtual(globalObject, key, moduleRecordValue, scriptFetcher, sentValue, resumeMode);

if ([moduleLoaderDelegate respondsToSelector:@selector(didEvaluateModule:)])

[moduleLoaderDelegate didEvaluateModule:url];

return result;

}

JSValue JSAPIGlobalObject::loadAndEvaluateJSScriptModule(const JSLockHolder&, JSScript *script)

{

ASSERT(script.type == kJSScriptTypeModule);

VM& vm = this->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

Identifier key = Identifier::fromString(vm, String { [[script sourceURL] absoluteString] });

JSPromise* promise = importModule(this, key, { }, nullptr, nullptr);

RETURN_IF_EXCEPTION(scope, { });

auto* result = JSPromise::create(vm, this->promiseStructure());

result->resolve(this, vm, promise);

RETURN_IF_EXCEPTION(scope, { });

return result;

}

}

#endif // JSC_OBJC_API_ENABLED