fixed the runner

Author: grantnelson-wf

playground/gen.go

@@ -1,5 +1,5 @@
-//go:generate go1.19.13 run ./internal/cmd/precompile
-//go:generate go1.19.13 install github.com/gopherjs/gopherjs
+//go:generate go1.20.14 run ./internal/cmd/precompile
+//go:generate go1.20.14 install github.com/gopherjs/gopherjs
 //go:generate env GOOS=js GOARCH=ecmascript gopherjs build -m .
 
 package main

playground/go.mod

@@ -4,7 +4,7 @@ go 1.20
 
 require (
 	github.com/google/go-cmp v0.5.8
-	github.com/gopherjs/gopherjs v1.19.0-beta2.0.20260112215734-09f0b7ce5c99
+	github.com/gopherjs/gopherjs v1.19.0-beta2.0.20260119142308-2cf5f59df243
 	golang.org/x/tools v0.16.0
 	honnef.co/go/js/xhr v0.0.0-20150307031022-00e3346113ae
 )

playground/go.sum

@@ -3,7 +3,7 @@ module github.com/grantnelson-wf/gopherjs.github.io/playground/internal/cmd/prec
 go 1.20
 
 require (
-	github.com/gopherjs/gopherjs v1.19.0-beta2.0.20260112215734-09f0b7ce5c99
+	github.com/gopherjs/gopherjs v1.19.0-beta2.0.20260119142308-2cf5f59df243
 	github.com/sirupsen/logrus v1.8.3
 )
 

playground/internal/cmd/precompile/go.mod

@@ -9,6 +9,8 @@ import (
 	"github.com/gopherjs/gopherjs.github.io/playground/internal/undoRedo"
 )
 
+const verbose = true
+
 // globals are the global objects used by the react components.
 //
 // Since passing Go structs through React props will cause problems
@@ -25,13 +27,13 @@ var globals = struct {
 }{
 	UndoRedo:      OnceValue(undoRedo.NewStack),
 	SnippetsStore: OnceValue(snippets.NewLocalStore), // TODO(grantnelson-wf): Switch to snippets.NewStore before deploying
-	Runner:        OnceValue(func() common.Runner { return runner.New(runner.NewFetcher()) }),
+	Runner:        OnceValue(func() common.Runner { return runner.New(runner.NewFetcher(verbose)) }),
 }
 
 // OnceValue initializes a value on the first call
 // then all following calls returns the initial value.
 //
