hexo-swpp 1.0.0

package/index.js

@@ -0,0 +1,395 @@
+// noinspection DuplicatedCode
+
+"use strict"
+
+const fs = require('fs')
+const logger = require('hexo-log')()
+const axios = require('axios')
+const path = require('path')
+
+const findScript = () => path.resolve('./', 'sw-cache')
+
+// noinspection JSUnresolvedVariable
+const config = hexo.config
+const pluginConfig = config.version
+const root = config.url + config.root
+const { cacheList, replaceList } = require(findScript())
+
+// 生成 update.json
+// noinspection JSUnresolvedVariable
+hexo.on('exit', async () => {
+    if (!fs.existsSync('public/index.html')) return logger.info('跳过生成')
+    const cachePath = 'cacheList.json'
+    const updatePath = 'update.json'
+    const oldCache = await getJsonFromNetwork(cachePath)
+    const oldUpdate = await getJsonFromNetwork(updatePath)
+    const newCache = buildNewJson(cachePath)
+    const dif = compare(oldCache, newCache)
+    buildUpdateJson(updatePath, dif, oldUpdate)
+})
+
+// 生成 sw.js
+// noinspection JSUnresolvedVariable
+hexo.extend.generator.register('buildSw', () => {
+    // noinspection JSUnresolvedVariable
+    if (pluginConfig.customJS) return
+    const absPath = module.path + '/sw-template.js'
+    const rootPath = path.resolve('./')
+    const relativePath = path.relative(rootPath, absPath)
+    const template = fs.readFileSync(relativePath, 'utf8')
+    const cache = fs.readFileSync('sw-cache.js', 'utf8')
+        .replace('module.exports.cacheList', 'const cacheList')
+        .replace('module.exports.replaceList', 'const replaceList')
+    return {
+        path: 'sw.js',
+        data: template.replace('const { cacheList, replaceList } = require(\'../sw-cache\')', cache)
+    }
+})
+
+// 生成注册 sw 的代码
+// noinspection JSUnresolvedVariable
+hexo.extend.injector.register('head_begin', () => {
+    // noinspection JSUnresolvedVariable
+    return `<script>
+              (() => {
+                const sw = navigator.serviceWorker
+                const error = () => ${pluginConfig.onError}
+                if (!sw?.register('/sw.js')?.then(() => {
+                  if (!sw.controller) ${pluginConfig.onSuccess}
+                })?.catch(error)) error()
+              })()
+          </script>`
+}, "default")
+
+/** 遍历指定目录下的所有文件 */
+const eachAllFile = (root, cb) => {
+    const stats = fs.statSync(root)
+    if (stats.isFile()) cb(root)
+    else {
+        const files = fs.readdirSync(root)
+        if (!root.endsWith('/')) root += '/'
+        files.forEach(it => eachAllFile(root + it, cb))
+    }
+}
+
+/** 判断指定文件是否需要排除 */
+const isExclude = pathname => {
+    for (let reg of pluginConfig.exclude) {
+        if (pathname.match(new RegExp(reg, 'i'))) return true
+    }
+    return false
+}
+
+/**
+ * 构建 md5 缓存表并写入到发布目录中
+ *
+ * 格式为 `{"[path]": "[md5Value]"}`
+ *
+ * @param path 相对于根目录的路径
+ * @return {Object} 生成的 json 对象
+ */
+const buildNewJson = path => {
+    const crypto = require('crypto')    // 用于计算 md5
+    const result = {}                   // 存储新的 MD5 表
+    const removeIndex = config.pretty_urls?.trailing_index
+    const removeHtml = config.pretty_urls?.trailing_html
+    eachAllFile(config.public_dir, path => {
+        if (!fs.existsSync(path)) return logger.error(`${path} 不存在！`)
+        let endIndex
+        if (removeIndex && path.endsWith('/index.html')) endIndex = path.length - 10
+        else if (removeHtml && path.endsWith('.html')) endIndex = path.length - 5
+        else endIndex = path.length
+        const url = new URL(root + path.substring(7, endIndex))
+        if (findCache(url) && !isExclude(url.pathname)) {
+            const content = fs.readFileSync(path)
+            const key = decodeURIComponent(url.pathname)
+            result[key] = crypto.createHash('md5').update(content).digest('hex')
+        }
+    })
+    let publicRoot = config.public_dir || 'public/'
+    if (!publicRoot.endsWith('/')) publicRoot += '/'
+    fs.writeFileSync(`${publicRoot}${path}`, JSON.stringify(result))
+    logger.info(`Generated: ${path}`)
+    return result
+}
+
+/**
+ * 从网络拉取 json 文件
+ * @param path 文件路径（相对于根目录）
+ */
+const getJsonFromNetwork = async path => {
+    const url = root + path
+    try {
+        const result = await axios.get(url)
+        if (result.status < 200 || result.status >= 400 || !result.data)
+            // noinspection ExceptionCaughtLocallyJS
+            throw `拉取 ${url} 时出现异常（${result.status}）`
+        return result.data
+    } catch (e) {
+        if (e.toString().includes('404'))
+            logger.error(`拉取 ${url} 时出现 404，如果您是第一次构建请忽略这个错误`)
+        else throw e
+    }
+}
+
+/**
+ * 对比两个 md5 缓存表的区别
+ * @return [string] 需要更新的文件路径
+ */
+const compare = (oldCache, newCache) => {
+    const result = []
+    if (!oldCache) return result
+    for (let path in oldCache) {
+        if (newCache[path] !== oldCache[path]) result.push(path)
+    }
+    return result
+}
+
+/** 判断指定资源是否需要合并 */
+const isMerge = (pathname, tidied) => {
+    // noinspection JSUnresolvedVariable
+    const optional = pluginConfig.merge
+    if (pathname.includes(`/${config.tag_dir}/`)) {
+        if (optional.tags ?? true) {
+            tidied.tags = true
+            return true
+        }
+    } else if (pathname.includes(`/${config.archive_dir}/`)) {
+        if (optional.archives ?? true) {
+            tidied.archives = true
+            return true
+        }
+    } else if (pathname.includes(`/${config.category_dir}/`)) {
+        if (optional.categories ?? true) {
+            tidied.categories = true
+            return true
+        }
+    } else if (pathname.startsWith('/page/') || pathname.length <= 1) {
+        if (optional.index ?? true) {
+            tidied.index = true
+            return true
+        }
+    }
+}
+
+/**
+ * 从一个字符串中提取最后两个 / 之间的内容
+ * @param it {string} 要操作的字符串
+ * @param keep {boolean} 是否保留最后一个 / 及其后面的内容
+ */
+const clipPageName = (it, keep) => {
+    const end = it.lastIndexOf('/')
+    let index = end - 1
+    for (; index > 0; --index) {
+        if (it[index] === '/') break
+    }
+    return it.substring(index + 1, keep ? it.length : end)
+}
+
+/** 构建新的 update.json */
+const buildUpdateJson = (name, dif, oldUpdate) => {
+    /** 将对象写入文件，如果对象为 null 或 undefined 则跳过写入 */
+    const writeJson = json => {
+        if (json) {
+            logger.info(`Generated: ${name}`)
+            fs.writeFileSync(`public/${name}`, JSON.stringify(json))
+        }
+    }
+    // 读取拓展 json
+    const expand = fs.existsSync(name) ? JSON.parse(fs.readFileSync(name)) : undefined
+    // 获取上次最新的版本
+    let oldVersion = oldUpdate?.info[0]?.version ?? 0
+    if (typeof oldVersion !== 'number') {
+        // 当上次最新的版本号不是数字是尝试对其进行转换，如果无法转换则直接置零
+        if (oldVersion.match('\D')) oldVersion = 0
+        else oldVersion = Number.parseInt(oldVersion)
+    }
+    // 存储本次更新的内容
+    const newInfo = {
+        version: oldVersion + 1,
+        change: expand?.change ?? []
+    }
+    // 整理更新的数据
+    const tidied = tidyDiff(dif, expand)
+    // 如果没有更新的文件就直接退出
+    if (
+        tidied.page.size === 0 && tidied.file.size === 0 &&
+        !(tidied.archives || tidied.categories || tidied.tags || tidied.index)
+    ) return writeJson(oldUpdate)
+    pushUpdateToInfo(newInfo, tidied)
+    const result = mergeUpdateWithOld(newInfo, oldUpdate, tidied)
+    return writeJson(result)
+}
+
+const mergeUpdateWithOld = (newInfo, oldUpdate, tidied) => {
+    const result = {
+        global: (oldUpdate?.global ?? 0) + (tidied.updateGlobal ? 1 : 0),
+        info: [newInfo]
+    }
+    // noinspection JSUnresolvedVariable
+    const charLimit = pluginConfig.charLimit ?? 1024
+    if (JSON.stringify(result).length > charLimit) {
+        return {
+            global: result.global,
+            info: [{version: newInfo.version}]
+        }
+    }
+    if (!oldUpdate) return result
+    for (let it of oldUpdate.info) {
+        if (it.change) it.change = zipInfo(newInfo, it)
+        result.info.push(it)
+        if (JSON.stringify(result).length > charLimit) {
+            result.info.pop()
+            break
+        }
+    }
+    return result
+}
+
+// 压缩相同项目
+const zipInfo = (newInfo, oldInfo) => {
+    oldInfo = oldInfo.change
+    newInfo = newInfo.change
+    const result = []
+    for (let i = oldInfo.length - 1; i !== -1; --i) {
+        const value = oldInfo[i]
+        if (value.flag === 'page' && newInfo.find(it => it.flag === 'html')) continue
+        const newValue = newInfo.find(it => it.flag === value.flag)
+        if (!newValue) {
+            result.push(value)
+            continue
+        }
+        if (!value.value) continue
+        const isArray = Array.isArray(newValue.value)
+        if (Array.isArray(value.value)) {
+            const array = value.value
+                .filter(it => isArray ? !newValue.value.find(that => that === it) : it !== newValue.value)
+            if (array.length === 0) continue
+            result.push({flag: value.flag, value: array.length === 1 ? array[0] : array})
+        } else if (isArray) {
+            if (!newValue.value.find(it => it === value.value))
+                result.push(value)
+        } else {
+            if (newValue.value !== value.value)
+                result.push(value)
+        }
+    }
+    return result
+}
+
+// 将更新推送到 info
+const pushUpdateToInfo = (info, tidied) => {
+    // 推送页面更新
+    // noinspection JSUnresolvedVariable
+    if (tidied.page.size > (pluginConfig.maxHtml ?? 15)) {
+        // 如果 html 数量超过阈值就直接清掉所有 html
+        info.change.push({flag: 'html'})
+    } else {
+        const pages = []        // 独立更新
+        const merges = []       // 要合并的更新
+        tidied.page.forEach(it => pages.push(it))
+        if (tidied.tags) merges.push(config.tag_dir)
+        if (tidied.archives) merges.push(config.archive_dir)
+        if (tidied.categories) merges.push(config.category_dir)
+        if (tidied.index) {
+            pages.push(clipPageName(root, false))
+            merges.push('page')
+        }
+        if (merges.length > 0)
+            info.change.push({flag: 'str', value: merges.map(it => `/${it}/`)})
+        if (pages.length > 0)
+            info.change.push({flag: 'page', value: pages})
+    }
+    // 推送文件更新
+    if (tidied.file.size > 0) {
+        const list = []
+        tidied.file.forEach(it => list.push(it))
+        info.change.push({flag: 'file', value: list})
+    }
+}
+
+// 将 diff 整理分类，并将 expand 整合到
+const tidyDiff = (dif, expand) => {
+    const tidied = {
+        /** 所有 HTML 页面 */
+        page: new Set(),
+        /** 所有文件 */
+        file: new Set(),
+        /** 标记 tags 是否更新 */
+        tags: false,
+        /** 标记 archives 是否更新 */
+        archives: false,
+        /** 标记 categories 是否更新 */
+        categories: false,
+        /** 标记 index 是否更新 */
+        index: false,
+        /** 标记是否更新 global 版本号 */
+        updateGlobal: expand?.global
+    }
+    // noinspection JSUnresolvedVariable
+    const mode = pluginConfig.precisionMode
+    for (let it of dif) {
+        const url = new URL(root + it)  // 当前文件的 URL
+        const cache = findCache(url)    // 查询缓存
+        if (!cache) {
+            logger.error(`[buildUpdate] 指定 URL(${url.pathname}) 未查询到缓存规则！`)
+            continue
+        }
+        if (cache.clean) tidied.updateGlobal = true
+        if (it.match(/(\/|\.html)$/)) { // 判断缓存是否是 html
+            if (isMerge(it, tidied)) continue
+            if (mode.html ?? false) tidied.page.add(url.pathname)
+            else tidied.page.add(clipPageName(url.href, !it.endsWith('/')))
+        } else {
+            const extendedName = (it.includes('.') ? it.match(/[^.]+$/)[0] : null) ?? 'default'
+            const setting = mode[extendedName] ?? (mode.default ?? false)
+            if (setting) tidied.file.add(url.pathname)
+            else {
+                let name = url.href.match(/[^/]+$/)[0]
+                if (!name) throw `${url.href} 格式错误`
+                tidied.file.add(name)
+            }
+        }
+    }
+    return tidied
+}
+
+function findCache(url) {
+    url = new URL(replaceRequest(url.href))
+    for (let key in cacheList) {
+        const value = cacheList[key]
+        if (value.match(url)) return value
+    }
+    return null
+}
+
+function replaceRequest(url) {
+    for (let key in replaceList) {
+        const value = replaceList[key]
+        for (let source of value.source) {
+            if (url.match(source)) {
+                url = url.replace(source, value.dist)
+            }
+        }
+    }
+    return url
+}
+
+/** 对 hexo 的全局变量进行排序，以保证每次生成的结果一致 */
+(() => {
+    // noinspection JSUnresolvedVariable
+    const locals = hexo.locals
+    const compare = (a, b) => a < b ? -1 : 1
+    const sort = (name, value) => locals.get(name).data.sort((a, b) => compare(a[value], b[value]))
+    const list = {
+        posts: 'title',
+        pages: 'title',
+        tags: 'name',
+        categories: 'name'
+    }
+    for (let key in list) sort(key, list[key])
+    locals.get('posts').forEach(it => {
+        it.tags.data.sort((a, b) => compare(a.name, b.name))
+        it.categories.data.sort((a, b) => compare(a.name, b.name))
+    })
+})()

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "hexo-swpp",
+  "version": "1.0.0",
+  "main": "index.js",
+  "dependencies": {
+    "axios": "^1.2.0",
+    "hexo-log": "^3.0.0"
+  },
+  "files": [
+    "index.js",
+    "sw-template.js"
+  ],
+  "keywords": [
+    "hexo",
+    "sw",
+    "ServiceWorker",
+    "json",
+    "auto"
+  ],
+  "author": "kmar",
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EmptyDreams/hexo-swpp.git"
+  }
+}

