@wxn0brp/falcon-frame 0.9.3 → 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/res.d.ts

@@ -83,4 +83,11 @@ export declare class FFResponse extends http.ServerResponse {
      * @returns The response object
      */
     sseSend(data: string | object): this;
+    /**
+     * Sends a Server-Sent Event with an event type to the client.
+     * @param event The event type
+     * @param data The data to be sent. If an object, it will be JSON.stringified.
+     * @returns The response object
+     */
+    sseEventSend(event: string, data: string | object): this;
 }

package/dist/res.js

@@ -180,4 +180,16 @@ export class FFResponse extends http.ServerResponse {
         this.write(`data: ${data}\n\n`);
         return this;
     }
+    /**
+     * Sends a Server-Sent Event with an event type to the client.
+     * @param event The event type
+     * @param data The data to be sent. If an object, it will be JSON.stringified.
+     * @returns The response object
+     */
+    sseEventSend(event, data) {
+        if (typeof data === "object")
+            data = JSON.stringify(data);
+        this.write(`event: ${event}\ndata: ${data}\n\n`);
+        return this;
+    }
 }

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,7 +14,8 @@ 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;
+    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();
@@ -80,7 +84,7 @@ export class Router {
         this.middlewares[index - 1].customParser = true;
         return this;
     }
-    router(path) {
+    router(path = "/") {
         const router = new Router();
         this.use(path, router);
         return router;

package/dist/sse.d.ts

@@ -12,5 +12,7 @@ export declare class SSEManager {
     }>;
     sendAll(data: any): void;
     sendTo(id: string, data: any): void;
+    sendEventAll(event: string, data: any): void;
+    sendEventTo(id: string, event: string, data: any): void;
     disconnect(id: string): void;
 }

package/dist/sse.js

@@ -20,21 +20,30 @@ export class SSEManager {
         return this._clients;
     }
     sendAll(data) {
-        for (const { res } of this._clients.values()) {
+        for (const { res } of this._clients.values())
             res.sseSend(data);
-        }
     }
     sendTo(id, data) {
         const client = this._clients.get(id);
-        if (client) {
-            client.res.sseSend(data);
-        }
+        if (!client)
+            return;
+        client.res.sseSend(data);
+    }
+    sendEventAll(event, data) {
+        for (const { res } of this._clients.values())
+            res.sseEventSend(event, data);
+    }
+    sendEventTo(id, event, data) {
+        const client = this._clients.get(id);
+        if (!client)
+            return;
+        client.res.sseEventSend(event, data);
     }
     disconnect(id) {
         const client = this._clients.get(id);
-        if (client) {
-            client.res.end();
-            this._clients.delete(id);
-        }
+        if (!client)
+            return;
+        client.res.end();
+        this._clients.delete(id);
     }
 }

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.3",
+  "version": "0.9.5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",