swpp-backends 0.0.1-alpha.0 → 0.0.2-alpha

package/src/SwppRules.ts

@@ -1,200 +0,0 @@
-import fs from 'fs'
-import {Request, Response} from 'node-fetch'
-import nodePath from 'path'
-import {SwppConfig, SwppConfigTemplate} from './SwppConfig'
-
-const defConfig: SwppConfigTemplate = {
-    serviceWorker: {
-        escape: 0,
-        cacheName: 'kmarBlogCache',
-        debug: false
-    },
-    register: {
-        onerror: () => console.error('Service Worker 注册失败！可能是由于您的浏览器不支持该功能！'),
-        builder: (root: string, _: any, pluginConfig: SwppConfig) => {
-            const registerConfig = pluginConfig.register as any
-            const {onerror, onsuccess} = registerConfig
-            return `<script>
-                (() => {
-                    let sw = navigator.serviceWorker
-                    let error = ${onerror.toString()}
-                    if (!sw?.register('${new URL(root).pathname}sw.js')
-                        ${onsuccess ? '?.then(' + onsuccess.toString() + ')' : ''}
-                        ?.catch(error)
-                    ) error()
-                })()
-            </script>`
-        }
-    },
-    dom: {},
-    json: {
-        maxHtml: 15,
-        charLimit: 1024,
-        merge: [],
-        exclude: {
-            localhost: [/^\/sw\.js$/],
-            other: []
-        }
-    },
-    external: {
-        timeout: 5000,
-        js: [],
-        stable: [],
-        replacer: it => it
-    }
-}
-
-const eventList: ((rules: any) => void)[] = []
-let _rules: SwppRules
-
-/**
- * 读取最后一次构建的 rules
- *
- * **执行该函数前必须调用过 [loadRules]**
- */
-export function readRules(): SwppRules {
-    if (!_rules) throw 'rules 尚未初始化'
-    return _rules
-}
-
-/**
- * 添加一个 rules 映射事件，这个事件允许用户修改 rules 的内容
- *
- * 执行时按照注册的顺序执行
- */
-export function addRulesMapEvent(mapper: (rules: any) => void) {
-    eventList.push(mapper)
-}
-
-/**
- * 加载 rules 文件
- * @param root 项目根目录
- * @param fileName rules 文件名称
- * @param selects 附加的可选目录，优先级低于 [root]
- */
-export function loadRules(root: string, fileName: string, selects: string[]): SwppRules {
-    // 支持的拓展名
-    const extensions = ['cjs', 'js']
-    // 根目录下的 rules 文件
-    const rootPath = extensions.map(it => nodePath.resolve(root, `${fileName}.${it}`))
-        .find(it => fs.existsSync(it))
-    // 其它可选目录下的 rules 文件
-    const selectPath = selects.flatMap(
-        value => extensions.map(it => nodePath.resolve(value, `${fileName}.${it}`))
-    ).find(it => fs.existsSync(it))
-    if (!(rootPath || selectPath))
-        throw '未查询到 rules 文件'
-    const rootRules = rootPath ? { ...require(rootPath) } : {}
-    const selectRules = selectPath ? require(selectPath) : {}
-    const config = rootRules.config ?? {}
-    mergeConfig(config, selectRules.config ?? {})
-    mergeConfig(config, defConfig)
-    Object.assign(rootRules, selectRules)
-    rootRules.config = config
-    for (let event of eventList) {
-        event(rootRules)
-    }
-    return _rules = rootRules
-}
-
-/** 合并配置项 */
-function mergeConfig(dist: any, that: any): any {
-    for (let key in that) {
-        const distValue = dist[key]
-        const thatValue = that[key]
-        if (!thatValue) continue
-        switch (typeof distValue) {
-            case "undefined":
-                dist[key] = thatValue
-                break
-            case "object":
-                mergeConfig(distValue, thatValue)
-                break
-        }
-    }
-    return dist
-}
-
-export interface SwppRules {
-    /** 配置项 */
-    config: SwppConfig,
-    /** 缓存规则 */
-    cacheRules?: {
-        [propName: string]: CacheRules
-    },
-    /**
-     * 修改 Request
-     * @param request 原始 request
-     * @param $eject 用于访问通过 [ejectValues] 函数插入的变量，变量名必须为 `$eject`
-     * @return 修改后的 Request，不修改的话返回 null 或不返回数据
-     */
-    modifyRequest?: (request: Request, $eject: any) => Request | undefined,
-    /**
-     * 获取一个 URL 对应的多个 CDN 的 URL
-     *
-     * 竞速时除了 URL 外所有参数保持一致
-     *
-     * @param url 原始 URL
-     * @return {?string[]} 返回值不包含则表示去除对原始 URL 地访问。返回 undefined 表示该 URL 不启用竞速
-     */
-    getRaceUrls?: (url: string) => string[] | undefined,
-    /**
-     * 获取一个 URL 对应的 URL 列表
-     *
-     * 访问顺序按列表顺序，所有 URL 访问时参数一致
-     *
-     * @param url 原始 URL
-     * @return {?SpareURLs} 返回 null 或不反悔表示对该 URL 不启用备用 URL 功能
-     */
-    getSpareUrls?: (url: string) => SpareURLs | undefined,
-    /**
-     * 判断是否阻塞指定响应
-     * @return {boolean} 返回 true 表示阻塞，false 表示不阻塞
-     */
-    blockRequest?: (url: URL) => boolean,
-    /** 插入到 sw 但不在 node 中执行的代码 */
-    afterJoin?: VoidFunction,
-    /** 插入到 sw 但不在 node 中执行的代码，框架主题禁止覆盖该项 */
-    afterTheme?: VoidFunction,
-    /** 获取要插入到 sw 中的变量和常量 */
-    ejectValues?: (framework: any, rules: SwppRules) => {
-        [propName: string]: EjectValue
-    },
-    /** 允许插入到 sw 的值 */
-    external?: string[],
-    /**
-     * 向指定的 request 发起网络请求（GET）
-     *
-     * **注意：声明该项后 swpp 内置的“CDN 竞速”“备用 URL”都将失效**
-     *
-     * @param request 请求信息
-     * @param banCache 是否禁用缓存
-     * @param spare 备用 URL
-     */
-    fetchFile?: (request: Request, banCache: boolean, spare?: SpareURLs) => Promise<Response>
-}
-
-export interface CacheRules {
-    /** 符合该规则的缓存在进行全局清理时是否清除 */
-    clean: boolean,
-    /** 是否检查 URL 参数（问号及问号之后的内容） */
-    search?: boolean,
-    /**
-     * 规则匹配器
-     * @param url 链接的 URL 对象（对象包括 hash 和 search，但禁止使用 hash，search 为 false 或留空时禁止使用 search）
-     * @param $eject 用于访问通过 [ejectValues] 函数插入的变量，变量名必须为 `$eject`
-     */
-    match: (url: URL, $eject?: any) => boolean
-}
-
-export interface SpareURLs {
-    /** 超时时间 */
-    timeout: number,
-    /** URL 列表 */
-    list: string[]
-}
-
-export interface EjectValue {
-    prefix: string,
-    value: string | number | boolean | bigint | object | string[] | number[] | boolean[] | bigint[] | object[]
-}

