hexo-theme-volantis 4.2.0 → 5.0.0-alpha.112

package/scripts/helpers/revisioned.js

@@ -0,0 +1,158 @@
+// hexo g 执行 hexo s 跳出 
+
+// https://blog.imkero.com/posts/hexo-page-performance.html#静态资源版本控制
+
+
+const minimatch = require("minimatch");
+const crypto = require('crypto');
+
+const stream2buffer = (stream) => {
+  if(!stream) return;
+  return new Promise((resolve, reject) => {
+    const _buf = [];
+    stream.on("data", (chunk) => _buf.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(_buf)));
+    stream.on("error", (err) => reject(err));
+  });
+};
+
+const readFileAsBuffer = (filePath) => {
+  return stream2buffer(hexo.route.get(filePath));
+};
+
+const readFileAsString = async (filePath) => {
+  const buffer = await readFileAsBuffer(filePath);
+  return buffer.toString();
+};
+
+const parseFilePath = (filePath) => {
+  const parts = filePath.split("/");
+  const originalFileName = parts[parts.length - 1];
+
+  const dotPosition = originalFileName.lastIndexOf(".");
+
+  const dirname = parts.slice(0, parts.length - 1).join("/");
+  const basename =
+    dotPosition === -1
+      ? originalFileName
+      : originalFileName.substring(0, dotPosition);
+  const extension =
+    dotPosition === -1 ? "" : originalFileName.substring(dotPosition);
+
+  return [dirname, basename, extension];
+};
+
+const genFilePath = (dirname, basename, extension) => {
+  let dirPrefix = "";
+  if (dirname) {
+    dirPrefix += dirname + "/";
+  }
+
+  if (extension && !extension.startsWith(".")) {
+    extension = "." + extension;
+  }
+
+  return dirPrefix + basename + extension;
+};
+
+const getRevisionedFilePath = (filePath, revision) => {
+  const [dirname, basename, extension] = parseFilePath(filePath);
+  return genFilePath(dirname, `${basename}.${revision}`, extension);
+};
+
+const revisioned = (filePath) => {
+  if (!hexo.theme.config.cdn_version) {
+    return;
+  }
+  let arg = process.argv[2];
+  if (arg == "s" || arg == "server") {
+    return filePath
+  }
+  return getRevisionedFilePath(filePath, `!!revision:${filePath}!!`);
+};
+
+hexo.extend.helper.register("revisioned", revisioned);
+
+const calcFileHash = async (filePath) => {
+  const buffer = await stream2buffer(hexo.route.get(filePath));
+  const fileHash = crypto.createHash("md5").update(buffer).digest('hex').substring(0, 8);
+  return fileHash;
+};
+
+const replaceRevisionPlaceholder = async () => {
+
+  if (!hexo.theme.config.cdn_version) {
+    return;
+  }
+
+  const options = hexo.config.new_revision || {};
+  const include = options.include || [];
+
+  const hashPromiseMap = {};
+  const hashMap = {};
+  const doHash = (filePath) =>
+    calcFileHash(filePath).then((hash) => {
+      hashMap[filePath] = hash;
+    });
+
+  await Promise.all(
+    hexo.route.list().map(async (path) => {
+      const [, , extension] = parseFilePath(path);
+      if (![".css", ".js", ".html"].includes(extension)) {
+        return;
+      }
+
+      let fileContent = await readFileAsString(path);
+
+      const regexp = /\.!!revision:([^\)]+?)!!/g;
+      const matchResult = [...fileContent.matchAll(regexp)];
+      if (matchResult.length) {
+        const hashTaskList = [];
+
+        // 异步获取文件 hash
+        matchResult.forEach((group) => {
+          const filePath = group[1];
+          if (!(filePath in hashPromiseMap)) {
+            hashPromiseMap[filePath] = doHash(filePath);
+          }
+          hashTaskList.push(hashPromiseMap[filePath]);
+        });
+
+        // 等待全部 hash 完成
+        await Promise.all(hashTaskList);
+
+        // 替换 placeholder
+        fileContent = fileContent.replace(regexp, function (match, filePath) {
+          if (!(filePath in hashMap)) {
+            throw new Error("file hash not computed");
+          }
+          return "." + hashMap[filePath];
+        });
+
+        hexo.route.set(path, fileContent);
+      }
+    })
+  );
+
+  await Promise.all(
+    hexo.route.list().map(async (path) => {
+      for (let i = 0, len = include.length; i < len; i++) {
+        if (minimatch(path, include[i])) {
+          return doHash(path);
+        }
+      }
+    })
+  );
+
+  await Promise.all(
+    Object.keys(hashMap).map(async (filePath) => {
+      hexo.route.set(
+        getRevisionedFilePath(filePath, hashMap[filePath]),
+        await readFileAsBuffer(filePath)
+      );
+      hexo.route.remove(filePath);
+    })
+  );
+};
+
+hexo.extend.filter.register("after_generate", replaceRevisionPlaceholder,999999999999999999999999999999999999);

