hexo-theme-redefine-x 2.8.5

package/scripts/filters/lazyload-handle.js

@@ -0,0 +1,350 @@
+"use strict";
+
+/**
+ * Redefine-X Image Preloader - Build Phase
+ * 
+ * This filter transforms <img> tags into <div class="img-preloader"> containers
+ * that will be processed by JavaScript at runtime for progressive loading.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const imageSize = require("image-size");
+const http = require("http");
+const https = require("https");
+
+const DEFAULT_FALLBACK_DIMENSIONS = { width: 1000, height: 500 };
+const REMOTE_MAX_BYTES = 12 * 1024 * 1024; // 12MB safety cap
+const REMOTE_TIMEOUT_MS = 8000;
+const REMOTE_MAX_REDIRECTS = 3;
+
+const remoteSizeCache = new Map();
+
+function escapeHtmlAttr(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/\"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+function stripQueryAndHash(url) {
+  return String(url).split("#")[0].split("?")[0];
+}
+
+function normalizeRemoteUrl(src) {
+  const s = String(src).trim();
+  if (s.startsWith("//")) return `https:${s}`;
+  return s;
+}
+
+function decodeDataUrlToBuffer(src) {
+  const s = String(src);
+  if (!s.startsWith("data:")) return null;
+  const commaIndex = s.indexOf(",");
+  if (commaIndex === -1) return null;
+  const meta = s.slice(5, commaIndex);
+  const data = s.slice(commaIndex + 1);
+  const isBase64 = /;base64/i.test(meta);
+  try {
+    return isBase64
+      ? Buffer.from(data, "base64")
+      : Buffer.from(decodeURIComponent(data), "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function fetchUrlBuffer(urlString, redirectsLeft = REMOTE_MAX_REDIRECTS) {
+  return new Promise((resolve, reject) => {
+    let parsed;
+    try {
+      parsed = new URL(urlString);
+    } catch (e) {
+      reject(e);
+      return;
+    }
+
+    const client = parsed.protocol === "http:" ? http : https;
+    const req = client.request(
+      parsed,
+      {
+        method: "GET",
+        headers: {
+          "User-Agent": "hexo-redefine-x-lazyload/1.0",
+          Accept: "image/*,*/*;q=0.8",
+        },
+      },
+      (res) => {
+        const status = res.statusCode || 0;
+
+        if (
+          [301, 302, 303, 307, 308].includes(status) &&
+          res.headers.location &&
+          redirectsLeft > 0
+        ) {
+          res.resume();
+          const nextUrl = new URL(res.headers.location, parsed).toString();
+          fetchUrlBuffer(nextUrl, redirectsLeft - 1).then(resolve, reject);
+          return;
+        }
+
+        if (status < 200 || status >= 300) {
+          res.resume();
+          reject(new Error(`HTTP ${status}`));
+          return;
+        }
+
+        const chunks = [];
+        let total = 0;
+        res.on("data", (chunk) => {
+          total += chunk.length;
+          if (total > REMOTE_MAX_BYTES) {
+            req.destroy(new Error("Remote image too large"));
+            return;
+          }
+          chunks.push(chunk);
+        });
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      },
+    );
+
+    req.setTimeout(REMOTE_TIMEOUT_MS, () => {
+      req.destroy(new Error("Remote image request timeout"));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+async function getImageDimensions(src, imgTag, data) {
+  const fromTag = tryGetDimensionsFromTag(imgTag);
+  if (fromTag) return fromTag;
+
+  const s = String(src).trim();
+
+  if (s.startsWith("data:")) {
+    const buffer = decodeDataUrlToBuffer(s);
+    if (buffer) {
+      try {
+        const size = imageSize(buffer);
+        if (size && size.width && size.height) return { width: size.width, height: size.height };
+      } catch {
+        // ignore
+      }
+    }
+    return null;
+  }
+
+  if (s.startsWith("blob:")) return null;
+
+  if (/^https?:\/\//i.test(s) || s.startsWith("//")) {
+    const normalized = normalizeRemoteUrl(s);
+    if (!remoteSizeCache.has(normalized)) {
+      remoteSizeCache.set(
+        normalized,
+        (async () => {
+          const buffer = await fetchUrlBuffer(normalized);
+          const size = imageSize(buffer);
+          if (size && size.width && size.height) return { width: size.width, height: size.height };
+          return null;
+        })(),
+      );
+    }
+
+    try {
+      return await remoteSizeCache.get(normalized);
+    } catch {
+      return null;
+    }
+  }
+
+  const localPath = resolveLocalImagePath(s, data);
+  if (localPath) {
+    try {
+      const size = imageSize(localPath);
+      if (size && size.width && size.height) return { width: size.width, height: size.height };
+    } catch {
+      // ignore
+    }
+  }
+
+  return null;
+}
+
+function resolveLocalImagePath(src, data) {
+  const rawSrc = stripQueryAndHash(src);
+
+  const siteRoot = hexo.config.root || "/";
+  let rel = rawSrc;
+  if (siteRoot !== "/" && rel.startsWith(siteRoot)) {
+    rel = rel.slice(siteRoot.length);
+  }
+  rel = rel.replace(/^\//, "");
+
+  const relDecoded = (() => {
+    try {
+      return decodeURIComponent(rel);
+    } catch {
+      return rel;
+    }
+  })();
+
+  const candidates = [];
+
+  if (hexo.source_dir) {
+    candidates.push(path.join(hexo.source_dir, relDecoded));
+  }
+
+  if (hexo.theme_dir) {
+    candidates.push(path.join(hexo.theme_dir, "source", relDecoded));
+  }
+
+  const sourcePath = data && (data.full_source || data.source);
+  if (sourcePath) {
+    const sourceFullPath = path.isAbsolute(sourcePath)
+      ? sourcePath
+      : path.join(hexo.source_dir || "", sourcePath);
+    candidates.push(path.join(path.dirname(sourceFullPath), relDecoded));
+  }
+
+  if (hexo.source_dir && !rawSrc.startsWith("/")) {
+    const rawDecoded = (() => {
+      try {
+        return decodeURIComponent(rawSrc);
+      } catch {
+        return rawSrc;
+      }
+    })();
+    candidates.push(path.join(hexo.source_dir, rawDecoded));
+  }
+
+  for (const candidate of candidates) {
+    try {
+      if (candidate && fs.existsSync(candidate)) return candidate;
+    } catch {
+      // ignore
+    }
+  }
+  return null;
+}
+
+function tryGetDimensionsFromTag(imgTag) {
+  const widthMatch = imgTag.match(/\bwidth\s*=\s*(["']?)(\d+)\1/i);
+  const heightMatch = imgTag.match(/\bheight\s*=\s*(["']?)(\d+)\1/i);
+  const width = widthMatch ? Number(widthMatch[2]) : null;
+  const height = heightMatch ? Number(heightMatch[2]) : null;
+  if (Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0) {
+    return { width, height };
+  }
+  return null;
+}
+
+/**
+ * Extract alt text from img tag
+ */
+function extractAltText(imgTag) {
+  const altMatch = imgTag.match(/\balt\s*=\s*(["'])([^"']*)\1/i);
+  return altMatch ? altMatch[2] : "";
+}
+
+/**
+ * Extract class from img tag
+ */
+function extractClass(imgTag) {
+  const classMatch = imgTag.match(/\bclass\s*=\s*(["'])([^"']*)\1/i);
+  return classMatch ? classMatch[2] : "";
+}
+
+/**
+ * Build the img-preloader div container
+ */
+function buildPreloaderDiv(src, dims, alt, originalClass) {
+  const w = dims.width;
+  const h = dims.height;
+  const aspectRatio = (w / h).toFixed(6);
+  
+  const classes = ["img-preloader"];
+  if (originalClass) {
+    classes.push(originalClass);
+  }
+
+  return `<div class="${classes.join(" ")}" ` +
+    `data-src="${escapeHtmlAttr(src)}" ` +
+    `data-width="${w}" ` +
+    `data-height="${h}" ` +
+    `data-alt="${escapeHtmlAttr(alt)}" ` +
+    `style="aspect-ratio: ${aspectRatio}; max-width: ${w}px;">` +
+    `<div class="img-preloader-skeleton"></div>` +
+    `</div>`;
+}
+
+hexo.extend.filter.register(
+  "after_post_render",
+  async function (data) {
+    const theme = hexo.theme.config;
+    if (!theme?.articles?.lazyload) return data;
+    if (!data || typeof data.content !== "string" || data.content.length === 0) return data;
+
+    const imgRegex = /<img\b[^>]*>/gim;
+    let result = "";
+    let lastIndex = 0;
+    let match;
+
+    while ((match = imgRegex.exec(data.content)) !== null) {
+      const imgTag = match[0];
+      const start = match.index;
+      const end = imgRegex.lastIndex;
+      result += data.content.slice(lastIndex, start);
+      lastIndex = end;
+
+      // Skip if marked with data-no-lazyload
+      if (/\bdata-no-lazyload\b/i.test(imgTag)) {
+        result += imgTag;
+        continue;
+      }
+
+      const srcMatch = imgTag.match(/\bsrc\s*=\s*(["'])([^"']*)\1/i);
+      if (!srcMatch) {
+        result += imgTag;
+        continue;
+      }
+
+      const originalSrc = srcMatch[2];
+      if (!originalSrc) {
+        result += imgTag;
+        continue;
+      }
+
+      // Skip data: URLs (already inline) and blob: URLs
+      if (originalSrc.startsWith("data:") || originalSrc.startsWith("blob:")) {
+        result += imgTag;
+        continue;
+      }
+
+      let dims = await getImageDimensions(originalSrc, imgTag, data);
+      if (!dims || !dims.width || !dims.height) {
+        dims = DEFAULT_FALLBACK_DIMENSIONS;
+        if (hexo?.log?.warn) {
+          hexo.log.warn(
+            `[redefine-x][lazyload] Unable to detect image size, fallback to ${dims.width}x${dims.height}: ${originalSrc}`,
+          );
+        }
+      }
+
+      const alt = extractAltText(imgTag);
+      const originalClass = extractClass(imgTag);
+      
+      // Replace <img> with <div class="img-preloader">
+      const preloaderDiv = buildPreloaderDiv(originalSrc, dims, alt, originalClass);
+      result += preloaderDiv;
+    }
+
+    result += data.content.slice(lastIndex);
+    data.content = result;
+
+    return data;
+  },
+  1,
+);

package/scripts/filters/lib/hbe.default.js

@@ -0,0 +1,15 @@
+const hbeTheme = `
+<div class="hbe hbe-container" id="hexo-blog-encrypt" data-wpm="{{hbeWrongPassMessage}}" data-whm="{{hbeWrongHashMessage}}">
+  <script id="hbeData" type="hbeData" data-hmacdigest="{{hbeHmacDigest}}">{{hbeEncryptedData}}</script>
+  <div class="hbe hbe-content">
+    <div class="hbe hbe-input hbe-input-default">
+      <input class="hbe hbe-input-field hbe-input-field-default" type="password" id="hbePass">
+      <label class="hbe hbe-input-label hbe-input-label-default" for="hbePass">
+        <span class="hbe hbe-input-label-content hbe-input-label-content-default">{{hbeMessage}}</span>
+      </label>
+    </div>
+  </div>
+</div>
+`;
+
+module.exports = { hbeTheme };

package/scripts/filters/link-handle.js

@@ -0,0 +1,42 @@
+/* main hexo */
+
+"use strict";
+
+hexo.extend.filter.register(
+  "after_post_render",
+  function (data) {
+    const theme = this.theme;
+    const config = this.config;
+    const url = new URL(config.url);
+    const siteHost = url.hostname || config.url;
+
+    // Match 'a' tags that don't contain html children.
+    const regPureATag = /<a([^>]*)href="([^"]*)"([^>]*)>([^<]*)<\/a>/gim;
+
+    data.content = data.content.replace(
+      regPureATag,
+      function (match, attrBegin, href, attrEnd, html) {
+        // Exit if the href attribute doesn't exists.
+        if (!href) return match;
+
+        let link = "";
+        try {
+          link = new URL(href);
+        } catch (e) {
+          // Invalid url, e.g. Anchor link.
+          return match;
+        }
+
+        // Exit if the url has same host with `config.url`, which means isn't an external link.
+        if (!link.protocol || link.hostname === siteHost) return match;
+
+        if (theme.config.articles.style.link_icon == false) {
+          return `<a class="link" ${attrBegin} href="${href}" ${attrEnd}>${html}</a>`;
+        } else {
+          return `<a class="link" ${attrBegin} href="${href}" ${attrEnd}>${html}<i class="fa-solid fa-arrow-up-right ml-[0.2em] font-light align-text-top text-[0.7em] link-icon"></i></a>`;
+        }
+      },
+    );
+  },
+  0,
+);

package/scripts/filters/stylus-handle.js

@@ -0,0 +1,9 @@
+hexo.extend.filter.register('stylus:renderer', function (style) {
+    style.define('url-for', function (data) {
+        const urlRender = hexo.extend.helper.get('url_for').bind(hexo);
+
+        const url = urlRender(data.val);
+
+        return url;
+    });
+})

package/scripts/filters/table-handle.js

@@ -0,0 +1,11 @@
+/*
+'use strict';
+
+hexo.extend.filter.register('after_post_render', function(data) {
+  const tableRegex = /<table(?![\s\S]*?class=["'].*?\bgutter\b.*?["'])[\s\S]*?<\/table>/g;
+  const wrappedTable = match => `<div class="table-container">${match}</div>`;
+  data.content = data.content.replace(tableRegex, wrappedTable);
+  return data;
+});
+
+*/

package/scripts/helpers/meta-helpers.js

@@ -0,0 +1,38 @@
+hexo.extend.helper.register('generateMeta', function (theme, page) {
+  const hexo = this;
+  let robots_content="";
+  if (page.robots) {
+    robots_content = page.robots
+  } else if (theme.seo && theme.seo.robots) {
+    if (hexo.is_home()) {
+      if (page.prev == 0) {
+        robots_content=theme.seo.robots.home_first_page
+      }else{
+        robots_content=theme.seo.robots.home_other_pages
+      }
+    } else if (hexo.is_archive()) {
+      robots_content=theme.seo.robots.archive
+    } else if (hexo.is_category()) {
+      robots_content=theme.seo.robots.category
+    } else if (hexo.is_tag()) {
+      robots_content=theme.seo.robots.tag
+    }
+  }
+  if(robots_content){
+    return `<meta name="robots" content="${robots_content}">`
+  }
+});
+
+/**
+* hexo-auto-canonical
+* https://github.com/hyunseob/hexo-auto-canonical.git
+* Copyright (c) 2015, HyunSeob
+* Licensed under the MIT license.
+*/
+
+hexo.extend.helper.register('autoCanonical', function (config, page) {
+  var base_url = config.url;
+  if (config.url.charAt(config.url.length - 1) !== '/') base_url += '/';
+
+  return '<link rel="canonical" href="' + base_url + page.canonical_path.replace('index.html', '').toLowerCase() + '"/>';
+});

package/scripts/helpers/page-helpers.js

@@ -0,0 +1,153 @@
+/*
+	pageData is an object that defines various page types and their associated rendering details.
+	
+	Each page type includes the following properties:
+	
+	- titles: An array of possible titles for the page, which are used to identify the page type.
+	- types: An array of page types that can be matched; the type takes precedence over the title for identification.
+	- partial: The path to the partial template that will be used to render the content of the page.
+	- layout: Specifies the layout style for the page. "raw" indicates that no theme layout will be applied, while "default" means the standard theme layout (container) will be used.
+*/
+
+const pageData = {
+	home: {
+		titles: ["home", "首页"],
+		types: ["home"],
+		partial: "pages/home/home-content",
+		layout: "raw",
+	},
+	archive: {
+		titles: ["archive", "归档"],
+		types: ["archive", "archives"],
+		partial: "pages/archive/archive",
+		layout: "raw",
+	},
+	post: {
+		titles: ["post", "文章"],
+		types: ["post", "posts"],
+		partial: "pages/post/article-content",
+		layout: "raw",
+	},
+	categories: {
+		titles: ["category", "categories"],
+		types: ["category", "categories"],
+		partial: "pages/category/categories",
+		layout: "default",
+	},
+	categoryDetail: {
+		titles: [],
+		types: [],
+		partial: "pages/category/category-detail",
+		layout: "default",
+	},
+	tags: {
+		titles: ["tag", "tags"],
+		types: ["tag", "tags"],
+		partial: "pages/tag/tags",
+		layout: "default",
+	},
+	tagDetail: {
+		titles: [],
+		types: [],
+		partial: "pages/tag/tag-detail",
+		layout: "default",
+	},
+	notFound: {
+		titles: ["404", "notfound"],
+		types: ["404", "notfound"],
+		partial: "pages/notfound/notfound",
+		layout: "raw",
+	},
+	friends: {
+		titles: ["friends", "links", "link", "friend", "友情链接"],
+		types: ["links", "link"],
+		partial: "pages/friends/friends-link",
+		layout: "default",
+	},
+	shuoshuo: {
+		titles: ["shuoshuo", "说说"],
+		types: ["essays", "essay", "shuoshuo"],
+		partial: "pages/shuoshuo/essays",
+		layout: "default",
+	},
+	masonry: {
+		titles: ["gallery", "瀑布流", "相册", "photos", "photo"],
+		types: ["masonry", "gallery", "瀑布流", "相册", "photos", "photo"],
+		partial: "pages/masonry/masonry",
+		layout: "default",
+	},
+	bookmarks: {
+		titles: [],
+		types: ["bookmarks", "bookmark", "tools"],
+		partial: "pages/bookmarks/bookmarks",
+		layout: "raw",
+	},
+	pageTemplate: {
+		titles: [],
+		types: [],
+		partial: "pages/page-template",
+		layout: "default",
+	},
+};
+
+hexo.extend.helper.register("getAllPageData", function () {
+	return pageData;
+});
+
+hexo.extend.helper.register("getPageData", function (page) {
+	if (this.is_home()) return pageData.home;
+	if (this.is_archive()) return pageData.archive;
+	if (this.is_post()) return pageData.post;
+	if (this.is_category()) return pageData.categoryDetail;
+	if (this.is_tag()) return pageData.tagDetail;
+
+	const currentPageConfig = Object.entries(pageData).find(([type, config]) => {
+		return config.types.includes(page.template || page.type) || config.titles.includes(page.title?.toLowerCase());
+	});
+	return currentPageConfig ? pageData[currentPageConfig[0]] : null;
+});
+
+hexo.extend.helper.register("getPagePartialPath", function (page) {
+	const matchesPageType = (type) => {
+		const config = pageData[type];
+		return (
+			config.types.includes(page.template || page.type) ||
+			config.titles.includes(page.title?.toLowerCase())
+		);
+	};
+
+	// Check built-in page types first
+	if (this.is_home()) return pageData.home.partial;
+
+	if (this.is_post()) return pageData.post.partial;
+	// Check custom page types
+	for (const [type, config] of Object.entries(pageData)) {
+		if (matchesPageType(type) && config.layout === "raw") {
+			return config.partial;
+		} else if (this.is_archive() && pageData.archive.layout === "raw") { // return raw layout for archive page
+			return pageData.archive.partial;
+		} else if (this.is_category() && pageData.categoryDetail.layout === "raw") { // return raw layout for category page
+			return pageData.categoryDetail.partial;
+		} else if (this.is_tag() && pageData.tagDetail.layout === "raw") { // return raw layout for tag page
+			return pageData.tagDetail.partial;
+		}
+	}
+
+	return pageData.pageTemplate.partial;
+});
+
+hexo.extend.helper.register("getPageTitle", function (page) {
+	const pageData = this.getPageData(page);
+	let type = null;
+
+	// Determine the type based on page properties
+	if (this.is_home()) type = "home";
+	else if (this.is_archive()) type = "archive";
+	else if (this.is_post()) type = "post";
+	else {
+		type = pageData.type;
+	}
+
+	// const config = type ? pageData[type] : null;
+	return page.title || this.__(type) || "Untitled";
+});