hexo-adsense 1.0.21 → 1.0.25

package/packages/hexo-extend-injector2/lib/bundle/handle-data-pre.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * 兼容以前的版本 v0.2
+ * injector.register('css', {text: '.book{font-size:2rem}'});
+ * injector.register('css', {path: 'xxxx.css'});
+ */
+
+const {resolve} = require('path');
+
+module.exports = (ctx, data, suffixes = []) => {
+  if (data.path) {
+    data.value = () => ctx.render.render({path: resolve(ctx.base_dir, data.path)});
+    return;
+  }
+  if (data.text) {
+    data.value = data.text;
+    return;
+  }
+  if (typeof data.value === 'string') {
+    const str = data.value;
+    for (const suffix of suffixes) {
+      if (str.endsWith(suffix)) {
+        data.value = () => ctx.render.render({path: resolve(ctx.base_dir, str)});
+        return;
+      }
+    }
+  }
+};

package/packages/hexo-extend-injector2/lib/bundle/js-bundle.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const handleDataPre = require('./handle-data-pre');
+const jsGenerator = require('./js-generator');
+
+const loadJsScript = (ctx, injector, config) => {
+  const { generator } = ctx.extend;
+  const { REGISTER_JS } = injector.order;
+
+  const url_for = require('hexo-util').url_for.bind(ctx);
+  injector.register('body-end', {
+    value: `<script src="${url_for(config.path)}"></script>`,
+    priority: REGISTER_JS
+  });
+
+  generator.register('js-bundler', () => {
+    return {
+      path: config.path,
+      data: jsGenerator(injector, config.options)
+    };
+  });
+};
+
+module.exports = (ctx, injector) => {
+
+  const config = injector.config.js;
+
+  if (!config.enable) return;
+
+  const { filter } = ctx.extend;
+
+  let isLoadJsScript = false;
+
+  filter.register('injector2:register-js', data => {
+    if (!isLoadJsScript) {
+      loadJsScript(ctx, injector, config);
+      isLoadJsScript = true;
+    }
+    handleDataPre(ctx, data, ['.js']);
+  });
+
+};

package/packages/hexo-extend-injector2/lib/bundle/js-generator.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const { minify } = require('terser');
+
+module.exports = (injector, options) => () => {
+  return Promise.all(injector.get('js').toPromise())
+    .then(values => values.join('\n'))
+    .then(source => minify(source, options))
+    .then(result => result.code);
+};

package/packages/hexo-extend-injector2/lib/default-config.js

@@ -0,0 +1,52 @@
+'use strict';
+
+module.exports = {
+
+  /**
+   * Injector Point
+   * If helper used, it will set injector_point_<key> to true
+   */
+  disable_default_point: false,
+  injector_point_headbegin: false,
+  injector_point_headend: false,
+  injector_point_bodybegin: false,
+  injector_point_bodyend: false,
+
+  /**
+   * NexT Plugin
+   */
+  load_next_compatible: true,
+  load_next_plugin: true,
+
+  /**
+   * Js bundler config, use terser
+   */
+  js: {
+    enable: true,
+    path: 'js/injector.js',
+    options: {}
+  },
+
+  /**
+   * CSS bundler config, use clean css
+   */
+  css: {
+    enable: true,
+    path: {
+      default: {
+        path: 'css/injector/main.css',
+        link: 'load'
+      },
+      dark: {
+        path: 'css/injector/dark.css',
+        link: 'preload'
+      },
+      light: {
+        path: 'css/injector/light.css',
+        link: 'preload'
+      }
+    },
+    options: {}
+  }
+
+};

package/packages/hexo-extend-injector2/lib/filter.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const injectFilter = injector => (data, locals) => {
+
+  function inject(data, pattern, flag, isBegin = true) {
+    if (injector.config[`injector_point_${injector.formatKey(flag)}`]) return data;
+    const code = injector.get(flag, {context: locals}).text();
+    if (!code.length) return data;
+    return data.replace(pattern, str => { return isBegin ? str + code : code + str; });
+  }
+
+  // Inject head_begin
+  data = inject(data, /<head.*?>/, 'head_begin', true);
+  // Inject head_end
+  data = inject(data, '</head>', 'head_end', false);
+  // Inject body_begin
+  data = inject(data, /<body.*?>/, 'body_begin', true);
+  // Inject body_end
+  data = inject(data, '</body>', 'body_end', false);
+
+  return data;
+};
+
+module.exports = injectFilter;

