npm - hexo-theme-gnix - Versions diffs - 9.0.0 → 10.0.0 - Mend

hexo-theme-gnix 9.0.0 → 10.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (66) hide show

package/README.md +4 -2
package/include/hexo/feed.js +5 -5
package/include/hexo/filter.js +25 -1
package/include/hexo/generator/archive.js +116 -0
package/include/hexo/generator/home.js +64 -0
package/include/hexo/generator/index.js +82 -0
package/include/hexo/generator/md_generator.js +87 -0
package/include/hexo/generator/page.js +55 -0
package/include/hexo/generator/tag.js +84 -0
package/include/hexo/helper.js +38 -0
package/include/hexo/i18n.js +183 -0
package/include/util/article_font.js +132 -0
package/include/util/i18n.js +280 -0
package/include/util/theme.js +84 -0
package/languages/en.yml +28 -0
package/languages/zh-CN.yml +28 -0
package/layout/archive.jsx +131 -127
package/layout/common/article.jsx +283 -16
package/layout/common/article_info.jsx +339 -0
package/layout/common/article_media.jsx +11 -4
package/layout/common/comment.jsx +15 -7
package/layout/common/footer.jsx +6 -5
package/layout/common/head.jsx +121 -32
package/layout/common/navbar.jsx +195 -65
package/layout/common/theme_selector.jsx +16 -14
package/layout/layout.jsx +43 -5
package/layout/misc/open_graph.jsx +162 -66
package/layout/misc/paginator.jsx +2 -8
package/layout/plugin/cookie_consent.jsx +252 -53
package/layout/plugin/swup.jsx +1 -1
package/layout/search/insight.jsx +1 -1
package/layout/tag.jsx +3 -2
package/layout/tags.jsx +81 -73
package/package.json +5 -5
package/scripts/index.js +1 -0
package/source/css/archive.css +225 -180
package/source/css/default.css +1162 -98
package/source/css/responsive.css +426 -0
package/source/css/shiki/shiki.css +12 -2081
package/source/css/tags.css +183 -0
package/source/css/twikoo.css +1049 -1045
package/source/img/favicon.svg +1 -6
package/source/img/og_image.webp +0 -0
package/source/js/article-font-utils.js +99 -0
package/source/js/busuanzi.js +91 -24
package/source/js/components/chat.js +169 -50
package/source/js/components/image-carousel.js +152 -108
package/source/js/components/sidenote.js +210 -0
package/source/js/components/text-image-section.js +78 -90
package/source/js/components/theme-stacked.js +65 -33
package/source/js/components/tree.js +30 -16
package/source/js/decrypt.js +7 -2
package/source/js/main.js +428 -5
package/source/js/swup.js +39 -0
package/source/js/theme-selector.js +26 -16
package/include/hexo/generator.js +0 -53
package/layout/misc/article_licensing.jsx +0 -99
package/source/css/responsive/desktop.css +0 -36
package/source/css/responsive/mobile.css +0 -29
package/source/css/responsive/tablet.css +0 -43
package/source/css/responsive/touch.css +0 -155
package/source/img/logo.svg +0 -9
package/source/js/archive-breadcrumb.js +0 -132
package/source/js/host/cookieconsent/3.1.1/build/cookieconsent.min.css +0 -6
package/source/js/host/cookieconsent/3.1.1/build/cookieconsent.min.js +0 -1
package/source/js/swup.bundle.js +0 -1

package/source/js/main.js CHANGED Viewed

