internal void InitWithCallback(Promise previous, PromiseCallback fulfilledCallback, PromiseCallback rejectedCallback)
{
Guard.ArgumentNotNull(previous, "previous");
this.fulfilledCallback = fulfilledCallback;
this.rejectedCallback = rejectedCallback;
previous.ContinueWith(HandleCompletedPromise);
}
public static Promise Resolve(EcmaValue value, PromiseCallback fulfilledCallback, PromiseCallback rejectedCallback)
{
Promise promise = new Promise();
promise.InitWithCallback(Promise.Resolve(value), fulfilledCallback, rejectedCallback);
return(promise);
}
public void HandleResult(PromiseState state, EcmaValue value)
{
if (!this.Handled)
{
PromiseCallback callback = state == PromiseState.Rejected ? OnReject : OnFulfill;
EcmaValue resolver = state == PromiseState.Rejected ? RejectCallback : ResolveCallback;
this.Handled = true;
if (callback != null)
{
value = callback(value);
}
resolver.Call(EcmaValue.Undefined, value);
}
}
public void HandlePromise(Promise promise, PromiseCallback onfulfill, PromiseCallback onreject)
{
Guard.ArgumentNotNull(promise, "promise");
if (this.Promise.GetUnderlyingObject() is Promise p)
{
p.InitWithCallback(promise, onfulfill, onreject);
}
else
{
this.OnFulfill = onfulfill;
this.OnReject = onreject;
promise.ContinueWith(HandleCompletedPromise);
}
}
public static EcmaValue Then([This] EcmaValue thisValue, EcmaValue onfulfill, EcmaValue onreject)
{
Promise promise = thisValue.GetUnderlyingObject <Promise>();
RuntimeObject constructor = RuntimeObject.GetSpeciesConstructor(promise, WellKnownObject.PromiseConstructor);
PromiseCallback c1 = null;
PromiseCallback c2 = null;
if (onfulfill.IsCallable)
{
c1 = v => onfulfill.Call(EcmaValue.Undefined, v);
}
if (onreject.IsCallable)
{
c2 = v => onreject.Call(EcmaValue.Undefined, v);
}
PromiseCapability capability = PromiseCapability.CreateFromConstructor(constructor);
capability.HandlePromise(promise, c1, c2);
return(capability.Promise);
}
private void SetState(PromiseState state, EcmaValue value, bool finalize)
{
PromiseCallback callback = state == PromiseState.Fulfilled ? fulfilledCallback : rejectedCallback;
fulfilledCallback = null;
rejectedCallback = null;
if (finalize || callback == null)
{
SetStateFinalize(state, value);
}
else
{
RuntimeExecution.Enqueue(() => {
try {
value = callback(value);
ResolveSelf(value, true);
} catch (Exception ex) {
SetStateFinalize(PromiseState.Rejected, EcmaValueUtility.GetValueFromException(ex));
}
});
}
}
public extern void Then <TOut>(PromiseCallback <T, TOut> fulfillCallback);