swpp-backends 3.0.0-alpha.3 → 3.0.0-alpha.310

package/dist/swpp/database/CrossDepCode.js

@@ -8,7 +8,17 @@ const RuntimeKeyValueDatabase_1 = require("./RuntimeKeyValueDatabase");
  */
 class CrossDepCode extends RuntimeKeyValueDatabase_1.RuntimeKeyValueDatabase {
     constructor() {
-        super(buildCommon());
+        super('CrossDepCode', buildCommon(), (key, value) => {
+            if (typeof value != 'object') {
+                throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidVarType, `crossDep[${key}] 返回的内容应当为一个 object`, { value });
+            }
+            if (!('runOnNode' in value)) {
+                throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidVarType, `crossDep[${key}] 返回的对象应当包含 {runOnNode} 字段`, { value });
+            }
+            if (!('runOnBrowser' in value)) {
+                throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidVarType, `crossDep[${key}] 返回的对象应当包含 {runOnBrowser} 字段`, { value });
+            }
+        });
     }
     /** 构建 JS 源代码 */
     buildJsSource() {
@@ -28,6 +38,22 @@ function buildCommon() {
                 }
             })
         },
+        /** 归一化 URL */
+        normalizeUrl: {
+            default: buildFunction({
+                runOnBrowser: (url) => {
+                    if (url.endsWith('/index.html'))
+                        return url.substring(0, url.length - 10);
+                    if (url.endsWith('.html'))
+                        return url.substring(0, url.length - 5);
+                    else
+                        return url;
+                },
+                runOnNode(url) {
+                    return this.runOnBrowser(url);
+                }
+            })
+        },
         /** 匹配缓存更新规则 */
         matchUpdateRule: {
             default: buildFunction({

package/dist/swpp/database/CrossEnv.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CrossEnv = void 0;
+const path_1 = __importDefault(require("path"));
+const ConfigCluster_1 = require("../config/ConfigCluster");
 const untils_1 = require("../untils");
 const KeyValueDatabase_1 = require("./KeyValueDatabase");
 const RuntimeKeyValueDatabase_1 = require("./RuntimeKeyValueDatabase");
@@ -11,7 +16,11 @@ function isLegalHeaderName(name) {
 /** 环境变量存储器 */
 class CrossEnv extends RuntimeKeyValueDatabase_1.RuntimeKeyValueDatabase {
     constructor() {
-        super(buildCommon());
+        super('CrossEnv', buildCommon(), (key, value) => {
+            if (typeof value === 'function') {
+                throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidVarType, `crossEnv[${key}] 应当返回一个非函数`, { value: value.toString() });
+            }
+        });
     }
     /** 构建 JS 源代码 */
     buildJsSource() {
@@ -60,7 +69,15 @@ function buildCommon() {
         }),
         /** 版本文件所在目录 */
         UPDATE_JSON_URL: (0, KeyValueDatabase_1.buildEnv)({
-            default: '/update.json'
+            default: (0, ConfigCluster_1.defineLazyInitConfig)((_, compilation) => {
+                const info = compilation.compilationEnv.read('SWPP_JSON_FILE');
+                return path_1.default.posix.join(info.swppPath, info.versionPath);
+            }),
+            checker(value) {
+                if (this.manual)
+                    return { value, message: '不应当手动设置该项！' };
+                return false;
+            }
         }),
         /** 检查更新的最短时间间隔 */
         UPDATE_CD: (0, KeyValueDatabase_1.buildEnv)({

package/{types → dist}/swpp/database/DomCode.d.ts

@@ -6,6 +6,9 @@ export declare class DomCode extends RuntimeKeyValueDatabase<any, COMMON_TYPE_DO
     buildInnerSource(): string;
 }
 declare function buildCommon(): {
+    readonly registry: {
+        readonly default: import("../config/SpecialConfig").LazyInitConfig<string>;
+    };
     readonly postMessage2Sw: {
         readonly default: (type: string) => void;
     };
@@ -22,7 +25,7 @@ declare function buildCommon(): {
         readonly default: () => void;
     };
     readonly messageEvent: {
-        readonly default: (event: MessageEvent) => Promise<void>;
+        readonly default: (event: MessageEvent) => void;
     };
 };
 export {};

package/dist/swpp/database/DomCode.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DomCode = void 0;
+const ConfigCluster_1 = require("../config/ConfigCluster");
 const untils_1 = require("../untils");
 const RuntimeKeyValueDatabase_1 = require("./RuntimeKeyValueDatabase");
 class DomCode extends RuntimeKeyValueDatabase_1.RuntimeKeyValueDatabase {
     constructor() {
-        super(buildCommon());
+        super('DomCode', buildCommon());
     }
     buildJsSource() {
         return `
@@ -16,9 +17,10 @@ class DomCode extends RuntimeKeyValueDatabase_1.RuntimeKeyValueDatabase {
     }
     buildInnerSource() {
         const map = this.entries();
+        delete map['registry'];
         const inlineCode = Object.keys(map)
             .filter(it => it.startsWith('_inline'))
-            .map(it => `${it}()`);
+            .map(it => `(${it.toString()})()`);
         return `
             const controller = navigator.serviceWorker?.controller
             if (!controller) return
@@ -31,15 +33,42 @@ class DomCode extends RuntimeKeyValueDatabase_1.RuntimeKeyValueDatabase {
     }
 }
 exports.DomCode = DomCode;
-let controller;
 let SESSION_KEY;
 let onSuccess;
 let pjaxUpdate;
 let postMessage2Sw;
 function buildCommon() {
     return {
+        registry: {
+            default: (0, ConfigCluster_1.defineLazyInitConfig)((_, compilation) => {
+                const value = (() => {
+                    const sw = navigator.serviceWorker;
+                    if (sw) {
+                        sw.register('$$sw.js')
+                            .then(async (registration) => {
+                            console.log('SWPP 注册成功');
+                            try {
+                                // @ts-ignore
+                                await registration.periodicSync.register("update", {
+                                    minInterval: 24 * 60 * 60 * 1000
+                                });
+                            }
+                            catch (e) {
+                                console.warn('Periodic Sync 注册失败', e);
+                            }
+                        })
+                            .catch(err => console.error('SWPP 注册失败', err));
+                    }
+                    else {
+                        console.warn('当前浏览器不支持 SW');
+                    }
+                }).toString();
+                const path = compilation.compilationEnv.read('SERVICE_WORKER');
+                return value.replace(`'$$sw.js'`, path + '.js');
+            })
+        },
         postMessage2Sw: {
-            default: (type) => controller.postMessage(type)
+            default: (type) => navigator.serviceWorker.controller.postMessage(type)
         },
         pjaxUpdate: {
             default: (url) => {
@@ -76,7 +105,7 @@ function buildCommon() {
             }
         },
         messageEvent: {
-            default: async (event) => {
+            default: (event) => {
                 const data = event.data;
                 sessionStorage.setItem(SESSION_KEY, data.type);
                 const list = data.data?.filter((url) => /\.(js|css)$/.test(url));

package/dist/swpp/database/KeyValueDatabase.d.ts

@@ -0,0 +1,72 @@
+import { RuntimeSpecialConfig } from '../config/SpecialConfig';
+import { CompilationData, RuntimeData } from '../SwCompiler';
+/** 键值对存储器 */
+export declare class KeyValueDatabase<T, CONTAINER extends Record<string, DatabaseValue<T>>> {
+    readonly namespace: string;
+    private readonly globalChecker?;
+    private dataValues;
+    private valueCaches;
+    private _runtime;
+    private _compilation;
+    /**
+     * @param namespace 命名空间
+     * @param map 默认值
+     * @param globalChecker 全局检查器（优先于每个属性设置的 checker 执行），遇到问题直接抛出异常
+     */
+    constructor(namespace: string, map?: CONTAINER, globalChecker?: ((key: string, value: T) => void) | undefined);
+    /** 延迟初始化 */
+    protected lazyInit(map: CONTAINER): void;
+    /** 初始化各项数据 */
+    initRuntimeAndCompilation(runtime: RuntimeData, compilation: CompilationData): void;
+    /**
+     * 读取指定键对应的值。
+     *
+     * 注意：允许被缓存的值返回后是不允许被修改的，不缓存的值是允许修改的。
+     */
+    read<K extends keyof CONTAINER | string>(_key: K): K extends keyof CONTAINER ? Exclude<CONTAINER[K]['default'], RuntimeSpecialConfig<any>> : T;
+    /** 读取默认配置 */
+    readDefault<K extends keyof CONTAINER | string>(_key: K): K extends keyof CONTAINER ? CONTAINER[K]['default'] : T;
+    /**
+     * 设置指定键对应的值
+     */
+    update<K extends keyof CONTAINER | string>(key: K, manual: T | RuntimeSpecialConfig<T>): void;
+    /**
+     * 追加键值对
+     */
+    append(key: string, env: DatabaseValue<T>): void;
+    /** 判断是否存在指定的环境变量 */
+    hasKey<K extends keyof CONTAINER | string>(key: K): (K extends keyof CONTAINER ? true : boolean);
+    /** 判断指定键对应的环境变量是否存在用户设置的值 */
+    hasValue<K extends keyof CONTAINER | string>(key: K): boolean;
+    /** 获取所有键值对 */
+    entries(): Record<string, T>;
+    /** 冻结 KV 库，冻结后无法再添加和修改内容 */
+    freeze(): void;
+    protected get runtime(): RuntimeData;
+    protected get compilation(): CompilationData;
+    private set runtime(value);
+    private set compilation(value);
+}
+/**
+ * 为优化 IDE 的类型推断提供的函数，直接返回传入的值
+ * @param env
+ */
+export declare function buildEnv<T>(env: DatabaseValue<T>): DatabaseValue<T>;
+/**
+ * 读取指定对象中的指定字段。
+ *
+ * 由于配置文件中允许同时写入 T 或 `Runtime<T>`，当在配置项中使用 `this` 时，需要先判定 `this` 是哪一个类型
+ */
+export declare function readThisValue<T extends RuntimeSpecialConfig<object> | object, K extends keyof (T extends RuntimeSpecialConfig<any> ? ReturnType<T['get']> : T)>(obj: T, key: K): T extends RuntimeSpecialConfig<any> ? ReturnType<T['get']>[K] : T[K];
+export interface DatabaseValue<T> {
+    /** 缺省值 */
+    default: T | RuntimeSpecialConfig<T>;
+    /** 用户填入的值 */
+    manual?: T | RuntimeSpecialConfig<T>;
+    /** 检查器，返回 false 表示无错误 */
+    checker?: (value: T) => false | RuntimeEnvErrorTemplate<T>;
+}
+export interface RuntimeEnvErrorTemplate<T> {
+    value: T;
+    message: string;
+}

package/dist/swpp/database/KeyValueDatabase.js

@@ -2,69 +2,156 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyValueDatabase = void 0;
 exports.buildEnv = buildEnv;
+exports.readThisValue = readThisValue;
+const SpecialConfig_1 = require("../config/SpecialConfig");
+const untils_1 = require("../untils");
 /** 键值对存储器 */
 class KeyValueDatabase {
-    constructor(map) {
-        this.runtimeEnvMap = {};
+    /**
+     * @param namespace 命名空间
+     * @param map 默认值
+     * @param globalChecker 全局检查器（优先于每个属性设置的 checker 执行），遇到问题直接抛出异常
+     */
+    constructor(namespace, map, globalChecker) {
+        this.namespace = namespace;
+        this.globalChecker = globalChecker;
+        this.dataValues = {};
+        this.valueCaches = {};
+        this._runtime = null;
+        this._compilation = null;
         if (map) {
-            Object.assign(this.runtimeEnvMap, map);
+            Object.assign(this.dataValues, map);
         }
     }
     /** 延迟初始化 */
     lazyInit(map) {
-        Object.assign(this.runtimeEnvMap, map);
+        Object.assign(this.dataValues, map);
+    }
+    /** 初始化各项数据 */
+    initRuntimeAndCompilation(runtime, compilation) {
+        this.runtime = runtime;
+        this.compilation = compilation;
     }
     /**
-     * 读取指定键对应的值
-     * @throws RuntimeEnvException
+     * 读取指定键对应的值。
+     *
+     * 注意：允许被缓存的值返回后是不允许被修改的，不缓存的值是允许修改的。
      */
-    read(key) {
-        const item = this.runtimeEnvMap[key];
+    read(_key) {
+        const key = _key;
+        if (key in this.valueCaches) {
+            return this.valueCaches[key];
+        }
+        const item = this.dataValues[key];
         if (!item)
-            throw { key, message: 'key 不存在' };
-        const value = item.getter ? item.getter() : item.default;
-        if (!(value === null || value === undefined) && typeof value != typeof item.default)
-            throw { key, value, message: '用户传入的值类型与缺省值类型不统一' };
+            throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidKey, `输入的 key[${key}] 不存在`);
+        // 获取真实值
+        let value = item.default;
+        let isNoCache = false;
+        if (item.manual) {
+            if (SpecialConfig_1.SpecialConfig.isSpecialConfig(item.manual)) {
+                this.runtime.debugCallChain.push(this.namespace, key);
+                value = item.manual.get(this.runtime, this.compilation);
+                this.runtime.debugCallChain.pop(this.namespace, key);
+                if (SpecialConfig_1.SpecialConfig.isNoCacheConfig(item.manual)) {
+                    isNoCache = true;
+                }
+            }
+            else {
+                value = item.manual;
+            }
+        }
+        // 进行类型预检
+        if (!(value === null || value === undefined) && typeof value != typeof item.default) {
+            throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidValue, '用户传入的值类型与缺省值类型不统一', { default: item.default, value });
+        }
+        // 执行全局检查
+        this.globalChecker?.(key, value);
+        // 执行用户数据检查
         const checkResult = item.checker?.(value);
-        if (checkResult)
-            throw { key, ...checkResult };
-        return value;
+        if (checkResult) {
+            throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidValue, `设置的值非法`, { key, ...checkResult });
+        }
+        // 如果不需要缓存直接返回，否则存入缓存后返回
+        if (isNoCache)
+            return value;
+        return this.valueCaches[key] = value;
+    }
+    /** 读取默认配置 */
+    readDefault(_key) {
+        const key = _key;
+        const item = this.dataValues[key];
+        if (!item)
+            throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidKey, `传入的 key[${key}] 不存在`);
+        return item.default;
     }
     /**
      * 设置指定键对应的值
-     * @throws RuntimeEnvException
      */
-    update(key, valueGetter) {
-        if (!(key in this.runtimeEnvMap))
-            throw { key, value: null, message: 'key 不存在' };
-        this.runtimeEnvMap[key].getter = valueGetter;
+    update(key, manual) {
+        if (!(key in this.dataValues))
+            throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidKey, `传入的 key[${key}] 不存在`);
+        this.dataValues[key].manual = manual;
+        delete this.valueCaches[key];
     }
     /**
      * 追加键值对
-     * @throws RuntimeEnvException
      */
     append(key, env) {
-        if (key in this.runtimeEnvMap)
-            throw { key, value: this.runtimeEnvMap[key], message: 'key 重复' };
-        this.runtimeEnvMap[key] = env;
+        if (key in this.dataValues)
+            throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidKey, `追加的 key[${key}] 已存在`);
+        if ('manual' in env)
+            throw new untils_1.RuntimeException(untils_1.exceptionNames.invalidValue, `追加的属性中不应当包含 getter 字段`);
+        this.dataValues[key] = env;
     }
     /** 判断是否存在指定的环境变量 */
     hasKey(key) {
         // @ts-ignore
-        return key in this.runtimeEnvMap;
+        return key in this.dataValues;
     }
     /** 判断指定键对应的环境变量是否存在用户设置的值 */
     hasValue(key) {
-        return this.hasKey(key) && !!this.runtimeEnvMap[key].getter;
+        return this.hasKey(key) && !!this.dataValues[key].manual;
     }
     /** 获取所有键值对 */
     entries() {
         const result = {};
-        for (let key in this.runtimeEnvMap) {
+        for (let key in this.dataValues) {
             result[key] = this.read(key);
         }
         return result;
     }
+    /** 冻结 KV 库，冻结后无法再添加和修改内容 */
+    freeze() {
+        if (Object.isFrozen(this.dataValues))
+            return;
+        this.dataValues = new Proxy(Object.freeze(this.dataValues), {
+            set() {
+                throw new untils_1.RuntimeException(untils_1.exceptionNames.isFrozen, 'KV 库已经被冻结无法修改');
+            },
+            setPrototypeOf() {
+                throw new untils_1.RuntimeException(untils_1.exceptionNames.isFrozen, 'KV 库已经被冻结无法修改');
+            },
+            deleteProperty() {
+                throw new untils_1.RuntimeException(untils_1.exceptionNames.isFrozen, 'KV 库已经被冻结无法修改');
+            },
+            defineProperty() {
+                throw new untils_1.RuntimeException(untils_1.exceptionNames.isFrozen, 'KV 库已经被冻结无法修改');
+            }
+        });
+    }
+    get runtime() {
+        return this._runtime;
+    }
+    get compilation() {
+        return this._compilation;
+    }
+    set runtime(value) {
+        this._runtime = value;
+    }
+    set compilation(value) {
+        this._compilation = value;
+    }
 }
 exports.KeyValueDatabase = KeyValueDatabase;
 /**
@@ -74,3 +161,11 @@ exports.KeyValueDatabase = KeyValueDatabase;
 function buildEnv(env) {
     return env;
 }
+/**
+ * 读取指定对象中的指定字段。
+ *
+ * 由于配置文件中允许同时写入 T 或 `Runtime<T>`，当在配置项中使用 `this` 时，需要先判定 `this` 是哪一个类型
+ */
+function readThisValue(obj, key) {
+    return obj[key];
+}

package/{types → dist}/swpp/database/RuntimeCoreCode.d.ts

@@ -5,7 +5,7 @@ export type COMMON_TYPE_RUNTIME_CORE = ReturnType<typeof buildCommon>;
 /**
  * 运行时核心功能代码
  */
-export declare class RuntimeCoreCode extends RuntimeKeyValueDatabase<FunctionInBrowser<any, any> | null, COMMON_TYPE_RUNTIME_CORE> {
+export declare class RuntimeCoreCode extends RuntimeKeyValueDatabase<FunctionInBrowser<any[], any> | null, COMMON_TYPE_RUNTIME_CORE> {
     constructor();
     /** 构建 JS 源代码 */
     buildJsSource(): string;
@@ -23,6 +23,7 @@ declare function buildCommon(): {
     readonly handleUpdate: {
         readonly default: (oldVersion: BrowserVersion | undefined, force?: boolean) => Promise<1 | -1 | 2 | undefined | null | void | string[]>;
     };
+    /** 处理网络请求事件 */
     readonly handleFetchEvent: {
         readonly default: (event: Event) => any;
     };

package/dist/swpp/database/RuntimeCoreCode.js

@@ -29,7 +29,7 @@ let matchUpdateRule;
  */
 class RuntimeCoreCode extends RuntimeKeyValueDatabase_1.RuntimeKeyValueDatabase {
     constructor() {
-        super(buildCommon());
+        super('RuntimeCoreCode', buildCommon());
     }
     /** 构建 JS 源代码 */
     buildJsSource() {
@@ -41,13 +41,13 @@ function buildCommon() {
     return {
         /** 逃生门功能实现 */
         handleEscape: {
-            default: () => readVersion()
-                .then(async (oldVersion) => {
-                if (oldVersion && oldVersion.escape !== ESCAPE) {
+            default: async () => {
+                const oldVersion = await readVersion();
+                if (ESCAPE && oldVersion && oldVersion.escape !== ESCAPE) {
                     await caches.delete(CACHE_NAME);
                     await postMessage('escape', null);
                 }
-            })
+            }
         },
         /**
          * 缓存增量更新功能实现
@@ -103,6 +103,7 @@ function buildCommon() {
                 return 2;
             }
         },
+        /** 处理网络请求事件 */
         handleFetchEvent: {
             default: (event) => {
                 // @ts-ignore

package/{types → dist}/swpp/database/RuntimeDepCode.d.ts

@@ -5,10 +5,8 @@ import { RuntimeKeyValueDatabase } from './RuntimeKeyValueDatabase';
 export type FunctionInBrowser<Args extends any[], R> = (...args: Args) => R;
 export type COMMON_KEY_RUNTIME_DEP = ReturnType<typeof buildCommon>;
 /** 运行时依赖代码 */
-export declare class RuntimeDepCode extends RuntimeKeyValueDatabase<FunctionInBrowser<any, any> | null, COMMON_KEY_RUNTIME_DEP> {
+export declare class RuntimeDepCode extends RuntimeKeyValueDatabase<FunctionInBrowser<any[], any> | null, COMMON_KEY_RUNTIME_DEP> {
     constructor();
-    /** 修正函数 */
-    fixDepFunction(): void;
     /** 构建 JS 源代码 */
     buildJsSource(): string;
 }
@@ -32,7 +30,7 @@ declare function buildCommon(): {
     };
     /** 判断指定的缓存是否是有效缓存 */
     readonly isValidCache: {
-        readonly default: (response: Response, rule: number | false | null | undefined) => boolean;
+        readonly default: (response: Response, rule: number) => boolean;
     };
     /** 读取版本号 */
     readonly readVersion: {
@@ -65,13 +63,13 @@ declare function buildCommon(): {
     };
     /** 获取竞速列表 */
     readonly getFastestRequests: {
-        readonly default: null;
-        readonly checker: (value: FunctionInBrowser<any, any> | null) => false | RuntimeEnvErrorTemplate<FunctionInBrowser<any[], any>>;
+        readonly default: FunctionInBrowser<any[], any> | null;
+        readonly checker: (value: FunctionInBrowser<any[], any> | null) => false | RuntimeEnvErrorTemplate<FunctionInBrowser<any[], any>>;
     };
     /** 获取备用 URL 列表 */
     readonly getStandbyRequests: {
-        readonly default: null;
-        readonly checker: (value: FunctionInBrowser<any, any> | null) => false | RuntimeEnvErrorTemplate<FunctionInBrowser<any[], any>>;
+        readonly default: FunctionInBrowser<any[], any> | null;
+        readonly checker: (value: FunctionInBrowser<any[], any> | null) => false | RuntimeEnvErrorTemplate<FunctionInBrowser<any[], any>>;
     };
     /** URL 竞速拉取 */
     readonly fetchFastest: {
@@ -81,16 +79,12 @@ declare function buildCommon(): {
     readonly fetchStandby: {
         readonly default: (request: Request, standbyRequests: {
             t: number;
-            l: Request[];
+            l: () => Request[];
         }, optional?: RequestInit) => Promise<Response>;
     };
     /** 拉取文件 */
     readonly fetchFile: {
-        readonly default: (request: RequestInfo | URL, optional?: RequestInit) => Promise<Response>;
-    };
-    /** 归一化 URL */
-    readonly normalizeUrl: {
-        readonly default: (url: string) => string;
+        readonly default: import("../config/SpecialConfig").LazyInitConfig<(requestOrUrl: RequestInfo | URL, optional?: RequestInit) => Promise<Response>>;
     };
     /** 是否阻断请求 */
     readonly isBlockRequest: {