Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion context_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -1160,7 +1160,7 @@ func TestContextPromise(t *testing.T) {
// Test PromiseState on non-Promise
nonPromise := ctx.NewString("not a promise")
defer nonPromise.Free()
require.Equal(t, PromisePending, nonPromise.PromiseState()) // Should return default
require.Equal(t, PromiseNotAPromise, nonPromise.PromiseState())
})

t.Run("ValueAwait", func(t *testing.T) {
Expand Down
71 changes: 58 additions & 13 deletions value.go
Original file line number Diff line number Diff line change
Expand Up @@ -1114,26 +1114,71 @@ func (v *Value) IsPromise() bool {
type PromiseState int

const (
PromisePending PromiseState = iota
PromiseFulfilled
PromiseRejected
PromiseNotAPromise PromiseState = PromiseState(C.JS_PROMISE_NOT_A_PROMISE)
PromisePending PromiseState = PromiseState(C.JS_PROMISE_PENDING)
PromiseFulfilled PromiseState = PromiseState(C.JS_PROMISE_FULFILLED)
PromiseRejected PromiseState = PromiseState(C.JS_PROMISE_REJECTED)
)

// PromiseState returns the state of the Promise
// promiseStateResultHook overrides JS_PromiseState results in tests.
var promiseStateResultHook func(state PromiseState) PromiseState

// PromiseState returns the promise state, or PromiseNotAPromise when v is not a Promise.
func (v *Value) PromiseState() PromiseState {
if !v.IsPromise() {
return PromisePending
if v == nil || !v.hasValidContext() {
return PromiseNotAPromise
}
state := PromiseState(C.JS_PromiseState(v.ctx.ref, v.ref))
if hook := promiseStateResultHook; hook != nil {
state = hook(state)
}

state := C.JS_PromiseState(v.ctx.ref, v.ref)
switch state {
case C.JSPromiseStateEnum(C.JS_PROMISE_PENDING):
return PromisePending
case C.JSPromiseStateEnum(C.JS_PROMISE_FULFILLED):
return PromiseFulfilled
case PromiseNotAPromise, PromisePending, PromiseFulfilled, PromiseRejected:
return state
default:
return PromiseRejected
return PromiseNotAPromise
}
}

// PromiseResult returns the current promise result value (fulfillment value or rejection reason).
// Caller must Free the returned value. For non-promise or pending promises, behavior matches QuickJS.
func (v *Value) PromiseResult() *Value {
if v == nil || !v.hasValidContext() {
return nil
}
return &Value{ctx: v.ctx, ref: C.JS_PromiseResult(v.ctx.ref, v.ref)}
}

// Then attaches native promise reactions via JS_PromiseThen.
// onFulfilled/onRejected may be nil (passed as undefined). Does not consume v or callbacks.
// Returns a new promise owned by the caller, or nil if fail-closed.
func (v *Value) Then(onFulfilled, onRejected *Value) *Value {
if v == nil || !v.hasValidContext() || !v.IsPromise() {
return nil
}
fulfilled := C.JS_NewUndefined()
rejected := C.JS_NewUndefined()
if onFulfilled != nil {
if !onFulfilled.belongsTo(v.ctx) {
return nil
}
fulfilled = onFulfilled.ref
}
if onRejected != nil {
if !onRejected.belongsTo(v.ctx) {
return nil
}
rejected = onRejected.ref
}
return &Value{ctx: v.ctx, ref: C.JS_PromiseThen(v.ctx.ref, v.ref, fulfilled, rejected)}
}

// MarkAsHandled marks a rejected promise as handled so it will not surface as unhandled.
func (v *Value) MarkAsHandled() {
if v == nil || !v.hasValidContext() || !v.IsPromise() {
return
}
C.JS_PromiseMarkAsHandled(v.ctx.ref, v.ref)
}

// Await waits for promise resolution and executes pending jobs
Expand Down
81 changes: 80 additions & 1 deletion value_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -1542,7 +1542,86 @@ func TestPromiseState(t *testing.T) {
// Test non-promise value (covers first if branch) - Updated to use New* methods
nonPromise := ctx.NewString("not a promise")
defer nonPromise.Free()
require.Equal(t, PromisePending, nonPromise.PromiseState())
require.Equal(t, PromiseNotAPromise, nonPromise.PromiseState())
require.Nil(t, nonPromise.Then(nil, nil))

fulfilled := ctx.Eval(`Promise.resolve(42)`)
defer fulfilled.Free()
result := fulfilled.PromiseResult()
defer result.Free()
require.EqualValues(t, 42, result.ToInt32())

onFulfilled := ctx.NewFunction(func(ctx *Context, this *Value, args []*Value) *Value {
if len(args) > 0 {
return ctx.NewInt32(args[0].ToInt32() + 1)
}
return ctx.NewInt32(0)
})
defer onFulfilled.Free()

chained := fulfilled.Then(onFulfilled, nil)
require.NotNil(t, chained)
deferred := ctx.Await(chained)
defer deferred.Free()
require.False(t, deferred.IsException())
require.EqualValues(t, 43, deferred.ToInt32())

rejected := ctx.Eval(`Promise.reject("boom")`)
defer rejected.Free()
rejected.MarkAsHandled()
require.Equal(t, PromiseRejected, rejected.PromiseState())
reason := rejected.PromiseResult()
defer reason.Free()
require.Equal(t, "boom", reason.ToString())

require.Nil(t, (*Value)(nil).PromiseResult())
require.Nil(t, (*Value)(nil).Then(nil, nil))
(*Value)(nil).MarkAsHandled()
require.Equal(t, PromiseNotAPromise, (*Value)(nil).PromiseState())

nonPromise.MarkAsHandled()
bothUndef := fulfilled.Then(nil, nil)
require.NotNil(t, bothUndef)
bothUndef.Free()

onRejected := ctx.NewFunction(func(ctx *Context, this *Value, args []*Value) *Value {
if len(args) > 0 {
return ctx.NewString("handled:" + args[0].ToString())
}
return ctx.NewString("handled")
})
defer onRejected.Free()
rejected2 := ctx.Eval(`Promise.reject("boom2")`)
defer rejected2.Free()
rejected2.MarkAsHandled()
chainedReject := rejected2.Then(nil, onRejected)
require.NotNil(t, chainedReject)
handled := ctx.Await(chainedReject)
defer handled.Free()
require.False(t, handled.IsException())
require.Equal(t, "handled:boom2", handled.ToString())

otherRT := NewRuntime()
defer otherRT.Close()
other := otherRT.NewContext()
defer other.Close()
foreignFn := other.NewFunction(func(ctx *Context, this *Value, args []*Value) *Value {
return ctx.NewUndefined()
})
defer foreignFn.Free()
require.Nil(t, fulfilled.Then(foreignFn, nil))
require.Nil(t, fulfilled.Then(nil, foreignFn))

prevHook := promiseStateResultHook
promiseStateResultHook = func(state PromiseState) PromiseState { return PromiseState(999) }
require.Equal(t, PromiseNotAPromise, fulfilled.PromiseState())
promiseStateResultHook = prevHook

orphan := &Value{} // non-nil value without a usable context
require.Equal(t, PromiseNotAPromise, orphan.PromiseState())
require.Nil(t, orphan.PromiseResult())
require.Nil(t, orphan.Then(nil, nil))
orphan.MarkAsHandled()
}

// TestValueAwait tests promise await functionality
Expand Down
Loading