package/packages/hexo-extend-injector2/lib/helper/injector.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = (injector, ctx) => point => {
+  injector.config[`injector_point_${injector.formatKey(point)}`] = true;
+  return injector.get(point, { context: ctx });
+};

package/packages/hexo-extend-injector2/lib/helper/next-inject.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const injectorHelper = require('./injector');
+
+module.exports = (injector, ctx) => point => {
+  const nextInject = ctx.theme.injects[point]
+    .map(item => ctx.partial(item.layout, item.locals, item.options))
+    .join('');
+  let injector2 = injectorHelper(injector, ctx)(point).text();
+  if (point === 'head') {
+    injector2 += injectorHelper(injector, ctx)('head-end').text();
+  }
+  return nextInject + injector2;
+};

package/packages/hexo-extend-injector2/lib/injector.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const order = require('./order');
+const defaultConfig = require('./default-config');
+const { mergeWith } = require('lodash');
+// const { join } = require('path');
+// const { readFileSync } = require('fs');
+class Injector {
+  constructor(ctx) {
+    this._store = {};
+    this._run = {};
+    this._ctx = ctx;
+    this.order = order;
+    this.config = mergeWith(defaultConfig, ctx.config.injector, (objValue, srcValue) => {
+      if (Array.isArray(objValue)) {
+        return srcValue;
+      }
+    });
+  }
+
+  clean() {
+    this._run = {};
+  }
+
+  get(entry, options) {
+    entry = this.formatKey(entry);
+    options = Object.assign({context: this._ctx}, options);
+    const ctx = options.context;
+
+    const _storeEntries = Array.from(this._store[entry] || []);
+    const _runEntries = Array.from(this._run[entry] || []);
+
+    const list = () => _storeEntries.concat(_runEntries)
+      .filter(item => item.predicate(ctx, options))
+      .sort((a, b) => a.priority - b.priority);
+
+    const rendered = () => list()
+      .map(item => {
+        const renderItem = Object.assign({}, item);
+        if (typeof item.value === 'function') {
+          renderItem.value = item.value(ctx, options);
+        }
+        return renderItem;
+      });
+
+    const text = (sep = '') => rendered()
+      .map(item => item.value)
+      .join(sep);
+
+    const toPromise = () => rendered()
+      .map(item => Promise.resolve(item.value));
+
+    return {list, rendered, text, toPromise};
+  }
+
+  getSize(entry) {
+    entry = this.formatKey(entry);
+    const storeLen = this._store[entry] ? this._store[entry].length : 0;
+    const runLen = this._run[entry] ? this._run[entry].length : 0;
+    return storeLen + runLen;
+  }
+
+  register(entry, value, predicate = () => true, priority = 10, isRun) {
+    if (!entry) throw new TypeError('entry is required');
+    entry = this.formatKey(entry);
+
+    if (typeof value !== 'object') {
+      value = { value };
+    }
+    const options = Object.assign({ predicate, priority, isRun }, value);
+
+    const store = options.isRun ? this._run : this._store;
+    store[entry] = store[entry] || [];
+
+    if (typeof options.predicate === 'string') {
+      options.predicate = this.is(options.predicate);
+    }
+
+    this._ctx.execFilterSync('injector2:register', options, {args: [entry]});
+    this._ctx.execFilterSync(`injector2:register-${entry}`, options);
+
+    store[entry].push(options);
+    return this;
+  }
+
+  is(...types) {
+    return locals => {
+      for (const type of types) {
+        if (type === 'home' && locals.page.__index) return true;
+        if (type === 'post' && locals.page.__post) return true;
+        if (type === 'page' && locals.page.__page) return true;
+        if (type === 'archive' && locals.page.archive) return true;
+        if (type === 'category' && locals.page.category) return true;
+        if (type === 'tag' && locals.page.tag) return true;
+        if (locals.page[type]) return true;
+      }
+      return false;
+    };
+  }
+
+  formatKey(entry) {
+    return entry.replace(/[-| |_]/g, '').toLowerCase();
+  }
+
+  registerDefaultPoint() {
+    const { filter } = this._ctx.extend;
+    filter.register('_after_html_render', require('./filter')(this));
+  }
+
+  registerHelper() {
+    const self = this;
+    const { helper } = this._ctx.extend;
+    helper.register('injector', function(point) {
+      return require('./helper/injector')(self, this)(point);
+    });
+  }
+
+  registerNexTHelper() {
+    // 为了能覆盖主题中的注册，请在after_init中调用
+    const self = this;
+    const { helper } = this._ctx.extend;
+    helper.register('next_inject', function(point) {
+      return require('./helper/next-inject')(self, this)(point);
+    });
+  }
+}
+
+module.exports = Injector;

