hexo-theme-shokax 0.0.1-alpha1

package/scripts/helpers/asset.js

@@ -0,0 +1,237 @@
+/* global hexo */
+
+'use strict'
+const { htmlTag, url_for, stripHTML } = require('hexo-util')
+const theme_env = require('../../package.json')
+
+hexo.extend.helper.register('_init_comments', function (mode) {
+  if (mode === 'twikoo') {
+    const options = {
+      // eslint-disable-next-line no-useless-escape
+      envId: `${hexo.theme.config?.twikoo?.envId}`,
+      el: '#tcomments'
+    }
+    if (hexo.theme.config.twikoo.mode === 'tencent') {
+      // eslint-disable-next-line no-useless-escape
+      options.region = `\'${hexo.theme.config.twikoo.region}\'`
+    }
+    return `
+        <script data-pjax>
+        setTimeout(function () {
+            twikoo.init(${JSON.stringify(options)})
+        }, 1000)
+        </script>`
+  } else if (mode === 'waline') {
+    const options = {
+      el: '#wcomments',
+      serverURL: hexo.theme.config.waline.serverURL
+    }
+    return `
+    <script type="module">
+        import { init } from 'https://unpkg.com/@waline/client@v2/dist/waline.mjs'
+        init(${JSON.stringify(options)});
+    </script>
+    <script nomodule type="text/javascript">
+        Waline.init(${JSON.stringify(options)});
+    </script>
+    `
+  }
+})
+
+hexo.extend.helper.register('_new_comments', function (mode) {
+  if (mode === 'twikoo') {
+    return `<script data-pjax type="module">
+            let comments = []
+           twikoo.getRecentComments({
+           envId: "${hexo.theme.config?.twikoo?.envId}",
+           pageSize: 10
+           }).then(function (res) {
+                res.forEach(function (item) {
+                    let cText = item.commentText
+                    if (item.commentText.length > 50) {
+                        cText = item.commentText.substring(0,50)+'...'
+                    }
+                    const siteLink = item.url + "#" + item.id
+                    comments.push({
+                        href: siteLink,
+                        nick: item.nick,
+                        time: item.relativeTime,
+                        text: cText
+                    })
+                });
+                Vue.createApp({
+                  data() {
+                      return {
+                          coms: comments
+                      }
+                  }
+                  }).mount('#new-comment')
+            }).catch(function (err) {
+                console.error(err)
+            })
+        </script>`
+  } else if (mode === 'waline') {
+    return `
+    <script type="module">
+        import { RecentComments } from 'https://unpkg.com/@waline/client@v2/dist/waline.mjs'
+        RecentComments({
+          el: '#new-comment',
+          serverURL: '${hexo.theme.config.waline.serverURL}',
+          count: 10,
+        });
+    </script>
+    <script nomodule type="text/javascript">
+        Waline.RecentComments({
+          el: '#new-comment',
+          serverURL: '${hexo.theme.config.waline.serverURL}',
+          count: 10,
+        });
+    </script>
+    `
+  }
+})
+
+hexo.extend.helper.register('_safedump', (source) => {
+  return JSON.stringify(source)
+})
+
+hexo.extend.helper.register('hexo_env', function (type) {
+  return this.env[type]
+})
+
+hexo.extend.helper.register('theme_env', function (type) {
+  return theme_env[type]
+})
+
+hexo.extend.helper.register('_vendor_font', () => {
+  const config = hexo.theme.config.font
+
+  if (!config || !config.enable) return ''
+
+  const fontDisplay = '&display=swap'
+  const fontSubset = '&subset=latin,latin-ext'
+  const fontStyles = ':300,300italic,400,400italic,700,700italic'
+  const fontHost = '//fonts.geekzu.org'
+
+  // Get a font list from config
+  let fontFamilies = ['global', 'logo', 'title', 'headings', 'posts', 'codes'].map(item => {
+    if (config[item] && config[item].family && config[item].external) {
+      return config[item].family + fontStyles
+    }
+    return ''
+  })
+
+  fontFamilies = fontFamilies.filter(item => item !== '')
+  fontFamilies = [...new Set(fontFamilies)]
+  fontFamilies = fontFamilies.join('|')
+
+  // Merge extra parameters to the final processed font string
+  return fontFamilies
+    ? htmlTag('link', {
+      rel: 'stylesheet',
+      href: `${fontHost}/css?family=${fontFamilies.concat(fontDisplay, fontSubset)}`
+    })
+    : ''
+})
+
+hexo.extend.helper.register('_local_fonts', () => {
+  let res = '<style>'
+  const fonts = hexo.theme.config.custom.font
+  fonts.forEach((item) => {
+    const tmp = `
+    @font-face {
+        font-family: ${item.family};
+        src: ${item.src};
+        font-display: swap;
+    };`
+    res += tmp
+  })
+  res += '</style>'
+  return res
+})
+
+hexo.extend.helper.register('_vendor_js', () => {
+  const config = hexo.theme.config.vendors.js
+
+  if (!config) return ''
+
+  // Get a font list from config
+  let vendorJs = ['pace', 'pjax', 'fetch', 'anime', 'algolia', 'instantsearch', 'lazyload', 'quicklink'].map(item => {
+    if (config[item]) {
+      return config[item]
+    }
+    return ''
+  })
+
+  vendorJs = vendorJs.filter(item => item !== '')
+  vendorJs = [...new Set(vendorJs)]
+  vendorJs = vendorJs.join(',')
+  return vendorJs ? htmlTag('script', { src: `https://cdn.jsdelivr.net/combine/${vendorJs}` }, '') : ''
+})
+
+hexo.extend.helper.register('_css', function (...urls) {
+  const { statics, css } = hexo.theme.config
+
+  return urls.map(url => htmlTag('link', {
+    rel: 'stylesheet',
+    href: url_for.call(this, `${statics}${css}/${url}?v=${theme_env.version}`)
+  })).join('')
+})
+
+hexo.extend.helper.register('_js', function (...urls) {
+  const { statics, js } = hexo.theme.config
+
+  return urls.map(url => htmlTag('script', { src: url_for.call(this, `${statics}${js}/${url}?v=${theme_env.version}`) }, '')).join('')
+})
+hexo.extend.helper.register('_list_vendor_js', () => {
+  return hexo.theme.config.vendorsList.js
+})
+
+hexo.extend.helper.register('_adv_vendor_js', function (js_name) {
+  const srcHelpers = (src) => { return src.endsWith('/') ? src : src + '/' }
+  const config = hexo.theme.config.advVendors.js[js_name]
+  const themeConfig = hexo.theme.config
+  const src = config.src
+  const publicCdns = {
+    npm: srcHelpers(themeConfig.advVendors.npm),
+    gh: srcHelpers(themeConfig.advVendors.github),
+    combine: srcHelpers(themeConfig.advVendors.combine),
+    bytedance: 'https://lf9-cdn-tos.bytecdntp.com/cdn/expire-6-M/',
+    baomitu: 'https://lib.baomitu.com/'
+  }
+  let result
+  if (src.startsWith('http')) {
+    result = src
+  } else if (src.startsWith('combine:')) {
+    hexo.log.info('The combine feature is not recommended!')
+    result = publicCdns.combine + src
+  } else if (src.startsWith('npm:')) {
+    result = publicCdns.npm + src.substring(4)
+  } else if (src.startsWith('gh:')) {
+    result = publicCdns.gh + src.substring(3)
+  } else if (src.startsWith('bytedance:')) {
+    result = publicCdns.bytedance + src.substring(10)
+  } else if (src.startsWith('baomitu:')) {
+    result = publicCdns.baomitu + src.substring(8)
+  } else {
+    result = '/' + src
+  }
+  const attr = { src: result }
+  if (config.async) attr.async = 'async'
+  if (config['data-pjax']) attr['data-pjax'] = 'data-pjax'
+  if (config['hash-value']) attr.integrity = config['hash-value']
+  if (config.deferLoad) {
+    return htmlTag('script', { 'data-pjax': true }, `
+        const script=document.createElement("script");script.src="${result}",script.async=true,document.body.appendChild(script)
+        `)
+  }
+  return htmlTag('script', attr, '')
+})
+
+hexo.extend.helper.register('_striptags', function (data) {
+  return stripHTML(data)
+})
+
+hexo.extend.helper.register('_truncate', function (data, end) {
+  return data.substring(0, end)
+})

