@wxn0brp/falcon-frame 0.7.0 → 0.8.0

package/dist/compress.js

@@ -1,4 +1,4 @@
-import { createGzip, createDeflate } from "zlib";
+import { createDeflate, createGzip } from "zlib";
 export function compression(req, res) {
     const encoding = req.headers["accept-encoding"];
     if (!encoding || typeof encoding !== "string" || res.headersSent) {

package/dist/cors.d.ts

@@ -4,4 +4,4 @@ export interface Opts {
     accessControlAllowHeaders?: boolean;
     headers?: Record<string, string>;
 }
-export declare function createCORS(allowedOrigins: string[], opts?: Opts): RouteHandler;
+export declare function createCORS(allowedOrigins: (string | RegExp)[], opts?: Opts): RouteHandler;

package/dist/cors.js

@@ -4,6 +4,54 @@ function setHeader(res, opts) {
     if (opts.accessControlAllowHeaders)
         res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
 }
+function parseOrigin(origin) {
+    try {
+        const url = new URL(origin);
+        return {
+            host: url.hostname,
+            port: url.port ||
+                (url.protocol === "https:" ? "443" : "80")
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function matches(origin, pattern) {
+    if (pattern === "*")
+        return true;
+    if (pattern instanceof RegExp)
+        return pattern.test(origin);
+    if (pattern.toLowerCase() === origin.toLowerCase())
+        return true;
+    const o = parseOrigin(origin);
+    if (!o)
+        return false;
+    // *.example.com[:port]
+    if (pattern.startsWith("*.")) {
+        const [pHost, pPort] = pattern.split(":");
+        const base = pHost.slice(2).toLowerCase();
+        if (o.host !== base && o.host.endsWith("." + base)) {
+            return !pPort || pPort === "*" || pPort === o.port;
+        }
+        return false;
+    }
+    // localhost:port
+    if (pattern.includes(":")) {
+        const [pHost, pPort] = pattern.split(":");
+        const base = pHost.toLowerCase();
+        return o.host === base && (pPort === "*" || o.port === pPort);
+    }
+    return false;
+}
+function handleEnd(req, res, next, origin) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    if (req.method === "OPTIONS") {
+        res.statusCode = 204;
+        return res.end();
+    }
+    next();
+}
 export function createCORS(allowedOrigins, opts = {}) {
     opts = {
         accessControlAllowMethods: true,
@@ -16,24 +64,12 @@ export function createCORS(allowedOrigins, opts = {}) {
                 res.setHeader(key, value);
             }
         }
-        if (allowedOrigins.includes("*")) {
-            res.setHeader("Access-Control-Allow-Origin", "*");
-            setHeader(res, opts);
-            if (req.method === "OPTIONS") {
-                res.statusCode = 204;
-                return res.end();
-            }
-            return next();
-        }
+        setHeader(res, opts);
         const origin = req.headers.origin;
-        if (origin && allowedOrigins.includes(origin)) {
-            res.setHeader("Access-Control-Allow-Origin", origin);
-            setHeader(res, opts);
-            if (req.method === "OPTIONS") {
-                res.statusCode = 204;
-                return res.end();
-            }
-        }
+        if (allowedOrigins.includes("*"))
+            return handleEnd(req, res, next, origin || "*");
+        if (origin && allowedOrigins.some((pattern) => matches(origin, pattern)))
+            return handleEnd(req, res, next, origin);
         next();
     };
 }

package/dist/index.js

@@ -43,9 +43,13 @@ export class FalconFrame extends Router {
             this.addBodyParser(json({ limit: this.opts.bodyLimit }));
         if (!this.opts.disableUrlencodedParser)
             this.addBodyParser(urlencoded({ limit: this.opts.bodyLimit }));
-        this.engine(".html", (path, options, callback, FF) => {
+        this.engine(".html", (path, data, callback, FF) => {
             try {
-                const content = renderHTML(path, options, [], FF);
+                const content = renderHTML({
+                    templatePath: path,
+                    data,
+                    FF,
+                });
                 callback(null, content);
             }
             catch (e) {

package/dist/render.d.ts

@@ -1,5 +1,12 @@
 import FalconFrame from "./index.js";
-export interface RenderOptions {
+import { CombinedVars } from "./types.js";
+export interface RenderHTMLOptions {
+    templatePath: string;
+    data?: Record<string, any>;
+    FF?: FalconFrame<any>;
     noLayout?: boolean;
+    FFVar?: CombinedVars<any>;
+    /** don't use, used internally */
+    _renderedPaths?: string[];
 }
-export declare function renderHTML(templatePath: string, data?: Record<string, any>, renderedPaths?: string[], FF?: FalconFrame<any>, opts?: RenderOptions): string;
+export declare function renderHTML(options: RenderHTMLOptions): string;

package/dist/render.js

@@ -1,10 +1,14 @@
 import fs from "fs";
 import path from "path";
-export function renderHTML(templatePath, data = {}, renderedPaths = [], FF, opts = {}) {
+export function renderHTML(options) {
     try {
+        let data = options.data || {};
+        const { templatePath, _renderedPaths: renderedPaths = [], FF, noLayout, FFVar, } = options;
         const realPath = path.resolve(templatePath);
         if (renderedPaths.includes(realPath))
             return `<!-- Circular dependency detected: tried to render ${templatePath} again -->`;
+        if (!fs.existsSync(templatePath))
+            return `<!-- Template not found: ${templatePath} -->`;
         let template = fs.readFileSync(templatePath, "utf8");
         // Loading internal data, e.g. <!-- data { "title": "My title" } -->
         const templateDataMatch = template.match(/<!--\s*data\s*(\{.*?\})\s*-->/s);
@@ -18,7 +22,7 @@ export function renderHTML(templatePath, data = {}, renderedPaths = [], FF, opts
                 template = template.replace(templateDataMatch[0], "<!-- Invalid template data -->");
             }
         }
-        const FFData = FF && FF.getVar("render data");
+        const FFData = FFVar?.["render data"] ?? (FF && FF.getVar("render data"));
         data = {
             ...(FFData || {}),
             ...templateData,
@@ -29,7 +33,14 @@ export function renderHTML(templatePath, data = {}, renderedPaths = [], FF, opts
         // 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, { noLayout: true });
+            return renderHTML({
+                templatePath: partialPath,
+                _renderedPaths: [...renderedPaths, realPath],
+                noLayout: true,
+                data,
+                FF,
+                FFVar,
+            });
         });
         // Loading files, e.g. /* include style.css */
         template = template.replace(/\/\*\s*include\s*(.*?)\s*\*\//g, (_, fileName) => {
@@ -42,8 +53,8 @@ export function renderHTML(templatePath, data = {}, renderedPaths = [], FF, opts
             }
         });
         // Layout
-        const FFLayout = FF && FF.getVar("layout");
-        if (!opts.noLayout && FFLayout) {
+        const FFLayout = FFVar?.layout ?? (FF && FF.getVar("layout"));
+        if (!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);
@@ -52,11 +63,21 @@ export function renderHTML(templatePath, data = {}, renderedPaths = [], FF, opts
                 return template;
             if (!hasHtmlStructure && forceNoLayout)
                 return template;
-            return renderHTML(FFLayout, { ...data, body: template }, [...renderedPaths, realPath], FF, { noLayout: true });
+            return renderHTML({
+                templatePath: FFLayout,
+                data: {
+                    ...data,
+                    body: template
+                },
+                _renderedPaths: [...renderedPaths, realPath],
+                noLayout: true,
+                FF,
+                FFVar,
+            });
         }
         return template;
     }
     catch (error) {
-        return `<!-- Template not found: ${templatePath} -->`;
+        return `<-- Template ${options.templatePath} has errors -->`;
     }
 }

package/dist/sse.d.ts

@@ -1,5 +1,5 @@
-import type { FFRequest, RouteHandler } from "./types.js";
 import { FFResponse } from "./res.js";
+import type { FFRequest, RouteHandler } from "./types.js";
 export declare class SSEManager {
     private clients;
     getMiddleware(lastHandler?: RouteHandler): RouteHandler;

package/dist/types.d.ts

@@ -66,7 +66,7 @@ export interface StaticServeOptions {
     errorIfDirNotFound?: boolean;
     notRenderHtml?: boolean;
 }
-export type EngineCallback = (path: string, options: any, callback: (e: any, rendered?: string) => void, FF?: FalconFrame) => void;
+export type EngineCallback = (path: string, data: any, callback: (e: any, rendered?: string) => void, FF?: FalconFrame) => void;
 export interface RenderOptions {
     notUseViews?: boolean;
     contentType?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -29,7 +29,7 @@
     "typescript": "*"
   },
   "dependencies": {
-    "@wxn0brp/lucerna-log": "^0.2.0"
+    "@wxn0brp/lucerna-log": "^0.2.2"
   },
   "files": [
     "dist"