@wxn0brp/falcon-frame 0.9.4 → 0.9.5

package/dist/index.d.ts

@@ -43,7 +43,8 @@ export declare class FalconFrame<Vars extends Record<string, any> = {}> extends
     set500(handler: ErrorHandler): void;
 }
 export default FalconFrame;
-export { OfflineEngine, OfflineRequest, OfflineResponse } from "./engine.js";
+export { OfflineEngine } from "./engine.js";
+export type { OfflineRequest, OfflineResponse } from "./engine.js";
 export * as Helpers from "./helpers.js";
 export type { FFOpts as Opts } from "./types.js";
 export { validateBody } from "./valid.js";

package/dist/router.d.ts

@@ -1,5 +1,5 @@
 import { SSEManager } from "./sse.js";
-import { Method, Middleware, RouteHandler, StaticServeOptions } from "./types.js";
+import { Method, Middleware, RouteHandler, StaticFileOptions, StaticServeOptions } from "./types.js";
 export type MiddlewareFn = RouteHandler | Router | {
     getRouteHandler(): RouteHandler;
 };
@@ -14,6 +14,7 @@ export declare class Router {
     patch(path: string, ...handlers: RouteHandler[]): this;
     all(path: string, ...handlers: RouteHandler[]): this;
     static(apiPath: string, dirPath?: string, opts?: StaticServeOptions): this;
+    file(routePath: string, filePath: string, opts?: StaticFileOptions): this;
     sse(path: string, ...handlers: RouteHandler[]): SSEManager;
     customParser(path: string, handler: RouteHandler, method?: Method): this;
     router(path?: string): Router;

package/dist/router.js

@@ -1,5 +1,5 @@
 import { SSEManager } from "./sse.js";
-import { handleStaticFiles } from "./static.js";
+import { handleSingleFile, handleStaticFiles } from "./static.js";
 export class Router {
     middlewares = [];
     addRoute(method, path, ...handlers) {
@@ -68,6 +68,10 @@ export class Router {
         this.use(apiPath, handleStaticFiles(dirPath, opts));
         return this;
     }
+    file(routePath, filePath, opts = {}) {
+        this.use(routePath, handleSingleFile(filePath, opts));
+        return this;
+    }
     sse(path, ...handlers) {
         const lastHandler = handlers.pop() || (() => { });
         const manager = new SSEManager();

package/dist/static.d.ts

@@ -1,2 +1,3 @@
-import { RouteHandler, StaticServeOptions } from "./types.js";
+import { RouteHandler, StaticFileOptions, StaticServeOptions } from "./types.js";
+export declare function handleSingleFile(filePath: string, opts: StaticFileOptions): RouteHandler;
 export declare function handleStaticFiles(dirPath: string, opts: StaticServeOptions): RouteHandler;

package/dist/static.js

@@ -1,6 +1,44 @@
 import fs from "fs";
 import path from "path";
 import { ensureLeadingDot, getContentType } from "./helpers.js";
+export function handleSingleFile(filePath, opts) {
+    opts = {
+        utf8: true,
+        etag: true,
+        errorIfFileNotFound: true,
+        ...opts,
+    };
+    if (opts.errorIfFileNotFound && !fs.existsSync(filePath))
+        throw new Error(`File ${filePath} does not exist`);
+    return (req, res, next) => {
+        if (req.method !== "GET" && req.method !== "HEAD")
+            return next();
+        let stats;
+        try {
+            stats = fs.statSync(filePath);
+        }
+        catch (e) {
+            res.statusCode = 404;
+            res.FF._404(req, res);
+            return;
+        }
+        if (opts.etag) {
+            const etag = `W/"${stats.size}-${stats.mtime.getTime()}"`;
+            if (req.headers["if-none-match"] === etag) {
+                res.status(304).end();
+                return;
+            }
+            res.setHeader("ETag", etag);
+        }
+        res.ct(getContentType(filePath, opts.utf8));
+        if (req.method === "HEAD") {
+            res.setHeader("Content-Length", stats.size);
+            res.end();
+            return;
+        }
+        fs.createReadStream(filePath).pipe(res);
+    };
+}
 export function handleStaticFiles(dirPath, opts) {
     opts = {
         utf8: true,

package/dist/types.d.ts

@@ -76,6 +76,11 @@ export interface StaticServeOptions {
     errorIfDirNotFound?: boolean;
     notRenderHtml?: boolean;
 }
+export interface StaticFileOptions {
+    utf8?: boolean;
+    etag?: boolean;
+    errorIfFileNotFound?: boolean;
+}
 export type EngineCallback = (path: string, data: any, callback: (e: any, rendered?: string) => void, FF?: FalconFrame) => void;
 export interface RenderOptions {
     notUseViews?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",