hexo-theme-volantis 4.3.0 → 5.0.0-rc.2

package/scripts/helpers/head/generate_preload_fontfamily.js

@@ -0,0 +1,22 @@
+function getType(file) {
+  var filename = file;
+  var index1 = filename.lastIndexOf(".");
+  var index2 = filename.length;
+  var type = filename.substring(index1 + 1, index2);
+  return type;
+}
+function getLink_preload(Url) {
+  return `<link rel="preload" href="${Url}" as="font" type="font/${getType(Url)}" crossorigin="anonymous">\n`
+}
+
+hexo.extend.helper.register("generate_preload_fontfamily", function (theme) {
+  const hexo = this;
+  let preload = "";
+  if (theme.custom_css.fontfamily.logofont && theme.custom_css.fontfamily.logofont.url) {
+    preload += getLink_preload(theme.custom_css.fontfamily.logofont.url)
+  }
+  if (theme.custom_css.fontfamily.bodyfont && theme.custom_css.fontfamily.bodyfont.url) {
+    preload += getLink_preload(theme.custom_css.fontfamily.bodyfont.url)
+  }
+  return preload
+});

package/scripts/helpers/head/generate_seo.js

@@ -0,0 +1,24 @@
+hexo.extend.helper.register('generate_seo', 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}">`
+  }
+});

package/scripts/helpers/head/generate_title__keywords__description.js

@@ -0,0 +1,91 @@
+function init(hexo, config, theme, page) {
+  var title = page.seo_title || page.title;
+  var keywords = page.keywords || "";
+  var description = page.description || "";
+  if (hexo.is_archive()) {
+    title = hexo.__("navbar.archive");
+    if (hexo.is_month()) {
+      title += hexo.__("symbol.colon") + page.year + "/" + page.month;
+    } else if (hexo.is_year()) {
+      title += hexo.__("symbol.colon") + page.year;
+    }
+  } else if (hexo.is_category()) {
+    title = hexo.__("navbar.category") + hexo.__("symbol.colon") + page.category;
+  } else if (hexo.is_tag()) {
+    title = hexo.__("navbar.tag") + hexo.__("symbol.colon") + page.tag;
+  } else if (hexo.is_home() && page.prev == 0) {
+    keywords = config.keywords || "";
+    description = config.description || "";
+  } else {
+    if (
+      page.layout == "docs" &&
+      page.group &&
+      page.group in theme.sidebar.widget_library
+    ) {
+      let widget = theme.sidebar.widget_library[page.group];
+      if (widget.class == "group" && widget.seo_title) {
+        title = widget.seo_title + ": " + title;
+      }
+    }
+  }
+  if (theme.seo && theme.seo.use_tags_as_keywords) {
+    if (!keywords && page.tags && page.tags.length > 0) {
+      let tags = page.tags
+        .map(function (t) {
+          return t.name;
+        })
+        .join(",");
+      if (tags.length > 0) {
+        keywords += tags;
+      }
+    }
+  }
+  if (theme.seo && theme.seo.use_excerpt_as_description) {
+    if (page.description == undefined) {
+      if (page.excerpt) {
+        description = hexo.truncate(hexo.strip_html(page.excerpt), { length: 160 });
+      }
+    }
+  }
+  return {
+    title: title,
+    keywords: keywords,
+    description: description,
+  };
+}
+
+hexo.extend.helper.register("generate_title", function (config, theme, page) {
+  const hexo = this;
+  let data = init(hexo, config, theme, page);
+  let title = data.title
+  let s = "<title>"
+  if (title) {
+    s += `${title} - `
+  }
+  s += `${config.title}</title>`
+  return s
+});
+
+hexo.extend.helper.register("generate_keywords", function (config, theme, page) {
+  const hexo = this;
+  let data = init(hexo, config, theme, page);
+  let keywords = data.keywords
+  if (!(hexo.is_home() && page.prev == 0)) {
+    if (keywords) {
+      keywords += `,`
+    }
+    keywords += `${config.keywords}`
+  }
+  return `<meta name="keywords" content="${keywords}">`
+});
+// open_graph() 函数会生成一个 description 标签???  https://github.com/hexojs/hexo/blob/92b979f4a3fa8714aebd3d11c3295d466b870905/lib/plugins/helper/open_graph.js#L98
+hexo.extend.helper.register("generate_description", function (config, theme, page) {
+  const hexo = this;
+  let data = init(hexo, config, theme, page);
+  let description = data.description
+  if (!description) {
+    description += config.description
+  }
+  description += ` - ${config.author} - ${config.title}`
+  return `<meta name="description" content="${description}">`
+});

