jimpex 7.0.2 → 9.0.0

package/dist/middlewares/html/fastHTML.d.mts

@@ -0,0 +1,180 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { l as Events, J as Jimpex, R as MiddlewareConnectFn } from '../../index-efeb437e.js';
+import { AsyncExpressMiddleware } from '../../types/express.mjs';
+import { SendFile } from '../../services/common/sendFile.mjs';
+import { HTMLGenerator } from '../../services/html/htmlGenerator.mjs';
+import { Response, NextFunction } from 'express';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.mjs';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import '../../services/frontend/frontendFs.mjs';
+import 'fs/promises';
+import '@homer0/deferred';
+
+/**
+ * The options to customize the behavior of the middleware.
+ *
+ * @group Middlewares/FastHTML
+ */
+type FastHTMLOptions = {
+    /**
+     * The name of the file the middleware will serve. If the {@link HTMLGenerator} service
+     * is available, it will be overriden by the service.
+     *
+     * @default 'index.html'
+     */
+    file: string;
+    /**
+     * A list of regular expressions to match request paths that should be ignored by the
+     * middleware.
+     *
+     * @default [/\.ico$/i]
+     */
+    ignoredRoutes: RegExp[];
+    /**
+     * If `true`, {@link FastHTML} will get the list of all the routes controlled by the
+     * application, and will use them to validate the incoming requests (in addition to the
+     * `ignore` list): If a request URL doesn't match with any of the "controlled routes",
+     * it will serve the HTML file.
+     *
+     * @default true
+     */
+    useAppRoutes: boolean;
+};
+/**
+ * The options to construct a {@link FastHTML}.
+ *
+ * @group Middlewares/FastHTML
+ */
+type FastHTMLConstructorOptions = Partial<FastHTMLOptions> & {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        sendFile: SendFile;
+        events: Events;
+        /**
+         * A function to get a possible {@link HTMLGenerator}. This is injected as a "getter"
+         * to not interrupt the DIC "lifecycle": middlewares are initialized right when the
+         * app starts, and injecting a reference would force the service to be initialized
+         * too, even if a request is not being made.
+         */
+        getHTMLGenerator?: () => HTMLGenerator | undefined;
+    };
+};
+/**
+ * The options for the middleware creator that will mount an instance of {@link FastHTML}.
+ *
+ * @group Middlewares/FastHTML
+ */
+type FastHTMLMiddlewareOptions = Partial<FastHTMLOptions> & {
+    /**
+     * The name of an {@link HTMLGenerator} service already available in the application.
+     *
+     * @default 'htmlGenerator'
+     */
+    htmlGeneratorServiceName?: string;
+};
+/**
+ * It's common for an app to show an HTML view when no route was able to handle a request,
+ * so the idea behind this middleware is to avoid going to every middleware and controller
+ * and just specify that if the request is not for a route handled by a controller, just
+ * serve the HTML and avoid processing unnecessary data.
+ *
+ * A simple example: The app has a route `/backend` that a frontend uses to get
+ * information.
+ * This middleware can be used to only allow the execution of middlewares and controllers
+ * when the request route is for `/backend`.
+ *
+ * **Disclaimer**: Managing statics files with Express is not a best practice, but there
+ * are scenarios where there is not other choice.
+ *
+ * @group Middleware Classes
+ * @group Middlewares/FastHTML
+ * @prettierignore
+ */
+declare class FastHTML {
+    /**
+     * The service that serves a file.
+     */
+    protected readonly _sendFile: SendFile;
+    /**
+     * The application envent bus, to listen and get the list of "controlled routes" after
+     * the application is started.
+     */
+    protected readonly _events: Events;
+    /**
+     * A function to get a possible {@link HTMLGenerator}. This is injected as a "getter"
+     * to not interrupt the DIC "lifecycle": middlewares are initialized right when the
+     * app starts, and injecting a reference would force the service to be initialized
+     * too, even if a request is not being made.
+     */
+    protected readonly _getHTMLGenerator: () => HTMLGenerator | undefined;
+    /**
+     * The customization options for the middleware.
+     */
+    protected _options: FastHTMLOptions;
+    /**
+     * Whether or not the file is ready to be served. In case the middleware uses an
+     * {@link HTMLGenerator} service, the file needs to be generated before being available,
+     * and that's why this flag exists.
+     */
+    protected _fileReady: boolean;
+    /**
+     * A list of regular expression that match the routes controlled by the application.
+     * This is in case the `useAppRoutes` option is set to `true`; when the application gets
+     * started, an event listener will obtain all the top controlled routes, create regular
+     * expressions, and save them on this property.
+     */
+    protected _routeExpressions: RegExp[];
+    /**
+     * @param options  The options to construct the class.
+     * @throws If `ignoredRoutes` is empty and `useAppRoutes` is set to `false`.
+     */
+    constructor({ inject, ...options }: FastHTMLConstructorOptions);
+    /**
+     * Generates the middleware that serves the HTML file.
+     */
+    getMiddleware(): AsyncExpressMiddleware;
+    /**
+     * The customization options.
+     */
+    get options(): Readonly<FastHTMLOptions>;
+    /**
+     * Serves the HTML file to the response.
+     *
+     * @param res   The response object generated by the application.
+     * @param next  The function to call the next middleware.
+     */
+    protected _sendResponse(res: Response, next: NextFunction): void;
+    /**
+     * Adds the event listener that obtains the list of "controlled routes" when
+     * `useAppRoutes` is set to `true`.
+     */
+    protected _setupEvents(): void;
+    /**
+     * Validates whether a route should be ignored or not. The method checks first against
+     * the `ignore` option, and then against the list of "controlled routes" if
+     * `useAppRoutes` is set to `true`.
+     *
+     * @param route  The route to validate.
+     */
+    protected _shouldIgnoreRoute(route: string): boolean;
+}
+/**
+ * Creates the middleware that filters the routes and serves an HTML before the
+ * application gets to evaluate whether there's a controller for the request or not.
+ *
+ * @group Middlewares
+ * @group Middlewares/FastHTML
+ */
+declare const fastHTMLMiddleware: _homer0_jimple.ResourceCreator<"middleware", "connect", (options?: FastHTMLMiddlewareOptions) => <ContainerType extends Jimpex = Jimpex>(app: ContainerType) => AsyncExpressMiddleware, MiddlewareConnectFn>;
+
+export { FastHTML, FastHTMLConstructorOptions, FastHTMLMiddlewareOptions, FastHTMLOptions, fastHTMLMiddleware };

