hexo-theme-volantis 4.3.1 → 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,7 +1,12 @@
 'use strict';
 
 function postBtn(args) {
-  args = args.join(' ').split(',');
+  if(/::/g.test(args)){
+    args = args.join(' ').split('::');
+  }
+  else{
+    args = args.join(' ').split(',');
+  }
   let cls = '';
   let text = '';
   let url = '';

package/scripts/tags/btns.js

@@ -7,7 +7,12 @@ function postBtns(args, content) {
 }
 
 function postCell(args, content) {
-  args = args.join(' ').split(',');
+  if(/::/g.test(args)){
+    args = args.join(' ').split('::');
+  }
+  else{
+    args = args.join(' ').split(',');
+  }
   let text = args[0] || '';
   let url = args[1] || '';
   text = text.trim();
@@ -16,7 +21,7 @@ function postCell(args, content) {
     url = 'href=\'' + url + '\'';
   }
   let icon = '';
-  let img = 'https://cdn.jsdelivr.net/gh/volantis-x/cdn-volantis@3/img/placeholder/d570170f4f12e1ee829ca0e85a7dffeb77343a.svg';
+  let img = hexo.theme.config.default.image;
   if (args.length > 2) {
     if (args[2].indexOf(' fa-') > -1) {
       icon = args[2].trim();

package/scripts/tags/checkbox.js

@@ -1,7 +1,12 @@
 'use strict';
 
 function postCheckbox(args) {
-  args = args.join(' ').split(',');
+  if(/::/g.test(args)){
+    args = args.join(' ').split('::');
+  }
+  else{
+    args = args.join(' ').split(',');
+  }
   var cls = '';
   var text = '';
   var checked = false;
@@ -24,7 +29,12 @@ function postCheckbox(args) {
   }
 }
 function postRadio(args) {
-  args = args.join(' ').split(',');
+  if(/::/g.test(args)){
+    args = args.join(' ').split('::');
+  }
+  else{
+    args = args.join(' ').split(',');
+  }
   var cls = '';
   var text = '';
   var checked = false;

package/scripts/tags/contributors.js

@@ -0,0 +1,100 @@
+/**
+ * friends.js v1 | https://github.com/xaoxuu/hexo-theme-stellar/
+ * 格式与官方标签插件一致使用空格分隔，中括号内的是可选参数（中括号不需要写出来）
+ *
+ * {% friends [only:group1] [not:group2] %}
+ */
+
+'use strict';
+
+hexo.extend.tag.register('contributors', function(args) {
+  args = hexo.args.map(args, ['only', 'not', 'api', 'source', 'repo']);
+  if (args.only) {
+    if(/::/g.test(args.only)){
+      args.only = args.only.split('::');
+    }else{
+      args.only = args.only.split(',');
+    }
+  }
+  if (args.not) {
+    if(/::/g.test(args.not)){
+      args.not = args.not.split('::');
+    }else{
+      args.not = args.not.split(',');
+    }
+  }
+  var friends = hexo.locals.get('data').contributors;
+  if (friends == undefined) {
+    friends = {};
+  }
+  if (args.repo) {
+    friends = {
+      group: {
+        api: args.api || 'https://gh-api.xaoxuu.com',
+        source: args.source || 'volantis-x/github-api',
+        repo: args.repo
+      }
+    }
+  }
+  var el = '<div class="tag-plugin users-wrap">';
+  function groupHeader(group) {
+    var header = '<div class="group-header">';
+    if (group.title) {
+      header += hexo.render.renderSync({text: group.title, engine: 'markdown'}).split('\n').join('');
+    }
+    if (group.description) {
+      header += hexo.render.renderSync({text: group.description, engine: 'markdown'}).split('\n').join('');
+    }
+    header += '</div>';
+    return header;
+  }
+  function cell(friend) {
+    if (friend.url && friend.title) {
+      var cell = '<div class="user-card">';
+      cell += '<a class="card-link" target="_blank" rel="external noopener noreferrer" href="' + friend.url + '">';
+      cell += '<img src="' + (friend.avatar || hexo.theme.config.default.avatar) + '" onerror="errorImgAvatar(this)"/>';
+      cell += '<div class="name"><span>' + friend.title + '</span></div>';
+      cell += '</a></div>'
+      return cell;
+    } else {
+      return '';
+    }
+  }
+  for (let groupId of Object.keys(friends)) {
+    function f() {
+      if (args.not && args.not.includes(groupId)) {
+        return;
+      }
+      if (groupId in friends) {
+        let group = friends[groupId];
+        if (group.title || group.description) {
+          el += groupHeader(group);
+        }
+        if (group.repo) {
+          el += '<div class="contributorsjs-wrap"';
+          el += ' id="contributors-api"';
+          el += ' api="' + group.api + '/v1/contributors?source=' + group.source + '&target=' + group.repo + '"';
+          el += '>';
+          el += '<div class="loading-wrap"><svg class="loading" style="vertical-align: middle;fill: currentColor;overflow: hidden;" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="2709"><path d="M832 512c0-176-144-320-320-320V128c211.2 0 384 172.8 384 384h-64zM192 512c0 176 144 320 320 320v64C300.8 896 128 723.2 128 512h64z" p-id="2710"></path></svg><p></p></div>';
+          el += '<div class="group-body"></div>';
+          el += '</div>';
+        } else if (group.items) {
+          el += '<div class="group-body">';
+          group.items.forEach((friend, i) => {
+            el += cell(friend);
+          });
+          el += '</div>';
+        }
+      }
+    }
+    if (args.only) {
+      if (args.only.includes(groupId)) {
+        f();
+      }
+    } else {
+      f();
+    }
+  }
+  el += '</div>';
+  return el;
+});