@xingwangzhe/stalux 1.6.0 → 1.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xingwangzhe/stalux",
-    "version": "1.6.0",
+    "version": "1.6.2",
     "description": "A powerful, modern Astro blog theme — use as template or install as plugin",
     "keywords": [
         "astro",

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

@@ -63,22 +63,156 @@ function getRouteChars(projectRoot: string, subsetId: string): string | null {
         return all.join("\n") || null;
     }
 
-    // ── Other HTML routes (home, archives, tags, categories, 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)) {
-        const configDir = join(contentRoot, "config");
-        if (!existsSync(configDir)) return null;
-        const all: string[] = [];
-        for (const f of readdirSync(configDir)) {
-            if (f.endsWith(".yml") || f.endsWith(".yaml")) {
-                all.push(readFileSync(join(configDir, f), "utf-8"));
+    // ── 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);
+    }
+
+    // ── Home page ───────────────────────────────────────────
+    if (subsetId === "home") {
+        return getAllConfigContent(contentRoot);
+    }
+
+    // ── Links page ──────────────────────────────────────────
+    if (subsetId === "links") {
+        return getAllConfigContent(contentRoot);
+    }
+
+    // ── Other HTML routes (common) ──
+    // The common subset includes UI text from source + config YAML
+    if (subsetId === "common") {
+        return getAllConfigContent(contentRoot);
+    }
+
+    return null;
+}
+
+/** Get all config YAML content */
+function getAllConfigContent(contentRoot: string): string | null {
+    const configDir = join(contentRoot, "config");
+    if (!existsSync(configDir)) return null;
+    const all: string[] = [];
+    for (const f of readdirSync(configDir)) {
+        if (f.endsWith(".yml") || f.endsWith(".yaml")) {
+            all.push(readFileSync(join(configDir, f), "utf-8"));
+        }
+    }
+    return all.join("\n") || 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;
     }
+    return all.join("\n") || null;
+}
 
-    return 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];
 }
 
 /**

package/src/internal/font-subset.ts

@@ -103,19 +103,100 @@ 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));
+        }
+    }
+
+    // Build virtual routes for config-driven pages (home, links)
+    // These pages render text from config YAML files (nav titles, site title, etc.)
+    const configDir = join(contentRoot, "config");
+    if (existsSync(configDir)) {
+        const allConfigContent: string[] = [];
+        for (const f of readdirSync(configDir)) {
+            if (f.endsWith(".yml") || f.endsWith(".yaml")) {
+                allConfigContent.push(readFileSync(join(configDir, f), "utf-8"));
+            }
+        }
+        if (allConfigContent.length > 0) {
+            const configText = allConfigContent.join("\n");
+            // Home page: site title, author, navs, typetexts, social media, footer
+            virtualRouteCache.set("home", extractChars(configText));
+            // Links page: links config + navs + footer
+            virtualRouteCache.set("links", extractChars(configText));
         }
     }
 
@@ -156,11 +237,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
@@ -311,6 +418,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");
         }

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/index.astro

@@ -15,7 +15,7 @@ import ToArchive from "@components/stalux/archives/toArchive.astro";
 import { getSiteData, getAuthorData, getHeadData, getNavsData, getLinksData, getCommentData, getFooterData, getPromoteData, getTypetextsData, getMediaLinksData } from "@utils/config-utils";
 ---
 
-<Stalux title={siteTitle} description={siteDescription}>
+<Stalux title={siteTitle} description={siteDescription} fontSubsetId="home">
   <div class={styles.homeBody}>
     <h1 class={styles.homeTitle}>{siteTitle}</h1>
     <div class={styles.homeNavs}>

package/src/pages/links.astro

@@ -13,12 +13,12 @@ const linksTitle = linksConfig.title;
 const linksDescription = linksConfig.description;
 ---
 
-	<ListPage
-	    title={siteTitle}
-	    description={siteDescription}
-	    heading={linksTitle}
-	    subheading={linksDescription}
-	   
-	>
+		<ListPage
+		    title={siteTitle}
+		    description={siteDescription}
+		    heading={linksTitle}
+		    subheading={linksDescription}
+		    fontSubsetId="links"
+		>
     <LinkList />
 </ListPage>

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 />