package/scripts/helpers/structured-data/index.js

@@ -0,0 +1,2 @@
+/*globals hexo */
+hexo.extend.helper.register("structured_data", require('./lib/'));

package/scripts/helpers/structured-data/lib/blogposting.js

@@ -0,0 +1,77 @@
+module.exports = (hexo, option) => {
+  const { config, page: post } = hexo;
+
+  const blogposting = {
+    "@context": "http://schema.org",
+    "@type": "BlogPosting",
+    headline: post.title || post.seo_title,
+    description: post.description || hexo.strip_html(post.excerpt) || config.description,
+    inLanguage: config.language,
+    mainEntityOfPage: {
+      "@type": "WebPage",
+      "@id": post.permalink,
+    },
+    author: {
+      "@type": "Person",
+      name: option.person.name,
+      image: {
+        "@type": "ImageObject",
+        url: option.logo.path,
+      },
+      url: option.person.url,
+    },
+    publisher: {
+      "@type": "Organization",
+      name: option.organization.name,
+      logo: {
+        "@type": "ImageObject",
+        url: option.logo.path,
+        width: option.logo.width,
+        height: option.logo.height,
+      },
+    },
+    url: post.permalink,
+  };
+
+  blogposting.wordCount = hexo.strip_html(post.excerpt).length;
+
+  if (post.date) {
+    blogposting.datePublished = post.date.toISOString();
+  }
+  if (post.updated) {
+    blogposting.dateModified = post.updated.toISOString();
+  }
+  if (post.categories && post.categories.length) {
+    if (post.categories.data) {
+      blogposting.articleSection = post.categories.data[0].name;
+    } else {
+      blogposting.articleSection = post.categories[0];
+    }
+  }
+
+  if (post.tags && post.tags.length) {
+    if (post.tags.data) {
+      blogposting.keywords = post.tags.map((tag) => tag.name).join(",");
+    } else {
+      blogposting.keywords = post.tags.map((tag) => tag).join(",");
+    }
+  }
+  let image = post.headimg || "";
+  if (image) {
+    blogposting.image = {
+      "@type": "ImageObject",
+      url: image,
+      width: 1024,
+      height: 768,
+    };
+  }else{
+    blogposting.image = {
+      "@type": "ImageObject",
+      url: option.logo.path,
+      width: option.logo.width,
+      height: option.logo.height,
+    };
+  }
+
+  return blogposting;
+};

package/scripts/helpers/structured-data/lib/breadcrumblist.js

