⚡ Improved the comments plug-in load function, close #12

static/js/third-party/analytics/baidu-analytics.js

@@ -0,0 +1,7 @@
+/* global _hmt */
+
+if (!window._hmt) window._hmt = [];
+
+document.addEventListener('pjax:success', () => {
+  _hmt.push(['_trackPageview', location.pathname]);
+});

static/js/third-party/analytics/google-analytics.js

@@ -0,0 +1,35 @@
+/* global CONFIG, dataLayer, gtag */
+
+if (!CONFIG.google_analytics.only_pageview) {
+  if (CONFIG.hostname === location.hostname) {
+    window.dataLayer = window.dataLayer || [];
+    window.gtag = function() {
+      dataLayer.push(arguments);
+    };
+    gtag('js', new Date());
+    gtag('config', CONFIG.google_analytics.tracking_id);
+
+    document.addEventListener('pjax:success', () => {
+      gtag('event', 'page_view', {
+        page_location: location.href,
+        page_path    : location.pathname,
+        page_title   : document.title
+      });
+    });
+  }
+} else {
+  const sendPageView = () => {
+    if (CONFIG.hostname !== location.hostname) return;
+    const uid = localStorage.getItem('uid') || (Math.random() + '.' + Math.random());
+    localStorage.setItem('uid', uid);
+    navigator.sendBeacon('https://www.google-analytics.com/collect', new URLSearchParams({
+      v  : 1,
+      tid: CONFIG.google_analytics.tracking_id,
+      cid: uid,
+      t  : 'pageview',
+      dp : encodeURIComponent(location.pathname)
+    }));
+  };
+  document.addEventListener('pjax:complete', sendPageView);
+  sendPageView();
+}

static/js/third-party/analytics/growingio.js

@@ -0,0 +1,10 @@
+/* global CONFIG, gio */
+
+if (!window.gio) {
+  window.gio = function() {
+    (window.gio.q = window.gio.q || []).push(arguments);
+  };
+}
+
+gio('init', `${CONFIG.growingio_analytics}`, {});
+gio('send');

static/js/third-party/chat/chatra.js

@@ -0,0 +1,19 @@
+/* global CONFIG, Chatra */
+
+(function() {
+  if (CONFIG.chatra.embed) {
+    window.ChatraSetup = {
+      mode    : 'frame',
+      injectTo: CONFIG.chatra.embed
+    };
+  }
+
+  window.ChatraID = CONFIG.chatra.id;
+
+  const chatButton = document.querySelector('.sidebar-button button');
+  if (chatButton) {
+    chatButton.addEventListener('click', () => {
+      Chatra('openChat', true);
+    });
+  }
+})();

static/js/third-party/chat/gitter.js

@@ -0,0 +1,5 @@
+/* global CONFIG */
+
+((window.gitter = {}).chat = {}).options = {
+  room: CONFIG.gitter.room
+};

static/js/third-party/chat/tidio.js

@@ -0,0 +1,10 @@
+/* global tidioChatApi */
+
+(function() {
+  const chatButton = document.querySelector('.sidebar-button button');
+  if (chatButton) {
+    chatButton.addEventListener('click', () => {
+      tidioChatApi.open();
+    });
+  }
+})();

static/js/third-party/fancybox.js

@@ -0,0 +1,38 @@
+document.addEventListener('page:loaded', () => {
+
+  /**
+   * Wrap images with fancybox.
+   */
+  document.querySelectorAll('.post-body :not(a) > img, .post-body > img').forEach(element => {
+    const $image = $(element);
+    const imageLink = $image.attr('data-src') || $image.attr('src');
+    const $imageWrapLink = $image.wrap(`<a class="fancybox fancybox.image" href="${imageLink}" itemscope itemtype="http://schema.org/ImageObject" itemprop="url"></a>`).parent('a');
+    if ($image.is('.post-gallery img')) {
+      $imageWrapLink.attr('data-fancybox', 'gallery').attr('rel', 'gallery');
+    } else if ($image.is('.group-picture img')) {
+      $imageWrapLink.attr('data-fancybox', 'group').attr('rel', 'group');
+    } else {
+      $imageWrapLink.attr('data-fancybox', 'default').attr('rel', 'default');
+    }
+
+    const imageTitle = $image.attr('title') || $image.attr('alt');
+    if (imageTitle) {
+      // Do not append image-caption if pandoc has already created a figcaption
+      if (!$imageWrapLink.next('figcaption').length) {
+        $imageWrapLink.append(`<p class="image-caption">${imageTitle}</p>`);
+      }
+      // Make sure img title tag will show correctly in fancybox
+      $imageWrapLink.attr('title', imageTitle).attr('data-caption', imageTitle);
+    }
+  });
+
+  $.fancybox.defaults.hash = false;
+  $('.fancybox').fancybox({
+    loop   : true,
+    helpers: {
+      overlay: {
+        locked: false
+      }
+    }
+  });
+});

