hexo-theme-redefine-x 2.8.5

package/scripts/helpers/recommendation-helpers.js

@@ -0,0 +1,367 @@
+/*
+ * Optimized by: EvanNotFound
+ */
+
+const articleLibrary = [];
+const corpus = [];
+let flag = null;
+
+hexo.extend.filter.register("template_locals", function (localVariables) {
+  const cfg = hexo.theme.config.articles.recommendation;
+  if (!cfg.enable) {
+    return localVariables;
+  }
+  if (!flag) {
+    flag = 1;
+    fetchData(localVariables.site.posts, cfg);
+    fetchData(localVariables.site.pages, cfg);
+    articleRecommendation(cfg);
+  }
+  return localVariables;
+});
+
+function fetchData(s, cfg) {
+  s.each(function (p) {
+    if (["post", "docs"].includes(p.layout)) {
+      articleLibrary.push({
+        path: p.path,
+        title: p.title || p.seo_title || p.short_title,
+        headimg: p.thumbnail || p.banner || p.cover || cfg.placeholder,
+      });
+      corpus.push(tokenize(p.raw));
+    }
+  });
+}
+
+function cleanData(data) {
+  const symbolLists = [
+    ",",
+    ".",
+    "?",
+    "!",
+    ":",
+    ";",
+    "、",
+    "……",
+    "~",
+    "&",
+    "@",
+    "#",
+    "，",
+    "。",
+    "？",
+    "！",
+    "：",
+    "；",
+    "·",
+    "…",
+    "～",
+    "＆",
+    "＠",
+    "＃",
+    "“",
+    "”",
+    "‘",
+    "’",
+    "〝",
+    "〞",
+    '"',
+    "'",
+    "＂",
+    "＇",
+    "´",
+    "＇",
+    "(",
+    ")",
+    "【",
+    "】",
+    "《",
+    "》",
+    "＜",
+    "＞",
+    "﹝",
+    "﹞",
+    "<",
+    ">",
+    "(",
+    ")",
+    "[",
+    "]",
+    "«",
+    "»",
+    "‹",
+    "›",
+    "〔",
+    "〕",
+    "〈",
+    "〉",
+    "{",
+    "}",
+    "［",
+    "］",
+    "「",
+    "」",
+    "｛",
+    "｝",
+    "〖",
+    "〗",
+    "『",
+    "』",
+    "︵",
+    "︷",
+    "︹",
+    "︿",
+    "︽",
+    "﹁",
+    "﹃",
+    "︻",
+    "︗",
+    "/",
+    "|",
+    "\\",
+    "︶",
+    "︸",
+    "︺",
+    "﹀",
+    "︾",
+    "﹂",
+    "﹄",
+    "﹄",
+    "︼",
+    "︘",
+    "／",
+    "｜",
+    "＼",
+    "_",
+    "¯",
+    "＿",
+    "￣",
+    "﹏",
+    "﹋",
+    "﹍",
+    "﹉",
+    "﹎",
+    "﹊",
+    "`",
+    "ˋ",
+    "¦",
+    "︴",
+    "¡",
+    "¿",
+    "^",
+    "ˇ",
+    "­",
+    "¨",
+    "ˊ",
+    " ",
+    "　",
+    "%",
+    "*",
+    "-",
+    "+",
+    "=",
+    "￥",
+    "$",
+    "（",
+    "）",
+  ];
+  data = data.replace(/\s/g, " ");
+  data = data.replace(/\!\[(.*?)\]\(.*?\)/g, (_a, b) => {
+    return b;
+  });
+  data = data.replace(
+    /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&amp;:/~\+#]*[\w\-\@?^=%&amp;/~\+#])?/g,
+    " ",
+  );
+  for (const symbol of symbolLists) {
+    data = data.replace(new RegExp("\\" + symbol, "g"), " ");
+  }
+  data = data.replace(/\d+/g, " ");
+  data = data.replace(/\s/g, " ");
+  return data;
+}
+
+const Jieba = require("@node-rs/jieba").Jieba;
+const jiebaInstance = new Jieba();
+function tokenize(data) {
+  const cleaned = cleanData(data);
+  const words = jiebaInstance.cut(cleaned, true);
+  return words.filter((word) => word && word !== " " && !/^[0-9]*$/.test(word));
+}
+
+function cosineSimilarity(vector1, vector2) {
+  let numerator = 0;
+  let sqrt1 = 0;
+  let sqrt2 = 0;
+  if (vector1.length == vector2.length) {
+    for (let i = 0; i < vector1.length; i++) {
+      numerator += vector1[i] * vector2[i];
+      sqrt1 += vector1[i] * vector1[i];
+      sqrt2 += vector2[i] * vector2[i];
+    }
+    return numerator / (Math.sqrt(sqrt1) * Math.sqrt(sqrt2));
+  }
+}
+
+function createWordLibrary(allWords) {
+  const wordLibrary = {};
+  allWords.forEach((word) => {
+    wordLibrary[word] = 0;
+  });
+  return wordLibrary;
+}
+
+function calculateWordFrequency(wordLibrary, wordsInArticle) {
+  const wordOccurrenceLibrary = wordsInArticle.reduce(
+    (wordCountObj, wordName) => {
+      if (wordName in wordCountObj) {
+        wordCountObj[wordName]++;
+      }
+      return wordCountObj;
+    },
+    JSON.parse(JSON.stringify(wordLibrary)),
+  );
+
+  const wordFrequency = JSON.parse(JSON.stringify(wordLibrary));
+  for (const word of Object.keys(wordLibrary)) {
+    wordFrequency[word] = wordOccurrenceLibrary[word] / wordsInArticle.length;
+  }
+  return wordFrequency;
+}
+
+function articleRecommendation(cfg) {
+  const dataSet = {};
+  const similaritySet = {};
+  const recommendationSet = {};
+  let allWordsInAllArticles = [];
+
+  for (const wordList of corpus) {
+    allWordsInAllArticles = [
+      ...new Set(allWordsInAllArticles.concat(wordList)),
+    ];
+  }
+
+  const wordLibrary = createWordLibrary(allWordsInAllArticles);
+  const documentCountLibrary = JSON.parse(JSON.stringify(wordLibrary));
+
+  for (let i = 0; i < corpus.length; i++) {
+    const articlePath = articleLibrary[i].path;
+    const wordsInArticle = corpus[i];
+
+    const wordFrequency = calculateWordFrequency(wordLibrary, wordsInArticle);
+    dataSet[articlePath] = { wordFrequency };
+
+    for (const word of Object.keys(wordLibrary)) {
+      if (wordFrequency[word]) {
+        documentCountLibrary[word]++;
+      }
+    }
+  }
+
+  for (let i = 0; i < corpus.length; i++) {
+    const articlePath = articleLibrary[i].path;
+    dataSet[articlePath]["inverseDocumentFrequency"] = JSON.parse(
+      JSON.stringify(wordLibrary),
+    );
+    dataSet[articlePath]["wordFrequency-inverseDocumentFrequency"] = JSON.parse(
+      JSON.stringify(wordLibrary),
+    );
+    dataSet[articlePath]["wordFrequencyVector"] = [];
+    for (const word of Object.keys(wordLibrary)) {
+      const inverseDocumentFrequency = Math.log(
+        corpus.length / (documentCountLibrary[word] + 1),
+      );
+      const wordFrequencyInverseDocumentFrequency =
+        dataSet[articlePath]["wordFrequency"][word] * inverseDocumentFrequency;
+      dataSet[articlePath]["wordFrequencyVector"].push(
+        wordFrequencyInverseDocumentFrequency,
+      );
+    }
+  }
+
+  for (let i = 0; i < corpus.length; i++) {
+    const articlePath1 = articleLibrary[i].path;
+    similaritySet[articlePath1] = {};
+    for (let j = 0; j < corpus.length; j++) {
+      const articlePath2 = articleLibrary[j].path;
+      similaritySet[articlePath1][articlePath2] = cosineSimilarity(
+        dataSet[articlePath1]["wordFrequencyVector"],
+        dataSet[articlePath2]["wordFrequencyVector"],
+      );
+    }
+    for (let j = 0; j < corpus.length; j++) {
+      recommendationSet[articlePath1] = Object.keys(
+        similaritySet[articlePath1],
+      ).sort(function (a, b) {
+        return similaritySet[articlePath1][b] - similaritySet[articlePath1][a]; // Descending order
+      });
+    }
+    const index = recommendationSet[articlePath1].indexOf(articlePath1);
+    if (index > -1) {
+      recommendationSet[articlePath1].splice(index, 1);
+    }
+    recommendationSet[articlePath1] = recommendationSet[articlePath1].slice(
+      0,
+      cfg.limit,
+    );
+    for (let j = 0; j < recommendationSet[articlePath1].length; j++) {
+      const e = recommendationSet[articlePath1][j];
+      recommendationSet[articlePath1][j] = articleLibrary.filter(
+        (w) => w.path == e,
+      )[0];
+    }
+  }
+  hexo.locals.set("recommendationSet", function () {
+    return recommendationSet;
+  });
+}
+
+hexo.extend.helper.register("articleRecommendationGenerator", function (post) {
+  if (!post) return "";
+  const cfg = hexo.theme.config.articles.recommendation;
+  if (!cfg.enable) {
+    return "";
+  }
+  for (const dir of cfg.skip_dirs) {
+    if (new RegExp("^" + dir, "g").test(post.path)) {
+      return "";
+    }
+  }
+  const recommendationSet = hexo.locals.get("recommendationSet");
+  const recommendedArticles = recommendationSet[post.path];
+  return userInterface(recommendedArticles, cfg);
+});
+
+function userInterface(recommendedArticles, cfg) {
+  let html = "";
+  let htmlMobile = "";
+  for (const item of recommendedArticles) {
+    html += itemInterface(item);
+  }
+  for (const itemMobile of recommendedArticles.slice(0, cfg.mobile_limit)) {
+    htmlMobile += itemInterface(itemMobile);
+  }
+  return `
+  <div class="recommended-article px-2 sm:px-6 md:px-8">
+   <div class="recommended-desktop">
+    <div class="recommended-article-header text-xl md:text-3xl font-bold mt-10">
+     <i aria-hidden="true"></i><span>${cfg.title}</span>
+    </div>
+    <div class="recommended-article-group">${html}</div>
+   </div>
+   <div class="recommended-mobile">
+   <div class="recommended-article-header text-xl md:text-3xl font-bold mt-10">
+     <i aria-hidden="true"></i><span>${cfg.title}</span>
+   </div>
+   <div class="recommended-article-group">${htmlMobile}</div>
+   </div>
+  </div>`;
+}
+
+function itemInterface(item) {
+  const url = hexo.extend.helper.get('url_for').call(hexo, item.path);
+  return `<a class="recommended-article-item" href="${url}" title="${item.title}" rel="bookmark">
+  <img src="/${item.headimg}" alt="${item.title}" class="!max-w-none">
+  <span class="title">${item.title}</span>
+</a>`;
+}

