Feat/structured clone

internal/testing/htmltest/script_context_helper.go

@@ -0,0 +1,25 @@
+package htmltest
+
+import (
+	"testing"
+
+	"github.com/gost-dom/browser/html"
+)
+
+type ScriptContextHelper struct {
+	html.ScriptContext
+	t testing.TB
+}
+
+func NewScriptContextHelper(t testing.TB, ctx html.ScriptContext) ScriptContextHelper {
+	return ScriptContextHelper{ctx, t}
+}
+
+func (h ScriptContextHelper) MustEval(script string) any {
+	h.t.Helper()
+	res, err := h.Eval(script)
+	if err != nil {
+		h.t.Fatalf("Script error: %v", err)
+	}
+	return res
+}

scripting/internal/js/arguments.go

@@ -48,8 +48,6 @@ func ConsumeArgument[T, U any](
 	}
 }
 
-func IsUndefined[T any](v Value[T]) bool { return v == nil || v.IsUndefined() }
-
 func ConsumeRestArguments[T, U any](
 	args CallbackContext[U],
 	name string,

scripting/internal/js/array.go

@@ -0,0 +1,6 @@
+package js
+
+type Array[T any] interface {
+	Value[T]
+	Push(Value[T]) error
+}

scripting/internal/js/callback_context.go

@@ -169,6 +169,7 @@ type ValueFactory[T any] interface {
 
 	NewPromise() Promise[T]
 	NewString(string) Value[T]
+	NewNumber(float64) Value[T]
 	NewBoolean(bool) Value[T]
 	NewObject() Object[T]
 	NewFunction(Callback[T]) Function[T]
@@ -179,7 +180,7 @@ type ValueFactory[T any] interface {
 
 	// NewArray creates a JavaScript array containing the values. If any value
 	// is nil, it will become undefined in the resulting array.
-	NewArray(...Value[T]) Value[T]
+	NewArray(...Value[T]) Array[T]
 	// NewIterator returns an object implementing the [Iterator protocol]
 	//
 	// [Iterator protocol]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_iterator_protocol

scripting/internal/js/value.go

@@ -1,5 +1,12 @@
 package js
 
+import (
+	"errors"
+	"fmt"
+
+	"github.com/gost-dom/browser/internal/constants"
+)
+
 // Value represents a value in JavaScript. Referential equality cannot be used
 // to check if to Value instances represent the same value in JavaScript. Use
 // StrictEquals to check if two values are equal.
@@ -15,6 +22,7 @@ type Value[T any] interface {
 	Self() T
 
 	String() string
+	Number() float64
 	Int32() int32
 	Uint32() uint32
 	Boolean() bool
@@ -23,16 +31,24 @@ type Value[T any] interface {
 	IsNull() bool
 	IsSymbol() bool
 	IsString() bool
+	IsNumber() bool
 	IsObject() bool
 	IsBoolean() bool
 	IsFunction() bool
+	IsArray() bool
 
 	AsFunction() (Function[T], bool)
 	AsObject() (Object[T], bool)
 
 	StrictEquals(Value[T]) bool
 }
 
+// IsNullish returns whether a JavaScript value is null or undefined.
+func IsNullish[T any](v Value[T]) bool { return v == nil || v.IsNull() || v.IsUndefined() }
+
+func IsUndefined[T any](v Value[T]) bool { return v == nil || v.IsUndefined() }
+func IsBoolean[T any](v Value[T]) bool   { return v != nil && v.IsBoolean() }
+
 type Function[T any] interface {
 	Value[T]
 
@@ -100,14 +116,108 @@ type Promise[T any] interface {
 	Reject(Value[T])
 }
 
-// IsNullish returns whether a JavaScript value is null or undefined.
-func IsNullish[T any](v Value[T]) bool { return v == nil || v.IsNull() || v.IsUndefined() }
-
-func IsBoolean[T any](v Value[T]) bool { return v != nil && v.IsBoolean() }
-
 func AsFunction[T any](v Value[T]) (Function[T], bool) {
 	if IsNullish(v) {
 		return nil, false
 	}
 	return v.AsFunction()
 }
+
+func Clone[T any](v Value[T], s Scope[T]) (Value[T], error) {
+	var objects [][2]Value[T]
+	return clone(v, s, &objects)
+}
+
+func clone[T any](v Value[T], s Scope[T], objects *[][2]Value[T]) (Value[T], error) {
+	switch {
+	case v == nil || v.IsUndefined():
+		return s.Undefined(), nil
+	case v.IsNull():
+		return s.Null(), nil
+	case v.IsUndefined():
+		return s.Undefined(), nil
+	case v.IsString():
+		return s.NewString(v.String()), nil
+	case v.IsNumber():
+		return s.NewNumber(v.Number()), nil
+	case v.IsBoolean():
+		return s.NewBoolean(v.Boolean()), nil
+	case v.IsArray():
+		return cloneArray(v, s, objects)
+	case v.IsFunction():
+		//TODO: Use correct error
+		return nil, errors.New("Serialize function")
+	}
+	if o, ok := v.AsObject(); ok {
+		return cloneObject(o, s, objects)
+	}
+	return nil, fmt.Errorf("Unable to clone value: %v", v)
+}
+
+func findKnownValue[T any](o Value[T], knownObjects *[][2]Value[T]) (Value[T], bool) {
+	for _, pair := range *knownObjects {
+		known := pair[0]
+		res := pair[1]
+		if o.StrictEquals(known) {
+			return res, true
+		}
+	}
+	return nil, false
+}
+
+func cloneArray[T any](
+	v Value[T],
+	s Scope[T],
+	knownObjects *[][2]Value[T],
+) (Value[T], error) {
+	if existing, ok := findKnownValue(v, knownObjects); ok {
+		return existing, nil
+	}
+	o, ok := v.AsObject()
+	if !ok {
+		return nil, fmt.Errorf(
+			"Object was an array, but not convertible to object. %w",
+			constants.ErrGostDomBug,
+		)
+	}
+	res := s.NewArray()
+	*knownObjects = append(*knownObjects, [2]Value[T]{v, res})
+
+	for v, err := range Iterate(o) {
+		if err != nil {
+			return nil, err
+		}
+		cloned, err := clone(v, s, knownObjects)
+		if err != nil {
+			return nil, err
+		}
+		res.Push(cloned)
+	}
+	// TODO: Potential bug here, if the array references itself recursively,
+	// this would lead to a stack overflow error.
+	return res, nil
+}
+
+func cloneObject[T any](o Object[T], s Scope[T], knownObjects *[][2]Value[T]) (Value[T], error) {
+	if existing, ok := findKnownValue(o, knownObjects); ok {
+		return existing, nil
+	}
+	res := s.NewObject()
+	*knownObjects = append(*knownObjects, [2]Value[T]{o, res})
+	keys, err := o.Keys()
+	if err != nil {
+		return nil, err
+	}
+	for _, k := range keys {
+		oldV, err := o.Get(k)
+		if err != nil {
+			return nil, err
+		}
+		newV, err := clone(oldV, s, knownObjects)
+		if err != nil {
+			return nil, err
+		}
+		res.Set(k, newV)
+	}
+	return res, nil
+}

scripting/internal/scripttests/engine_suites.go

@@ -0,0 +1,96 @@
+package scripttests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/gost-dom/browser/html"
+	"github.com/gost-dom/browser/internal/entity"
+	"github.com/gost-dom/browser/internal/testing/htmltest"
+	"github.com/gost-dom/browser/scripting/internal/js"
+	"github.com/stretchr/testify/assert"
+)
+
+// RunScriptEngineSuites runs test suites of the script engine without a
+// predefined global scope. In contrast to [RunSuites] that expect an engine
+// configured for the global scope in the Window realm.
+func RunScriptEngineSuites[T any](t *testing.T, f ScriptEngineFactory[T]) {
+	type Global = entity.Entity
+
+	e := f(js.ConfigurerFunc[T](func(e js.ScriptEngine[T]) {
+		global := e.ConfigureGlobalScope("Global", nil)
+		global.CreateOperation("store", func(ctx js.CallbackContext[T]) (js.Value[T], error) {
+			v, ok := ctx.ConsumeArg()
+			if !ok {
+				return nil, ctx.NewTypeError("Missing argument")
+			}
+			c, err := js.As[entity.Components](ctx.GlobalThis().NativeValue(), nil)
+			if err != nil {
+				return nil, err
+			}
+			entity.SetComponentType(c, v)
+			return nil, nil
+		})
+
+		global.CreateOperation("get", func(ctx js.CallbackContext[T]) (js.Value[T], error) {
+			c, err := js.As[entity.Components](ctx.GlobalThis().NativeValue(), nil)
+			if err != nil {
+				return nil, err
+			}
+			val, ok := entity.ComponentType[js.Value[T]](c)
+			if !ok {
+				return nil, fmt.Errorf("Value missing")
+			}
+
+			res, err := js.Clone(val, ctx)
+			if err != nil {
+				t.Errorf("Clone error: %v", err)
+			}
+			return res, err
+		})
+	}))
+
+	global1 := new(Global)
+	global2 := new(Global)
+
+	c1 := htmltest.NewScriptContextHelper(
+		t,
+		e.NewHost(html.ScriptEngineOptions{}).NewContext(dummyContext{global1, t.Context()}),
+	)
+	c2 := htmltest.NewScriptContextHelper(
+		t,
+		e.NewHost(html.ScriptEngineOptions{}).NewContext(dummyContext{global2, t.Context()}),
+	)
+
+	assert.NoError(t, c1.Run(`
+		const b = {
+			id: "b",
+		}
+		const arr = [1,2,3]
+		const recursiveArray = [1,2,3]
+		recursiveArray.push(recursiveArray)
+		const a = {
+			stringVal: "hello",
+			numberVal: 42.5,
+			trueVal: true,
+			falseVal: false,
+			b1: b,
+			b2: b,
+			arr1: arr,
+			arr2: arr,
+			recursiveArray,
+		}
+		globalThis.store(a)
+	`))
+	val, ok := entity.ComponentType[js.Value[T]](global1)
+	assert.True(t, ok)
+	entity.SetComponentType(global2, val)
+
+	assert.NoError(t, c2.Run("const cloned = globalThis.get()"))
+	assert.Equal(t, "hello", c2.MustEval("cloned.stringVal"))
+	assert.Equal(t, 42.5, c2.MustEval("cloned.numberVal"))
+	assert.True(t, c2.MustEval("cloned.trueVal").(bool))
+	assert.False(t, c2.MustEval("cloned.falseVal").(bool))
+	assert.True(t, c2.MustEval("cloned.b1 === cloned.b2").(bool))
+	assert.Equal(t, "1,2,3", c2.MustEval("cloned.arr1.join(',')"))
+}

scripting/internal/scripttests/suites.go

@@ -1,12 +1,17 @@
 package scripttests
 
 import (
+	"context"
+	"log/slog"
+	"net/http"
 	"testing"
 
 	"github.com/gost-dom/browser/html"
+	"github.com/gost-dom/browser/internal/entity"
 	"github.com/gost-dom/browser/internal/testing/browsertest"
 	"github.com/gost-dom/browser/scripting/internal/dom/domsuite"
 	"github.com/gost-dom/browser/scripting/internal/html/htmlsuite"
+	"github.com/gost-dom/browser/scripting/internal/js"
 	"github.com/gost-dom/browser/scripting/internal/uievents/uieventssuite"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
@@ -28,9 +33,11 @@ func RunBasicSuite(t *testing.T, e html.ScriptEngine) {
 	assert.True(t, w.MustEval("window === globalThis").(bool))
 }
 
+type ScriptEngineFactory[T any] = func(js.Configurer[T]) html.ScriptEngine
+
 func RunSuites(t *testing.T, e html.ScriptEngine) {
 	t.Run("ScriptEngineBehaviour", func(t *testing.T) { testScriptEngineBehaviour(t, e) })
-	t.Run("SharowRoot", runSuite(NewShadowRootSuite(e)))
+	t.Run("ShadowRoot", runSuite(NewShadowRootSuite(e)))
 	t.Run("DocumentFragment", runSuite(NewDocumentFragmentSuite(e)))
 	t.Run("XMLHttpRequest", runSuite(NewXMLHttpRequestSuite(e)))
 	t.Run("Location", runSuite(NewLocationSuite(e)))
@@ -58,3 +65,13 @@ func RunSuites(t *testing.T, e html.ScriptEngine) {
 	t.Run("html", func(t *testing.T) { htmlsuite.RunHtmlSuite(t, e) })
 	t.Run("dom", func(t *testing.T) { domsuite.RunDomSuite(t, e) })
 }
+
+type dummyContext struct {
+	*entity.Entity
+	ctx context.Context
+}
+
+func (c dummyContext) Context() context.Context { return c.ctx }
+func (c dummyContext) HTTPClient() http.Client  { return *http.DefaultClient }
+func (c dummyContext) LocationHREF() string     { return "http://example.com" }
+func (c dummyContext) Logger() *slog.Logger     { return nil }

scripting/sobekengine/array.go

@@ -0,0 +1,31 @@
+package sobekengine
+
+import (
+	"errors"
+
+	"github.com/grafana/sobek"
+)
+
+type array struct {
+	value
+	obj *sobek.Object
+}
+
+func newArray(c *scriptContext, o *sobek.Object) jsArray {
+	return array{value{c, o}, o}
+}
+
+func (a array) Push(v jsValue) error {
+	push := a.obj.Get("push")
+	if push == nil {
+		return errors.New("gost-dom/sobekengine: array.push: Underlying object doesn't have a push")
+	}
+	p, ok := sobek.AssertFunction(push)
+	if !ok {
+		return errors.New(
+			"gost-dom/sobekengine: array.push: Underlying object's push is not a function",
+		)
+	}
+	_, err := p(a.obj, v.Self().value)
+	return err
+}