@@ -17,6 +17,7 @@ function tableWrapFix() {
 function twikoo_handler() {
   const el = document.getElementById("tko");
   if (!el) return;
+  if (el.dataset.initialized === "true" || el.dataset.initializing === "true") return;
   const { envId, region, lang, jsUrl, cssUrl } = el.dataset;
@@ -26,10 +27,20 @@ function twikoo_handler() {
   if (typeof window.twikoo?.init === "function") {
     window.twikoo.init(config);
+    el.dataset.initialized = "true";
     return;
   }
-  loadScriptOnce(jsUrl, () => window.twikoo.init(config));
+  el.dataset.initializing = "true";
+  loadScriptOnce(jsUrl, () => {
+    if (el.dataset.initialized === "true") {
+      delete el.dataset.initializing;
+      return;
+    }
+    window.twikoo.init(config);
+    el.dataset.initialized = "true";
+    delete el.dataset.initializing;
+  });
 }
 // #region mdit@tab-plugin
 /**
@@ -288,25 +299,435 @@ function handleMermaid() {
 // #endregion
+const articleFontConfig = window.__GNIX_ARTICLE_FONT_CONFIG__ || {};
+const ARTICLE_FONT_STORAGE_KEY = articleFontConfig.storageKey || "gnix-article-font";
+const ARTICLE_FONT_DEFAULT_SETTINGS = articleFontConfig.defaultSettings || { size: "medium", type: "serif", lineHeight: 1.7, weight: "regular" };
+const ARTICLE_SIZE_OPTIONS = new Set(articleFontConfig.sizeOptions || ["small", "medium-small", "medium", "medium-large", "large"]);
+const ARTICLE_FONT_OPTIONS = new Set(articleFontConfig.fontOptions || ["serif", "sans-serif", "mono", "handwriting"]);
+const ARTICLE_WEIGHT_OPTIONS = new Set(articleFontConfig.weightOptions || ["light", "regular", "medium"]);
+const ARTICLE_LINE_HEIGHT_MIN = articleFontConfig.lineHeight?.min ?? 1.45;
+const ARTICLE_LINE_HEIGHT_MAX = articleFontConfig.lineHeight?.max ?? 1.9;
+const ARTICLE_CUSTOM_FONT_OPTIONS = articleFontConfig.customFonts?.familyOptions || {
+  serif: "--font-serif",
+  "sans-serif": "--font-sans-serif",
+  mono: "--font-mono",
+  handwriting: "--font-handwriting",
+};
+const ARTICLE_CUSTOM_FONT_IMPORT_LIMIT = articleFontConfig.customFonts?.importLimit ?? 6;
+const ARTICLE_CUSTOM_FONT_LINK_SELECTOR = 'link[data-gnix-custom-font="true"]';
+function getCssVariableValue(name, fallback = "") {
+  if (typeof document === "undefined") return fallback;
+  const value = window.getComputedStyle(document.documentElement).getPropertyValue(name).trim();
+  return value || fallback;
+}
+// Reads `--font-*` from default.css. Custom fonts are applied as inline
+// styles on <html>, which would override the stylesheet value; we strip
+// those overrides while reading and restore them after.
+function getDefaultCustomFontFamilies() {
+  if (typeof document === "undefined") return {};
+  const html = document.documentElement;
+  const saved = {};
+  Object.values(ARTICLE_CUSTOM_FONT_OPTIONS).forEach((cssVar) => {
+    const inline = html.style.getPropertyValue(cssVar);
+    if (inline) {
+      saved[cssVar] = inline;
+      html.style.removeProperty(cssVar);
+    }
+  });
+  const defaults = {
+    serif: getCssVariableValue(ARTICLE_CUSTOM_FONT_OPTIONS.serif),
+    "sans-serif": getCssVariableValue(ARTICLE_CUSTOM_FONT_OPTIONS["sans-serif"]),
+    mono: getCssVariableValue(ARTICLE_CUSTOM_FONT_OPTIONS.mono),
+    handwriting: getCssVariableValue(ARTICLE_CUSTOM_FONT_OPTIONS.handwriting),
+  };
+  Object.keys(saved).forEach((cssVar) => {
+    html.style.setProperty(cssVar, saved[cssVar]);
+  });
+  return defaults;
+}
+const ARTICLE_FONT_UTILS = window.__GNIX_ARTICLE_FONT_UTILS__ || {};
+function normalizeCustomFonts(value = {}) {
+  const normalized = ARTICLE_FONT_UTILS.normalizeCustomFonts
+    ? ARTICLE_FONT_UTILS.normalizeCustomFonts(value, ARTICLE_CUSTOM_FONT_OPTIONS, ARTICLE_CUSTOM_FONT_IMPORT_LIMIT)
+    : { imports: [], families: {} };
+  const defaultFamilies = getDefaultCustomFontFamilies();
+  Object.keys(ARTICLE_CUSTOM_FONT_OPTIONS).forEach((key) => {
+    if (!normalized.families[key]) {
+      normalized.families[key] = defaultFamilies[key] || "";
+    }
+  });
+  return normalized;
+}
+function applyCustomFonts(customFonts = {}) {
+  const normalized = normalizeCustomFonts(customFonts);
+  if (ARTICLE_FONT_UTILS.applyCustomFontImports) {
+    ARTICLE_FONT_UTILS.applyCustomFontImports(normalized.imports, ARTICLE_CUSTOM_FONT_LINK_SELECTOR);
+  }
+  if (ARTICLE_FONT_UTILS.applyCustomFontFamilies) {
+    ARTICLE_FONT_UTILS.applyCustomFontFamilies(document.documentElement, normalized.families, ARTICLE_CUSTOM_FONT_OPTIONS);
+  }
+  return normalized;
+}
+function initHoverPopover(trigger, popover) {
+  if (!trigger || !popover || typeof popover.showPopover !== "function" || typeof popover.hidePopover !== "function") {
+    return;
+  }
+  let hideTimer = null;
+  function clearHideTimer() {
+    if (hideTimer) {
+      clearTimeout(hideTimer);
+      hideTimer = null;
+    }
+  }
+  function openPopover() {
+    clearHideTimer();
+    if (!popover.matches(":popover-open")) {
+      popover.showPopover();
+    }
+    const rect = trigger.getBoundingClientRect();
+    const popoverWidth = popover.offsetWidth || 0;
+    const left = Math.min(Math.max(16, rect.left), Math.max(16, window.innerWidth - popoverWidth - 16));
+    popover.style.left = `${left}px`;
+    popover.style.top = `${rect.bottom + 8}px`;
+  }
+  function scheduleClose() {
+    clearHideTimer();
+    hideTimer = window.setTimeout(() => {
+      const hasPointer = trigger.matches(":hover") || popover.matches(":hover");
+      const hasFocus = trigger.matches(":focus-visible") || popover.contains(document.activeElement);
+      if (!hasPointer && !hasFocus && popover.matches(":popover-open")) {
+        popover.hidePopover();
+      }
+    }, 80);
+  }
+  trigger.addEventListener("pointerenter", openPopover);
+  trigger.addEventListener("focus", openPopover);
+  trigger.addEventListener("pointerleave", scheduleClose);
+  trigger.addEventListener("blur", scheduleClose);
+  trigger.addEventListener("click", openPopover);
+  popover.addEventListener("pointerenter", openPopover);
+  popover.addEventListener("pointerleave", scheduleClose);
+  popover.addEventListener("focusin", openPopover);
+  popover.addEventListener("focusout", scheduleClose);
+  popover.addEventListener("toggle", (event) => {
+    if (event.newState === "closed") clearHideTimer();
+  });
+}
+function normalizeArticleLineHeight(value) {
+  if (value === "compact") return 1.55;
+  if (value === "normal") return 1.7;
+  if (value === "relaxed") return 1.85;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return ARTICLE_FONT_DEFAULT_SETTINGS.lineHeight;
+  return Math.min(ARTICLE_LINE_HEIGHT_MAX, Math.max(ARTICLE_LINE_HEIGHT_MIN, parsed));
+}
+function normalizeArticleFontSettings(value = {}) {
+  const candidate = value || {};
+  return {
+    size: ARTICLE_SIZE_OPTIONS.has(candidate.size) ? candidate.size : ARTICLE_FONT_DEFAULT_SETTINGS.size,
+    type: ARTICLE_FONT_OPTIONS.has(candidate.type) ? candidate.type : ARTICLE_FONT_DEFAULT_SETTINGS.type,
+    lineHeight: normalizeArticleLineHeight(candidate.lineHeight),
+    weight: ARTICLE_WEIGHT_OPTIONS.has(candidate.weight) ? candidate.weight : ARTICLE_FONT_DEFAULT_SETTINGS.weight,
+    customFonts: normalizeCustomFonts(candidate.customFonts),
+  };
+}
+function getArticleFontSettings() {
+  let settings = { ...ARTICLE_FONT_DEFAULT_SETTINGS };
+  try {
+    const stored = localStorage.getItem(ARTICLE_FONT_STORAGE_KEY);
+    if (stored) settings = normalizeArticleFontSettings({ ...ARTICLE_FONT_DEFAULT_SETTINGS, ...JSON.parse(stored) });
+  } catch {
+    settings = { ...ARTICLE_FONT_DEFAULT_SETTINGS };
+  }
+  return settings;
+}
+function applyArticleFontSettings(settings = getArticleFontSettings()) {
+  const normalized = normalizeArticleFontSettings(settings);
+  const html = document.documentElement;
+  applyCustomFonts(normalized.customFonts);
+  html.dataset.articleFontSize = normalized.size;
+  html.dataset.articleFontFamily = normalized.type;
+  html.dataset.articleLineHeight = String(normalized.lineHeight);
+  html.dataset.articleFontWeight = normalized.weight;
+  html.style.setProperty("--article-line-height", String(normalized.lineHeight));
+}
+function saveArticleFontSettings(settings) {
+  try {
+    localStorage.setItem(ARTICLE_FONT_STORAGE_KEY, JSON.stringify(normalizeArticleFontSettings(settings)));
+  } catch {
+    // Keep the current page responsive even when storage is unavailable.
+  }
+}
+function initArticleSettings() {
+  const settings = getArticleFontSettings();
+  applyArticleFontSettings(settings);
+  const fontSettingsPopover = document.getElementById("article-font-settings");
+  if (!fontSettingsPopover) return;
+  function updateButtonStates(selector, isActive) {
+    fontSettingsPopover.querySelectorAll(selector).forEach((btn) => {
+      const active = isActive(btn);
+      btn.classList.toggle("is-active", active);
+      btn.setAttribute("aria-pressed", String(active));
+    });
+  }
+  const lineHeightSlider = fontSettingsPopover.querySelector(".font-line-height-slider");
+  const lineHeightValue = fontSettingsPopover.querySelector(".font-line-height-value");
+  const customFontForm = fontSettingsPopover.querySelector(".font-custom-form");
+  const customFontImportInput = fontSettingsPopover.querySelector(".font-custom-imports");
+  const customFontResetButton = fontSettingsPopover.querySelector(".font-custom-reset");
+  const customFontFamilyInputs = fontSettingsPopover.querySelectorAll(".font-custom-family-input");
+  const customFontHelpButton = fontSettingsPopover.querySelector(".font-custom-help-btn");
+  const customFontHelpPopover = document.getElementById("font-custom-help-popover");
+  const customFontToggleButton = fontSettingsPopover.querySelector(".font-custom-toggle");
+  const customFontPanel = fontSettingsPopover.querySelector(".font-custom-panel");
+  initHoverPopover(customFontHelpButton, customFontHelpPopover);
+  if (customFontToggleButton && customFontPanel) {
+    const syncCustomFontPanelState = (expanded) => {
+      customFontToggleButton.setAttribute("aria-expanded", String(expanded));
+      customFontPanel.dataset.expanded = String(expanded);
+      customFontPanel.setAttribute("aria-hidden", String(!expanded));
+    };
+    syncCustomFontPanelState(false);
+    customFontToggleButton.addEventListener("click", () => {
+      const expanded = customFontToggleButton.getAttribute("aria-expanded") === "true";
+      syncCustomFontPanelState(!expanded);
+    });
+  }
+  function updateLineHeightUI() {
+    if (lineHeightSlider) {
+      lineHeightSlider.value = String(settings.lineHeight);
+    }
+    if (lineHeightValue) {
+      lineHeightValue.textContent = settings.lineHeight.toFixed(2);
+    }
+  }
+  function updateActiveStates() {
+    updateButtonStates(".font-size-btn", (btn) => btn.dataset.size === settings.size);
+    updateButtonStates(".font-type-btn", (btn) => btn.dataset.font === settings.type);
+    updateButtonStates(".font-weight-btn", (btn) => btn.dataset.weight === settings.weight);
+    updateLineHeightUI();
+  }
+  function updateCustomFontUI() {
+    const customFonts = normalizeCustomFonts(settings.customFonts);
+    if (customFontImportInput) {
+      customFontImportInput.value = customFonts.imports.join("\n");
+    }
+    customFontFamilyInputs.forEach((input) => {
+      input.value = customFonts.families[input.dataset.fontFamily] || "";
+    });
+  }
+  function readCustomFontsFromUI() {
+    const families = {};
+    customFontFamilyInputs.forEach((input) => {
+      families[input.dataset.fontFamily] = input.value;
+    });
+    return normalizeCustomFonts({
+      imports: customFontImportInput?.value || "",
+      families,
+    });
+  }
+  fontSettingsPopover.querySelectorAll(".font-size-btn").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      if (!ARTICLE_SIZE_OPTIONS.has(btn.dataset.size)) return;
+      settings.size = btn.dataset.size;
+      saveArticleFontSettings(settings);
+      updateActiveStates();
+      applyArticleFontSettings(settings);
+    });
+  });
+  fontSettingsPopover.querySelectorAll(".font-type-btn").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      if (!ARTICLE_FONT_OPTIONS.has(btn.dataset.font)) return;
+      settings.type = btn.dataset.font;
+      saveArticleFontSettings(settings);
+      updateActiveStates();
+      applyArticleFontSettings(settings);
+    });
+  });
+  if (lineHeightSlider) {
+    lineHeightSlider.min = String(ARTICLE_LINE_HEIGHT_MIN);
+    lineHeightSlider.max = String(ARTICLE_LINE_HEIGHT_MAX);
+    lineHeightSlider.step = "0.05";
+    lineHeightSlider.addEventListener("input", () => {
+      settings.lineHeight = normalizeArticleLineHeight(lineHeightSlider.value);
+      saveArticleFontSettings(settings);
+      updateActiveStates();
+      applyArticleFontSettings(settings);
+    });
+  }
+  fontSettingsPopover.querySelectorAll(".font-weight-btn").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      if (!ARTICLE_WEIGHT_OPTIONS.has(btn.dataset.weight)) return;
+      settings.weight = btn.dataset.weight;
+      saveArticleFontSettings(settings);
+      updateActiveStates();
+      applyArticleFontSettings(settings);
+    });
+  });
+  if (customFontForm) {
+    customFontForm.addEventListener("submit", (event) => {
+      event.preventDefault();
+      settings.customFonts = readCustomFontsFromUI();
+      saveArticleFontSettings(settings);
+      applyArticleFontSettings(settings);
+      updateCustomFontUI();
+    });
+  }
+  if (customFontResetButton) {
+    customFontResetButton.addEventListener("click", () => {
+      settings.customFonts = normalizeCustomFonts();
+      saveArticleFontSettings(settings);
+      applyArticleFontSettings(settings);
+      const defaults = getDefaultCustomFontFamilies();
+      if (customFontImportInput) {
+        customFontImportInput.value = "";
+      }
+      customFontFamilyInputs.forEach((input) => {
+        const key = input.dataset.fontFamily;
+        input.value = defaults[key] || "";
+      });
+    });
+  }
+  updateActiveStates();
+  updateCustomFontUI();
+}
+function initArticleCommentPopover() {
+  const commentPopover = document.getElementById("article-comment-popover");
+  if (!commentPopover) {
+    twikoo_handler();
+    return;
+  }
+  // Preload twikoo JS during idle time so comments render faster on click
+  const tko = document.getElementById("tko");
+  if (tko && tko.dataset.jsUrl) {
+    const preload = () => loadScriptOnce(tko.dataset.jsUrl, () => {});
+    if (typeof requestIdleCallback === "function") {
+      requestIdleCallback(preload, { timeout: 3000 });
+    } else {
+      setTimeout(preload, 200);
+    }
+  }
+  const initializeComments = () => twikoo_handler();
+  if (commentPopover.matches(":popover-open")) {
+    initializeComments();
+  }
+  if (commentPopover.dataset.bound === "true") return;
+  commentPopover.dataset.bound = "true";
+  commentPopover.addEventListener("toggle", (event) => {
+    if (event.newState === "open") initializeComments();
+  });
+}
+function getComparablePath(url) {
+  const path = new URL(url, window.location.href).pathname.replace(/\/index\.html$/, "/").replace(/\/+$/, "");
+  return path || "/";
+}
+function updateNavbarCurrentPage() {
+  const currentPath = getComparablePath(window.location.href);
+  document.querySelectorAll(".navbar-start .navbar-item").forEach((item) => {
+    const itemPath = getComparablePath(item.href);
+    const active = itemPath === currentPath || (itemPath !== "/" && currentPath.startsWith(`${itemPath}/`));
+    item.classList.toggle("is-active", active);
+    if (active) {
+      item.setAttribute("aria-current", "page");
+    } else {
+      item.removeAttribute("aria-current");
+    }
+  });
+}
+function refreshNavbarIcons() {
+  document.querySelectorAll(".navbar-end iconify-icon").forEach((el) => {
+    if (!el.getAttribute("icon")) return;
+    if (el.shadowRoot?.querySelector("svg")) return;
+    const parent = el.parentNode;
+    if (!parent) return;
+    const next = el.nextSibling;
+    parent.removeChild(el);
+    parent.insertBefore(el, next);
+  });
+}
 function initPage() {
   tableWrapFix();
   initializeTabs();
   handleMermaid();
   addHighlightTool();
+  initArticleSettings();
   const zoomOpts = { background: "hsla(from var(--mantle) / 0.9)" };
   const zoomImgs = new Set();
   document.querySelectorAll(".content img").forEach((img) => zoomImgs.add(img));
   mediumZoom([...zoomImgs], zoomOpts);
-  twikoo_handler();
+  initArticleCommentPopover();
+  updateNavbarCurrentPage();
+  refreshNavbarIcons();
 }
 document.addEventListener("DOMContentLoaded", initPage, { once: true });
-// Re-initialize on page changes when using swup
-if (typeof swup !== "undefined") {
-  swup.hooks.on("page:view", initPage);
+function bindSwupPageHook(swupInstance) {
+  if (!swupInstance || swupInstance.gnixMainPageHookBound) return;
+  swupInstance.gnixMainPageHookBound = true;
+  swupInstance.hooks.on("page:view", initPage);
 }
+bindSwupPageHook(window.swup);
+document.addEventListener("gnix:swup-ready", (event) => bindSwupPageHook(event.detail?.swup), { once: true });
 document.addEventListener("keydown", handleKeyDown, {
   capture: true, // 捕获阶段监听，优先于浏览器默认处理
   passive: false, // 允许调用 preventDefault
@@ -326,3 +747,5 @@ function toggleNav(event) {
     menu.classList.remove("is-active");
   }
 }
+window.toggleNav = toggleNav;

package/source/js/swup.js ADDED Viewed

@@ -0,0 +1,39 @@
+import SwupHeadPlugin from "https://unpkg.com/@swup/head-plugin@2?module";
+import SwupScriptsPlugin from "https://unpkg.com/@swup/scripts-plugin@2?module";
+import Swup from "https://unpkg.com/swup@4?module";
+const swup = new Swup({
+  containers: ["#swup"],
+  cache: true,
+  native: false,
+  animationSelector: false,
+  plugins: [
+    new SwupHeadPlugin({
+      persistTags: true,
+    }),
+    new SwupScriptsPlugin({
+      optin: true,
+    }),
+  ],
+});
+document.addEventListener(
+  "click",
+  (event) => {
+    if (!swup.navigating || event.defaultPrevented) return;
+    if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+    const link = event.target instanceof Element ? event.target.closest("a[href]") : null;
+    if (!link || link.matches('[download], [target="_blank"]')) return;
+    const url = new URL(link.href, window.location.href);
+    if (url.origin !== window.location.origin) return;
+    event.preventDefault();
+    event.stopImmediatePropagation();
+  },
+  { capture: true },
+);
+window.swup = swup;
+document.dispatchEvent(new CustomEvent("gnix:swup-ready", { detail: { swup } }));

package/source/js/theme-selector.js CHANGED Viewed

@@ -1,15 +1,14 @@
 ((window, document, localStorage) => {
-  const STORAGE_KEY = "themePreference";
-  const colorSchemeMediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+  const themeConfig = window.__GNIX_THEME_CONFIG__;
-  const THEME_MAP = {
-    mocha: "night",
-    rose_pine: "night",
-    nord: "light",
-    nord_night: "night",
-    tokyo_night: "night",
-    latte: "light",
-  };
+  if (!themeConfig) return;
+  const STORAGE_KEY = themeConfig.storageKey;
+  const DEFAULT_THEME = themeConfig.defaultTheme;
+  const SYSTEM_THEME = themeConfig.systemTheme;
+  const THEME_MAP = themeConfig.themeClassMap || {};
+  const THEME_CLASSES = [...new Set(Object.values(THEME_MAP))];
+  const colorSchemeMediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
   let currentIndex = 0;
   let previewTheme = null;
@@ -19,18 +18,28 @@
   let previousFocus = null;
   let popoverEl = null;
+  function isValidTheme(theme) {
+    return theme === DEFAULT_THEME || Object.hasOwn(THEME_MAP, theme);
+  }
+  function resolveTheme(theme) {
+    return theme === DEFAULT_THEME ? (colorSchemeMediaQuery.matches ? SYSTEM_THEME.dark : SYSTEM_THEME.light) : theme;
+  }
   function getThemePreference() {
     const stored = localStorage.getItem(STORAGE_KEY);
-    return stored && stored in THEME_MAP ? stored : "system";
+    return isValidTheme(stored) ? stored : DEFAULT_THEME;
   }
   function applyTheme(theme, persist = false) {
-    const resolved = theme === "system" ? (colorSchemeMediaQuery.matches ? "mocha" : "nord") : theme;
+    const preference = isValidTheme(theme) ? theme : DEFAULT_THEME;
+    const resolved = resolveTheme(preference);
+    const themeClass = THEME_MAP[resolved];
     const html = document.documentElement;
     html.setAttribute("data-theme", resolved);
-    html.classList.remove("night", "light");
-    html.classList.add(THEME_MAP[resolved]);
-    if (persist) localStorage.setItem(STORAGE_KEY, theme);
+    html.classList.remove(...THEME_CLASSES);
+    if (themeClass) html.classList.add(themeClass);
+    if (persist) localStorage.setItem(STORAGE_KEY, preference);
   }
   function updateFocus() {
@@ -54,6 +63,7 @@
     originalTheme = getThemePreference();
     previewTheme = null;
     shouldApply = false;
+    currentIndex = 0;
     themeOptions = el.querySelectorAll(".theme-option");
     themeOptions.forEach((option, index) => {
@@ -143,7 +153,7 @@
   }
   colorSchemeMediaQuery.addEventListener("change", () => {
-    if (getThemePreference() === "system") applyTheme("system", true);
+    if (getThemePreference() === DEFAULT_THEME) applyTheme(DEFAULT_THEME, true);
   });
   window.selectThemeOption = (index) => {

package/include/hexo/generator.js DELETED Viewed

@@ -1,53 +0,0 @@
-const util = require("hexo-util");
-module.exports = (hexo) => {
-  hexo.extend.generator.register("insight", function (locals) {
-    const url_for = hexo.extend.helper.get("url_for").bind(this);
-    function minify(str) {
-      return util
-        .stripHTML(str)
-        .trim()
-        .replace(/\n/g, " ")
-        .replace(/\s+/g, " ")
-        .replace(/&#x([\da-fA-F]+);/g, (_, hex) => {
-          return String.fromCharCode(parseInt(hex, 16));
-        })
-        .replace(/&#([\d]+);/g, (_, dec) => {
-          return String.fromCharCode(dec);
-        });
-    }
-    function mapPost(post) {
-      return {
-        title: util.escapeHTML(post.title).trim(),
-        text: post.password ? "该文章需要密码" : minify(post.content),
-        link: url_for(post.path),
-      };
-    }
-    function mapTag(tag) {
-      return {
-        name: util.escapeHTML(tag.name).trim(),
-        slug: minify(tag.slug),
-        link: url_for(tag.path),
-      };
-    }
-    const site = {
-      posts: locals.posts.map(mapPost),
-      tags: locals.tags.map(mapTag),
-    };
-    return {
-      path: "/content.json",
-      data: JSON.stringify(site),
-    };
-  });
-  // Generate "<root>/tags/" page
-  hexo.extend.generator.register("tags", (locals) => {
-    return {
-      path: "tags/",
-      layout: ["tags"],
-      data: Object.assign({}, locals, {
-        __tags: true,
-      }),
-    };
-  });
-};