hexo-swpp 2.8.9 → 3.0.0-alpha

package/README.md

@@ -1,13 +1,3 @@
   该插件用于在 hexo 中自动构建可用的 ServiceWorker，插件内自带了一个缺省的 sw.js，也支持使用自定义的 sw。
 
-  具体说明见：[小白也能用的 SW 构建插件 - 山岳库博](https://kmar.top/posts/73014407/)
-
----
-
-  插件版本：A.B.C：
-
-+ A：重大功能更新时变化
-+ B：修改配置文件或功能更新时变化
-+ C：BUG 修复时变化
-
-  所以 C 修改时务必更新版本，A、B 修改时可酌情追更，由于本人不会维护旧版本的代码，所以仍然建议使用最新版本的插件。
+  三代版本仍在开发中，有兴趣的可以先看一看 v2 分支。

package/dist/index.js

@@ -0,0 +1,193 @@
+"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 });
+const fs = __importStar(require("fs"));
+const swpp_backends_1 = __importDefault(require("swpp-backends"));
+const path_1 = __importDefault(require("path"));
+const logger = require('hexo-log').default();
+// noinspection JSUnusedGlobalSymbols
+function start(hexo) {
+    const { config } = hexo;
+    if (!(config['swpp']?.enable || hexo.theme.config['swpp']?.enable))
+        return;
+    const themeName = config.theme;
+    swpp_backends_1.default.event.addRulesMapEvent(rules => {
+        if ('cacheList' in rules && !('cacheRules' in rules)) {
+            rules.cacheRules = rules['cacheList'];
+            delete rules['cacheList'];
+        }
+        if ('getCdnList' in rules && !('getRaceUrls' in rules)) {
+            rules.getRaceUrls = rules['getCdnList'];
+            delete rules['getCdnList'];
+        }
+    });
+    const rules = swpp_backends_1.default.loader.loadRules('./', 'sw-rules', [`./themes/${themeName}/`, `./node_modules/hexo-${themeName}/`]);
+    swpp_backends_1.default.builder.calcEjectValues(hexo);
+    sort(hexo);
+    buildServiceWorker(hexo);
+    if (rules.config.json) {
+        hexo.extend.console.register('swpp', '生成前端更新需要的 json 文件及后端使用的版本文件', {}, async () => {
+            if (!fs.existsSync(hexo.config.public_dir))
+                return logger.warn(`[SWPP] 未检测到发布目录，跳过指令执行`);
+            const url = hexo.config.url;
+            await swpp_backends_1.default.loader.loadUpdateJson(url + '/update.json');
+            const versionJson = await swpp_backends_1.default.loader.loadVersionJson(url + '/cacheList.json');
+            let forceRefreshCache = false;
+            if ('update' in rules) {
+                const update = rules.update;
+                const { flag, change, refresh, force } = update;
+                if (!flag) {
+                    logger.error(`[SWPP Console] 规则文件的 update 项目必须包含 flag 值！`);
+                    throw 'update.flag 缺失';
+                }
+                swpp_backends_1.default.event.submitCacheInfo({ updateFlag: flag });
+                if (flag !== versionJson.external.flag) {
+                    if (change)
+                        swpp_backends_1.default.event.submitChange(...change);
+                    if (refresh)
+                        refresh.forEach(swpp_backends_1.default.event.refreshUrl);
+                    if (force)
+                        forceRefreshCache = true;
+                }
+            }
+            await buildVersionJson(hexo);
+            const dif = swpp_backends_1.default.builder.analyze(swpp_backends_1.default.cache.readNewVersionJson());
+            if (forceRefreshCache)
+                dif.force = true;
+            await buildUpdateJson(hexo, dif);
+        });
+    }
+}
+async function buildUpdateJson(hexo, dif) {
+    const url = hexo.config.url;
+    const json = swpp_backends_1.default.builder.buildNewInfo(url, dif);
+    fs.writeFileSync(`${hexo.config.public_dir}/update.json`, JSON.stringify(json), 'utf-8');
+}
+async function buildVersionJson(hexo) {
+    const url = hexo.config.url;
+    let protocol, domain;
+    if (url.startsWith('https:')) {
+        protocol = 'https://';
+        domain = url.substring(protocol.length + 1);
+    }
+    else {
+        protocol = 'http://';
+        domain = url.substring(protocol.length + 1);
+    }
+    // @ts-ignore
+    const json = await swpp_backends_1.default.builder.buildVersionJson(protocol, domain, path_1.default.resolve('./', hexo.config.public_dir));
+    fs.writeFileSync(`${hexo.config.public_dir}/cacheList.json`, JSON.stringify(json), 'utf-8');
+}
+function buildServiceWorker(hexo) {
+    const rules = swpp_backends_1.default.cache.readRules();
+    const pluginConfig = rules.config;
+    // 生成 sw
+    if (pluginConfig.serviceWorker) {
+        hexo.extend.generator.register('build_service_worker', () => {
+            return {
+                path: 'sw.js',
+                data: swpp_backends_1.default.builder.buildServiceWorker()
+            };
+        });
+    }
+    // 生成注册 sw 的代码
+    if (pluginConfig.register) {
+        hexo.extend.injector.register('head_begin', () => pluginConfig.register.builder(hexo.config.url, hexo, pluginConfig));
+    }
+    // 生成 sw-dom.js
+    if (pluginConfig.dom) {
+        // noinspection HtmlUnknownTarget
+        hexo.extend.injector.register('body_begin', () => `<script src="/sw-dom.js"></script>`);
+        hexo.extend.generator.register('build_dom_js', () => {
+            const template = fs.readFileSync(path_1.default.resolve('./', 'node_modules/swpp-backends/dist/resources/sw-dom.js'), 'utf-8').replaceAll(`// \${onSuccess}`, `(${pluginConfig.dom.onsuccess.toString()})()`);
+            return {
+                path: 'sw-dom.js',
+                data: template
+            };
+        });
+    }
+}
+/** 对 hexo 中的变量进行排序 */
+function sort(hexo) {
+    const version = hexo.version;
+    let Locals;
+    if (version.startsWith('7')) {
+        Locals = require(path_1.default.resolve('./', 'node_modules/hexo/dist/hexo/locals')).prototype;
+    }
+    else {
+        Locals = require(path_1.default.resolve('./', 'node_modules/hexo/lib/hexo/locals')).prototype;
+    }
+    const compare = (a, b) => {
+        const result = a.length === b.length ? a < b : a.length < b.length;
+        return result ? -1 : 1;
+    };
+    const sort = (obj, value) => {
+        if (!obj)
+            return;
+        const target = obj.data ?? obj;
+        if (!target.sort)
+            return;
+        if (typeof value === 'boolean') {
+            if (value)
+                target.sort(compare);
+        }
+        else {
+            target.sort((a, b) => compare(a[value], b[value]));
+        }
+    };
+    const list = {
+        posts: 'title',
+        pages: 'title',
+        tags: 'name'
+    };
+    // @ts-ignore
+    Object.assign(list, swpp_backends_1.default.cache.readRules().config['sort']);
+    const getter = Locals.get;
+    Locals.get = function (name) {
+        const result = getter.call(this, name);
+        if (name in list)
+            sort(result, list[name]);
+        if ('forEach' in result) {
+            result.forEach((it) => {
+                for (let tag in list)
+                    sort(it[tag], list[tag]);
+            });
+        }
+        return result;
+    };
+}
+try {
+    // noinspection TypeScriptUnresolvedReference
+    // @ts-ignore
+    start(hexo);
+}
+catch (e) {
+    logger.error("[SWPP] 加载时遇到错误，可能是由于缺少规则文件。");
+    logger.error(e);
+    process.exit(114514);
+}

package/package.json

@@ -1,35 +1,34 @@
-{
-  "name": "hexo-swpp",
-  "version": "2.8.9",
-  "main": "index.js",
-  "dependencies": {
-    "cheerio": "^1.0.0-rc.12",
-    "hexo-log": "^3.0.0",
-    "node-fetch": "^2.6.9",
-    "postcss": "^8.4.27"
-  },
-  "files": [
-    "index.js",
-    "lib/sw-template.js",
-    "lib/sw-dom.js",
-    "lib/swBuilder.js",
-    "lib/jsonBuilder.js",
-    "lib/sort.js",
-    "lib/configLoader.js",
-    "lib/utils.js"
-  ],
-  "keywords": [
-    "hexo",
-    "sw",
-    "ServiceWorker",
-    "json",
-    "auto"
-  ],
-  "author": "kmar",
-  "license": "AGPL-3.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/EmptyDreams/hexo-swpp.git"
-  },
-  "homepage": "https://kmar.top/posts/73014407/"
+{
+  "name": "hexo-swpp",
+  "version": "3.0.0-alpha",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "keywords": [
+    "hexo",
+    "sw",
+    "ServiceWorker",
+    "json",
+    "auto"
+  ],
+  "author": "kmar",
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EmptyDreams/hexo-swpp.git"
+  },
+  "homepage": "https://kmar.top/posts/73014407/",
+  "devDependencies": {
+    "@types/node": "^20.4.7",
+    "hexo": "7.0.0-rc2",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "hexo-log": "^4.1.0",
+    "swpp-backends": "0.0.5-alpha"
+  },
+  "scripts": {}
 }