package/sw-template.js

@@ -0,0 +1,289 @@
+// noinspection JSIgnoredPromiseFromCall
+
+(() => {
+    /** 缓存库名称 */
+    const CACHE_NAME = 'kmarBlogCache'
+    /** 版本名称存储地址（必须以`/`结尾） */
+    const VERSION_PATH = 'https://id.v3/'
+
+    self.addEventListener('install', () => self.skipWaiting())
+
+    const { cacheList, replaceList } = require('../sw-cache')
+
+    /**
+     * 删除指定缓存
+     * @param list 要删除的缓存列表
+     * @return {Promise<Array<string>>} 删除的缓存的URL列表
+     */
+    const deleteCache = list => new Promise(resolve => {
+        caches.open(CACHE_NAME).then(cache => cache.keys()
+            .then(keys => Promise.all(keys.map(
+                it => new Promise(async resolve1 => {
+                    const url = it.url
+                    if (url !== VERSION_PATH && list.match(url)) {
+                        await cache.delete(it)
+                        resolve1(url)
+                    } else resolve1(undefined)
+                })
+            )).then(removeList => resolve(removeList)))
+        )
+    })
+
+    self.addEventListener('fetch', event => {
+        const replace = replaceRequest(event.request)
+        const request = replace || event.request
+        const url = new URL(request.url)
+        if (findCache(url)) {
+            event.respondWith(new Promise(async resolve => {
+                const key = new Request(`${url.protocol}//${url.host}${url.pathname}`)
+                let response = await caches.match(key)
+                if (!response) {
+                    response = await fetchNoCache(request)
+                    const status = response.status
+                    if ((status > 199 && status < 400) || status === 0) {
+                        const clone = response.clone()
+                        caches.open(CACHE_NAME).then(cache => cache.put(key, clone))
+                    }
+                }
+                resolve(response)
+            }))
+        } else if (replace !== null) {
+            event.respondWith(fetch(request))
+        }
+    })
+
+    self.addEventListener('message', event => {
+        const data = event.data
+        switch (data) {
+            case 'update':
+                updateJson().then(info => {
+                    // noinspection JSUnresolvedVariable
+                    event.source.postMessage({
+                        type: 'update',
+                        update: info.update,
+                        version: info.version,
+                    })
+                })
+                break
+            default:
+                const list = new VersionList()
+                list.push(new CacheChangeExpression({'flag': 'all'}))
+                deleteCache(list).then(() => {
+                    if (data === 'refresh')
+                        event.source.postMessage({type: 'refresh'})
+                })
+                break
+        }
+    })
+
+    /** 忽略浏览器HTTP缓存的请求指定request */
+    const fetchNoCache = request => fetch(request, {cache: "no-store"})
+
+    /** 判断指定url击中了哪一种缓存，都没有击中则返回null */
+    function findCache(url) {
+        for (let key in cacheList) {
+            const value = cacheList[key]
+            if (value.match(url)) return value
+        }
+        return null
+    }
+
+    /**
+     * 检查连接是否需要重定向至另外的链接，如果需要则返回新的Request，否则返回null<br/>
+     * 该函数会顺序匹配{@link replaceList}中的所有项目，即使已经有可用的替换项<br/>
+     * 故该函数允许重复替换，例如：<br/>
+     * 如果第一个匹配项把链接由"http://abc.com/"改为了"https://abc.com/"<br/>
+     * 此时第二个匹配项可以以此为基础继续进行修改，替换为"https://abc.net/"<br/>
+     * @return {Request|null}
+     */
+    function replaceRequest(request) {
+        let url = request.url;
+        let flag = false
+        for (let key in replaceList) {
+            const value = replaceList[key]
+            for (let source of value.source) {
+                if (url.match(source)) {
+                    url = url.replace(source, value.dist)
+                    flag = true
+                }
+            }
+        }
+        return flag ? new Request(url) : null
+    }
+
+    /**
+     * 根据JSON删除缓存
+     * @returns {Promise<boolean>} 返回值用于标记当前页是否被刷新
+     */
+    function updateJson() {
+        /**
+         * 解析elements，并把结果输出到list中
+         * @return boolean 是否刷新全站缓存
+         */
+        const parseChange = (list, elements, version) => {
+            let biliFlag = false
+            let result = true
+            for (let element of elements) {
+                const ver = element['version']
+                if (ver === version) {
+                    result = false
+                    break
+                }
+                if (ver.endsWith('b')) biliFlag = true
+                const jsonList = element['change']
+                if (jsonList) {
+                    for (let it of jsonList)
+                        list.push(new CacheChangeExpression(it))
+                }
+            }
+            if (biliFlag) list.push(new CacheChangeExpression({flag: "str", value: "/bilibili/"}))
+            // resul=true时表明读取了已存在的所有版本信息后依然没有找到客户端当前的版本号
+            // 说明跨版本幅度过大，直接清理全站
+            return result
+        }
+        /** 解析字符串 */
+        const parseJson = json => new Promise(resolve => {
+            /** 版本号读写操作 */
+            const dbVersion = {
+                write: (id) => new Promise((resolve, reject) => {
+                    caches.open(CACHE_NAME).then(function (cache) {
+                        cache.put(
+                            new Request(VERSION_PATH),
+                            new Response(id)
+                        ).then(() => resolve())
+                    }).catch(() => reject())
+                }), read: () => new Promise((resolve) => {
+                    caches.match(new Request(VERSION_PATH))
+                        .then(response => {
+                            if (!response) resolve(null)
+                            response.text().then(text => {
+                                resolve(text)
+                            })
+                        }).catch(() => resolve(null)
+                    )
+                })
+            }
+            let list = new VersionList()
+            dbVersion.read().then(oldData => {
+                const oldVersion = JSON.parse(oldData)
+                const elementList = json['info']
+                const global = json['global']
+                const newVersion = {global: global, local: elementList[0].version}
+                //新用户不进行更新操作
+                if (!oldVersion) {
+                    dbVersion.write(JSON.stringify(newVersion))
+                    return resolve(newVersion)
+                }
+                const refresh = parseChange(list, elementList, oldVersion.local)
+                dbVersion.write(JSON.stringify(newVersion))
+                //如果需要清理全站
+                if (refresh) {
+                    if (global === oldVersion.global) {
+                        list._list.length = 0
+                        list.push(new CacheChangeExpression({'flag': 'all'}))
+                    } else list.refresh = true
+                }
+                resolve({list: list, version: newVersion})
+            }).catch(() => dbVersion.write('{"global":0, "local":"-"}'))
+        })
+        const url = `/update.json` //需要修改JSON地址的在这里改
+        return new Promise(resolve => fetchNoCache(url)
+            .then(response => {
+                if (response.ok || response.status === 301 || response.status === 302)
+                    response.json().then(json => {
+                        parseJson(json).then(result => {
+                            if (!result.list) return resolve({version: result})
+                            deleteCache(result.list).then(list => resolve({
+                                    update: list.filter(it => it),
+                                    version: result.version
+                                })
+                            )
+                        })
+                    })
+                else console.error(`加载 update.json 时遇到异常，状态码：${response.status}`)
+            })
+        )
+    }
+
+    /** 版本列表 */
+    class VersionList {
+
+        _list = []
+        refresh = false
+
+        push(element) {
+            this._list.push(element)
+        }
+
+        clean(element = null) {
+            this._list.length = 0
+            if (!element) this.push(element)
+        }
+
+        match(url) {
+            if (this.refresh) return true
+            else {
+                for (let it of this._list) {
+                    if (it.match(url)) return true
+                }
+            }
+            return false
+        }
+
+    }
+
+    /**
+     * 缓存更新匹配规则表达式
+     * @param json 格式{"flag": ..., "value": ...}
+     * @see https://kmar.top/posts/bcfe8408/#JSON格式
+     */
+    class CacheChangeExpression {
+
+        constructor(json) {
+            const checkCache = url => {
+                const cache = findCache(new URL(url))
+                return !cache || cache.clean
+            }
+            /**
+             * 遍历所有value
+             * @param action {function(string): boolean} 接受value并返回bool的函数
+             * @return {boolean} 如果value只有一个则返回`action(value)`，否则返回所有运算的或运算（带短路）
+             */
+            const forEachValues = action => {
+                const value = json.value
+                if (Array.isArray(value)) {
+                    for (let it of value) {
+                        if (action(it)) return true
+                    }
+                    return false
+                } else return action(value)
+            }
+            switch (json['flag']) {
+                case 'all':
+                    this.match = checkCache
+                    break
+                case 'post':
+                    this.match = url => url.endsWith('postsInfo.json') ||
+                        forEachValues(post => url.endsWith(`posts/${post}/`))
+                    break
+                case 'html':
+                    this.match = url => cacheList.html.match(new URL(url)) || url.endsWith('postsInfo.json')
+                    break
+                case 'file':
+                    this.match = url => forEachValues(value => url.endsWith(value))
+                    break
+                case 'new':
+                    this.match = url => url.endsWith('postsInfo.json') || url.match(/\/archives\//)
+                    break
+                case 'page':
+                    this.match = url => forEachValues(value => url.match(new RegExp(`\/${value}(\/|)$`)))
+                    break
+                case 'str':
+                    this.match = url => forEachValues(value => url.includes(value))
+                    break
+                default: throw `未知表达式：${JSON.stringify(json)}`
+            }
+        }
+
+    }
+})()