@wxn0brp/falcon-frame 0.6.0 → 0.6.1

package/dist/index.d.ts

@@ -1,33 +1,27 @@
-import { Logger, LoggerOptions } from "@wxn0brp/lucerna-log";
+import { Logger } from "@wxn0brp/lucerna-log";
 import http from "http";
 import { renderHTML } from "./render.js";
 import { FFResponse } from "./res.js";
 import { Router } from "./router.js";
-import type { BeforeHandleRequest, EngineCallback, ErrorHandler, FFRequest, RouteHandler, ValidationErrorFormatter } from "./types.js";
-export interface Opts {
-    loggerOpts?: LoggerOptions;
-    bodyLimit?: string;
-    disableJsonParser?: boolean;
-    disableUrlencodedParser?: boolean;
-}
-export declare class FalconFrame<Vars extends Record<string, any> = any> extends Router {
+import type { BeforeHandleRequest, CombinedVars, EngineCallback, ErrorHandler, FFOpts, FFRequest, RouteHandler, ValidationErrorFormatter } from "./types.js";
+export declare class FalconFrame<Vars extends Record<string, any> = Record<string, any>> extends Router {
     logger: Logger;
     bodyParsers: RouteHandler[];
-    vars: Vars;
-    opts: Opts;
+    vars: CombinedVars<Vars>;
+    opts: FFOpts;
     engines: Record<string, EngineCallback>;
     _400_formatter: ValidationErrorFormatter;
     _404: RouteHandler;
     _413: RouteHandler;
     _500: ErrorHandler;
-    constructor(opts?: Partial<Opts>);
+    constructor(opts?: Partial<FFOpts>);
     addBodyParser(parser: RouteHandler): this;
     listen(port: number | string, callback?: (() => void) | boolean, beforeHandleRequest?: BeforeHandleRequest): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
     getApp(beforeHandleRequest?: BeforeHandleRequest): (req: any, res: any) => Promise<void>;
     engine(ext: string, callback: EngineCallback): this;
-    setVar(key: keyof Vars, value: typeof this.vars[keyof Vars]): void;
-    set(key: keyof Vars, value: typeof this.vars[keyof Vars]): void;
-    getVar(key: string): typeof this.vars[keyof Vars];
+    setVar(key: keyof CombinedVars<Vars>, value: typeof this.vars[keyof CombinedVars<Vars>]): void;
+    set(key: keyof CombinedVars<Vars>, value: typeof this.vars[keyof CombinedVars<Vars>]): void;
+    getVar(key: keyof CombinedVars<Vars>): typeof this.vars[keyof CombinedVars<Vars>];
     /**
      * Sets the allowed origins for CORS.
      * This method is a shortcut that simplifies CORS configuration
@@ -50,5 +44,6 @@ export declare class FalconFrame<Vars extends Record<string, any> = any> extends
 }
 export default FalconFrame;
 export * as Helpers from "./helpers.js";
+export { FFOpts as Opts } from "./types.js";
 export { validateBody } from "./valid.js";
 export { FFRequest, FFResponse, renderHTML, RouteHandler, Router };

package/dist/index.js

@@ -92,7 +92,7 @@ export class FalconFrame extends Router {
                 if (result || res._ended)
                     return;
             }
-            await handleRequest(req, res, this);
+            handleRequest(req, res, this);
         };
     }
     engine(ext, callback) {

package/dist/render.d.ts

@@ -1,6 +1,2 @@
 import FalconFrame from "./index.js";
-interface RenderData {
-    [key: string]: string;
-}
-export declare function renderHTML(templatePath: string, data: RenderData, renderedPaths?: string[], FF?: FalconFrame): string;
-export {};
+export declare function renderHTML(templatePath: string, data?: Record<string, any>, renderedPaths?: string[], FF?: FalconFrame): string;

package/dist/render.js

@@ -1,13 +1,14 @@
 import fs from "fs";
 import path from "path";
-export function renderHTML(templatePath, data, renderedPaths = [], FF) {
+export function renderHTML(templatePath, data = {}, renderedPaths = [], FF) {
     try {
         const realPath = path.resolve(templatePath);
         if (renderedPaths.includes(realPath))
             return `<!-- Circular dependency detected: tried to render ${templatePath} again -->`;
-        if (FF && FF.vars["render data"]) {
+        const FFData = FF && FF.getVar("render data");
+        if (FFData) {
             data = {
-                ...FF.vars["render data"],
+                ...FFData,
                 ...data,
             };
         }
@@ -33,7 +34,8 @@ export function renderHTML(templatePath, data, renderedPaths = [], FF) {
             }
         });
         // Layout
-        if (FF && FF.vars["layout"]) {
+        const FFLayout = FF && FF.getVar("layout");
+        if (FFLayout) {
             const hasHtmlStructure = /<\s*html|<\s*body/i.test(template);
             const forceLayout = /<!--\s*force-layout\s*-->/.test(template);
             const forceNoLayout = /<!--\s*force-no-layout\s*-->/.test(template);
@@ -41,7 +43,7 @@ export function renderHTML(templatePath, data, renderedPaths = [], FF) {
                 return template;
             if (!hasHtmlStructure && forceNoLayout)
                 return template;
-            return renderHTML(FF.vars["layout"], { ...data, body: template }, [...renderedPaths, realPath], FF);
+            return renderHTML(FFLayout, { ...data, body: template }, [...renderedPaths, realPath], FF);
         }
         return template;
     }

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { LoggerOptions } from "@wxn0brp/lucerna-log";
 import FalconFrame from "./index.js";
 import { FFResponse } from "./res.js";
 import http from "http";
@@ -73,3 +74,16 @@ export interface RenderOptions {
     notAppendExt?: boolean;
     notShareFF?: boolean;
 }
+export interface FFOpts {
+    loggerOpts?: LoggerOptions;
+    bodyLimit?: string;
+    disableJsonParser?: boolean;
+    disableUrlencodedParser?: boolean;
+}
+export type FFVars = {
+    "render data": Record<string, any>;
+    "view engine": string;
+    "views": string;
+    "layout": string;
+};
+export type CombinedVars<ExtraVars> = ExtraVars & FFVars;

package/package.json

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