@@ -0,0 +1,152 @@
+module.exports = (hexo, option) => {
+  const { config, page } = hexo;
+
+  const breadcrumb = {
+    "@context": "http://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: [
+      {
+        "@type": "ListItem",
+        position: 1,
+        item: {
+          "@id": config.url + config.root,
+          name: config.title,
+        },
+      },
+    ],
+  };
+
+  if (hexo.is_category()) {
+    let { category_dir, category_map: map } = config;
+    if (!Array.isArray(map)) map = [];
+    if (category_dir === "/") category_dir = "";
+    if (category_dir.slice(-1) !== "/") category_dir += "/";
+    const category_path =
+      category_dir + (map[page.category] || page.category) + "/";
+
+    breadcrumb.itemListElement.push({
+      "@type": "ListItem",
+      position: 2,
+      item: {
+        "@id": config.url + config.root + category_path,
+        name: page.category,
+      },
+    });
+  }
+
+  if (hexo.is_tag()) {
+    let { tag_dir, tag_map: map } = config;
+    if (!Array.isArray(map)) map = [];
+    if (tag_dir === "/") tag_dir = "";
+    if (tag_dir.slice(-1) !== "/") tag_dir += "/";
+    const tag_path = tag_dir + (map[page.tag] || page.tag) + "/";
+
+    breadcrumb.itemListElement.push({
+      "@type": "ListItem",
+      position: 2,
+      item: {
+        "@id": config.url + config.root + tag_path,
+        name: page.tag,
+      },
+    });
+  }
+
+  if (hexo.is_archive()) {
+    let { archive_dir } = config;
+    if (archive_dir.slice(-1) !== "/") archive_dir += "/";
+
+    breadcrumb.itemListElement.push({
+      "@type": "ListItem",
+      position: 2,
+      item: {
+        "@id": config.url + config.root + archive_dir,
+        name: "Archive",
+      },
+    });
+    let timezone = config.timezone || "Asia/Shanghai";
+    if (hexo.is_year()) {
+      const dtf = new Intl.DateTimeFormat(config.language, {
+        year: "numeric",
+        timeZone: timezone,
+      });
+      breadcrumb.itemListElement.push({
+        "@type": "ListItem",
+        position: 3,
+        item: {
+          "@id": config.url + config.root + archive_dir + page.year + "/",
+          name: dtf.format(new Date(page.year, 0, 1)),
+        },
+      });
+    }
+
+    if (hexo.is_month()) {
+      const dtf = new Intl.DateTimeFormat(config.language, {
+        month: "numeric",
+        timeZone: timezone,
+      });
+      breadcrumb.itemListElement.push({
+        "@type": "ListItem",
+        position: 4,
+        item: {
+          "@id":
+            config.url +
+            config.root +
+            archive_dir +
+            page.year +
+            "/" +
+            page.month +
+            "/",
+          name: dtf.format(new Date(page.year, page.month - 1, 1)),
+        },
+      });
+    }
+  }
+
+  if (hexo.is_post()) {
+    page.categories.data.forEach((category) =>
+      breadcrumb.itemListElement.push({
+        "@type": "ListItem",
+        position: 2,
+        item: {
+          "@id": config.url + config.root + category.path,
+          name: category.name,
+        },
+      })
+    );
+
+    breadcrumb.itemListElement.push({
+      "@type": "ListItem",
+      position: 3,
+      item: {
+        "@id": config.url + config.root + page.path,
+        name: page.title || page.seo_title,
+      },
+    });
+  }
+
+  if (hexo.is_page()&&page.categories) {
+    let temp = "/"
+    for (let index = 0; index < page.categories.length; index++) {
+      const cat = page.categories[index];
+      temp = temp + cat + "/"
+      breadcrumb.itemListElement.push({
+        "@type": "ListItem",
+        position: 2,
+        item: {
+          "@id": config.url + config.root + config.category_dir + temp,
+          name: cat,
+        },
+      })
+    }
+    breadcrumb.itemListElement.push({
+      "@type": "ListItem",
+      position: 3,
+      item: {
+        "@id": config.url + config.root + page.path,
+        name: page.title || page.seo_title,
+      },
+    });
+  }
+
+  return breadcrumb;
+};

package/scripts/helpers/structured-data/lib/config.js

