@xingwangzhe/stalux 1.5.4 → 1.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@xingwangzhe/stalux",
-    "version": "1.5.4",
-    "description": "A powerful, modern Astro blog theme \u2014 use as template or install as plugin",
+    "version": "1.6.0",
+    "description": "A powerful, modern Astro blog theme — use as template or install as plugin",
     "keywords": [
         "astro",
         "astro-integration",
@@ -83,15 +83,15 @@
         "@xingwangzhe/satteri-photoswipe": "^0.2.0",
         "@xingwangzhe/tags-cloud": "^1.2.4",
         "animejs": "^4.5.0",
-        "astro": "^7.1.3",
         "astro-expressive-code": "^0.44.1",
         "astro-seo": "^1.1.0",
         "astro-typewriter": "^1.2.0",
         "badge-maker": "^6.0.0",
         "pagefind": "^1.5.2",
         "photoswipe": "^5.4.4",
+        "satteri": "^0.9.5",
         "simple-icons": "^16.27.1",
-        "taetype": "0.1.3",
+        "subset-font": "^2.5.0",
         "temml": "^0.13.3"
     },
     "devDependencies": {

package/src/index.ts

@@ -8,10 +8,10 @@
  * 基于 Astro 7.1.3 Integration API（astro:config:setup / injectRoute / injectScript）
  */
 
+import { existsSync, readdirSync } from "node:fs";
 import path from "node:path";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync, readdirSync } from "node:fs";
 
 import type { AstroIntegration } from "astro";
 // pagefind 是 ESM-only 包，需要在模块顶层导入

package/src/internal/font-subset-dev.ts

