promise.go

//go:build js

package goji

import (
	"context"
	"syscall/js"
)

func init() {
	Promise = promiseJS(js.Global().Get("Promise"))
}

type promiseJS js.Value

// Promise is a wrapper for the Promise global object.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
var Promise promiseJS

// New wraps the Promise constructor.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
func (p promiseJS) New(executor js.Func) PromiseValue {
	res := js.Value(p).New(executor)
	return PromiseValue(res)
}

// All wraps the Promise all static method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all
func (p promiseJS) All(iterable js.Value) PromiseValue {
	res := js.Value(p).Call("all", iterable)
	return PromiseValue(res)
}

// AllSettled wraps the Promise allSettled static method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
func (p promiseJS) AllSettled(iterable js.Value) PromiseValue {
	res := js.Value(p).Call("allSettled", iterable)
	return PromiseValue(res)
}

// Any wraps the Promise any static method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any
func (p promiseJS) Any(iterable js.Value) PromiseValue {
	res := js.Value(p).Call("any", iterable)
	return PromiseValue(res)
}

// Race wraps the Promise race static method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race
func (p promiseJS) Race(iterable js.Value) PromiseValue {
	res := js.Value(p).Call("race", iterable)
	return PromiseValue(res)
}

// Reject wraps the Promise reject static method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject
func (p promiseJS) Reject(value js.Value) PromiseValue {
	res := js.Value(p).Call("reject", value)
	return PromiseValue(res)
}

// Resolve wraps the Promise resolve static method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/resolve
func (p promiseJS) Resolve(value js.Value) PromiseValue {
	res := js.Value(p).Call("resolve", value)
	return PromiseValue(res)
}

// PromiseValue is an instance of Promise.
type PromiseValue js.Value

// Then wraps the Promise then prototype method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then
func (v PromiseValue) Then(onFulfilled js.Func) PromiseValue {
	res := js.Value(v).Call("then", onFulfilled)
	return PromiseValue(res)
}

// Catch wraps the Promise catch prototype method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch
func (v PromiseValue) Catch(onRejected js.Func) PromiseValue {
	res := js.Value(v).Call("catch", onRejected)
	return PromiseValue(res)
}

// Finally wraps the Promise finally prototype method.
//
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally
func (v PromiseValue) Finally(onFinally js.Value) PromiseValue {
	res := js.Value(v).Call("catch", onFinally)
	return PromiseValue(res)
}

// PromiseOf is a helper function that wraps the given func in a promise.
func PromiseOf(fn func(resolve, reject func(value js.Value))) PromiseValue {
	var executor js.Func
	executor = js.FuncOf(func(this js.Value, args []js.Value) any {
		executor.Release()
		resolve := func(value js.Value) {
			args[0].Invoke(value)
		}
		reject := func(value js.Value) {
			args[1].Invoke(value)
		}
		// the function must run in a new go routine
		// to avoid blocking the render thread in JS
		go fn(resolve, reject)
		return js.Undefined()
	})
	return Promise.New(executor)
}

// awaitResult contains the promise results.
type awaitResult struct {
	val []js.Value
	err error
}

// AwaitContext is a helper function that waits for a promise to resolve or reject
// and returns the results and an error value.
//
// This helper function supports context cancellation.
func AwaitContext(ctx context.Context, promise PromiseValue) ([]js.Value, error) {
	res := make(chan awaitResult)
	defer close(res)

	onFulfilled := js.FuncOf(func(this js.Value, args []js.Value) any {
		res <- awaitResult{val: args}
		return js.Undefined()
	})
	defer onFulfilled.Release()

	onRejected := js.FuncOf(func(this js.Value, args []js.Value) any {
		res <- awaitResult{err: ErrorValue(args[0])}
		return js.Undefined()
	})
	defer onRejected.Release()

	promise.Then(onFulfilled).Catch(onRejected)

	select {
	case <-ctx.Done():
		return nil, ctx.Err()
	case out := <-res:
		return out.val, out.err
	}
}

// Await is a helper function that waits for a promise to resolve or reject
// and returns the results and an error value.
func Await(promise PromiseValue) ([]js.Value, error) {
	return AwaitContext(context.Background(), promise)
}

// Async is a helper function that wraps the given func in a promise that
// resolves when no error is returned or rejects when an error is returned.
func Async(fn func(this js.Value, args []js.Value) (js.Value, error)) js.Func {
	return js.FuncOf(func(this js.Value, args []js.Value) any {
		prom := PromiseOf(func(resolve, reject func(value js.Value)) {
			res, err := fn(this, args)
			if err != nil {
				reject(js.Value(Error.New(err.Error())))
			} else {
				resolve(res)
			}
		})
		return js.Value(prom)
	})
}