package/scripts/helpers/theme-helpers.js

@@ -0,0 +1,251 @@
+/* main hexo */
+
+"use strict";
+
+const url = require("url");
+const { version } = require("../../package.json");
+const themeVersion = version;
+
+hexo.extend.helper.register("isHomePagePagination", function (pagePath, route) {
+  if (pagePath.length > 5 && route === "/") {
+    return pagePath.slice(0, 5) === "page/";
+  }
+
+  return false;
+});
+
+/* code block language display */
+hexo.extend.filter.register("after_post_render", function (data) {
+  // Only process if not already processed
+  if (data._processedHighlight) return data;
+  
+  // Updated pattern to include numbers and other special characters
+  const pattern = /<figure class="highlight ([^"]+)">([\s\S]*?)<\/figure>/g;
+  data.content = data.content.replace(pattern, function (match, p1, p2) {
+    // If already has code-container anywhere in the match, return unchanged
+    if (match.includes('code-container')) {
+      return match;
+    }
+
+    let language = p1 || "code";
+    if (language === "plain") {
+      language = "code";
+    }
+
+    return '<div class="code-container" data-rel="' +
+      language.charAt(0).toUpperCase() +
+      language.slice(1) +
+      '">' +
+      match.replace(
+        '<figure class="highlight ',
+        '<figure class="iseeu highlight '
+      ) +
+      "</div>";
+  });
+
+  // Mark as processed
+  data._processedHighlight = true;
+  return data;
+});
+
+hexo.extend.helper.register("createNewArchivePosts", function (posts) {
+  const postList = [],
+    postYearList = [];
+  posts.forEach((post) => postYearList.push(post.date.year()));
+  Array.from(new Set(postYearList)).forEach((year) => {
+    postList.push({
+      year: year,
+      postList: [],
+    });
+  });
+  postList.sort((a, b) => b.year - a.year);
+  postList.forEach((item) => {
+    posts.forEach(
+      (post) => item.year === post.date.year() && item.postList.push(post),
+    );
+  });
+  postList.forEach((item) =>
+    item.postList.sort((a, b) => b.date.unix() - a.date.unix()),
+  );
+  return postList;
+});
+
+hexo.extend.helper.register(
+  "getAuthorLabel",
+  function (postCount, isAuto, labelList) {
+    let level = Math.floor(Math.log2(postCount));
+    level = level < 2 ? 1 : level - 1;
+
+    if (isAuto === false && Array.isArray(labelList) && labelList.length > 0) {
+      return level > labelList.length
+        ? labelList[labelList.length - 1]
+        : labelList[level - 1];
+    } else {
+      return `Lv${level}`;
+    }
+  },
+);
+
+hexo.extend.helper.register("getPostUrl", function (rootUrl, path) {
+  if (rootUrl) {
+    let { href } = new URL(rootUrl);
+    if (href.substring(href.length - 1) !== "/") {
+      href = href + "/";
+    }
+    return href + path;
+  } else {
+    return path;
+  }
+});
+
+hexo.extend.helper.register("renderJS", function (path, options = {}) {
+  const _js = hexo.extend.helper.get("js").bind(hexo);
+  const { module = false, async = false, swupReload = false } = options;
+
+  if (Array.isArray(path)) {
+    path = path.map((p) => "js/build/" + p);
+  } else {
+    path = "js/build/" + path;
+  }
+
+  const cdnProviders = {
+    zstatic:
+      "https://s4.zstatic.net/ajax/libs/hexo-theme-redefine/:version/:path",
+    cdnjs:
+      "https://cdnjs.cloudflare.com/ajax/libs/hexo-theme-redefine/:version/:path",
+    unpkg: "https://unpkg.com/hexo-theme-redefine@:version/source/:path",
+    jsdelivr:
+      "https://cdn.jsdelivr.net/npm/hexo-theme-redefine@:version/source/:path",
+    aliyun:
+      "https://evan.beee.top/projects/hexo-theme-redefine@:version/source/:path",
+    npmmirror:
+      "https://registry.npmmirror.com/hexo-theme-redefine/:version/files/source/:path",
+    custom: this.theme.cdn.custom_url,
+  };
+
+  const cdnPathHandle = (path) => {
+    const cdnBase =
+      cdnProviders[this.theme.cdn.provider] || cdnProviders.npmmirror;
+    let scriptTag;
+
+    const typeAttr = module ? 'type="module"' : "";
+    // const asyncAttr = async ? "async" : "";
+    const swupAttr = swupReload ? "data-swup-reload-script" : "";
+
+    if (this.theme.cdn.enable) {
+      if (this.theme.cdn.provider === "custom") {
+        const customUrl = cdnBase
+          .replace(":version", themeVersion)
+          .replace(":path", path);
+        scriptTag = `<script ${typeAttr} src="${
+          this.theme.cdn.enable ? customUrl : _js({ src: path })
+        }" ${swupAttr}></script>`;
+      } else {
+        scriptTag = `<script ${typeAttr} src="${cdnBase
+          .replace(":version", themeVersion)
+          .replace(":path", path)}" ${swupAttr}></script>`;
+      }
+    } else {
+      scriptTag = _js({
+        src: path,
+        type: module ? "module" : undefined,
+        "data-swup-reload-script": swupReload ? "" : undefined,
+        // async: async,
+      });
+    }
+
+    return scriptTag;
+  };
+
+  let renderedScripts = "";
+
+  if (Array.isArray(path)) {
+    renderedScripts = path.map(cdnPathHandle).join("");
+  } else {
+    renderedScripts = cdnPathHandle(path);
+  }
+
+  return renderedScripts;
+});
+
+hexo.extend.helper.register("renderCSS", function (path) {
+  const _css = hexo.extend.helper.get("css").bind(hexo);
+
+  const cdnProviders = {
+    zstatic:
+      "https://s4.zstatic.net/ajax/libs/hexo-theme-redefine/:version/:path",
+    cdnjs:
+      "https://cdnjs.cloudflare.com/ajax/libs/hexo-theme-redefine/:version/:path",
+    unpkg: "https://unpkg.com/hexo-theme-redefine@:version/source/:path",
+    jsdelivr:
+      "https://cdn.jsdelivr.net/npm/hexo-theme-redefine@:version/source/:path",
+    aliyun:
+      "https://evan.beee.top/projects/hexo-theme-redefine@:version/source/:path",
+    npmmirror:
+      "https://registry.npmmirror.com/hexo-theme-redefine/:version/files/source/:path",
+    custom: this.theme.cdn.custom_url,
+  };
+
+  const cdnPathHandle = (path) => {
+    const cdnBase =
+      cdnProviders[this.theme.cdn.provider] || cdnProviders.npmmirror;
+    let cssLink;
+
+    if (this.theme.cdn.enable) {
+      if (this.theme.cdn.provider === "custom") {
+        const customUrl = cdnBase
+          .replace(":version", themeVersion)
+          .replace(":path", path);
+        cssLink = `<link rel="stylesheet" href="${customUrl}">`;
+      } else {
+        cssLink = `<link rel="stylesheet" href="${cdnBase
+          .replace(":version", themeVersion)
+          .replace(":path", path)}">`;
+      }
+    } else {
+      cssLink = _css(path);
+    }
+
+    return cssLink;
+  };
+
+  if (Array.isArray(path)) {
+    return path.map(cdnPathHandle).join("");
+  } else {
+    return cdnPathHandle(path);
+  }
+});
+
+hexo.extend.helper.register("getThemeVersion", function () {
+  return themeVersion;
+});
+
+hexo.extend.helper.register("checkDeprecation", function (condition, id, message) {
+  if (condition) {
+    // Use Set to ensure each warning is only logged once per Hexo process
+    if (!global.deprecationWarnings) {
+      global.deprecationWarnings = new Set();
+    }
+    
+    if (!global.deprecationWarnings.has(id)) {
+      hexo.log.warn(`${message}`);
+      global.deprecationWarnings.add(id);
+    }
+    return true;
+  }
+  return false;
+});
+
+hexo.extend.helper.register("configOptions", function (obj, indent = '  ') {
+  if (!obj || typeof obj !== 'object') return '';
+  
+  return Object.entries(obj)
+    .filter(([key, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => {
+      if (typeof value === 'string') {
+        return `${indent}${key}: '${value}',`;
+      }
+      return `${indent}${key}: ${value},`;
+    })
+    .join('\n');
+});

package/scripts/helpers/waline-helpers.js

@@ -0,0 +1,33 @@
+hexo.extend.helper.register('waline_reaction_config', function(reactionConfig) {
+  if (Array.isArray(reactionConfig) && reactionConfig.length) {
+    return `[${reactionConfig.map(item => `'${item}'`).join(', ')}]`;
+  } else {
+    return Boolean(reactionConfig);
+  }
+});
+
+hexo.extend.helper.register('waline_array_config', function(arrayConfig) {
+  if (Array.isArray(arrayConfig) && arrayConfig.length) {
+    return `[${arrayConfig.map(item => `'${item}'`).join(', ')}]`;
+  }
+  return '[]';
+});
+
+hexo.extend.helper.register('waline_config_options', function(config) {
+  if (!config || typeof config !== 'object') return '';
+  
+  const formatValue = (value) => {
+    if (typeof value === 'string') {
+      return `'${value}'`;
+    }
+    if (Array.isArray(value)) {
+      return `[${value.map(item => typeof item === 'string' ? `'${item}'` : item).join(', ')}]`;
+    }
+    return value;
+  };
+  
+  return Object.entries(config)
+    .filter(([key, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `          ${key}: ${formatValue(value)},`)
+    .join('\n');
+});