package/scripts/helpers/engine.js

@@ -0,0 +1,183 @@
+/* global hexo */
+
+'use strict'
+
+const { htmlTag, url_for } = require('hexo-util')
+const url = require('url')
+const crypto = require('crypto')
+
+const randomServer = parseInt(Math.random() * 4, 10) + 1
+
+const randomBG = function (count = 1, image_server = null, image_list = []) {
+  let i
+  if (image_server) {
+    if (count && count > 1) {
+      const arr = new Array(count)
+      for (i = 0; i < arr.length; i++) {
+        arr[i] = image_server + '?' + Math.floor(Math.random() * 999999)
+      }
+
+      return arr
+    }
+
+    return image_server + '?' + Math.floor(Math.random() * 999999)
+  }
+
+  const parseImage = function (img, size) {
+    if (img.startsWith('//') || img.startsWith('http')) {
+      return img
+    } else {
+      return `https://tva${randomServer}.sinaimg.cn/` + size + '/' + img
+    }
+  }
+
+  if (count && count > 1) {
+    const shuffled = image_list.slice(0)
+    i = image_list.length
+    const min = i - count; let temp; let index
+    while (i-- > min) {
+      index = Math.floor((i + 1) * Math.random())
+      temp = shuffled[index]
+      shuffled[index] = shuffled[i]
+      shuffled[i] = temp
+    }
+
+    return shuffled.slice(min).map(function (img) {
+      return parseImage(img, 'large')
+    })
+  }
+
+  return parseImage(image_list[Math.floor(Math.random() * image_list.length)], 'mw690')
+}
+
+hexo.extend.helper.register('_url', function (path, text, options = {}) {
+  if (!path) { return }
+
+  const { config } = this
+  // eslint-disable-next-line n/no-deprecated-api
+  const data = url.parse(path)
+  // eslint-disable-next-line n/no-deprecated-api
+  const siteHost = url.parse(config.url).hostname || config.url
+
+  const theme = hexo.theme.config
+  let exturl = ''
+  let tag = 'a'
+  let attrs = { href: url_for.call(this, path) }
+
+  // If `exturl` enabled, set spanned links only on external links.
+  if (theme.exturl && data.protocol && data.hostname !== siteHost) {
+    tag = 'span'
+    exturl = 'exturl'
+    const encoded = Buffer.from(path).toString('base64')
+    attrs = {
+      class: exturl,
+      'data-url': encoded
+    }
+  }
+
+  for (const key in options) {
+    /**
+         * If option have `class` attribute, add it to
+         * 'exturl' class if `exturl` option enabled.
+         */
+    if (exturl !== '' && key === 'class') {
+      attrs[key] += ' ' + options[key]
+    } else {
+      attrs[key] = options[key]
+    }
+  }
+
+  if (attrs.class && Array.isArray(attrs.class)) {
+    attrs.class = attrs.class.join(' ')
+  }
+
+  // If it's external link, rewrite attributes.
+  if (data.protocol && data.hostname !== siteHost) {
+    attrs.external = null
+
+    if (!theme.exturl) {
+      // Only for simple link need to rewrite/add attributes.
+      attrs.rel = 'noopener'
+      attrs.target = '_blank'
+    } else {
+      // Remove rel attributes for `exturl` in main menu.
+      attrs.rel = null
+    }
+  }
+
+  return htmlTag(tag, attrs, decodeURI(text), false)
+})
+
+hexo.extend.helper.register('_image_url', function (img, path = '') {
+  const { statics } = hexo.theme.config
+  const { post_asset_folder } = hexo.config
+
+  if (img.startsWith('//') || img.startsWith('http')) {
+    return img
+  } else {
+    return url_for.call(this, statics + (post_asset_folder ? path : '') + img)
+  }
+})
+
+hexo.extend.helper.register('_cover', function (item, num) {
+  const { statics, js, image_server, image_list } = hexo.theme.config
+
+  if (item.cover) {
+    return this._image_url(item.cover, item.path)
+  } else if (item.photos && item.photos.length > 0) {
+    return this._image_url(item.photos[0], item.path)
+  } else {
+    return randomBG(num || 1, image_server, image_list)
+  }
+})
+
+// TODO 此函数已被废弃
+hexo.extend.helper.register('_md5', function (path) {
+  const str = url_for.call(this, path)
+  str.replace('index.html', '')
+  return crypto.createHash('md5').update(str).digest('hex')
+})
+
+hexo.extend.helper.register('_permapath', function (str) {
+  // https://support.google.com/webmasters/answer/139066
+  const { permalink } = hexo.config
+  let url = str.replace(/index\.html$/, '')
+  if (!permalink.endsWith('.html')) {
+    url = url.replace(/\.html$/, '')
+  }
+  return url
+})
+
+hexo.extend.helper.register('canonical', function () {
+  return `<link rel="canonical" href="${this._permapath(this.url)}">`
+})
+
+/**
+ * Get page path given a certain language tag
+ */
+hexo.extend.helper.register('i18n_path', function (language) {
+  const { path, lang } = this.page
+  const base = path.startsWith(lang) ? path.slice(lang.length + 1) : path
+  return url_for.call(this, `${this.languages.indexOf(language) === 0 ? '' : '/' + language}/${base}`)
+})
+
+/**
+ * Get the language name
+ */
+hexo.extend.helper.register('language_name', function (language) {
+  const name = hexo.theme.i18n.__(language)('name')
+  return name === 'name' ? language : name
+})
+
+hexo.extend.helper.register('random_color', function () {
+  const arr = []
+  for (let i = 0; i < 3; i++) {
+    arr.push(Math.floor(Math.random() * 128 + 128))
+  }
+  const [r, g, b] = arr
+  return `#${
+      r.toString(16).length > 1 ? r.toString(16) : '0' + r.toString(16)
+    }${g.toString(16).length > 1 ? g.toString(16) : '0' + g.toString(16)}${
+      b.toString(16).length > 1 ? b.toString(16) : '0' + b.toString(16)
+    }`
+})

