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

package/scripts/events/lib/render-stylus.js

@@ -0,0 +1,78 @@
+// hexo.renderStylus 渲染 Stylus 的工具函数
+// hexo.createUuid   创建 uuid
+
+const stylus = require("stylus");
+const Promise = require("bluebird");
+
+module.exports = hexo => {
+  hexo.renderStylus = async (str) => {
+    /**************************************************************************** */
+    // from https://github.com/hexojs/hexo-renderer-stylus/blob/8f63a5e1ad886466ce59532978dfa34b4b3c6dc7/lib/renderer.js#L5
+    function getProperty(obj, name) {
+      name = name.replace(/\[(\w+)\]/g, ".$1").replace(/^\./, "");
+      const split = name.split(".");
+      let key = split.shift();
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) return "";
+      let result = obj[key];
+      const len = split.length;
+      if (!len) return result || "";
+      if (typeof result !== "object") return "";
+      for (let i = 0; i < len; i++) {
+        key = split[i];
+        if (!Object.prototype.hasOwnProperty.call(result, key)) return "";
+        result = result[split[i]];
+        if (typeof result !== "object") return result;
+      }
+      return result;
+    }
+    function defineConfig(style) {
+      style.define("hexo-config", (data) => {
+        return getProperty(hexo.theme.config, data.val);
+      });
+    }
+    /**************************************************************************** */
+    return new Promise((resolve) => {
+      return stylus(str)
+        .use(defineConfig)
+        .include(hexo.theme.context.theme_dir + "source/css/")
+        .render(function (err, css) {
+          if (err) throw err;
+          resolve(css);
+          return css;
+        });
+    })
+  }
+  hexo.createUuid = () => {
+    let s = [];
+    const hexDigits = '0123456789abcdef';
+    for (let i = 0; i < 36; i++) {
+      s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
+    }
+    s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1);
+    s[8] = s[13] = s[18] = s[23] = '-';
+    return s.join('');
+  };
+  hexo.merge = merge;
+  hexo.getType = getType;
+};
+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;
+}
+function getType(file){
+  var filename=file;
+  var index1=filename.lastIndexOf(".");
+  var index2=filename.length;
+  var type=filename.substring(index1+1,index2);
+  return type;
+}

package/scripts/events/lib/stellar-tag-utils.js

@@ -0,0 +1,76 @@
+/**
+ * utils.js v1 | https://github.com/xaoxuu/hexo-theme-stellar/
+ */
+
+// stellar 标签插件 命令解析器
+
+
+'use strict';
+
+module.exports = hexo => {
+  hexo.args = {
+    map: (args, keys, others) => {
+      if (Array.isArray(args) == false) {
+        return args;
+      }
+      var map = {others: Array()};
+      args.forEach((arg, i) => {
+        let kv = arg.trim();
+        if (kv.includes('://') && kv.split(':').length == 2) {
+          // 纯 url
+          map.others.push(kv);
+        } else {
+          kv = kv.split(':');
+          if (kv.length > 1) {
+            if (keys.includes(kv[0]) == true) {
+              map[kv.shift()] = kv.join(':');
+            } else {
+              map.others.push(kv.join(':'));
+            }
+          } else if (kv.length == 1) {
+            map.others.push(kv[0]);
+          }
+        }
+      });
+      // 解析不带 key 的参数
+      if (others && others.length > 0 && map.others.length > 0) {
+        if (Array.isArray(others) == false) {
+          others = [others];
+        }
+        others.forEach((arg, i) => {
+          map[arg] = map.others.shift();
+        });
+        // 最后一段合并到最后一个参数中
+        if (map.others.length > 0) {
+          map[others[others.length-1]] += ' ' + map.others.join(' ');
+          map.others = [];
+        }
+      }
+      return map;
+    },
+    joinTags: (args, keys) => {
+      if (Array.isArray(keys) == false) {
+        keys = [keys];
+      }
+      var ret = [];
+      keys.forEach((key, i) => {
+        if (args[key] && args[key].length > 0) {
+          ret.push(key + '="' + args[key] + '"');
+        }
+      });
+      return ret;
+    },
+    joinURLParams: (args, keys) => {
+      if (Array.isArray(keys) == false) {
+        keys = [keys];
+      }
+      var ret = [];
+      keys.forEach((key, i) => {
+        if (args[key] && args[key].length > 0) {
+          ret.push(key + '=' + args[key]);
+        }
+      });
+      return ret.join('&');
+    }
+  };
+};

package/scripts/filters/content-visibility.js