@@ -1,7 +1,7 @@
 /**
  * Dev mode on-demand font subsetting middleware.
  *
- * Intercepts /fonts/subset-*.css requests, generates the WOFF2 subset
+ * Intercepts /fonts/subset-*.css requests, generates the TTF subset
  * for the requested route on-the-fly, and serves it.
  *
  * Handles ALL HTML routes: posts, about, words, home, archives, tags, etc.
@@ -12,7 +12,7 @@ import { resolve, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import type { AstroIntegrationLogger } from "astro";
-import { register_font_raw, get_glyph_ids, subset_font_full } from "taetype";
+import subsetFont from "subset-font";
 
 const FONT_INPUT = "src/assets/fonts/LXGWWenKai-Regular.ttf";
 const CONTENT_ROOT = "stalux";
@@ -98,14 +98,6 @@ async function generateSubsetOnDemand(
     for (const ch of chars) charSet.add(ch);
     if (charSet.size === 0) return null;
 
-    // Deduplicate against common subset
-    const outDir = resolve(projectRoot, FONT_OUT_DIR);
-
-    // We can't precisely know which chars common covers without re-extracting.
-    // But we can read the i18n + config source for a rough estimate.
-    // For now, generate the full subset - the WOFF2 will be small either way.
-    // (Most chars are already in common, so the delta is tiny.)
-
     // Locate font file
     const fontPaths = [
         resolve(projectRoot, FONT_INPUT),
@@ -122,23 +114,23 @@ async function generateSubsetOnDemand(
     if (!fontPath) return null;
 
     const fontBuffer = readFileSync(fontPath);
+    const outDir = resolve(projectRoot, FONT_OUT_DIR);
     mkdirSync(outDir, { recursive: true });
 
-    // Generate subset TTF using taetype
+    // Generate subset TTF using subset-font (WASM)
     const charsStr = [...charSet].sort().join("");
-    try { register_font_raw("stalux", fontBuffer); } catch { /* already registered */ }
-    const glyphs = get_glyph_ids(charsStr, "stalux", "normal", 400);
-    if (glyphs.length === 0) return null;
-    const subsetResult = subset_font_full("stalux", "normal", 400, 0, glyphs);
-    const hash = [...charsStr].slice(0, 12).join("");
+    const hash = hashStr(charsStr);
     const filename = `subset-${subsetId}-${hash}.ttf`;
     const outPath = join(outDir, filename);
 
     if (!existsSync(outPath)) {
         try {
-            writeFileSync(outPath, subsetResult.fontBytes);
+            const result = await subsetFont(fontBuffer, charsStr, {
+                targetFormat: "sfnt",
+            });
+            writeFileSync(outPath, result);
             logger.info(
-                `  on-demand subset: ${(subsetResult.fontBytes.length / 1024).toFixed(1)} KB → ${filename}`,
+                `  on-demand subset: ${(result.length / 1024).toFixed(1)} KB → ${filename}`,
             );
         } catch {
             return null;
@@ -152,6 +144,17 @@ async function generateSubsetOnDemand(
 }`;
 }
 
+/** Simple hash function for strings */
+function hashStr(s: string): string {
+    let hash = 0;
+    for (let i = 0; i < s.length && i < 100; i++) {
+        const ch = s.charCodeAt(i);
+        hash = (hash << 5) - hash + ch;
+        hash |= 0;
+    }
+    return Math.abs(hash).toString(36).slice(0, 8);
+}
+
 /**
  * Create Vite middleware for on-demand font subsetting in dev mode.
  */

package/src/internal/font-subset.ts

@@ -2,26 +2,32 @@
  * Per-route font subsetting engine.
  *
  * Scans each content file individually, extracts its unique character set,
- * and generates a minimal WOFF2 subset per route. Also generates a "common"
+ * and generates a minimal TTF subset per route. Also generates a "common"
  * subset for UI text (navs, i18n, layout).
  *
  * Output layout (under public/fonts/):
  *   fonts/
- *     common.ttf             — UI text subset (ASCII, nav, i18n)
- *     post-{abbrlink}.ttf   — per-post subset
- *     about.ttf              — about page subset
- *     words.ttf              — combined words subset
- *     manifest.json         — route → subset file mapping
- *     subset.css            — global @font-face declarations
+ *     common-{hash}.ttf       — UI text subset (ASCII, nav, i18n)
+ *     subset-{hash}.ttf       — per-route subset (shared by routes with same chars)
+ *     common.css              — @font-face for common subset
+ *     subset-{route}.css      — per-route @font-face
+ *     manifest.json           — route → subset file mapping
  */
 
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from "node:fs";
+import {
+    existsSync,
+    mkdirSync,
+    readFileSync,
+    writeFileSync,
+    readdirSync,
+    unlinkSync,
+} from "node:fs";
 import { resolve, basename, extname, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import type { AstroIntegrationLogger } from "astro";
-import { register_font_raw, get_glyph_ids, subset_font_full } from "taetype";
+import subsetFont from "subset-font";
 
 // ---------------------------------------------------------------------------
 // Configuration
@@ -277,20 +283,16 @@ export async function runFontSubsetting(
     }
     const fontBuffer = readFileSync(fontPath);
 
-    // Register font with taetype for fast Rust subsetting
-    try {
-      register_font_raw("stalux", fontBuffer);
-    } catch (e) {
-      logger.warn(`Font registration failed: ${e}, skipping subsetting`);
-      return;
-    }
-
     // Clean old generated font files to avoid stale cached references
     const outDir = resolve(projectRoot, FONT_OUT_DIR);
     if (existsSync(outDir)) {
         for (const f of readdirSync(outDir)) {
             if (f.startsWith("common-") || f.startsWith("subset-")) {
-                try { unlinkSync(join(outDir, f)); } catch { /* skip */ }
+                try {
+                    unlinkSync(join(outDir, f));
+                } catch {
+                    /* skip */
+                }
             }
         }
     }
@@ -320,25 +322,32 @@ export async function runFontSubsetting(
         });
     }
 
-    // 5. Deduplicate and generate subsets using taetype (Rust native, fast)
+    // 5. Deduplicate and generate subsets using subset-font (WASM)
     mkdirSync(outDir, { recursive: true });
 
-    // Helper: subset using taetype
-    function doSubset(chars: string): Uint8Array {
-        const glyphs = get_glyph_ids(chars, "stalux", "normal", 400);
-        if (glyphs.length === 0) return new Uint8Array(0);
-        const result = subset_font_full("stalux", "normal", 400, 0, glyphs);
-        return result.fontBytes;
+    // Helper: subset using subset-font (async WASM)
+    async function doSubset(chars: string): Promise<Uint8Array> {
+        if (!chars) return new Uint8Array(0);
+        try {
+            const result = await subsetFont(fontBuffer, chars, {
+                targetFormat: "sfnt", // "sfnt" = TTF output
+            });
+            return result;
+        } catch {
+            return new Uint8Array(0);
+        }
     }
 
     // Generate common subset
     const commonFilename = `common-${commonHash}.ttf`;
     const commonOutPath = join(outDir, commonFilename);
     if (!existsSync(commonOutPath)) {
-        const data = doSubset(commonChars);
+        const data = await doSubset(commonChars);
         if (data.length > 0) {
             writeFileSync(commonOutPath, data);
-            logger.info(`  common subset: ${(data.length / 1024).toFixed(1)} KB → ${commonFilename}`);
+            logger.info(
+                `  common subset: ${(data.length / 1024).toFixed(1)} KB → ${commonFilename}`,
+            );
         }
     }
 
@@ -370,13 +379,12 @@ export async function runFontSubsetting(
                     .filter((ch) => !commonChars.includes(ch))
                     .join("");
                 if (uniqueChars.length > 0) {
-                    const glyphs = get_glyph_ids(uniqueChars, "stalux", "normal", 400);
-                    if (glyphs.length > 0) {
-                        const result = subset_font_full("stalux", "normal", 400, 0, glyphs);
-                        writeFileSync(outPath, result.fontBytes);
+                    const data = await doSubset(uniqueChars);
+                    if (data.length > 0) {
+                        writeFileSync(outPath, data);
                         subsetCount++;
                         logger.info(
-                            `  subset ${subsetCount}: ${(result.fontBytes.length / 1024).toFixed(1)} KB → ${filename}`,
+                            `  subset ${subsetCount}: ${(data.length / 1024).toFixed(1)} KB → ${filename}`,
                         );
                     }
                 }