package/src/UpdateJsonBuilder.ts

@@ -1,279 +0,0 @@
-import {readMergeVersionMap} from './FileAnalyzer'
-import {readRules} from './SwppRules'
-import {fetchFile, warn} from './Utils'
-import {AnalyzerResult} from './VersionAnalyzer'
-
-let _oldJson: UpdateJson | undefined | null = undefined
-const externalChange: ChangeExpression[] = []
-
-/** 提交修改 */
-export function submitChange(...change: ChangeExpression[]) {
-    externalChange.push(...change)
-}
-
-/**
- * 加载版本文件
- *
- * + **调用该函数前必须调用过 [loadRules]**
- */
-export async function loadUpdateJson(url: string): Promise<UpdateJson | null> {
-    if (_oldJson !== undefined) return _oldJson
-    const response = await fetchFile(url)
-    if (response.status === 404) {
-        warn('LoadUpdateJson', `拉取 ${url} 时出现 404 错误，如果您是第一次构建请忽略这个警告。`)
-        return _oldJson = null
-    }
-    return _oldJson = (await response.json()) as UpdateJson
-}
-
-/**
- * 读取最后一次加载的版本文件
- *
- * + **调用该函数前必须调用过 [loadRules]**
- * + **调用该函数前必须调用过 [loadUpdateJson]**
- */
-export function readUpdateJson(): UpdateJson | null {
-    if (_oldJson === undefined) throw 'UpdateJson 未初始化'
-    return _oldJson
-}
-
-/**
- * 构建新的 update json
- *
- * + **执行该函数前必须调用过 [loadRules]**
- * + **调用该函数前必须调用过 [loadCacheJson]**
- * + **执行该函数前必须调用过 [buildVersionJson]**
- * + **执行该函数前必须调用过 [calcEjectValues]**
- *
- * @param root 网站根路径（包括网络协议）
- * @param dif 网站文件变化
- */
-export function buildNewInfo(root: string, dif: AnalyzerResult): UpdateJson {
-    const config = readRules().config.json
-    if (!config) throw '功能未开启'
-    const old = readUpdateJson()
-    let global = old?.global ?? 0
-    if (dif.force) return {
-        global: global + 1,
-        info: [{
-            version: old ? old.info[0].version + 1 : 0
-        }]
-    }
-    const change: ChangeExpression[] = []
-    const info: UpdateVersionInfo = {
-        version: old ? old.info[0].version + 1 : 0,
-        change
-    }
-    const list = [...dif.refresh, ...dif.deleted, ...dif.variational, ...dif.rules.remove]
-    const records = {
-        merge: new Set<string>(),
-        html: new Set<string>()
-    }
-    for (let url of list) {
-        if (url.startsWith('/')) {
-            // 本地链接
-            const merge = config.merge.find(it => url.startsWith(`/${it}/`))
-            if (merge) {
-                records.merge.add(merge)
-                continue
-            }
-            url = root + url
-        }
-        if (/(\/|\.html)$/.test(url)) { // is html
-            records.html.add(getShorthand(url, 1))
-        } else {    // not html
-            change.push({
-                flag: 'end',
-                value: getShorthand(url)
-            })
-        }
-    }
-    if (records.html.size !== 0) {
-        if (records.html.size > config.maxHtml) {
-            change.push({flag: 'html'})
-        } else {
-            change.push({
-                flag: 'end',
-                value: Array.from(records.html)
-            })
-        }
-    }
-    if (records.merge.size !== 0) {
-        change.push({
-            flag: 'begin',
-            value: Array.from(records.merge).map(it => `/${it}/`)
-        })
-    }
-    change.push(...externalChange)
-    return zipJson({
-        global,
-        info: [info, ...(old?.info ?? [])]
-    })
-}
-
-function zipJson(json: UpdateJson): UpdateJson {
-    const record = new Map<FlagStr, string[]>()
-    /** 合并同名项目 */
-    function merge(info: UpdateVersionInfo) {
-        const localRecord = new Map<FlagStr, Set<string>>()
-        if (!info.change) return
-        for (let exp of info.change) {
-            const value = exp.value
-            if (!localRecord.has(exp.flag))
-                localRecord.set(exp.flag, new Set())
-            if (!value) continue
-            const set = localRecord.get(exp.flag)!
-            if (typeof value === 'string') {
-                set.add(value)
-            } else {
-                value.forEach(it => set.add(it))
-            }
-        }
-        type FunResult = [FlagStr, string[]]
-        info.change = Array.from(localRecord)
-            .map(it => {
-                if (it[0] === 'html') return [it[0], []] as FunResult
-                const values = Array.from(it[1])
-                if (it[0] === 'str' || it[0] === 'reg') return [it[0], values] as FunResult
-                const filtered = values.filter((value, index) => {
-                    if (it[0] === 'end' && record.has('html') && /(\/|\.html)$/.test(value))
-                        return false
-                    for (let i = 0; i < values.length; i++) {
-                        if (i === index) continue
-                        const that = values[i]
-                        switch (it[0]) {
-                            case 'end':
-                                if (value.endsWith(that)) return false
-                                break
-                            case 'begin':
-                                if (value.startsWith(that)) return false
-                                break
-                        }
-                    }
-                    return true
-                })
-                return [it[0], filtered] as FunResult
-            }).filter(it => it[1].length !== 0 || it[0] === 'html')
-            .map(it => {
-                record.set(it[0], it[1])
-                if (it[1].length === 0) return { flag: it[0] }
-                return {
-                    flag: it[0],
-                    value: it[1].length === 1 ? it[1][0] : it[1]
-                }
-            })
-    }
-    /** 移除不可达的表达式 */
-    function deleteUnreachableExp(list: UpdateVersionInfo[]) {
-        for (let i = list.length - 1; i > 0; i--) {
-            const info = list[i]
-            let change = info.change
-            if (!change) continue
-            for (let k = 0; k < change.length; k++) {
-                const exp = change[k]
-                const top = record.get(exp.flag)
-                if (exp.flag === 'html') {
-                    change.splice(k--, 1)
-                    continue
-                }
-                let array = typeof exp.value === 'string' ? [exp.value] : exp.value!
-                const find = (test: (it: string) => boolean) => {
-                    if (!top) return false
-                    return top.find(test)
-                }
-                switch (exp.flag) {
-                    case 'end':
-                        array = array.filter(value => {
-                            if (/(\/|\.html)$/.test(value) && record.has('html'))
-                                return false
-                            if (!top) return true
-                            return !find(it => value.endsWith(it))
-                        })
-                        break
-                    case 'begin':
-                        array = array.filter(value => !find(it => value.startsWith(it)))
-                        break
-                    case 'str':
-                        array = array.filter(value => !find(it => value.includes(it)))
-                        break
-                    case 'reg':
-                        array = array.filter(value => !top?.includes(value))
-                        break
-                }
-                switch (array.length) {
-                    case 0:
-                        change.splice(k--, 1)
-                        break
-                    case 1:
-                        exp.value = array[0]
-                        break
-                    default:
-                        exp.value = array
-                        break
-                }
-            }
-            if (change.length === 0)
-                delete info.change
-        }
-    }
-    merge(json.info[0])
-    deleteUnreachableExp(json.info)
-    return json
-}
-
-/**
- * 获取 URL 的缩写形式
- *
- * + **执行该函数前必须调用过 [loadRules]**
- * + **调用该函数前必须调用过 [loadCacheJson]**
- * + **执行该函数前必须调用过 [buildVersionJson]**
- * + **执行该函数前必须调用过 [calcEjectValues]**
- */
-export function getShorthand(url: string, offset: number = 0): string {
-    const map = readMergeVersionMap()
-    let collide = new Set<string>()
-    for (let mapKey in map) {
-        collide.add(mapKey)
-    }
-    let index = Math.max(url.lastIndexOf('/', url.length - offset - 1), url.length - 20)
-    let result: string
-    while (true) {
-        result = url.substring(index)
-        let count = 0
-        const removeSet = new Set<string>()
-        for (let url of collide) {
-            if (url.endsWith(result)) {
-                ++count
-                if (count === 2) break
-            } else {
-                removeSet.add(url)
-            }
-        }
-        switch (count) {
-            case 1: return result
-            case 2:
-                --index
-                removeSet.forEach(it => collide.delete(it))
-                break
-            default:
-                throw '意料之外的错误：' + count
-        }
-    }
-}
-
-export interface UpdateJson {
-    global: number,
-    info: UpdateVersionInfo[]
-}
-
-export interface UpdateVersionInfo {
-    version: number,
-    change?: ChangeExpression[]
-}
-
-export interface ChangeExpression {
-    flag: FlagStr,
-    value?: string | string[]
-}
-
-export type FlagStr = 'html' | 'end' | 'begin' | 'str' | 'reg'

