type reader struct{}
func (r *reader) Read(b []byte) (int, error) {
- jsCrypto.Call("getRandomValues", b)
+ a := js.TypedArrayOf(b)
+ jsCrypto.Call("getRandomValues", a)
+ a.Release()
return len(b), nil
}
return
}
value := make([]byte, result.Get("value").Get("byteLength").Int())
- js.ValueOf(value).Call("set", result.Get("value"))
+ a := js.TypedArrayOf(value)
+ a.Call("set", result.Get("value"))
+ a.Release()
bCh <- value
})
defer success.Close()
// Wrap the input ArrayBuffer with a Uint8Array
uint8arrayWrapper := js.Global().Get("Uint8Array").New(args[0])
value := make([]byte, uint8arrayWrapper.Get("byteLength").Int())
- js.ValueOf(value).Call("set", uint8arrayWrapper)
+ a := js.TypedArrayOf(value)
+ a.Call("set", uint8arrayWrapper)
+ a.Release()
bCh <- value
})
defer success.Close()
return n, err
}
- n, err := fsCall("readSync", fd, b, 0, len(b))
+ a := js.TypedArrayOf(b)
+ n, err := fsCall("readSync", fd, a, 0, len(b))
+ a.Release()
if err != nil {
return 0, err
}
return n, err
}
- n, err := fsCall("writeSync", fd, b, 0, len(b))
+ a := js.TypedArrayOf(b)
+ n, err := fsCall("writeSync", fd, a, 0, len(b))
+ a.Release()
if err != nil {
return 0, err
}
}
func Pread(fd int, b []byte, offset int64) (int, error) {
- n, err := fsCall("readSync", fd, b, 0, len(b), offset)
+ a := js.TypedArrayOf(b)
+ n, err := fsCall("readSync", fd, a, 0, len(b), offset)
+ a.Release()
if err != nil {
return 0, err
}
}
func Pwrite(fd int, b []byte, offset int64) (int, error) {
- n, err := fsCall("writeSync", fd, b, 0, len(b), offset)
+ a := js.TypedArrayOf(b)
+ n, err := fsCall("writeSync", fd, a, 0, len(b), offset)
+ a.Release()
if err != nil {
return 0, err
}
return valueGlobal
}
-var uint8Array = valueGlobal.Get("Uint8Array")
-
-// ValueOf returns x as a JavaScript value.
+// ValueOf returns x as a JavaScript value:
+//
+// | Go | JavaScript |
+// | --------------------- | --------------------- |
+// | js.Value | [its value] |
+// | js.TypedArray | [typed array] |
+// | js.Callback | function |
+// | nil | null |
+// | bool | boolean |
+// | integers and floats | number |
+// | string | string |
func ValueOf(x interface{}) Value {
switch x := x.(type) {
case Value:
return x
+ case TypedArray:
+ return x.Value
case Callback:
return x.enqueueFn
case nil:
return floatValue(x)
case string:
return makeValue(stringVal(x))
- case []byte:
- if len(x) == 0 {
- return uint8Array.New(memory.Get("buffer"), 0, 0)
- }
- return uint8Array.New(memory.Get("buffer"), unsafe.Pointer(&x[0]), len(x))
default:
- panic("invalid value")
+ panic("ValueOf: invalid value")
}
}
}
}
+func TestTypedArrayOf(t *testing.T) {
+ testTypedArrayOf(t, "[]int8", []int8{0, -42, 0}, -42)
+ testTypedArrayOf(t, "[]int16", []int16{0, -42, 0}, -42)
+ testTypedArrayOf(t, "[]int32", []int32{0, -42, 0}, -42)
+ testTypedArrayOf(t, "[]uint8", []uint8{0, 42, 0}, 42)
+ testTypedArrayOf(t, "[]uint16", []uint16{0, 42, 0}, 42)
+ testTypedArrayOf(t, "[]uint32", []uint32{0, 42, 0}, 42)
+ testTypedArrayOf(t, "[]float32", []float32{0, -42.5, 0}, -42.5)
+ testTypedArrayOf(t, "[]float64", []float64{0, -42.5, 0}, -42.5)
+}
+
+func testTypedArrayOf(t *testing.T, name string, slice interface{}, want float64) {
+ t.Run(name, func(t *testing.T) {
+ a := js.TypedArrayOf(slice)
+ got := a.Index(1).Float()
+ a.Release()
+ if got != want {
+ t.Errorf("got %#v, want %#v", got, want)
+ }
+ })
+}
+
func TestNaN(t *testing.T) {
want := js.ValueOf(math.NaN())
got := dummys.Get("NaN")
--- /dev/null
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build js,wasm
+
+package js
+
+import (
+ "sync"
+ "unsafe"
+)
+
+var (
+ int8Array = Global().Get("Int8Array")
+ int16Array = Global().Get("Int16Array")
+ int32Array = Global().Get("Int32Array")
+ uint8Array = Global().Get("Uint8Array")
+ uint16Array = Global().Get("Uint16Array")
+ uint32Array = Global().Get("Uint32Array")
+ float32Array = Global().Get("Float32Array")
+ float64Array = Global().Get("Float64Array")
+)
+
+// TypedArray represents a JavaScript typed array.
+type TypedArray struct {
+ Value
+}
+
+// Release frees up resources allocated for the typed array.
+// The typed array and its buffer must not be accessed after calling Release.
+func (a TypedArray) Release() {
+ openTypedArraysMutex.Lock()
+ delete(openTypedArrays, a)
+ openTypedArraysMutex.Unlock()
+}
+
+var (
+ openTypedArraysMutex sync.Mutex
+ openTypedArrays = make(map[TypedArray]interface{})
+)
+
+// TypedArrayOf returns a JavaScript typed array backed by the slice's underlying array.
+// It can be passed to functions of this package that accept interface{}, for example Value.Set and Value.Call.
+//
+// The supported types are []int8, []int16, []int32, []uint8, []uint16, []uint32, []float32 and []float64.
+// Passing an unsupported value causes a panic.
+//
+// TypedArray.Release must be called to free up resources when the typed array will not be used any more.
+func TypedArrayOf(slice interface{}) TypedArray {
+ a := TypedArray{typedArrayOf(slice)}
+ openTypedArraysMutex.Lock()
+ openTypedArrays[a] = slice
+ openTypedArraysMutex.Unlock()
+ return a
+}
+
+func typedArrayOf(slice interface{}) Value {
+ switch slice := slice.(type) {
+ case []int8:
+ if len(slice) == 0 {
+ return int8Array.New(memory.Get("buffer"), 0, 0)
+ }
+ return int8Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
+ case []int16:
+ if len(slice) == 0 {
+ return int16Array.New(memory.Get("buffer"), 0, 0)
+ }
+ return int16Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
+ case []int32:
+ if len(slice) == 0 {
+ return int32Array.New(memory.Get("buffer"), 0, 0)
+ }
+ return int32Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
+ case []uint8:
+ if len(slice) == 0 {
+ return uint8Array.New(memory.Get("buffer"), 0, 0)
+ }
+ return uint8Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
+ case []uint16:
+ if len(slice) == 0 {
+ return uint16Array.New(memory.Get("buffer"), 0, 0)
+ }
+ return uint16Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
+ case []uint32:
+ if len(slice) == 0 {
+ return uint32Array.New(memory.Get("buffer"), 0, 0)
+ }
+ return uint32Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
+ case []float32:
+ if len(slice) == 0 {
+ return float32Array.New(memory.Get("buffer"), 0, 0)
+ }
+ return float32Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
+ case []float64:
+ if len(slice) == 0 {
+ return float64Array.New(memory.Get("buffer"), 0, 0)
+ }
+ return float64Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
+ default:
+ panic("TypedArrayOf: not a supported slice")
+ }
+}