@wxn0brp/falcon-frame 0.6.0 → 0.6.2

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 type { 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,5 @@
 import FalconFrame from "./index.js";
-interface RenderData {
-    [key: string]: string;
+export interface RenderOptions {
+    noLayout?: boolean;
 }
-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, opts?: RenderOptions): string;

package/dist/render.js

@@ -1,26 +1,35 @@
 import fs from "fs";
 import path from "path";
-export function renderHTML(templatePath, data, renderedPaths = [], FF) {
+export function renderHTML(templatePath, data = {}, renderedPaths = [], FF, opts = {}) {
     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"]) {
-            data = {
-                ...FF.vars["render data"],
-                ...data,
-            };
-        }
         let template = fs.readFileSync(templatePath, "utf8");
+        // Loading internal data, e.g. <!-- data { "title": "My title" } -->
+        const templateDataMatch = template.match(/<!--\s*data\s*(\{.*?\})\s*-->/s);
+        let templateData = {};
+        if (templateDataMatch) {
+            try {
+                templateData = JSON.parse(templateDataMatch[1]);
+                template = template.replace(templateDataMatch[0], "");
+            }
+            catch (err) {
+                template = template.replace(templateDataMatch[0], "<!-- Invalid template data -->");
+            }
+        }
+        const FFData = FF && FF.getVar("render data");
+        data = {
+            ...(FFData || {}),
+            ...templateData,
+            ...data,
+        };
         // Inserting data, e.g. {{name}}
         template = template.replace(/{{(.*?)}}/g, (_, key) => data[key.trim()] || "");
         // Loading partials, e.g. <!-- include header -->
         template = template.replace(/<!--\s*include\s*(.*?)\s*-->/g, (_, partialName) => {
             const partialPath = path.join(path.dirname(templatePath), partialName + ".html");
-            return renderHTML(partialPath, data, [
-                ...renderedPaths,
-                realPath,
-            ], FF);
+            return renderHTML(partialPath, data, [...renderedPaths, realPath], FF, { noLayout: true });
         });
         // Loading files, e.g. /* include style.css */
         template = template.replace(/\/\*\s*include\s*(.*?)\s*\*\//g, (_, fileName) => {
@@ -33,15 +42,17 @@ export function renderHTML(templatePath, data, renderedPaths = [], FF) {
             }
         });
         // Layout
-        if (FF && FF.vars["layout"]) {
+        const FFLayout = FF && FF.getVar("layout");
+        if (!opts.noLayout && 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);
+            template = template.replace(/<!--\s*layout\s*-->|<!--\s*force-layout\s*-->|<!--\s*force-no-layout\s*-->/g, "");
             if (hasHtmlStructure && !forceLayout)
                 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, { noLayout: true });
         }
         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,16 +1,28 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
   "license": "MIT",
   "type": "module",
+  "description": "Lightweight modular TypeScript web framework",
   "homepage": "https://github.com/wxn0brP/FalconFrame",
   "repository": {
     "type": "git",
     "url": "https://github.com/wxn0brP/FalconFrame.git"
   },
+  "keywords": [
+    "http",
+    "web",
+    "framework",
+    "typescript",
+    "modular",
+    "lightweight",
+    "middleware",
+    "middleware-first",
+    "middleware-chain"
+  ],
   "devDependencies": {
     "@types/node": "*",
     "tsc-alias": "*",