package/packages/hexo-extend-injector2/lib/load.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const Injector = require('./injector');
+const { join } = require('path');
+const { readFileSync } = require('fs');
+
+const loadInjector = ctx => {
+  const { filter } = ctx.extend;
+
+  // Init injector
+  const injector = new Injector(ctx);
+  ctx.extend.injector2 = injector;
+  ctx.on('generateBefore', () => {
+    injector.clean();
+  });
+  injector.registerHelper();
+
+  const { order, config } = injector;
+
+  if (!config.disable_default_point) {
+    injector.registerDefaultPoint();
+  }
+
+  // Load next plugin
+  const themeD = JSON.parse(readFileSync(join(ctx.theme_dir, 'package.json'), 'utf-8'));
+  if (themeD.name === 'hexo-theme-next') {
+    if (config.load_next_compatible) {
+      filter.register('after_init', () => {
+        injector.registerNexTHelper();
+      }, order.REGISTER_NEXT_HELPER);
+    }
+  } else {
+    if (config.load_next_plugin) {
+      require('./next')(ctx, injector);
+    }
+  }
+
+  // Build js and css bundler
+  require('./bundle/js-bundle')(ctx, injector);
+  require('./bundle/css-bundle')(ctx, injector);
+
+  return injector;
+};
+
+module.exports = loadInjector;

package/packages/hexo-extend-injector2/lib/next-point.js

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = {
+  views: [
+    'head',
+    'header',
+    'sidebar',
+    'postMeta',
+    'postBodyEnd',
+    'footer',
+    'bodyEnd',
+    'comment'
+  ],
+  styles: [
+    'variable',
+    'mixin',
+    'style'
+  ]
+};

package/packages/hexo-extend-injector2/lib/next.js

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * Compatible with next theme injector
+ */
+const points = require('./next-point');
+const fs = require('fs');
+const path = require('path');
+const defaultExtname = '.swig';
+
+// Defining stylus types
+class StylusInject {
+  constructor(base_dir) {
+    this.base_dir = base_dir;
+    this.files = [];
+  }
+  push(file) {
+    // Get absolute path base on hexo dir
+    this.files.push(path.resolve(this.base_dir, file));
+  }
+}
+
+// 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
+    this.raw(name, fs.readFileSync(path.resolve(this.base_dir, file), 'utf8'), ...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;
+}
+
+
+module.exports = (ctx, injector) => {
+
+  ctx.on('generateBefore', () => {
+    const injects = initInject(ctx.base_dir);
+    ctx.execFilterSync('theme_inject', injects);
+    // stylus
+    points.styles.forEach(type => {
+      injects[type].files.forEach(file => injector.register(type, file, () => true, 10, true));
+    });
+    // view
+    points.views.forEach(type => {
+      injects[type].raws
+        .map((injectObj, index) => {
+          const name = injectObj.name;
+          const layout = `inject/${type}/${name}`;
+          if (!ctx.theme.getView(layout)) {
+            ctx.theme.setView(layout, injectObj.raw);
+          }
+          const locals = injectObj.args[0];
+          const options = injectObj.args[1];
+          const order = injectObj.args[2] || index;
+          const value = ctx => ctx.partial(layout, locals, options);
+          return { value, priority: order, name, layout, locals, options, isRun: true };
+        })
+        .sort((a, b) => b.priority - a.priority)
+        .forEach(data => injector.register(type, data));
+    });
+  });
+};