@@ -0,0 +1,25 @@
+// https://web.dev/content-visibility/
+// https://www.caniuse.com/?search=content-visibility
+// 在文章内容渲染时将每两个 <h2> 之间的内容分为一块 用 <div class="post-story"></div> 包裹起来。然后为 .post-story 声明 content-visibility: auto
+hexo.extend.filter.register('after_post_render', function (data) {
+  let dataList = data.content.split('\n')
+  let mydata = ``
+  let flag = 1
+  dataList.forEach(e => {
+    let yy = e.replace(/<h2.*?>.*?<\/h2>/, function (str) {
+      if (flag) {
+        flag = 0
+        return `<div class="story post-story">` + str
+      } else {
+        return `</div><div class="story post-story">` + str
+      }
+    })
+    mydata += yy
+    mydata += "\n"
+  });
+  if (!flag) {
+    mydata += `</div>`
+  }
+  data.content = mydata
+  return data;
+});

package/scripts/filters/replace.js

@@ -0,0 +1,15 @@
+/* global hexo */
+
+'use strict';
+
+hexo.extend.filter.register('after_render:html', function(data) {
+  if (hexo.theme.config.replace) {
+    hexo.theme.config.replace.forEach(e => {
+      let s = e.split(" => ")
+      let a = s[0]
+      let b = s[1]
+      data = data.replace(new RegExp(a,"g"), b);
+    });
+  }
+  return data;
+},999999999999);

package/scripts/{z-lazyload/lib/process.js → filters/z-lazyload.js}

@@ -52,16 +52,19 @@ function lazyProcess(htmlContent, target) {
     if (loadingImg) {
       return result.replace(p2, p2 + '" class="lazyload placeholder" ' + 'data-srcset="' + p2 + '" srcset="' + loadingImg);
     }
-    return result.replace(p2, p2 + '" class="lazyload" ' + 'data-srcset="' + p2 + '" srcset="' + 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAAaADAAQAAAABAAAAAQAAAADa6r/EAAAAC0lEQVQIHWNgAAIAAAUAAY27m/MAAAAASUVORK5CYII=');
+    return result.replace(p2, p2 + '" class="lazyload" ' + 'data-srcset="' + p2 + '" srcset="' + 'data:image/gif;base64,R0lGODlhAQABAIAAAP///////yH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==');
 
   });
 }
 