package/scripts/helpers/list_categories.js

@@ -0,0 +1,140 @@
+'use strict'
+/* global hexo */
+
+const fs = require('hexo-fs')
+
+const prepareQuery = (categories, parent) => {
+  const query = {}
+
+  if (parent) {
+    query.parent = parent
+  } else {
+    query.parent = { $exists: false }
+  }
+
+  return categories.find(query).sort('name', 1).filter(cat => cat.length)
+}
+
+hexo.extend.helper.register('_list_categories', function (depth = 0) {
+  // let hexo = this
+  const categories = this.site.categories
+
+  if (!categories || !categories.length) return ''
+
+  const hierarchicalList = (level, parent) => {
+    let result = ''
+
+    prepareQuery(categories, parent).forEach((cat, i) => {
+      let child
+
+      if (level + 1 < depth) {
+        child = hierarchicalList(level + 1, cat._id)
+      }
+
+      const catname = `<a itemprop="url" href="${this.url_for(cat.path)}">${cat.name}</a><small>( ${cat.length} )</small>`
+
+      switch (level) {
+        case 0:
+          result += `<div><h2 class="item header">${catname}</h2>`
+          break
+
+        case 1:
+          result += `<h3 class="item section">${catname}</h3>`
+          break
+
+        case 2:
+          result += `<div class="item normal"><div class="title">${catname}</div></div>`
+          break
+      }
+
+      if (child) {
+        result += `${child}`
+      }
+
+      if (level === 0) {
+        result += '</div>'
+      }
+    })
+
+    return result
+  }
+
+  return hierarchicalList(0)
+})
+
+hexo.extend.helper.register('_categories', function () {
+  // let hexo = this
+  const categories = this.site.categories
+  if (!categories || !categories.length) return ''
+
+  const pangu = this.theme.pangu
+    ? require('pangu')
+    : {
+        spacing: data => {
+          return data
+        }
+      }
+
+  const result = {}
+
+  categories.forEach((cat, i) => {
+    const child = prepareQuery(categories, cat._id)
+    const cover = 'source/_posts' + cat.path.replace(this.config.category_dir, '') + 'cover.jpg'
+
+    if (fs.existsSync(cover)) {
+      const className = cat.slug.split('/')
+      className.pop()
+      cat.class = className.join(' ')
+      cat.name = pangu.spacing(cat.name)
+
+      if (child.length !== 0) {
+        cat.child = child
+      }
+
+      result[cat._id] = cat
+    }
+  })
+
+  return result
+})
+
+hexo.extend.helper.register('_category_prev', function (name) {
+  // let hexo = this
+  const categories = this.site.categories
+  if (!categories || !categories.length) return ''
+
+  let result = ''
+
+  categories.find({ name }).forEach((current) => {
+    if (current.parent) {
+      categories.find({ _id: current.parent }).forEach((cat, i) => {
+        result += `<a href="${this.url_for(cat.path)}">${cat.name}</a>`
+      })
+    }
+  })
+
+  return result
+})
+
+hexo.extend.helper.register('_category_posts', function (page) {
+  // let hexo = this
+  const categories = this.site.categories
+  if (!categories || !categories.length || !page.categories || !page.categories.length) return ''
+
+  let result = ''
+  const cat = page.categories.toArray()
+
+  categories.find({ _id: cat[cat.length - 1]._id }).forEach((category) => {
+    if (category.posts) {
+      category.posts.sort('date', 1).forEach((post) => {
+        let current = ''
+        if (post.path === page.path) {
+          current = ' class="active"'
+        }
+        result += `<li ${current}><a href="${this.url_for(post.path)}" rel="bookmark" title="${post.title}">${post.title}</a></li>`
+      })
+    }
+  })
+
+  return result
+})

