hexo-theme-shokax 0.0.1-alpha1

package/layout/tag.pug

@@ -0,0 +1,43 @@
+extends ./_partials/layout.pug
+
+block title
+    != `${__('title.tag')}${__('symbol.colon')}${page.tag}|`
+
+block header
+    h1(itemprop="name headline")
+        != _p('title.tag_in', page.tag)
+
+block content
+    div(class="collapse wrap")
+        h2(class="item header")
+            a(href=url_for(config.tag_dir))
+                != __('title.all')
+            small /
+            != page.tag
+            small
+                != __('title.tag')
+        - var posts = page.posts
+        each post in posts.toArray()
+            article(class="item normal" itemscope itemtype="http://schema.org/Article")
+                div(class="meta")
+                    time(itemprop="dateCreated"
+                        datetime=moment(post.date).format()
+                        content=date(post.date, config.date_format))
+                        != date(post.date, 'YYYY-MM-DD')
+                    if post.categories && post.categories.length
+                        - var cat_length = post.categories.length
+                        each cat,index in post.categories.toArray()
+                            if index == cat_length && cat.name !== page.category
+                                span
+                                    a(href=url_for(cat.path))
+                                        != cat.name
+                div(class="title")
+                    if post.link
+                        - var postTitleIcon = '<i class="ic i-link-alt"></i>'
+                        - var postText = post.title || post.link
+                        != _url(post.link, postText + postTitleIcon, {class: 'external', itemprop: 'url'})
+                    else
+                        a(href=url_for(post.path) itemprop="url")
+                            span(itemprop="name")
+                                != post.title || __('post.untitled')
+    include _partials/pagination.pug

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "hexo-theme-shokax",
+  "version": "0.0.1-alpha1",
+  "description": "a hexo theme based on shoka",
+  "main": "index.js",
+  "repository": "https://github.com/zkz098/hexo-theme-shokaX",
+  "author": "Chou kaitaku",
+  "license": "MIT",
+  "scripts": {
+    "test": "cd ./source/js && tsc"
+  },
+  "devDependencies": {
+    "@types/animejs": "^3.1.6",
+    "@types/fancybox": "^3.5.3",
+    "@types/hexo": "^3.8.8",
+    "@types/jquery": "^3.5.14",
+    "@types/js-yaml": "^4.0.5",
+    "@types/lozad": "^1.16.1",
+    "@types/node": "^18.11.17",
+    "@types/shelljs": "^0.8.11",
+    "@typescript-eslint/eslint-plugin": "^5.47.0",
+    "@typescript-eslint/parser": "^5.47.0",
+    "eslint": "^8.30.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.6.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-vue": "^9.8.0",
+    "typescript": "^4.9.4",
+    "vue": "^3.2.45"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  }
+}

package/scripts/filters/locals.js

@@ -0,0 +1,57 @@
+'use strict'
+/* global hexo */
+const path = require('path')
+const url = require('url')
+
+const fmtNum = num => {
+  return num < 10 ? '0' + num : num
+}
+
+hexo.extend.filter.register('template_locals', locals => {
+  const { env, config } = hexo
+  const { __, theme } = locals
+  const { i18n } = hexo.theme
+
+  const pangu = theme.pangu
+    ? require('pangu')
+    : {
+        spacing: data => {
+          return data
+        }
+      }
+
+  // Language & Config
+  locals.alternate = theme.alternate
+  locals.title = pangu.spacing(__('title') !== 'title' ? __('title') : config.title)
+  locals.subtitle = pangu.spacing(__('subtitle') !== 'subtitle' ? __('subtitle') : config.subtitle)
+  locals.author = __('author') !== 'author' ? __('author') : config.author
+  locals.description = pangu.spacing(__('description') !== 'description' ? __('description') : config.description)
+  locals.languages = [...i18n.languages]
+  locals.languages.splice(locals.languages.indexOf('default'), 1)
+  locals.page.lang = locals.page.lang || locals.page.language
+  locals.hostname = new URL(config.url).hostname || config.url
+
+  // Creative Commons
+  locals.ccURL = 'https://creativecommons.org/' + (theme.creative_commons.license === 'zero' ? 'publicdomain/zero/1.0/' : 'licenses/' + theme.creative_commons.license + '/4.0/') + (theme.creative_commons.language || '')
+
+  if (locals.page.title) {
+    locals.page.title = pangu.spacing(locals.page.title)
+  }
+  locals.page.lastcat = ''
+  if (locals.page.categories) {
+    locals.page.categories.map((cat) => {
+      if (cat.name) {
+        cat.name = locals.page.lastcat = pangu.spacing(cat.name)
+      }
+      return cat
+    })
+  }
+
+  if (locals.page.category) {
+    locals.page.title = pangu.spacing(locals.page.category)
+  }
+
+  if (locals.page.month) {
+    locals.page.month = fmtNum(locals.page.month)
+  }
+})

