npm install hexo-cli -g

hexo init blog

hexo s

hexo.on('ready', () => {
  hexo.log.info('Hello world!')
})

hexo cl

hexo s

npm install hexo-lazyload-image --save

"dependencies": {
    ...,
    "hexo-lazyload-image": "^1.1.3",
    ...
  }

hexo.on('ready', () => {
  hexo.log.info('Hello world!')
})

hexo.on("new", function (post) {
    console.log(`New post created:\n${post.content}\n${post.path}`);
});

hexo new test

hexo.on("exit", function () {
    console.log('Bye!');
});

hexo.on("generateBefore", function () {
    let posts = hexo.locals.get("posts");
    console.log(posts);
    console.log("\n----------------\n");
});
 
hexo.on("generateAfter", function () {
    let posts = hexo.locals.get("posts");
    console.log(posts);
    console.log("\n----------------\n");
});

hexo cl
hexo s

hexo.on("generateBefore", function () {
    console.log(hexo.route.list());
});
 
hexo.on("generateAfter", function () {
    console.log(hexo.route.list());
});

hexo s

'use strict';
 
if (!hexo.config.lazyload || !hexo.config.lazyload.enable) {
    return;
}
if (hexo.config.lazyload.onlypost) {
    hexo.extend.filter.register('after_post_render', require('./lib/process').processPost);
}
else {
    hexo.extend.filter.register('after_render:html', require('./lib/process').processSite);
}
hexo.extend.filter.register('after_render:html', require('./lib/addscripts').addScript);

if (!hexo.config.lazyload || !hexo.config.lazyload.enable) {
    return;
}

if (hexo.config.lazyload.onlypost) {
    hexo.extend.filter.register('after_post_render', require('./lib/process').processPost);
}
else {
    hexo.extend.filter.register('after_render:html', require('./lib/process').processSite);
}

hexo.extend.filter.register('after_render:html', require('./lib/addscripts').addScript);

'use strict';
 
const fs = require('hexo-fs');
 
function lazyProcess(htmlContent) {
    let defaultImagePath = __dirname + '/default-image.json';
    let loadingImage = this.config.lazyload.loadingImg;
 
    if (!loadingImage) {
        loadingImage = JSON.parse(fs.readFileSync(defaultImagePath)).default;
    }
 
    return htmlContent.replace(/<img(.*?)src="(.*?)"(.*?)>/gi, function (str, p1, p2) {
        // might be duplicate
        if(/data-original/gi.test(str)){
            return str;
        }
        if(/src="data:image(.*?)/gi.test(str)) {
            return str;
        }
        if(/no-lazy/gi.test(str)) {
            return str;
        }
        return str.replace(p2, loadingImage + '" data-original="' + p2);
    });
}
 
module.exports.processPost = function (data) {
    if (data.lazyimage !== 'no') {
        data.content = lazyProcess.call(this, data.content);
    }
    return data;
};
 
module.exports.processSite = function (htmlContent) {
    return lazyProcess.call(this, htmlContent);
};

module.exports.processPost = function (data) {
    if (data.lazyimage !== 'no') {
        data.content = lazyProcess.call(this, data.content);
    }
    return data;
};

module.exports.processSite = function (htmlContent) {
    return lazyProcess.call(this, htmlContent);
};

const fs = require('hexo-fs');
const UglifyJS = require('uglify-js');
const lazyLoadPath = __dirname + '/simple-lazyload.js';
const thirdPartyFixPath = __dirname + '/third-party-fix.js';
 
module.exports.addScript = function(htmlContent){
    let injectSetting = function () {
    return `
        <style>
            [bg-lazy] {
                background-image: none !important;
                background-color: #eee !important;
            }
        </style>
        <script>
            window.imageLazyLoadSetting = {
                isSPA: ${!!this.config.lazyload.isSPA},
                preloadRatio: ${this.config.lazyload.preloadRatio || 1},
                processImages: null,
            };
        </script>`;
    };
    let injectExtraScript = function (filePath) {
        if (!fs.exists(filePath)) throw new TypeError(filePath + ' not found!');
        let sourceCode = fs.readFileSync(filePath, { escape: true });
        return '<script>' + UglifyJS.minify(sourceCode).code + '</script>';
    };
    let appendScript = function(content, htmlContent) {
        let lastIndex = htmlContent.lastIndexOf('</body>');
        return htmlContent.substring(0, lastIndex) + content + htmlContent.substring(lastIndex, htmlContent.length);
    };
    if (/<\/body>/gi.test(htmlContent)) {
        htmlContent = appendScript(injectSetting.bind(this)(), htmlContent);
        htmlContent = appendScript(injectExtraScript(thirdPartyFixPath), htmlContent);
        htmlContent = appendScript(injectExtraScript(lazyLoadPath), htmlContent);
    }
    return htmlContent;
};

