hexo-theme-shokax 0.3.14 → 0.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hexo-theme-shokax",
-    "version": "0.3.14",
+    "version": "0.3.15",
     "description": "a hexo theme based on shoka",
     "main": "index.js",
     "repository": "https://github.com/theme-shoka-x/hexo-theme-shokaX",

package/scripts/filters/locals.js

@@ -0,0 +1,52 @@
+// @ts-ignore
+const fmtNum = (num) => {
+    return num < 10 ? '0' + num : num;
+};
+hexo.extend.filter.register('template_locals', (locals) => {
+    const { config } = hexo;
+    const { __, theme } = locals;
+    // @ts-ignore
+    const { i18n } = hexo.theme;
+    const pangu = {
+        spacing: (data) => {
+            return data;
+        }
+    };
+    // Language & Config
+    // 根据主题配置的 Creative Commons 许可证生成链接
+    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
+    // 根据主题配置的 Creative Commons 许可证生成链接
+    if (theme.creative_commons.license === 'zero') {
+        locals.ccURL = 'https://creativecommons.org/' + 'publicdomain/zero/1.0/' + (theme.creative_commons.language || '');
+    }
+    else {
+        locals.ccURL = 'https://creativecommons.org/' + '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,5 @@
+/* global hexo */
+hexo.extend.filter.register('after_post_render', (data) => {
+    // 使用正则表达式将<img>标签的src属性替换为data-src属性
+    data.content = data.content.replace(/(<img[^>]*) src=/img, '$1 loading="lazy" data-src=');
+}, 0);

package/scripts/generaters/archive.js

@@ -0,0 +1,133 @@
+/* global hexo */
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const hexo_pagination_1 = __importDefault(require("hexo-pagination"));
+// @ts-ignore
+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';
+        // @ts-ignore
+        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((0, hexo_pagination_1.default)(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 = {};
+        // 按日期对文章进行分类
+        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个数组. 第一个数组是给这一年的文章准备的
+                // 其他则是各个月份的文章
+                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,48 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* global hexo */
+const hexo_util_1 = require("hexo-util");
+const node_fs_1 = __importDefault(require("node:fs"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+hexo.extend.filter.register('before_generate', () => {
+    if (hexo.config.theme_config) {
+        // @ts-ignore
+        hexo.theme.config = (0, hexo_util_1.deepMerge)(hexo.theme.config, hexo.config.theme_config);
+    }
+    const data = hexo.locals.get('data');
+    if (data.languages) {
+        // @ts-ignore
+        const { i18n } = hexo.theme;
+        const mergeLang = lang => {
+            if (data.languages[lang]) { // @ts-ignore
+                i18n.set(lang, (0, hexo_util_1.deepMerge)(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 (node_fs_1.default.existsSync(custom_file)) {
+            hexo.theme.config.style[style] = path_1.default.resolve(hexo.base_dir, custom_file);
+        }
+    }
+    if (data.images && data.images.length > 0) {
+        hexo.theme.config.image_list = data.images;
+    }
+    else {
+        hexo.theme.config.image_list = js_yaml_1.default.load(node_fs_1.default.readFileSync(path_1.default.join(__dirname, '../../_images.yml'), { encoding: 'utf-8' }));
+    }
+    if (node_fs_1.default.existsSync(path_1.default.join(__dirname, '../../_images_index.yml'))) {
+        hexo.theme.config.index_images = js_yaml_1.default.load(node_fs_1.default.readFileSync(path_1.default.join(__dirname, '../../_images_index.yml'), { encoding: 'utf-8' }));
+    }
+    else {
+        hexo.theme.config.index_images = data.index_images || [];
+    }
+});

package/scripts/generaters/images.js

@@ -0,0 +1,23 @@
+/* global hexo */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const fs = require("hexo-fs");
+hexo.extend.generator.register('images', function (locals) {
+    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,107 @@
+// @ts-nocheck
+/* global hexo */
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("hexo-fs");
+const hexo_pagination_1 = __importDefault(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 sticky = locals.posts.find({ sticky: true }).sort(config.index_generator.order_by);
+    const posts = locals.posts.find({ sticky: { $in: [false, undefined] } }).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) {
+                        cat.subs.push(...cat.posts.sort({ title: 1 })
+                            .filter(function (item, i) { return item.categories.last()._id === cat._id; })
+                            .limit(pl).toArray());
+                    }
+                }
+                else {
+                    cat.subs = cat.posts.sort({ title: 1 }).limit(6).toArray();
+                }
+                catlist.push(cat);
+            }
+        });
+    }
+    if (posts.length > 0) {
+        pages = (0, hexo_pagination_1.default)(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,
+                    current: 1,
+                }
+            }];
+    }
+    return [...covers, ...pages];
+});

package/scripts/generaters/pages.js

@@ -0,0 +1,15 @@
+hexo.extend.generator.register('pages', function () {
+    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,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* global hexo */
+const package_json_1 = __importDefault(require("../../package.json"));
+const fs = __importStar(require("hexo-fs"));
+const esbuild_1 = require("esbuild");
+const utils_1 = require("../utils");
+hexo.extend.generator.register('script', function (locals) {
+    const config = hexo.config;
+    const theme = hexo.theme.config;
+    const siteConfig = {
+        version: package_json_1.default.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: {
+            copy_tex: (0, utils_1.getVendorLink)(hexo, theme.vendors.async_js.copy_tex),
+            fancybox: (0, utils_1.getVendorLink)(hexo, theme.vendors.async_js.fancybox)
+        },
+        css: {
+            katex: (0, utils_1.getVendorLink)(hexo, theme.vendors.css.katex),
+            mermaid: theme.css + '/mermaid.css',
+            fancybox: (0, utils_1.getVendorLink)(hexo, theme.vendors.css.fancybox),
+            justifiedGallery: (0, utils_1.getVendorLink)(hexo, theme.vendors.css.justifiedGallery)
+        },
+        loader: theme.loader,
+        search: null,
+        outime: {
+            enable: theme.outime.enable,
+            days: theme.outime.days
+        },
+        quicklink: {
+            timeout: theme.quicklink.timeout,
+            priority: theme.quicklink.priority
+        },
+        playerAPI: theme.playerAPI,
+        disableVL: theme.disableVL,
+        noPlayer: theme.experiments?.noPlayer,
+        audio: undefined,
+        fireworks: (theme.fireworks && theme.fireworks.enable && theme.fireworks.options)
+            ? theme.fireworks.options
+            : undefined
+    };
+    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;
+    let enterPoint;
+    if (fs.existsSync('themes/shokaX/source/js/_app/pjax/siteInit.js')) {
+        enterPoint = 'themes/shokaX/source/js/_app/pjax/siteInit.js';
+    }
+    else {
+        enterPoint = 'node_modules/hexo-theme-shokax/source/js/_app/pjax/siteInit.js';
+    }
+    text = 'const CONFIG = ' + JSON.stringify(siteConfig) + ';';
+    (0, esbuild_1.buildSync)({
+        entryPoints: [enterPoint],
+        bundle: true,
+        outfile: 'shokax_temp.js',
+        platform: 'browser',
+        format: 'iife',
+        target: ['es2022'],
+        minify: true,
+        define: {
+            __UNLAZY_LOGGING__: 'false'
+        }
+    });
+    text += fs.readFileSync('shokax_temp.js');
+    const result = hexo.render.renderSync({ text, engine: 'js' });
+    fs.unlinkSync('shokax_temp.js');
+    return {
+        path: theme.js + '/app.js',
+        data: function () {
+            return result;
+        }
+    };
+});

package/scripts/helpers/asset.js

@@ -0,0 +1,147 @@
+"use strict";
+/* global hexo */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const package_json_1 = __importDefault(require("../../package.json"));
+const hexo_util_1 = require("hexo-util");
+const utils_1 = require("../utils");
+hexo.extend.helper.register('_new_comments', function (mode) {
+    const root = this.config.url.replace(/^(https?:\/\/)?[^\/]*/, '');
+    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,
+                          root: '${root}'
+                      }
+                  }
+                  }).mount('#new-comment')
+            }).catch(function (err) {
+                console.error(err)
+            })
+        </script>`;
+    }
+    else if (mode === 'waline') {
+        return `
+    <script type="module" data-pjax>
+        let items = []
+        import { RecentComments } from 'https://npm.webcache.cn/@waline/client@v2/dist/waline.mjs'
+        RecentComments({
+          serverURL: '${hexo.theme.config.waline.serverURL.replace(/\/+$/, '')}',
+          count: 10,
+        }).then(({ comments }) => {
+          comments.forEach(function (item) {
+              let cText = (item.orig.length > 50) ? item.orig.substring(0,50)+'...' : item.orig
+              item.url = item.url.startsWith('/') ? item.url : '/' + item.url;
+              const siteLink = item.url + "#" + item.objectId
+              items.push({
+                  href: siteLink,
+                  nick: item.nick,
+                  time: item.insertedAt.split('T').shift(),
+                  text: cText
+              })
+          })
+          Vue.createApp({
+            data() {
+                return {
+                    coms: items,
+                    root: '${root}'
+                }
+            }
+          }).mount('#new-comment')
+        }).catch(function (err) {
+          console.error(err)
+        })
+    </script>
+    `;
+    }
+    else {
+        console.log(`${mode} is not supported recent comment`);
+    }
+});
+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 package_json_1.default[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 = 'https://fonts.googleapis.com';
+    // 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 !== '');
+    // @ts-ignore
+    fontFamilies = [...new Set(fontFamilies)];
+    // @ts-ignore
+    fontFamilies = fontFamilies.join('|');
+    // Merge extra parameters to the final processed font string
+    return fontFamilies
+        ? (0, hexo_util_1.htmlTag)('link', {
+            rel: 'stylesheet',
+            href: `${fontHost}/css?family=${fontFamilies.concat(fontDisplay, fontSubset)}`
+        })
+        : '';
+});
+hexo.extend.helper.register('_css', function (...urls) {
+    const { statics, css } = hexo.theme.config;
+    return urls.map(url => (0, hexo_util_1.htmlTag)('link', {
+        rel: 'stylesheet',
+        href: hexo_util_1.url_for.call(this, `${statics}${css}/${url}?v=${package_json_1.default.version}`)
+    })).join('');
+});
+hexo.extend.helper.register('_js', function (...urls) {
+    const { statics, js } = hexo.theme.config;
+    return urls.map(url => (0, hexo_util_1.htmlTag)('script', { src: hexo_util_1.url_for.call(this, `${statics}${js}/${url}?v=${package_json_1.default.version}`) }, '')).join('');
+});
+hexo.extend.helper.register('vendor_js', function () {
+    const vendors = hexo.theme.config.vendors;
+    let res = '';
+    for (const jsSync in vendors.js) {
+        res += (0, hexo_util_1.htmlTag)('script', { src: (0, utils_1.getVendorLink)(hexo, vendors.js[jsSync]) }, '');
+    }
+    // for (const jsAsync in vendors.async_js) {
+    //   res += htmlTag('script', { src: getVendorLink(hexo, vendors.async_js[jsAsync]), async: true }, '')
+    // }
+    return res;
+});
+hexo.extend.helper.register('_striptags', function (data) {
+    return (0, hexo_util_1.stripHTML)(data);
+});
+hexo.extend.helper.register('_truncate', function (data, end) {
+    return data.substring(0, end);
+});