yonluandClaude Opus 5
4471db3aef
Phases 2 and 3 of plan 009, plus the parts of phase 1 that could not
land before them. Nothing in the tree imports wails/v2 any more; all
three lint and test configurations are green and `go build .` produces
a running binary.
The point of the migration is one file. backend/events/emit.go probed
ctx.Value("events") — a v2-*private* context key — to decide whether
emitting was safe, because runtime.EventsEmit called log.Fatalf on a
context without the runtime and took the process down with it. v3's
emit takes no context, so that is now application.Get() == nil. D1
held: events.Emit keeps its ctx as the WithSink test seam, and all 45
call sites and 7 test files are untouched.
The bootstrap splits into application.New + Window.NewWithOptions +
Run. Ten bound services implement ServiceStartup instead of being
handed a context by hand from OnStartup, which also stops ten
SetContext methods being exported as bindings. jobs.Registry and
explore.SearchIndex keep theirs — neither is bound, so converting them
would be churn for no binding removed.
Four things differed from the plan and are written up in it: GPU policy
moved to the per-window LinuxWindow options rather than surviving on
LinuxOptions; there is no OnStartup/OnDomReady option, so app-level
wiring hangs off ApplicationStarted; application.NewService is generic,
so FEBindings []any could not survive (the binding generator is a
static analyser and would have seen nothing); and the quit veto had to
be restructured, because v3's dialog answers on a callback rather than
returning the button, so ShouldQuit vetoes, asks, and quits again from
the callback.
Window state saving moves to a WindowClosing hook — the size has to be
read while the window still exists, and v3's OnShutdown has neither
context nor window. backend/logging is deleted rather than ported:
v3 takes a *slog.Logger directly, so the v2 logger.Logger adapter had
no caller left.
Phase 1's tail rides along, now that it can: the Makefile's wails
invocations, all 50 webkit2_41 sites, lefthook, both packaging recipes
and ci.yml's apt lists. v3 builds against GTK4 + WebKitGTK 6.0, which
Arch and ubuntu:24.04 both ship, so the tag is a deletion rather than
a translation.
Phase 4 is next and the branch is not usable until it lands: the app
builds, but frontend/wailsjs/ is v2's tree and nothing regenerates it,
so the frontend cannot reach the backend yet.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UDCbcCZQepnpSQYJ6SxxZm
84 lines
2.1 KiB
Go
84 lines
2.1 KiB
Go
// Package assets handles serving frontend static files.
|
|
package assets
|
|
|
|
import (
|
|
"embed"
|
|
"fmt"
|
|
"io/fs"
|
|
"log/slog"
|
|
"net/http"
|
|
|
|
"github.com/wailsapp/wails/v3/pkg/application"
|
|
)
|
|
|
|
// distRoot is where the frontend build lands inside the embedded FS.
|
|
// v2 knew this prefix itself; v3 takes an fs.FS rooted at the assets,
|
|
// so the sub-FS is taken here.
|
|
const distRoot = "frontend/dist"
|
|
|
|
// Handler serves frontend assets with custom route support.
|
|
type Handler struct {
|
|
Options application.AssetOptions
|
|
logger *slog.Logger
|
|
frontendDistAssets embed.FS
|
|
serveMux *http.ServeMux
|
|
wailsAssetHandler http.Handler
|
|
}
|
|
|
|
// NewAssetHandler creates a new asset handler.
|
|
func NewAssetHandler(logger *slog.Logger, frontendDistAssets embed.FS) (*Handler, error) {
|
|
handler := &Handler{
|
|
logger: logger,
|
|
frontendDistAssets: frontendDistAssets,
|
|
serveMux: http.NewServeMux(),
|
|
}
|
|
|
|
dist, err := fs.Sub(frontendDistAssets, distRoot)
|
|
if err != nil {
|
|
return nil, fmt.Errorf(
|
|
"could not open %s in the embedded assets: %w", distRoot, err,
|
|
)
|
|
}
|
|
|
|
handler.Options = application.AssetOptions{
|
|
Handler: application.AssetFileServerFS(dist),
|
|
Middleware: handler.Middleware,
|
|
}
|
|
|
|
return handler, nil
|
|
}
|
|
|
|
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
// if we dont have a custom handler defined, then use the wails asset handler
|
|
if _, pattern := h.serveMux.Handler(r); len(pattern) == 0 {
|
|
h.logger.Debug(
|
|
"custom handler for request not found, using wails asset handler",
|
|
"path",
|
|
r.URL.Path,
|
|
)
|
|
h.wailsAssetHandler.ServeHTTP(w, r)
|
|
|
|
return
|
|
}
|
|
|
|
h.logger.Debug(
|
|
"using custom handler for request",
|
|
"path",
|
|
r.URL.Path,
|
|
)
|
|
h.serveMux.ServeHTTP(w, r)
|
|
}
|
|
|
|
// Middleware captures the Wails asset handler for fallback routing.
|
|
func (h *Handler) Middleware(next http.Handler) http.Handler {
|
|
h.wailsAssetHandler = next
|
|
|
|
return h
|
|
}
|
|
|
|
// RegisterHandler adds a custom handler for a URL pattern.
|
|
func (h *Handler) RegisterHandler(pattern string, handler http.Handler) {
|
|
h.logger.Debug("registering asset handler", "pattern", pattern)
|
|
h.serveMux.Handle(pattern, handler)
|
|
}
|