jimpex 10.0.2 → 11.0.0

package/dist/esm/middlewares/utils/versionValidator.js

@@ -1,135 +0,0 @@
-import {
-  __publicField
-} from "../../chunk-V6TY7KAL.js";
-import { deepAssignWithOverwrite } from "@homer0/deep-assign";
-import { middlewareCreator } from "../../utils";
-class VersionValidator {
-  /**
-   * @param options  The options to construct the class.
-   * @throws If no `version` is specified in the options.
-   */
-  constructor({ inject, version, ...options }) {
-    /**
-     * To generate the errors in case the validation fails.
-     */
-    __publicField(this, "_HTTPError");
-    /**
-     * To generate responses for popups.
-     */
-    __publicField(this, "_responsesBuilder");
-    /**
-     * The uility service to get HTTP status codes.
-     */
-    __publicField(this, "_statuses");
-    /**
-     * The customization options.
-     */
-    __publicField(this, "_options");
-    this._HTTPError = inject.HTTPError;
-    this._responsesBuilder = inject.responsesBuilder;
-    this._statuses = inject.statuses;
-    this._options = deepAssignWithOverwrite(
-      {
-        error: "The application version doesn't match",
-        latest: {
-          allow: true,
-          name: "latest"
-        },
-        popup: {
-          variable: "popup",
-          title: "Conflict",
-          message: "vesion:conflict"
-        },
-        version
-      },
-      options
-    );
-    if (!this._options.version) {
-      throw new Error("You need to supply a version");
-    }
-  }
-  /**
-   * Generates the middleware that validates the version.
-   */
-  getMiddleware() {
-    return (req, res, next) => {
-      const { version } = req.params;
-      if (!version) {
-        next();
-        return;
-      }
-      if (version === this._options.version || this._isTheAllowedLatest(version)) {
-        next();
-        return;
-      }
-      const status = this._statuses("conflict");
-      if (this._isPopup(req)) {
-        const { title, message } = this._options.popup;
-        this._responsesBuilder.htmlPostMessage({
-          res,
-          title,
-          message,
-          status
-        });
-        return;
-      }
-      next(
-        new this._HTTPError(this._options.error, status, {
-          response: {
-            validation: true
-          }
-        })
-      );
-    };
-  }
-  /**
-   * The customization options.
-   */
-  get options() {
-    return deepAssignWithOverwrite({}, this._options);
-  }
-  /**
-   * Helper method that checks if the incoming request is from a popup. It will look for
-   * the query string variable defined in the constructor options.
-   *
-   * @param req  The request object sent by the application.
-   */
-  _isPopup(req) {
-    const popup = req.query[this._options.popup.variable];
-    return !!(popup && String(popup).toLowerCase() === "true");
-  }
-  /**
-   * Helper method that checks if the "latest version" is enabled and if the given version
-   * is "the latest" (comparing it with the option name).
-   *
-   * @param version  The version received in the request.
-   */
-  _isTheAllowedLatest(version) {
-    const { allow, name } = this._options.latest;
-    return allow && version === name;
-  }
-}
-const versionValidatorMiddleware = middlewareCreator(
-  (options = {}) => (app, route) => {
-    const version = app.getConfig("version");
-    const middleware = new VersionValidator({
-      inject: {
-        HTTPError: app.get("HTTPError"),
-        responsesBuilder: app.get("responsesBuilder"),
-        statuses: app.get("statuses")
-      },
-      version,
-      ...options
-    }).getMiddleware();
-    if (route) {
-      const router = app.getRouter();
-      return router.all("/:version/*", middleware);
-    }
-    return middleware;
-  }
-);
-export {
-  VersionValidator,
-  versionValidatorMiddleware
-};
-//# sourceMappingURL=versionValidator.js.map