package/scripts/{related_posts → helpers/related_posts}/index.js

@@ -24,7 +24,7 @@ hexo.extend.helper.register('htmlGenerator', function(args) {
     var ret = '';
     ret += '<a class="item" href="' + list.path + '" title="' + list.title + '" rel="bookmark ">';
 
-    if (cfg.placeholder_img.length > 0) {
+    if (cfg.placeholder_img && cfg.placeholder_img.length > 0) {
       if (list.img && list.img != '') {
         ret += '<img src="' + list.img + '" />';
       } else {

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,65 @@
+module.exports = (hexo, option) => {
+  const { config, page: post } = hexo;
+
+  const blogposting = {
+    "@context": "http://schema.org",
+    "@type": "BlogPosting",
+    headline: post.title,
+    description: post.description || hexo.strip_html(post.excerpt),
+    datePublished: post.date.toISOString(),
+    dateModified: post.updated.toISOString(),
+    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.categories && post.categories.length) {
+    blogposting.articleSection = post.categories.data[0].name;
+  }
+
+  if (post.tags && post.tags.length) {
+    blogposting.keywords = post.tags.map((tag) => tag.name).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,128 @@
+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,
+      },
+    });
+  }
+
+  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,38 @@
+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];
+
+  if (hexo.is_post()) {
+    builder.push(BlogPosting);
+  } else {
+    builder.push(WebSite);
+  }
+
+  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/helpers/tag-plugins-style/index.js

@@ -0,0 +1,199 @@
+// 标签插件样式按需加载
+const fs = require("hexo-fs");
+const Database = require('warehouse'); // https://hexojs.github.io/warehouse/
+
+hexo.database.model("TagPluginCSS", new Database.Schema({
+  _id: { type: String, required: true },
+  data: { type: String }
+}));
+
+hexo.database.model("TagPluginOfPost", new Database.Schema({
+  _id: { type: String, required: true },
+  tags: { type: Array }
+}));
+
+const findTags = (data) => {
+  dataList = data.match(/{% (\w*?)\W.*?%}/g)
+  let tagSet = new Set()
+  if (dataList) {
+    dataList.forEach(e => {
+      let tag = /{% (\w*?)\W.*?%}/g.exec(e)
+      if (tag && tag[1].indexOf('end') != 0) {
+        tagSet.add(tag[1])
+      }
+    });
+  }
+  return Array.from(tagSet)
+}
+
+const renderStyl = (styList, callback) => {
+  let stySet = new Set(styList)
+  let tagPageStyleDir = "_style/_tag-plugins/"
+  let tagPageStyle = `@import '_defines/*'\n`
+  stySet.forEach(e => {
+    tagPageStyle += `@import '` + tagPageStyleDir + e + `'` + "\n"
+  })
+  hexo.renderStylus(tagPageStyle).then(callback)
+}
+function getTagPluginCSSInfo() {
+  let info = hexo.locals.get('TagPluginCSSInfo')
+  if (!info) {
+    info = fs.readFileSync(
+      hexo.theme.context.theme_dir + "source/css/_style/_tag-plugins/tag.json"
+    );
+    info = JSON.parse(info)
+    hexo.locals.set('TagPluginCSSInfo', function () {
+      return info
+    });
+  }
+  return info
+}
+
+function setTagPluginCSS(uuidTagCSS, css) {
+  let TagPluginCSS = hexo.locals.get('TagPluginCSS')
+  if (!TagPluginCSS) {
+    TagPluginCSS = {}
+  }
+  TagPluginCSS[uuidTagCSS] = css
+  hexo.locals.set('TagPluginCSS', function () {
+    return TagPluginCSS
+  });
+}
+function renderTagCSSAllPage(info) {
+  let styListAllPage = []
+  hexo.theme.config.plugins.tag_plugin_load_on_demand.plugins.forEach(e => {
+    if (e in info) {
+      info[e].forEach(x => {
+        styListAllPage.push(x)
+      })
+    }
+  })
+  renderStyl(styListAllPage, (css) => {
+    setTagPluginCSS("AllPage", css)
+  })
+
+}
+function insertTagCSS(uuidTagCSS, tagList) {
+  let info = getTagPluginCSSInfo()
+  let styList = []
+  let tagListSave = []
+  if (tagList) {
+    tagList.forEach(e => {
+      if (e in info) {
+        info[e].forEach(x => {
+          styList.push(x)
+        })
+        tagListSave.push(e)
+      }
+    })
+  }
+  hexo.theme.config.plugins.tag_plugin_load_on_demand.plugins.forEach(e => {
+    if (e in info) {
+      info[e].forEach(x => {
+        styList.push(x)
+      })
+      tagListSave.push(e)
+    }
+  })
+  renderStyl(styList, (css) => {
+    setTagPluginCSS(uuidTagCSS, css)
+  })
+  if (!hexo.locals.get('TagCSSAllPageFlag') && hexo.theme.config.plugins.tag_plugin_load_on_demand.plugins) {
+    hexo.locals.set('TagCSSAllPageFlag', function () {
+      return 1
+    });
+    renderTagCSSAllPage(info)
+  }
+  hexo.database.model('TagPluginOfPost').insert({
+    _id: uuidTagCSS,
+    tags: tagListSave,
+  })
+}
+
+function updateTagCSS(uuidTagCSS) {
+  // 这里在第二次刷新页面时生效
+  let arg = process.argv[2];
+  if (arg != "s" && arg != "server") {
+    return
+  }
+  let info = getTagPluginCSSInfo()
+  let res = hexo.database.model('TagPluginOfPost').find({ _id: uuidTagCSS })
+  if (res && res.data && res.data[0] && res.data[0].tags) {
+    let tags = res.data[0].tags;
+    let styList = []
+    tags.forEach(e => {
+      if (e in info) {
+        info[e].forEach(x => {
+          styList.push(x)
+        })
+      }
+    })
+    renderStyl(styList, (css) => {
+      setTagPluginCSS(uuidTagCSS, css)
+    })
+  } else {
+    renderTagCSSAllPage(info)
+  }
+}
+
+function generateTagCSS(data) {
+  if (!hexo.theme.config.plugins.tag_plugin_load_on_demand.enable) {
+    return data
+  }
+  let uuidTagCSS = hexo.createUuid()
+  data.uuidTagCSS = uuidTagCSS
+  let tagList = findTags(data._content)
+  insertTagCSS(uuidTagCSS, tagList)
+  return data;
+}
+
+function getTagCSS(page) {
+  if (!hexo.theme.config.plugins.tag_plugin_load_on_demand.enable) {
+    return
+  }
+  updateTagCSS(page.uuidTagCSS)
+  let TagPluginCSS = hexo.locals.get('TagPluginCSS')
+  if (TagPluginCSS) {
+    if (TagPluginCSS[page.uuidTagCSS]) {
+      return TagPluginCSS[page.uuidTagCSS]
+    } else {
+      return TagPluginCSS["AllPage"]
+    }
+  }
+}
+hexo.extend.filter.register("before_generate", function () {
+  if (!hexo.theme.config.plugins.tag_plugin_load_on_demand.enable) {
+    return
+  }
+  let arg = process.argv[2];
+  if (arg != "s" && arg != "server") {
+    return
+  }
+  // 只执行一次
+  if (hexo.locals.get('TagCSSbeforeFlag')) {
+    return
+  }
+  hexo.locals.set('TagCSSbeforeFlag', function () {
+    return 1
+  });
+  let info = getTagPluginCSSInfo()
+  hexo.database.model('TagPluginOfPost').forEach(x => {
+    if (x.tags) {
+      let tags = x.tags;
+      let styList = []
+      tags.forEach(e => {
+        if (e in info) {
+          info[e].forEach(x => {
+            styList.push(x)
+          })
+        }
+      })
+      renderStyl(styList, (css) => {
+        setTagPluginCSS(x._id, css)
+      })
+    }
+  })
+  renderTagCSSAllPage(info)
+});
+hexo.extend.filter.register('before_post_render', generateTagCSS)
+hexo.extend.helper.register("TagCSS", getTagCSS);