const assign = require('deep-assign');
 
// api url https://github.com/knsv/mermaid/blob/master/src/mermaidAPI.js
const config = {
  theme: 'forest',
  logLevel: 5,
  startOnLoad: true,
  arrowMarkerAbsolute: false,
  flowchart: {
    htmlLabels: true,
    useMaxWidth: true,
    curve: 'linear'
  },
  sequence: {
    diagramMarginX: 50,
    diagramMarginY: 10,
    actorMargin: 50,
    width: 150,
    height: 65,
    boxMargin: 10,
    boxTextMargin: 5,
    noteMargin: 10,
    messageMargin: 35,
    mirrorActors: true,
    bottomMarginAdj: 1,
    useMaxWidth: true
  },
  gantt: {
    titleTopMargin: 25,
    barHeight: 20,
    barGap: 4,
    topPadding: 50,
    leftPadding: 75,
    gridLineStartPadding: 35,
    fontSize: 11,
    fontFamily: '"Open-Sans", "sans-serif"',
    numberSectionStyles: 4,
    axisFormat: '%Y-%m-%d'
  },
  class: {},
  git: {}
};
 
hexo.config.mermaid = assign({
  version: '7.1.2',
  enable: true
},
  config,
  hexo.config.mermaid
);
 
hexo.extend.filter.register('before_post_render', require('./lib/render'), 9);