package/dist/middlewares/html/fastHTML.d.ts

@@ -0,0 +1,180 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { l as Events, J as Jimpex, R as MiddlewareConnectFn } from '../../index-b2a04c78.js';
+import { AsyncExpressMiddleware } from '../../types/express.js';
+import { SendFile } from '../../services/common/sendFile.js';
+import { HTMLGenerator } from '../../services/html/htmlGenerator.js';
+import { Response, NextFunction } from 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.js';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import '../../services/frontend/frontendFs.js';
+import 'fs/promises';
+import '@homer0/deferred';
+
+/**
+ * The options to customize the behavior of the middleware.
+ *
+ * @group Middlewares/FastHTML
+ */
+type FastHTMLOptions = {
+    /**
+     * The name of the file the middleware will serve. If the {@link HTMLGenerator} service
+     * is available, it will be overriden by the service.
+     *
+     * @default 'index.html'
+     */
+    file: string;
+    /**
+     * A list of regular expressions to match request paths that should be ignored by the
+     * middleware.
+     *
+     * @default [/\.ico$/i]
+     */
+    ignoredRoutes: RegExp[];
+    /**
+     * If `true`, {@link FastHTML} will get the list of all the routes controlled by the
+     * application, and will use them to validate the incoming requests (in addition to the
+     * `ignore` list): If a request URL doesn't match with any of the "controlled routes",
+     * it will serve the HTML file.
+     *
+     * @default true
+     */
+    useAppRoutes: boolean;
+};
+/**
+ * The options to construct a {@link FastHTML}.
+ *
+ * @group Middlewares/FastHTML
+ */
+type FastHTMLConstructorOptions = Partial<FastHTMLOptions> & {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        sendFile: SendFile;
+        events: Events;
+        /**
+         * A function to get a possible {@link HTMLGenerator}. This is injected as a "getter"
+         * to not interrupt the DIC "lifecycle": middlewares are initialized right when the
+         * app starts, and injecting a reference would force the service to be initialized
+         * too, even if a request is not being made.
+         */
+        getHTMLGenerator?: () => HTMLGenerator | undefined;
+    };
+};
+/**
+ * The options for the middleware creator that will mount an instance of {@link FastHTML}.
+ *
+ * @group Middlewares/FastHTML
+ */
+type FastHTMLMiddlewareOptions = Partial<FastHTMLOptions> & {
+    /**
+     * The name of an {@link HTMLGenerator} service already available in the application.
+     *
+     * @default 'htmlGenerator'
+     */
+    htmlGeneratorServiceName?: string;
+};
+/**
+ * It's common for an app to show an HTML view when no route was able to handle a request,
+ * so the idea behind this middleware is to avoid going to every middleware and controller
+ * and just specify that if the request is not for a route handled by a controller, just
+ * serve the HTML and avoid processing unnecessary data.
+ *
+ * A simple example: The app has a route `/backend` that a frontend uses to get
+ * information.
+ * This middleware can be used to only allow the execution of middlewares and controllers
+ * when the request route is for `/backend`.
+ *
+ * **Disclaimer**: Managing statics files with Express is not a best practice, but there
+ * are scenarios where there is not other choice.
+ *
+ * @group Middleware Classes
+ * @group Middlewares/FastHTML
+ * @prettierignore
+ */
+declare class FastHTML {
+    /**
+     * The service that serves a file.
+     */
+    protected readonly _sendFile: SendFile;
+    /**
+     * The application envent bus, to listen and get the list of "controlled routes" after
+     * the application is started.
+     */
+    protected readonly _events: Events;
+    /**
+     * A function to get a possible {@link HTMLGenerator}. This is injected as a "getter"
+     * to not interrupt the DIC "lifecycle": middlewares are initialized right when the
+     * app starts, and injecting a reference would force the service to be initialized
+     * too, even if a request is not being made.
+     */
+    protected readonly _getHTMLGenerator: () => HTMLGenerator | undefined;
+    /**
+     * The customization options for the middleware.
+     */
+    protected _options: FastHTMLOptions;
+    /**
+     * Whether or not the file is ready to be served. In case the middleware uses an
+     * {@link HTMLGenerator} service, the file needs to be generated before being available,
+     * and that's why this flag exists.
+     */
+    protected _fileReady: boolean;
+    /**
+     * A list of regular expression that match the routes controlled by the application.
+     * This is in case the `useAppRoutes` option is set to `true`; when the application gets
+     * started, an event listener will obtain all the top controlled routes, create regular
+     * expressions, and save them on this property.
+     */
+    protected _routeExpressions: RegExp[];
+    /**
+     * @param options  The options to construct the class.
+     * @throws If `ignoredRoutes` is empty and `useAppRoutes` is set to `false`.
+     */
+    constructor({ inject, ...options }: FastHTMLConstructorOptions);
+    /**
+     * Generates the middleware that serves the HTML file.
+     */
+    getMiddleware(): AsyncExpressMiddleware;
+    /**
+     * The customization options.
+     */
+    get options(): Readonly<FastHTMLOptions>;
+    /**
+     * Serves the HTML file to the response.
+     *
+     * @param res   The response object generated by the application.
+     * @param next  The function to call the next middleware.
+     */
+    protected _sendResponse(res: Response, next: NextFunction): void;
+    /**
+     * Adds the event listener that obtains the list of "controlled routes" when
+     * `useAppRoutes` is set to `true`.
+     */
+    protected _setupEvents(): void;
+    /**
+     * Validates whether a route should be ignored or not. The method checks first against
+     * the `ignore` option, and then against the list of "controlled routes" if
+     * `useAppRoutes` is set to `true`.
+     *
+     * @param route  The route to validate.
+     */
+    protected _shouldIgnoreRoute(route: string): boolean;
+}
+/**
+ * Creates the middleware that filters the routes and serves an HTML before the
+ * application gets to evaluate whether there's a controller for the request or not.
+ *
+ * @group Middlewares
+ * @group Middlewares/FastHTML
+ */
+declare const fastHTMLMiddleware: _homer0_jimple.ResourceCreator<"middleware", "connect", (options?: FastHTMLMiddlewareOptions) => <ContainerType extends Jimpex = Jimpex>(app: ContainerType) => AsyncExpressMiddleware, MiddlewareConnectFn>;
+
+export { FastHTML, FastHTMLConstructorOptions, FastHTMLMiddlewareOptions, FastHTMLOptions, fastHTMLMiddleware };

