Merge pull request #124 from realPy/develop

Develop

README.md

@@ -51,6 +51,12 @@ Start the tinygo container with your source
 docker run --rm -it -w /go/src/yourproject -v "$PWD":/go/src/yourproject tinygo/tinygo bash 
 ```
 
+Build your binary
+
+```
+tinygo build -o -o ./yourstaticdirectory/project.wasm  --no-debug -target wasm main.go
+```
+
 If you the compiler is upgraded, sync the wasm_exec.js loader with your current wasm_exec.js compiler version
 
 ```
@@ -133,7 +139,7 @@ Just replace the "example.wasm" with the relative (or absolute) link of you bina
 
 Hogosuru is splitted in several directory for each components for a specific reason:  
 Avoid the inclusion of binary code that would not be necessary and thus avoid loading the entire framework (and especially having the smallest binaries possible)  
-Apart from the dependence of the components between them, tinygo will include the strict necessary for the compilation of your project
+Apart from the dependence of the components between them, the compiler will include the strict necessary for the compilation of your project
 
 ## Minimal code for your wasm
 

dragevent/dragevent.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/realPy/hogosuru/baseobject"
 	"github.com/realPy/hogosuru/datatransfer"
-	"github.com/realPy/hogosuru/event"
+	"github.com/realPy/hogosuru/mouseevent"
 )
 
 var singleton sync.Once