-// TODO: Replace with sync.OnceValue when we reach Go 1.21
+// TODO(grantnelson-wf): Replace with sync.OnceValue when we reach Go 1.21
 func OnceValue[T any](init func() T) func() T {
 	var (
 		initFn func() T = init

playground/internal/cmd/precompile/go.sum

@@ -27,6 +27,7 @@ func (o *outputImpl) Clear() {
 
 func (o *outputImpl) AddError(err error) {
 	o.setOutput.Invoke(func(items []any) []any {
+		// TODO(grantnelson-wf): Need to move errlist.ErrorList out of internal so that we can split it out here
 		if list, ok := err.(scanner.ErrorList); ok {
 			for _, entry := range list {
 				items = append(items, map[string]any{typeKey: errType, contextKey: entry.Error()})
@@ -86,7 +87,9 @@ func outputBoxComponent(props react.Props) *react.Element {
 	return react.Div(react.Props{
 		`id`:  `output-box`,
 		`ref`: outputBoxRef,
-	}, children...)
+	}, react.Div(react.Props{
+		`id`: `output-box-inner`,
+	}, children...))
 }
 
 // hasNonErrors determines if any output is not an error,

playground/internal/page/globals.go

@@ -125,7 +125,14 @@ func playgroundComponent(props react.Props) *react.Element {
 	// TODO(grantnelson-wf): Implement a periodic read of the code after a change to preload packages.
 
 	onRun := react.UseCallback(func() {
+		if asyncOpInProgress.Current() {
+			return
+		}
 		asyncOpInProgress.SetCurrent(true)
+		output := Output(setOutput)
+		output.Clear()
+		output.AddOutput(`Compiling...`)
+
 		// TODO(grantnelson-wf): Finish implementing and debugging.
 		globals.Runner().Compile(code, func(jsCode string, err error) {
 			defer asyncOpInProgress.SetCurrent(false)

playground/internal/page/outputBox.go

@@ -13,40 +13,40 @@ import (
 	"github.com/gopherjs/gopherjs.github.io/playground/internal/common"
 )
 
-type fetcher struct{}
+type fetcher struct {
+	verbose bool
+}
 
-func NewFetcher() common.Fetcher {
-	return &fetcher{}
+func NewFetcher(verbose bool) common.Fetcher {
+	return &fetcher{verbose: verbose}
 }
 
-func (f *fetcher) FetchPackage(importPath string) (srcs *sources.Sources, err error) {
+// See comments in [common.Fetcher]
+func (f *fetcher) FetchPackage(importPath string) (*sources.Sources, error) {
+	if f.verbose {
+		println("Fetching package:", importPath)
+	}
+
 	data, err := f.fetchFile(importPath)
 	if err != nil {
 		return nil, err
 	}
 
-	zr, err := gzip.NewReader(bytes.NewReader(data))
+	srcs, err := f.readPackage(importPath, data)
 	if err != nil {
-		return nil, fmt.Errorf(`failed to create gzip reader for package %q: %v`, importPath, err)
+		return nil, err
 	}
-	defer func() {
-		if closeErr := zr.Close(); err == nil && closeErr != nil {
-			err = fmt.Errorf(`failed to close gzip reader for package %q: %w`, importPath, closeErr)
-		}
-	}()
 
-	srcs = &sources.Sources{}
-	if err := srcs.Read(gob.NewDecoder(zr).Decode); err != nil {
-		return nil, fmt.Errorf(`failed to decode package %q: %v`, importPath, err)
+	if f.verbose {
+		println("Package ready:   ", importPath)
 	}
-
 	return srcs, nil
 }
 
 func (f *fetcher) fetchFile(importPath string) ([]byte, error) {
 	const (
 		pkgBaseURL = `pkg/`
-		pkgExt     = `.a.js`
+		pkgExt     = `.a.js` // TODO(grantnelson-wf): Should probably pick a better extension for precompiled packages since they aren't JS anymore, maybe .zip
 	)
 
 	req := xhr.NewRequest(`GET`, pkgBaseURL+importPath+pkgExt)
@@ -60,3 +60,22 @@ func (f *fetcher) fetchFile(importPath string) ([]byte, error) {
 	data := js.Global.Get(`Uint8Array`).New(req.Response).Interface().([]byte)
 	return data, nil
 }
+
+func (f *fetcher) readPackage(importPath string, data []byte) (srcs *sources.Sources, err error) {
+	zr, err := gzip.NewReader(bytes.NewReader(data))
+	if err != nil {
+		return nil, fmt.Errorf(`failed to create gzip reader for package %q: %v`, importPath, err)
+	}
+	defer func() {
+		if closeErr := zr.Close(); err == nil && closeErr != nil {
+			err = fmt.Errorf(`failed to close gzip reader for package %q: %w`, importPath, closeErr)
+		}
+	}()
+
+	srcs = &sources.Sources{}
+	if err := srcs.Read(gob.NewDecoder(zr).Decode); err != nil {
+		return nil, fmt.Errorf(`failed to decode package %q: %v`, importPath, err)
+	}
+
+	return srcs, nil
+}

playground/internal/page/playground.go

@@ -70,7 +70,7 @@ func (pc *packageCache) syncLoad(importPath string) syncLoadFunc {
 // The given cached sources must be the sources that are already loaded in the cache.
 func (pc *packageCache) alreadyLoaded(cached *sources.Sources) syncLoadFunc {
 	return func(srcs *sources.Sources) (loadResult, error) {
-		*srcs = *cached // Copy the cached sources.
+		*srcs = *cached // Shallow copy the cached sources.
 		return loadCached, nil
 	}
 }
@@ -86,7 +86,7 @@ func (pc *packageCache) alreadyInprogress(importPath string, ch chan struct{}) s
 		defer pc.lock.Unlock()
 
 		if cached, found := pc.cached[importPath]; found {
-			*srcs = *cached // Copy the cached sources.
+			*srcs = *cached // Shallow copy the cached sources.
 			return loadCached, nil
 		}
 		return loadFailed, fmt.Errorf(`failed to find package %q in cache after waiting load`, importPath)
@@ -107,7 +107,7 @@ func (pc *packageCache) startLoading(importPath string, ch chan struct{}) syncLo
 		defer pc.lock.Unlock()
 
 		pc.cached[importPath] = fetched
-		*srcs = *fetched // Copy the fetched sources.
+		*srcs = *fetched // Shallow copy the fetched sources.
 		delete(pc.inprogress, importPath)
 		close(ch)
 		return loadFetched, nil