package/packages/hexo-extend-injector2/lib/order.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = {
+  REGISTER_NEXT_HELPER: -1000,
+  REGISTER_VARIABLE: -1000,
+  REGISTER_STYLE: 1000,
+  REGISTER_JS: 1000,
+  REGISTER_CSS: 1000
+};

package/packages/hexo-extend-injector2/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "hexo-extend-injector2",
+  "version": "0.3.1",
+  "description": "🍀 a hexo extend to inject any code into theme.",
+  "main": "index.js",
+  "scripts": {
+    "eslint": "eslint .",
+    "test": "mocha test/index.js",
+    "p": "yarn --proxy=http://localhost:1080"
+  },
+  "directories": {
+    "lib": "./lib"
+  },
+  "files": [
+    "lib",
+    "index.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jiangtj/hexo-extend-injector2.git"
+  },
+  "keywords": [
+    "hexo",
+    "hexo-plugin"
+  ],
+  "author": "Mr.J",
+  "license": "LGPL-3.0",
+  "bugs": {
+    "url": "https://github.com/jiangtj/hexo-extend-injector2/issues"
+  },
+  "homepage": "https://github.com/jiangtj/hexo-extend-injector2#readme",
+  "dependencies": {
+    "clean-css": "^5.1.1",
+    "hexo-util": "^2.0.0",
+    "lodash": "^4.17.15",
+    "terser": "^5.0.0"
+  },
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "eslint": "^7.0.0",
+    "eslint-config-hexo": "^4.1.0",
+    "hexo": "^5.0.0",
+    "hexo-renderer-stylus": "^2.0.0",
+    "mocha": "^8.0.1"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  }
+}

package/packages/hexo-extend-injector2/renovate.json

@@ -0,0 +1,6 @@
+{
+  "extends": [
+    "config:base",
+    ":preserveSemverRanges"
+  ]
+}

package/packages/hexo-extend-injector2/test/.eslintrc

@@ -0,0 +1,3 @@
+{
+  "extends": "hexo/test"
+}

package/packages/hexo-extend-injector2/test/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const Hexo = require('hexo');
+// eslint-disable-next-line no-unused-vars
+const hexo = new Hexo(__dirname, { silent: true });
+
+describe('main', () => {
+  require('./lib/injector');
+  describe('helper', () => {
+    require('./lib/helper/injector');
+    require('./lib/helper/next-inject');
+  });
+  describe('bundler', () => {
+    require('./lib/bundle/bundle-js');
+    require('./lib/bundle/bundle-css');
+  });
+  require('./lib/hexo-compatible');
+});

package/packages/hexo-extend-injector2/test/lib/bundle/bundle-css.js

