hexo-swpp 3.3.6 → 3.4.0-alpha.110

package/README.md

@@ -5,7 +5,7 @@
 使用时需要同时安装 `hexo-swpp` 和 `swpp-backends`：
 
 ```bash
-npm install hexo-swpp swpp-backends
+npm install hexo-swpp swpp-backends@3.0.0-alpha.100
 ```
 
 当 `swpp-backends` 存在版本更新时，可以直接更新 `swpp-backends` 版本，不需要更新 `hexo-swpp` 的版本。（不过 `hexo-swpp` 有更新的话最好也跟进一下。）
@@ -18,6 +18,7 @@ npm install hexo-swpp swpp-backends
 |     ~3.1     |      ^1.1.0      |
 |     ~3.2     |      ^2.0.0      |
 |     ~3.3     |      ^2.1.2      |
+|  4.0-alpha   | ^3.0.0-alpha.100 |
 
 ## 使用
 
@@ -25,15 +26,36 @@ npm install hexo-swpp swpp-backends
 
 ```yml
 swpp:
-  # 是否启用插件
+  # 是否启用，默认 false
   enable: true
-  # 是否在发布前自动执行脚本
-  # auto_exec: true
-  # 构建时拉取版本文件的警告等级，缺省为 1（该功能仅在 swpp-backends 版本号 >= 2.1.2 时可用）
-  # 0 - 表示不允许出现 404 情况；1 - 表示允许服务器返回 404 状态码；2 - 表示允许任何 404（包括 DNS 解析失败等）
-  # warn_level: 1
-  # 检查版本的 URL，不能以 '/' 结尾
+  # 配置文件名称，不带拓展名
+  # config_name: 'swpp.config'
+  # 是否生成 sw
+  # serviceWorker: true
+  # 是否向所有 HTML 插入注册 sw 的代码
+  # auto_register: true
+  # 是否生成 DOM 端的 JS 文件并在 HTML 中插入 script
+  # gen_dom: true
+  # 是否在执行 hexo deploy 时自动执行 swpp 指令
+  # auto_exec: false
+  # 检查更新的网址，默认 "https://registry.npmjs.org"，注意不能以斜杠结尾
   # npm_url: 'https://registry.npmmirror.com'
+  #
+  # 排序规则。
+  # 该配置项是为了对 hexo 中的一些变量进行排序，避免每次生成 HTML 时由于这些变量的顺序变动导致生成结果不完全相同。
+  # 示例：
+  # ```yaml
+  # # 下面给出的值为插件的缺省值，用户设置该项不会直接覆盖这些值，只有用户也声明 posts、pages 或 tags 时才会覆盖对应的值。
+  # swpp:
+  #   sort_rules:
+  #     posts: 'title'
+  #     pages: 'title'
+  #     tags: 'name'
+  # ```
+  #
+  # 其中 key 值为要排序的变量的名称，value 为变量排序时的依据，
+  # 填 false 表示禁用该项排序，填 true 表示以 value 本身为键进行排序，填字符串表示以 value[tag] 为键进行排序。
+  # sort_rules:
 ```
 
 插件会在生成网站时自动生成 Service Worker、注册代码、DOM 端支持代码（如果功能开启了的话），版本更新文件需要通过 `hexo swpp` 命令手动生成。
@@ -42,35 +64,23 @@ swpp:
 
 ⚠ 注意：
 
-+ 如果你的网站启用 `swpp` 后还没有发布过，请勿将 `warn_level` 设置为 0，这会导致构建失败。
 + 尽可能在压缩网站内容前执行 `hexo swpp`，因为部分压缩插件可能会出现同样的内容连续压缩结果不一样的问题，这会导致插件错误地更新缓存。
 + 如果你的网站发布过程不使用 `hexo deploy` 指令，则不要启用 `auto_exec` 选项。
 + 将 `npm_url` 调整为非官方 URL 后检查版本时可能会出现 404 错误。
 
-插件的具体配置见 [Swpp Backends 官方文档 | 山岳库博](https://kmar.top/posts/b70ec88f/)。
+SWPP v3 的文档尚未完成，敬请期待。
 
-### sort
+### 指令
 
-`hexo-swpp` 在规则文件中添加了一个配置项——`sort`，用法如下：
-
-```javascript
-module.exports.config = {
-    sort: {
-        posts: 'title',
-        pages: 'title',
-        tags: 'name'
-    }
-}
-```
-
-该配置项是为了对 hexo 中的一些变量进行排序，避免每次生成 HTML 时由于这些变量的顺序变动导致生成结果不完全相同。上方代码给出的值为插件的缺省值，用户设置该项不会直接覆盖这些值，只有用户也声明 `posts`、`pages` 或 `tags` 时才会覆盖对应的值。
-
-其中 key 值为要排序的变量的名称，value 为变量排序时的依据，填 `false` 表示禁用该项排序，填 `true` 表示以 value 本身为键进行排序，填字符串表示以 `value[tag]` 为键进行排序。
-
----
+1. `hexo swpp` - 构建 json 文件
+2. `hexo swpp -b` / `hexo swpp --build` - 构建 json 文件，同 `hexo swpp`
+3. `hexo swpp -t [URL]` / `hexo swpp --test [URL]` - 尝试拉取指定 URL，使用时将 `[URL]` 替换为有效的 HTTP/HTTPS 链接（需要附带协议头）
 
 ## 更新日志
 
++ 3.4+
+  1. 适配 `swpp-backends@3`
+
 + 3.3+
   1. 版本检查改为仅在执行 `hexo server` 时执行 \[3.3.0]
   2. 支持自定义版本更新检查的 URL \[3.3.0]
@@ -79,6 +89,8 @@ module.exports.config = {
   5. 修复 hexo7 中无法排序 tags 的问题 \[3.3.3]
   6. 修复 hexo7 中执行 `hexo g` 指令时排序报错的问题 \[3.3.5]
   7. 修复属性的值不支持使用`in`时报错的问题 \[3.3.6]
+  8. 添加新的指令 \[3.3.7]
+  9. 优化控制台输出 \[3.3.7]
 
 + 3.2+
 

package/dist/index.js

@@ -27,12 +27,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const swpp_backends_1 = __importDefault(require("swpp-backends"));
 const path_1 = __importDefault(require("path"));
+const swpp_backends_1 = require("swpp-backends");
 const logger = require('hexo-log').default();
-// noinspection JSUnusedGlobalSymbols
-function start(hexo) {
+const CONSOLE_OPTIONS = [
+    { name: '-t, --test', desc: '尝试拉取指定链接' },
+    { name: '-b, --build', desc: '构建 swpp，留空参数与使用该参数效果一致' }
+];
+let runtimeData;
+let compilationData;
+const configLoadWaitList = [];
+/** 等待配置加载 */
+function waitUntilConfig() {
+    if (runtimeData)
+        return Promise.resolve();
+    return new Promise(resolve => configLoadWaitList.push(resolve));
+}
+/** 运行插件 */
+async function start(hexo) {
+    // @ts-ignore
+    globalThis.hexo = hexo;
     const config = hexo.config;
     const pluginConfig = config['swpp'] ?? config.theme_config['swpp'];
     if (!pluginConfig?.enable)
@@ -40,44 +54,112 @@ function start(hexo) {
     if (process.argv.find(it => 'server'.startsWith(it)))
         checkVersion(pluginConfig);
     let init = false;
-    hexo.on('generateBefore', () => {
+    hexo.on('generateBefore', async () => {
         if (init)
             return;
         init = true;
-        loadRules(hexo);
-        sort(hexo);
-        buildServiceWorker(hexo);
+        buildServiceWorker(hexo, pluginConfig);
+        sort(hexo, pluginConfig);
+        await initRules(hexo, pluginConfig);
+    });
+    hexo.extend.console.register('swpp', 'Hexo Swpp 的相关指令', {
+        options: CONSOLE_OPTIONS
+    }, async (args) => {
+        const test = args.t ?? args.test;
+        // noinspection JSUnresolvedReference
+        const build = args.b ?? args.build;
+        if (test) {
+            if (typeof test == 'boolean' || Array.isArray(test) || !/^(https?):\/\/(\S*?)\.(\S*?)(\S*)$/i.test(test)) {
+                logger.error('[SWPP][CONSOLE] --test/-t 后应跟随一个有效 URL');
+            }
+            else {
+                await initRules(hexo, pluginConfig);
+                try {
+                    const response = await compilationData.compilationEnv.read('FETCH_NETWORK_FILE').fetch(test);
+                    if ([200, 301, 302, 307, 308].includes(response.status)) {
+                        logger.info('[SWPP][LINK TEST] 资源拉取成功，状态码：' + response.status);
+                    }
+                    else {
+                        logger.warn('[SWPP][LINK TEST] 资源拉取失败，状态码：' + response.status);
+                    }
+                }
+                catch (e) {
+                    logger.warn('[SWPP][LINK TEST] 资源拉取失败', e);
+                }
+            }
+        }
+        if (build) {
+            if (typeof build !== 'boolean') {
+                logger.warn('[SWPP][CONSOLE] -build/-b 后方不应跟随参数');
+            }
+        }
+        if (build || !test) {
+            try {
+                await runSwpp(hexo, pluginConfig);
+            }
+            catch (e) {
+                logger.error('执行 SWPP 指令时出现异常');
+                console.error(e);
+                process.exit(-1);
+            }
+        }
     });
     if (pluginConfig['auto_exec']) {
         hexo.on('deployBefore', async () => {
-            await runSwpp(hexo, pluginConfig);
+            try {
+                await runSwpp(hexo, pluginConfig);
+            }
+            catch (e) {
+                logger.error('执行 SWPP 指令时出现异常');
+                console.error(e);
+                process.exit(-1);
+            }
         });
     }
-    else {
-        hexo.extend.console.register('swpp', '生成前端更新需要的 json 文件及后端使用的版本文件', {}, async () => {
-            await runSwpp(hexo, pluginConfig);
-        });
+}
+async function initRules(hexo, pluginConfig) {
+    if (!runtimeData) {
+        try {
+            await loadConfig(hexo, pluginConfig);
+            configLoadWaitList.forEach(it => it());
+        }
+        catch (e) {
+            logger.error("[SWPP] 加载时遇到错误。");
+            logger.error(e);
+            process.exit(0x114514);
+        }
     }
 }
+/** 运行 swpp 指令 */
 async function runSwpp(hexo, pluginConfig) {
     const config = hexo.config;
     if (!fs.existsSync(config.public_dir))
         return logger.warn(`[SWPP] 未检测到发布目录，跳过指令执行`);
-    const rules = loadRules(hexo);
-    if (!rules.config.json)
-        return logger.error(`[SWPP] JSON 生成功能未开启，跳过指令执行`);
-    const url = config.url;
-    await Promise.all([
-        swpp_backends_1.default.loader.loadUpdateJson(url + '/update.json', pluginConfig['warn_level'] ?? 1),
-        swpp_backends_1.default.loader.loadVersionJson(url + '/cacheList.json', pluginConfig['warn_level'] ?? 1)
+    await initRules(hexo, pluginConfig);
+    const scanner = new swpp_backends_1.ResourcesScanner(compilationData);
+    const versionFile = compilationData.compilationEnv.read('SWPP_JSON_FILE');
+    const tracker = await scanner.scanLocalFile(config.public_dir);
+    const jsonBuilder = await tracker.diff();
+    function writeFile(path, content) {
+        return new Promise((resolve, reject) => {
+            fs.writeFile(path, content, 'utf-8', (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    const json = await jsonBuilder.buildJson();
+    return Promise.all([
+        writeFile(path_1.default.join(hexo.config.public_dir, versionFile.versionPath), JSON.stringify(json)),
+        writeFile(path_1.default.join(hexo.config.public_dir, versionFile.trackerPath), tracker.json())
     ]);
-    await buildVersionJson(hexo);
-    const dif = swpp_backends_1.default.builder.analyzeVersion();
-    await buildUpdateJson(hexo, dif);
 }
+/** 检查 swpp-backends 的版本 */
 function checkVersion(pluginConfig) {
     const root = pluginConfig['npm_url'] ?? 'https://registry.npmjs.org';
-    (0, node_fetch_1.default)(`${root}/swpp-backends/${swpp_backends_1.default.version}`)
+    fetch(`${root}/swpp-backends/${swpp_backends_1.swppVersion}`)
         .then(response => {
         if (![200, 301, 302, 307, 308].includes(response.status))
             return Promise.reject(response.status);
@@ -86,93 +168,89 @@ function checkVersion(pluginConfig) {
         if ('error' in json)
             return Promise.reject(json.error);
         if ('deprecated' in json) {
-            logger.error(`[SWPP VersionChecker] 您使用的 swpp-backends@${swpp_backends_1.default.version} 已被弃用，请更新版本！`);
-            logger.error(`\t补充信息：${json['deprecated']}`);
+            logger.warn(`[SWPP][VersionChecker] 您使用的 swpp-backends@${swpp_backends_1.swppVersion} 已被弃用，请更新版本！`);
+            logger.warn(`\t补充信息：${json['deprecated']}`);
+            logger.warn('请注意！！！当您看到这条消息时，表明您正在使用的后台版本存在漏洞，请务必更新版本！！！');
+            logger.info('可以使用 `npm update swpp-backends` 更新后台版本，或使用您自己常用的等效命令。');
         }
         else {
-            logger.info('[SWPP VersionChecker] 版本检查通过，注意定期检查版本更新。');
+            logger.info('[SWPP VersionChecker] 版本检查通成功，您使用的版本目前没有被废弃，注意定期检查版本更新。');
         }
     }).catch(err => {
         const isSimple = ['number', 'string'].includes(typeof err);
-        logger.warn(`[SWPP VersionChecker] 版本检查失败${isSimple ? ('（' + err + '）') : ''}`);
+        logger.warn(`[SWPP][VersionChecker] 版本检查失败${isSimple ? ('（' + err + '）') : ''}`);
         if (!isSimple)
             logger.warn(err);
     });
 }
-function loadRules(hexo) {
+/** 加载配置文件 */
+async function loadConfig(hexo, pluginConfig) {
     const themeName = hexo.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 loader = new swpp_backends_1.ConfigLoader();
+    loader.loadFromCode({
+        compilationEnv: {
+            DOMAIN_HOST: new URL(hexo.config.root, hexo.config.url)
         }
     });
-    const result = swpp_backends_1.default.loader.loadRules('./', 'sw-rules', [`./themes/${themeName}/`, `./node_modules/hexo-${themeName}/`]);
-    swpp_backends_1.default.builder.calcEjectValues(hexo);
-    return result;
-}
-async function buildUpdateJson(hexo, dif) {
-    const url = hexo.config.url;
-    const json = swpp_backends_1.default.builder.buildUpdateJson(url, dif);
-    fs.writeFileSync(`${hexo.config.public_dir}/update.json`, JSON.stringify(json), 'utf-8');
-    logger.info('成功生成：update.json');
-}
-async function buildVersionJson(hexo) {
-    const url = hexo.config.url;
-    let protocol, domain;
-    if (url.startsWith('https:')) {
-        protocol = 'https://';
-    }
-    else {
-        protocol = 'http://';
+    const configName = pluginConfig['config_name'] ?? 'swpp.config';
+    const configPaths = [configName, `./themes/${themeName}/${configName}`, `./node_modules/hexo-${themeName}/${configName}`];
+    const extnameList = ['ts', 'cts', 'mts', 'js', 'cjs', 'mjs'];
+    for (let path of configPaths) {
+        for (let extname of extnameList) {
+            const uri = `${path}.${extname}`;
+            if (fs.existsSync(uri)) {
+                await loader.load(path_1.default.resolve(uri));
+                break;
+            }
+        }
     }
-    domain = url.substring(protocol.length, url.endsWith('/') ? url.length - 1 : url.length);
-    // @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');
-    logger.info('成功生成：cacheList.json');
+    const result = loader.generate();
+    runtimeData = result.runtime;
+    compilationData = result.compilation;
 }
-function buildServiceWorker(hexo) {
-    const rules = swpp_backends_1.default.cache.readRules();
-    const pluginConfig = rules.config;
+/** 注册生成器 */
+function buildServiceWorker(hexo, hexoConfig) {
+    const { serviceWorker, auto_register, gen_dom } = hexoConfig;
     // 生成 sw
-    if (pluginConfig.serviceWorker) {
-        hexo.extend.generator.register('build_service_worker', () => {
-            return {
-                path: 'sw.js',
-                data: swpp_backends_1.default.builder.buildServiceWorker()
-            };
+    if (serviceWorker ?? true) {
+        hexo.extend.generator.register('build_service_worker', async () => {
+            await waitUntilConfig();
+            return ({
+                path: compilationData.compilationEnv.read('SERVICE_WORKER') + '.js',
+                data: new swpp_backends_1.SwCompiler().buildSwCode(runtimeData)
+            });
         });
     }
     // 生成注册 sw 的代码
-    if (pluginConfig.register) {
-        hexo.extend.injector.register('head_begin', () => pluginConfig.register.builder(hexo.config.url, hexo, pluginConfig));
+    if (auto_register ?? true) {
+        waitUntilConfig().then(() => {
+            hexo.extend.injector.register('head_begin', `<script>(${runtimeData.domConfig.read('registry')})()</script>`);
+        });
     }
     // 生成 sw-dom.js
-    if (pluginConfig.dom) {
-        // noinspection HtmlUnknownTarget
-        hexo.extend.injector.register('head_end', `<script defer src="/sw-dom.js"></script>`);
-        hexo.extend.generator.register('build_dom_js', () => {
+    if (gen_dom ?? true) {
+        hexo.extend.injector.register('head_end', () => {
+            // noinspection HtmlUnknownTarget
+            return `<script defer src="/sw-dom.js"></script>`;
+        });
+        hexo.extend.generator.register('build_dom_js', async () => {
+            await waitUntilConfig();
             return {
                 path: 'sw-dom.js',
-                data: swpp_backends_1.default.builder.buildDomJs()
+                data: runtimeData.domConfig.buildJsSource()
             };
         });
     }
 }
 /** 对 hexo 中的变量进行排序 */
-function sort(hexo) {
+function sort(hexo, pluginConfig) {
     const version = hexo.version;
     let Locals;
     if (version.startsWith('7')) {
-        Locals = require(path_1.default.resolve('./', 'node_modules/hexo/dist/hexo/locals')).prototype;
+        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;
+        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;
@@ -229,8 +307,7 @@ function sort(hexo) {
         pages: 'title',
         tags: 'name'
     };
-    // @ts-ignore
-    Object.assign(list, swpp_backends_1.default.cache.readRules().config['sort'] ?? {});
+    Object.assign(list, pluginConfig.sort_rules ?? {});
     const getter = Locals.get;
     Locals.get = function (name) {
         const result = getter.call(this, name);
@@ -245,13 +322,8 @@ function sort(hexo) {
         return result;
     };
 }
-try {
-    // noinspection TypeScriptUnresolvedReference
-    // @ts-ignore
-    start(hexo);
-}
-catch (e) {
-    logger.error("[SWPP] 加载时遇到错误，可能是由于缺少规则文件。");
+start(hexo).catch(e => {
+    logger.error("[SWPP] 加载时遇到严重错误！");
     logger.error(e);
-    process.exit(114514);
-}
+    process.exit(0x19491001);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hexo-swpp",
-  "version": "3.3.6",
+  "version": "3.4.0-alpha.110",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
   "files": [
@@ -22,17 +22,15 @@
   },
   "homepage": "https://kmar.top/posts/73014407/",
   "devDependencies": {
-    "@types/node": "^20.4.7",
-    "@types/node-fetch": "^2.6.4",
-    "hexo": "7.0.0",
-    "typescript": "^5.1.6"
+    "@types/node": "^22.0.2",
+    "hexo": "^7.3.0",
+    "typescript": "^5.5.4"
   },
   "dependencies": {
-    "hexo-log": "^4.1.0",
-    "node-fetch": "^2.6.12"
+    "hexo-log": "^4.1.0"
   },
   "peerDependencies": {
-    "swpp-backends": "^2.1.2"
+    "swpp-backends": "^3.0.0-ahpla.100"
   },
   "scripts": {}
 }