package/types/index.d.ts

@@ -0,0 +1,7 @@
+import { ChangeExpression } from 'swpp-backends';
+export interface HexoSwppUpdate {
+    flag: any;
+    force?: boolean;
+    change?: ChangeExpression[];
+    refresh?: string[];
+}

package/index.js

@@ -1,59 +0,0 @@
-// noinspection JSUnresolvedVariable
-
-"use strict"
-
-const config = hexo.config
-const enable = (config.swpp ?? hexo.theme.config.swpp)?.enable
-
-if (enable) {
-    try {
-        const configLoader = require('./lib/configLoader')
-        const rules = configLoader.load(hexo)
-        const ejectValues = calcEjectValues(hexo, rules)
-        // 排序
-        require('./lib/sort')(rules.config)
-        // 生成 update.json
-        require('./lib/jsonBuilder')(hexo, config, rules, ejectValues?.obj)
-        // 生成 sw.js
-        require('./lib/swBuilder')(hexo, config, rules, ejectValues?.str)
-    } catch (e) {
-        const logger = require('hexo-log')()
-        logger.error('[SWPP Index] 加载过程中遇到了错误：')
-        process.exit(114514)
-    }
-}
-
-/**
- * 计算导出的键值表
- * @param hexo
- * @param rules
- * @return {?{str: string, obj: *}}
- */
-function calcEjectValues(hexo, rules) {
-    if (!('ejectValues' in rules)) return null
-    const { getSource } = require('./lib/utils')
-    const obj = rules.ejectValues(hexo, rules)
-    const nodeObj = {}
-    let result = ''
-    for (let key in obj) {
-        if (!key.match(/^[A-Za-z0-9]+$/)) {
-            logger.error(`[SWPP EjectValues] 变量名 [${key}] 仅允许包含英文字母和阿拉伯数字！`)
-            throw "变量名异常：" + key
-        }
-        const data = obj[key]
-        const type = typeof data.value
-        nodeObj[key] = data.value
-        switch (type) {
-            case 'undefined': break
-            case 'boolean': case 'number': case 'string': case 'bigint':
-                result += `    ${data.prefix} eject${key[0].toUpperCase()}${key.substring(1)} = ${getSource(data.value)}`
-                break
-            default:
-                logger.error(`[SWPP EjectValues] 不支持导出 ${type} 类型的数据。`)
-                throw `不支持的键值：key=${key}, value type=${type}`
-        }
-    }
-    return {
-        obj: nodeObj, str: result
-    }
-}

