hexo-theme-gnix 9.0.0 → 11.0.0

package/include/hexo/i18n.js

@@ -0,0 +1,183 @@
+const { extname } = require("node:path");
+const createPostProcessor = require("hexo/dist/plugins/processor/post");
+const { isHiddenFile, isMatch, isTmpFile } = require("hexo/dist/plugins/processor/common");
+const {
+  getI18nKey,
+  getLanguageBasePath,
+  getLanguage,
+  getLanguageKeys,
+  getPageLanguageKey,
+  inferI18nKeyFromSource,
+  isI18nEnabled,
+  localizePath,
+  trimSlashes,
+} = require("../util/i18n");
+
+function getConfig(hexo, locals = {}) {
+  return Object.assign({}, hexo.config, hexo.config.theme_config, hexo.theme.config, locals.theme);
+}
+
+function getLocalizedPostParams(hexo, sourcePath) {
+  const config = getConfig(hexo);
+  if (!isI18nEnabled(config) || isTmpFile(sourcePath)) return null;
+
+  const match = sourcePath.replace(/\\/g, "/").match(/^([^/]+)\/(_posts|_drafts)\/(.+)$/);
+  if (!match) return null;
+
+  const langKey = match[1];
+  if (!getLanguageKeys(config).includes(langKey)) return null;
+
+  const postPath = match[3];
+  if (isHiddenFile(postPath)) return null;
+
+  let renderable = hexo.render.isRenderable(sourcePath) && !isMatch(sourcePath, hexo.config.skip_render);
+  if (renderable && hexo.config.post_asset_folder) {
+    renderable = extname(hexo.config.new_post_name) === extname(sourcePath);
+  }
+
+  return {
+    i18n_lang: langKey,
+    path: postPath,
+    published: match[2] === "_posts",
+    renderable,
+  };
+}
+
+function getLocalizedPageParams(hexo, sourcePath) {
+  const config = getConfig(hexo);
+  if (!isI18nEnabled(config) || isTmpFile(sourcePath)) return null;
+
+  const normalized = sourcePath.replace(/\\/g, "/");
+  const match = normalized.match(/^([^/]+)\/(.+)$/);
+  if (!match) return null;
+
+  const langKey = match[1];
+  if (!getLanguageKeys(config).includes(langKey)) return null;
+
+  const pagePath = match[2];
+  if (pagePath.startsWith("_posts/") || pagePath.startsWith("_drafts/") || isHiddenFile(pagePath)) return null;
+
+  const renderable = hexo.render.isRenderable(sourcePath) && !isMatch(sourcePath, hexo.config.skip_render);
+  if (!renderable) return null;
+
+  return {
+    i18n_lang: langKey,
+  };
+}
+
+function buildPostI18nUpdate(post, langKey, config) {
+  const language = getLanguage(config, langKey);
+  const update = {
+    i18n_path: getLanguageBasePath(config, langKey),
+    i18n_lang: langKey,
+    lang: language.locale,
+    language: language.locale,
+  };
+
+  if (!post.i18n_key) {
+    update.i18n_key = getI18nKey(post) || inferI18nKeyFromSource(post.source);
+  }
+
+  return { $set: update };
+}
+
+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 buildPageI18nUpdate(page, langKey, config) {
+  const language = getLanguage(config, langKey);
+  const update = {
+    i18n_path: getLanguageBasePath(config, langKey),
+    i18n_lang: langKey,
+    lang: language.locale,
+    language: language.locale,
+    path: getLocalizedPagePath(page, langKey, config),
+  };
+
+  if (!page.i18n_key) {
+    update.i18n_key = getI18nKey(page) || inferI18nKeyFromSource(page.source);
+  }
+
+  return { $set: update };
+}
+
+module.exports = (hexo) => {
+  const defaultPostProcessor = createPostProcessor(hexo);
+
+  hexo.extend.processor.register(
+    (sourcePath) => getLocalizedPostParams(hexo, sourcePath),
+    (file) =>
+      Promise.resolve(defaultPostProcessor.process(file)).then(() => {
+        if (!isI18nEnabled(getConfig(hexo))) return null;
+        if (!file.params.renderable) return null;
+
+        const post = hexo.model("Post").findOne({ source: file.path });
+        if (!post) return null;
+
+        return post.update(buildPostI18nUpdate(post, file.params.i18n_lang, getConfig(hexo)));
+      }),
+  );
+
+  hexo.extend.processor.register(
+    (sourcePath) => getLocalizedPageParams(hexo, sourcePath),
+    (file) => {
+      if (!isI18nEnabled(getConfig(hexo))) return null;
+      if (file.type === "delete") return null;
+
+      const page = hexo.model("Page").findOne({ source: file.path });
+      if (!page) return null;
+
+      return page.update(buildPageI18nUpdate(page, file.params.i18n_lang, getConfig(hexo)));
+    },
+  );
+
+  hexo.extend.filter.register(
+    "post_permalink",
+    (post) => {
+      if (!post || typeof post !== "object") return post;
+      const activeConfig = getConfig(hexo);
+      if (!isI18nEnabled(activeConfig)) return post;
+
+      const langKey = getPageLanguageKey(post, activeConfig);
+      const language = getLanguage(activeConfig, langKey);
+
+      post.i18n_lang = post.i18n_lang || langKey;
+      post.i18n_path = getLanguageBasePath(activeConfig, langKey);
+      post.lang = language.locale;
+      post.language = language.locale;
+      post.i18n_key = post.i18n_key || getI18nKey(post) || inferI18nKeyFromSource(post.source);
+
+      return post;
+    },
+    5,
+  );
+
+  hexo.extend.filter.register(
+    "template_locals",
+    (locals) => {
+      const page = locals.page;
+      const activeConfig = getConfig(hexo, locals);
+      if (!page || !isI18nEnabled(activeConfig)) return locals;
+
+      const langKey = getPageLanguageKey(page, activeConfig);
+      const language = getLanguage(activeConfig, langKey);
+
+      page.i18n_lang = page.i18n_lang || langKey;
+      page.i18n_path = getLanguageBasePath(activeConfig, langKey);
+      page.lang = language.locale;
+      page.language = language.locale;
+      page.i18n_key = page.i18n_key || getI18nKey(page) || inferI18nKeyFromSource(page.source);
+
+      return locals;
+    },
+    5,
+  );
+};