package/dist/esm/middlewares/utils/versionValidator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/middlewares/utils/versionValidator.ts"],"sourcesContent":["import { deepAssignWithOverwrite } from '@homer0/deep-assign';\nimport { middlewareCreator, type Statuses } from '../../utils';\nimport { DeepPartial, Request, ExpressMiddleware } from '../../types';\nimport type { HTTPErrorClass, ResponsesBuilder } from '../../services';\n/**\n * The options for how the middleware should behave if the requested version is `latest`.\n *\n * @group Middlewares/VersionValidator\n */\nexport type VersionValidatorLatestOptions = {\n  /**\n   * Whether or not the middleware should validate the _\"latest version\"_.\n   *\n   * @default true\n   */\n  allow: boolean;\n  /**\n   * The name of the _\"latest version\"_. Basically, `req.params.version` must match with\n   * this property in order to be consider \"latest\".\n   *\n   * @default 'latest'\n   */\n  name: string;\n};\n/**\n * The options for how to detect if the request comes from a popup and how to compose the\n * post message the middleware will use to respond.\n *\n * @group Middlewares/VersionValidator\n */\nexport type VersionValidatorPopupOptions = {\n  /**\n   * The name of the query string variable the middleware will check in order to indentify\n   * whether the request comes from a popup or not. The variable must have `'true'` as its\n   * value.\n   *\n   * @default 'popup'\n   */\n  variable: string;\n  /**\n   * The title of the page that will be generated to respond in case the versions don't\n   * match.\n   *\n   * @default 'Conflict'\n   */\n  title: string;\n  /**\n   * The contents of the post message the generated page will send if the versions don't\n   * match.\n   *\n   * @default 'version:conflict'\n   */\n  message: string;\n};\n/**\n * The options used to customize a {@link VersionValidator} instance.\n *\n * @group Middlewares/VersionValidator\n */\nexport type VersionValidatorOptions = {\n  /**\n   * The version used to validate the requests.\n   */\n  version: string;\n  /**\n   * The options for how the middleware should behave if the requested version is\n   * `latest`.\n   */\n  latest: VersionValidatorLatestOptions;\n  /**\n   * The options for how to detect if the request comes from a popup and how to compose\n   * the post message the middleware will use to respond.\n   */\n  popup: VersionValidatorPopupOptions;\n  /**\n   * The error message to show when the version is invalid.\n   *\n   * @default \"The application version doesn't match\"\n   * @prettierignore\n   */\n  error: string;\n};\n/**\n * A partial version of the {@link VersionValidatorOptions}, to be used in the constructor\n * and the middleware creator. The reason it omits `version` it's because for the\n * constructor it's required, but for the middleware creator it's not.\n *\n * @group Middlewares/VersionValidator\n */\nexport type VersionValidatorPartialOptions = DeepPartial<\n  Omit<VersionValidatorOptions, 'version'>\n>;\n/**\n * The options to construct a {@link VersionValidator}.\n *\n * @group Middlewares/VersionValidator\n */\nexport type VersionValidatorConstructorOptions = VersionValidatorPartialOptions & {\n  /**\n   * The version used to validate the requests.\n   */\n  version: string;\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    HTTPError: HTTPErrorClass;\n    responsesBuilder: ResponsesBuilder;\n    statuses: Statuses;\n  };\n};\n/**\n * The options for the middleware creator that will mount an instance of\n * {@link VersionValidator}.\n *\n * @group Middlewares/VersionValidator\n */\nexport type VersionValidatorMiddlewareOptions = VersionValidatorPartialOptions & {\n  /**\n   * The version used to validate the requests. This is optional in here because if it's\n   * not specified, it will be obtained from the configuration service.\n   */\n  version?: string;\n};\n/**\n * This is the handler for the middleware/controller that validates the application\n * version.\n * This is useful in cases where you want to restrict the access to specific versions; for\n * example: you have a frontend which needs to be aligned with the \"current\" version of\n * the application, since the frontend won't realize a new version was released, the\n * validator can be used to let the frontend know.\n * Also, it can be configured to handle requests from popups, in which case, instead of\n * generating an error message, it will send a post message.\n *\n * @group Middleware Classes\n * @group Middlewares/VersionValidator\n * @prettierignore\n */\nexport class VersionValidator {\n  /**\n   * To generate the errors in case the validation fails.\n   */\n  protected readonly _HTTPError: HTTPErrorClass;\n  /**\n   * To generate responses for popups.\n   */\n  protected readonly _responsesBuilder: ResponsesBuilder;\n  /**\n   * The uility service to get HTTP status codes.\n   */\n  protected readonly _statuses: Statuses;\n  /**\n   * The customization options.\n   */\n  protected readonly _options: VersionValidatorOptions;\n  /**\n   * @param options  The options to construct the class.\n   * @throws If no `version` is specified in the options.\n   */\n  constructor({ inject, version, ...options }: VersionValidatorConstructorOptions) {\n    this._HTTPError = inject.HTTPError;\n    this._responsesBuilder = inject.responsesBuilder;\n    this._statuses = inject.statuses;\n    this._options = deepAssignWithOverwrite(\n      {\n        error: \"The application version doesn't match\",\n        latest: {\n          allow: true,\n          name: 'latest',\n        },\n        popup: {\n          variable: 'popup',\n          title: 'Conflict',\n          message: 'vesion:conflict',\n        },\n        version,\n      },\n      options,\n    );\n\n    if (!this._options.version) {\n      throw new Error('You need to supply a version');\n    }\n  }\n  /**\n   * Generates the middleware that validates the version.\n   */\n  getMiddleware(): ExpressMiddleware {\n    return (req, res, next) => {\n      // Get the `version` parameter from the request.\n      const { version } = req.params;\n      // If no version is present, move on to the next middleware.\n      if (!version) {\n        next();\n        return;\n      }\n      // If the version matches, or it's a \"latest\" version, move on to the next middleware.\n      if (version === this._options.version || this._isTheAllowedLatest(version)) {\n        next();\n        return;\n      }\n\n      const status = this._statuses('conflict');\n      // If the request comes from a popup, send the post message.\n      if (this._isPopup(req)) {\n        const { title, message } = this._options.popup;\n        this._responsesBuilder.htmlPostMessage({\n          res,\n          title,\n          message,\n          status,\n        });\n        return;\n      }\n\n      // Every other validation failed, and it's not a popup, so generate an error.\n      next(\n        new this._HTTPError(this._options.error, status, {\n          response: {\n            validation: true,\n          },\n        }),\n      );\n    };\n  }\n  /**\n   * The customization options.\n   */\n  get options(): Readonly<VersionValidatorOptions> {\n    return deepAssignWithOverwrite({}, this._options);\n  }\n  /**\n   * Helper method that checks if the incoming request is from a popup. It will look for\n   * the query string variable defined in the constructor options.\n   *\n   * @param req  The request object sent by the application.\n   */\n  protected _isPopup(req: Request): boolean {\n    const popup = req.query[this._options.popup.variable];\n    return !!(popup && String(popup).toLowerCase() === 'true');\n  }\n  /**\n   * Helper method that checks if the \"latest version\" is enabled and if the given version\n   * is \"the latest\" (comparing it with the option name).\n   *\n   * @param version  The version received in the request.\n   */\n  protected _isTheAllowedLatest(version: string): boolean {\n    const { allow, name } = this._options.latest;\n    return allow && version === name;\n  }\n}\n/**\n * A middleware that will validate a `version` request parameter against the application\n * version, and generate an error if they don't match.\n * This is a \"middleware/controller\" because the wrappers for both are the same, the\n * difference is that, for controllers, Jimpex sends a second parameter with the route\n * where they are mounted.\n * By validating the route parameter, the function can know whether the implementation is\n * going to use the middleware by itself or as a route middleware.\n * If used as middleware, it will just return the result of\n * {@link VersionValidator.getMiddleware}; but if used as controller, it will mount it on\n * `[route]/:version/*`.\n *\n * @group Middlewares\n * @group Middlewares/VersionValidator\n */\nexport const versionValidatorMiddleware = middlewareCreator(\n  (options: VersionValidatorMiddlewareOptions = {}) =>\n    (app, route) => {\n      const version = app.getConfig<string>('version');\n      const middleware = new VersionValidator({\n        inject: {\n          HTTPError: app.get('HTTPError'),\n          responsesBuilder: app.get('responsesBuilder'),\n          statuses: app.get('statuses'),\n        },\n        version,\n        ...options,\n      }).getMiddleware();\n\n      if (route) {\n        const router = app.getRouter();\n        return router.all('/:version/*', middleware);\n      }\n\n      return middleware;\n    },\n);\n"],"mappings":";;;AAAA,SAAS,+BAA+B;AACxC,SAAS,yBAAwC;AAyI1C,MAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA,EAqB5B,YAAY,EAAE,QAAQ,SAAS,GAAG,QAAQ,GAAuC;AAjBjF;AAAA;AAAA;AAAA,wBAAmB;AAInB;AAAA;AAAA;AAAA,wBAAmB;AAInB;AAAA;AAAA;AAAA,wBAAmB;AAInB;AAAA;AAAA;AAAA,wBAAmB;AAMjB,SAAK,aAAa,OAAO;AACzB,SAAK,oBAAoB,OAAO;AAChC,SAAK,YAAY,OAAO;AACxB,SAAK,WAAW;AAAA,MACd;AAAA,QACE,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,OAAO;AAAA,UACP,MAAM;AAAA,QACR;AAAA,QACA,OAAO;AAAA,UACL,UAAU;AAAA,UACV,OAAO;AAAA,UACP,SAAS;AAAA,QACX;AAAA,QACA;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAEA,QAAI,CAAC,KAAK,SAAS,SAAS;AAC1B,YAAM,IAAI,MAAM,8BAA8B;AAAA,IAChD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAIA,gBAAmC;AACjC,WAAO,CAAC,KAAK,KAAK,SAAS;AAEzB,YAAM,EAAE,QAAQ,IAAI,IAAI;AAExB,UAAI,CAAC,SAAS;AACZ,aAAK;AACL;AAAA,MACF;AAEA,UAAI,YAAY,KAAK,SAAS,WAAW,KAAK,oBAAoB,OAAO,GAAG;AAC1E,aAAK;AACL;AAAA,MACF;AAEA,YAAM,SAAS,KAAK,UAAU,UAAU;AAExC,UAAI,KAAK,SAAS,GAAG,GAAG;AACtB,cAAM,EAAE,OAAO,QAAQ,IAAI,KAAK,SAAS;AACzC,aAAK,kBAAkB,gBAAgB;AAAA,UACrC;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AACD;AAAA,MACF;AAGA;AAAA,QACE,IAAI,KAAK,WAAW,KAAK,SAAS,OAAO,QAAQ;AAAA,UAC/C,UAAU;AAAA,YACR,YAAY;AAAA,UACd;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAA6C;AAC/C,WAAO,wBAAwB,CAAC,GAAG,KAAK,QAAQ;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,SAAS,KAAuB;AACxC,UAAM,QAAQ,IAAI,MAAM,KAAK,SAAS,MAAM,QAAQ;AACpD,WAAO,CAAC,EAAE,SAAS,OAAO,KAAK,EAAE,YAAY,MAAM;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,oBAAoB,SAA0B;AACtD,UAAM,EAAE,OAAO,KAAK,IAAI,KAAK,SAAS;AACtC,WAAO,SAAS,YAAY;AAAA,EAC9B;AACF;AAgBO,MAAM,6BAA6B;AAAA,EACxC,CAAC,UAA6C,CAAC,MAC7C,CAAC,KAAK,UAAU;AACd,UAAM,UAAU,IAAI,UAAkB,SAAS;AAC/C,UAAM,aAAa,IAAI,iBAAiB;AAAA,MACtC,QAAQ;AAAA,QACN,WAAW,IAAI,IAAI,WAAW;AAAA,QAC9B,kBAAkB,IAAI,IAAI,kBAAkB;AAAA,QAC5C,UAAU,IAAI,IAAI,UAAU;AAAA,MAC9B;AAAA,MACA;AAAA,MACA,GAAG;AAAA,IACL,CAAC,EAAE,cAAc;AAEjB,QAAI,OAAO;AACT,YAAM,SAAS,IAAI,UAAU;AAC7B,aAAO,OAAO,IAAI,eAAe,UAAU;AAAA,IAC7C;AAEA,WAAO;AAAA,EACT;AACJ;","names":[]}

package/dist/esm/services/common/appError.js

@@ -1,98 +0,0 @@
-import {
-  __publicField
-} from "../../chunk-V6TY7KAL.js";
-import { provider, statuses as statusesFn } from "../../utils";
-class AppError extends Error {
-  /**
-   * @param message   The message of the error.
-   * @param context   The context information, for the error handler.
-   * @param statuses  A reference to the service that generates HTTP status codes. This
-   *                  is in case the implementation wants to use a special version from
-   *                  the container; otherwise, it will use the `statuses` library
-   *                  directly.
-   */
-  constructor(message, context = {}, statuses = statusesFn) {
-    super(message);
-    /**
-     * The date of when the error was generated.
-     */
-    __publicField(this, "_date");
-    /**
-     * The context information that can be provided to the error, and picked by the error
-     * handler.
-     */
-    __publicField(this, "_context");
-    /**
-     * The service that generates HTTP status codes.
-     */
-    __publicField(this, "_statuses");
-    this.name = this.constructor.name;
-    this._date = /* @__PURE__ */ new Date();
-    this._statuses = statuses;
-    this._context = this._parseContext(context);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  /**
-   * Gets an object that can be included in a response from the application. This method
-   * is a helper for the `response` getter, as it allows for the assertion of the response
-   * type.
-   *
-   * @template T  The type of the response.
-   */
-  getResponse() {
-    return this.response;
-  }
-  /**
-   * Information about the error that can be included in a response. This is set using the
-   * `response` key in the `context` option.
-   */
-  get response() {
-    return this._context.response || {};
-  }
-  /**
-   * An HTTP status code related to the error. This is set using the `status` key on the
-   * `context`.
-   */
-  get status() {
-    return this._context.status;
-  }
-  /**
-   * Context information related to the error.
-   */
-  get context() {
-    return this._context;
-  }
-  /**
-   * The date of when the error was generated.
-   */
-  get date() {
-    return this._date;
-  }
-  /**
-   * Utility method that formats the context before saving it in the instance:
-   * - If the context includes a `status` as a `string`, it will try to replace it with
-   * its actual status code from the `statuses `service.
-   *
-   * @param context  The original context sent to the constructor.
-   */
-  _parseContext(context) {
-    const result = { ...context };
-    if (result.status && typeof result.status === "string") {
-      result.status = this._statuses.code[result.status.toLowerCase()] || result.status;
-    }
-    return result;
-  }
-}
-const createAppError = (...args) => new AppError(...args);
-const appErrorProvider = provider((app) => {
-  app.set("AppError", () => AppError);
-  app.set("appError", () => createAppError);
-});
-export {
-  AppError,
-  appErrorProvider,
-  createAppError
-};
-//# sourceMappingURL=appError.js.map

package/dist/esm/services/common/appError.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/services/common/appError.ts"],"sourcesContent":["import { provider, statuses as statusesFn, type Statuses } from '../../utils';\n/**\n * A dictionary with some context information that can be provided to {@link AppError}.\n *\n * @group Services/AppError\n */\nexport type AppErrorContext = {\n  /**\n   * Extra information that the error handler can pick and include the response.\n   */\n  response?: unknown;\n  /**\n   * A status code or name for the error handler to set in the response.\n   */\n  status?: string | number;\n} & Record<string, unknown>;\n/**\n * A simple subclass of `Error` but with support for context information.\n *\n * @group Services\n * @group Services/AppError\n */\nexport class AppError extends Error {\n  /**\n   * The date of when the error was generated.\n   */\n  readonly _date: Date;\n  /**\n   * The context information that can be provided to the error, and picked by the error\n   * handler.\n   */\n  readonly _context: AppErrorContext;\n  /**\n   * The service that generates HTTP status codes.\n   */\n  protected _statuses: Statuses;\n  /**\n   * @param message   The message of the error.\n   * @param context   The context information, for the error handler.\n   * @param statuses  A reference to the service that generates HTTP status codes. This\n   *                  is in case the implementation wants to use a special version from\n   *                  the container; otherwise, it will use the `statuses` library\n   *                  directly.\n   */\n  constructor(\n    message: string,\n    context: AppErrorContext = {},\n    statuses: Statuses = statusesFn,\n  ) {\n    super(message);\n    this.name = this.constructor.name;\n    this._date = new Date();\n    this._statuses = statuses;\n    this._context = this._parseContext(context);\n\n    // Limit the stack trace if possible.\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n  /**\n   * Gets an object that can be included in a response from the application. This method\n   * is a helper for the `response` getter, as it allows for the assertion of the response\n   * type.\n   *\n   * @template T  The type of the response.\n   */\n  getResponse<T>(): T {\n    return this.response as T;\n  }\n  /**\n   * Information about the error that can be included in a response. This is set using the\n   * `response` key in the `context` option.\n   */\n  get response(): unknown {\n    return this._context.response || {};\n  }\n  /**\n   * An HTTP status code related to the error. This is set using the `status` key on the\n   * `context`.\n   */\n  get status(): number | undefined {\n    return this._context.status as number | undefined;\n  }\n  /**\n   * Context information related to the error.\n   */\n  get context(): unknown {\n    return this._context;\n  }\n  /**\n   * The date of when the error was generated.\n   */\n  get date(): Date {\n    return this._date;\n  }\n  /**\n   * Utility method that formats the context before saving it in the instance:\n   * - If the context includes a `status` as a `string`, it will try to replace it with\n   * its actual status code from the `statuses `service.\n   *\n   * @param context  The original context sent to the constructor.\n   */\n  protected _parseContext(context: AppErrorContext): AppErrorContext {\n    const result = { ...context };\n    if (result.status && typeof result.status === 'string') {\n      result.status = this._statuses.code[result.status.toLowerCase()] || result.status;\n    }\n\n    return result;\n  }\n}\n/**\n * Shorthand for `new AppError()`.\n *\n * @param args  The same parameters as the {@link AppError} constructor.\n * @returns A new instance of {@link AppError}.\n * @group Services\n * @group Services/AppError\n */\nexport const createAppError = (\n  ...args: ConstructorParameters<typeof AppError>\n): AppError => new AppError(...args);\n/**\n * The type of the function that generates a new instance of {@link AppError}.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/AppError\n */\nexport type CreateAppErrorFn = typeof createAppError;\n/**\n * THe type of the {@link AppError} class.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/AppError\n */\nexport type AppErrorClass = typeof AppError;\n/**\n * A service provider that will register both, {@link AppError} and\n * {@link createAppError}, on the container. `AppError` will be the key for class, and\n * `appError` will be for the generator function.\n *\n * @example\n *\n *   // Register it on the container\n *   container.register(appErrorProvider);\n *   // Getting access to the class.\n *   const AppError = container.get<AppErrorClass>('AppError');\n *   // Getting access to the function.\n *   const appError = container.get<CreateAppErrorFn>('appError');\n *\n * @group Providers\n * @group Services/AppError\n */\nexport const appErrorProvider = provider((app) => {\n  app.set('AppError', () => AppError);\n  app.set('appError', () => createAppError);\n});\n"],"mappings":";;;AAAA,SAAS,UAAU,YAAY,kBAAiC;AAsBzD,MAAM,iBAAiB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBlC,YACE,SACA,UAA2B,CAAC,GAC5B,WAAqB,YACrB;AACA,UAAM,OAAO;AAvBf;AAAA;AAAA;AAAA,wBAAS;AAKT;AAAA;AAAA;AAAA;AAAA,wBAAS;AAIT;AAAA;AAAA;AAAA,wBAAU;AAeR,SAAK,OAAO,KAAK,YAAY;AAC7B,SAAK,QAAQ,oBAAI,KAAK;AACtB,SAAK,YAAY;AACjB,SAAK,WAAW,KAAK,cAAc,OAAO;AAG1C,QAAI,MAAM,mBAAmB;AAC3B,YAAM,kBAAkB,MAAM,KAAK,WAAW;AAAA,IAChD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,cAAoB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,WAAoB;AACtB,WAAO,KAAK,SAAS,YAAY,CAAC;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,SAA6B;AAC/B,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAAmB;AACrB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,OAAa;AACf,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,cAAc,SAA2C;AACjE,UAAM,SAAS,EAAE,GAAG,QAAQ;AAC5B,QAAI,OAAO,UAAU,OAAO,OAAO,WAAW,UAAU;AACtD,aAAO,SAAS,KAAK,UAAU,KAAK,OAAO,OAAO,YAAY,CAAC,KAAK,OAAO;AAAA,IAC7E;AAEA,WAAO;AAAA,EACT;AACF;AASO,MAAM,iBAAiB,IACzB,SACU,IAAI,SAAS,GAAG,IAAI;AAgC5B,MAAM,mBAAmB,SAAS,CAAC,QAAQ;AAChD,MAAI,IAAI,YAAY,MAAM,QAAQ;AAClC,MAAI,IAAI,YAAY,MAAM,cAAc;AAC1C,CAAC;","names":[]}

package/dist/esm/services/common/httpError.js

@@ -1,28 +0,0 @@
-import "../../chunk-V6TY7KAL.js";
-import { provider, statuses as statusesFn } from "../../utils";
-import { AppError } from "./appError";
-class HTTPError extends AppError {
-  /**
-   * @param message   The error message.
-   * @param status    The HTTP status code.
-   * @param context   Context information related to the error.
-   * @param statuses  A reference to the service that generates HTTP status codes. This
-   *                  is in case the implementation wants to use a special version from
-   *                  the container; otherwise, it will use the `statuses` library
-   *                  directly.
-   */
-  constructor(message, status = statusesFn("ok"), context = {}, statuses = statusesFn) {
-    super(message, { ...context, status }, statuses);
-  }
-}
-const createHTTPError = (...args) => new HTTPError(...args);
-const httpErrorProvider = provider((app) => {
-  app.set("HTTPError", () => HTTPError);
-  app.set("httpError", () => createHTTPError);
-});
-export {
-  HTTPError,
-  createHTTPError,
-  httpErrorProvider
-};
-//# sourceMappingURL=httpError.js.map

package/dist/esm/services/common/httpError.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/services/common/httpError.ts"],"sourcesContent":["import { provider, statuses as statusesFn, type Statuses } from '../../utils';\nimport { AppError, type AppErrorContext } from './appError';\n/**\n * A type of error to be used on HTTP requests. This is the most common type of error used\n * by Jimpex.\n *\n * @group Services\n * @group Services/HTTPError\n */\nexport class HTTPError extends AppError {\n  /**\n   * @param message   The error message.\n   * @param status    The HTTP status code.\n   * @param context   Context information related to the error.\n   * @param statuses  A reference to the service that generates HTTP status codes. This\n   *                  is in case the implementation wants to use a special version from\n   *                  the container; otherwise, it will use the `statuses` library\n   *                  directly.\n   */\n  constructor(\n    message: string,\n    status: number | string = statusesFn('ok'),\n    context: AppErrorContext = {},\n    statuses: Statuses = statusesFn,\n  ) {\n    super(message, { ...context, status }, statuses);\n  }\n}\n/**\n * Shorthand for `new HTTPError()`.\n *\n * @param args  The same parameters as the {@link HTTPError} constructor.\n * @returns A new instance of {@link HTTPError}.\n * @group Services\n * @group Services/HTTPError\n */\nexport const createHTTPError = (\n  ...args: ConstructorParameters<typeof HTTPError>\n): HTTPError => new HTTPError(...args);\n/**\n * The type of the function that generates a new instance of {@link HTTPError}.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/HTTPError\n */\nexport type CreateHTTPErrorFn = typeof createHTTPError;\n/**\n * THe type of the {@link HTTPError} class.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/HTTPError\n */\nexport type HTTPErrorClass = typeof HTTPError;\n/**\n * A service provider that will register both the {@link HTTPError} and a generator\n * function on the container. `HTTPError` will be the key for class, and `httpError` will\n * be for the generator function.\n *\n * @example\n *\n *   // Register it on the container\n *   container.register(httpErrorProvider);\n *   // Getting access to the class.\n *   const HTTPError = container.get<HTTPErrorClass>('HTTPError');\n *   // Getting access to the function.\n *   const httpError = container.get<CreateHTTPErrorFn>('httpError');\n *\n * @group Providers\n * @group Services/HTTPError\n */\nexport const httpErrorProvider = provider((app) => {\n  app.set('HTTPError', () => HTTPError);\n  app.set('httpError', () => createHTTPError);\n});\n"],"mappings":";AAAA,SAAS,UAAU,YAAY,kBAAiC;AAChE,SAAS,gBAAsC;AAQxC,MAAM,kBAAkB,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUtC,YACE,SACA,SAA0B,WAAW,IAAI,GACzC,UAA2B,CAAC,GAC5B,WAAqB,YACrB;AACA,UAAM,SAAS,EAAE,GAAG,SAAS,OAAO,GAAG,QAAQ;AAAA,EACjD;AACF;AASO,MAAM,kBAAkB,IAC1B,SACW,IAAI,UAAU,GAAG,IAAI;AAgC9B,MAAM,oBAAoB,SAAS,CAAC,QAAQ;AACjD,MAAI,IAAI,aAAa,MAAM,SAAS;AACpC,MAAI,IAAI,aAAa,MAAM,eAAe;AAC5C,CAAC;","names":[]}

package/dist/esm/services/common/index.js

@@ -1,17 +0,0 @@
-import "../../chunk-V6TY7KAL.js";
-import { providers } from "../../utils";
-import { appErrorProvider } from "./appError";
-import { httpErrorProvider } from "./httpError";
-import { sendFileProvider } from "./sendFile";
-const commonServicesProvider = providers({
-  appErrorProvider,
-  httpErrorProvider,
-  sendFileProvider
-});
-export * from "./appError";
-export * from "./httpError";
-export * from "./sendFile";
-export {
-  commonServicesProvider
-};
-//# sourceMappingURL=index.js.map

package/dist/esm/services/common/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/services/common/index.ts"],"sourcesContent":["import { providers } from '../../utils';\nimport { appErrorProvider } from './appError';\nimport { httpErrorProvider } from './httpError';\nimport { sendFileProvider } from './sendFile';\n/**\n * Registers all the common services on the container.\n *\n * - {@link AppError | appError}\n * - {@link HTTPError | httpError}\n * - {@link SendFile | sendFile}\n *\n * @example\n *\n *   // Register the collection on the container\n *   container.register(commonServicesProvider);\n *   // Getting access to one the services instance\n *   const sendFile = container.get<SendFile>('sendFile');\n *\n * @group Providers\n */\nexport const commonServicesProvider = providers({\n  appErrorProvider,\n  httpErrorProvider,\n  sendFileProvider,\n});\n\nexport * from './appError';\nexport * from './httpError';\nexport * from './sendFile';\n"],"mappings":";AAAA,SAAS,iBAAiB;AAC1B,SAAS,wBAAwB;AACjC,SAAS,yBAAyB;AAClC,SAAS,wBAAwB;AAiB1B,MAAM,yBAAyB,UAAU;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAED,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/esm/services/common/sendFile.js

@@ -1,27 +0,0 @@
-import "../../chunk-V6TY7KAL.js";
-import { provider } from "../../utils";
-const sendFile = ({ inject: { pathUtils } }) => ({ res, filepath, from = "app", next = () => {
-} }) => {
-  res.sendFile(pathUtils.joinFrom(from, filepath), (error) => {
-    if (error) {
-      next(error);
-    } else {
-      res.end();
-    }
-  });
-};
-const sendFileProvider = provider((app) => {
-  app.set(
-    "sendFile",
-    () => sendFile({
-      inject: {
-        pathUtils: app.get("pathUtils")
-      }
-    })
-  );
-});
-export {
-  sendFile,
-  sendFileProvider
-};
-//# sourceMappingURL=sendFile.js.map

package/dist/esm/services/common/sendFile.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/services/common/sendFile.ts"],"sourcesContent":["import { provider } from '../../utils';\nimport type { Response, NextFunction, PathUtils } from '../../types';\n/**\n * The options to create a {@link SendFile} function.\n *\n * @group Services/SendFile\n */\nexport type SendFileGeneratorOptions = {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    pathUtils: PathUtils;\n  };\n};\n/**\n * The options for the function that actually serves a file.\n *\n * @group Services/SendFile\n */\nexport type SendFileOptions = {\n  /**\n   * The response object sent by the application. Necessary to write the file.\n   */\n  res: Response;\n  /**\n   * The path of the file to serve. Depending on the `from` option, it will be either\n   * relative to the project root, or the application executable.\n   */\n  filepath: string;\n  /**\n   * The name of a location on the `pathUtils` service from where the `filepath` is\n   * relative to. It can be `app` for the directory containing the application executable,\n   * or `project` for the project root. It could also be any other location that the\n   * implementation may have registered.\n   *\n   * @default 'app'\n   */\n  from?: string;\n  /**\n   * The function to move to the next middleware. It can be used to report an error in\n   * case the file can't be served.\n   *\n   * @default {() => {}}\n   */\n  next?: NextFunction;\n};\n/**\n * The type of the function that serves a file.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/SendFile\n */\nexport type SendFile = (options: SendFileOptions) => void;\n/**\n * Generates a function to send files on the application response.\n *\n * @param options  To inject the required dependencies.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   // Let's say this is inside an Express middleware.\n *   // Get the function\n *   const send = sendFile(pathUtils);\n *   send({ res, filepath: 'some-file.html', next });\n *   // If your app is on \"/app/index.js\", this will send \"/app/some-file.html\".\n *\n * @group Services\n * @group Services/SendFile\n */\nexport const sendFile =\n  ({ inject: { pathUtils } }: SendFileGeneratorOptions): SendFile =>\n  ({ res, filepath, from = 'app', next = () => {} }) => {\n    res.sendFile(pathUtils.joinFrom(from, filepath), (error) => {\n      if (error) {\n        next(error);\n      } else {\n        res.end();\n      }\n    });\n  };\n\n/**\n * The service provider that once registered on the container will set the result of\n * {@link sendFile} as the `sendFile` service.\n *\n * @example\n *\n *   // Register it on the container\n *   container.register(sendFileProvider);\n *   // Getting access to the service instance\n *   const sendFile = container.get<SendFile>('sendFile');\n *\n * @group Providers\n * @group Services/SendFile\n */\nexport const sendFileProvider = provider((app) => {\n  app.set('sendFile', () =>\n    sendFile({\n      inject: {\n        pathUtils: app.get('pathUtils'),\n      },\n    }),\n  );\n});\n"],"mappings":";AAAA,SAAS,gBAAgB;AAuElB,MAAM,WACX,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,MACzB,CAAC,EAAE,KAAK,UAAU,OAAO,OAAO,OAAO,MAAM;AAAC,EAAE,MAAM;AACpD,MAAI,SAAS,UAAU,SAAS,MAAM,QAAQ,GAAG,CAAC,UAAU;AAC1D,QAAI,OAAO;AACT,WAAK,KAAK;AAAA,IACZ,OAAO;AACL,UAAI,IAAI;AAAA,IACV;AAAA,EACF,CAAC;AACH;AAgBK,MAAM,mBAAmB,SAAS,CAAC,QAAQ;AAChD,MAAI;AAAA,IAAI;AAAA,IAAY,MAClB,SAAS;AAAA,MACP,QAAQ;AAAA,QACN,WAAW,IAAI,IAAI,WAAW;AAAA,MAChC;AAAA,IACF,CAAC;AAAA,EACH;AACF,CAAC;","names":[]}

package/dist/esm/services/frontend/frontendFs.js

@@ -1,66 +0,0 @@
-import {
-  __publicField
-} from "../../chunk-V6TY7KAL.js";
-import fs from "fs/promises";
-import { provider } from "../../utils";
-class FrontendFs {
-  /**
-   * @param options  The options to construct the service.
-   */
-  constructor({ inject: { pathUtils } }) {
-    /**
-     * The service that generates the relative paths.
-     */
-    __publicField(this, "_pathUtils");
-    this._pathUtils = pathUtils;
-  }
-  /**
-   * Deletes a file from the file system.
-   *
-   * @param filepath  The path to the file.
-   */
-  delete(filepath) {
-    return fs.unlink(this.getAppPath(filepath));
-  }
-  /**
-   * Reads a file from the file system.
-   *
-   * @param filepath  The path to the file.
-   * @param encoding  The text encoding in which the file should be read.
-   */
-  read(filepath, encoding = "utf-8") {
-    return fs.readFile(this.getAppPath(filepath), encoding);
-  }
-  /**
-   * Writes a file on the file system.
-   *
-   * @param filepath  The path to the file.
-   * @param content   The contents of the file.
-   */
-  write(filepath, content) {
-    return fs.writeFile(this.getAppPath(filepath), content);
-  }
-  /**
-   * Utility method to get the path of a file relative to the application executable.
-   *
-   * @param filepath  The path to the file.
-   */
-  getAppPath(filepath) {
-    return this._pathUtils.joinFrom("app", filepath);
-  }
-}
-const frontendFsProvider = provider((app) => {
-  app.set(
-    "frontendFs",
-    () => new FrontendFs({
-      inject: {
-        pathUtils: app.get("pathUtils")
-      }
-    })
-  );
-});
-export {
-  FrontendFs,
-  frontendFsProvider
-};
-//# sourceMappingURL=frontendFs.js.map

package/dist/esm/services/frontend/frontendFs.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/services/frontend/frontendFs.ts"],"sourcesContent":["import fs from 'fs/promises';\nimport { provider } from '../../utils';\nimport type { PathUtils } from '../../types';\n/**\n * The options to construct a {@link FrontendFs}.\n *\n * @group Services/FrontendFs\n */\nexport type FrontendFsOptions = {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    pathUtils: PathUtils;\n  };\n};\n/**\n * This service allows the application to easily work with the filesystem. The idea behind\n * centralizing this functionalities into a service is that is pretty common to have\n * bundling tools to generate the frontend, and on that process files can have different\n * paths or not even be generated all. The service can be extended/overwritten to\n * accommodate any requirements and avoid having to update or add `if`s to every `fs` call\n * the application does.\n * Another _'feature'_ of this service is that all the paths are relative to the directory\n * where the app executable is located, so you don't have to remember the relative path\n * from the place you are accessing a file to the place where it's located.\n *\n * @group Services\n * @group Services/FrontendFs\n */\nexport class FrontendFs {\n  /**\n   * The service that generates the relative paths.\n   */\n  protected readonly _pathUtils: PathUtils;\n  /**\n   * @param options  The options to construct the service.\n   */\n  constructor({ inject: { pathUtils } }: FrontendFsOptions) {\n    this._pathUtils = pathUtils;\n  }\n  /**\n   * Deletes a file from the file system.\n   *\n   * @param filepath  The path to the file.\n   */\n  delete(filepath: string): Promise<void> {\n    return fs.unlink(this.getAppPath(filepath));\n  }\n  /**\n   * Reads a file from the file system.\n   *\n   * @param filepath  The path to the file.\n   * @param encoding  The text encoding in which the file should be read.\n   */\n  read(filepath: string, encoding: BufferEncoding = 'utf-8'): Promise<string> {\n    return fs.readFile(this.getAppPath(filepath), encoding);\n  }\n  /**\n   * Writes a file on the file system.\n   *\n   * @param filepath  The path to the file.\n   * @param content   The contents of the file.\n   */\n  write(filepath: string, content: Parameters<typeof fs.writeFile>[1]): Promise<void> {\n    return fs.writeFile(this.getAppPath(filepath), content);\n  }\n  /**\n   * Utility method to get the path of a file relative to the application executable.\n   *\n   * @param filepath  The path to the file.\n   */\n  protected getAppPath(filepath: string): string {\n    return this._pathUtils.joinFrom('app', filepath);\n  }\n}\n/**\n * The service provider that once registered on the container will set an instance of\n * {@link FrontendFs} as the `frontendFs` service.\n *\n * @example\n *\n *   // Register it on the container\n *   container.register(frontendFsProvider);\n *   // Getting access to the service instance\n *   const frontendFs = container.get<FrontendFs>('frontendFs');\n *\n * @group Providers\n * @group Services/FrontendFs\n */\nexport const frontendFsProvider = provider((app) => {\n  app.set(\n    'frontendFs',\n    () =>\n      new FrontendFs({\n        inject: {\n          pathUtils: app.get<PathUtils>('pathUtils'),\n        },\n      }),\n  );\n});\n"],"mappings":";;;AAAA,OAAO,QAAQ;AACf,SAAS,gBAAgB;AA6BlB,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA,EAQtB,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAsB;AAJ1D;AAAA;AAAA;AAAA,wBAAmB;AAKjB,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,UAAiC;AACtC,WAAO,GAAG,OAAO,KAAK,WAAW,QAAQ,CAAC;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,KAAK,UAAkB,WAA2B,SAA0B;AAC1E,WAAO,GAAG,SAAS,KAAK,WAAW,QAAQ,GAAG,QAAQ;AAAA,EACxD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,UAAkB,SAA4D;AAClF,WAAO,GAAG,UAAU,KAAK,WAAW,QAAQ,GAAG,OAAO;AAAA,EACxD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMU,WAAW,UAA0B;AAC7C,WAAO,KAAK,WAAW,SAAS,OAAO,QAAQ;AAAA,EACjD;AACF;AAeO,MAAM,qBAAqB,SAAS,CAAC,QAAQ;AAClD,MAAI;AAAA,IACF;AAAA,IACA,MACE,IAAI,WAAW;AAAA,MACb,QAAQ;AAAA,QACN,WAAW,IAAI,IAAe,WAAW;AAAA,MAC3C;AAAA,IACF,CAAC;AAAA,EACL;AACF,CAAC;","names":[]}

package/dist/esm/services/frontend/index.js

@@ -1,11 +0,0 @@
-import "../../chunk-V6TY7KAL.js";
-import { providers } from "../../utils";
-import { frontendFsProvider } from "./frontendFs";
-const frontendServicesProvider = providers({
-  frontendFsProvider
-});
-export * from "./frontendFs";
-export {
-  frontendServicesProvider
-};
-//# sourceMappingURL=index.js.map

package/dist/esm/services/frontend/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/services/frontend/index.ts"],"sourcesContent":["import { providers } from '../../utils';\nimport { frontendFsProvider } from './frontendFs';\n/**\n * Registers all the frontend services on the container.\n *\n * - {@link FrontendFs | frontendFs}\n *\n * @example\n *\n *   // Register the collection on the container\n *   container.register(frontendServicesProvider);\n *   // Getting access to one the services instance\n *   const frontendFs = container.get<FrontendFs>('frontendFs');\n *\n * @group Providers\n */\nexport const frontendServicesProvider = providers({\n  frontendFsProvider,\n});\n\nexport * from './frontendFs';\n"],"mappings":";AAAA,SAAS,iBAAiB;AAC1B,SAAS,0BAA0B;AAe5B,MAAM,2BAA2B,UAAU;AAAA,EAChD;AACF,CAAC;AAED,cAAc;","names":[]}

package/dist/esm/services/html/htmlGenerator.js

@@ -1,192 +0,0 @@
-import {
-  __publicField
-} from "../../chunk-V6TY7KAL.js";
-import { get } from "@homer0/object-utils";
-import { deepAssignWithOverwrite } from "@homer0/deep-assign";
-import { deferred } from "@homer0/deferred";
-import { providerCreator } from "../../utils";
-class HTMLGenerator {
-  /**
-   * @param options  The options to construct the class.
-   * @throws If `valuesService` is specified but it doesn't have a `getValues`
-   *         method.
-   */
-  constructor({
-    inject: { config, logger, frontendFs, valuesService },
-    ...options
-  }) {
-    /**
-     * The service customization options.
-     */
-    __publicField(this, "_options");
-    /**
-     * The application configuration service, to get the settings specified by the
-     * `configKeys` option.
-     */
-    __publicField(this, "_config");
-    /**
-     * The service that logs messages on the terminal, in case the `silent` option is `false`.
-     */
-    __publicField(this, "_logger");
-    /**
-     * The service that interacts with the filesystem.
-     */
-    __publicField(this, "_frontendFs");
-    /**
-     * A service that can provide values to be replaced in the template.
-     */
-    __publicField(this, "_valuesService");
-    /**
-     * Whether or not the file was already generated.
-     */
-    __publicField(this, "_fileReady", false);
-    /**
-     * A deferred promise to return when another service asks if the file has been
-     * generated. Once this sevice finishes generating the file, the promise will be
-     * resolved for all implementations that hold a reference to this deferred.
-     */
-    __publicField(this, "_fileDeferred");
-    this._config = config;
-    this._logger = logger;
-    this._frontendFs = frontendFs;
-    this._valuesService = valuesService;
-    this._options = deepAssignWithOverwrite(
-      {
-        template: "index.tpl.html",
-        file: "index.html",
-        silent: false,
-        deleteTemplateAfter: true,
-        replacePlaceholder: /\{\{appConfig(?:uration)?\}\}/,
-        placeholderExpression: /\{\{(.*?)\}\}/gi,
-        variableName: "appConfig",
-        configKeys: ["features", "version", "postMessagesPrefix"]
-      },
-      options
-    );
-    if (this._valuesService && typeof this._valuesService.getValues !== "function") {
-      throw new Error("The HTMLGenerator values service must have a `getValues` method");
-    }
-  }
-  /**
-   * Gets a promise that will be resolved when the file has been generated.
-   */
-  whenReady() {
-    return this._fileDeferred ? this._fileDeferred.promise : Promise.resolve();
-  }
-  /**
-   * Generates the HTML file.
-   */
-  async generateHTML() {
-    if (this._fileReady) return void 0;
-    if (this._fileDeferred) return this._fileDeferred.promise;
-    this._fileDeferred = deferred();
-    const { template, deleteTemplateAfter, file, silent } = this._options;
-    try {
-      const templateContents = await this._frontendFs.read(template);
-      const values = await this._getValues();
-      const html = this._processHTML(templateContents, values);
-      await this._frontendFs.write(file, html);
-      if (!silent) {
-        this._logger.success(`The HTML file was successfully generated (${file})`);
-      }
-      if (deleteTemplateAfter) {
-        await this._frontendFs.delete(template);
-        if (!silent) {
-          this._logger.info(`The HTML template was successfully removed (${template})`);
-        }
-      }
-      this._fileReady = true;
-      this._fileDeferred.resolve();
-      this._fileDeferred = void 0;
-      return void 0;
-    } catch (error) {
-      this._fileDeferred.reject(error);
-      this._fileDeferred = void 0;
-      if (!silent) {
-        this._logger.error("There was an error while generating the HTML");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Gets the customization options.
-   */
-  get options() {
-    return deepAssignWithOverwrite({}, this._options);
-  }
-  /**
-   * Helper method to get the values that will be replaced in the template. If a "values
-   * service" was specified in the constructor, it will get the values from there,
-   * otherwise, it will use the `configKeys` option to get the values from the
-   * application configuration.
-   */
-  _getValues() {
-    if (this._valuesService) {
-      return this._valuesService.getValues(this._options);
-    }
-    const { configKeys } = this._options;
-    if (configKeys && configKeys.length) {
-      return Promise.resolve(this._config.get(configKeys));
-    }
-    return Promise.resolve({});
-  }
-  /**
-   * Processes the HTML template by replacing the placeholders with the actual values.
-   *
-   * @param template  The template for the HTML file.
-   * @param values    The values dictionary that should be replaced in the template.
-   */
-  _processHTML(template, values) {
-    const { replacePlaceholder, placeholderExpression, variableName } = this._options;
-    const htmlObject = JSON.stringify(values);
-    let code = template.replace(
-      replacePlaceholder,
-      `window.${variableName} = ${htmlObject}`
-    );
-    const matches = [];
-    let match = placeholderExpression.exec(code);
-    while (match) {
-      const [string, value] = match;
-      if (string && value) {
-        matches.push({
-          string,
-          value
-        });
-      }
-      match = placeholderExpression.exec(code);
-    }
-    matches.forEach((info) => {
-      code = code.replace(info.string, String(get(values, info.value)));
-    });
-    return code;
-  }
-}
-const htmlGeneratorProvider = providerCreator(
-  (options = {}) => (app) => {
-    const {
-      serviceName = "htmlGenerator",
-      valuesServiceName = "htmlGeneratorValues",
-      ...rest
-    } = options;
-    app.set(
-      serviceName,
-      () => new HTMLGenerator({
-        inject: {
-          config: app.get("config"),
-          logger: app.get("logger"),
-          frontendFs: app.get("frontendFs"),
-          valuesService: app.try(valuesServiceName)
-        },
-        ...rest
-      })
-    );
-    app.once("afterStart", () => {
-      app.get(serviceName).generateHTML();
-    });
-  }
-);
-export {
-  HTMLGenerator,
-  htmlGeneratorProvider
-};
-//# sourceMappingURL=htmlGenerator.js.map