package/scripts/filters/post.js

@@ -0,0 +1,23 @@
+'use strict'
+
+hexo.extend.filter.register('after_post_render', data => {
+  const { config } = hexo
+  const theme = hexo.theme.config
+
+  data.content = data.content.replace(/(<img[^>]*) src=/img, '$1 data-src=')
+
+  const url = require('url')
+  // eslint-disable-next-line n/no-deprecated-api
+  const siteHost = url.parse(config.url).hostname || config.url
+  data.content = data.content.replace(/<a[^>]* href="([^"]+)"[^>]*>([^<]*)<\/a>/img, (match, href, html) => {
+    // Exit if the href attribute doesn't exists.
+    if (!href) return match
+
+    // Exit if the url has same host with `config.url`, which means it's an internal link.
+    // eslint-disable-next-line n/no-deprecated-api
+    const link = url.parse(href)
+    if (!link.protocol || link.hostname === siteHost) return match
+
+    return `<span class="exturl" data-url="${Buffer.from(href).toString('base64')}">${html}</span>`
+  })
+}, 0)

package/scripts/generaters/archive.js

@@ -0,0 +1,141 @@
+/* global hexo */
+'use strict'
+
+const pagination = require('hexo-pagination')
+
+const fmtNum = num => {
+  return num < 10 ? '0' + num : num
+}
+
+if (!(hexo.config.archive && hexo.config.archive.enabled === false)) {
+  // when archive disabled pagination, per_page should be 0.
+  let per_page
+
+  if (hexo.config.archive === 1) {
+    per_page = 0
+  } else if (typeof hexo.config.per_page === 'undefined') {
+    per_page = 10
+  } else {
+    per_page = hexo.config.per_page
+  }
+
+  hexo.config.archive_generator = Object.assign({
+    per_page,
+    yearly: true,
+    monthly: true,
+    daily: false
+  }, hexo.config.archive_generator)
+
+  hexo.extend.generator.register('archive', function (locals) {
+    const config = hexo.config
+    let archiveDir = config.archive_dir
+    const paginationDir = config.pagination_dir || 'page'
+    const allPosts = locals.posts.sort(config.archive_generator.order_by || '-date')
+    const perPage = config.archive_generator.per_page
+    let result = []
+
+    if (!allPosts.length) return
+
+    if (archiveDir[archiveDir.length - 1] !== '/') archiveDir += '/'
+
+    function generate (path, posts, options) {
+      options = options || {}
+      options.archive = true
+
+      result = result.concat(pagination(path, posts, {
+        perPage: path === archiveDir ? 0 : perPage,
+        layout: ['archive', 'index'],
+        format: paginationDir + '/%d/',
+        data: options
+      }))
+    }
+
+    generate(archiveDir, allPosts)
+
+    if (!config.archive_generator.yearly) return result
+
+    const posts = {}
+
+    // Organize posts by date
+    allPosts.forEach(post => {
+      const date = post.date
+      const year = date.year()
+      const month = date.month() + 1 // month is started from 0
+
+      if (!Object.prototype.hasOwnProperty.call(posts, year)) {
+        // 13 arrays. The first array is for posts in this year
+        // and the other arrays is for posts in this month
+        posts[year] = [
+          [],
+          [],
+          [],
+          [],
+          [],
+          [],
+          [],
+          [],
+          [],
+          [],
+          [],
+          [],
+          []
+        ]
+      }
+
+      posts[year][0].push(post)
+      posts[year][month].push(post)
+      // Daily
+      if (config.archive_generator.daily) {
+        const day = date.date()
+        if (!Object.prototype.hasOwnProperty.call(posts[year][month], 'day')) {
+          posts[year][month].day = {}
+        }
+
+        (posts[year][month].day[day] || (posts[year][month].day[day] = [])).push(post)
+      }
+    })
+
+    const Query = this.model('Post').Query
+    const years = Object.keys(posts)
+    let year, data, month, monthData, url
+
+    // Yearly
+    for (let i = 0, len = years.length; i < len; i++) {
+      year = +years[i]
+      data = posts[year]
+      url = archiveDir + year + '/'
+      if (!data[0].length) continue
+
+      generate(url, new Query(data[0]), { year })
+
+      if (!config.archive_generator.monthly && !config.archive_generator.daily) continue
+
+      // Monthly
+      for (month = 1; month <= 12; month++) {
+        monthData = data[month]
+        if (!monthData.length) continue
+        if (config.archive_generator.monthly) {
+          generate(url + fmtNum(month) + '/', new Query(monthData), {
+            year,
+            month
+          })
+        }
+
+        if (!config.archive_generator.daily) continue
+
+        // Daily
+        for (let day = 1; day <= 31; day++) {
+          const dayData = monthData.day[day]
+          if (!dayData || !dayData.length) continue
+          generate(url + fmtNum(month) + '/' + fmtNum(day) + '/', new Query(dayData), {
+            year,
+            month,
+            day
+          })
+        }
+      }
+    }
+
+    return result
+  })
+}

