hexo-theme-shokax 0.4.6-dev5 → 0.4.6

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,51 @@
+'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 (data.images_index && data.images_index.length > 0) {
+        hexo.theme.config.index_images = data.images_index;
+    }
+    else 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,156 @@
+"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 package_json_1 = __importDefault(require("../../package.json"));
+const node_fs_1 = __importDefault(require("node: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,
+        audio: undefined,
+        fireworks: (theme.fireworks && theme.fireworks.enable && theme.fireworks.options)
+            ? theme.fireworks.options
+            : undefined,
+        waline: {
+            serverURL: theme.waline.serverURL,
+            lang: theme.waline.lang,
+            locale: theme.waline.locale,
+            emoji: theme.waline.emoji,
+            meta: theme.waline.meta,
+            requiredMeta: theme.waline.requiredMeta,
+            wordLimit: theme.waline.wordLimit,
+            pageSize: theme.waline.pageSize,
+            pageview: theme.waline.pageview
+        },
+        twikoo: {
+            envId: theme.twikoo.envId,
+            region: theme.twikoo.region
+        }
+    };
+    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 enterPoint;
+    if (node_fs_1.default.existsSync('themes/shokaX/source/js/_app/pjax/siteInit.ts')) {
+        enterPoint = 'themes/shokaX/source/js/_app/pjax/siteInit.ts';
+    }
+    else {
+        enterPoint = 'node_modules/hexo-theme-shokax/source/js/_app/pjax/siteInit.ts';
+    }
+    (0, esbuild_1.buildSync)({
+        entryPoints: [enterPoint],
+        bundle: true,
+        outdir: 'shokaxTemp',
+        tsconfigRaw: {
+            compilerOptions: {
+                target: 'ES2022',
+                esModuleInterop: true,
+                module: 'ESNext',
+                moduleResolution: 'Node',
+                skipLibCheck: true
+            }
+        },
+        platform: 'browser',
+        format: 'esm',
+        target: ['es2022'],
+        minify: true,
+        legalComments: 'linked',
+        mainFields: ['module', 'browser', 'main'],
+        splitting: true,
+        define: {
+            __UNLAZY_LOGGING__: 'false',
+            __UNLAZY_HASH_DECODING__: theme.modules.unlazyHash ? 'true' : 'false',
+            __shokax_player__: theme.modules.player ? 'true' : 'false',
+            __shokax_VL__: theme.modules.visibilityListener ? 'true' : 'false',
+            __shokax_fireworks__: (theme.fireworks && theme.fireworks.enable && theme.fireworks.options && theme.modules.fireworks) ? 'true' : 'false',
+            __shokax_search__: config?.algolia ? 'true' : 'false',
+            __shokax_outime__: theme.outime.enable ? 'true' : 'false',
+            __shokax_tabs__: theme.modules.tabs ? 'true' : 'false',
+            __shokax_quiz__: theme.modules.quiz ? 'true' : 'false',
+            __shokax_fancybox__: theme.modules.fancybox ? 'true' : 'false',
+            __shokax_waline__: theme.waline.enable ? 'true' : 'false',
+            __shokax_twikoo__: theme.twikoo.enable ? 'true' : 'false',
+            shokax_CONFIG: JSON.stringify(siteConfig),
+            shokax_siteURL: "'" + config.url + "'"
+        },
+        alias: {
+            'algoliasearch/lite': 'algoliasearch/dist/algoliasearch-lite.esm.browser.js'
+        }
+    });
+    const res = [];
+    node_fs_1.default.readdirSync('./shokaxTemp').forEach((file) => {
+        const fileText = node_fs_1.default.readFileSync(`./shokaxTemp/${file}`, { encoding: 'utf-8' });
+        if (file.endsWith('js')) {
+            const result = hexo.render.renderSync({ text: fileText, engine: 'js' });
+            res.push({
+                path: theme.js + '/' + file,
+                data: function () {
+                    return result;
+                }
+            });
+        }
+        else if (file.endsWith('css')) {
+            const result = hexo.render.renderSync({ text: fileText, engine: 'css' });
+            res.push({
+                path: theme.css + '/' + file,
+                data: function () {
+                    return result;
+                }
+            });
+        }
+        else {
+            res.push({
+                path: theme.js + '/' + file,
+                data: function () {
+                    return fileText;
+                }
+            });
+        }
+    });
+    return res;
+});

package/scripts/helpers/asset.js

@@ -0,0 +1,73 @@
+"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('_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 = ':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)}`,
+            media: 'none',
+            onload: "this.media='all'"
+        })
+        : '';
+});
+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}`), type: 'module', fetchpriority: 'high', defer: true }, '')).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]), 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);
+});