@xingwangzhe/stalux 1.5.4 → 1.6.1

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.1",
+    "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";
@@ -63,10 +63,37 @@ function getRouteChars(projectRoot: string, subsetId: string): string | null {
         return all.join("\n") || null;
     }
 
-    // ── Other HTML routes (home, archives, tags, categories, links, 404) ──
+    // ── Archives ────────────────────────────────────────────
+    if (subsetId === "archives") {
+        return getAllPostContent(contentRoot);
+    }
+
+    // ── Tags index ──────────────────────────────────────────
+    if (subsetId === "tags") {
+        return getAllTagsAndPostContent(contentRoot);
+    }
+
+    // ── Tags detail ─────────────────────────────────────────
+    if (subsetId.startsWith("tags-")) {
+        const tagName = decodeURIComponent(subsetId.slice(5));
+        return getTagContent(contentRoot, tagName);
+    }
+
+    // ── Categories index ────────────────────────────────────
+    if (subsetId === "categories") {
+        return getAllCategoriesAndPostContent(contentRoot);
+    }
+
+    // ── Categories detail ───────────────────────────────────
+    if (subsetId.startsWith("categories-")) {
+        const catName = decodeURIComponent(subsetId.slice(11));
+        return getCategoryContent(contentRoot, catName);
+    }
+
+    // ── Other HTML routes (home, links, 404) ──
     // These pages use i18n text + config YAML text, which are already
     // covered by the common subset. Return config text for extra safety.
