From d468273e57b399da0e74404e31d88336f8603802 Mon Sep 17 00:00:00 2001 From: Brian Wang Date: Fri, 6 Nov 2026 11:06:48 +0800 Subject: [PATCH 1/2] feat: add Promise Then/MarkAsHandled/PromiseResult APIs Align PromiseState with quickjs-ng (PromiseNotAPromise) and expose JS_PromiseThen, JS_PromiseMarkAsHandled, and JS_PromiseResult. --- context_test.go | 2 +- value.go | 65 +++++++++++++++++++++++++++++++++++++++---------- value_test.go | 36 ++++++++++++++++++++++++++- 3 files changed, 88 insertions(+), 15 deletions(-) diff --git a/context_test.go b/context_test.go index 8f086d7..dd69a4c 100644 --- a/context_test.go +++ b/context_test.go @@ -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) { diff --git a/value.go b/value.go index 6ed1ba5..b631eaa 100644 --- a/value.go +++ b/value.go @@ -1114,26 +1114,65 @@ 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 +// 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 := C.JS_PromiseState(v.ctx.ref, v.ref) + state := PromiseState(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 diff --git a/value_test.go b/value_test.go index ca12c9f..f65bc67 100644 --- a/value_test.go +++ b/value_test.go @@ -1542,7 +1542,41 @@ 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() } // TestValueAwait tests promise await functionality From 224475b7d5c10c417b9820e7a8b50a0f565227c6 Mon Sep 17 00:00:00 2001 From: Brian Wang Date: Fri, 6 Nov 2026 12:26:31 +0800 Subject: [PATCH 2/2] test: cover Promise Then/MarkAsHandled/PromiseResult to 100% Exercise nil/invalid context, foreign callbacks, rejection handlers, and unknown PromiseState default via a test hook. --- value.go | 6 ++++++ value_test.go | 45 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+) diff --git a/value.go b/value.go index b631eaa..f0c441c 100644 --- a/value.go +++ b/value.go @@ -1120,12 +1120,18 @@ const ( PromiseRejected PromiseState = PromiseState(C.JS_PROMISE_REJECTED) ) +// 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 == nil || !v.hasValidContext() { return PromiseNotAPromise } state := PromiseState(C.JS_PromiseState(v.ctx.ref, v.ref)) + if hook := promiseStateResultHook; hook != nil { + state = hook(state) + } switch state { case PromiseNotAPromise, PromisePending, PromiseFulfilled, PromiseRejected: return state diff --git a/value_test.go b/value_test.go index f65bc67..14d825c 100644 --- a/value_test.go +++ b/value_test.go @@ -1577,6 +1577,51 @@ func TestPromiseState(t *testing.T) { 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