go25: generatehtml works by passing an arg instead of tags, which don't transfer across modules. verified that lab/docs and compcogneuro/web work, whereas they did not before. also, it uses -nogui instead of offscreen tags.

Author: rcoreilly

base/websocket/websocket_generatehtml.go

@@ -2,12 +2,13 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !js && !generatehtml
+//go:build !js
 
 package websocket
 
 import (
 	"cogentcore.org/core/base/errors"
+	"cogentcore.org/core/system"
 	"github.com/gorilla/websocket"
 )
 
@@ -24,6 +25,9 @@ type Client struct {
 
 // Connect connects to a WebSocket server and returns a [Client].
 func Connect(url string) (*Client, error) {
+	if system.GenerateHTMLArg() {
+		return &Client{}, nil
+	}
 	conn, _, err := websocket.DefaultDialer.Dial(url, nil)
 	if err != nil {
 		return nil, err
@@ -34,6 +38,9 @@ func Connect(url string) (*Client, error) {
 // OnMessage sets a callback function to be called when a message is received.
 // This function can only be called once.
 func (c *Client) OnMessage(f func(typ MessageTypes, msg []byte)) {
+	if system.GenerateHTMLArg() {
+		return
+	}
 	go func() {
 		for {
 			typ, msg, err := c.conn.ReadMessage()
@@ -48,19 +55,28 @@ func (c *Client) OnMessage(f func(typ MessageTypes, msg []byte)) {
 
 // Send sends a message to the WebSocket server with the given type and message.
 func (c *Client) Send(typ MessageTypes, msg []byte) error {
+	if system.GenerateHTMLArg() {
+		return nil
+	}
 	return c.conn.WriteMessage(int(typ), msg)
 }
 
 // Close cleanly closes the WebSocket connection.
 // It does not directly trigger [Client.OnClose], but once the connection
 // is closed, [Client.OnMessage] will trigger it.
 func (c *Client) Close() error {
+	if system.GenerateHTMLArg() {
+		return nil
+	}
 	return c.conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
 }
 
 // OnClose sets a callback function to be called when the connection is closed.
 // This function can only be called once.
 func (c *Client) OnClose(f func()) {
+	if system.GenerateHTMLArg() {
+		return
+	}
 	go func() {
 		<-c.done
 		f()

base/websocket/websocket_notjs.go

@@ -109,7 +109,7 @@ func makeFiles(c *config.Config) error {
 
 	preRenderHTML := ""
 	if c.Web.GenerateHTML {
-		preRenderHTML, err = exec.Output("go", "run", "-tags", "offscreen,generatehtml", ".")
+		preRenderHTML, err = exec.Output("go", "run", ".", "-generatehtml", "-nogui")
 		if err != nil {
 			return err
 		}

cmd/web/build.go

@@ -2,13 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build generatehtml
-
 package content
 
 import (
-	"fmt"
-	"os"
 	"strings"
 
 	"cogentcore.org/core/base/errors"
@@ -18,51 +14,50 @@ import (
 	"cogentcore.org/core/tree"
 )
 
-// This file is activated by the core tool to pre-render Cogent Core apps
-// as HTML that can be used as a preview and for SEO purposes.
-
 func init() {
-	// We override the OnChildAdded set in core/generatehtml.go
-	core.ExternalParent.AsWidget().SetOnChildAdded(func(n tree.Node) {
-		var ct *Content
-		n.AsTree().WalkDown(func(n tree.Node) bool {
-			if ct != nil {
+	core.GenerateHTML = generateHTML
+}
+
+// GenerateHTML is called by the core tool to pre-render Cogent Core apps
+// as HTML that can be used as a preview and for SEO purposes.
+func generateHTML(w core.Widget) string {
+	var ct *Content
+	w.AsTree().WalkDown(func(n tree.Node) bool {
+		if ct != nil {
+			return tree.Break
+		}
+		if c, ok := n.(*Content); ok {
+			ct = c
+			return tree.Break
+		}
+		return tree.Continue
+	})
+	if ct == nil {
+		return core.GenerateHTMLCore(w) // basic fallback
+	}
+	prps := []*bcontent.PreRenderPage{}
+	ct.UpdateTree() // need initial update first
+	for _, pg := range ct.pages {
+		ct.Open(pg.URL)
+		prp := &bcontent.PreRenderPage{
+			Page: *pg,
+			HTML: core.GenerateHTMLCore(ct),
+		}
+		// The first non-emphasized paragraph is used as the description
+		// (<em> typically indicates a note or caption, not an introduction).
+		ct.WalkDown(func(n tree.Node) bool {
+			if prp.Description != "" {
 				return tree.Break
 			}
-			if c, ok := n.(*Content); ok {
-				ct = c
-				return tree.Break
+			if tx, ok := n.(*core.Text); ok {
+				if tx.Property("tag") == "p" && !strings.HasPrefix(tx.Text, "<em>") {
+					prp.Description = tx.Text
+					return tree.Break
+				}
 			}
 			return tree.Continue
 		})
-		if ct == nil {
-			fmt.Println(core.GenerateHTML(n.(core.Widget))) // basic fallback
-			os.Exit(0)
-		}
-		prps := []*bcontent.PreRenderPage{}
-		ct.UpdateTree() // need initial update first
-		for _, pg := range ct.pages {
-			ct.Open(pg.URL)
-			prp := &bcontent.PreRenderPage{
-				Page: *pg,
-				HTML: core.GenerateHTML(ct),
-			}
-			// The first non-emphasized paragraph is used as the description
-			// (<em> typically indicates a note or caption, not an introduction).
-			ct.WalkDown(func(n tree.Node) bool {
-				if prp.Description != "" {
-					return tree.Break
-				}
-				if tx, ok := n.(*core.Text); ok {
-					if tx.Property("tag") == "p" && !strings.HasPrefix(tx.Text, "<em>") {
-						prp.Description = tx.Text
-						return tree.Break
-					}
-				}
-				return tree.Continue
-			})
-			prps = append(prps, prp)
-		}
-		fmt.Println(string(errors.Log1(jsonx.WriteBytes(prps))))
-	})
+		prps = append(prps, prp)
+	}
+	return string(errors.Log1(jsonx.WriteBytes(prps)))
 }

content/generatehtml.go

@@ -2,34 +2,24 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build generatehtml
-
 package core
 
 import (
-	"fmt"
 	"log/slog"
 	"os"
-
-	"cogentcore.org/core/tree"
 )
 
-// This file is activated by the core tool to pre-render Cogent Core apps
-// as HTML that can be used as a preview and for SEO purposes.
+// GenerateHTML is the Function to call for the -generatehtml argument.
+// it returns generated HTML for the given widget.
+// It exits the program if there is an error, but does not exit
+// the program if there is no error.
+var GenerateHTML func(w Widget) string
 
 func init() {
-	wb := NewWidgetBase()
-	ExternalParent = wb
-	wb.SetOnChildAdded(func(n tree.Node) {
-		fmt.Println(GenerateHTML(n.(Widget)))
-		os.Exit(0)
-	})
+	GenerateHTML = GenerateHTMLCore
 }
 
-// GenerateHTML returns generated HTML for the given widget.
-// It exits the program if there is an error, but does not exit
-// the program if there is no error.
-func GenerateHTML(w Widget) string {
+func GenerateHTMLCore(w Widget) string {
 	wb := w.AsWidget()
 	wb.UpdateTree()
 	wb.StyleTree()

core/generatehtml.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"image"
 	"log/slog"
+	"os"
 
 	"cogentcore.org/core/cursors"
 	"cogentcore.org/core/events"
@@ -32,6 +33,19 @@ func newMainStage(typ StageTypes, sc *Scene) *Stage {
 	return st
 }
 
+func generateHTMLBody(bd *Body) {
+	if !system.GenerateHTMLArg() || ExternalParent != nil {
+		return
+	}
+	wb := NewWidgetBase()
+	ExternalParent = wb
+	wb.SetOnChildAdded(func(n tree.Node) {
+		fmt.Println(GenerateHTML(n.(Widget)))
+		os.Exit(0)
+	})
+	bd.handleExternalParent()
+}
+
 // RunMainWindow creates a new main window from the body,
 // runs it, starts the app's main loop, and waits for all windows
 // to close. It should typically be called once by every app at
@@ -40,6 +54,7 @@ func newMainStage(typ StageTypes, sc *Scene) *Stage {
 // If you need to configure the [Stage] further, use [Body.NewWindow]
 // and then [Stage.RunMain] on the resulting [Stage].
 func (bd *Body) RunMainWindow() {
+	generateHTMLBody(bd)
 	if ExternalParent != nil {
 		bd.handleExternalParent()
 		return
@@ -54,6 +69,7 @@ func (bd *Body) RunMainWindow() {
 // on the [Stage]. It can not be called more than once for one app.
 // For secondary stages, see [Stage.Run].
 func (st *Stage) RunMain() {
+	generateHTMLBody(st.Scene.Body)
 	if ExternalParent != nil {
 		st.Scene.Body.handleExternalParent()
 		return
@@ -80,6 +96,7 @@ var waitCalled bool
 // For the first window of your app, you should typically call
 // [Body.RunMainWindow] instead.
 func (bd *Body) RunWindow() *Stage {
+	generateHTMLBody(bd)
 	if ExternalParent != nil && !waitCalled {
 		bd.handleExternalParent()
 		return nil

core/mainstage.go

@@ -2,14 +2,15 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !offscreen && ((darwin && !ios) || windows || (linux && !android) || dragonfly || openbsd)
+//go:build (darwin && !ios) || windows || (linux && !android) || dragonfly || openbsd
 
 package gpu
 
 import (
 	"image"
 
 	"cogentcore.org/core/base/errors"
+	"cogentcore.org/core/system"
 	"github.com/cogentcore/webgpu/wgpu"
 	"github.com/cogentcore/webgpu/wgpuglfw"
 	"github.com/go-gl/glfw/v3.3/glfw"
@@ -42,6 +43,9 @@ func Terminate() {
 // GLFWCreateWindow is a helper function intended only for use in simple examples that makes a
 // new window with glfw on platforms that support it and is largely a no-op on other platforms.
 func GLFWCreateWindow(size image.Point, title string, resize *func(size image.Point)) (surface *wgpu.Surface, terminate func(), pollEvents func() bool, actualSize image.Point, err error) {
+	if system.GenerateHTMLArg() {
+		return
+	}
 	if err = Init(); err != nil {
 		return
 	}

gpu/glfw.go

@@ -14,6 +14,7 @@ package system
 
 import (
 	"fmt"
+	"os"
 	"runtime/debug"
 
 	"cogentcore.org/core/styles"
@@ -283,3 +284,13 @@ func init() {
 		}
 	}
 }
+
+// GenerateHTMLArg returns true if the first [os.Args] is -generatehtml.
+// Apps that process args should test this first and skip arg processing
+// if true.
+func GenerateHTMLArg() bool {
+	if len(os.Args) < 2 {
+		return false
+	}
+	return os.Args[1] == "-generatehtml"
+}

gpu/glfw_generatehtml.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build android && !offscreen
+//go:build android
 
 package driver