-    if (["home", "archives", "tags", "categories", "links", "common"].includes(subsetId)) {
+    if (["home", "links", "common"].includes(subsetId)) {
         const configDir = join(contentRoot, "config");
         if (!existsSync(configDir)) return null;
         const all: string[] = [];
@@ -81,6 +108,99 @@ function getRouteChars(projectRoot: string, subsetId: string): string | null {
     return null;
 }
 
+/** Get all post content concatenated (including template/_ files) */
+function getAllPostContent(contentRoot: string): string | null {
+    const postsDir = join(contentRoot, "posts");
+    if (!existsSync(postsDir)) return null;
+    const all: string[] = [];
+    for (const f of readdirSync(postsDir)) {
+        if (f.endsWith(".md") || f.endsWith(".mdx")) {
+            all.push(readFileSync(join(postsDir, f), "utf-8"));
+        }
+    }
+    return all.join("\n") || null;
+}
+
+/** Get all tags + all post content */
+function getAllTagsAndPostContent(contentRoot: string): string | null {
+    const postContent = getAllPostContent(contentRoot);
+    if (!postContent) return null;
+    const tags = extractAllYamlValues(postContent, "tags");
+    return postContent + " " + tags.join(" ");
+}
+
+/** Get all categories + all post content */
+function getAllCategoriesAndPostContent(contentRoot: string): string | null {
+    const postContent = getAllPostContent(contentRoot);
+    if (!postContent) return null;
+    const categories = extractAllYamlValues(postContent, "categories");
+    return postContent + " " + categories.join(" ");
+}
+
+/** Get content for a specific tag: tag name + posts with that tag */
+function getTagContent(contentRoot: string, tagName: string): string | null {
+    const postsDir = join(contentRoot, "posts");
+    if (!existsSync(postsDir)) return null;
+    const all: string[] = [tagName];
+    for (const f of readdirSync(postsDir)) {
+        if ((f.endsWith(".md") || f.endsWith(".mdx")) && !f.startsWith("_")) {
+            const content = readFileSync(join(postsDir, f), "utf-8");
+            const tags = extractYamlListFromContent(content, "tags");
+            if (tags.includes(tagName)) {
+                all.push(content);
+            }
+        }
+    }
+    return all.join("\n") || null;
+}
+
+/** Get content for a specific category: category name + posts in that category */
+function getCategoryContent(contentRoot: string, catName: string): string | null {
+    const postsDir = join(contentRoot, "posts");
+    if (!existsSync(postsDir)) return null;
+    const all: string[] = [catName];
+    for (const f of readdirSync(postsDir)) {
+        if ((f.endsWith(".md") || f.endsWith(".mdx")) && !f.startsWith("_")) {
+            const content = readFileSync(join(postsDir, f), "utf-8");
+            const categories = extractYamlListFromContent(content, "categories");
+            if (categories.includes(catName)) {
+                all.push(content);
+            }
+        }
+    }
+    return all.join("\n") || null;
+}
+
+/** Extract a YAML list value from frontmatter by key */
+function extractYamlListFromContent(content: string, key: string): string[] {
+    const lines: string[] = [];
+    const regex = new RegExp(`^${key}:$`, "m");
+    const match = content.match(regex);
+    if (!match) return [];
+    const startIdx = match.index! + match[0].length;
+    const afterKey = content.slice(startIdx);
+    const listMatch = afterKey.match(/^\n((?:\s+-\s+.+\n?)*)/);
+    if (!listMatch) return [];
+    for (const line of listMatch[1].split("\n")) {
+        const item = line.match(/^\s+-\s+(.+)/)?.[1];
+        if (item) lines.push(item.trim());
+    }
+    return lines;
+}
+
+/** Extract all YAML list values from all posts by key */
+function extractAllYamlValues(postContent: string, key: string): string[] {
+    const values = new Set<string>();
+    // Split by frontmatter boundaries (---)
+    const parts = postContent.split(/^---$/m);
+    for (let i = 1; i < parts.length; i += 2) {
+        const fm = parts[i];
+        const list = extractYamlListFromContent("---\n" + fm + "\n---\n", key);
+        for (const v of list) values.add(v);
+    }
+    return [...values];
+}
+
 /**
  * Generate and serve a font subset on demand.
  * Returns the CSS content to be served.
@@ -98,14 +218,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 +234,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 +264,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
@@ -97,19 +103,81 @@ function scanContent(projectRoot: string): ContentFile[] {
 
     // Posts
     const postsDir = join(contentRoot, "posts");
+    const allPostContents: {
+        abbrlink: string;
+        tags: string[];
+        categories: string[];
+        content: string;
+    }[] = [];
     if (existsSync(postsDir)) {
         for (const f of readdirSync(postsDir)) {
             if (!f.endsWith(".md") && !f.endsWith(".mdx")) continue;
-            if (f.startsWith("_")) continue; // skip template files
             const content = readFileSync(join(postsDir, f), "utf-8");
-            // Extract abbrlink from frontmatter
+            const isTemplate = f.startsWith("_");
+
+            // Per-post routes: skip template (_) files
+            if (!isTemplate) {
+                const abbrlinkMatch = content.match(/^abbrlink:\s*(.+)$/m);
+                const abbrlink = abbrlinkMatch?.[1]?.trim() ?? basename(f, extname(f));
+                files.push({
+                    route: `posts/${abbrlink}`,
+                    filePath: join(postsDir, f),
+                    abbrlink,
+                });
+            }
+
+            // Virtual routes (archives/tags/categories): include ALL posts including templates
+            // because content collections load them and they render on those pages
             const abbrlinkMatch = content.match(/^abbrlink:\s*(.+)$/m);
             const abbrlink = abbrlinkMatch?.[1]?.trim() ?? basename(f, extname(f));
-            files.push({
-                route: `posts/${abbrlink}`,
-                filePath: join(postsDir, f),
-                abbrlink,
-            });
+            const tags = extractYamlList(content, "tags");
+            const categories = extractYamlList(content, "categories");
+            allPostContents.push({ abbrlink, tags, categories, content });
+        }
+    }
+
+    // Build virtual routes for archives, tags, categories (aggregated pages)
+    // These pages render content from ALL posts
+    if (allPostContents.length > 0) {
+        const allContent = allPostContents.map((p) => p.content).join("\n");
+
+        // Archives: all posts' content (titles, dates, etc.)
+        virtualRouteCache.set("archives", extractChars(allContent));
+
+        // Tags index: all tags + all posts' content
+        const allTags = [...new Set(allPostContents.flatMap((p) => p.tags))].join(" ");
+        virtualRouteCache.set("tags", extractChars(allContent + allTags));
+
+        // Categories index: all categories + all posts' content
+        const allCategories = [...new Set(allPostContents.flatMap((p) => p.categories))].join(" ");
+        virtualRouteCache.set("categories", extractChars(allContent + allCategories));
+
+        // Per-tag routes: tag name + posts with that tag
+        const tagPosts = new Map<string, string[]>();
+        for (const p of allPostContents) {
+            for (const tag of p.tags) {
+                const list = tagPosts.get(tag) ?? [];
+                list.push(p.content);
+                tagPosts.set(tag, list);
+            }
+        }
+        for (const [tag, contents] of tagPosts) {
+            const tagContent = tag + " " + contents.join("\n");
+            virtualRouteCache.set(`tags-${tag}`, extractChars(tagContent));
+        }
+
+        // Per-category routes: category name + posts in that category
+        const catPosts = new Map<string, string[]>();
+        for (const p of allPostContents) {
+            for (const cat of p.categories) {
+                const list = catPosts.get(cat) ?? [];
+                list.push(p.content);
+                catPosts.set(cat, list);
+            }
+        }
+        for (const [cat, contents] of catPosts) {
+            const catContent = cat + " " + contents.join("\n");
+            virtualRouteCache.set(`categories-${cat}`, extractChars(catContent));
         }
     }
 
@@ -150,11 +218,37 @@ function scanContent(projectRoot: string): ContentFile[] {
         }
     }
 
+    // Add virtual routes (archives, tags, categories) as content files
+    for (const [route] of virtualRouteCache) {
+        files.push({
+            route,
+            filePath: resolve(projectRoot, CONTENT_ROOT, `_virtual/${route}.md`),
+        });
+    }
+
     return files;
 }
 
+/** Extract a YAML list value from frontmatter by key */
+function extractYamlList(content: string, key: string): string[] {
+    const lines: string[] = [];
+    const regex = new RegExp(`^${key}:$`, "m");
+    const match = content.match(regex);
+    if (!match) return [];
+    const startIdx = match.index! + match[0].length;
+    const afterKey = content.slice(startIdx);
+    const listMatch = afterKey.match(/^\n((?:\s+-\s+.+\n?)*)/);
+    if (!listMatch) return [];
+    for (const line of listMatch[1].split("\n")) {
+        const item = line.match(/^\s+-\s+(.+)/)?.[1];
+        if (item) lines.push(item.trim());
+    }
+    return lines;
+}
+
 // Cache for virtual route char sets
 const wordCharsCache = new Map<string, string>();
+const virtualRouteCache = new Map<string, string>();
 
 // ---------------------------------------------------------------------------
 // Common subset: extract chars from UI source files
@@ -277,20 +371,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 */
+                }
             }
         }
     }
