@xingwangzhe/stalux 1.5.3 → 1.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@xingwangzhe/stalux",
-    "version": "1.5.3",
-    "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}`,
+            );
         }
     }
 
@@ -357,79 +366,63 @@ export async function runFontSubsetting(
     const postMap: Record<string, string> = {};
 
     let subsetCount = 0;
-    const cssGenerated = new Set<string>();
-
-  if (!skipPerRoute) {
-    for (const [hash, routes] of groups) {
-        const filename = `subset-${hash}.ttf`;
-        const outPath = join(outDir, filename);
-        if (!existsSync(outPath)) {
-            const route = routeSets.find((r) => r.hash === hash);
-            const chars = route?.chars ?? "";
-            const uniqueChars = chars
-                .split("")
-                .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);
-                    subsetCount++;
-                    logger.info(
-                        `  subset ${subsetCount}: ${(result.fontBytes.length / 1024).toFixed(1)} KB → ${filename}`,
-                    );
+
+    if (!skipPerRoute) {
+        for (const [hash, routes] of groups) {
+            const filename = `subset-${hash}.ttf`;
+            const outPath = join(outDir, filename);
+            if (!existsSync(outPath)) {
+                const route = routeSets.find((r) => r.hash === hash);
+                const chars = route?.chars ?? "";
+                const uniqueChars = chars
+                    .split("")
+                    .filter((ch) => !commonChars.includes(ch))
+                    .join("");
+                if (uniqueChars.length > 0) {
+                    const data = await doSubset(uniqueChars);
+                    if (data.length > 0) {
+                        writeFileSync(outPath, data);
+                        subsetCount++;
+                        logger.info(
+                            `  subset ${subsetCount}: ${(data.length / 1024).toFixed(1)} KB → ${filename}`,
+                        );
+                    }
                 }
             }
-        }
 
-        // Generate per-route CSS (one per unique hash, references all routes with this hash)
-        if (!cssGenerated.has(hash)) {
-            cssGenerated.add(hash);
+            // Generate per-route CSS (each route gets its own CSS file)
+            // If no unique chars, reference the common TTF as fallback
+            const refTtf = existsSync(outPath) ? filename : commonFilename;
             for (const route of routes) {
                 const cssContent = `/* Auto-generated font subset for route: ${route} */
 @font-face {
     font-family: "LXGW WenKai Subset";
-    src: url("/fonts/${filename}") format("truetype");
+    src: url("/fonts/${refTtf}") format("truetype");
     font-display: swap;
 }
 `;
-                    // Use first route's name as the CSS filename (they share the same subset)
-                    const cssName = routes.length === 1 ? route.replace("/", "-") : `group-${hash}`;
-                    const cssFilename = `subset-${cssName}.css`;
-                    writeFileSync(join(outDir, cssFilename), cssContent);
-                    routeMap[route] = cssFilename;
-
-                    if (route.startsWith("posts/")) {
-                        const abbrlink = route.replace("posts/", "");
-                        postMap[abbrlink] = cssFilename;
-                    }
-                }
-            } else {
-                // CSS already generated, just map
-                for (const route of routes) {
-                    const cssFilename =
-                        routes.length === 1
-                            ? `subset-${route.replace("/", "-")}.css`
-                            : `subset-group-${hash}.css`;
-                    routeMap[route] = cssFilename;
-                    if (route.startsWith("posts/")) {
-                        postMap[route.replace("posts/", "")] = cssFilename;
-                    }
+                const cssName = route.replace("/", "-");
+                const cssFilename = `subset-${cssName}.css`;
+                writeFileSync(join(outDir, cssFilename), cssContent);
+                routeMap[route] = cssFilename;
+
+                if (route.startsWith("posts/")) {
+                    const abbrlink = route.replace("posts/", "");
+                    postMap[abbrlink] = cssFilename;
                 }
             }
         }
-    }
 
-    // 6. Generate manifest
-    const manifest: FontManifest = {
-        common: commonFilename,
-        routes: routeMap,
-        posts: postMap,
-    };
-    writeFileSync(join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-
-    logger.info(
-        `Font subsetting done: ${subsetCount} route subsets + common (${(fontBuffer.length / 1024 / 1024).toFixed(1)} MB → variable)`,
-    );
+        // 6. Generate manifest
+        const manifest: FontManifest = {
+            common: commonFilename,
+            routes: routeMap,
+            posts: postMap,
+        };
+        writeFileSync(join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+
+        logger.info(
+            `Font subsetting done: ${subsetCount} route subsets + common (${(fontBuffer.length / 1024 / 1024).toFixed(1)} MB → variable)`,
+        );
+    }
 }