package/dist/middlewares/html/fastHTML.js

@@ -0,0 +1,185 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var fastHTML_exports = {};
+__export(fastHTML_exports, {
+  FastHTML: () => FastHTML,
+  fastHTMLMiddleware: () => fastHTMLMiddleware
+});
+module.exports = __toCommonJS(fastHTML_exports);
+var import_utils = require("../../utils");
+class FastHTML {
+  /**
+   * @param options  The options to construct the class.
+   * @throws If `ignoredRoutes` is empty and `useAppRoutes` is set to `false`.
+   */
+  constructor({ inject, ...options }) {
+    /**
+     * The service that serves a file.
+     */
+    __publicField(this, "_sendFile");
+    /**
+     * The application envent bus, to listen and get the list of "controlled routes" after
+     * the application is started.
+     */
+    __publicField(this, "_events");
+    /**
+     * A function to get a possible {@link HTMLGenerator}. This is injected as a "getter"
+     * to not interrupt the DIC "lifecycle": middlewares are initialized right when the
+     * app starts, and injecting a reference would force the service to be initialized
+     * too, even if a request is not being made.
+     */
+    __publicField(this, "_getHTMLGenerator");
+    /**
+     * The customization options for the middleware.
+     */
+    __publicField(this, "_options");
+    /**
+     * Whether or not the file is ready to be served. In case the middleware uses an
+     * {@link HTMLGenerator} service, the file needs to be generated before being available,
+     * and that's why this flag exists.
+     */
+    __publicField(this, "_fileReady", false);
+    /**
+     * A list of regular expression that match the routes controlled by the application.
+     * This is in case the `useAppRoutes` option is set to `true`; when the application gets
+     * started, an event listener will obtain all the top controlled routes, create regular
+     * expressions, and save them on this property.
+     */
+    __publicField(this, "_routeExpressions", []);
+    this._sendFile = inject.sendFile;
+    this._events = inject.events;
+    this._getHTMLGenerator = inject.getHTMLGenerator || (() => void 0);
+    this._options = {
+      file: "index.html",
+      ignoredRoutes: [/\.ico$/i],
+      useAppRoutes: true,
+      ...options
+    };
+    if (!this._options.ignoredRoutes.length && !this._options.useAppRoutes) {
+      throw new Error("You must provide either `ignoredRoutes` or `useAppRoutes`");
+    }
+    if (this._options.useAppRoutes) {
+      this._setupEvents();
+    }
+  }
+  /**
+   * Generates the middleware that serves the HTML file.
+   */
+  getMiddleware() {
+    return async (req, res, next) => {
+      if (this._shouldIgnoreRoute(req.originalUrl)) {
+        next();
+        return;
+      }
+      if (this._fileReady) {
+        this._sendResponse(res, next);
+        return;
+      }
+      const htmlGenerator = this._getHTMLGenerator();
+      if (!htmlGenerator) {
+        this._fileReady = true;
+        this._sendResponse(res, next);
+        return;
+      }
+      try {
+        await htmlGenerator.whenReady();
+        this._options.file = htmlGenerator.options.file;
+        this._fileReady = true;
+        this._sendResponse(res, next);
+      } catch (error) {
+        next(error);
+      }
+    };
+  }
+  /**
+   * The customization options.
+   */
+  get options() {
+    return { ...this._options };
+  }
+  /**
+   * Serves the HTML file to the response.
+   *
+   * @param res   The response object generated by the application.
+   * @param next  The function to call the next middleware.
+   */
+  _sendResponse(res, next) {
+    res.setHeader("Content-Type", "text/html");
+    this._sendFile({
+      res,
+      next,
+      filepath: this._options.file
+    });
+  }
+  /**
+   * Adds the event listener that obtains the list of "controlled routes" when
+   * `useAppRoutes` is set to `true`.
+   */
+  _setupEvents() {
+    this._events.once("afterStart", ({ app }) => {
+      const [routeExpressions] = app.routes.reduce(
+        (acc, route) => {
+          const [expressions, processed] = acc;
+          const clean = (0, import_utils.removeSlashes)(route).trim();
+          if (!clean || processed.includes(clean))
+            return acc;
+          expressions.push((0, import_utils.createRouteExpression)(clean));
+          processed.push(clean);
+          return acc;
+        },
+        [[], []]
+      );
+      this._routeExpressions.push(...routeExpressions);
+    });
+  }
+  /**
+   * Validates whether a route should be ignored or not. The method checks first against
+   * the `ignore` option, and then against the list of "controlled routes" if
+   * `useAppRoutes` is set to `true`.
+   *
+   * @param route  The route to validate.
+   */
+  _shouldIgnoreRoute(route) {
+    return this._options.ignoredRoutes.some((expression) => route.match(expression)) || this._routeExpressions.some((expression) => route.match(expression));
+  }
+}
+const fastHTMLMiddleware = (0, import_utils.middlewareCreator)(
+  (options = {}) => (app) => {
+    const { htmlGeneratorServiceName = "htmlGenerator", ...rest } = options;
+    return new FastHTML({
+      inject: {
+        events: app.get("events"),
+        sendFile: app.get("sendFile"),
+        getHTMLGenerator: () => app.try(htmlGeneratorServiceName)
+      },
+      ...rest
+    }).getMiddleware();
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FastHTML,
+  fastHTMLMiddleware
+});
+//# sourceMappingURL=fastHTML.js.map