@@ -0,0 +1,86 @@
+'use strict';
+
+require('chai').should();
+const Hexo = require('hexo');
+const Injector = require('../../../lib/injector');
+const cssGenerator = require('../../../lib/bundle/css-generator');
+const { resolve } = require('path');
+
+describe('CSS Bundler', () => {
+  it('basic', () => {
+    const hexo = new Hexo();
+    const injector = new Injector(hexo);
+    require('../../../lib/bundle/css-bundle')(hexo, injector);
+    injector.register('css', 'a{--color: #6f42c1;}');
+    injector.register('css', 'body {\n  color: #abc;\n}\n');
+
+    injector.get('headend').text().should.eql('<link rel="stylesheet" type="text/css" href="/css/injector/main.css" />');
+
+    const exec = cssGenerator(injector, 'default');
+    return exec()
+      .then(result => {
+        result.should.eql('a{--color:#6f42c1}body{color:#abc}');
+      });
+  });
+
+  it('v0.2 scheme', () => {
+    const hexo = new Hexo();
+    const injector = new Injector(hexo);
+    require('../../../lib/bundle/css-bundle')(hexo, injector);
+    injector.register('css', { path: resolve(__dirname, 'test.css') });
+    injector.register('css', { text: () => 'body {\n  color: #abc;\n}\n' });
+
+    const exec = cssGenerator(injector, 'default');
+    return exec()
+      .then(result => {
+        result.should.eql('.book1{color:#0ff}body{color:#abc}');
+      });
+  });
+
+  it('dark mode', () => {
+    const hexo = new Hexo();
+    const injector = new Injector(hexo);
+    require('../../../lib/bundle/css-bundle')(hexo, injector);
+    injector.register('css', 'a{--color: #6f42c1;}');
+    injector.register('css', 'body {\n  color: #abc;\n}\n');
+    injector.register('css', {env: 'dark', value: 'a{--color: #bbb;}'});
+    injector.register('css', {env: 'dark', value: 'book{--color: #aaa;}'});
+
+    injector.get('headend').text().should.eql('<link rel="stylesheet" type="text/css" href="/css/injector/main.css" /><link rel="preload" as="style" href="/css/injector/dark.css" />');
+
+    let exec = cssGenerator(injector, 'default');
+    return exec()
+      .then(result => {
+        result.should.eql('a{--color:#6f42c1}body{color:#abc}');
+        exec = cssGenerator(injector, 'dark');
+        return exec();
+      })
+      .then(result => {
+        result.should.eql('a{--color:#bbb}book{--color:#aaa}');
+      });
+  });
+
+  it('light mode', () => {
+    const hexo = new Hexo();
+    const injector = new Injector(hexo);
+    require('../../../lib/bundle/css-bundle')(hexo, injector);
+    injector.register('css', 'a{--color: #6f42c1;}');
+    injector.register('css', 'body {\n  color: #abc;\n}\n');
+    injector.register('css', {env: 'light', value: 'a{--color: #bbb;}'});
+    injector.register('css', {env: 'light', value: 'book{--color: #aaa;}'});
+
+    injector.get('headend').text().should.eql('<link rel="stylesheet" type="text/css" href="/css/injector/main.css" /><link rel="preload" as="style" href="/css/injector/light.css" />');
+
+    let exec = cssGenerator(injector, 'default');
+    return exec()
+      .then(result => {
+        result.should.eql('a{--color:#6f42c1}body{color:#abc}');
+        exec = cssGenerator(injector, 'light');
+        return exec();
+      })
+      .then(result => {
+        result.should.eql('a{--color:#bbb}book{--color:#aaa}');
+      });
+  });
+
+});

package/packages/hexo-extend-injector2/test/lib/bundle/bundle-js.js

@@ -0,0 +1,36 @@
+'use strict';
+
+require('chai').should();
+const Hexo = require('hexo');
+const Injector = require('../../../lib/injector');
+const jsGenerator = require('../../../lib/bundle/js-generator');
+const { resolve } = require('path');
+
+describe('JS Bundler', () => {
+  it('basic', () => {
+    const hexo = new Hexo();
+    const injector = new Injector(hexo);
+    require('../../../lib/bundle/js-bundle')(hexo, injector);
+    injector.register('js', 'var a=1;');
+    injector.register('js', 'var b=1;');
+
+    injector.get('bodyend').text().should.eql('<script src="/js/injector.js"></script>');
+    const exec = jsGenerator(injector);
+    return exec().then(result => {
+      result.should.eql('var a=1,b=1;');
+    });
+  });
+
+  it('v0.2 scheme', () => {
+    const hexo = new Hexo();
+    const injector = new Injector(hexo);
+    require('../../../lib/bundle/js-bundle')(hexo, injector);
+    injector.register('js', { path: resolve(__dirname, 'test.js') });
+    injector.register('js', { text: () => 'var b=1;' });
+    const exec = jsGenerator(injector);
+    return exec().then(result => {
+      result.should.eql('var a=1,b=1;');
+    });
+  });
+
+});

package/packages/hexo-extend-injector2/test/lib/bundle/test.css

@@ -0,0 +1,3 @@
+.book1 {
+  color: aqua;
+}