@@ -0,0 +1,31 @@
+module.exports = function (hexo) {
+  const {config} = hexo;
+  return {
+    person: {
+      name: config.author,
+      url: config.url + config.root,
+      sns: [],
+      description: config.description,
+    },
+    logo: {
+      path: /404/,
+      width: 192,
+      height: 192,
+    },
+    organization: {
+      name: config.title,
+      url: config.url + config.root,
+    },
+    website: {
+      name: config.title,
+      url: config.url + config.root,
+      keywords: config.keywords,
+      description: config.description,
+      search: {
+        name: "Site Search",
+        url: config.url + "?s={search_term_string}",
+        query: "required name=search_term_string",
+      },
+    },
+  };
+};

package/scripts/helpers/structured-data/lib/index.js

@@ -0,0 +1,30 @@
+const config = require("./config");
+
+const WebSite = require("./website");
+const Organization = require("./organization");
+const Person = require("./person");
+const BlogPosting = require("./blogposting");
+const BreadcrumbList = require("./breadcrumblist");
+
+function isObject(item) {
+  return item && typeof item === 'object' && !Array.isArray(item);
+}
+
+function merge(target, source) {
+  for (const key in source) {
+    if (isObject(target[key]) && isObject(source[key])) {
+      merge(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+
+module.exports = function () {
+  const hexo = this;
+  const option = merge(config(hexo), hexo.theme.structured_data.data);
+  const builder = [Organization, Person, BreadcrumbList, WebSite, BlogPosting];
+  const jsonld = JSON.stringify(builder.map((f) => f(hexo, option)));
+  return `<script type="application/ld+json">${jsonld}</script>`;
+};

package/scripts/helpers/structured-data/lib/organization.js

@@ -0,0 +1,15 @@
+
+module.exports = (hexo, option) => {
+  return {
+    "@context": "http://schema.org",
+    "@type": "Organization",
+    "name": option.organization.name,
+    "url": option.organization.url,
+    "logo": {
+      "@type": "ImageObject",
+      "url": option.logo.path,
+      "width": option.logo.width,
+      "height": option.logo.height
+    }
+  };
+};

package/scripts/helpers/structured-data/lib/person.js

@@ -0,0 +1,16 @@
+module.exports = (hexo, option) => {
+  const { config } = hexo;
+
+  return {
+    "@context": "http://schema.org",
+    "@type": "Person",
+    name: option.person.name,
+    image: {
+      "@type": "ImageObject",
+      url: option.logo.path,
+    },
+    url: option.person.url,
+    sameAs: option.person.sns,
+    description: option.person.description,
+  };
+};

package/scripts/helpers/structured-data/lib/website.js

@@ -0,0 +1,42 @@
+module.exports = (hexo,option) => {
+  const { config } = hexo;
+
+  return {
+    "@context": "http://schema.org",
+    "@type": "WebSite",
+    name: option.website.name,
+    url: option.website.url,
+    keywords: option.website.keywords,
+    description: option.website.description,
+    author: {
+      "@type": "Person",
+      name: option.person.name,
+      image: {
+        "@type": "ImageObject",
+        url: option.logo.path,
+      },
+      url: option.person.url,
+      description: option.person.description,
+    },
+    publisher: {
+      "@type": "Organization",
+      name: option.organization.name,
+      url: option.organization.url,
+      logo: {
+        "@type": "ImageObject",
+        url: option.logo.path,
+        width: option.logo.width,
+        height: option.logo.height,
+      },
+    },
+    potentialAction: {
+      "@type": "SearchAction",
+      name: option.website.search.name,
+      target: {
+        "@type": "EntryPoint",
+        urlTemplate: option.website.search.url,
+      },
+      "query-input": option.website.search.query,
+    },
+  };
+};

package/scripts/tags/btn.js

@@ -1,49 +1,54 @@
 'use strict';
 
 function postBtn(args) {
-  args = args.join(' ').split(',')
-  let cls = ''
-  let text = ''
-  let url = ''
-  let icon = ''
+  if(/::/g.test(args)){
+    args = args.join(' ').split('::');
+  }
+  else{
+    args = args.join(' ').split(',');
+  }
+  let cls = '';
+  let text = '';
+  let url = '';
+  let icon = '';
   if (args.length > 3) {
-    cls = args[0]
-    text = args[1]
-    url = args[2]
-    icon = args[3]
+    cls = args[0];
+    text = args[1];
+    url = args[2];
+    icon = args[3];
   } else if (args.length > 2) {
     if (args[2].indexOf(' fa-') > -1) {
       // text, url, icon
-      text = args[0]
-      url = args[1]
-      icon = args[2]
+      text = args[0];
+      url = args[1];
+      icon = args[2];
     } else {
-      cls = args[0]
-      text = args[1]
-      url = args[2]
+      cls = args[0];
+      text = args[1];
+      url = args[2];
     }
   } else if (args.length > 1) {
-    text = args[0]
-    url = args[1]
+    text = args[0];
+    url = args[1];
   } else if (args.length > 0) {
-    text = args[0]
+    text = args[0];
   }
 
-  cls = cls.trim()
-  icon = icon.trim()
-  text = text.trim()
-  url = url.trim()
+  cls = cls.trim();
+  icon = icon.trim();
+  text = text.trim();
+  url = url.trim();
   if (url.length > 0) {
-    url = "href='" + url + "'"
+    url = 'href=\'' + url + '\'';
   }
   if (cls.length > 0) {
-    cls = ' ' + cls
+    cls = ' ' + cls;
   }
   if (icon.length > 0) {
     return `<span class='btn${cls}'><a class="button" ${url} title='${text}'><i class='${icon}'></i>${text}</a></span>`;
-  } else {
-    return `<span class='btn${cls}'><a class="button" ${url} title='${text}'>${text}</a></span>`;
   }
+  return `<span class='btn${cls}'><a class="button" ${url} title='${text}'>${text}</a></span>`;
+
 }
 
 hexo.extend.tag.register('btn', postBtn);

package/scripts/tags/btns.js

@@ -7,28 +7,33 @@ function postBtns(args, content) {
 }
 
 function postCell(args, content) {
-  args = args.join(' ').split(',')
-  let text = args[0] || ''
-  let url = args[1] || ''
-  text = text.trim()
-  url = url.trim()
+  if(/::/g.test(args)){
+    args = args.join(' ').split('::');
+  }
+  else{
+    args = args.join(' ').split(',');
+  }
+  let text = args[0] || '';
+  let url = args[1] || '';
+  text = text.trim();
+  url = url.trim();
   if (url.length > 0) {
-    url = "href='" + url + "'"
+    url = 'href=\'' + url + '\'';
   }
-  let icon = ''
-  let img = 'https://cdn.jsdelivr.net/gh/volantis-x/cdn-volantis@3/img/placeholder/d570170f4f12e1ee829ca0e85a7dffeb77343a.svg'
+  let icon = '';
+  let img = hexo.theme.config.default.image;
   if (args.length > 2) {
     if (args[2].indexOf(' fa-') > -1) {
-      icon = args[2].trim()
+      icon = args[2].trim();
     } else {
-      img = args[2].trim()
+      img = args[2].trim();
     }
   }
   if (icon.length > 0) {
-    return `<a class="button" ${url} title='${text}'><i class='${icon}'></i>${text}</a>`
-  } else {
-    return `<a class="button" ${url} title='${text}'><img src='${img}'>${text}</a>`
+    return `<a class="button" ${url} title='${text}'><i class='${icon}'></i>${text}</a>`;
   }
+  return `<a class="button" ${url} title='${text}'><img src='${img}'>${text}</a>`;
+
 }
 
 hexo.extend.tag.register('btns', postBtns, {ends: true});