Clear offline data on logout, test offline plan and recipe reads, drop Pillow
- POST /auth/logout answers with Clear-Site-Data: "storage", "cache", which removes the verified-session marker, the service worker and its caches, so an offline visit after logout cannot reopen household data. The 401/403 clearing path is unchanged. - The service worker no longer answers network-only requests; it leaves them to the browser. Chrome stalls a Clear-Site-Data navigation that the worker answered, so the logout POST must bypass it. - New tests send plan and recipe reads through the real API client and the real network-first strategy online, then serve them from the cache offline. - The icon generator is now Go on golang.org/x/image (approved) instead of Python on Pillow; the icons are regenerated with it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -1,59 +0,0 @@
|
||||
"""Generates the PWA icons in web/public from the MealQuest logo.
|
||||
|
||||
Run from the repository root with Pillow installed:
|
||||
|
||||
python3 web/scripts/generate-icons.py
|
||||
|
||||
The logo fills the regular icons edge to edge. The maskable icon shrinks it
|
||||
onto the colour of its own parchment, so the banner stays inside
|
||||
the circular safe zone (radius 40% of the icon) that launchers may crop to.
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from PIL import Image, ImageDraw, ImageFilter, ImageStat
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
SOURCE = ROOT / "design" / "logos" / "logo_v1_2Oct2026.jpg"
|
||||
PUBLIC = ROOT / "web" / "public"
|
||||
|
||||
MASKABLE_SCALE = 0.66
|
||||
|
||||
|
||||
def resized(logo: Image.Image, size: int) -> Image.Image:
|
||||
return logo.resize((size, size), Image.Resampling.LANCZOS)
|
||||
|
||||
|
||||
def maskable(logo: Image.Image, size: int) -> Image.Image:
|
||||
# The padding is the median colour of the logo's top edge, which is bare
|
||||
# parchment; a feathered edge hides the seam.
|
||||
top_edge = ImageStat.Stat(logo.crop((0, 0, logo.width, logo.height // 40)))
|
||||
canvas = Image.new("RGB", (size, size), tuple(round(c) for c in top_edge.median))
|
||||
inner = round(size * MASKABLE_SCALE)
|
||||
offset = (size - inner) // 2
|
||||
feather = Image.new("L", (inner, inner), 0)
|
||||
margin = inner // 24
|
||||
ImageDraw.Draw(feather).rectangle((margin, margin, inner - margin, inner - margin), fill=255)
|
||||
feather = feather.filter(ImageFilter.GaussianBlur(margin / 2))
|
||||
canvas.paste(resized(logo, inner), (offset, offset), feather)
|
||||
return canvas
|
||||
|
||||
|
||||
def main() -> None:
|
||||
logo = Image.open(SOURCE).convert("RGB")
|
||||
if logo.width != logo.height:
|
||||
raise SystemExit(f"{SOURCE} is {logo.width}x{logo.height}; the logo must be square")
|
||||
outputs = {
|
||||
PUBLIC / "icons" / "icon-192.png": resized(logo, 192),
|
||||
PUBLIC / "icons" / "icon-512.png": resized(logo, 512),
|
||||
PUBLIC / "icons" / "icon-maskable-512.png": maskable(logo, 512),
|
||||
PUBLIC / "apple-touch-icon.png": resized(logo, 180),
|
||||
}
|
||||
for path, image in outputs.items():
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
image.save(path, optimize=True)
|
||||
print(f"wrote {path.relative_to(ROOT)} ({image.width}x{image.height})")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,186 @@
|
||||
// Command generate-icons writes the PWA icons in web/public from the
|
||||
// MealQuest logo. Run it from the repository root:
|
||||
//
|
||||
// go run ./web/scripts/generate-icons
|
||||
//
|
||||
// The logo fills the regular icons edge to edge. The maskable icon shrinks it
|
||||
// onto the colour of its own parchment, so the banner stays inside the
|
||||
// circular safe zone (radius 40% of the icon) that launchers may crop to.
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"image"
|
||||
"image/color"
|
||||
"image/png"
|
||||
"math"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
|
||||
"golang.org/x/image/draw"
|
||||
)
|
||||
|
||||
const (
|
||||
source = "design/logos/logo_v1_2Oct2026.jpg"
|
||||
public = "web/public"
|
||||
maskableScale = 0.66
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := run(); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "generate-icons:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func run() error {
|
||||
logo, err := load(source)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if b := logo.Bounds(); b.Dx() != b.Dy() {
|
||||
return fmt.Errorf("%s is %dx%d; the logo must be square", source, b.Dx(), b.Dy())
|
||||
}
|
||||
outputs := []struct {
|
||||
path string
|
||||
image *image.RGBA
|
||||
}{
|
||||
{"icons/icon-192.png", resized(logo, 192)},
|
||||
{"icons/icon-512.png", resized(logo, 512)},
|
||||
{"icons/icon-maskable-512.png", maskable(logo, 512)},
|
||||
{"apple-touch-icon.png", resized(logo, 180)},
|
||||
}
|
||||
for _, out := range outputs {
|
||||
path := filepath.Join(public, out.path)
|
||||
if err := save(path, out.image); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("wrote %s (%dx%d)\n", path, out.image.Rect.Dx(), out.image.Rect.Dy())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// load decodes the logo. The file is a PNG despite its .jpg name, so the
|
||||
// format is sniffed rather than taken from the extension.
|
||||
func load(path string) (image.Image, error) {
|
||||
f, err := os.Open(path)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer f.Close()
|
||||
img, _, err := image.Decode(f)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("decode %s: %w", path, err)
|
||||
}
|
||||
return img, nil
|
||||
}
|
||||
|
||||
func save(path string, img image.Image) error {
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
f, err := os.Create(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
enc := png.Encoder{CompressionLevel: png.BestCompression}
|
||||
if err := enc.Encode(f, img); err != nil {
|
||||
f.Close()
|
||||
return fmt.Errorf("encode %s: %w", path, err)
|
||||
}
|
||||
return f.Close()
|
||||
}
|
||||
|
||||
func resized(logo image.Image, size int) *image.RGBA {
|
||||
dst := image.NewRGBA(image.Rect(0, 0, size, size))
|
||||
draw.CatmullRom.Scale(dst, dst.Rect, logo, logo.Bounds(), draw.Src, nil)
|
||||
return dst
|
||||
}
|
||||
|
||||
func maskable(logo image.Image, size int) *image.RGBA {
|
||||
// The padding is the median colour of the logo's top edge, which is bare
|
||||
// parchment; a feathered edge hides the seam.
|
||||
b := logo.Bounds()
|
||||
canvas := image.NewRGBA(image.Rect(0, 0, size, size))
|
||||
draw.Draw(canvas, canvas.Rect, image.NewUniform(medianColour(logo, image.Rect(b.Min.X, b.Min.Y, b.Max.X, b.Min.Y+b.Dy()/40))), image.Point{}, draw.Src)
|
||||
inner := int(math.Round(float64(size) * maskableScale))
|
||||
offset := (size - inner) / 2
|
||||
margin := inner / 24
|
||||
at := image.Rect(offset, offset, offset+inner, offset+inner)
|
||||
draw.DrawMask(canvas, at, resized(logo, inner), image.Point{}, feather(inner, margin), image.Point{}, draw.Over)
|
||||
return canvas
|
||||
}
|
||||
|
||||
// medianColour is the per-channel median of the pixels in r.
|
||||
func medianColour(img image.Image, r image.Rectangle) color.RGBA {
|
||||
var channels [3][]uint8
|
||||
for y := r.Min.Y; y < r.Max.Y; y++ {
|
||||
for x := r.Min.X; x < r.Max.X; x++ {
|
||||
c := color.RGBAModel.Convert(img.At(x, y)).(color.RGBA)
|
||||
channels[0] = append(channels[0], c.R)
|
||||
channels[1] = append(channels[1], c.G)
|
||||
channels[2] = append(channels[2], c.B)
|
||||
}
|
||||
}
|
||||
var median [3]uint8
|
||||
for i, values := range channels {
|
||||
slices.Sort(values)
|
||||
median[i] = values[len(values)/2]
|
||||
}
|
||||
return color.RGBA{R: median[0], G: median[1], B: median[2], A: 0xff}
|
||||
}
|
||||
|
||||
// feather is an opaque square inset by margin on a size×size mask, its edge
|
||||
// softened by a Gaussian blur with a standard deviation of margin/2.
|
||||
func feather(size, margin int) *image.Alpha {
|
||||
values := make([]float64, size*size)
|
||||
for y := margin; y <= size-margin && y < size; y++ {
|
||||
for x := margin; x <= size-margin && x < size; x++ {
|
||||
values[y*size+x] = 255
|
||||
}
|
||||
}
|
||||
kernel := gaussian(float64(margin) / 2)
|
||||
values = blur(values, size, kernel, 1, size)
|
||||
values = blur(values, size, kernel, size, 1)
|
||||
mask := image.NewAlpha(image.Rect(0, 0, size, size))
|
||||
for i, v := range values {
|
||||
mask.Pix[i] = uint8(math.Round(min(max(v, 0), 255)))
|
||||
}
|
||||
return mask
|
||||
}
|
||||
|
||||
// gaussian is a normalised kernel reaching three standard deviations.
|
||||
func gaussian(sigma float64) []float64 {
|
||||
radius := int(math.Ceil(3 * sigma))
|
||||
kernel := make([]float64, 2*radius+1)
|
||||
var sum float64
|
||||
for i := range kernel {
|
||||
d := float64(i - radius)
|
||||
kernel[i] = math.Exp(-d * d / (2 * sigma * sigma))
|
||||
sum += kernel[i]
|
||||
}
|
||||
for i := range kernel {
|
||||
kernel[i] /= sum
|
||||
}
|
||||
return kernel
|
||||
}
|
||||
|
||||
// blur convolves each line of a size×size grid with kernel: step is the
|
||||
// distance between neighbours along a line and stride between lines. Samples
|
||||
// beyond the edge repeat the edge.
|
||||
func blur(values []float64, size int, kernel []float64, step, stride int) []float64 {
|
||||
radius := len(kernel) / 2
|
||||
out := make([]float64, len(values))
|
||||
for line := range size {
|
||||
for i := range size {
|
||||
var v float64
|
||||
for k, w := range kernel {
|
||||
j := min(max(i+k-radius, 0), size-1)
|
||||
v += w * values[line*stride+j*step]
|
||||
}
|
||||
out[line*stride+i*step] = v
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
Reference in New Issue
Block a user