improve stream

README.md

@@ -161,6 +161,7 @@ All help is welcome. If you are interested by this project, please contact me
 | Promise | Full | https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise |
 | PushManager | Full | https://developer.mozilla.org/en-US/docs/Web/API/PushManager |
 | ReadableStream | Full | https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream |
+
 | Response | Full | https://developer.mozilla.org/fr/docs/Web/API/Response |
 | ServiceWorker | Full | https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker|
 | ServiceWorkerContainer | Full | https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer|

base/blob/blob.go

@@ -188,7 +188,7 @@ func (b Blob) Stream() (stream.ReadableStream, error) {
 	var obj js.Value
 
 	if obj, err = b.Call("stream"); err == nil {
-		return stream.NewFromJSObject(obj)
+		return stream.NewReadableStreamFromJSObject(obj)
 
 	}
 	return readablestream.ReadableStream{}, err

base/compressionstream/compressionstream.go

@@ -0,0 +1,113 @@
+package compressionstream
+
+import (
+	"sync"
+	"syscall/js"
+
+	"github.com/realPy/hogosuru/base/baseobject"
+	"github.com/realPy/hogosuru/base/initinterface"
+	"github.com/realPy/hogosuru/base/response"
+	"github.com/realPy/hogosuru/base/stream"
+)
+
+func init() {
+
+	initinterface.RegisterInterface(GetInterface)
+
+}
+
+var singleton sync.Once
+
+var compressionstreaminterface js.Value
+
+// GetJSInterface Get the JS Fetch Interface If nil browser doesn't implement it
+func GetInterface() js.Value {
+
+	singleton.Do(func() {
+		var err error
+		if compressionstreaminterface, err = baseobject.Get(js.Global(), "CompressionStream"); err != nil {
+			compressionstreaminterface = js.Undefined()
+		}
+
+		response.GetInterface()
+		baseobject.Register(compressionstreaminterface, func(v js.Value) (interface{}, error) {
+			return NewFromJSObject(v)
+		})
+	})
+
+	return compressionstreaminterface
+}
+
+// CompressionStream struct
+type CompressionStream struct {
+	baseobject.BaseObject
+}
+
+type CompressionStreamFrom interface {
+	CompressionStream_() CompressionStream
+}
+
+func (c CompressionStream) CompressionStream() CompressionStream {
+	return c
+}
+
+func New(format string) (CompressionStream, error) {
+	var c CompressionStream
+	var err error
+	var obj js.Value
+
+	if compressionstreami := GetInterface(); !compressionstreami.IsUndefined() {
+
+		if obj, err = baseobject.New(compressionstreami, js.ValueOf(format)); err == nil {
+			c.BaseObject = c.SetObject(obj)
+		}
+
+	} else {
+		err = ErrNotImplemented
+	}
+	return c, err
+
+}
+
+func NewFromJSObject(obj js.Value) (CompressionStream, error) {
+	var c CompressionStream
+	var err error
+	if compressionstreami := GetInterface(); !compressionstreami.IsUndefined() {
+		if obj.IsUndefined() || obj.IsNull() {
+			err = baseobject.ErrUndefinedValue
+		} else {
+
+			if obj.InstanceOf(compressionstreami) {
+
+				c.BaseObject = c.SetObject(obj)
+			} else {
+				err = ErrNotACompressionStream
+			}
+		}
+	} else {
+		err = ErrNotImplemented
+	}
+	return c, err
+}
+
+func (c CompressionStream) Readable() (stream.ReadableStream, error) {
+	var err error
+	var obj js.Value
+
+	if obj, err = c.Get("readable"); err == nil {
+		return stream.NewReadableStreamFromJSObject(obj)
+
+	}
+	return stream.ReadableStream{}, err
+}
+
+func (c CompressionStream) Writable() (stream.WritableStream, error) {
+	var err error
+	var obj js.Value
+
+	if obj, err = c.Get("writable"); err == nil {
+		return stream.NewWriteableStreamFromJSObject(obj)
+
+	}
+	return stream.WritableStream{}, err
+}

base/compressionstream/compressionstream_test.go

@@ -0,0 +1,50 @@
+package compressionstream
+
+import (
+	"syscall/js"
+	"testing"
+
+	"github.com/realPy/hogosuru/base/baseobject"
+	"github.com/realPy/hogosuru/testingutils"
+)
+
+func TestMain(m *testing.M) {
+	baseobject.SetSyscall()
+	baseobject.Eval(`enc=new CompressionStream("gzip")`)
+	m.Run()
+}
+
+func TestNewFromJSObject(t *testing.T) {
+
+	if obj, err := baseobject.Get(js.Global(), "enc"); testingutils.AssertErr(t, err) {
+		if nav, err := NewFromJSObject(obj); testingutils.AssertErr(t, err) {
+
+			testingutils.AssertExpect(t, "CompressionStream", nav.ConstructName_())
+
+		}
+	}
+
+	encstream, err := New("gzip")
+	testingutils.AssertExpect(t, nil, err)
+	testingutils.AssertExpect(t, "CompressionStream", encstream.ConstructName_())
+}
+
+var methodsAttempt []map[string]interface{} = []map[string]interface{}{
+	{"method": "Readable", "type": "constructnamechecking", "resultattempt": "ReadableStream"},
+	{"method": "Writable", "type": "constructnamechecking", "resultattempt": "WritableStream"},
+}
+
+func TestMethods(t *testing.T) {
+
+	if obj, err := baseobject.Get(js.Global(), "enc"); testingutils.AssertErr(t, err) {
+
+		if nav, err := NewFromJSObject(obj); testingutils.AssertErr(t, err) {
+
+			for _, result := range methodsAttempt {
+				testingutils.InvokeCheck(t, nav, result)
+			}
+
+		}
+
+	}
+}

base/compressionstream/errors.go

@@ -0,0 +1,9 @@
+package compressionstream
+
+import "errors"
+
+var (
+	//ErrNotImplemented ErrNotImplemented error
+	ErrNotImplemented        = errors.New("Browser not implemented CompressionStream")
+	ErrNotACompressionStream = errors.New("Object is not a CommpressionStream")
+)

base/decompressionstream/decompressionstream.go

@@ -0,0 +1,112 @@
+package decompressionstream
+
+import (
+	"sync"
+	"syscall/js"
+
+	"github.com/realPy/hogosuru/base/baseobject"
+	"github.com/realPy/hogosuru/base/initinterface"
+	"github.com/realPy/hogosuru/base/response"
+	"github.com/realPy/hogosuru/base/stream"
+)
+
+func init() {
+
+	initinterface.RegisterInterface(GetInterface)
+}
+
+var singleton sync.Once
+
+var decompressionstreaminterface js.Value
+
+// GetJSInterface Get the JS Fetch Interface If nil browser doesn't implement it
+func GetInterface() js.Value {
+
+	singleton.Do(func() {
+		var err error
+		if decompressionstreaminterface, err = baseobject.Get(js.Global(), "DecompressionStream"); err != nil {
+			decompressionstreaminterface = js.Undefined()
+		}
+
+		response.GetInterface()
+		baseobject.Register(decompressionstreaminterface, func(v js.Value) (interface{}, error) {
+			return NewFromJSObject(v)
+		})
+	})
+
+	return decompressionstreaminterface
+}
+
+// DecompressionStream struct
+type DecompressionStream struct {
+	baseobject.BaseObject
+}
+
+type DecompressionStreamFrom interface {
+	DecompressionStream_() DecompressionStream
+}
+
+func (d DecompressionStream) DecompressionStream_() DecompressionStream {
+	return d
+}
+
+func New(format string) (DecompressionStream, error) {
+	var d DecompressionStream
+	var err error
+	var obj js.Value
+
+	if decompressionstreami := GetInterface(); !decompressionstreami.IsUndefined() {
+
+		if obj, err = baseobject.New(decompressionstreami, js.ValueOf(format)); err == nil {
+			d.BaseObject = d.SetObject(obj)
+		}
+
+	} else {
+		err = ErrNotImplemented
+	}
+	return d, err
+
+}
+
+func NewFromJSObject(obj js.Value) (DecompressionStream, error) {
+	var d DecompressionStream
+	var err error
+	if decompressionstreami := GetInterface(); !decompressionstreami.IsUndefined() {
+		if obj.IsUndefined() || obj.IsNull() {
+			err = baseobject.ErrUndefinedValue
+		} else {
+
+			if obj.InstanceOf(decompressionstreami) {
+
+				d.BaseObject = d.SetObject(obj)
+			} else {
+				err = ErrNotADecompressionStream
+			}
+		}
+	} else {
+		err = ErrNotImplemented
+	}
+	return d, err
+}
+
+func (d DecompressionStream) Readable() (stream.ReadableStream, error) {
+	var err error
+	var obj js.Value
+
+	if obj, err = d.Get("readable"); err == nil {
+		return stream.NewReadableStreamFromJSObject(obj)
+
+	}
+	return stream.ReadableStream{}, err
+}
+
+func (d DecompressionStream) Writable() (stream.WritableStream, error) {
+	var err error
+	var obj js.Value
+
+	if obj, err = d.Get("writable"); err == nil {
+		return stream.NewWriteableStreamFromJSObject(obj)
+
+	}
+	return stream.WritableStream{}, err
+}

base/decompressionstream/decompressionstream_test.go

@@ -0,0 +1,50 @@
+package decompressionstream
+
+import (
+	"syscall/js"
+	"testing"
+
+	"github.com/realPy/hogosuru/base/baseobject"
+	"github.com/realPy/hogosuru/testingutils"
+)
+
+func TestMain(m *testing.M) {
+	baseobject.SetSyscall()
+	baseobject.Eval(`dec=new DecompressionStream("gzip")`)
+	m.Run()
+}
+
+func TestNewFromJSObject(t *testing.T) {
+
+	if obj, err := baseobject.Get(js.Global(), "dec"); testingutils.AssertErr(t, err) {
+		if nav, err := NewFromJSObject(obj); testingutils.AssertErr(t, err) {
+
+			testingutils.AssertExpect(t, "DecompressionStream", nav.ConstructName_())
+
+		}
+	}
+
+	decstream, err := New("gzip")
+	testingutils.AssertExpect(t, nil, err)
+	testingutils.AssertExpect(t, "DecompressionStream", decstream.ConstructName_())
+}
+
+var methodsAttempt []map[string]interface{} = []map[string]interface{}{
+	{"method": "Readable", "type": "constructnamechecking", "resultattempt": "ReadableStream"},
+	{"method": "Writable", "type": "constructnamechecking", "resultattempt": "WritableStream"},
+}
+
+func TestMethods(t *testing.T) {
+
+	if obj, err := baseobject.Get(js.Global(), "dec"); testingutils.AssertErr(t, err) {
+
+		if nav, err := NewFromJSObject(obj); testingutils.AssertErr(t, err) {
+
+			for _, result := range methodsAttempt {
+				testingutils.InvokeCheck(t, nav, result)
+			}
+
+		}
+
+	}
+}

base/decompressionstream/errors.go

@@ -0,0 +1,9 @@
+package decompressionstream
+
+import "errors"
+
+var (
+	//ErrNotImplemented ErrNotImplemented error
+	ErrNotImplemented          = errors.New("Browser not implemented DecompressionStream")
+	ErrNotADecompressionStream = errors.New("Object is not a DecommpressionStream")
+)

base/response/response.go

@@ -60,13 +60,21 @@ func GetInterface() js.Value {
 }
 
 // New Create a response
-func New() (Response, error) {
+func New(opts ...interface{}) (Response, error) {
 	var r Response
 	var obj js.Value
 	var err error
+	var array []interface{}
+
+	for _, opt := range opts {
+		if v, ok := opt.(baseobject.ObjectFrom); ok {
+			array = append(array, v.JSObject())
+		}
+
+	}
 	if ri := GetInterface(); !ri.IsUndefined() {
 
-		if obj, err = baseobject.New(ri); err == nil {
+		if obj, err = baseobject.New(ri, array...); err == nil {
 			r.BaseObject = r.SetObject(obj)
 		}
 
@@ -264,7 +272,7 @@ func (r Response) Body() (stream.ReadableStream, error) {
 	var err error
 	var s stream.ReadableStream
 	if obj, err = r.Get("body"); err == nil {
-		s, err = stream.NewFromJSObject(obj)
+		s, err = stream.NewReadableStreamFromJSObject(obj)
 
 	}
 	return s, err