package/dist/middlewares/html/fastHTML.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/middlewares/html/fastHTML.ts"],"sourcesContent":["import { createRouteExpression, middlewareCreator, removeSlashes } from '../../utils';\nimport type { HTMLGenerator, SendFile } from '../../services';\nimport type { AsyncExpressMiddleware, Response, NextFunction, Events } from '../../types';\n/**\n * The options to customize the behavior of the middleware.\n *\n * @group Middlewares/FastHTML\n */\nexport type FastHTMLOptions = {\n  /**\n   * The name of the file the middleware will serve. If the {@link HTMLGenerator} service\n   * is available, it will be overriden by the service.\n   *\n   * @default 'index.html'\n   */\n  file: string;\n  /**\n   * A list of regular expressions to match request paths that should be ignored by the\n   * middleware.\n   *\n   * @default [/\\.ico$/i]\n   */\n  ignoredRoutes: RegExp[];\n  /**\n   * If `true`, {@link FastHTML} will get the list of all the routes controlled by the\n   * application, and will use them to validate the incoming requests (in addition to the\n   * `ignore` list): If a request URL doesn't match with any of the \"controlled routes\",\n   * it will serve the HTML file.\n   *\n   * @default true\n   */\n  useAppRoutes: boolean;\n};\n/**\n * The options to construct a {@link FastHTML}.\n *\n * @group Middlewares/FastHTML\n */\nexport type FastHTMLConstructorOptions = Partial<FastHTMLOptions> & {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    sendFile: SendFile;\n    events: Events;\n    /**\n     * A function to get a possible {@link HTMLGenerator}. This is injected as a \"getter\"\n     * to not interrupt the DIC \"lifecycle\": middlewares are initialized right when the\n     * app starts, and injecting a reference would force the service to be initialized\n     * too, even if a request is not being made.\n     */\n    getHTMLGenerator?: () => HTMLGenerator | undefined;\n  };\n};\n/**\n * The options for the middleware creator that will mount an instance of {@link FastHTML}.\n *\n * @group Middlewares/FastHTML\n */\nexport type FastHTMLMiddlewareOptions = Partial<FastHTMLOptions> & {\n  /**\n   * The name of an {@link HTMLGenerator} service already available in the application.\n   *\n   * @default 'htmlGenerator'\n   */\n  htmlGeneratorServiceName?: string;\n};\n/**\n * It's common for an app to show an HTML view when no route was able to handle a request,\n * so the idea behind this middleware is to avoid going to every middleware and controller\n * and just specify that if the request is not for a route handled by a controller, just\n * serve the HTML and avoid processing unnecessary data.\n *\n * A simple example: The app has a route `/backend` that a frontend uses to get\n * information.\n * This middleware can be used to only allow the execution of middlewares and controllers\n * when the request route is for `/backend`.\n *\n * **Disclaimer**: Managing statics files with Express is not a best practice, but there\n * are scenarios where there is not other choice.\n *\n * @group Middleware Classes\n * @group Middlewares/FastHTML\n * @prettierignore\n */\nexport class FastHTML {\n  /**\n   * The service that serves a file.\n   */\n  protected readonly _sendFile: SendFile;\n  /**\n   * The application envent bus, to listen and get the list of \"controlled routes\" after\n   * the application is started.\n   */\n  protected readonly _events: Events;\n  /**\n   * A function to get a possible {@link HTMLGenerator}. This is injected as a \"getter\"\n   * to not interrupt the DIC \"lifecycle\": middlewares are initialized right when the\n   * app starts, and injecting a reference would force the service to be initialized\n   * too, even if a request is not being made.\n   */\n  protected readonly _getHTMLGenerator: () => HTMLGenerator | undefined;\n  /**\n   * The customization options for the middleware.\n   */\n  protected _options: FastHTMLOptions;\n  /**\n   * Whether or not the file is ready to be served. In case the middleware uses an\n   * {@link HTMLGenerator} service, the file needs to be generated before being available,\n   * and that's why this flag exists.\n   */\n  protected _fileReady: boolean = false;\n  /**\n   * A list of regular expression that match the routes controlled by the application.\n   * This is in case the `useAppRoutes` option is set to `true`; when the application gets\n   * started, an event listener will obtain all the top controlled routes, create regular\n   * expressions, and save them on this property.\n   */\n  protected _routeExpressions: RegExp[] = [];\n  /**\n   * @param options  The options to construct the class.\n   * @throws If `ignoredRoutes` is empty and `useAppRoutes` is set to `false`.\n   */\n  constructor({ inject, ...options }: FastHTMLConstructorOptions) {\n    this._sendFile = inject.sendFile;\n    this._events = inject.events;\n    this._getHTMLGenerator = inject.getHTMLGenerator || (() => undefined);\n    this._options = {\n      file: 'index.html',\n      ignoredRoutes: [/\\.ico$/i],\n      useAppRoutes: true,\n      ...options,\n    };\n\n    if (!this._options.ignoredRoutes.length && !this._options.useAppRoutes) {\n      throw new Error('You must provide either `ignoredRoutes` or `useAppRoutes`');\n    }\n\n    if (this._options.useAppRoutes) {\n      this._setupEvents();\n    }\n  }\n  /**\n   * Generates the middleware that serves the HTML file.\n   */\n  getMiddleware(): AsyncExpressMiddleware {\n    return async (req, res, next) => {\n      // If the route should be ignored, move to the next middleware.\n      if (this._shouldIgnoreRoute(req.originalUrl)) {\n        next();\n        return;\n      }\n\n      // If the file is ready to be served, serve it.\n      if (this._fileReady) {\n        this._sendResponse(res, next);\n        return;\n      }\n\n      const htmlGenerator = this._getHTMLGenerator();\n      // If there's no generator, switch the flag and just serve the file.\n      if (!htmlGenerator) {\n        this._fileReady = true;\n        this._sendResponse(res, next);\n        return;\n      }\n\n      try {\n        // Wait for the HTML to be generated.\n        await htmlGenerator.whenReady();\n        // Update the local option.\n        this._options.file = htmlGenerator.options.file;\n        // Switch the flag and serve the file.\n        this._fileReady = true;\n        this._sendResponse(res, next);\n      } catch (error) {\n        next(error);\n      }\n    };\n  }\n  /**\n   * The customization options.\n   */\n  get options(): Readonly<FastHTMLOptions> {\n    return { ...this._options };\n  }\n  /**\n   * Serves the HTML file to the response.\n   *\n   * @param res   The response object generated by the application.\n   * @param next  The function to call the next middleware.\n   */\n  protected _sendResponse(res: Response, next: NextFunction): void {\n    res.setHeader('Content-Type', 'text/html');\n    this._sendFile({\n      res,\n      next,\n      filepath: this._options.file,\n    });\n  }\n  /**\n   * Adds the event listener that obtains the list of \"controlled routes\" when\n   * `useAppRoutes` is set to `true`.\n   */\n  protected _setupEvents() {\n    this._events.once('afterStart', ({ app }) => {\n      const [routeExpressions] = app.routes.reduce<[RegExp[], string[]]>(\n        (acc, route) => {\n          const [expressions, processed] = acc;\n          const clean = removeSlashes(route).trim();\n          if (!clean || processed.includes(clean)) return acc;\n          expressions.push(createRouteExpression(clean));\n          processed.push(clean);\n          return acc;\n        },\n        [[], []],\n      );\n      this._routeExpressions.push(...routeExpressions);\n    });\n  }\n  /**\n   * Validates whether a route should be ignored or not. The method checks first against\n   * the `ignore` option, and then against the list of \"controlled routes\" if\n   * `useAppRoutes` is set to `true`.\n   *\n   * @param route  The route to validate.\n   */\n  protected _shouldIgnoreRoute(route: string): boolean {\n    return (\n      this._options.ignoredRoutes.some((expression) => route.match(expression)) ||\n      this._routeExpressions.some((expression) => route.match(expression))\n    );\n  }\n}\n/**\n * Creates the middleware that filters the routes and serves an HTML before the\n * application gets to evaluate whether there's a controller for the request or not.\n *\n * @group Middlewares\n * @group Middlewares/FastHTML\n */\nexport const fastHTMLMiddleware = middlewareCreator(\n  (options: FastHTMLMiddlewareOptions = {}) =>\n    (app) => {\n      const { htmlGeneratorServiceName = 'htmlGenerator', ...rest } = options;\n      return new FastHTML({\n        inject: {\n          events: app.get('events'),\n          sendFile: app.get('sendFile'),\n          getHTMLGenerator: () => app.try(htmlGeneratorServiceName),\n        },\n        ...rest,\n      }).getMiddleware();\n    },\n);\n"],"mappings":"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","names":[]}

package/dist/middlewares/html/index.d.mts

@@ -0,0 +1,21 @@
+export { FastHTML, FastHTMLConstructorOptions, FastHTMLMiddlewareOptions, FastHTMLOptions, fastHTMLMiddleware } from './fastHTML.mjs';
+export { ShowHTML, ShowHTMLConstructorOptions, ShowHTMLMiddlewareOptions, ShowHTMLOptions, showHTMLMiddleware } from './showHTML.mjs';
+import '@homer0/jimple';
+import '../../index-efeb437e.js';
+import '../../types/express.mjs';
+import 'express';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.mjs';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import '../../services/common/sendFile.mjs';
+import '../../services/html/htmlGenerator.mjs';
+import '../../services/frontend/frontendFs.mjs';
+import 'fs/promises';
+import '@homer0/deferred';

package/dist/middlewares/html/index.d.ts

@@ -0,0 +1,21 @@
+export { FastHTML, FastHTMLConstructorOptions, FastHTMLMiddlewareOptions, FastHTMLOptions, fastHTMLMiddleware } from './fastHTML.js';
+export { ShowHTML, ShowHTMLConstructorOptions, ShowHTMLMiddlewareOptions, ShowHTMLOptions, showHTMLMiddleware } from './showHTML.js';
+import '@homer0/jimple';
+import '../../index-b2a04c78.js';
+import '../../types/express.js';
+import 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.js';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import '../../services/common/sendFile.js';
+import '../../services/html/htmlGenerator.js';
+import '../../services/frontend/frontendFs.js';
+import 'fs/promises';
+import '@homer0/deferred';

package/dist/middlewares/html/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var html_exports = {};
+module.exports = __toCommonJS(html_exports);
+__reExport(html_exports, require("./fastHTML"), module.exports);
+__reExport(html_exports, require("./showHTML"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./fastHTML"),
+  ...require("./showHTML")
+});
+//# sourceMappingURL=index.js.map

package/dist/middlewares/html/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/middlewares/html/index.ts"],"sourcesContent":["export * from './fastHTML';\nexport * from './showHTML';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,yBAAc,uBAAd;AACA,yBAAc,uBADd;","names":[]}