-module.exports.processPost = function(data) {
+let processPost = function(data) {
   data.content = lazyProcess.call(this, data.content, 'post');
   return data;
 };
 
-module.exports.processSite = function(htmlContent) {
+let processSite = function(htmlContent) {
   return lazyProcess.call(this, htmlContent, 'site');
 };
+
+hexo.extend.filter.register('after_post_render', processPost);
+hexo.extend.filter.register('after_render:html', processSite);

package/scripts/helpers/custom-files.js

@@ -0,0 +1,165 @@
+// Custom Files 自定义文件   --- Modified From NexT ---
+
+const fs = require('hexo-fs');
+const path = require('path');
+const defaultExtname = '.ejs';
+let points = {
+  styles: [
+    "first",
+    "style",
+    "dark",
+    "darkVar",
+  ],
+  views: [
+    "headBegin",
+    "headEnd",
+    "header",
+    "side",
+    "topMeta",
+    "bottomMeta",
+    "footer",
+    "postEnd",
+    "bodyBegin",
+    "bodyEnd",
+  ]
+}
+// hexo s 和 hexo server 时监听自定义文件变动
+function watchFile(path) {
+  let arg = process.argv[2];
+  if (arg == "s" || arg == "server") {
+    fs.watch(path)
+  }
+}
+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;
+}
+hexo.merge = merge;
+hexo.extend.filter.register('theme_inject', injects => {
+
+  let filePath = {}
+  points.styles.forEach(key => {
+    filePath[key] = "source/_volantis/" + key + ".styl"
+  });
+  points.views.forEach(key => {
+    filePath[key] = "source/_volantis/" + key + defaultExtname
+  });
+  filePath = hexo.merge(filePath, hexo.theme.config.custom_files)
+  // console.log(filePath);
+  // console.log(hexo.theme.config.custom_files);
+
+
+  points.styles.forEach(key => {
+    if (filePath[key]) {
+      injects[key].push(filePath[key]);
+    }
+  });
+  points.views.forEach(key => {
+    if (filePath[key]) {
+      injects[key].file('custom', filePath[key]);
+    }
+  });
+}, 99);
+hexo.extend.helper.register('volantis_inject', function (point) {
+  if (this.theme.injects[point]) {
+    return this.theme.injects[point]
+      .map(item => this.partial(item.layout, item.locals, item.options))
+      .join('');
+  }
+  return []
+});
+hexo.on('generateBefore', function () {
+  hexo.theme.config.custom = {};
+  // Defining stylus types
+  class StylusInject {
+    constructor(base_dir) {
+      this.base_dir = base_dir;
+      this.files = [];
+    }
+    push(file) {
+      // Get absolute path base on hexo dir
+      let temp_path = path.resolve(this.base_dir, file)
+      watchFile(temp_path)
+      if (fs.existsSync(temp_path)) {
+        this.files.push(temp_path);
+      }
+    }
+  }
+  // Defining view types
+  class ViewInject {
+    constructor(base_dir) {
+      this.base_dir = base_dir;
+      this.raws = [];
+    }
+    raw(name, raw, ...args) {
+      // Set default extname
+      if (path.extname(name) === '') {
+        name += defaultExtname;
+      }
+      this.raws.push({ name, raw, args });
+    }
+    file(name, file, ...args) {
+      // Set default extname from file's extname
+      if (path.extname(name) === '') {
+        name += path.extname(file);
+      }
+      // Get absolute path base on hexo dir
+      let temp_path = path.resolve(this.base_dir, file)
+      let temp_raw = ""
+      watchFile(temp_path)
+      if (fs.existsSync(temp_path)) {
+        temp_raw = fs.readFileSync(temp_path)
+      }
+      this.raw(name, temp_raw, ...args);
+    }
+  }
+  // Init injects
+  function initInject(base_dir) {
+    const injects = {};
+    points.styles.forEach(item => {
+      injects[item] = new StylusInject(base_dir);
+    });
+    points.views.forEach(item => {
+      injects[item] = new ViewInject(base_dir);
+    });
+    return injects;
+  }
+  hexo.theme.config.injects = {};
+  const injects = initInject(hexo.base_dir);
+  hexo.execFilterSync('theme_inject', injects);
+  points.styles.forEach(type => {
+    hexo.theme.config.injects[type] = injects[type].files;
+  });
+  // Inject views
+  points.views.forEach(type => {
+    const configs = Object.create(null);
+    hexo.theme.config.injects[type] = [];
+    // Add or override view.
+    injects[type].raws.forEach((injectObj, index) => {
+      const name = `inject/${type}/${injectObj.name}`;
+      hexo.theme.setView(name, injectObj.raw);
+      configs[name] = {
+        layout: name,
+        locals: injectObj.args[0],
+        options: injectObj.args[1],
+        order: injectObj.args[2] || index
+      };
+    });
+    // Views sort.
+    hexo.theme.config.injects[type] = Object.values(configs).sort((x, y) => x.order - y.order)
+    // console.log(injects);
+  });
+});
+
+
+

package/scripts/helpers/first-style.js

@@ -0,0 +1,19 @@
+// 将首屏样式 first.styl 硬编码到HTML页面
+"use strict";
+const fs = require("hexo-fs");
+
+function generateFirstCSS() {
+  let s = fs.readFileSync(
+    hexo.theme.context.theme_dir + "source/css/first.styl"
+  );
+  hexo.renderStylus(s).then((css)=>{
+    hexo.locals.set('FirstCSS', function(){
+      return css
+    });
+  })
+}
+function getFirstCSS() {
+  return hexo.locals.get('FirstCSS');
+}
+hexo.extend.filter.register("before_generate", generateFirstCSS);
+hexo.extend.helper.register("FirstCSS", getFirstCSS);

package/scripts/helpers/head/autoCanonical.js

@@ -0,0 +1,15 @@
+/**
+* hexo-auto-canonical
+* https://github.com/hyunseob/hexo-auto-canonical.git
+* Copyright (c) 2015, HyunSeob
+* Licensed under the MIT license.
+*/
+
+'use strict';
+
+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/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,101 @@
+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}">`
+});
+
+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) {
+    if (config.description) {
+      description = config.description
+    }else{
+      description = config.title
+    }
+  }
+  description += ` - ${config.author} - ${config.title}`
+  return `<meta desc name="description" content="${description}">`
+});
+// open_graph() 函数会生成一个 description 标签???  https://github.com/hexojs/hexo/blob/92b979f4a3fa8714aebd3d11c3295d466b870905/lib/plugins/helper/open_graph.js#L98
+// 移除 open_graph() 函数会生成的 description
+hexo.extend.filter.register('after_render:html', function(data) {
+  data = data.replace(/<meta name="description".*>/g, "");
+  return data;
+},99);

package/scripts/{related_posts/index.js → helpers/related-posts.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 {