@@ -309,6 +399,8 @@ export async function runFontSubsetting(
         let content: string;
         if (file.route === "words" && wordCharsCache.has("words")) {
             content = wordCharsCache.get("words")!;
+        } else if (virtualRouteCache.has(file.route)) {
+            content = virtualRouteCache.get(file.route)!;
         } else {
             content = readFileSync(file.filePath, "utf-8");
         }
@@ -320,25 +412,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 +469,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}`,
                         );
                     }
                 }

package/src/pages/archives.astro

@@ -12,7 +12,7 @@ const { t } = createTranslator(siteConfig.lang || "zh-CN");
 const posts = await getCollection("posts", ({ data }) => !data.draft);
 ---
 
-<Stalux title={t("archives.title") + " | " + siteConfig.title} description={t("archives.description", { title: siteConfig.title })}>
+<Stalux title={t("archives.title") + " | " + siteConfig.title} description={t("archives.description", { title: siteConfig.title })} fontSubsetId={posts.length > 0 ? "archives" : undefined}>
     <div style="height: 3em;"></div>
     <Navs />
     <h1 class={styles.h1}>{t("archives.heading")}</h1>

package/src/pages/categories/[category].astro

@@ -27,7 +27,7 @@ const props = Astro.props as Props;
 <Stalux
     title={t("taxonomy.category") + ": " + props.category + " | " + siteConfig.title}
     description={t("taxonomy.browseCategory", { title: siteConfig.title, category: props.category, count: props.count })}
-   
+    fontSubsetId={props.posts.length > 0 ? `categories-${encodeURIComponent(props.category)}` : undefined}
 >
     <div style="height: 3em;"></div>
     <Navs />

package/src/pages/categories/index.astro

@@ -9,12 +9,14 @@ import { getSiteData, getAuthorData, getHeadData, getNavsData, getLinksData, get
 const configEntries2 = await getCollection("config");
 const siteConfig = getSiteData(configEntries2);
 const { t } = createTranslator(siteConfig.lang || "zh-CN");
+const posts = await getCollection("posts", ({ data }) => !data.draft);
+const hasContent = posts.length > 0;
 ---
 
 <Stalux
     title={t("categories.title") + " | " + siteConfig.title}
     description={t("categories.description", { title: siteConfig.title })}
-   
+    fontSubsetId={hasContent ? "categories" : undefined}
 >
     <div style="height: 3em;"></div>
     <Navs />

package/src/pages/tags/[tag].astro

@@ -29,7 +29,7 @@ const props = Astro.props as Props;
     title={t("taxonomy.tag") + ": " + props.tag + " | " + siteConfig.title}
     description={t("taxonomy.browseTag", { title: siteConfig.title, tag: props.tag, count: props.count })}
     noindex={props.count < 3}
-   
+    fontSubsetId={props.posts.length > 0 ? `tags-${encodeURIComponent(props.tag)}` : undefined}
 >
     <div style="height: 3em;"></div>
     <Navs />

package/src/pages/tags/index.astro

@@ -9,12 +9,14 @@ import { getSiteData, getAuthorData, getHeadData, getNavsData, getLinksData, get
 const configEntries = await getCollection("config");
 const siteConfig = getSiteData(configEntries);
 const { t } = createTranslator(siteConfig.lang || "zh-CN");
+const posts = await getCollection("posts", ({ data }) => !data.draft);
+const hasContent = posts.length > 0;
 ---
 
 <Stalux
     title={t("tags.title") + " | " + siteConfig.title}
     description={t("tags.description", { title: siteConfig.title })}
-   
+    fontSubsetId={hasContent ? "tags" : undefined}
 >
     <div style="height: 3em;"></div>
     <Navs />