static/js/third-party/math/katex.js

@@ -0,0 +1,7 @@
+/* global NexT, CONFIG */
+
+document.addEventListener('page:loaded', () => {
+  if (!CONFIG.enableMath) return;
+
+  NexT.utils.getScript(CONFIG.katex.copy_tex_js).catch(() => {});
+});

static/js/third-party/math/mathjax.js

@@ -0,0 +1,36 @@
+/* global NexT, CONFIG, MathJax */
+
+document.addEventListener('page:loaded', () => {
+  if (!CONFIG.enableMath) return;
+
+  if (typeof MathJax === 'undefined') {
+    window.MathJax = {
+      tex: {
+        inlineMath: { '[+]': [['$', '$']] },
+        tags      : CONFIG.mathjax.tags
+      },
+      options: {
+        renderActions: {
+          insertedScript: [200, () => {
+            document.querySelectorAll('mjx-container').forEach(node => {
+              const target = node.parentNode;
+              if (target.nodeName.toLowerCase() === 'li') {
+                target.parentNode.classList.add('has-jax');
+              }
+            });
+          }, '', false]
+        }
+      }
+    };
+    NexT.utils.getScript(CONFIG.mathjax.js, {
+      attributes: {
+        defer: true
+      }
+    });
+  } else {
+    MathJax.startup.document.state(0);
+    MathJax.typesetClear();
+    MathJax.texReset();
+    MathJax.typesetPromise();
+  }
+});

static/js/third-party/pace.js

@@ -0,0 +1,7 @@
+/* global Pace */
+
+Pace.options.restartOnPushState = false;
+
+document.addEventListener('pjax:send', () => {
+  Pace.restart();
+});

static/js/third-party/quicklink.js

@@ -0,0 +1,37 @@
+/* global CONFIG, quicklink */
+
+(function() {
+  if (typeof CONFIG.quicklink.ignores === 'string') {
+    const ignoresStr = `[${CONFIG.quicklink.ignores}]`;
+    CONFIG.quicklink.ignores = JSON.parse(ignoresStr);
+  }
+
+  let resetFn = null;
+
+  const onRefresh = () => {
+    if (resetFn) resetFn();
+    if (!CONFIG.quicklink.enable) return;
+
+    let ignoresArr = CONFIG.quicklink.ignores || [];
+    if (!Array.isArray(ignoresArr)) {
+      ignoresArr = [ignoresArr];
+    }
+
+    resetFn = quicklink.listen({
+      timeout : CONFIG.quicklink.timeout,
+      priority: CONFIG.quicklink.priority,
+      ignores : [
+        uri => uri.includes('#'),
+        uri => uri === CONFIG.quicklink.url,
+        ...ignoresArr
+      ]
+    });
+  };
+
+  if (CONFIG.quicklink.delay) {
+    window.addEventListener('load', onRefresh);
+    document.addEventListener('pjax:success', onRefresh);
+  } else {
+    document.addEventListener('page:loaded', onRefresh);
+  }
+})();

static/js/third-party/rating.js