@@ -18,8 +18,7 @@ var drageventinterface js.Value
 
 //DragEvent DragEvent struct
 type DragEvent struct {
-	//Must be herited from mouseevent
-	event.Event
+	mouseevent.MouseEvent
 }
 
 type DragEventFrom interface {

json/json.go

@@ -84,22 +84,27 @@ func extractJsonFromObject(jsobj js.Value) interface{} {
 	if obj, err := object.NewFromJSObject(jsobj); err == nil {
 
 		if ok, err := array.IsArray(obj.BaseObject); ok && err == nil {
-			var array []interface{}
-			keys, _ := obj.Values()
-			itkeys, _ := keys.Values()
 
-			for _, vkey, err := itkeys.Next(); err == nil; _, vkey, err = itkeys.Next() {
+			var arrayret []interface{}
+
+			if a, err := array.NewFromJSObject(obj.JSObject()); err == nil {
+				if it, err := a.Entries(); err == nil {
+					for _, value, err := it.Next(); err == nil; _, value, err = it.Next() {
+
+						if obj1, ok := value.(baseobject.ObjectFrom); !ok {
+							arrayret = append(arrayret, value)
 
-				if obj1, ok := vkey.(baseobject.ObjectFrom); !ok {
-					array = append(array, vkey)
+						} else {
+							arrayret = append(arrayret, extractJsonFromObject(obj1.JSObject()))
+						}
+
+					}
 
-				} else {
-					array = append(array, extractJsonFromObject(obj1.JSObject()))
 				}
 
 			}
 
-			retvalue = array
+			retvalue = arrayret
 
 		} else {
 

keyobservable.go

@@ -14,7 +14,7 @@ var ko Observable
 
 var (
 	//ErrKeyNotFound ErrKeyNotFound error
-	ErrKeyNotFound = errors.New("Key ot found")
+	ErrKeyNotFound = errors.New("Key not found")
 )
 
 type KeyObservableFunc func(value interface{})

mouseevent/errors.go

@@ -0,0 +1,9 @@
+package mouseevent
+
+import "errors"
+
+var (
+	//ErrNotImplemented ErrNotImplemented error
+	ErrNotImplemented = errors.New("Browser not implemented MouseEvent")
+	ErrNotAMouseEvent = errors.New("Object is not a MouseEvent")
+)

mouseevent/mouseevent.go

@@ -0,0 +1,221 @@
+package mouseevent
+
+import (
+	"sync"
+	"syscall/js"
+
+	"github.com/realPy/hogosuru/baseobject"
+	"github.com/realPy/hogosuru/event"
+	"github.com/realPy/hogosuru/eventtarget"
+)
+
+var singleton sync.Once
+
+var mouseeventinterface js.Value
+
+//MouseEvent MouseEvent struct
+type MouseEvent struct {
+	//Must be herited from mouseevent
+	event.Event
+}
+
+type MouseEventFrom interface {
+	MouseEvent_() MouseEvent
+}
+
+func (m MouseEvent) MouseEvent_() MouseEvent {
+	return m
+}
+
+//GetInterface get MouseEvent interface
+func GetInterface() js.Value {
+
+	singleton.Do(func() {
+
+		var err error
+		if mouseeventinterface, err = baseobject.Get(js.Global(), "MouseEvent"); err != nil {
+			mouseeventinterface = js.Undefined()
+		}
+		baseobject.Register(mouseeventinterface, func(v js.Value) (interface{}, error) {
+			return NewFromJSObject(v)
+		})
+
+		eventtarget.GetInterface()
+	})
+
+	return mouseeventinterface
+}
+
+func New(typeevent string, init ...map[string]interface{}) (MouseEvent, error) {
+
+	var m MouseEvent
+	var obj js.Value
+	var err error
+	var arrayJS []interface{}
+
+	if mei := GetInterface(); !mei.IsUndefined() {
+		arrayJS = append(arrayJS, js.ValueOf(typeevent))
+		if len(init) > 0 {
+			arrayJS = append(arrayJS, js.ValueOf(init[0]))
+		}
+		if obj, err = baseobject.New(mei, arrayJS...); err == nil {
+			m.BaseObject = m.SetObject(obj)
+		}
+
+	} else {
+		err = ErrNotImplemented
+	}
+	return m, err
+}
+
+func NewFromJSObject(obj js.Value) (MouseEvent, error) {
+	var m MouseEvent
+	var err error
+	if mei := GetInterface(); !mei.IsUndefined() {
+		if obj.IsUndefined() || obj.IsNull() {
+			err = baseobject.ErrUndefinedValue
+		} else {
+
+			if obj.InstanceOf(mei) {
+				m.BaseObject = m.SetObject(obj)
+
+			} else {
+				err = ErrNotAMouseEvent
+			}
+		}
+	} else {
+		err = ErrNotImplemented
+	}
+	return m, err
+}
+
+func (m MouseEvent) AltKey() (bool, error) {
+
+	return m.GetAttributeBool("altKey")
+}
+
+func (m MouseEvent) Button() (int, error) {
+
+	return m.GetAttributeInt("button")
+}
+
+func (m MouseEvent) Buttons() (int, error) {
+
+	return m.GetAttributeInt("buttons")
+}
+
+func (m MouseEvent) ClientX() (float64, error) {
+
+	return m.GetAttributeDouble("clientX")
+}
+
+func (m MouseEvent) ClientY() (float64, error) {
+
+	return m.GetAttributeDouble("clientY")
+}
+
+func (m MouseEvent) CtrlKey() (bool, error) {
+
+	return m.GetAttributeBool("ctrlKey")
+}
+
+func (m MouseEvent) MetaKey() (bool, error) {
+
+	return m.GetAttributeBool("metaKey")
+}
+
+func (m MouseEvent) MovementX() (int, error) {
+
+	return m.GetAttributeInt("movementX")
+}
+
+func (m MouseEvent) MovementY() (int, error) {
+
+	return m.GetAttributeInt("movementY")
+}
+
+func (m MouseEvent) OffsetX() (float64, error) {
+
+	return m.GetAttributeDouble("offsetX")
+}
+
+func (m MouseEvent) OffsetY() (float64, error) {
+
+	return m.GetAttributeDouble("offsetY")
+}
+
+func (m MouseEvent) PageX() (int, error) {
+
+	return m.GetAttributeInt("pageX")
+}
+
+func (m MouseEvent) PageY() (int, error) {
+
+	return m.GetAttributeInt("pageY")
+}
+
+func (m MouseEvent) Region() (string, error) {
+
+	return m.GetAttributeString("region")
+}
+
+func (m MouseEvent) RelatedTarget() (eventtarget.EventTarget, error) {
+	var err error
+	var obj interface{}
+
+	var e eventtarget.EventTarget
+
+	if obj, err = m.GetAttributeGlobal("relatedTarget"); err == nil {
+
+		if obj != nil {
+			if efrom, ok := obj.(eventtarget.EventTargetFrom); ok {
+				e = efrom.EventTarget_()
+			}
+		} else {
+			err = baseobject.ErrUndefinedValue
+		}
+
+	}
+	return e, err
+}
+
+func (m MouseEvent) ScreenX() (float64, error) {
+
+	return m.GetAttributeDouble("screenX")
+}
+
+func (m MouseEvent) ScreenY() (float64, error) {
+
+	return m.GetAttributeDouble("screenY")
+}
+
+func (m MouseEvent) ShiftKey() (bool, error) {
+
+	return m.GetAttributeBool("shiftKey")
+}
+
+func (m MouseEvent) X() (float64, error) {
+
+	return m.GetAttributeDouble("x")
+}
+
+func (m MouseEvent) Y() (float64, error) {
+
+	return m.GetAttributeDouble("y")
+}
+
+func (m MouseEvent) GetModifierState(args string) (bool, error) {
+	var err error
+	var obj js.Value
+	var result bool
+
+	if obj, err = m.Call("getModifierState", js.ValueOf(args)); err == nil {
+		if obj.Type() == js.TypeBoolean {
+			result = obj.Bool()
+		} else {
+			err = baseobject.ErrObjectNotBool
+		}
+	}
+
+	return result, err
+}

mouseevent/mouseevent_test.go

@@ -0,0 +1,77 @@
+package mouseevent
+
+import (
+	"syscall/js"
+	"testing"
+
+	"github.com/realPy/hogosuru/baseobject"
+	"github.com/realPy/hogosuru/testingutils"
+)
+
+func TestMain(m *testing.M) {
+	baseobject.SetSyscall()
+	baseobject.Eval(`mevent=new MouseEvent("test",{altKey:true,button:2,buttons:16,clientX:200,clientY:453,ctrlKey:true,metaKey:true,movementX:100,movementY:300,screenX:89,screenY:43,shiftKey:true})
+
+	`)
+	m.Run()
+}
+
+func TestNew(t *testing.T) {
+
+	if k, err := New("test"); testingutils.AssertErr(t, err) {
+
+		testingutils.AssertExpect(t, "[object MouseEvent]", k.ToString_())
+
+	}
+}
+
+func TestNewFromJSObject(t *testing.T) {
+
+	if obj, err := baseobject.Get(js.Global(), "mevent"); testingutils.AssertErr(t, err) {
+		if mevent, err := NewFromJSObject(obj); testingutils.AssertErr(t, err) {
+
+			testingutils.AssertExpect(t, "[object MouseEvent]", mevent.ToString_())
+
+		}
+	}
+
+}
+
+var methodsAttempt []map[string]interface{} = []map[string]interface{}{
+
+	{"method": "AltKey", "resultattempt": true},
+	{"method": "Button", "resultattempt": 2},
+	{"method": "Buttons", "resultattempt": 16},
+	{"method": "ClientX", "resultattempt": float64(200)},
+	{"method": "ClientY", "resultattempt": float64(453)},
+	{"method": "CtrlKey", "resultattempt": true},
+	{"method": "MetaKey", "resultattempt": true},
+	{"method": "MovementX", "resultattempt": 100},
+	{"method": "MovementY", "resultattempt": 300},
+	{"method": "OffsetX", "resultattempt": float64(200)},
+	{"method": "OffsetY", "resultattempt": float64(453)},
+	{"method": "PageX", "resultattempt": 200},
+	{"method": "PageY", "resultattempt": 453},
+	{"method": "RelatedTarget", "type": "error", "resultattempt": baseobject.ErrUndefinedValue},
+	{"method": "ScreenX", "resultattempt": float64(89)},
+	{"method": "ScreenY", "resultattempt": float64(43)},
+	{"method": "ShiftKey", "resultattempt": true},
+	{"method": "X", "resultattempt": float64(200)},
+	{"method": "Y", "resultattempt": float64(453)},
+	{"method": "GetModifierState", "args": []interface{}{"Accel"}, "resultattempt": true},
+}
+
+func TestMethods(t *testing.T) {
+
+	if obj, err := baseobject.Get(js.Global(), "mevent"); testingutils.AssertErr(t, err) {
+
+		if mevent, err := NewFromJSObject(obj); testingutils.AssertErr(t, err) {
+
+			for _, result := range methodsAttempt {
+				testingutils.InvokeCheck(t, mevent, result)
+			}
+
+		}
+
+	}
+}