bumping to go1.20 master

Author: grantnelson-wf

go.work

@@ -1,4 +1,4 @@
-go 1.19
+go 1.20
 
 use (
 	./playground

playground/go.mod

@@ -1,17 +1,18 @@
 module github.com/gopherjs/gopherjs.github.io/playground
 
-go 1.19
+go 1.20
 
 require (
 	github.com/google/go-cmp v0.5.8
-	github.com/gopherjs/gopherjs v1.19.0-beta2.0.20251008200541-113c92b42b18
+	github.com/gopherjs/gopherjs v1.19.0-beta2.0.20260112215734-09f0b7ce5c99
 	golang.org/x/tools v0.16.0
 	honnef.co/go/js/xhr v0.0.0-20150307031022-00e3346113ae
 )
 
 require (
 	github.com/evanw/esbuild v0.25.4 // indirect
 	github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86 // indirect
+	github.com/neelance/sourcemap v0.0.0-20200213170602-2833bce08e4c // indirect
 	github.com/sirupsen/logrus v1.8.3 // indirect
 	github.com/stretchr/testify v1.11.1 // indirect
 	golang.org/x/sys v0.10.0 // indirect

playground/go.sum

@@ -1,10 +1,10 @@
 module github.com/grantnelson-wf/gopherjs.github.io/playground/internal/cmd/precompile
 
-go 1.19
+go 1.20
 
 require (
-	github.com/gopherjs/gopherjs v1.19.0-beta2.0.20251008200541-113c92b42b18
-	github.com/sirupsen/logrus v1.8.1
+	github.com/gopherjs/gopherjs v1.19.0-beta2.0.20260112215734-09f0b7ce5c99
+	github.com/sirupsen/logrus v1.8.3
 )
 
 require (
@@ -17,5 +17,3 @@ require (
 	golang.org/x/sys v0.10.0 // indirect
 	golang.org/x/tools v0.16.0 // indirect
 )
-
-replace github.com/gopherjs/gopherjs => /Users/grantnelson/go/src/github.com/Workiva/gopherjs // TODO(grantnelson-wf): REMOVE

playground/internal/cmd/precompile/go.mod

@@ -32,9 +32,7 @@ type logLevelFlag struct{ log.Level }
 
 func (l *logLevelFlag) Set(raw string) error { return l.UnmarshalText([]byte(raw)) }
 
-var (
-	logLevel logLevelFlag = logLevelFlag{Level: log.ErrorLevel}
-)
+var logLevel logLevelFlag = logLevelFlag{Level: log.ErrorLevel}
 
 func init() {
 	flag.Var(&logLevel, "log_level", "Default logging level.")
@@ -63,14 +61,9 @@ func run() error {
 			return fmt.Errorf("failed to get build package for %s: %w", path, err)
 		}
 
-		var srcs *sources.Sources
-		if srcs, err = s.LoadPackages(pkg); err != nil {
+		if _, err = s.LoadPackages(pkg); err != nil {
 			return fmt.Errorf("failed to prepackaged package %q: %w", pkg, err)
 		}
-
-		if _, err := s.PrepareAndCompilePackages(srcs); err != nil {
-			return fmt.Errorf("failed to compile package %q: %w", pkg, err)
-		}
 	}
 
 	target, err := targetDir(s)

playground/internal/cmd/precompile/go.sum

@@ -1,28 +1,31 @@
+// The globals are the global objects used by the react components.
+//
+// Since passing Go structs through React props will cause problems
+// because of how React serializes props, even if we wrap it in a Ref
+// the GopherJS will convert structs to JS objects,
+// instead we use a global singleton instead to pass around global state.
+//
+// This could be problematic if we ever want to have multiple code editors
+// on the same page, but that is not a use case we currently have to support.
 package react
 
 import (
 	"sync"
 
 	"github.com/gopherjs/gopherjs.github.io/playground/internal/common"
+	"github.com/gopherjs/gopherjs.github.io/playground/internal/runner"
 	"github.com/gopherjs/gopherjs.github.io/playground/internal/snippets"
 	"github.com/gopherjs/gopherjs.github.io/playground/internal/undoRedo"
 )
 
-// Globals is the global objects used by the react components.
-//
-// Since passing Go structs through React props will cause problems
-// because of how React serializes props, even if we wrap it in a Ref
-// the GopherJS will convert structs to JS objects,
-// instead we use a global singleton instead to pass around global state.
-//
-// This could be problematic if we ever want to have multiple code editors
-// on the same page, but that is not a use case we currently have to support.
-var globals = &struct {
+var globals = struct {
 	UndoRedo      func() common.UndoRedoStack
 	SnippetsStore func() common.SnippetStore
+	Runner        func() common.Runner
 }{
-	UndoRedo:      OnceValue(undoRedo.NewUndoRedoStack),
+	UndoRedo:      OnceValue(undoRedo.NewStack),
 	SnippetsStore: OnceValue(snippets.NewStore),
+	Runner:        OnceValue(func() common.Runner { return runner.New(runner.NewFetcher()) }),
 }
 
 // OnceValue initializes a value on the first call

playground/internal/cmd/precompile/precompile.go

@@ -1,6 +1,9 @@
 package react
 
-import "github.com/gopherjs/gopherjs/js"
+import (
+	"github.com/gopherjs/gopherjs/compiler"
+	"github.com/gopherjs/gopherjs/js"
+)
 
 func Playground() *Element {
 	return CreateElement(playgroundComponent, nil)
@@ -13,10 +16,9 @@ func playgroundComponent(props Props) *Element {
 		output, setOutput         = UseState([]any{})
 		fmtImports, setFmtImports = UseState(true)
 		lightTheme, setLightTheme = UseStateLazy(getDefaultToLightTheme)
+		runButtonRef              = UseRef()
 	)
 
-	version := UseMemo(func() string { return `vx.x.x` }, []any{}) // TODO(grantnelson-wf): Replace with `UseMemo(compiler.Version)`
-
 	UseEffect(func() {
 		setDataTheme(lightTheme)
 	}, []any{lightTheme})
@@ -46,12 +48,17 @@ func playgroundComponent(props Props) *Element {
 	})
 	*/
 
-	onSaveKeyPress := UseCallback(func() {
-		println("Save key pressed") // TODO(grantnelson-wf): Implement
+	onEscapeCode := UseCallback(func() {
+		// Escape will move focus to the run button.
+		// This is for eccessability so that users can easily run the
+		// code after editing. Or at minimum, users can exit the text area
+		// like they would be able to with tab stops but our editor is consuming
+		// tab key presses so tab stops won't work when in the text area.
+		runButtonRef.Call(`focus`)
 	}, []any{})
 
-	onEscapeCode := UseCallback(func() {
-		println("Escape code pressed") // TODO(grantnelson-wf): Implement to change focus to the run button or something
+	onSaveKeyPress := UseCallback(func() {
+		println("Save key pressed") // TODO(grantnelson-wf): Implement by running format (and maybe sharing)
 	}, []any{})
 
 	onRunClick := UseCallback(func() {
@@ -70,11 +77,11 @@ func playgroundComponent(props Props) *Element {
 		Div(Props{
 			`id`: `banner`,
 		},
-			BannerTitle(version),
+			BannerTitle(compiler.Version),
 			Span(Props{
 				`id`: `controls`,
 			},
-				Button(`run-button`, `Run`, nil, onRunClick),
+				Button(`run-button`, `Run`, Props{`ref`: runButtonRef}, onRunClick),
 				Button(`format-button`, `Format`, nil, onFormatClick),
 				ToggleBox(`format-imports`, `Rewrite imports on Format`, `Imports`, fmtImports, setFmtImports),
 				ShareUrlControl(shareUrl, onShareClick),

playground/internal/react/globals.go

@@ -1,6 +1,7 @@
 package runner
 
 import (
+	"fmt"
 	"sync"
 
 	"github.com/gopherjs/gopherjs.github.io/playground/internal/common"
@@ -16,68 +17,90 @@ const (
 )
 
 type packageCache struct {
-	output     common.Output
 	fetcher    common.Fetcher
 	cached     map[string]*sources.Sources
 	inprogress map[string]chan struct{}
 	lock       sync.Mutex
 }
 
-func newPackageCache(output common.Output, fetcher common.Fetcher) *packageCache {
+func newPackageCache(fetcher common.Fetcher) *packageCache {
 	return &packageCache{
-		output:     output,
 		fetcher:    fetcher,
 		cached:     make(map[string]*sources.Sources),
 		inprogress: make(map[string]chan struct{}),
 	}
 }
 
-func (pc *packageCache) Load(importPath string) (*sources.Sources, loadResult) {
+func (pc *packageCache) Load(importPath string) (*sources.Sources, loadResult, error) {
 	srcs := &sources.Sources{}
-	result := pc.syncLoad(importPath)(srcs)
-	return srcs, result
+	result, err := pc.syncLoad(importPath)(srcs)
+	return srcs, result, err
 }
 
+type syncLoadFunc func(srcs *sources.Sources) (loadResult, error)
+
 // syncLoad returns a function to complete loading the package.
 //
 // The returned function may either return the cached package immediately,
 // wait for an in-progress load to complete, or perform the load itself.
 // syncLoad will not block, but the returned function may block.
-func (pc *packageCache) syncLoad(importPath string) func(srcs *sources.Sources) loadResult {
+//
+// If the returned function is run and returns loadFailed, the error will be non-nil
+// and if the error is non-nil, the loadResult will be loadFailed.
+func (pc *packageCache) syncLoad(importPath string) syncLoadFunc {
 	pc.lock.Lock()
 	defer pc.lock.Unlock()
 
 	if cached, found := pc.cached[importPath]; found {
-		return func(srcs *sources.Sources) loadResult {
-			*srcs = *cached // Copy the cached sources.
-			return loadCached
-		}
+		return pc.alreadyLoaded(cached)
 	}
 
 	// Load is already in progress, wait for it to complete.
 	if ch, loading := pc.inprogress[importPath]; loading {
-		return func(srcs *sources.Sources) loadResult {
-			<-ch // Wait for the in-progress load to complete.
-
-			pc.lock.Lock()
-			defer pc.lock.Unlock()
-
-			if cached, found := pc.cached[importPath]; found {
-				*srcs = *cached // Copy the cached sources.
-				return loadCached
-			}
-			return loadFailed
-		}
+		return pc.alreadyInprogress(importPath, ch)
 	}
 
 	// Load is not in progress, start it now.
 	ch := make(chan struct{})
 	pc.inprogress[importPath] = ch
-	return func(srcs *sources.Sources) loadResult {
+	return pc.startLoading(importPath, ch)
+}
+
+// alreadyLoaded returns a syncLoadFunc that immediately returns the cached sources.
+// 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.
+		return loadCached, nil
+	}
+}
+
+// alreadyInprogress returns a syncLoadFunc that waits for an in-progress load to complete.
+// The given channel will be waited on until it is closed, indicating the load is complete
+// and the sources should now be in the cache.
+func (pc *packageCache) alreadyInprogress(importPath string, ch chan struct{}) syncLoadFunc {
+	return func(srcs *sources.Sources) (loadResult, error) {
+		<-ch // Wait for the in-progress load to complete.
+
+		pc.lock.Lock()
+		defer pc.lock.Unlock()
+
+		if cached, found := pc.cached[importPath]; found {
+			*srcs = *cached // Copy the cached sources.
+			return loadCached, nil
+		}
+		return loadFailed, fmt.Errorf(`failed to find package %q in cache after waiting load`, importPath)
+	}
+}
+
+// startLoading returns a syncLoadFunc that performs the package load.
+// The given channel will be closed when the load is complete to indicate to any
+// other processed waiting on the load that it is done.
+func (pc *packageCache) startLoading(importPath string, ch chan struct{}) syncLoadFunc {
+	return func(srcs *sources.Sources) (loadResult, error) {
 		fetched, err := pc.fetcher.FetchPackage(importPath)
 		if err != nil {
-			pc.output.AddError(err)
-			return loadFailed
+			return loadFailed, err
 		}
 
 		pc.lock.Lock()
@@ -87,6 +110,6 @@ func (pc *packageCache) syncLoad(importPath string) func(srcs *sources.Sources)
 		*srcs = *fetched // Copy the fetched sources.
 		delete(pc.inprogress, importPath)
 		close(ch)
-		return loadFetched
+		return loadFetched, nil
 	}
 }