|
|
| import { getMimeType } from "hono/utils/mime";
|
| import { createReadStream, statSync, existsSync } from "fs";
|
| import { join } from "path";
|
| import { versions } from "process";
|
| import { Readable } from "stream";
|
| var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
|
| var ENCODINGS = {
|
| br: ".br",
|
| zstd: ".zst",
|
| gzip: ".gz"
|
| };
|
| var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
|
| var pr54206Applied = () => {
|
| const [major, minor] = versions.node.split(".").map((component) => parseInt(component));
|
| return major >= 23 || major === 22 && minor >= 7 || major === 20 && minor >= 18;
|
| };
|
| var useReadableToWeb = pr54206Applied();
|
| var createStreamBody = (stream) => {
|
| if (useReadableToWeb) {
|
| return Readable.toWeb(stream);
|
| }
|
| const body = new ReadableStream({
|
| start(controller) {
|
| stream.on("data", (chunk) => {
|
| controller.enqueue(chunk);
|
| });
|
| stream.on("error", (err) => {
|
| controller.error(err);
|
| });
|
| stream.on("end", () => {
|
| controller.close();
|
| });
|
| },
|
| cancel() {
|
| stream.destroy();
|
| }
|
| });
|
| return body;
|
| };
|
| var getStats = (path) => {
|
| let stats;
|
| try {
|
| stats = statSync(path);
|
| } catch {
|
| }
|
| return stats;
|
| };
|
| var tryDecode = (str, decoder) => {
|
| try {
|
| return decoder(str);
|
| } catch {
|
| return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
|
| try {
|
| return decoder(match);
|
| } catch {
|
| return match;
|
| }
|
| });
|
| }
|
| };
|
| var tryDecodeURI = (str) => tryDecode(str, decodeURI);
|
| var serveStatic = (options = { root: "" }) => {
|
| const root = options.root || "";
|
| const optionPath = options.path;
|
| if (root !== "" && !existsSync(root)) {
|
| console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
|
| }
|
| return async (c, next) => {
|
| if (c.finalized) {
|
| return next();
|
| }
|
| let filename;
|
| if (optionPath) {
|
| filename = optionPath;
|
| } else {
|
| try {
|
| filename = tryDecodeURI(c.req.path);
|
| if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}/.test(filename)) {
|
| throw new Error();
|
| }
|
| } catch {
|
| await options.onNotFound?.(c.req.path, c);
|
| return next();
|
| }
|
| }
|
| let path = join(
|
| root,
|
| !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
|
| );
|
| let stats = getStats(path);
|
| if (stats && stats.isDirectory()) {
|
| const indexFile = options.index ?? "index.html";
|
| path = join(path, indexFile);
|
| stats = getStats(path);
|
| }
|
| if (!stats) {
|
| await options.onNotFound?.(path, c);
|
| return next();
|
| }
|
| const mimeType = getMimeType(path);
|
| c.header("Content-Type", mimeType || "application/octet-stream");
|
| if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
|
| const acceptEncodingSet = new Set(
|
| c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim())
|
| );
|
| for (const encoding of ENCODINGS_ORDERED_KEYS) {
|
| if (!acceptEncodingSet.has(encoding)) {
|
| continue;
|
| }
|
| const precompressedStats = getStats(path + ENCODINGS[encoding]);
|
| if (precompressedStats) {
|
| c.header("Content-Encoding", encoding);
|
| c.header("Vary", "Accept-Encoding", { append: true });
|
| stats = precompressedStats;
|
| path = path + ENCODINGS[encoding];
|
| break;
|
| }
|
| }
|
| }
|
| let result;
|
| const size = stats.size;
|
| const range = c.req.header("range") || "";
|
| if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
|
| c.header("Content-Length", size.toString());
|
| c.status(200);
|
| result = c.body(null);
|
| } else if (!range) {
|
| c.header("Content-Length", size.toString());
|
| result = c.body(createStreamBody(createReadStream(path)), 200);
|
| } else {
|
| c.header("Accept-Ranges", "bytes");
|
| c.header("Date", stats.birthtime.toUTCString());
|
| const parts = range.replace(/bytes=/, "").split("-", 2);
|
| const start = parseInt(parts[0], 10) || 0;
|
| let end = parseInt(parts[1], 10) || size - 1;
|
| if (size < end - start + 1) {
|
| end = size - 1;
|
| }
|
| const chunksize = end - start + 1;
|
| const stream = createReadStream(path, { start, end });
|
| c.header("Content-Length", chunksize.toString());
|
| c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
|
| result = c.body(createStreamBody(stream), 206);
|
| }
|
| await options.onFound?.(path, c);
|
| return result;
|
| };
|
| };
|
| export {
|
| serveStatic
|
| };
|
|
|