package/scripts/helpers/symbols_count_time.js

@@ -0,0 +1,76 @@
+'use strict'
+/* global hexo */
+/*
+  hexo-symbols-count-time by theme-next
+  under GNU Lesser General Public License v3.0
+  https://github.com/theme-next/hexo-symbols-count-time/blob/master/LICENSE
+ */
+
+const { stripHTML } = require('hexo-util')
+
+const config = hexo.config.symbols_count_time = Object.assign({
+  symbols: true,
+  time: true,
+  total_symbols: true,
+  total_time: true,
+  exclude_codeblock: false,
+  awl: 4,
+  wpm: 275,
+  suffix: 'mins.'
+}, hexo.config.symbols_count_time)
+
+function getSymbols (post) {
+  return post?._content?.length ?? post?.content?.length ?? post.length
+}
+
+function getSymbolsTotal (site) {
+  let symbolsResultCount = 0
+  site.posts.forEach((post) => {
+    symbolsResultCount += getSymbols(post)
+  })
+  return symbolsResultCount
+}
+
+function getFormatTime (minutes, suffix) {
+  const fHours = Math.floor(minutes / 60)
+  let fMinutes = Math.floor(minutes - (fHours * 60))
+  if (fMinutes < 1) {
+    fMinutes = 1 // 0 => 1
+  }
+  return fHours < 1
+    ? fMinutes + ' ' + suffix // < 59 => 59 mins.
+    : fHours + ':' + ('00' + fMinutes).slice(-2) // = 61 => 1:01
+}
+
+hexo.extend.helper.register('symbolsCount', function (post) {
+  let symbolsResult = getSymbols(post)
+  if (symbolsResult > 9999) {
+    symbolsResult = Math.round(symbolsResult / 1000) + 'k' // > 9999 => 11k
+  } else if (symbolsResult > 999) {
+    symbolsResult = Math.round(symbolsResult / 100) / 10 + 'k' // > 999 => 1.1k
+  } // < 999 => 111
+  return symbolsResult
+})
+
+hexo.extend.helper.register('symbolsTime', function (post, awl = config.awl, wpm = config.wpm, suffix = config.suffix) {
+  const minutes = Math.round(getSymbols(post) / (awl * wpm))
+  return getFormatTime(minutes, suffix)
+})
+
+hexo.extend.helper.register('symbolsCountTotal', function (site) {
+  const symbolsResultTotal = getSymbolsTotal(site)
+  return symbolsResultTotal < 1000000
+    ? Math.round(symbolsResultTotal / 1000) + 'k' // < 999k => 111k
+    : Math.round(symbolsResultTotal / 100000) / 10 + 'm' // > 999k => 1.1m
+})
+
+hexo.extend.helper.register('symbolsTimeTotal', function (site, awl = config.awl, wpm = config.wpm, suffix = config.suffix) {
+  const minutes = Math.round(getSymbolsTotal(site) / (awl * wpm))
+  return getFormatTime(minutes, suffix)
+})
+
+hexo.extend.filter.register('after_post_render', (data) => {
+  let { content } = data
+  if (config.exclude_codeblock) content = content.replace(/<pre>.*?<\/pre>/g, '')
+  data.length = stripHTML(content).replace(/\r?\n|\r/g, '').replace(/\s+/g, '').length
+}, 0)