swpp-backends 0.0.1-alpha

package/dist/fileAnalyzer.js

@@ -0,0 +1,448 @@
+"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 });
+exports.replaceRequest = exports.findCache = exports.eachAllLinkInJavaScript = exports.eachAllLinkInCss = exports.eachAllLinkInHtml = exports.eachAllLinkInUrl = exports.buildVersionJson = exports.readMergeVersionMap = exports.readNewVersionJson = exports.readOldVersionJson = exports.loadVersionJson = exports.isStable = exports.isExclude = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const node_fetch_1 = require("node-fetch");
+const SwppRules_1 = require("./SwppRules");
+const crypto = __importStar(require("crypto"));
+const buffer_1 = require("buffer");
+const fast_html_parser_1 = __importDefault(require("fast-html-parser"));
+const css_1 = __importDefault(require("css"));
+const Utils_1 = require("./Utils");
+/**
+ * 遍历指定目录及其子目录中包含的所有文件（不遍历文件夹）
+ * @param root 根目录
+ * @param cb 回调函数（接收的参数是文件的相对路径）
+ */
+function eachAllFile(root, cb) {
+    const stats = fs_1.default.statSync(root);
+    if (stats.isFile())
+        cb(root);
+    else {
+        const files = fs_1.default.readdirSync(root);
+        files.forEach(it => eachAllFile(path_1.default.join(root, it), cb));
+    }
+}
+/**
+ * 判断指定 URL 是否排除
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ *
+ * @param webRoot 网站域名
+ * @param url 要判断的 URL
+ */
+function isExclude(webRoot, url) {
+    const exclude = (0, SwppRules_1.readRules)().config?.json?.exclude;
+    if (!exclude)
+        throw 'exclude 为空';
+    const list = isExternalLink(webRoot, url) ? exclude.other : exclude.localhost;
+    for (let reg of list) {
+        if (url.match(reg))
+            return true;
+    }
+    return false;
+}
+exports.isExclude = isExclude;
+/**
+ * 判断指定 URL 是否是 stable 的
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ */
+function isStable(url) {
+    const stable = (0, SwppRules_1.readRules)().config?.external?.stable;
+    if (!stable)
+        throw 'stable 为空';
+    for (let reg of stable) {
+        if (url.match(reg))
+            return true;
+    }
+    return false;
+}
+exports.isStable = isStable;
+/**
+ * 从指定 URL 加载 cache json
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ */
+async function loadVersionJson(url) {
+    const response = await (0, Utils_1.fetchFile)(url);
+    return _oldVersionJson = (await response.json());
+}
+exports.loadVersionJson = loadVersionJson;
+let _oldVersionJson;
+let _newVersionJson;
+let _mergeVersionMap;
+/**
+ * 读取最后一次加载的 version json
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **调用该函数前必须调用过 [loadCacheJson]**
+ */
+function readOldVersionJson() {
+    if (!_oldVersionJson)
+        throw 'cache json 尚未初始化';
+    return _oldVersionJson;
+}
+exports.readOldVersionJson = readOldVersionJson;
+/**
+ * 读取最后一次构建的 VersionJson
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **调用该函数前必须调用过 [loadCacheJson]**
+ * + **执行该函数前必须调用过 [buildVersionJson]**
+ * + **执行该函数前必须调用过 [calcEjectValues]**
+ */
+function readNewVersionJson() {
+    if (!_newVersionJson)
+        throw 'cache json 尚未初始化';
+    return _newVersionJson;
+}
+exports.readNewVersionJson = readNewVersionJson;
+/**
+ * 读取新旧版本文件合并后的版本地图
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **调用该函数前必须调用过 [loadCacheJson]**
+ * + **执行该函数前必须调用过 [buildVersionJson]**
+ * + **执行该函数前必须调用过 [calcEjectValues]**
+ */
+function readMergeVersionMap() {
+    if (_mergeVersionMap)
+        return _mergeVersionMap;
+    const map = {};
+    Object.assign(map, readOldVersionJson().list);
+    Object.assign(map, readNewVersionJson().list);
+    return _mergeVersionMap = map;
+}
+exports.readMergeVersionMap = readMergeVersionMap;
+/**
+ * 构建一个 cache json
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **调用该函数前必须调用过 [loadCacheJson]**
+ * + **执行该函数前必须调用过 [calcEjectValues]**
+ *
+ * @param protocol 网站的网络协议
+ * @param webRoot 网站域名（包括二级域名）
+ * @param root 网页根目录（首页 index.html 所在目录）
+ */
+async function buildVersionJson(protocol, webRoot, root) {
+    const list = {};
+    eachAllFile(root, async (path) => {
+        const endIndex = path.length - (path.endsWith('/index.html') ? 10 : 0);
+        const url = new URL(protocol + path_1.default.join(webRoot, path.substring(root.length, endIndex)));
+        const pathname = url.pathname;
+        if (isExclude(webRoot, pathname))
+            return;
+        let content = null;
+        if (findCache(url)) {
+            content = fs_1.default.readFileSync(path, 'utf-8');
+            const key = decodeURIComponent(url.pathname);
+            list[key] = crypto.createHash('md5').update(content).digest('hex');
+        }
+        if (pathname.endsWith('/') || pathname.endsWith('.html')) {
+            if (!content)
+                content = fs_1.default.readFileSync(path, 'utf-8');
+            await eachAllLinkInHtml(webRoot, content, list);
+        }
+        else if (pathname.endsWith('.css')) {
+            if (!content)
+                content = fs_1.default.readFileSync(path, 'utf-8');
+            await eachAllLinkInCss(webRoot, content, list);
+        }
+        else if (pathname.endsWith('.js')) {
+            if (!content)
+                content = fs_1.default.readFileSync(path, 'utf-8');
+            await eachAllLinkInJavaScript(webRoot, content, list);
+        }
+    });
+    return _newVersionJson = {
+        version: 3, list
+    };
+}
+exports.buildVersionJson = buildVersionJson;
+/**
+ * 检索一个 URL 指向的文件中所有地外部链接
+ *
+ * 该函数会处理该 URL 指向的文件和文件中直接或间接包含的所有 URL
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **调用该函数前必须调用过 [loadCacheJson]**
+ * + **执行该函数前必须调用过 [calcEjectValues]**
+ *
+ * @param webRoot 网站域名
+ * @param url 要检索的 URL
+ * @param result 存放结果的对象
+ * @param event 检索到一个 URL 时触发的事件
+ */
+async function eachAllLinkInUrl(webRoot, url, result, event) {
+    if (url.startsWith('//'))
+        url = 'http' + url;
+    if (url in result)
+        return event?.(url);
+    if (!url.startsWith('http') || isExclude(webRoot, url))
+        return;
+    if (!(isExternalLink(webRoot, url) && findCache(new URL(url))))
+        return;
+    event?.(url);
+    const stable = isStable(url);
+    if (stable) {
+        const old = readOldVersionJson().list;
+        if (url in old) {
+            const copyTree = (key) => {
+                const value = old[key];
+                if (!value)
+                    return;
+                result[key] = value;
+                if (Array.isArray(value)) {
+                    result[key] = value;
+                    for (let url of value) {
+                        copyTree(url);
+                    }
+                }
+                else {
+                    event?.(value);
+                }
+            };
+            copyTree(url);
+            return;
+        }
+    }
+    const response = await (0, Utils_1.fetchFile)(url);
+    if (![200, 301, 302, 307, 308].includes(response.status))
+        throw response;
+    const pathname = new URL(url).pathname;
+    let content;
+    const relay = [];
+    const nextEvent = (it) => {
+        relay.push(it);
+        event?.(it);
+    };
+    switch (true) {
+        case pathname.endsWith('.html'):
+        case pathname.endsWith('/'):
+            content = await response.text();
+            await eachAllLinkInHtml(webRoot, content, result, nextEvent);
+            break;
+        case pathname.endsWith('.css'):
+            content = await response.text();
+            await eachAllLinkInCss(webRoot, content, result, nextEvent);
+            break;
+        case pathname.endsWith('.js'):
+            content = await response.text();
+            await eachAllLinkInJavaScript(webRoot, content, result, nextEvent);
+            break;
+        default:
+            if (stable) {
+                result[url] = [];
+            }
+            else {
+                const buffer = buffer_1.Buffer.from(await response.arrayBuffer());
+                result[url] = crypto.createHash('md5').update(buffer).digest('hex');
+            }
+            break;
+    }
+    if (content) {
+        if (stable) {
+            result[url] = relay;
+        }
+        else {
+            result[url] = crypto.createHash('md5').update(content).digest('hex');
+        }
+    }
+}
+exports.eachAllLinkInUrl = eachAllLinkInUrl;
+/**
+ * 检索 HTML 文件中的所有外部链接
+ *
+ * 该函数仅处理 HTML 当中直接或间接包含的 URL，不处理文件本身
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **调用该函数前必须调用过 [loadCacheJson]**
+ *
+ * @param webRoot 网站域名
+ * @param content HTML 文件内容
+ * @param result 存放结果的对象
+ * @param event 检索到 URL 时触发的事件
+ */
+async function eachAllLinkInHtml(webRoot, content, result, event) {
+    const each = async (node) => {
+        let url = undefined;
+        switch (node.tagName) {
+            case 'link':
+                url = node.attributes.href;
+                break;
+            case 'script':
+            case 'img':
+            case 'source':
+            case 'iframe':
+            case 'embed':
+                url = node.attributes.src;
+                break;
+            case 'object':
+                url = node.attributes.data;
+                break;
+        }
+        if (url) {
+            await eachAllLinkInUrl(webRoot, url, result, event);
+        }
+        else if (node.tagName === 'script') {
+            await eachAllLinkInJavaScript(webRoot, node.rawText, result, event);
+        }
+        else if (node.tagName === 'style') {
+            await eachAllLinkInCss(webRoot, node.rawText, result, event);
+        }
+        for (let childNode of node.childNodes) {
+            await each(childNode);
+        }
+    };
+    await each(fast_html_parser_1.default.parse(content, { style: true, script: true }));
+}
+exports.eachAllLinkInHtml = eachAllLinkInHtml;
+/**
+ * 检索 CSS 文件中的所有外部链
+ *
+ * 该函数仅处理 CSS 当中直接或间接包含的 URL，不处理文件本身
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **调用该函数前必须调用过 [loadCacheJson]**
+ *
+ * @param webRoot 网站域名
+ * @param content CSS 文件内容
+ * @param result 存放结果的对象
+ * @param event 当检索到一个 URL 后触发的事件
+ */
+async function eachAllLinkInCss(webRoot, content, result, event) {
+    const each = async (any) => {
+        if (!any)
+            return;
+        for (let rule of any) {
+            switch (rule.type) {
+                case 'rule':
+                    await each(rule.declarations);
+                    break;
+                case 'declaration':
+                    const value = rule.value;
+                    const list = value.match(/url\(['"]?([^'")]+)['"]?\)/g)
+                        ?.map(it => it.replace(/(^url\(['"])|(['"]\)$)/g, ''));
+                    if (list) {
+                        for (let url of list) {
+                            await eachAllLinkInUrl(webRoot, url, result, event);
+                        }
+                    }
+                    break;
+                case 'import':
+                    const url = rule.import.trim().replace(/^["']|["']$/g, '');
+                    await eachAllLinkInUrl(webRoot, url, result, event);
+                    break;
+            }
+        }
+    };
+    await each(css_1.default.parse(content).stylesheet?.rules);
+}
+exports.eachAllLinkInCss = eachAllLinkInCss;
+/**
+ * 遍历 JS 文件中地所有外部链接
+ *
+ * 该函数仅处理 JS 当中直接或间接包含的 URL，不处理文件本身
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **调用该函数前必须调用过 [loadCacheJson]**
+ *
+ * @param webRoot 网站域名
+ * @param content JS 文件内容
+ * @param result 存放结果的对象
+ * @param event 当检索到一个 URL 后触发的事件
+ */
+async function eachAllLinkInJavaScript(webRoot, content, result, event) {
+    const ruleList = (0, SwppRules_1.readRules)().config?.external?.js;
+    if (!ruleList)
+        throw 'ruleList 为空';
+    for (let value of ruleList) {
+        if (typeof value === 'function') {
+            const urls = value(content);
+            for (let url of urls) {
+                await eachAllLinkInUrl(webRoot, url, result, event);
+            }
+        }
+        else {
+            const { head, tail } = value;
+            const reg = new RegExp(`${head}(['"\`])(.*?)(['"\`])${tail}`, 'mg');
+            const list = content.match(reg)
+                ?.map(it => it.substring(head.length, it.length - tail.length).trim())
+                ?.map(it => it.replace(/^['"`]|['"`]$/g, ''));
+            if (list) {
+                for (let url of list) {
+                    await eachAllLinkInUrl(webRoot, url, result, event);
+                }
+            }
+        }
+    }
+}
+exports.eachAllLinkInJavaScript = eachAllLinkInJavaScript;
+/** 判断一个 URL 是否是外部链接 */
+function isExternalLink(webRoot, url) {
+    return new RegExp(`^(https?:)?\\/\\/${webRoot}`).test(url);
+}
+/**
+ * 查询指定 URL 对应的缓存规则
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **执行该函数前必须调用过 [calcEjectValues]**
+ */
+function findCache(url) {
+    const { cacheRules } = (0, SwppRules_1.readRules)();
+    const eject = (0, Utils_1.readEjectData)();
+    if (typeof url === 'string')
+        url = new URL(url);
+    url = new URL(replaceRequest(url.href));
+    for (let key in cacheRules) {
+        const value = cacheRules[key];
+        if (value.match(url, eject.nodeEject))
+            return value;
+    }
+    return null;
+}
+exports.findCache = findCache;
+/**
+ * 替换请求
+ *
+ * + **执行该函数前必须调用过 [loadRules]**
+ * + **执行该函数前必须调用过 [calcEjectValues]**
+ */
+function replaceRequest(url) {
+    const rules = (0, SwppRules_1.readRules)();
+    if (!('modifyRequest' in rules))
+        return url;
+    const { modifyRequest } = rules;
+    const request = new node_fetch_1.Request(url);
+    return modifyRequest?.(request, (0, Utils_1.readEjectData)().nodeEject)?.url ?? url;
+}
+exports.replaceRequest = replaceRequest;

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Utils_1 = require("./Utils");
+const FileAnalyzer_1 = require("./FileAnalyzer");
+const ServiceWorkerBuilder_1 = require("./ServiceWorkerBuilder");
+const SwppRules_1 = require("./SwppRules");
+const UpdateJsonBuilder_1 = require("./UpdateJsonBuilder");
+const VersionAnalyzer_1 = require("./VersionAnalyzer");
+// noinspection JSUnusedGlobalSymbols
+exports.default = {
+    cache: {
+        readEjectData: Utils_1.readEjectData, readUpdateJson: UpdateJsonBuilder_1.readUpdateJson,
+        readRules: SwppRules_1.readRules, readMergeVersionMap: FileAnalyzer_1.readMergeVersionMap,
+        readOldVersionJson: FileAnalyzer_1.readOldVersionJson, readNewVersionJson: FileAnalyzer_1.readNewVersionJson
+    },
+    builder: {
+        buildServiceWorker: ServiceWorkerBuilder_1.buildServiceWorker,
+        buildVersionJson: FileAnalyzer_1.buildVersionJson,
+        buildNewInfo: UpdateJsonBuilder_1.buildNewInfo,
+        calcEjectValues: Utils_1.calcEjectValues,
+        analyzer: VersionAnalyzer_1.analyzer
+    },
+    loader: {
+        loadRules: SwppRules_1.loadRules, loadUpdateJson: UpdateJsonBuilder_1.loadUpdateJson, loadVersionJson: FileAnalyzer_1.loadVersionJson
+    },
+    event: {
+        addRulesMapEvent: SwppRules_1.addRulesMapEvent, refreshUrl: VersionAnalyzer_1.refreshUrl, submitChange: UpdateJsonBuilder_1.submitChange
+    },
+    utils: {
+        getSource: Utils_1.getSource, getShorthand: UpdateJsonBuilder_1.getShorthand, findCache: FileAnalyzer_1.findCache,
+        fetchFile: Utils_1.fetchFile, replaceDevRequest: Utils_1.replaceDevRequest, replaceRequest: FileAnalyzer_1.replaceRequest,
+        isStable: FileAnalyzer_1.isStable, isExclude: FileAnalyzer_1.isExclude,
+        eachAllLinkInUrl: FileAnalyzer_1.eachAllLinkInUrl, eachAllLinkInHtml: FileAnalyzer_1.eachAllLinkInHtml, eachAllLinkInCss: FileAnalyzer_1.eachAllLinkInCss, eachAllLinkInJavaScript: FileAnalyzer_1.eachAllLinkInJavaScript
+    }
+};

package/dist/resources/sw-dom.js

@@ -0,0 +1,51 @@
+document.addEventListener('DOMContentLoaded', () => {
+    /** 检查 SW 是否可用 */
+    const checkServiceWorker = () => 'serviceWorker' in navigator && navigator.serviceWorker.controller
+    /** 发送信息到 sw */
+    const postMessage2SW = type => navigator.serviceWorker.controller.postMessage(type)
+    const pjaxUpdate = url => new Promise(resolve => {
+        const type = url.endsWith('js') ? 'script' : 'link'
+        const name = type.length === 4 ? 'href' : 'src'
+        for (let item of document.querySelectorAll(type)) {
+            const itUrl = item[name]
+            if (url.length > itUrl ? url.endsWith(itUrl) : itUrl.endsWith(url)) {
+                const newEle = document.createElement(type)
+                const content = item.text || item.textContent || item.innerHTML || ''
+                Array.from(item.attributes).forEach(attr => newEle.setAttribute(attr.name, attr.value))
+                newEle.appendChild(document.createTextNode(content))
+                item.parentNode.replaceChildren(newEle, item)
+                return resolve(true)
+            }
+        }
+        resolve(false)
+    })
+    if (!checkServiceWorker()) return
+    if (sessionStorage.getItem('updated')) {
+        sessionStorage.removeItem('updated')
+        // ${onSuccess}
+    } else postMessage2SW('update')
+    navigator.serviceWorker.addEventListener('message', event => {
+        const data = event.data
+        switch (data.type) {
+            case 'update':
+                const list = data.update
+                if (!list) break
+                sessionStorage.setItem('updated', '1')
+                // noinspection JSUnresolvedVariable,JSUnresolvedFunction
+                if (window.Pjax?.isSupported()) {
+                    Promise.all(list.map(url => {
+                        if (url.endsWith('.js'))
+                            return pjaxUpdate(url)
+                        if (url.endsWith('.css'))
+                            return pjaxUpdate(url)
+                        return Promise.resolve()
+                    })).then(() => location.reload())
+                } else location.reload()
+                break
+            case 'escape':
+                sessionStorage.setItem('updated', '1')
+                location.reload()
+                break
+        }
+    })
+})