befly 3.16.10 → 3.17.0

package/dist/lib/cacheHelper.js

@@ -1,477 +0,0 @@
-/**
- * 缓存助手 - TypeScript 版本
- * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
- */
-import { CoreError } from "../types/coreError";
-import { CacheKeys } from "./cacheKeys";
-import { Logger } from "./logger";
-/**
- * 缓存助手类
- */
-export class CacheHelper {
-    db;
-    redis;
-    constructor(deps) {
-        this.db = deps.db;
-        this.redis = deps.redis;
-    }
-    assertApiPathname(value, errorPrefix) {
-        if (typeof value !== "string") {
-            throw new Error(`${errorPrefix} 必须是字符串`);
-        }
-        const trimmed = value.trim();
-        if (!trimmed) {
-            throw new Error(`${errorPrefix} 不允许为空字符串`);
-        }
-        if (/^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/i.test(trimmed)) {
-            throw new Error(`${errorPrefix} 不允许包含 method 前缀，应为 url.pathname（例如 /api/app/xxx）`);
-        }
-        if (!trimmed.startsWith("/")) {
-            throw new Error(`${errorPrefix} 必须是 pathname（以 / 开头）`);
-        }
-        if (trimmed.includes(" ")) {
-            throw new Error(`${errorPrefix} 不允许包含空格`);
-        }
-        return trimmed;
-    }
-    assertMenuPathname(value, errorPrefix) {
-        if (typeof value !== "string") {
-            throw new Error(`${errorPrefix} 必须是字符串`);
-        }
-        const trimmed = value.trim();
-        if (!trimmed) {
-            throw new Error(`${errorPrefix} 不允许为空字符串`);
-        }
-        if (!trimmed.startsWith("/")) {
-            throw new Error(`${errorPrefix} 必须是 pathname（以 / 开头）`);
-        }
-        if (trimmed.includes(" ")) {
-            throw new Error(`${errorPrefix} 不允许包含空格`);
-        }
-        if (trimmed.length > 1 && trimmed.endsWith("/")) {
-            throw new Error(`${errorPrefix} 不允许以 / 结尾`);
-        }
-        return trimmed;
-    }
-    assertApiPathList(value, roleCode) {
-        if (value === null || value === undefined)
-            return [];
-        let list = value;
-        // 兼容历史/手工数据：apis 可能被存成 JSON 字符串或 "null"
-        if (typeof list === "string") {
-            const trimmed = list.trim();
-            // TEXT 字段常见历史值："null"（表示空）
-            if (trimmed === "" || trimmed === "null") {
-                return [];
-            }
-            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-                try {
-                    list = JSON.parse(trimmed);
-                }
-                catch {
-                    throw new Error(`角色权限数据不合法：addon_admin_role.apis JSON 解析失败，roleCode=${roleCode}`);
-                }
-            }
-        }
-        if (!Array.isArray(list)) {
-            const typeLabel = typeof list;
-            throw new Error(`角色权限数据不合法：addon_admin_role.apis 必须是字符串数组或 JSON 数组字符串，roleCode=${roleCode}，type=${typeLabel}`);
-        }
-        const out = [];
-        for (const item of list) {
-            out.push(this.assertApiPathname(item, `角色权限数据不合法：addon_admin_role.apis 元素，roleCode=${roleCode}`));
-        }
-        return out;
-    }
-    assertMenuPathList(value, roleCode) {
-        if (value === null || value === undefined)
-            return [];
-        let list = value;
-        // 兼容历史/手工数据：menus 可能被存成 JSON 字符串或 "null"
-        if (typeof list === "string") {
-            const trimmed = list.trim();
-            if (trimmed === "" || trimmed === "null") {
-                return [];
-            }
-            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-                try {
-                    list = JSON.parse(trimmed);
-                }
-                catch {
-                    throw new Error(`角色菜单权限数据不合法：addon_admin_role.menus JSON 解析失败，roleCode=${roleCode}`);
-                }
-            }
-        }
-        if (!Array.isArray(list)) {
-            const typeLabel = typeof list;
-            throw new Error(`角色菜单权限数据不合法：addon_admin_role.menus 必须是字符串数组或 JSON 数组字符串，roleCode=${roleCode}，type=${typeLabel}`);
-        }
-        const out = [];
-        for (const item of list) {
-            out.push(this.assertMenuPathname(item, `角色菜单权限数据不合法：addon_admin_role.menus 元素，roleCode=${roleCode}`));
-        }
-        return out;
-    }
-    /**
-     * 缓存所有接口到 Redis
-     */
-    async cacheApis() {
-        try {
-            // 检查表是否存在
-            const tableExists = await this.db.tableExists("addon_admin_api");
-            if (!tableExists.data) {
-                Logger.warn("⚠️ 接口表不存在，跳过接口缓存");
-                return;
-            }
-            // 从数据库查询所有接口
-            const apiList = await this.db.getAll({
-                table: "addon_admin_api"
-            });
-            // 缓存到 Redis
-            const result = await this.redis.setObject(CacheKeys.apisAll(), apiList.data.lists);
-            if (result === null) {
-                Logger.warn("⚠️ 接口缓存失败");
-            }
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "⚠️ 接口缓存异常" });
-        }
-    }
-    /**
-     * 缓存所有菜单到 Redis（从数据库读取）
-     */
-    async cacheMenus() {
-        try {
-            // 检查表是否存在
-            const tableExists = await this.db.tableExists("addon_admin_menu");
-            if (!tableExists.data) {
-                Logger.warn("⚠️ 菜单表不存在，跳过菜单缓存");
-                return;
-            }
-            // 从数据库查询所有菜单
-            const menus = await this.db.getAll({
-                table: "addon_admin_menu"
-            });
-            // 缓存到 Redis
-            const result = await this.redis.setObject(CacheKeys.menusAll(), menus.data.lists);
-            if (result === null) {
-                Logger.warn("⚠️ 菜单缓存失败");
-            }
-        }
-        catch (error) {
-            Logger.warn({ err: error, msg: "⚠️ 菜单缓存异常" });
-        }
-    }
-    /**
-     * 缓存所有角色的接口权限到 Redis
-     * 全量重建：清理所有角色权限缓存并重建
-     * - 极简方案：每个角色一个 Set，直接覆盖更新（DEL + SADD）
-     */
-    async rebuildRoleApiPermissions() {
-        try {
-            // 检查表是否存在
-            const roleTableExists = await this.db.tableExists("addon_admin_role");
-            if (!roleTableExists.data) {
-                Logger.warn("⚠️ 角色表不存在，跳过角色权限缓存");
-                return;
-            }
-            // 查询所有角色（仅取必要字段）
-            const roles = await this.db.getAll({
-                table: "addon_admin_role",
-                fields: ["code", "apis"]
-            });
-            const roleApiPathsMap = new Map();
-            for (const role of roles.data.lists) {
-                if (!role?.code)
-                    continue;
-                const apiPaths = this.assertApiPathList(role.apis, role.code);
-                roleApiPathsMap.set(role.code, apiPaths);
-            }
-            const roleCodes = Array.from(roleApiPathsMap.keys());
-            if (roleCodes.length === 0) {
-                Logger.info("✅ 没有需要缓存的角色权限");
-                return;
-            }
-            // 清理所有角色的缓存 key（保证幂等）
-            const roleKeys = roleCodes.map((code) => CacheKeys.roleApis(code));
-            await this.redis.delBatch(roleKeys);
-            // 批量写入新缓存（只写入非空权限）
-            const items = [];
-            for (const roleCode of roleCodes) {
-                const apiPaths = roleApiPathsMap.get(roleCode) || [];
-                const members = Array.from(new Set(apiPaths)).sort();
-                if (members.length > 0) {
-                    items.push({ key: CacheKeys.roleApis(roleCode), members: members });
-                }
-            }
-            if (items.length > 0) {
-                await this.redis.saddBatch(items);
-            }
-            // 极简方案不做版本/ready/meta：重建完成即生效
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "⚠️ 角色权限缓存异常（将阻断启动）" });
-            throw new CoreError({
-                kind: "runtime",
-                message: "⚠️ 角色权限缓存异常（将阻断启动）",
-                logged: true,
-                cause: error,
-                meta: {
-                    subsystem: "cache",
-                    operation: "rebuildRoleApiPermissions"
-                }
-            });
-        }
-    }
-    /**
-     * 缓存所有角色的菜单权限到 Redis
-     * 全量重建：清理所有角色菜单权限缓存并重建
-     * - 每个角色一个 Set，直接覆盖更新（DEL + SADD）
-     */
-    async rebuildRoleMenuPermissions() {
-        try {
-            // 检查表是否存在
-            const roleTableExists = await this.db.tableExists("addon_admin_role");
-            if (!roleTableExists.data) {
-                Logger.warn("⚠️ 角色表不存在，跳过角色菜单权限缓存");
-                return;
-            }
-            // 查询所有角色（仅取必要字段）
-            const roles = await this.db.getAll({
-                table: "addon_admin_role",
-                fields: ["code", "menus"]
-            });
-            const roleMenuPathsMap = new Map();
-            for (const role of roles.data.lists) {
-                if (!role?.code)
-                    continue;
-                const menuPaths = this.assertMenuPathList(role.menus, role.code);
-                roleMenuPathsMap.set(role.code, menuPaths);
-            }
-            const roleCodes = Array.from(roleMenuPathsMap.keys());
-            if (roleCodes.length === 0) {
-                Logger.info("✅ 没有需要缓存的角色菜单权限");
-                return;
-            }
-            // 清理所有角色的缓存 key（保证幂等）
-            const roleKeys = roleCodes.map((code) => CacheKeys.roleMenus(code));
-            await this.redis.delBatch(roleKeys);
-            // 批量写入新缓存（只写入非空权限）
-            const items = [];
-            for (const roleCode of roleCodes) {
-                const menuPaths = roleMenuPathsMap.get(roleCode) || [];
-                const members = Array.from(new Set(menuPaths)).sort();
-                if (members.length > 0) {
-                    items.push({ key: CacheKeys.roleMenus(roleCode), members: members });
-                }
-            }
-            if (items.length > 0) {
-                await this.redis.saddBatch(items);
-            }
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "⚠️ 角色菜单权限缓存异常（将阻断启动）" });
-            throw new CoreError({
-                kind: "runtime",
-                message: "⚠️ 角色菜单权限缓存异常（将阻断启动）",
-                logged: true,
-                cause: error,
-                meta: {
-                    subsystem: "cache",
-                    operation: "rebuildRoleMenuPermissions"
-                }
-            });
-        }
-    }
-    /**
-     * 增量刷新单个角色的接口权限缓存
-     * - apiIds 为空数组：仅清理缓存（防止残留）
-     * - apiIds 非空：使用 $in 最小查询，DEL 后 SADD
-     */
-    async refreshRoleApiPermissions(roleCode, apiPaths) {
-        if (!roleCode || typeof roleCode !== "string") {
-            throw new Error("roleCode 必须是非空字符串");
-        }
-        if (!Array.isArray(apiPaths)) {
-            throw new Error("apiPaths 必须是数组");
-        }
-        const normalizedPaths = apiPaths.map((p) => this.assertApiPathname(p, `refreshRoleApiPermissions: apiPaths 元素，roleCode=${roleCode}`));
-        const roleKey = CacheKeys.roleApis(roleCode);
-        // 空数组短路：保证清理残留
-        if (normalizedPaths.length === 0) {
-            await this.redis.del(roleKey);
-            return;
-        }
-        const members = Array.from(new Set(normalizedPaths));
-        await this.redis.del(roleKey);
-        if (members.length > 0) {
-            await this.redis.sadd(roleKey, members);
-        }
-    }
-    /**
-     * 增量刷新单个角色的菜单权限缓存
-     * - menuPaths 为空数组：仅清理缓存（防止残留）
-     * - menuPaths 非空：DEL 后 SADD
-     */
-    async refreshRoleMenuPermissions(roleCode, menuPaths) {
-        if (!roleCode || typeof roleCode !== "string") {
-            throw new Error("roleCode 必须是非空字符串");
-        }
-        if (!Array.isArray(menuPaths)) {
-            throw new Error("menuPaths 必须是数组");
-        }
-        const normalizedPaths = menuPaths.map((p) => this.assertMenuPathname(p, `refreshRoleMenuPermissions: menuPaths 元素，roleCode=${roleCode}`));
-        const roleKey = CacheKeys.roleMenus(roleCode);
-        // 空数组短路：保证清理残留
-        if (normalizedPaths.length === 0) {
-            await this.redis.del(roleKey);
-            return;
-        }
-        const members = Array.from(new Set(normalizedPaths));
-        await this.redis.del(roleKey);
-        if (members.length > 0) {
-            await this.redis.sadd(roleKey, members);
-        }
-    }
-    /**
-     * 缓存所有数据
-     */
-    async cacheAll() {
-        // 1. 缓存接口
-        await this.cacheApis();
-        // 2. 缓存菜单
-        await this.cacheMenus();
-        // 3. 缓存角色权限
-        await this.rebuildRoleApiPermissions();
-        // 4. 缓存角色菜单权限
-        await this.rebuildRoleMenuPermissions();
-    }
-    /**
-     * 获取缓存的所有接口
-     * @returns 接口列表
-     */
-    async getApis() {
-        try {
-            const apis = await this.redis.getObject(CacheKeys.apisAll());
-            return apis || [];
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "获取接口缓存失败" });
-            return [];
-        }
-    }
-    /**
-     * 获取缓存的所有菜单
-     * @returns 菜单列表
-     */
-    async getMenus() {
-        try {
-            const menus = await this.redis.getObject(CacheKeys.menusAll());
-            return menus || [];
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "获取菜单缓存失败" });
-            return [];
-        }
-    }
-    /**
-     * 获取角色的接口权限
-     * @param roleCode - 角色代码
-     * @returns 接口路径列表
-     */
-    async getRolePermissions(roleCode) {
-        try {
-            const permissions = await this.redis.smembers(CacheKeys.roleApis(roleCode));
-            return permissions || [];
-        }
-        catch (error) {
-            Logger.error({ err: error, roleCode: roleCode, msg: "获取角色权限缓存失败" });
-            return [];
-        }
-    }
-    /**
-     * 获取角色的菜单权限
-     * @param roleCode - 角色代码
-     * @returns 菜单路径列表（menu.path）
-     */
-    async getRoleMenuPermissions(roleCode) {
-        try {
-            const permissions = await this.redis.smembers(CacheKeys.roleMenus(roleCode));
-            return permissions || [];
-        }
-        catch (error) {
-            Logger.error({ err: error, roleCode: roleCode, msg: "获取角色菜单权限缓存失败" });
-            return [];
-        }
-    }
-    /**
-     * 检查角色是否有指定接口权限
-     * @param roleCode - 角色代码
-     * @param apiPath - 接口路径（url.pathname，例如 /api/user/login；与 method 无关）
-     * @returns 是否有权限
-     */
-    async checkRolePermission(roleCode, apiPath) {
-        try {
-            const pathname = this.assertApiPathname(apiPath, "checkRolePermission: apiPath");
-            return await this.redis.sismember(CacheKeys.roleApis(roleCode), pathname);
-        }
-        catch (error) {
-            Logger.error({ err: error, roleCode: roleCode, msg: "检查角色权限失败" });
-            return false;
-        }
-    }
-    /**
-     * 检查角色是否有指定菜单权限
-     * @param roleCode - 角色代码
-     * @param menuPath - 菜单路径（menu.path）
-     * @returns 是否有权限
-     */
-    async checkRoleMenuPermission(roleCode, menuPath) {
-        try {
-            const pathname = this.assertMenuPathname(menuPath, "checkRoleMenuPermission: menuPath");
-            return await this.redis.sismember(CacheKeys.roleMenus(roleCode), pathname);
-        }
-        catch (error) {
-            Logger.error({ err: error, roleCode: roleCode, msg: "检查角色菜单权限失败" });
-            return false;
-        }
-    }
-    /**
-     * 删除角色的接口权限缓存
-     * @param roleCode - 角色代码
-     * @returns 是否删除成功
-     */
-    async deleteRolePermissions(roleCode) {
-        try {
-            const result = await this.redis.del(CacheKeys.roleApis(roleCode));
-            if (result > 0) {
-                Logger.info(`✅ 已删除角色 ${roleCode} 的权限缓存`);
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            Logger.error({ err: error, roleCode: roleCode, msg: "删除角色权限缓存失败" });
-            return false;
-        }
-    }
-    /**
-     * 删除角色的菜单权限缓存
-     * @param roleCode - 角色代码
-     * @returns 是否删除成功
-     */
-    async deleteRoleMenuPermissions(roleCode) {
-        try {
-            const result = await this.redis.del(CacheKeys.roleMenus(roleCode));
-            if (result > 0) {
-                Logger.info(`✅ 已删除角色 ${roleCode} 的菜单权限缓存`);
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            Logger.error({ err: error, roleCode: roleCode, msg: "删除角色菜单权限缓存失败" });
-            return false;
-        }
-    }
-}

package/dist/lib/cacheKeys.d.ts

@@ -1,27 +0,0 @@
-/**
- * Cache Key 统一管理
- * 所有缓存键在此统一定义，避免硬编码分散
- */
-/**
- * Cache Key 生成函数集合
- */
-export declare class CacheKeys {
-    /** 所有接口缓存2 */
-    static apisAll(): string;
-    /** 所有菜单缓存 */
-    static menusAll(): string;
-    /** 角色信息缓存（完整角色对象） */
-    static roleInfo(roleCode: string): string;
-    /**
-     * 角色菜单权限缓存（Set 集合）
-     * - key: role:menus:${roleCode}
-     * - member: menu.path（例如 /permission/role）
-     */
-    static roleMenus(roleCode: string): string;
-    /**
-     * 角色接口权限缓存（Set 集合）
-     * - key: role:apis:${roleCode}
-     * - member: url.pathname（例如 /api/user/login；与 method 无关）
-     */
-    static roleApis(roleCode: string): string;
-}

package/dist/lib/cacheKeys.js

@@ -1,37 +0,0 @@
-/**
- * Cache Key 统一管理
- * 所有缓存键在此统一定义，避免硬编码分散
- */
-/**
- * Cache Key 生成函数集合
- */
-export class CacheKeys {
-    /** 所有接口缓存2 */
-    static apisAll() {
-        return "apis:all";
-    }
-    /** 所有菜单缓存 */
-    static menusAll() {
-        return "menus:all";
-    }
-    /** 角色信息缓存（完整角色对象） */
-    static roleInfo(roleCode) {
-        return `role:info:${roleCode}`;
-    }
-    /**
-     * 角色菜单权限缓存（Set 集合）
-     * - key: role:menus:${roleCode}
-     * - member: menu.path（例如 /permission/role）
-     */
-    static roleMenus(roleCode) {
-        return `role:menus:${roleCode}`;
-    }
-    /**
-     * 角色接口权限缓存（Set 集合）
-     * - key: role:apis:${roleCode}
-     * - member: url.pathname（例如 /api/user/login；与 method 无关）
-     */
-    static roleApis(roleCode) {
-        return `role:apis:${roleCode}`;
-    }
-}

package/dist/lib/cipher.d.ts

@@ -1,153 +0,0 @@
-/**
- * 加密工具类 - TypeScript 版本
- * 提供各种哈希、HMAC、密码加密等功能
- */
-import type { EncodingType, HashAlgorithm, PasswordHashOptions } from "../types/crypto";
-/**
- * 加密工具类
- */
-export declare class Cipher {
-    /**
-     * MD5 哈希
-     * @param data - 要哈希的数据
-     * @param encoding - 输出编码
-     * @returns MD5 哈希值
-     */
-    static md5(data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * HMAC-MD5 签名
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC-MD5 签名
-     */
-    static hmacMd5(key: string | Uint8Array, data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * SHA-1 哈希
-     * @param data - 要哈希的数据
-     * @param encoding - 输出编码
-     * @returns SHA-1 哈希值
-     */
-    static sha1(data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * HMAC-SHA1 签名
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC-SHA1 签名
-     */
-    static hmacSha1(key: string | Uint8Array, data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * SHA-256 哈希
-     * @param data - 要哈希的数据
-     * @param encoding - 输出编码
-     * @returns SHA-256 哈希值
-     */
-    static sha256(data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * RSA-SHA256 签名
-     * @param data - 要签名的数据
-     * @param privateKey - 私钥
-     * @param encoding - 输出编码（'hex' | 'base64' | 'base64url'）
-     * @returns RSA-SHA256 签名
-     */
-    static rsaSha256(data: string, privateKey: string | Buffer, encoding?: "hex" | "base64" | "base64url"): string;
-    /**
-     * HMAC-SHA256 签名
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC-SHA256 签名
-     */
-    static hmacSha256(key: string | Uint8Array, data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * SHA-512 哈希
-     * @param data - 要哈希的数据
-     * @param encoding - 输出编码
-     * @returns SHA-512 哈希值
-     */
-    static sha512(data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * HMAC-SHA512 签名
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC-SHA512 签名
-     */
-    static hmacSha512(key: string | Uint8Array, data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * 通用哈希方法
-     * @param algorithm - 算法名称
-     * @param data - 要哈希的数据
-     * @param encoding - 输出编码
-     * @returns 哈希值
-     */
-    static hash(algorithm: HashAlgorithm, data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * 通用 HMAC 方法
-     * @param algorithm - 算法名称
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC 签名
-     */
-    static hmac(algorithm: HashAlgorithm, key: string | Uint8Array, data: string | Uint8Array, encoding?: EncodingType): string;
-    /**
-     * 文件哈希
-     * @param filePath - 文件路径
-     * @param algorithm - 算法名称
-     * @param encoding - 输出编码
-     * @returns 文件哈希值
-     */
-    static hashFile(filePath: string, algorithm?: HashAlgorithm, encoding?: EncodingType): Promise<string>;
-    /**
-     * 密码哈希（使用 bcrypt 算法）
-     * @param password - 密码
-     * @param options - 选项（可选，支持自定义 cost 参数）
-     * @returns 哈希后的密码（固定 60 字符）
-     * @example
-     * // 默认配置（推荐）
-     * const hash = await Cipher.hashPassword('123456');
-     *
-     * // 自定义强度（可选）
-     * const hash = await Cipher.hashPassword('123456', { cost: 12 });
-     */
-    static hashPassword(password: string, options?: PasswordHashOptions): Promise<string>;
-    /**
-     * 验证密码
-     * @param password - 原始密码
-     * @param hash - 存储的哈希值（自动识别算法和提取盐值）
-     * @returns 验证结果
-     * @example
-     * const isValid = await Cipher.verifyPassword('123456', storedHash);
-     * if (isValid) {
-     *   // 密码正确
-     * }
-     */
-    static verifyPassword(password: string, hash: string): Promise<boolean>;
-    /**
-     * Base64 编码
-     * @param data - 要编码的数据
-     * @returns Base64 编码的字符串
-     */
-    static base64Encode(data: string): string;
-    /**
-     * Base64 解码
-     * @param data - Base64 编码的字符串
-     * @returns 解码后的字符串
-     */
-    static base64Decode(data: string): string;
-    /**
-     * 生成随机十六进制字符串
-     * @param length - 字符串长度
-     * @returns 随机十六进制字符串
-     */
-    static randomString(length: number): string;
-    /**
-     * 快速哈希 (非密码学)
-     * @param data - 数据
-     * @param seed - 种子值
-     * @returns 64位哈希值
-     */
-    static fastHash(data: string | Uint8Array, seed?: number): number;
-}