const reg = /(\s*)(`{3}) *(mermaid) *\n?([\s\S]+?)\s*(\2)(\n+|$)/g;
 
const ignore = data => {
  var source = data.source;
  var ext = source.substring(source.lastIndexOf('.')).toLowerCase();
  return ['.js', '.css', '.html', '.htm'].indexOf(ext) > -1;
}
 
module.exports = function (data) {
  const mermaidConfig = this.config.mermaid;
  let { enable } = mermaidConfig;
  enable = enable || false;
  if (!enable) {
    return;
  }
  if (!ignore(data)) {
    data.content = data.content
      .replace(reg, function (raw, start, startQuote, lang, content, endQuote, end) {
        return `${start}<pre class="mermaid">${content}</pre>${end}`;
      });
  }
};

hide_posts:
  # 是否启用 hexo-hide-posts 插件。
  enable: true
 
  # 用于标记隐藏文章的 front-matter 键。
  # 你可以根据需要修改过滤器名称。
  filter: hidden
 
  # 添加 "noindex" 元标签以防止隐藏文章被搜索引擎索引。
  noindex: true
 
  # 允许访问隐藏文章的生成器名单。
  # Hexo 中常见的生成器：'index', 'tag', 'category', 'archive', 'sitemap', 'feed'
  # allowlist_generators: []
 
  # 禁止访问隐藏文章的生成器名单。
  # 如果同时设置了允许名单，允许名单优先级更高。
  # blocklist_generators: ['*']

/* global hexo */
'use strict';
 
// Backward compatibility for v0.2.0
if (hexo.config.hide_posts) {
  const config = hexo.config.hide_posts;
  if (config.public_generators && !config.allowlist_generators) {
    config.allowlist_generators = config.public_generators;
  }
}
 
// Load plugin config
hexo.config.hide_posts = Object.assign({
  enable: true,
  filter: 'hidden',
  allowlist_generators: [],
  blocklist_generators: ['*'],
  allowlist_function: null,
  acl_function_per_post: null,
  hexo_7_compatibility_patch: hexo.version.startsWith('7'),
  noindex: true,
  noindex_tag: '<meta name="robots" content="noindex">',
  html_flag: '<!-- flag of hidden posts -->'
}, hexo.config.hide_posts);
 
const config = hexo.config.hide_posts;
 
if (!config.enable) {
  return;
}
 
// Ensure allowlist and blocklist are arrays
if (config.allowlist_generators && !Array.isArray(config.allowlist_generators)) {
  config.allowlist_generators = [config.allowlist_generators];
}
 
if (config.blocklist_generators && !Array.isArray(config.blocklist_generators)) {
  config.blocklist_generators = [config.blocklist_generators];
}
 
// Prepare hidden posts
hexo.extend.filter.register('before_generate', require('./lib/prepareHiddenPosts'));
 
// Apply patch for Hexo 7.0
hexo.extend.filter.register('before_generate', require('./lib/applyPatch'));
 
// Hook into generators
hexo.extend.filter.register('after_init', require('./lib/injectGenerators'));
 
// Add a command to get a list of all hidden posts.
// Usage: `$ hexo hidden:list`
hexo.extend.console.register(
  'hidden:list',
  'Show a list of all hidden articles.',
  require('./lib/getHiddenList')
);
 
// Append a special HTML tag to render result of hidden posts for future use.
hexo.extend.filter.register('after_post_render', data => {
  if (data[config.filter]) {
    data.content += config.html_flag;
  }
  return data;
});
 
// When `after_render:html` filter is triggered, no useful data but
// only a bunch of messy HTML string will be passed as argument.
// So we have to use the HTML flag set before in `after_post_render` filter
// to recognize hidden posts, and manipulate whatever we want.
if (config.noindex) {
  hexo.extend.filter.register('after_render:html', str => {
    if (str && str.includes(config.html_flag)) {
      str = str.replace('</title>', '</title>' + config.noindex_tag);
    }
    return str;
  });
}

/* global hexo */
 
'use strict';
 
hexo.extend.renderer.register('less', 'css', require('./lib/renderer'));

'use strict';
 
const less = require('less');
const { basename, dirname, join } = require('path');
const micromatch = require('micromatch');
 
async function lessFn(data) {
  const { route, theme } = this;
 
  theme.config.less = Object.assign({
    paths: [],
    options: {}
  }, theme.config.less);
 
  const config = theme.config.less;
  const { options, paths: pathsCfg } = config;
  const cwd = process.cwd();
  const routeList = route.list();
  const tmpPaths = typeof pathsCfg === 'string' ? [pathsCfg] : pathsCfg;
 
  const paths = tmpPaths.filter(path => !micromatch.scan(path).isGlob)
    .map(path => join(cwd, path)); // assuming paths are relative from the root of the project;
  const match = micromatch(routeList, config.paths).map(path => join(cwd, dirname(path)));
  paths.push(...match, dirname(data.path));
 
  const result = await less.render(data.text, {
    paths,
    filename: basename(data.path),
    ...options
  });
 
  return result.css;
}
 
lessFn.disableNunjucks = true;
 
module.exports = lessFn;

/* global hexo */
 
'use strict';
 
hexo.config.markdown = Object.assign({
  preset: 'default',
  render: {},
  anchors: {}
}, hexo.config.markdown);
 
hexo.config.markdown.render = Object.assign({
  html: true,
  xhtmlOut: false,
  breaks: true,
  linkify: true,
  typographer: true,
  quotes: '“”‘’'
}, hexo.config.markdown.render);
 
hexo.config.markdown.anchors = Object.assign({
  level: 2,
  collisionSuffix: '',
  permalink: false,
  permalinkClass: 'header-anchor',
  permalinkSide: 'left',
  permalinkSymbol: '¶',
  case: 0,
  separator: '-'
}, hexo.config.markdown.anchors);
 
const Renderer = require('./lib/renderer');
const renderer = new Renderer(hexo);
 
renderer.disableNunjucks = Boolean(hexo.config.markdown.disableNunjucks);
 
function render(data, options) {
  return renderer.render(data, options);
}
 
hexo.extend.renderer.register('md', 'html', render, true);
hexo.extend.renderer.register('markdown', 'html', render, true);
hexo.extend.renderer.register('mkd', 'html', render, true);
hexo.extend.renderer.register('mkdn', 'html', render, true);
hexo.extend.renderer.register('mdwn', 'html', render, true);
hexo.extend.renderer.register('mdtxt', 'html', render, true);
hexo.extend.renderer.register('mdtext', 'html', render, true)

/* global hexo */
 
'use strict';
 
var assign = require('object-assign');
 
hexo.config.index_generator = assign({
  per_page: typeof hexo.config.per_page === 'undefined' ? 10 : hexo.config.per_page,
  order_by: '-date'
}, hexo.config.index_generator);
 
hexo.extend.generator.register('index', require('./lib/generator'));

'use strict';
var pagination = require('hexo-pagination');
module.exports = function(locals){
  var config = this.config;
  var posts = locals.posts;
    posts.data = posts.data.sort(function(a, b) {
        if(a.top && b.top) { // 两篇文章top都有定义
            if(a.top == b.top) return b.date - a.date; // 若top值一样则按照文章日期降序排
            else return b.top - a.top; // 否则按照top值降序排
        }
        else if(a.top && !b.top) { // 以下是只有一篇文章top有定义，那么将有top的排在前面（这里用异或操作居然不行233）
            return -1;
        }
        else if(!a.top && b.top) {
            return 1;
        }
        else return b.date - a.date; // 都没定义按照文章日期降序排
    });
  var paginationDir = config.pagination_dir || 'page';
  return pagination('', posts, {
    perPage: config.index_generator.per_page,
    layout: ['index', 'archive'],
    format: paginationDir + '/%d/',
    data: {
      __index: true
    }
  });
};

search:
  path: search.xml
  field: post
  content: true
  template: ./search.xml

var merge = require('utils-merge');
var pathFn = require('path');
 
var config = hexo.config.search = merge({
	path: 'search.xml',
	field: 'post'
}, hexo.config.search);
 
// Set default search path
if (!config.path){
  config.path = 'search.xml';
}
 
// Add extension name if don't have
if (!pathFn.extname(config.path)){
  config.path += '.xml';
}
 
if (pathFn.extname(config.path)=='.xml') {
	hexo.extend.generator.register('xml', require('./lib/xml_generator'));
}
 
if (pathFn.extname(config.path)=='.json') {    
	hexo.extend.generator.register('json', require('./lib/json_generator'));
}

'use strict';
var nunjucks = require('nunjucks');
var env = new nunjucks.Environment();
var pathFn = require('path');
var fs = require('fs');
 
// 添加自定义过滤器
env.addFilter('uriencode', function(str) {
	return encodeURI(str);
});
 
env.addFilter('noControlChars', function(str) {
	return str && str.replace(/[\x00-\x1F\x7F]/g, '');
});
 
// 导出主函数。locals 是 Hexo 提供的上下文数据，包含所有文章、页面等信息。
module.exports = function(locals){
    // 读取和编译模板
  var config = this.config;
  var searchConfig = config.search;
 
  var searchTmplSrc = searchConfig.template || pathFn.join(__dirname, '../templates/search.xml');
  var searchTmpl = nunjucks.compile(fs.readFileSync(searchTmplSrc, 'utf8'), env);
 
  // 解析搜索范围
  var template = searchTmpl;
  var searchfield = searchConfig.field;
  var content = searchConfig.content;
  if (content == undefined) content=true;
 
  var posts, pages;
 
  if(searchfield.trim() != ''){
    searchfield = searchfield.trim();
    if(searchfield == 'post'){
      posts = locals.posts.sort('-date');
    }else if(searchfield == 'page'){
      pages = locals.pages;
    }else{
      posts = locals.posts.sort('-date');
      pages = locals.pages;
    }
  }else{
    posts = locals.posts.sort('-date');
  }
 
  // 处理根路径
  var rootURL;
  if (config.root == null){
    rootURL = "/";
  }else{
    rootURL = config.root;
  }
 
  // 渲染模板并返回结果
  var xml = template.render({
    config: config,  // 全局配置。
    posts: posts,  // 搜索范围内的文章和页面。
    pages: pages,
    content: content,  // 文章内容
    url: rootURL  // 文章根路径
  });
 
  return {
    path: searchConfig.path,
    data: xml
  };
};

/* global hexo */
'use strict';
 
hexo.extend.deployer.register('git', require('./lib/deployer'));

/**
 * Button
 * {% btn url text icon option %}
 * option: color outline center block larger
 * color : default/blue/pink/red/purple/orange/green
 */
 
'use strict'
 
const urlFor = require('hexo-util').url_for.bind(hexo)
 
const btn = args => {
  args = args.join(' ').split(',')
  const [url = '', text = '', icon = '', option = ''] = args.map(arg => arg.trim())
 
  return `<a class="btn-beautify ${option}" href="${urlFor(url)}" 
  title="${text}">${icon.length ? `<i class="${icon}"></i>` : ''}${text.length ? `<span>${text}</span>` : ''}</a>`
}
 
hexo.extend.tag.register('btn', btn, { ends: false })

<a class="btn-beautify ${option}" href="${urlFor(url)}" 
  title="${text}">${icon.length ? `<i class="${icon}"></i>` : ''}${text.length ? `<span>${text}</span>` : ''}</a>