@@ -0,0 +1,22 @@
+/* global CONFIG, WPac */
+
+(function() {
+  const widgets = [{
+    widget: 'Rating',
+    id    : CONFIG.rating.id,
+    el    : 'wpac-rating',
+    color : CONFIG.rating.color
+  }];
+
+  document.addEventListener('page:loaded', () => {
+    if (!CONFIG.page.isPost) return;
+
+    const newWidgets = widgets.map(widget => ({ ...widget }));
+
+    if (window.WPac) {
+      WPac.init(newWidgets);
+    } else {
+      window.wpac_init = newWidgets;
+    }
+  });
+})();

static/js/third-party/search/algolia-search.js

@@ -0,0 +1,130 @@
+/* global instantsearch, algoliasearch, CONFIG, pjax */
+
+document.addEventListener('DOMContentLoaded', () => {
+  const { indexName, appID, apiKey, hits } = CONFIG.algolia;
+
+  const search = instantsearch({
+    indexName,
+    searchClient  : algoliasearch(appID, apiKey),
+    searchFunction: helper => {
+      if (document.querySelector('.search-input').value) {
+        helper.search();
+      }
+    }
+  });
+
+  if (typeof pjax === 'object') {
+    search.on('render', () => {
+      pjax.refresh(document.querySelector('.algolia-hits'));
+    });
+  }
+
+  // Registering Widgets
+  search.addWidgets([
+    instantsearch.widgets.configure({
+      hitsPerPage: hits.per_page || 10
+    }),
+
+    instantsearch.widgets.searchBox({
+      container           : '.search-input-container',
+      placeholder         : CONFIG.i18n.placeholder,
+      // Hide default icons of algolia search
+      showReset           : false,
+      showSubmit          : false,
+      showLoadingIndicator: false,
+      cssClasses          : {
+        input: 'search-input'
+      }
+    }),
+
+    instantsearch.widgets.stats({
+      container: '.algolia-stats',
+      templates: {
+        text: data => {
+          const stats = CONFIG.i18n.hits_time
+            .replace('${hits}', data.nbHits)
+            .replace('${time}', data.processingTimeMS);
+          return `<span>${stats}</span>
+            <img src="${CONFIG.images}/logo-algolia-nebula-blue-full.svg" alt="Algolia">`;
+        }
+      },
+      cssClasses: {
+        text: 'search-stats'
+      }
+    }),
+
+    instantsearch.widgets.hits({
+      container : '.algolia-hits',
+      escapeHTML: false,
+      templates : {
+        item: data => {
+          const { title, excerpt, excerptStrip, contentStripTruncate } = data._highlightResult;
+          let result = `<a href="${data.permalink}" class="search-result-title">${title.value}</a>`;
+          const content = excerpt || excerptStrip || contentStripTruncate;
+          if (content && content.value) {
+            const div = document.createElement('div');
+            div.innerHTML = content.value;
+            result += `<a href="${data.permalink}"><p class="search-result">${div.textContent.substring(0, 100)}...</p></a>`;
+          }
+          return result;
+        },
+        empty: data => {
+          return `<div class="algolia-hits-empty">
+              ${CONFIG.i18n.empty.replace('${query}', data.query)}
+            </div>`;
+        }
+      },
+      cssClasses: {
+        list: 'search-result-list'
+      }
+    }),
+
+    instantsearch.widgets.pagination({
+      container: '.algolia-pagination',
+      scrollTo : false,
+      showFirst: false,
+      showLast : false,
+      templates: {
+        first   : '<i class="fa fa-angle-double-left"></i>',
+        last    : '<i class="fa fa-angle-double-right"></i>',
+        previous: '<i class="fa fa-angle-left"></i>',
+        next    : '<i class="fa fa-angle-right"></i>'
+      },
+      cssClasses: {
+        list        : ['pagination', 'algolia-pagination'],
+        item        : 'pagination-item',
+        link        : 'page-number',
+        selectedItem: 'current',
+        disabledItem: 'disabled-item'
+      }
+    })
+  ]);
+
+  search.start();
+
+  // Handle and trigger popup window
+  document.querySelectorAll('.popup-trigger').forEach(element => {
+    element.addEventListener('click', () => {
+      document.body.classList.add('search-active');
+      setTimeout(() => document.querySelector('.search-input').focus(), 500);
+    });
+  });
+
+  // Monitor main search box
+  const onPopupClose = () => {
+    document.body.classList.remove('search-active');
+  };
+
+  document.querySelector('.search-pop-overlay').addEventListener('click', event => {
+    if (event.target === document.querySelector('.search-pop-overlay')) {
+      onPopupClose();
+    }
+  });
+  document.querySelector('.popup-btn-close').addEventListener('click', onPopupClose);
+  document.addEventListener('pjax:success', onPopupClose);
+  window.addEventListener('keyup', event => {
+    if (event.key === 'Escape') {
+      onPopupClose();
+    }
+  });
+});

