internal PromisePrototype(
Engine engine,
Realm realm,
PromiseConstructor constructor,
ObjectPrototype objectPrototype) : base(engine, realm)
{
_prototype = objectPrototype;
_constructor = constructor;
}
protected override ExpressionResult EvaluateInternal(EvaluationContext context)
{
var referencingScriptOrModule = context.Engine.GetActiveScriptOrModule();
var argRef = _importExpression.Evaluate(context);
var specifier = context.Engine.GetValue(argRef.Value); //.UnwrapIfPromise();
var promiseCapability = PromiseConstructor.NewPromiseCapability(context.Engine, context.Engine.Realm.Intrinsics.Promise);
var specifierString = TypeConverter.ToString(specifier);
context.Engine._host.ImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability);
context.Engine.RunAvailableContinuations();
return(NormalCompletion(promiseCapability.PromiseInstance));
}
/// <summary>
/// https://tc39.es/ecma262/#sec-execute-async-module
/// </summary>
private Completion ExecuteAsyncModule()
{
if (Status != ModuleStatus.Evaluating && Status != ModuleStatus.EvaluatingAsync || !_hasTLA)
{
ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
}
var capability = PromiseConstructor.NewPromiseCapability(_engine, _realm.Intrinsics.Promise);
var onFullfilled = new ClrFunctionInstance(_engine, "fulfilled", AsyncModuleExecutionFulfilled, 1, PropertyFlag.Configurable);
var onRejected = new ClrFunctionInstance(_engine, "rejected", AsyncModuleExecutionRejected, 1, PropertyFlag.Configurable);
PromiseOperations.PerformPromiseThen(_engine, (PromiseInstance)capability.PromiseInstance, onFullfilled, onRejected, null);
return(ExecuteModule(capability));
}
/// <summary>
/// https://tc39.es/ecma262/#sec-moduleevaluation
/// </summary>
public override JsValue Evaluate()
{
var module = this;
if (module.Status != ModuleStatus.Linked &&
module.Status != ModuleStatus.EvaluatingAsync &&
module.Status != ModuleStatus.Evaluated)
{
ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
}
if (module.Status is ModuleStatus.EvaluatingAsync or ModuleStatus.Evaluated)
{
module = module._cycleRoot;
}
if (module._topLevelCapability is not null)
{
return(module._topLevelCapability.PromiseInstance);
}
var stack = new Stack <CyclicModuleRecord>();
var capability = PromiseConstructor.NewPromiseCapability(_engine, _realm.Intrinsics.Promise);
var asyncEvalOrder = 0;
module._topLevelCapability = capability;
var result = module.InnerModuleEvaluation(stack, 0, ref asyncEvalOrder);
if (result.Type != CompletionType.Normal)
{
foreach (var m in stack)
{
m.Status = ModuleStatus.Evaluated;
m._evalError = result;
}
capability.Reject.Call(Undefined, new[] { result.Value });
}
else
{
if (module.Status != ModuleStatus.EvaluatingAsync && module.Status != ModuleStatus.Evaluated)
{
ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
}
if (module._evalError is not null)
{
ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
}
if (!module._asyncEvaluation)
{
if (module.Status != ModuleStatus.Evaluated)
{
ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
}
capability.Resolve.Call(Undefined, Array.Empty <JsValue>());
}
if (stack.Count > 0)
{
ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
}
}
return(capability.PromiseInstance);
}
public IPromiseAwaiter GetAwaiter()
{
return(PromiseConstructor.Resolve(Global.Promise, this).GetUnderlyingObject <Promise>());
}