package/src/Utils.ts

@@ -1,195 +0,0 @@
-import fetch from 'node-fetch'
-import {readRules} from './SwppRules'
-
-const logger = require('hexo-log').default({
-    debug: false,
-    silent: false
-})
-
-export function error(type: string, message: string) {
-    logger.error(`[SWPP ${type}] ${message}`)
-}
-
-export function warn(type: string, message: string) {
-    logger.warn(`[SWPP ${type}] ${message}`)
-}
-
-export interface EjectCache {
-    strValue: string,
-    nodeEject: any
-}
-
-let ejectData: EjectCache | undefined = undefined
-
-/**
- * 获取 eject values
- *
- * + **执行该函数前必须调用过 [loadRules]**
- *
- * @param framework 框架对象
- */
-export function calcEjectValues(framework: any) {
-    const rules = readRules()
-    if (!('ejectValues' in rules)) return
-    // noinspection JSUnresolvedReference
-    const eject = rules.ejectValues?.(framework, rules)
-    const nodeEject: any = {}
-    let ejectStr = ''
-    for (let key in eject) {
-        if (!key.match(/^[A-Za-z0-9]+$/)) {
-            logger.error(`[SWPP EjectValues] 变量名 [${key}] 仅允许包含英文字母和阿拉伯数字！`)
-            throw '变量名违规：' + key
-        }
-        const data = eject[key]
-        const str = getSource(data.value, name => {
-            if (['string', 'number', 'boolean', 'object', 'array', 'bigint'].includes(name))
-                return true
-            logger.error(`[SWPP EjectValue] 不支持导出 ${name} 类型的数据`)
-            throw `不支持的键值：key=${key}, value type=${name}`
-        })
-        ejectStr += `    ${data.prefix} ${key} = ${str}\n`
-        nodeEject[key] = data.value
-    }
-    ejectData = {
-        strValue: ejectStr,
-        nodeEject
-    }
-}
-
-/**
- * 读取最近的已计算的 eject 数据
- *
- * + **执行该函数前必须调用过 [loadRules]**
- * + **执行该函数前必须调用过 [calcEjectValues]**
- */
-export function readEjectData(): EjectCache {
-    if (!ejectData) throw 'eject data 尚未初始化'
-    return ejectData
-}
-
-/**
- * 获取指定值的 js 源码表达形式
- * @param obj 要转换的对象
- * @param typeChecker 类型检查器，用于筛除不希望映射的类型
- * @param whiteList 白名单，当 obj 为 Object 时将只转换在白名单中的值（不会传递）
- * @param isTop 是否为顶层元素，为 true 且 obj 为 Object 时将去除最外层的大括号，改为 let（不会传递）
- */
-export function getSource(
-    obj: any,
-    typeChecker: ((name: string) => boolean) | undefined = undefined,
-    whiteList: string[] | undefined = undefined,
-    isTop: boolean = false
-): string {
-    const type = typeof obj
-    if (typeChecker) {
-        let value
-        if (type === 'object') {
-            value = Array.isArray(obj) ? 'array' : type
-        } else value = type
-        if (!typeChecker(value)) return ''
-    }
-    switch (type) {
-        case "undefined": return 'undefined'
-        case "object":
-            if (Array.isArray(obj)) {
-                return '[' + (obj as Array<any>).map(it => getSource(it)).join(', ') + ']'
-            } else {
-                let result = isTop ? '' : '{\n'
-                result += Object.getOwnPropertyNames(obj)
-                    .filter(key => !whiteList || whiteList.includes(key))
-                    .map(key => {
-                        const value = obj[key]
-                        let str = getSource(value, typeChecker)
-                        if (str.length === 0) return ''
-                        if (isTop && whiteList && ['cacheList', 'modifyRequest'].includes(key)) {
-                            str = str
-                                .replace(
-                                    /\(\s*(.*?)\s*,\s*\$eject\s*\)/g, "$1"
-                                )    // 去掉箭头函数参数表中的 $eject
-                                .replaceAll(
-                                    /\$eject\.(\w+)/g,
-                                    (_, match) => `eject${match[0].toUpperCase()}${match.substring(1)}`
-                                )   // 将函数体中的 $eject.xxx 替换为 ejectXxx
-                        }
-                        return isTop ? `let ${key} = ${str}` : `${key}: ${str}`
-                    })
-                    .filter(it => it.length !== 0)
-                    .join(isTop ? '\n' : ',\n')
-                result += isTop ? '' : '}\n'
-                return result
-            }
-        case "string":
-            if (!obj.includes("'"))
-                return `'${obj}'`
-            else if (!obj.includes('"'))
-                return `"${obj}"`
-            else if (!obj.includes('`'))
-                return `\`${obj}\``
-            else
-                return `'${(obj as string).replaceAll("'", "\\'")}'`
-        case "bigint": return `${obj.toString()}n`
-        default: return obj.toString()
-        case "symbol":
-            logger.error("[SWPP ServiceWorkerBuilder] 不支持写入 symbol 类型，请从 sw-rules.js 中移除相关内容！")
-            throw '不支持写入 symbol 类型'
-    }
-}
-
-/**
- * 拉取文件
- *
- * **调用该函数前必须调用过 [loadRules]**
- */
-export async function fetchFile(link: string) {
-    const config = readRules().config
-    const url = replaceDevRequest(link)
-    const opts = {
-        headers: {
-            referer: 'kmar-swpp',
-            'User-Agent': 'kmar-swpp'
-        },
-        timeout: (config.external as any).timeout
-    }
-    try {
-        if (typeof url === 'string') {
-            return await fetch(url, opts)
-        } else {
-            return await fetchSpeed(url)
-        }
-    } catch (err) {
-        // @ts-ignore
-        if (err.type === 'request-timeout') {
-            logger.error(
-                `[SWPP FetchFile] 拉取文件 [${link}] 时出现了超时错误，如果您构建所在的位置无法访问该资源，` +
-                "请尝试通过 DevReplace（https://kmar.top/posts/73014407/#4ea71e00）功能解决该问题。"
-            )
-            throw 'timeout'
-        }
-        throw err
-    }
-}
-
-/**
- * 替换编译期的 URL（CDN 竞速）
- *
- * **调用该函数前必须调用过 [loadRules]**
- */
-export function replaceDevRequest(link: string): string[] | string {
-    const config = readRules().config
-    return config.external?.replacer(link) ?? link
-}
-
-/** 通过 CDN 竞速的方式拉取文件 */
-async function fetchSpeed(list: string[]) {
-    const controllers: AbortController[] = new Array(list.length)
-    const result = await Promise.any(
-        list.map((it, index) => fetch(it, {
-                signal: (controllers[index] = new AbortController()).signal
-            }).then(response => [200, 301, 302, 307, 308].includes(response.status) ? {index, response} : Promise.reject())
-        )
-    )
-    for (let i = 0; i < controllers.length; i++) {
-        if (i !== result.index) controllers[i].abort()
-    }
-    return result.response
-}