static/js/third-party/search/local-search.js

@@ -0,0 +1,99 @@
+/* global CONFIG, pjax, LocalSearch */
+
+document.addEventListener('DOMContentLoaded', () => {
+  if (!CONFIG.path) {
+    // Search DB path
+    console.warn('`hexo-generator-searchdb` plugin is not installed!');
+    return;
+  }
+  const localSearch = new LocalSearch({
+    path             : CONFIG.path,
+    top_n_per_article: CONFIG.localsearch.top_n_per_article,
+    unescape         : CONFIG.localsearch.unescape
+  });
+
+  const input = document.querySelector('.search-input');
+
+  const inputEventFunction = () => {
+    if (!localSearch.isfetched) return;
+    const searchText = input.value.trim().toLowerCase();
+    const keywords = searchText.split(/[-\s]+/);
+    const container = document.querySelector('.search-result-container');
+    let resultItems = [];
+    if (searchText.length > 0) {
+      // Perform local searching
+      resultItems = localSearch.getResultItems(keywords);
+    }
+    if (keywords.length === 1 && keywords[0] === '') {
+      container.classList.add('no-result');
+      container.innerHTML = '<div class="search-result-icon"><i class="fa fa-search fa-5x"></i></div>';
+    } else if (resultItems.length === 0) {
+      container.classList.add('no-result');
+      container.innerHTML = '<div class="search-result-icon"><i class="far fa-frown fa-5x"></i></div>';
+    } else {
+      resultItems.sort((left, right) => {
+        if (left.includedCount !== right.includedCount) {
+          return right.includedCount - left.includedCount;
+        } else if (left.hitCount !== right.hitCount) {
+          return right.hitCount - left.hitCount;
+        }
+        return right.id - left.id;
+      });
+      const stats = CONFIG.i18n.hits.replace('${hits}', resultItems.length);
+
+      container.classList.remove('no-result');
+      container.innerHTML = `<div class="search-stats">${stats}</div>
+        <hr>
+        <ul class="search-result-list">${resultItems.map(result => result.item).join('')}</ul>`;
+      if (typeof pjax === 'object') pjax.refresh(container);
+    }
+  };
+
+  localSearch.highlightSearchWords(document.querySelector('.post-body'));
+  if (CONFIG.localsearch.preload) {
+    localSearch.fetchData();
+  }
+
+  if (CONFIG.localsearch.trigger === 'auto') {
+    input.addEventListener('input', inputEventFunction);
+  } else {
+    document.querySelector('.search-icon').addEventListener('click', inputEventFunction);
+    input.addEventListener('keypress', event => {
+      if (event.key === 'Enter') {
+        inputEventFunction();
+      }
+    });
+  }
+  window.addEventListener('search:loaded', inputEventFunction);
+
+  // Handle and trigger popup window
+  document.querySelectorAll('.popup-trigger').forEach(element => {
+    element.addEventListener('click', () => {
+      document.body.classList.add('search-active');
+      // Wait for search-popup animation to complete
+      setTimeout(() => input.focus(), 500);
+      if (!localSearch.isfetched) localSearch.fetchData();
+    });
+  });
+
+  // Monitor main search box
+  const onPopupClose = () => {
+    document.body.classList.remove('search-active');
+  };
+
+  document.querySelector('.search-pop-overlay').addEventListener('click', event => {
+    if (event.target === document.querySelector('.search-pop-overlay')) {
+      onPopupClose();
+    }
+  });
+  document.querySelector('.popup-btn-close').addEventListener('click', onPopupClose);
+  document.addEventListener('pjax:success', () => {
+    localSearch.highlightSearchWords(document.querySelector('.post-body'));
+    onPopupClose();
+  });
+  window.addEventListener('keyup', event => {
+    if (event.key === 'Escape') {
+      onPopupClose();
+    }
+  });
+});