package/scripts/generaters/config.js

@@ -0,0 +1,43 @@
+'use strict'
+/* global hexo */
+
+const merge = require('hexo-util').deepMerge || require('lodash/merge')
+const fs = require('hexo-fs')
+const path = require('path')
+const yaml = require('js-yaml')
+
+hexo.extend.filter.register('before_generate', () => {
+  if (hexo.config.theme_config) {
+    hexo.theme.config = merge(hexo.theme.config, hexo.config.theme_config)
+  }
+
+  const data = hexo.locals.get('data')
+
+  if (data.languages) {
+    const { language } = hexo.config
+    const { i18n } = hexo.theme
+
+    const mergeLang = lang => {
+      if (data.languages[lang]) { i18n.set(lang, merge(i18n.get([lang]), data.languages[lang])) }
+    }
+
+    for (const lang of ['en', 'ja', 'zh-CN', 'zh-HK', 'zh-TW']) {
+      mergeLang(lang)
+    }
+  }
+
+  hexo.theme.config.style = {}
+
+  for (const style of ['iconfont', 'colors', 'custom']) {
+    const custom_file = 'source/_data/' + style + '.styl'
+    if (fs.existsSync(custom_file)) {
+      hexo.theme.config.style[style] = path.resolve(hexo.base_dir, custom_file)
+    }
+  }
+
+  if (data.images && data.images.length > 6) {
+    hexo.theme.config.image_list = data.images
+  } else {
+    hexo.theme.config.image_list = yaml.load(fs.readFileSync(path.join(__dirname, '../../_images.yml')))
+  }
+})

package/scripts/generaters/images.js

@@ -0,0 +1,26 @@
+/* global hexo */
+'use strict'
+
+const fs = require('hexo-fs')
+
+hexo.extend.generator.register('images', function (locals) {
+  const config = hexo.config
+  const theme = hexo.theme.config
+  const dir = 'source/_data/' + theme.assets + '/'
+
+  if (!fs.existsSync(dir)) { return }
+
+  const result = []
+  const files = fs.listDirSync(dir)
+
+  files.forEach((file) => {
+    result.push({
+      path: theme.assets + '/' + file,
+      data: function () {
+        return fs.createReadStream(dir + file)
+      }
+    })
+  })
+
+  return result
+})

package/scripts/generaters/index.js

@@ -0,0 +1,110 @@
+/* global hexo */
+'use strict'
+
+const fs = require('hexo-fs')
+const pagination = require('hexo-pagination')
+
+hexo.config.index_generator = Object.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', function (locals) {
+  const covers = []
+  const catlist = []
+  let pages
+  const config = hexo.config
+  const theme = hexo.theme.config
+  const sticky = locals.posts.find({ sticky: true }).sort(config.index_generator.order_by)
+  const posts = locals.posts.find({ sticky: { $exists: false } }).sort(config.index_generator.order_by)
+  const paginationDir = config.pagination_dir || 'page'
+  const path = config.index_generator.path || ''
+  const categories = locals.categories
+
+  const getTopcat = function (cat) {
+    if (cat.parent) {
+      const pCat = categories.findOne({ _id: cat.parent })
+      return getTopcat(pCat)
+    } else {
+      return cat
+    }
+  }
+
+  if (categories && categories.length) {
+    categories.forEach((cat) => {
+      const cover = `source/_posts/${cat.slug}`
+      if (fs.existsSync(cover + '/cover.avif')) {
+        covers.push({
+          path: cat.slug + '/cover.avif',
+          data: function () {
+            return fs.createReadStream(cover + '/cover.avif')
+          }
+        })
+      } else if (fs.existsSync(cover + '/cover.webp')) {
+        covers.push({
+          path: cat.slug + '/cover.webp',
+          data: function () {
+            return fs.createReadStream(cover + '/cover.webp')
+          }
+        })
+      } else if (fs.existsSync(cover + '/cover.jpg')) {
+        covers.push({
+          path: cat.slug + '/cover.jpg',
+          data: function () {
+            return fs.createReadStream(cover + '/cover.jpg')
+          }
+        })
+
+        const topcat = getTopcat(cat)
+
+        if (topcat._id !== cat._id) {
+          cat.top = topcat
+        }
+
+        const child = categories.find({ parent: cat._id })
+        let pl = 6
+
+        if (child.length !== 0) {
+          cat.child = child.length
+          cat.subs = child.sort({ name: 1 }).limit(6).toArray()
+          pl = Math.max(0, pl - child.length)
+          if (pl > 0) {
+            // eslint-disable-next-line array-callback-return
+            cat.subs.push.apply(cat.subs, cat.posts.sort({ title: 1 }).filter(function (item, i) {
+              if (item.categories.last()._id === cat._id) { return true }
+            }).limit(pl).toArray())
+          }
+        } else {
+          cat.subs = cat.posts.sort({ title: 1 }).limit(6).toArray()
+        }
+
+        catlist.push(cat)
+      }
+    })
+  }
+
+  if (posts.length > 0) {
+    pages = pagination(path, posts, {
+      perPage: config.index_generator.per_page,
+      layout: ['index', 'archive'],
+      format: paginationDir + '/%d/',
+      data: {
+        __index: true,
+        catlist,
+        sticky
+      }
+    })
+  } else {
+    pages = [{
+      path,
+      layout: ['index', 'archive'],
+      data: {
+        __index: true,
+        catlist,
+        sticky
+      }
+    }]
+  }
+
+  return [...covers, ...pages]
+})

