hexo-theme-gnix 9.0.0 → 11.0.0

package/README.md

@@ -12,8 +12,8 @@ hexo config theme gnix
 Support multiple light and dark themes:
 
 - **System Theme**: Follow system theme automatically, use `Nord` for light mode and `Mocha` for dark mode by default
-- **Light Themes**: `Nord`, `Cattpuccin Latte`
-- **Dark Themes**: `Catppuccin Mocha`, `Catppuccin Macchiato`, `Tokyo Night`
+- **Light Themes**: `Nord`, `Catppuccin Latte`, `Song Porcelain`
+- **Dark Themes**: `Catppuccin Mocha`, `Nord Night`, `Rosé Pine`, `Tokyo Night`
 
 <table border="1">
   <tr>
@@ -25,10 +25,6 @@ Support multiple light and dark themes:
 
 ## Components
 
-```shell
-bun i hexo-renderer-markdown-exit
-```
-
 ### Table, Math, Quote, Callout & Tabs, Highlight
 
 <table>
@@ -64,3 +60,5 @@ bun i hexo-renderer-markdown-exit
 - [ppoffice/hexo-theme-icarus: A simple, delicate, and modern theme for the static site generator Hexo.](https://github.com/ppoffice/hexo-theme-icarus)
 - [D0n9X1n/hexo-blog-encrypt: Yet, just another hexo plugin for security.](https://github.com/D0n9X1n/hexo-blog-encrypt)
 - [hexojs/hexo-generator-feed: Feed generator for Hexo.](https://github.com/hexojs/hexo-generator-feed)
+- [hexojs/hexo-generator-tag: Tag generator for Hexo.](https://github.com/hexojs/hexo-generator-tag)
+- [hexojs/hexo-generator-archive: Archive generator for Hexo.](https://github.com/hexojs/hexo-generator-archive)

package/include/hexo/feed.js

@@ -120,15 +120,15 @@ module.exports = (hexo) => {
     const currentYear = new Date().getFullYear();
 
     return {
-      title: context.title,
-      description: context.subtitle || context.description,
+      title: context.config.title,
+      description: context.config.subtitle || context.config.description,
       url,
       feedUrl,
       icon,
       hub,
-      language: context.language,
-      author: { name: context.author, email: context.email },
-      copyright: context.author && `All rights reserved ${currentYear}, ${context.author}`,
+      language: context.config.language,
+      author: { name: context.config.author, email: context.config.email },
+      copyright: context.config.author && `All rights reserved ${currentYear}, ${context.config.author}`,
       updated: latestPost.updated ? latestPost.updated.toDate() : latestPost.date.toDate(),
     };
   }

package/include/hexo/filter.js

@@ -26,9 +26,10 @@ module.exports = (hexo) => {
   };
 
   function stripConfig(source, reservedKeys) {
+    const localOnlyKeys = ["i18n"];
     const result = {};
     Object.keys(source)
-      .filter((key) => !key.startsWith("_") && !reservedKeys.includes(key) && typeof source[key] !== "function")
+      .filter((key) => !key.startsWith("_") && !reservedKeys.includes(key) && !localOnlyKeys.includes(key) && typeof source[key] !== "function")
       .forEach((key) => {
         result[key] = source[key];
       });
@@ -66,4 +67,27 @@ module.exports = (hexo) => {
 
     return locals;
   });
+
+  hexo.extend.filter.register("after_render:html", (data) => {
+    if (!data.includes("data-page-head") || !data.includes("</head>")) {
+      return data;
+    }
+
+    const seenHeadTags = new Set();
+    const headTags = [];
+    const html = data.replace(/<link\b(?=[^>]*\sdata-page-head(?:=(?:"[^"]*"|'[^']*'|[^\s>]+))?)[^>]*>/gi, (tag) => {
+      const cleanTag = tag.replace(/\sdata-page-head(?:=(?:"[^"]*"|'[^']*'|[^\s>]+))?/i, "");
+      if (!seenHeadTags.has(cleanTag)) {
+        seenHeadTags.add(cleanTag);
+        headTags.push(cleanTag);
+      }
+      return "";
+    });
+
+    if (!headTags.length) {
+      return data;
+    }
+
+    return html.replace("</head>", `${headTags.join("")}</head>`);
+  });
 };

package/include/hexo/generator/archive.js

@@ -0,0 +1,116 @@
+const pagination = require("hexo-pagination");
+const { filterByLanguage, getLanguage, getLanguageBasePath, getLanguageKeys, isI18nEnabled } = require("../../util/i18n");
+
+const fmtNum = (num) => num.toString().padStart(2, "0");
+
+module.exports = (hexo) => {
+  hexo.extend.generator.register("archive", function (locals) {
+    const { config } = this;
+    const fullConfig = Object.assign({}, config, config.theme_config, hexo.theme.config);
+    const themeConfig = hexo.theme.config.archive_generator || {};
+    let archiveDir = config.archive_dir || "archives";
+    const paginationDir = config.pagination_dir || "page";
+    const perPage = themeConfig.per_page ?? 0;
+    const { Query } = this.model("Post");
+    const result = [];
+
+    if (!archiveDir.endsWith("/")) archiveDir += "/";
+
+    function generate(path, posts, options = {}) {
+      options.archive = true;
+      result.push(
+        ...pagination(path, posts, {
+          perPage,
+          layout: ["archive", "index"],
+          format: `${paginationDir}/%d/`,
+          data: options,
+        }),
+      );
+    }
+
+    function generateLanguageArchives(langKey = null) {
+      const languageBase = langKey ? getLanguageBasePath(fullConfig, langKey) : "";
+      const allPostsSource = locals.posts.sort(themeConfig.order_by || "-date");
+      const allPosts = langKey ? filterByLanguage(allPostsSource, langKey, fullConfig) : allPostsSource;
+
+      if (!allPosts.length) return;
+
+      const baseArchiveDir = languageBase + archiveDir;
+      const languageData = langKey
+        ? {
+            i18n_lang: langKey,
+            lang: getLanguage(fullConfig, langKey).locale,
+          }
+        : {};
+
+      generate(baseArchiveDir, allPosts, languageData);
+
+      const yearly = themeConfig.yearly ?? true;
+      const monthly = themeConfig.monthly ?? true;
+      const daily = themeConfig.daily ?? false;
+
+      if (!yearly) return;
+
+      const posts = {};
+
+      allPosts.forEach((post) => {
+        const date = post.date;
+        const year = date.year();
+        const month = date.month() + 1;
+
+        if (!Object.hasOwn(posts, year)) {
+          posts[year] = [[], [], [], [], [], [], [], [], [], [], [], [], []];
+        }
+
+        posts[year][0].push(post);
+        posts[year][month].push(post);
+
+        if (daily) {
+          const day = date.date();
+          if (!Object.hasOwn(posts[year][month], "day")) {
+            posts[year][month].day = {};
+          }
+          (posts[year][month].day[day] || (posts[year][month].day[day] = [])).push(post);
+        }
+      });
+
+      const years = Object.keys(posts);
+
+      for (let i = 0, len = years.length; i < len; i++) {
+        const year = +years[i];
+        const data = posts[year];
+        const url = `${baseArchiveDir + year}/`;
+        if (!data[0].length) continue;
+
+        generate(url, new Query(data[0]), Object.assign({ year }, languageData));
+
+        if (!monthly && !daily) continue;
+
+        for (let month = 1; month <= 12; month++) {
+          const monthData = data[month];
+          if (!monthData.length) continue;
+
+          if (monthly) {
+            generate(`${url + fmtNum(month)}/`, new Query(monthData), Object.assign({ year, month }, languageData));
+          }
+
+          if (!daily) continue;
+
+          for (let day = 1; day <= 31; day++) {
+            const dayData = monthData.day[day];
+            if (!dayData || !dayData.length) continue;
+            generate(`${url + fmtNum(month)}/${fmtNum(day)}/`, new Query(dayData), Object.assign({ year, month, day }, languageData));
+          }
+        }
+      }
+    }
+
+    if (isI18nEnabled(fullConfig)) {
+      getLanguageKeys(fullConfig).forEach((langKey) => generateLanguageArchives(langKey));
+      return result;
+    }
+
+    generateLanguageArchives();
+    return result;
+  });
+};

package/include/hexo/generator/home.js

@@ -0,0 +1,64 @@
+const pagination = require("hexo-pagination");
+const { filterByLanguage, getDefaultLanguageKey, getLanguage, getLanguageBasePath, getLanguageKeys, isI18nEnabled } = require("../../util/i18n");
+
+function redirectTo(path) {
+  const target = path.startsWith("/") ? path : `/${path}`;
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="robots" content="noindex"><meta http-equiv="refresh" content="0;url=${target}"><link rel="canonical" href="${target}"></head><body><a href="${target}">Continue</a></body></html>`;
+}
+
+module.exports = (hexo) => {
+  hexo.extend.generator.register("index", function (locals) {
+    const config = this.config;
+    const fullConfig = Object.assign({}, config, config.theme_config, hexo.theme.config);
+    const themeConfig = hexo.theme.config.index_generator || {};
+    const orderBy = themeConfig.order_by ?? "-date";
+    const perPage = themeConfig.per_page ?? config.per_page ?? 16;
+    const layout = themeConfig.layout ?? ["index", "archive"];
+    const paginationDir = themeConfig.pagination_dir ?? config.pagination_dir ?? "page";
+    const path = themeConfig.path ?? "";
+
+    if (!isI18nEnabled(fullConfig)) {
+      const posts = locals.posts.sort(orderBy);
+      posts.data.sort((a, b) => (b.sticky || 0) - (a.sticky || 0));
+
+      return pagination(path, posts, {
+        perPage,
+        layout,
+        format: `${paginationDir}/%d/`,
+        data: {
+          __index: true,
+        },
+      });
+    }
+
+    const result = [];
+    const defaultLanguageBase = getLanguageBasePath(fullConfig, getDefaultLanguageKey(fullConfig));
+
+    if (defaultLanguageBase) {
+      result.push({
+        path: "index.html",
+        data: redirectTo(defaultLanguageBase),
+      });
+    }
+
+    getLanguageKeys(fullConfig).forEach((langKey) => {
+      const posts = filterByLanguage(locals.posts.sort(orderBy), langKey, fullConfig);
+      posts.data.sort((a, b) => (b.sticky || 0) - (a.sticky || 0));
+
+      result.push(
+        ...pagination(getLanguageBasePath(fullConfig, langKey) + path, posts, {
+          perPage,
+          layout,
+          format: `${paginationDir}/%d/`,
+          data: {
+            __index: true,
+            i18n_lang: langKey,
+            lang: getLanguage(fullConfig, langKey).locale,
+          },
+        }),
+      );
+    });
+
+    return result;
+  });
+};

package/include/hexo/generator/index.js

@@ -0,0 +1,82 @@
+const util = require("hexo-util");
+const { filterByLanguage, getLanguageBasePath, getLanguageKeys, getLocalizedTagPath, isI18nEnabled } = require("../../util/i18n");
+
+function minify(str) {
+  return util
+    .stripHTML(str)
+    .trim()
+    .replace(/\s+/g, " ")
+    .replace(/&#(?:x([\da-fA-F]+)|([\d]+));/g, (_, hex, dec) => {
+      return String.fromCharCode(parseInt(hex || dec, hex ? 16 : 10));
+    });
+}
+
+function mapPost(post, url_for) {
+  return {
+    title: util.escapeHTML(post.title).trim(),
+    text: post.password ? "该文章需要密码" : minify(post.content),
+    link: url_for(post.path),
+  };
+}
+
+function mapTag(tag, url_for, langKey = null, config = {}) {
+  return {
+    name: util.escapeHTML(tag.name).trim(),
+    slug: minify(tag.slug),
+    link: url_for(langKey ? `/${getLocalizedTagPath(tag, langKey, config)}` : tag.path),
+  };
+}
+
+module.exports = (hexo) => {
+  const mdConfig = hexo.theme.config.md_generator || {};
+  if (mdConfig.enabled !== false) {
+    require("./md_generator")(hexo);
+  }
+
+  hexo.extend.generator.register("insight", function (locals) {
+    const url_for = hexo.extend.helper.get("url_for").bind(this);
+    const fullConfig = Object.assign({}, this.config, this.config.theme_config, hexo.theme.config);
+
+    if (isI18nEnabled(fullConfig)) {
+      return getLanguageKeys(fullConfig).map((langKey) => {
+        const posts = filterByLanguage(locals.posts, langKey, fullConfig);
+        const tags = locals.tags
+          .filter((tag) => filterByLanguage(tag.posts, langKey, fullConfig).length)
+          .map((tag) => mapTag(tag, url_for, langKey, fullConfig));
+
+        return {
+          path: `${getLanguageBasePath(fullConfig, langKey)}content.json`,
+          data: JSON.stringify({
+            posts: posts.map((post) => mapPost(post, url_for)),
+            tags,
+          }),
+        };
+      });
+    }
+
+    return {
+      path: "/content.json",
+      data: JSON.stringify({
+        posts: locals.posts.map((post) => mapPost(post, url_for)),
+        tags: locals.tags.map((tag) => mapTag(tag, url_for)),
+      }),
+    };
+  });
+
+  const tagConfig = hexo.theme.config.tag_generator || {};
+  if (tagConfig.enabled !== false) {
+    require("./tag")(hexo);
+  }
+
+  const archiveConfig = hexo.theme.config.archive_generator || {};
+  if (archiveConfig.enabled !== false) {
+    require("./archive")(hexo);
+  }
+
+  const indexConfig = hexo.theme.config.index_generator || {};
+  if (indexConfig.enabled !== false) {
+    require("./home")(hexo);
+  }
+
+  require("./page")(hexo);
+};

package/include/hexo/generator/md_generator.js

@@ -0,0 +1,87 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { Readable } = require("node:stream");
+
+const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]);
+const MARKDOWN_EXTENSIONS = new Set([".md", ".markdown", ".mdown", ".mkd", ".mkdn"]);
+
+function getPosts(posts) {
+  if (typeof posts?.toArray === "function") return posts.toArray();
+  if (Array.isArray(posts?.data)) return posts.data;
+  if (Array.isArray(posts)) return posts;
+  return [];
+}
+
+function hasPassword(post) {
+  return Boolean(post?.password || post?.password === 0);
+}
+
+function isMarkdownSource(post) {
+  const source = post?.source || post?.full_source;
+  if (typeof source !== "string") return false;
+  return MARKDOWN_EXTENSIONS.has(path.extname(source).toLowerCase());
+}
+
+function getHtmlRoutePath(routePath) {
+  if (typeof routePath !== "string") return null;
+  const normalized = routePath.replace(/^\/+/, "").replace(/\\/g, "/").replace(/\?.*$/, "");
+  if (!normalized || normalized.endsWith("/")) {
+    return `${normalized}index.html`;
+  }
+  return normalized;
+}
+
+function getMarkdownOutputPath(post) {
+  if (hasPassword(post) || !isMarkdownSource(post)) return null;
+
+  const htmlPath = getHtmlRoutePath(post?.path);
+  if (!htmlPath) return null;
+
+  const ext = path.posix.extname(htmlPath);
+  if (!ext) return `${htmlPath}.md`;
+  return `${htmlPath.slice(0, -ext.length)}.md`;
+}
+
+function readMarkdownFile(sourcePath) {
+  let content;
+  try {
+    content = fs.readFileSync(sourcePath);
+  } catch {
+    return null;
+  }
+
+  const hasBom = content.length >= 3 && content.subarray(0, 3).equals(UTF8_BOM);
+  return hasBom ? content : Buffer.concat([UTF8_BOM, content]);
+}
+
+module.exports = (hexo) => {
+  hexo.extend.generator.register("md_generator", (locals) =>
+    getPosts(locals.posts)
+      .map((post) => {
+        const markdownPath = getMarkdownOutputPath(post);
+        const sourcePath = post?.full_source;
+
+        if (!markdownPath || typeof sourcePath !== "string") {
+          delete post.markdown_path;
+          return null;
+        }
+
+        const data = readMarkdownFile(sourcePath);
+        if (!data) {
+          delete post.markdown_path;
+          return null;
+        }
+
+        post.markdown_path = markdownPath;
+
+        return {
+          path: markdownPath,
+          data: {
+            data: () => Readable.from(data),
+            modified: true,
+          },
+        };
+      })
+      .filter(Boolean),
+  );
+};

package/include/hexo/generator/page.js

@@ -0,0 +1,55 @@
+const { getI18nKey, getLanguage, getLanguageBasePath, getPageLanguageKey, inferI18nKeyFromSource, isI18nEnabled, localizePath, trimSlashes } = require("../../util/i18n");
+
+function getLocalizedPagePath(page, langKey, config) {
+  const sourcePrefix = `${trimSlashes(langKey)}/`;
+  let route = page.path || "";
+
+  if (route.startsWith(sourcePrefix)) {
+    route = route.slice(sourcePrefix.length);
+  }
+
+  return trimSlashes(localizePath(`/${route}`, langKey, config));
+}
+
+function decorateLocalizedPage(page, langKey, config) {
+  const language = getLanguage(config, langKey);
+
+  page.i18n_path = getLanguageBasePath(config, langKey);
+  page.i18n_lang = page.i18n_lang || langKey;
+  page.lang = language.locale;
+  page.language = language.locale;
+  page.i18n_key = page.i18n_key || getI18nKey(page) || inferI18nKeyFromSource(page.source);
+  page.path = getLocalizedPagePath(page, langKey, config);
+}
+
+module.exports = (hexo) => {
+  hexo.extend.generator.register("page", function (locals) {
+    const config = Object.assign({}, this.config, this.config.theme_config, hexo.theme.config);
+    const i18nEnabled = isI18nEnabled(config);
+
+    return locals.pages.map((page) => {
+      const { layout } = page;
+
+      if (i18nEnabled) {
+        decorateLocalizedPage(page, getPageLanguageKey(page, config), config);
+      }
+
+      if (!layout || layout === "false" || layout === "off") {
+        return {
+          path: page.path,
+          data: page.content,
+        };
+      }
+
+      const layouts = ["page", "post", "index"];
+      if (layout !== "page") layouts.unshift(layout);
+
+      page.__page = true;
+      return {
+        path: page.path,
+        layout: layouts,
+        data: page,
+      };
+    });
+  });
+};

package/include/hexo/generator/tag.js

@@ -0,0 +1,84 @@
+const pagination = require("hexo-pagination");
+const { filterByLanguage, getLanguage, getLanguageBasePath, getLanguageKeys, getLocalizedTagPath, isI18nEnabled } = require("../../util/i18n");
+
+module.exports = (hexo) => {
+  hexo.extend.generator.register("tag", function (locals) {
+    const config = this.config;
+    const fullConfig = Object.assign({}, config, config.theme_config, hexo.theme.config);
+    const themeConfig = hexo.theme.config.tag_generator || {};
+    const perPage = themeConfig.per_page ?? 10;
+    const orderBy = themeConfig.order_by ?? "-date";
+    const paginationDir = config.pagination_dir || "page";
+    const tags = locals.tags;
+    const result = [];
+
+    function generateTagPages(langKey = null) {
+      const languageData = langKey
+        ? {
+            i18n_lang: langKey,
+            lang: getLanguage(fullConfig, langKey).locale,
+          }
+        : {};
+
+      const languageTags = [];
+
+      tags.forEach((tag) => {
+        if (!tag.length) return;
+
+        const postsSource = tag.posts.sort(orderBy);
+        const posts = langKey ? filterByLanguage(postsSource, langKey, fullConfig) : postsSource;
+        if (!posts.length) return;
+
+        languageTags.push(tag);
+
+        const data = pagination(langKey ? getLocalizedTagPath(tag, langKey, fullConfig) : tag.path, posts, {
+          perPage,
+          layout: ["tag", "archive", "index"],
+          format: `${paginationDir}/%d/`,
+          data: Object.assign(
+            {
+              tag: tag.name,
+            },
+            languageData,
+          ),
+        });
+
+        result.push(...data);
+      });
+
+      const tagDir = config.tag_dir || "tags";
+      const tagDirWithSlash = tagDir.endsWith("/") ? tagDir : `${tagDir}/`;
+      const indexPath = langKey ? `${getLanguageBasePath(fullConfig, langKey) + tagDirWithSlash}` : tagDirWithSlash;
+
+      result.push({
+        path: indexPath,
+        layout: ["tags"],
+        data: Object.assign(
+          {
+            base: indexPath,
+            total: 1,
+            current: 1,
+            current_url: indexPath,
+            prev: 0,
+            prev_link: "",
+            next: 0,
+            next_link: "",
+            tags: languageTags,
+            __tags: true,
+          },
+          languageData,
+        ),
+      });
+    }
+
+    if (isI18nEnabled(fullConfig)) {
+      getLanguageKeys(fullConfig).forEach((langKey) => generateTagPages(langKey));
+      return result;
+    }
+
+    // Generate individual tag pages with pagination
+    generateTagPages();
+
+    return result;
+  });
+};

package/include/hexo/helper.js

@@ -13,6 +13,16 @@ function getCDN(cdn, pkg, version, filename) {
   }
 }
 
+const {
+  getLanguageLabel,
+  getPageLanguageKey,
+  getPageLocale,
+  getLocalizedTagPath,
+  isExternalUrl,
+  isI18nEnabled,
+  localizePath,
+} = require("../util/i18n");
+
 module.exports = (hexo) => {
   hexo.extend.helper.register("cdn", function (_package, version, filename) {
     cdn = this.config.providers?.cdn ? this.config.providers.cdn : "jsdelivr";
@@ -21,4 +31,32 @@ module.exports = (hexo) => {
   hexo.extend.helper.register("is_tags", function (page = null) {
     return (page === null ? this.page : page).__tags === true;
   });
+  hexo.extend.helper.register("is_i18n_enabled", function () {
+    return isI18nEnabled(this.config);
+  });
+  hexo.extend.helper.register("language_key", function (page = null) {
+    return getPageLanguageKey(page || this.page, this.config);
+  });
+  hexo.extend.helper.register("language_locale", function (page = null) {
+    return getPageLocale(page || this.page, this.config);
+  });
+  hexo.extend.helper.register("language_label", function (keyOrLocale) {
+    return getLanguageLabel(this.config, keyOrLocale);
+  });
+  hexo.extend.helper.register("localized_path", function (targetPath, langKey = null) {
+    return localizePath(targetPath, langKey || getPageLanguageKey(this.page, this.config), this.config);
+  });
+  hexo.extend.helper.register("localized_url_for", function (targetPath, langKey = null) {
+    const localized = localizePath(targetPath, langKey || getPageLanguageKey(this.page, this.config), this.config);
+    const urlFor = hexo.extend.helper.get("url_for").bind(this);
+    return isExternalUrl(localized) ? localized : urlFor(localized);
+  });
+  hexo.extend.helper.register("localized_tag_url", function (tag, langKey = null) {
+    const urlFor = hexo.extend.helper.get("url_for").bind(this);
+    if (!isI18nEnabled(this.config)) {
+      return urlFor(typeof tag === "string" ? tag : tag.path);
+    }
+    const route = getLocalizedTagPath(tag, langKey || getPageLanguageKey(this.page, this.config), this.config);
+    return urlFor(`/${route}`);
+  });
 };