static/js/third-party/statistics/firestore.js

@@ -0,0 +1,64 @@
+/* global CONFIG, firebase */
+
+firebase.initializeApp({
+  apiKey   : CONFIG.firestore.apiKey,
+  projectId: CONFIG.firestore.projectId
+});
+
+(function() {
+  const getCount = (doc, increaseCount) => {
+    // IncreaseCount will be false when not in article page
+    return doc.get().then(d => {
+      // Has no data, initialize count
+      let count = d.exists ? d.data().count : 0;
+      // If first view this article
+      if (increaseCount) {
+        // Increase count
+        count++;
+        doc.set({
+          count
+        });
+      }
+      return count;
+    });
+  };
+
+  const appendCountTo = el => {
+    return count => {
+      el.innerText = count;
+    };
+  };
+
+  const db = firebase.firestore();
+  const articles = db.collection(CONFIG.firestore.collection);
+
+  document.addEventListener('page:loaded', () => {
+
+    if (CONFIG.page.isPost) {
+      // Fix issue #118
+      // https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent
+      const title = document.querySelector('.post-title').textContent.trim();
+      const doc = articles.doc(title);
+      let increaseCount = CONFIG.hostname === location.hostname;
+      if (localStorage.getItem(title)) {
+        increaseCount = false;
+      } else {
+        // Mark as visited
+        localStorage.setItem(title, true);
+      }
+      getCount(doc, increaseCount).then(appendCountTo(document.querySelector('.firestore-visitors-count')));
+    } else if (CONFIG.page.isHome) {
+      const promises = [...document.querySelectorAll('.post-title')].map(element => {
+        const title = element.textContent.trim();
+        const doc = articles.doc(title);
+        return getCount(doc);
+      });
+      Promise.all(promises).then(counts => {
+        const metas = document.querySelectorAll('.firestore-visitors-count');
+        counts.forEach((val, idx) => {
+          appendCountTo(metas[idx])(val);
+        });
+      });
+    }
+  });
+})();

static/js/third-party/statistics/lean-analytics.js

