feat: gzip fallback glyph fixtures

.changeset/three-moose-trade.md

@@ -0,0 +1,5 @@
+---
+'smp-noto-glyphs': patch
+---
+
+Gzip noto glyph fallbacks at rest

packages/glyphs/fixtures/glyphs/.gitignore

@@ -0,0 +1 @@
+!*.gz

packages/glyphs/lib/noto.js

@@ -19,14 +19,14 @@ const GLYPHS_DIR = fileURLToPath(new URL('../fixtures/glyphs', import.meta.url))
 const cache = new Map()
 
 /**
- * Read a PBF glyph range file, returning the cached buffer or null if not found.
+ * Read a gzipped PBF glyph range file, returning the cached buffer or null if not found.
  * @param {string} range
  * @returns {Uint8Array | null}
  */
 function getGlyphPbf(range) {
   if (cache.has(range))
     return /** @type {Uint8Array | null} */ (cache.get(range))
-  const filePath = path.join(GLYPHS_DIR, `${range}.pbf`)
+  const filePath = path.join(GLYPHS_DIR, `${range}.pbf.gz`)
   try {
     const data = fs.readFileSync(filePath)
     cache.set(range, data)
@@ -42,6 +42,9 @@ function getGlyphPbf(range) {
  * glyph ranges for common scripts, and empty PBFs for uncommon/CJK ranges
  * (which MapLibre renders client-side via `localIdeographFontFamily`).
  *
+ * All responses are gzip-encoded — both pre-built ranges (stored as .pbf.gz)
+ * and empty fallbacks. Fixtures are stored compressed to reduce package size.
+ *
  * Covers 80+ scripts including Latin, Cyrillic, Greek, Arabic, Hebrew,
  * Devanagari, Thai, and more. See https://github.com/satbyy/go-noto-universal
  *
@@ -52,24 +55,13 @@ function getGlyphPbf(range) {
  * @returns {Response}
  */
 export function notoGlyphFallback(_fontstack, range) {
-  const pbf = getGlyphPbf(range)
-  if (pbf) {
-    return new Response(/** @type {any} */ (pbf), {
-      status: 200,
-      headers: {
-        'Content-Type': 'application/x-protobuf',
-        'Content-Length': String(pbf.byteLength),
-        'Cache-Control': 'public, max-age=604800',
-      },
-    })
-  }
-  // No pre-built PBF for this range — serve empty gzipped PBF
-  return new Response(/** @type {any} */ (EMPTY_GZ), {
+  const gz = getGlyphPbf(range) ?? EMPTY_GZ
+  return new Response(gz, {
     status: 200,
     headers: {
       'Content-Type': 'application/x-protobuf',
       'Content-Encoding': 'gzip',
-      'Content-Length': String(EMPTY_GZ.byteLength),
+      'Content-Length': String(gz.byteLength),
       'Cache-Control': 'public, max-age=604800',
     },
   })

packages/glyphs/test/noto.js

@@ -5,23 +5,30 @@ import fs from 'node:fs'
 import { notoGlyphFallback } from '../lib/noto.js'
 
 describe('notoGlyphFallback', () => {
-  test('returns PBF with correct headers for a known range', () => {
+  test('returns gzipped PBF with correct headers for a known range', () => {
     const response = notoGlyphFallback('Any Font', '0-255')
     expect(response.status).toBe(200)
     expect(response.headers.get('Content-Type')).toBe('application/x-protobuf')
-    expect(Number(response.headers.get('Content-Length'))).toBeGreaterThan(50)
-    // Known ranges should NOT have Content-Encoding (raw PBF, not gzipped)
-    expect(response.headers.get('Content-Encoding')).toBeNull()
+    expect(response.headers.get('Content-Encoding')).toBe('gzip')
+    expect(Number(response.headers.get('Content-Length'))).toBeGreaterThan(20)
     expect(response.headers.get('Cache-Control')).toBe('public, max-age=604800')
   })
 
   test('returns non-empty body for known range', async () => {
     const response = notoGlyphFallback('Any Font', '0-255')
     const body = await response.arrayBuffer()
-    expect(body.byteLength).toBeGreaterThan(50)
+    expect(body.byteLength).toBeGreaterThan(20)
     expect(body.byteLength).toBe(Number(response.headers.get('Content-Length')))
   })
 
+  test('known range body is larger than empty fallback', async () => {
+    const known = notoGlyphFallback('Any Font', '0-255')
+    const unknown = notoGlyphFallback('Any Font', '60000-60255')
+    const knownBody = await known.arrayBuffer()
+    const unknownBody = await unknown.arrayBuffer()
+    expect(knownBody.byteLength).toBeGreaterThan(unknownBody.byteLength)
+  })
+
   test('returns empty gzipped PBF for unknown range', () => {
     const response = notoGlyphFallback('Any Font', '60000-60255')
     expect(response.status).toBe(200)

scripts/generate-glyphs.js

@@ -27,6 +27,7 @@ import https from 'node:https'
 import os from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { gzipSync } from 'node:zlib'
 
 import { LOCAL_GLYPH_RANGES } from '../packages/api/lib/utils/style.js'
 
@@ -142,7 +143,7 @@ async function main() {
 
     // Clean existing PBF files
     for (const f of fs.readdirSync(OUTPUT_DIR)) {
-      if (f.endsWith('.pbf')) {
+      if (f.endsWith('.pbf') || f.endsWith('.pbf.gz')) {
         fs.unlinkSync(path.join(OUTPUT_DIR, f))
       }
     }
@@ -170,10 +171,13 @@ async function main() {
       if (excluded || data.length <= MIN_GLYPH_SIZE) {
         skippedCount++
       } else {
-        fs.copyFileSync(src, path.join(OUTPUT_DIR, filename))
-        totalSize += data.length
+        const gz = gzipSync(data)
+        fs.writeFileSync(path.join(OUTPUT_DIR, `${filename}.gz`), gz)
+        totalSize += gz.length
         copiedCount++
-        console.log(`  ${filename} (${(data.length / 1024).toFixed(1)} KB)`)
+        console.log(
+          `  ${filename}.gz (${(gz.length / 1024).toFixed(1)} KB, ${((1 - gz.length / data.length) * 100).toFixed(0)}% smaller)`,
+        )
       }
     }