package/include/hexo/renderer.js

@@ -1,3 +1,129 @@
+const path = require("node:path");
+const { tab } = require("@mdit/plugin-tab");
+const { createMarkdownExit } = require("markdown-exit");
+const mermaidDiagram = require("markdown-exit-mermaid");
+const ratex = require("markdown-exit-ratex");
+const code = require("markdown-exit-shiki");
+const abbr = require("markdown-it-abbr");
+const anchor = require("markdown-it-anchor");
+const footnote = require("markdown-it-footnote");
+const ins = require("markdown-it-ins");
+const mark = require("markdown-it-mark");
+const sub = require("markdown-it-sub");
+const sup = require("markdown-it-sup");
+const taskLists = require("markdown-it-task-lists");
+
+function resolveDefault(module) {
+  return module && typeof module === "object" && "default" in module ? module.default : module;
+}
+
+class MarkdownRenderer {
+  constructor(hexo) {
+    this.hexo = hexo;
+    this.config = {
+      render_options: {
+        breaks: true,
+        html: true,
+        langPrefix: "language-",
+        linkify: true,
+        quotes: "“”‘’",
+        typographer: true,
+        xhtmlOut: false,
+      },
+      code_options: {
+        themes: {
+          light: "catppuccin-latte",
+        },
+      },
+      mermaid_options: {
+        theme: "default",
+      },
+      ...(hexo.config.markdown_exit || {}),
+    };
+
+    this.md = createMarkdownExit(this.config.render_options);
+    this.initPlugins();
+  }
+
+  initPlugins() {
+    console.time("MarkdownExit: Load Default Plugins");
+    if (this.config.defaultPlugins !== false) {
+      this.md
+        .use(resolveDefault(footnote))
+        .use(resolveDefault(mark))
+        .use(resolveDefault(sub))
+        .use(resolveDefault(sup))
+        .use(resolveDefault(abbr))
+        .use(resolveDefault(ins))
+        .use(resolveDefault(taskLists))
+        .use(resolveDefault(code), this.config.code_options)
+        .use(resolveDefault(mermaidDiagram), this.config.mermaid_options)
+        .use(resolveDefault(ratex), this.config.ratex_options)
+        .use(tab)
+        .use(resolveDefault(anchor), {
+          permalink: resolveDefault(anchor).permalink.headerLink(),
+        });
+    }
+    console.timeEnd("MarkdownExit: Load Default Plugins");
+
+    console.time("MarkdownExit: Load User Plugins");
+    this.loadUserPlugins();
+    console.timeEnd("MarkdownExit: Load User Plugins");
+  }
+
+  resolvePluginFunction(plugin) {
+    if (plugin && typeof plugin.default === "function") return plugin.default;
+    if (typeof plugin === "function") return plugin;
+
+    if (plugin && typeof plugin === "object") {
+      for (const key in plugin) {
+        if (typeof plugin[key] === "function") return plugin[key];
+      }
+    }
+
+    return plugin;
+  }
+
+  loadUserPlugins() {
+    const plugins = this.config.plugins || [];
+    for (const pluginConfig of plugins) {
+      const isString = typeof pluginConfig === "string";
+      const pluginName = isString ? pluginConfig : pluginConfig.name;
+      const pluginOptions = isString ? {} : pluginConfig.options || {};
+
+      try {
+        const pluginPath = path.join(this.hexo.base_dir, "node_modules", pluginName);
+        const plugin = require(pluginPath);
+        const pluginFn = this.resolvePluginFunction(plugin);
+
+        this.md.use(pluginFn, pluginOptions);
+        if (process.env.DEBUG) {
+          console.log(`Successfully loaded plugin: ${pluginName}`);
+        }
+      } catch (error) {
+        console.warn(`Failed to load plugin: ${pluginName}`);
+        if (process.env.DEBUG) {
+          console.warn(`   Error: ${error}`);
+        }
+      }
+    }
+  }
+
+  async render(data) {
+    if (!data.text) return "";
+    return this.md.renderAsync(data.text);
+  }
+}
+
+const markdownRendererInstances = new WeakMap();
+
+function getMarkdownRenderer(hexo) {
+  if (!markdownRendererInstances.has(hexo)) {
+    markdownRendererInstances.set(hexo, new MarkdownRenderer(hexo));
+  }
+  return markdownRendererInstances.get(hexo);
+}
+
 const { transformSync } = require("esbuild");
 const { createElement } = require("inferno-create-element");
 const { renderToStaticMarkup } = require("inferno-server");
