wok-server 0.4.13 → 0.6.0

package/dist/mvc/static/static-handler.js

@@ -1,372 +1,372 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaticHandler = void 0;
-const fs_1 = require("fs");
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const zlib_1 = require("zlib");
-const render_1 = require("../render");
-const header_1 = require("./header");
-const mime_type_1 = require("./mime-type");
-const server_cache_1 = require("./server-cache");
-const server_cache_config_1 = require("./server-cache-config");
-class StaticHandler {
-    DEFAULT_CONTENT_TYPE = 'application/octet-stream';
-    maxFileSize;
-    cache;
-    rules;
-    /**
-     * 静态处理器。规则说明：
-     * 请求路径仅支持前缀匹配，不支持通配符，比如 /a/demo.html 可以匹配 /a 路径，响应配置的文件目录下的 demo.html 文件。
-     * 路径配置是有优先级的，如果访问 /a/b/music.mp3 则会匹配到 /a/b 的配置，而不是 /a ，因为 /a/b 的配置更详细，优先级也更高，
-     * 并且如果从 /a/b 配置的目录下没有找到文件，也不会再尝试 /a 的配置。
-     *
-     * 静态文件同时也支持主页自动映射，比如访问 /a/b/c ，会匹配到 /a/b 的配置，然后在配置的文件目录下寻找文件 c ，
-     * 如果找不到则尝试寻找目录 c 下的 index.html 文件。
-     * @param rules 规则设置
-     */
-    constructor(rules) {
-        const config = (0, server_cache_config_1.getConfig)();
-        this.maxFileSize = (0, server_cache_config_1.parseSize)(config.maxFileSize);
-        if (config.enable) {
-            this.cache = new server_cache_1.ServerCache({ maxSize: (0, server_cache_config_1.parseSize)(config.maxSize), maxAge: config.maxAge });
-        }
-        this.rules = [];
-        // 规则解析，路径判定，设置的目录必须存在或可以被创建
-        // 重复记录表 ，作用是为了路径去重判定，可以提示哪些路径是重复的
-        const duplicateMap = new Map();
-        for (const entry of Object.entries(rules)) {
-            const [path, setting] = entry;
-            const dir = (0, path_1.isAbsolute)(setting.dir) ? setting.dir : (0, path_1.resolve)(process.cwd(), setting.dir);
-            if (!(0, fs_1.existsSync)(dir)) {
-                throw new Error(`Static file configuration error，path ${dir} does not exist，config dir：${setting.dir}`);
-            }
-            const statRes = (0, fs_1.statSync)(dir);
-            if (!statRes.isDirectory()) {
-                throw new Error(`Static file configuration error，path ${dir} is not a directory，config dir：${setting.dir}`);
-            }
-            let finalPath = path.startsWith('/') ? path : '/' + path;
-            // 保持以 / 结尾，为了匹配方便
-            if (!finalPath.endsWith('/')) {
-                finalPath += '/';
-            }
-            if (duplicateMap.has(finalPath)) {
-                throw new Error(`Static path duplicated: ${duplicateMap.get(finalPath)} and ${path}`);
-            }
-            duplicateMap.set(finalPath, path);
-            this.rules.push({ path: finalPath, dir, cacheAge: setting.cacheAge || 0 });
-        }
-        // 优先级排序
-        this.rules.sort((o1, o2) => {
-            let priority1 = o1.path === '/' ? -1 : o1.path.split('/').length;
-            let priority2 = o2.path === '/' ? -1 : o2.path.split('/').length;
-            // 如果 o1 优先级高，就应该排前面，返回小于0的值，反之亦然\
-            // 前面的优先级值是值越大优先级越高，反过来减
-            return priority2 - priority1;
-        });
-    }
-    /**
-     * 处理静态文件 get 请求
-     * @param request
-     * @param response
-     * @param path
-     * @returns 是否能够处理，如果因为找不到文件或其它原因无法处理则返回 false ，由后续流程继续处理
-     */
-    async handleGet(request, response, path) {
-        // 解析消息头
-        const headersInfo = (0, header_1.parseHeaders)(request.headers);
-        // 构建文件信息
-        let file = await this.buildRespFile(path, headersInfo);
-        if (!file) {
-            return false;
-        }
-        // content-type
-        response.setHeader('Content-Type', file.mimeType);
-        // client cache
-        if (file.maxAge === 0) {
-            response.setHeader('Cache-Control', 'no-store');
-        }
-        else if (file.maxAge) {
-            response.setHeader('Cache-Control', `max-age=${file.maxAge}`);
-        }
-        response.setHeader('Last-Modified', file.mtime.toUTCString());
-        // 开始响应，先判定 if-modified-since
-        if (headersInfo.ifModifiedSince) {
-            if (headersInfo.ifModifiedSince >= file.mtime) {
-                response.statusCode = 304;
-                response.end();
-                return true;
-            }
-        }
-        if (headersInfo.range) {
-            const { start } = headersInfo.range;
-            if (isNaN(start) || start < 0) {
-                (0, render_1.renderError)(response, `Range not satisfiable，start is ${start}.`, 416);
-                return true;
-            }
-            const maxEnd = file.size - 1;
-            let end = headersInfo.range.end ? headersInfo.range.end : maxEnd;
-            // 校验 end
-            if (end <= start) {
-                (0, render_1.renderError)(response, `Range not satisfiable，end must be greater than start.`, 416);
-                return true;
-            }
-            if (end > maxEnd) {
-                (0, render_1.renderError)(response, `Range not satisfiable，end must not be greater than ${maxEnd}.`, 416);
-                return true;
-            }
-            // range 是前后都包含的，详细可以参考规范：
-            // https://www.rfc-editor.org/rfc/rfc9110#field.range
-            // 但是 buffer.subarray 中包含前不包含后，createReadStream 是前后都包含的，需要注意
-            // 还需要注意 gzip 编码
-            response.setHeader('Content-Range', `bytes ${start}-${end}/${file.size}`);
-            response.statusCode = 206;
-            if (file.bufferOrPath instanceof Buffer) {
-                let buffer = file.bufferOrPath.subarray(start, end + 1);
-                if (headersInfo.gzip) {
-                    buffer = await new Promise((resolve, reject) => {
-                        (0, zlib_1.gzip)(buffer, (err, res) => {
-                            if (err) {
-                                reject(err);
-                                return;
-                            }
-                            resolve(res);
-                        });
-                    });
-                    response.setHeader('Content-Encoding', 'gzip');
-                }
-                await this.endRespWithBuffer(response, buffer);
-            }
-            else {
-                const filePath = file.bufferOrPath;
-                // 文件处理
-                await new Promise((resolve, reject) => {
-                    response.setHeader('Content-Encoding', 'gzip');
-                    response.once('finish', resolve).once('error', reject);
-                    if (headersInfo.gzip) {
-                        (0, fs_1.createReadStream)(filePath, { start, end }).pipe((0, zlib_1.createGzip)()).pipe(response);
-                    }
-                    else {
-                        (0, fs_1.createReadStream)(filePath, { start, end }).pipe(response);
-                    }
-                });
-            }
-            return true;
-        }
-        // gzip
-        if (headersInfo.gzip) {
-            response.setHeader('Content-Encoding', 'gzip');
-            if (file.bufferOrPath instanceof Buffer) {
-                // buffer 是缓存的文件，gzip 编码缓存的文件即是已经压缩后的文件
-                await this.endRespWithBuffer(response, file.bufferOrPath);
-            }
-            else {
-                const path = file.bufferOrPath;
-                await new Promise((resolve, reject) => {
-                    response.once('finish', resolve).once('error', reject);
-                    (0, fs_1.createReadStream)(path).pipe((0, zlib_1.createGzip)()).pipe(response);
-                });
-            }
-            return true;
-        }
-        // 普通的整个文件请求处理
-        if (file.bufferOrPath instanceof Buffer) {
-            await this.endRespWithBuffer(response, file.bufferOrPath);
-        }
-        else {
-            const filePath = file.bufferOrPath;
-            await new Promise((resolve, reject) => {
-                response.once('finish', resolve).once('error', reject);
-                (0, fs_1.createReadStream)(filePath).pipe(response);
-            });
-        }
-        return true;
-    }
-    /**
-     *  处理 head 请求，不响应正文内容，如果文件可以被找到，仅仅响应以下的消息头：
-     * Content-Length
-     * Content-Type
-     * Last-Modified
-     * Cache-Control
-     *
-     * @param path 请求路径
-     * @param response
-     * @returns 是否成功处理
-     */
-    async handleHead(path, response) {
-        // 构建文件信息
-        let file = await this.buildRespFile(path, { gzip: false });
-        if (!file) {
-            return false;
-        }
-        response.setHeader('Content-Length', file.size);
-        response.setHeader('Content-Type', file.mimeType);
-        response.setHeader('Last-Modified', file.mtime.toUTCString());
-        if (file.maxAge === 0) {
-            response.setHeader('Cache-Control', 'no-store');
-        }
-        else if (file.maxAge) {
-            response.setHeader('Cache-Control', `max-age=${file.maxAge}`);
-        }
-        response.end();
-        return true;
-    }
-    async endRespWithBuffer(response, buffer) {
-        if (response.writableEnded || response.destroyed) {
-            return;
-        }
-        await new Promise((resolve, reject) => {
-            response.write(buffer, err => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-        await new Promise((resolve, reject) => {
-            response.end(resolve);
-        });
-    }
-    /**
-     * 构建响应文件
-     *
-     * @param path
-     * @param headers
-     * @returns
-     */
-    async buildRespFile(path, headers) {
-        if (!this.cache) {
-            const file = await this.findFile(path);
-            if (!file) {
-                return null;
-            }
-            let { mtime } = file.stats;
-            mtime.setMilliseconds(0);
-            return {
-                maxAge: file.maxAge,
-                mtime: mtime,
-                size: file.stats.size,
-                bufferOrPath: file.filePath,
-                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
-            };
-        }
-        const cacheingGzip = headers.gzip && !headers.range;
-        const key = cacheingGzip ? `gzip-${path}` : path;
-        let file;
-        const cachedVal = await this.cache.computeIfAbsent(key, async () => {
-            file = (await this.findFile(path)) || undefined;
-            if (!file) {
-                return null;
-            }
-            // 文件太大不能被缓存
-            if (file.stats.size > this.maxFileSize) {
-                return null;
-            }
-            let buffer = await (0, promises_1.readFile)(file.filePath);
-            // gzip 存储压缩后的文件
-            if (cacheingGzip) {
-                buffer = await new Promise((resolve, reject) => {
-                    (0, zlib_1.gzip)(buffer, (err, res) => {
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            resolve(res);
-                        }
-                    });
-                });
-            }
-            let { mtime } = file.stats;
-            mtime.setMilliseconds(0);
-            return {
-                buffer,
-                mtime: mtime,
-                cacheAge: file.maxAge,
-                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
-            };
-        });
-        if (cachedVal) {
-            return {
-                maxAge: cachedVal.cacheAge,
-                mtime: cachedVal.mtime,
-                size: cachedVal.buffer.length,
-                bufferOrPath: cachedVal.buffer,
-                mimeType: cachedVal.mimeType
-            };
-        }
-        // 判定文件大小
-        if (file) {
-            let { mtime } = file.stats;
-            mtime.setMilliseconds(0);
-            return {
-                maxAge: file.maxAge,
-                mtime: mtime,
-                size: file.stats.size,
-                bufferOrPath: file.filePath,
-                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
-            };
-        }
-        return null;
-    }
-    /**
-     * 根据路径查找文件
-     * @param path 访问路径
-     * @returns 返回被查询到的文件信息，如果找不到则返回 null
-     */
-    async findFile(path) {
-        let matchedRule;
-        for (const rule of this.rules) {
-            if (rule.path === '/') {
-                matchedRule = rule;
-                break;
-            }
-            if (path.startsWith(rule.path)) {
-                matchedRule = rule;
-                break;
-            }
-        }
-        // 匹配失败
-        if (!matchedRule) {
-            return null;
-        }
-        // 构建地址
-        let finalPath = matchedRule.path === '/' ? path : path.substring(matchedRule.path.length);
-        if (finalPath.startsWith('/')) {
-            finalPath = finalPath.substring(1);
-        }
-        let filePath = (0, path_1.resolve)(matchedRule.dir, finalPath);
-        if (!(0, fs_1.existsSync)(filePath)) {
-            return null;
-        }
-        const fileStat = await (0, promises_1.stat)(filePath);
-        // 如果是目录，尝试查找 index.html
-        if (fileStat.isDirectory()) {
-            const indexPath = (0, path_1.resolve)(filePath, 'index.html');
-            if (!(0, fs_1.existsSync)(indexPath)) {
-                return null;
-            }
-            const indexStat = await (0, promises_1.stat)(indexPath);
-            if (!indexStat.isFile()) {
-                return null;
-            }
-            return { filePath: indexPath, stats: indexStat };
-        }
-        if (!fileStat.isFile()) {
-            return null;
-        }
-        return { filePath, stats: fileStat, maxAge: matchedRule.cacheAge };
-    }
-    /**
-     * 删除服务器端静态资源缓存
-     * @param path
-     */
-    removeServerCache(path) {
-        if (this.cache) {
-            this.cache.remove(path);
-            this.cache.remove(`gzip-${path}`);
-        }
-    }
-}
-exports.StaticHandler = StaticHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticHandler = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const zlib_1 = require("zlib");
+const render_1 = require("../render");
+const header_1 = require("./header");
+const mime_type_1 = require("./mime-type");
+const server_cache_1 = require("./server-cache");
+const server_cache_config_1 = require("./server-cache-config");
+class StaticHandler {
+    DEFAULT_CONTENT_TYPE = 'application/octet-stream';
+    maxFileSize;
+    cache;
+    rules;
+    /**
+     * 静态处理器。规则说明：
+     * 请求路径仅支持前缀匹配，不支持通配符，比如 /a/demo.html 可以匹配 /a 路径，响应配置的文件目录下的 demo.html 文件。
+     * 路径配置是有优先级的，如果访问 /a/b/music.mp3 则会匹配到 /a/b 的配置，而不是 /a ，因为 /a/b 的配置更详细，优先级也更高，
+     * 并且如果从 /a/b 配置的目录下没有找到文件，也不会再尝试 /a 的配置。
+     *
+     * 静态文件同时也支持主页自动映射，比如访问 /a/b/c ，会匹配到 /a/b 的配置，然后在配置的文件目录下寻找文件 c ，
+     * 如果找不到则尝试寻找目录 c 下的 index.html 文件。
+     * @param rules 规则设置
+     */
+    constructor(rules) {
+        const config = (0, server_cache_config_1.getConfig)();
+        this.maxFileSize = (0, server_cache_config_1.parseSize)(config.maxFileSize);
+        if (config.enable) {
+            this.cache = new server_cache_1.ServerCache({ maxSize: (0, server_cache_config_1.parseSize)(config.maxSize), maxAge: config.maxAge });
+        }
+        this.rules = [];
+        // 规则解析，路径判定，设置的目录必须存在或可以被创建
+        // 重复记录表 ，作用是为了路径去重判定，可以提示哪些路径是重复的
+        const duplicateMap = new Map();
+        for (const entry of Object.entries(rules)) {
+            const [path, setting] = entry;
+            const dir = (0, path_1.isAbsolute)(setting.dir) ? setting.dir : (0, path_1.resolve)(process.cwd(), setting.dir);
+            if (!(0, fs_1.existsSync)(dir)) {
+                throw new Error(`Static file configuration error，path ${dir} does not exist，config dir：${setting.dir}`);
+            }
+            const statRes = (0, fs_1.statSync)(dir);
+            if (!statRes.isDirectory()) {
+                throw new Error(`Static file configuration error，path ${dir} is not a directory，config dir：${setting.dir}`);
+            }
+            let finalPath = path.startsWith('/') ? path : '/' + path;
+            // 保持以 / 结尾，为了匹配方便
+            if (!finalPath.endsWith('/')) {
+                finalPath += '/';
+            }
+            if (duplicateMap.has(finalPath)) {
+                throw new Error(`Static path duplicated: ${duplicateMap.get(finalPath)} and ${path}`);
+            }
+            duplicateMap.set(finalPath, path);
+            this.rules.push({ path: finalPath, dir, cacheAge: setting.cacheAge || 0 });
+        }
+        // 优先级排序
+        this.rules.sort((o1, o2) => {
+            let priority1 = o1.path === '/' ? -1 : o1.path.split('/').length;
+            let priority2 = o2.path === '/' ? -1 : o2.path.split('/').length;
+            // 如果 o1 优先级高，就应该排前面，返回小于0的值，反之亦然\
+            // 前面的优先级值是值越大优先级越高，反过来减
+            return priority2 - priority1;
+        });
+    }
+    /**
+     * 处理静态文件 get 请求
+     * @param request
+     * @param response
+     * @param path
+     * @returns 是否能够处理，如果因为找不到文件或其它原因无法处理则返回 false ，由后续流程继续处理
+     */
+    async handleGet(request, response, path) {
+        // 解析消息头
+        const headersInfo = (0, header_1.parseHeaders)(request.headers);
+        // 构建文件信息
+        let file = await this.buildRespFile(path, headersInfo);
+        if (!file) {
+            return false;
+        }
+        // content-type
+        response.setHeader('Content-Type', file.mimeType);
+        // client cache
+        if (file.maxAge === 0) {
+            response.setHeader('Cache-Control', 'no-store');
+        }
+        else if (file.maxAge) {
+            response.setHeader('Cache-Control', `max-age=${file.maxAge}`);
+        }
+        response.setHeader('Last-Modified', file.mtime.toUTCString());
+        // 开始响应，先判定 if-modified-since
+        if (headersInfo.ifModifiedSince) {
+            if (headersInfo.ifModifiedSince >= file.mtime) {
+                response.statusCode = 304;
+                response.end();
+                return true;
+            }
+        }
+        if (headersInfo.range) {
+            const { start } = headersInfo.range;
+            if (isNaN(start) || start < 0) {
+                (0, render_1.renderError)(response, `Range not satisfiable，start is ${start}.`, 416);
+                return true;
+            }
+            const maxEnd = file.size - 1;
+            let end = headersInfo.range.end ? headersInfo.range.end : maxEnd;
+            // 校验 end
+            if (end <= start) {
+                (0, render_1.renderError)(response, `Range not satisfiable，end must be greater than start.`, 416);
+                return true;
+            }
+            if (end > maxEnd) {
+                (0, render_1.renderError)(response, `Range not satisfiable，end must not be greater than ${maxEnd}.`, 416);
+                return true;
+            }
+            // range 是前后都包含的，详细可以参考规范：
+            // https://www.rfc-editor.org/rfc/rfc9110#field.range
+            // 但是 buffer.subarray 中包含前不包含后，createReadStream 是前后都包含的，需要注意
+            // 还需要注意 gzip 编码
+            response.setHeader('Content-Range', `bytes ${start}-${end}/${file.size}`);
+            response.statusCode = 206;
+            if (file.bufferOrPath instanceof Buffer) {
+                let buffer = file.bufferOrPath.subarray(start, end + 1);
+                if (headersInfo.gzip) {
+                    buffer = await new Promise((resolve, reject) => {
+                        (0, zlib_1.gzip)(buffer, (err, res) => {
+                            if (err) {
+                                reject(err);
+                                return;
+                            }
+                            resolve(res);
+                        });
+                    });
+                    response.setHeader('Content-Encoding', 'gzip');
+                }
+                await this.endRespWithBuffer(response, buffer);
+            }
+            else {
+                const filePath = file.bufferOrPath;
+                // 文件处理
+                await new Promise((resolve, reject) => {
+                    response.setHeader('Content-Encoding', 'gzip');
+                    response.once('finish', resolve).once('error', reject);
+                    if (headersInfo.gzip) {
+                        (0, fs_1.createReadStream)(filePath, { start, end }).pipe((0, zlib_1.createGzip)()).pipe(response);
+                    }
+                    else {
+                        (0, fs_1.createReadStream)(filePath, { start, end }).pipe(response);
+                    }
+                });
+            }
+            return true;
+        }
+        // gzip
+        if (headersInfo.gzip) {
+            response.setHeader('Content-Encoding', 'gzip');
+            if (file.bufferOrPath instanceof Buffer) {
+                // buffer 是缓存的文件，gzip 编码缓存的文件即是已经压缩后的文件
+                await this.endRespWithBuffer(response, file.bufferOrPath);
+            }
+            else {
+                const path = file.bufferOrPath;
+                await new Promise((resolve, reject) => {
+                    response.once('finish', resolve).once('error', reject);
+                    (0, fs_1.createReadStream)(path).pipe((0, zlib_1.createGzip)()).pipe(response);
+                });
+            }
+            return true;
+        }
+        // 普通的整个文件请求处理
+        if (file.bufferOrPath instanceof Buffer) {
+            await this.endRespWithBuffer(response, file.bufferOrPath);
+        }
+        else {
+            const filePath = file.bufferOrPath;
+            await new Promise((resolve, reject) => {
+                response.once('finish', resolve).once('error', reject);
+                (0, fs_1.createReadStream)(filePath).pipe(response);
+            });
+        }
+        return true;
+    }
+    /**
+     *  处理 head 请求，不响应正文内容，如果文件可以被找到，仅仅响应以下的消息头：
+     * Content-Length
+     * Content-Type
+     * Last-Modified
+     * Cache-Control
+     *
+     * @param path 请求路径
+     * @param response
+     * @returns 是否成功处理
+     */
+    async handleHead(path, response) {
+        // 构建文件信息
+        let file = await this.buildRespFile(path, { gzip: false });
+        if (!file) {
+            return false;
+        }
+        response.setHeader('Content-Length', file.size);
+        response.setHeader('Content-Type', file.mimeType);
+        response.setHeader('Last-Modified', file.mtime.toUTCString());
+        if (file.maxAge === 0) {
+            response.setHeader('Cache-Control', 'no-store');
+        }
+        else if (file.maxAge) {
+            response.setHeader('Cache-Control', `max-age=${file.maxAge}`);
+        }
+        response.end();
+        return true;
+    }
+    async endRespWithBuffer(response, buffer) {
+        if (response.writableEnded || response.destroyed) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            response.write(buffer, err => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        await new Promise((resolve, reject) => {
+            response.end(resolve);
+        });
+    }
+    /**
+     * 构建响应文件
+     *
+     * @param path
+     * @param headers
+     * @returns
+     */
+    async buildRespFile(path, headers) {
+        if (!this.cache) {
+            const file = await this.findFile(path);
+            if (!file) {
+                return null;
+            }
+            let { mtime } = file.stats;
+            mtime.setMilliseconds(0);
+            return {
+                maxAge: file.maxAge,
+                mtime: mtime,
+                size: file.stats.size,
+                bufferOrPath: file.filePath,
+                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
+            };
+        }
+        const cacheingGzip = headers.gzip && !headers.range;
+        const key = cacheingGzip ? `gzip-${path}` : path;
+        let file;
+        const cachedVal = await this.cache.computeIfAbsent(key, async () => {
+            file = (await this.findFile(path)) || undefined;
+            if (!file) {
+                return null;
+            }
+            // 文件太大不能被缓存
+            if (file.stats.size > this.maxFileSize) {
+                return null;
+            }
+            let buffer = await (0, promises_1.readFile)(file.filePath);
+            // gzip 存储压缩后的文件
+            if (cacheingGzip) {
+                buffer = await new Promise((resolve, reject) => {
+                    (0, zlib_1.gzip)(buffer, (err, res) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(res);
+                        }
+                    });
+                });
+            }
+            let { mtime } = file.stats;
+            mtime.setMilliseconds(0);
+            return {
+                buffer,
+                mtime: mtime,
+                cacheAge: file.maxAge,
+                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
+            };
+        });
+        if (cachedVal) {
+            return {
+                maxAge: cachedVal.cacheAge,
+                mtime: cachedVal.mtime,
+                size: cachedVal.buffer.length,
+                bufferOrPath: cachedVal.buffer,
+                mimeType: cachedVal.mimeType
+            };
+        }
+        // 判定文件大小
+        if (file) {
+            let { mtime } = file.stats;
+            mtime.setMilliseconds(0);
+            return {
+                maxAge: file.maxAge,
+                mtime: mtime,
+                size: file.stats.size,
+                bufferOrPath: file.filePath,
+                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
+            };
+        }
+        return null;
+    }
+    /**
+     * 根据路径查找文件
+     * @param path 访问路径
+     * @returns 返回被查询到的文件信息，如果找不到则返回 null
+     */
+    async findFile(path) {
+        let matchedRule;
+        for (const rule of this.rules) {
+            if (rule.path === '/') {
+                matchedRule = rule;
+                break;
+            }
+            if (path.startsWith(rule.path)) {
+                matchedRule = rule;
+                break;
+            }
+        }
+        // 匹配失败
+        if (!matchedRule) {
+            return null;
+        }
+        // 构建地址
+        let finalPath = matchedRule.path === '/' ? path : path.substring(matchedRule.path.length);
+        if (finalPath.startsWith('/')) {
+            finalPath = finalPath.substring(1);
+        }
+        let filePath = (0, path_1.resolve)(matchedRule.dir, finalPath);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return null;
+        }
+        const fileStat = await (0, promises_1.stat)(filePath);
+        // 如果是目录，尝试查找 index.html
+        if (fileStat.isDirectory()) {
+            const indexPath = (0, path_1.resolve)(filePath, 'index.html');
+            if (!(0, fs_1.existsSync)(indexPath)) {
+                return null;
+            }
+            const indexStat = await (0, promises_1.stat)(indexPath);
+            if (!indexStat.isFile()) {
+                return null;
+            }
+            return { filePath: indexPath, stats: indexStat };
+        }
+        if (!fileStat.isFile()) {
+            return null;
+        }
+        return { filePath, stats: fileStat, maxAge: matchedRule.cacheAge };
+    }
+    /**
+     * 删除服务器端静态资源缓存
+     * @param path
+     */
+    removeServerCache(path) {
+        if (this.cache) {
+            this.cache.remove(path);
+            this.cache.remove(`gzip-${path}`);
+        }
+    }
+}
+exports.StaticHandler = StaticHandler;