package/lib/configLoader.js

@@ -1,236 +0,0 @@
-// 配置加载器
-
-const logger = require('hexo-log')()
-
-// 加载 sw-rules.js
-module.exports.load = hexo => {
-    const rules = loadRules(hexo)
-    const handle = (obj, def, list) => {
-        for (let key in def) {
-            const defValue = def[key]
-            const value = obj[key]
-            switch (typeof value) {
-                case 'undefined':
-                    obj[key] = defValue
-                    break
-                case 'object':
-                    const defA = Array.isArray(defValue)
-                    const objA = Array.isArray(value)
-                    if (defA !== objA) {
-                        logger.error(`[ConfigLoader] ${list.join('.')} 值与标准值类型不相同！已经使用默认配置项替代。`)
-                        obj[key] = defValue
-                        break
-                    }
-                    if (!defA) {
-                        list.push(key)
-                        handle(value, defValue, list)
-                        list.pop()
-                    }
-                    break
-                case 'boolean':
-                    break
-            }
-        }
-    }
-    if (!('config' in rules)) {
-        logger.error("[ConfigLoader] 未在 sw-rules.js 中查询到配置项！")
-        throw '配置项缺失！'
-    }
-    handle(rules.config, defConfig, [])
-    return rules
-}
-
-// 存储缺省配置
-const defConfig = {
-    // sw 有关配置项
-    serviceWorker: {
-        /**
-         * 逃生门
-         * @type number
-         * @see https://kmar.top/posts/73014407/#6c7c33f0
-         */
-        escape: 0,
-        /**
-         * 缓存库名称
-         * 发布网站后 **切勿修改** 该配置项！
-         * @type string
-         */
-        cacheName: 'kmarBlogCache',
-        /**
-         * 是否启用调试，启用后会在 sw 中插入一些辅助调试的代码，不建议开启
-         * @type boolean
-         */
-        debug: false
-    },
-    // 与 SW 注册有关的配置项
-    register: {
-        /**
-         * sw 注册成功时的动作
-         * @type ?VoidFunction
-         * */
-        onsuccess: undefined,
-        /**
-         * sw 注册失败时的动作
-         * @type ?VoidFunction
-         */
-        onerror: undefined,
-        /**
-         * 生成注册 SW 的 HTML 代码片段
-         * @param root {string} 网页根目录的 URL
-         * @param hexoConfig {Object} Hexo 配置项
-         * @param pluginConfig {Object} SW 配置项
-         * @return {string} 一个 HTML 标签的字符串形式
-         */
-        builder: (root, hexoConfig, pluginConfig) => {
-            const {onerror, onsuccess} = pluginConfig.register
-            return `<script>
-                (() => {
-                    const sw = navigator.serviceWorker
-                    const error = ${onerror.toString()}
-                    if (!sw?.register('${new URL(root).pathname}sw.js')
-                        ${onsuccess ? '?.then(' + onsuccess + ')' : ''}
-                        ?.catch(error)
-                        ) error()
-                })()
-            </script>`
-        }
-    },
-    // 与 DOM 端有关的配置项
-    dom: {
-        /**
-         * 版本更新完成后的动作
-         * @type VoidFunction
-         */
-        onsuccess: () => {}
-    },
-    /**
-     * 与插件生成的版本文件相关的配置项
-     * 该功能目前无法关闭
-     */
-    json: {
-        /**
-         * 更新缓存时允许更新的最大 HTML 页面数量，需要更新的 HTML 文件数量超过这个值后会清除所有 HTML 缓存
-         * @type number
-         */
-        maxHtml: 15,
-        /**
-         * 版本文件（update.json）字符数量限制，插件将保证版本文件的字符数量不超过该值
-         * @type number
-         */
-        charLimit: 1024,
-        /**
-         * 文件缓存匹配采取精确模式
-         * 关闭时更新缓存时仅匹配文件名称，如 https://kmar.top/simple/a/index.html 仅匹配 /a/index.html
-         * 开启后更新缓存时将会匹配完整名称，如 https://kmar.top/simple/a/index.html 将匹配 /simple/a/index.html
-         * 两种方式各有优劣，开启后会增加 update.json 的空间占用，但会提升精确度
-         * 如果网站内没有多级目录结构，就可以放心大胆的关闭了
-         * key 值为文件拓展名，default 用于指代所有未列出的拓展名以及没有拓展名的文件
-         */
-        precisionMode: {
-            default: false
-        },
-        /**
-         * 是否合并指定项目
-         * 例如当 tags 为 true 时（假设标签目录为 https://kmar.top/tags/...）
-         * 如果标签页存在更新，则直接匹配 https://kmar.top/tags/ 目录下的所有文件
-         * **推荐将此项开启**
-         */
-        merge: {
-            index: true,
-            tags: true,
-            archives: true,
-            categories: true,
-            /**
-             * 这里填写目录名称列表（不带两边的斜杠）
-             * @type string[]
-             */
-            custom: []
-        },
-        /**
-         * 生成版本文件时忽略的文件
-         * 注：匹配的时候不附带域名，只有 pathname，匹配的内容一定是博客本地的文件
-         * @type RegExp[]
-         */
-        exclude: [
-            /sw\.js$/
-        ]
-    },
-    /**
-     * 外部文件更新监听
-     * @see https://kmar.top/posts/73014407/#c60b3060
-     */
-    external: {
-        /**
-         * 拉取网络文件时的超时时间
-         * @type number
-         */
-        timeout: 1500,
-        /**
-         * 匹配 JS 代码中的 URL
-         * @see https://kmar.top/posts/73014407/#c60b3060
-         */
-        js: [],
-        /**
-         * 某些外链只要 URL 不变其内容就一定不会变
-         * 可以通过正则表达式排除这些外链的文件内容监控，加快构建速度
-         * 注意：当某一个文件被跳过拉取后，这个文件中包含的 URL 也会被跳过
-         * @type RegExp[]
-         */
-        skip: [],
-        /**
-         * 在构建过程中替换部分链接，该替换结果不会影响文件内容
-         * 该设置项是为了应对构建服务器在国外，但是网站内部分缓存资源无法在国外访问导致拉取时超时的问题
-         * @type Object[]
-         * @see https://kmar.top/posts/73014407/#4ea71e00
-         */
-        replace: []
-    },
-    /**
-     * 对 Hexo 中的变量进行排序
-     * 默认插件对 posts、tags、categories、pages 四个变量进行排序
-     * 排序规则为优先按照字符串长度排序，若长度一致按照字典序排序
-     */
-    sort: {}
-}
-
-// 加载 sw-rules.js 文件
-const loadRules = hexo => {
-    // noinspection JSUnresolvedReference
-    const themeName = hexo.config.theme
-    // noinspection JSUnresolvedReference
-    const rulesFileName = (hexo.config.swpp?.rules ?? hexo.theme.config.swpp?.rules) ?? 'sw-rules'
-    const nodePath = require('path')
-    const fs = require('fs')
-    const rootList = ['./', `./themes/${themeName}/`, `./node_modules/hexo-theme-${themeName}/`]
-    const fileNameList = [`${rulesFileName}.cjs`, `${rulesFileName}.js`]
-
-    /** 尝试在指定目录下查询 rules 文件 */
-    function findRules(root) {
-        for (let name of fileNameList) {
-            const path = nodePath.resolve(root, name)
-            if (fs.existsSync(path))
-                return path
-        }
-        return null
-    }
-
-    const paths = {
-        root: findRules(rootList[0]),
-        themes: findRules(rootList[1]),
-        modules: findRules(rootList[2])
-    }
-    if (!(paths.root || paths.themes || paths.modules)) {
-        const tip = "未找到 sw-rules 文件"
-        logger.error(`[sw-rules]: ${tip}`)
-        throw tip
-    }
-    let result = {}
-    if (paths.themes)
-        result = require(paths.themes)
-    else if (paths.modules) {
-        result = require(paths.modules)
-    }
-    if ('afterTheme' in result)
-        logger.error("[sw-rules]: 主题目录下的 sw-rules.js 中不应当包含 afterTheme 函数！")
-    return paths.root ? { ...result, ...require(paths.root) } : result
-}