@@ -0,0 +1,102 @@
+/* global CONFIG */
+/* eslint-disable no-console */
+
+(function() {
+  const leancloudSelector = url => {
+    url = encodeURI(url);
+    return document.getElementById(url).querySelector('.leancloud-visitors-count');
+  };
+
+  const addCount = Counter => {
+    const visitors = document.querySelector('.leancloud_visitors');
+    const url = decodeURI(visitors.id);
+    const title = visitors.dataset.flagTitle;
+
+    Counter('get', `/classes/Counter?where=${encodeURIComponent(JSON.stringify({ url }))}`)
+      .then(response => response.json())
+      .then(({ results }) => {
+        if (results.length > 0) {
+          const counter = results[0];
+          leancloudSelector(url).innerText = counter.time + 1;
+          Counter('put', '/classes/Counter/' + counter.objectId, {
+            time: {
+              '__op'  : 'Increment',
+              'amount': 1
+            }
+          })
+            .catch(error => {
+              console.error('Failed to save visitor count', error);
+            });
+        } else if (CONFIG.leancloud_visitors.security) {
+          leancloudSelector(url).innerText = 'Counter not initialized! More info at console err msg.';
+          console.error('ATTENTION! LeanCloud counter has security bug, see how to solve it here: https://github.com/theme-next/hexo-leancloud-counter-security. \n However, you can still use LeanCloud without security, by setting `security` option to `false`.');
+        } else {
+          Counter('post', '/classes/Counter', { title, url, time: 1 })
+            .then(response => response.json())
+            .then(() => {
+              leancloudSelector(url).innerText = 1;
+            })
+            .catch(error => {
+              console.error('Failed to create', error);
+            });
+        }
+      })
+      .catch(error => {
+        console.error('LeanCloud Counter Error', error);
+      });
+  };
+
+  const showTime = Counter => {
+    const visitors = document.querySelectorAll('.leancloud_visitors');
+    const entries = [...visitors].map(element => {
+      return decodeURI(element.id);
+    });
+
+    Counter('get', `/classes/Counter?where=${encodeURIComponent(JSON.stringify({ url: { '$in': entries } }))}`)
+      .then(response => response.json())
+      .then(({ results }) => {
+        for (const url of entries) {
+          const target = results.find(item => item.url === url);
+          leancloudSelector(url).innerText = target ? target.time : 0;
+        }
+      })
+      .catch(error => {
+        console.error('LeanCloud Counter Error', error);
+      });
+  };
+
+  const { app_id, app_key, server_url } = CONFIG.leancloud_visitors;
+  const fetchData = api_server => {
+    const Counter = (method, url, data) => {
+      return fetch(`${api_server}/1.1${url}`, {
+        method,
+        headers: {
+          'X-LC-Id'     : app_id,
+          'X-LC-Key'    : app_key,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(data)
+      });
+    };
+    if (CONFIG.page.isPost) {
+      if (CONFIG.hostname !== location.hostname) return;
+      addCount(Counter);
+    } else if (document.querySelectorAll('.post-title-link').length >= 1) {
+      showTime(Counter);
+    }
+  };
+
+  const api_server = app_id.slice(-9) === '-MdYXbMMI' ? `https://${app_id.slice(0, 8).toLowerCase()}.api.lncldglobal.com` : server_url;
+
+  document.addEventListener('page:loaded', () => {
+    if (api_server) {
+      fetchData(api_server);
+    } else {
+      fetch(`https://app-router.leancloud.cn/2/route?appId=${app_id}`)
+        .then(response => response.json())
+        .then(({ api_server }) => {
+          fetchData(`https://${api_server}`);
+        });
+    }
+  });
+})();

static/js/third-party/tags/mermaid.js

@@ -0,0 +1,32 @@
+/* global NexT, CONFIG, mermaid */
+
+document.addEventListener('page:loaded', () => {
+  const mermaidElements = document.querySelectorAll('.mermaid');
+  if (mermaidElements.length) {
+    NexT.utils.getScript(CONFIG.mermaid.js, {
+      condition: window.mermaid
+    }).then(() => {
+      mermaidElements.forEach(element => {
+        const newElement = document.createElement('div');
+        newElement.innerHTML = element.innerHTML;
+        newElement.className = element.className;
+        const parent = element.parentNode;
+        // Fix issue #347
+        // Support mermaid inside backtick code block
+        if (parent.matches('pre')) {
+          parent.parentNode.replaceChild(newElement, parent);
+        } else {
+          parent.replaceChild(newElement, element);
+        }
+      });
+      mermaid.initialize({
+        theme    : CONFIG.darkmode && window.matchMedia('(prefers-color-scheme: dark)').matches ? CONFIG.mermaid.theme.dark : CONFIG.mermaid.theme.light,
+        logLevel : 4,
+        flowchart: { curve: 'linear' },
+        gantt    : { axisFormat: '%m/%d/%Y' },
+        sequence : { actorMargin: 50 }
+      });
+      mermaid.init();
+    });
+  }
+});

static/js/third-party/tags/pdf.js

@@ -0,0 +1,23 @@
+/* global NexT, CONFIG, PDFObject */
+
+document.addEventListener('page:loaded', () => {
+  if (document.querySelectorAll('.pdf-container').length) {
+    NexT.utils.getScript(CONFIG.pdf.object_url, {
+      condition: window.PDFObject
+    }).then(() => {
+      document.querySelectorAll('.pdf-container').forEach(element => {
+        PDFObject.embed(element.dataset.target, element, {
+          pdfOpenParams: {
+            navpanes : 0,
+            toolbar  : 0,
+            statusbar: 0,
+            pagemode : 'thumbs',
+            view     : 'FitH'
+          },
+          PDFJS_URL: CONFIG.pdf.url,
+          height   : element.dataset.height
+        });
+      });
+    });
+  }
+});