package/scripts/generaters/pages.js

@@ -0,0 +1,19 @@
+/* global hexo */
+'use strict'
+
+hexo.extend.generator.register('pages', function (locals) {
+  const config = hexo.config
+
+  return [
+    {
+      path: config.category_dir + '/index.html',
+      data: { type: 'categories' },
+      layout: ['page']
+    },
+    {
+      path: config.tag_dir + '/index.html',
+      data: { type: 'tags' },
+      layout: ['page']
+    }
+  ]
+})

package/scripts/generaters/script.js

@@ -0,0 +1,81 @@
+/* global hexo */
+const fs = require('hexo-fs')
+// const url = require('url')
+
+hexo.extend.generator.register('script', function (locals) {
+  const log = hexo.log || console.log
+  const config = hexo.config
+  const theme = hexo.theme.config
+
+  const env = require('../../package.json')
+
+  const siteConfig = {
+    version: env.version,
+    hostname: config.url,
+    root: config.root,
+    statics: theme.statics,
+    favicon: {
+      normal: theme.assets + '/favicon.ico',
+      hidden: theme.assets + '/failure.ico'
+    },
+    darkmode: theme.darkmode,
+    auto_dark: theme.auto_dark,
+    auto_scroll: theme.auto_scroll,
+    js: {
+      chart: theme.vendors.js.chart,
+      copy_tex: theme.vendors.js.copy_tex,
+      fancybox: theme.vendors.js.fancybox
+    },
+    css: {
+      valine: theme.css + '/comment.css',
+      katex: theme.vendors.css.katex,
+      mermaid: theme.css + '/mermaid.css',
+      fancybox: theme.vendors.css.fancybox
+    },
+    loader: theme.loader,
+    search: null,
+    valine: theme.valine,
+    outime: {
+      enable: theme.outime.enable,
+      days: theme.outime.days
+    },
+    quicklink: {
+      timeout: theme.quicklink.timeout,
+      priority: theme.quicklink.priority
+    }
+  }
+
+  if (config?.algolia) {
+    siteConfig.search = {
+      appID: config.algolia.appId,
+      apiKey: config.algolia.apiKey,
+      indexName: config.algolia.indexName,
+      hits: theme.search.hits
+    }
+  }
+
+  if (theme?.audio) {
+    siteConfig.audio = theme.audio
+  }
+
+  let text = '';
+
+  ['library', 'global', 'page', 'vue', 'components'].forEach(function (item) {
+    text += fs.readFileSync(`themes/shokaX/source/js/_app/${item}.js`).toString()
+  })
+  if (!theme.experiments?.noPlayer) {
+    text += fs.readFileSync('themes/shokaX/source/js/_app/player.js').toString()
+  }
+  if (theme.fireworks && theme.fireworks.enable) {
+    siteConfig.fireworks = theme.fireworks.color || ['rgba(255,182,185,.9)', 'rgba(250,227,217,.9)', 'rgba(187,222,214,.9)', 'rgba(138,198,209,.9)']
+  }
+
+  text = 'const CONFIG = ' + JSON.stringify(siteConfig) + ';' + text
+  const result = hexo.render.renderSync({ text, engine: 'js' })
+  return {
+    path: theme.js + '/app.js',
+    data: function () {
+      return result
+    }
+  }
+})