@@ -50,5 +176,10 @@ function renderer(data, locals) {
 renderer.compile = compile;
 
 module.exports = (hexo) => {
+  const markdownConfig = hexo.config.markdown_exit || {};
+  const markdownRenderer = async (data) => getMarkdownRenderer(hexo).render(data);
+  markdownRenderer.disableNunjucks = Boolean(markdownConfig.disableNunjucks);
+
+  hexo.extend.renderer.register("md", "html", markdownRenderer);
   hexo.extend.renderer.register("jsx", "html", renderer, true);
 };

package/include/util/article_font.js

@@ -0,0 +1,132 @@
+const STORAGE_KEY = "gnix-article-font";
+
+const DEFAULT_SETTINGS = Object.freeze({
+  size: "medium",
+  type: "serif",
+  lineHeight: 1.7,
+  weight: "regular",
+});
+
+const SIZE_OPTIONS = Object.freeze(["small", "medium-small", "medium", "medium-large", "large"]);
+const FONT_OPTIONS = Object.freeze(["serif", "sans-serif", "mono", "handwriting"]);
+const WEIGHT_OPTIONS = Object.freeze(["light", "regular", "medium"]);
+const LINE_HEIGHT = Object.freeze({
+  min: 1.45,
+  max: 1.9,
+});
+
+const CUSTOM_FONT_FAMILY_OPTIONS = Object.freeze({
+  serif: "--font-serif",
+  "sans-serif": "--font-sans-serif",
+  mono: "--font-mono",
+  handwriting: "--font-handwriting",
+});
+
+const CUSTOM_FONT_IMPORT_LIMIT = 6;
+
+function getClientArticleFontConfig() {
+  return {
+    storageKey: STORAGE_KEY,
+    defaultSettings: DEFAULT_SETTINGS,
+    sizeOptions: SIZE_OPTIONS,
+    fontOptions: FONT_OPTIONS,
+    weightOptions: WEIGHT_OPTIONS,
+    lineHeight: LINE_HEIGHT,
+    customFonts: {
+      familyOptions: CUSTOM_FONT_FAMILY_OPTIONS,
+      importLimit: CUSTOM_FONT_IMPORT_LIMIT,
+    },
+  };
+}
+
+function stringifyForScript(value) {
+  return JSON.stringify(value)
+    .replace(/</g, "\\u003c")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+}
+
+function getArticleFontInitScript() {
+  const config = stringifyForScript(getClientArticleFontConfig());
+
+  return `
+(function() {
+  var config = ${config};
+  var defaults = config.defaultSettings || {};
+  var stored = null;
+  var parsed = {};
+  var utils = window.__GNIX_ARTICLE_FONT_UTILS__ || {};
+
+  window.__GNIX_ARTICLE_FONT_CONFIG__ = config;
+
+  try {
+    stored = localStorage.getItem(config.storageKey);
+  } catch (_) {}
+
+  if (stored) {
+    try {
+      parsed = JSON.parse(stored) || {};
+    } catch (_) {}
+  }
+
+  function hasOption(options, value) {
+    return Array.isArray(options) && options.indexOf(value) !== -1;
+  }
+
+  function normalizeLineHeight(value) {
+    if (value === "compact") return 1.55;
+    if (value === "normal") return 1.7;
+    if (value === "relaxed") return 1.85;
+
+    var parsedValue = Number(value);
+    var min = Number(config.lineHeight && config.lineHeight.min);
+    var max = Number(config.lineHeight && config.lineHeight.max);
+    var fallback = Number(defaults.lineHeight);
+
+    if (!Number.isFinite(parsedValue)) parsedValue = Number.isFinite(fallback) ? fallback : 1.7;
+    if (!Number.isFinite(min)) min = 1.45;
+    if (!Number.isFinite(max)) max = 1.9;
+
+    return Math.min(max, Math.max(min, parsedValue));
+  }
+
+  var candidate = Object.assign({}, defaults, parsed);
+  var customFonts = utils.normalizeCustomFonts
+    ? utils.normalizeCustomFonts(
+        candidate.customFonts,
+        config.customFonts && config.customFonts.familyOptions,
+        config.customFonts && config.customFonts.importLimit
+      )
+    : { imports: [], families: {} };
+  var settings = {
+    size: hasOption(config.sizeOptions, candidate.size) ? candidate.size : defaults.size,
+    type: hasOption(config.fontOptions, candidate.type) ? candidate.type : defaults.type,
+    lineHeight: normalizeLineHeight(candidate.lineHeight),
+    weight: hasOption(config.weightOptions, candidate.weight) ? candidate.weight : defaults.weight,
+    customFonts: customFonts
+  };
+  var html = document.documentElement;
+
+  if (utils.applyCustomFontImports) utils.applyCustomFontImports(settings.customFonts.imports);
+  if (utils.applyCustomFontFamilies) utils.applyCustomFontFamilies(html, settings.customFonts.families, config.customFonts && config.customFonts.familyOptions);
+  html.setAttribute("data-article-font-size", settings.size);
+  html.setAttribute("data-article-font-family", settings.type);
+  html.setAttribute("data-article-line-height", String(settings.lineHeight));
+  html.setAttribute("data-article-font-weight", settings.weight);
+  html.style.setProperty("--article-line-height", String(settings.lineHeight));
+})();
+`;
+}
+
+module.exports = {
+  CUSTOM_FONT_FAMILY_OPTIONS,
+  CUSTOM_FONT_IMPORT_LIMIT,
+  DEFAULT_SETTINGS,
+  FONT_OPTIONS,
+  LINE_HEIGHT,
+  SIZE_OPTIONS,
+  STORAGE_KEY,
+  WEIGHT_OPTIONS,
+  getArticleFontInitScript,
+  getClientArticleFontConfig,
+};