jimpex 7.0.1 → 8.0.0

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

@@ -0,0 +1,101 @@
+import {
+  __publicField
+} from "../../chunk-T2T6Q22Z.js";
+import { deepAssignWithOverwrite } from "@homer0/deep-assign";
+import { middlewareCreator } from "../../utils";
+class VersionValidator {
+  constructor({ inject, version, ...options }) {
+    __publicField(this, "_HTTPError");
+    __publicField(this, "_responsesBuilder");
+    __publicField(this, "_statuses");
+    __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");
+    }
+  }
+  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
+          }
+        })
+      );
+    };
+  }
+  get options() {
+    return deepAssignWithOverwrite({}, this._options);
+  }
+  _isPopup(req) {
+    const popup = req.query[this._options.popup.variable];
+    return !!(popup && String(popup).toLowerCase() === "true");
+  }
+  _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

@@ -0,0 +1 @@
+{"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,EAqB5B,YAAY,EAAE,QAAQ,YAAY,QAAQ,GAAuC;AAjBjF,wBAAmB;AAInB,wBAAmB;AAInB,wBAAmB;AAInB,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,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,EAIA,IAAI,UAA6C;AAC/C,WAAO,wBAAwB,CAAC,GAAG,KAAK,QAAQ;AAAA,EAClD;AAAA,EAOU,SAAS,KAAuB;AACxC,UAAM,QAAQ,IAAI,MAAM,KAAK,SAAS,MAAM;AAC5C,WAAO,CAAC,EAAE,SAAS,OAAO,KAAK,EAAE,YAAY,MAAM;AAAA,EACrD;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

@@ -0,0 +1,52 @@
+import {
+  __publicField
+} from "../../chunk-T2T6Q22Z.js";
+import { provider, statuses as statusesFn } from "../../utils";
+class AppError extends Error {
+  constructor(message, context = {}, statuses = statusesFn) {
+    super(message);
+    __publicField(this, "_date");
+    __publicField(this, "_context");
+    __publicField(this, "_statuses");
+    this.name = this.constructor.name;
+    this._date = new Date();
+    this._statuses = statuses;
+    this._context = this._parseContext(context);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  getResponse() {
+    return this.response;
+  }
+  get response() {
+    return this._context.response || {};
+  }
+  get status() {
+    return this._context.status;
+  }
+  get context() {
+    return this._context;
+  }
+  get date() {
+    return this._date;
+  }
+  _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

@@ -0,0 +1 @@
+{"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,EAsBlC,YACE,SACA,UAA2B,CAAC,GAC5B,WAAqB,YACrB;AACA,UAAM,OAAO;AAvBf,wBAAS;AAKT,wBAAS;AAIT,wBAAU;AAeR,SAAK,OAAO,KAAK,YAAY;AAC7B,SAAK,QAAQ,IAAI,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,EAQA,cAAoB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA,EAKA,IAAI,WAAoB;AACtB,WAAO,KAAK,SAAS,YAAY,CAAC;AAAA,EACpC;AAAA,EAKA,IAAI,SAA6B;AAC/B,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA,EAIA,IAAI,UAAmB;AACrB,WAAO,KAAK;AAAA,EACd;AAAA,EAIA,IAAI,OAAa;AACf,WAAO,KAAK;AAAA,EACd;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,MAAM,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

@@ -0,0 +1,19 @@
+import "../../chunk-T2T6Q22Z.js";
+import { provider, statuses as statusesFn } from "../../utils";
+import { AppError } from "./appError";
+class HTTPError extends AppError {
+  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

@@ -0,0 +1 @@
+{"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,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

@@ -0,0 +1,17 @@
+import "../../chunk-T2T6Q22Z.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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,27 @@
+import "../../chunk-T2T6Q22Z.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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,38 @@
+import {
+  __publicField
+} from "../../chunk-T2T6Q22Z.js";
+import fs from "fs/promises";
+import { provider } from "../../utils";
+class FrontendFs {
+  constructor({ inject: { pathUtils } }) {
+    __publicField(this, "_pathUtils");
+    this._pathUtils = pathUtils;
+  }
+  delete(filepath) {
+    return fs.unlink(this.getAppPath(filepath));
+  }
+  read(filepath, encoding = "utf-8") {
+    return fs.readFile(this.getAppPath(filepath), encoding);
+  }
+  write(filepath, content) {
+    return fs.writeFile(this.getAppPath(filepath), content);
+  }
+  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

@@ -0,0 +1 @@
+{"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,EAQtB,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAsB;AAJ1D,wBAAmB;AAKjB,SAAK,aAAa;AAAA,EACpB;AAAA,EAMA,OAAO,UAAiC;AACtC,WAAO,GAAG,OAAO,KAAK,WAAW,QAAQ,CAAC;AAAA,EAC5C;AAAA,EAOA,KAAK,UAAkB,WAA2B,SAA0B;AAC1E,WAAO,GAAG,SAAS,KAAK,WAAW,QAAQ,GAAG,QAAQ;AAAA,EACxD;AAAA,EAOA,MAAM,UAAkB,SAA4D;AAClF,WAAO,GAAG,UAAU,KAAK,WAAW,QAAQ,GAAG,OAAO;AAAA,EACxD;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

@@ -0,0 +1,11 @@
+import "../../chunk-T2T6Q22Z.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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,144 @@
+import {
+  __publicField
+} from "../../chunk-T2T6Q22Z.js";
+import { get } from "@homer0/object-utils";
+import { deepAssignWithOverwrite } from "@homer0/deep-assign";
+import { deferred } from "@homer0/deferred";
+import { providerCreator } from "../../utils";
+class HTMLGenerator {
+  constructor({
+    inject: { config, logger, frontendFs, valuesService },
+    ...options
+  }) {
+    __publicField(this, "_options");
+    __publicField(this, "_config");
+    __publicField(this, "_logger");
+    __publicField(this, "_frontendFs");
+    __publicField(this, "_valuesService");
+    __publicField(this, "_fileReady", false);
+    __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");
+    }
+  }
+  whenReady() {
+    return this._fileDeferred ? this._fileDeferred.promise : Promise.resolve();
+  }
+  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;
+    }
+  }
+  get options() {
+    return deepAssignWithOverwrite({}, this._options);
+  }
+  _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({});
+  }
+  _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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/html/htmlGenerator.ts"],"sourcesContent":["import { get } from '@homer0/object-utils';\nimport { deepAssignWithOverwrite } from '@homer0/deep-assign';\nimport { deferred, type DeferredPromise } from '@homer0/deferred';\nimport { providerCreator } from '../../utils';\nimport type { Config, Logger } from '../../types';\nimport type { FrontendFs } from '../frontend';\n/**\n * The options to customize a {@link HTMLGenerator} instance.\n *\n * @group Services/HTMLGenerator\n */\nexport type HTMLGeneratorOptions = {\n  /**\n   * The name of the file it should use as template.\n   *\n   * @default 'index.tpl.html'\n   */\n  template: string;\n  /**\n   * The name of the generated file.\n   *\n   * @default 'index.html'\n   */\n  file: string;\n  /**\n   * If `true`, it won't log messages on the terminal when generating the file.\n   *\n   * @default false\n   */\n  silent: boolean;\n  /**\n   * Whether or not to delete the tempalte after generating the file.\n   *\n   * @default true\n   */\n  deleteTemplateAfter: boolean;\n  /**\n   * The placeholder string where the information will be written.\n   *\n   * @default /\\{\\{appConfi(?:guration)?\\}\\}/\n   */\n  replacePlaceholder: string | RegExp;\n  /**\n   * A regular expression for dynamic placeholders that will be replaced by values when\n   * the file is generated.\n   *\n   * @default /\\{\\{(.*?)\\}\\}/gi\n   */\n  placeholderExpression: RegExp;\n  /**\n   * The name of the variable that will have the information on the file.\n   *\n   * @default 'appConfig'\n   */\n  variableName: string;\n  /**\n   * A list of settings from the app configuration that will be used as the information to\n   * inject on the file.\n   *\n   * @default ['features', 'version', 'postMessagesPrefix']\n   */\n  configKeys: string[];\n};\n/**\n * An external service that can be used to provide the values the generator will replace\n * in the template.\n *\n * @group Services/HTMLGenerator\n */\nexport type HTMLGeneratorValuesService = {\n  /**\n   * A function that will be called to get the values to replace in the template.\n   *\n   * @param options  The service customization options.\n   */\n  getValues: (options: HTMLGeneratorOptions) => Promise<Record<string, unknown>>;\n};\n/**\n * The options to construct a {@link HTMLGenerator}.\n *\n * @group Services/HTMLGenerator\n */\nexport type HTMLGeneratorConstructorOptions = Partial<HTMLGeneratorOptions> & {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    config: Config;\n    logger: Logger;\n    frontendFs: FrontendFs;\n    /**\n     * A service that can provide the values to replace in the template. If specified, the\n     * values from `configKeys` will be ignored.\n     */\n    valuesService?: HTMLGeneratorValuesService;\n  };\n};\n/**\n * Custom options for the provider that will register an instance of {@link HTMLGenerator}\n * as a service.\n *\n * @group Services/HTMLGenerator\n */\nexport type HTMLGeneratorProviderOptions = Partial<HTMLGeneratorOptions> & {\n  /**\n   * The name that will be used to register the service on the container. This is to allow\n   * multiple \"instances\" of the service to be created.\n   *\n   * @default 'htmlGenerator'\n   */\n  serviceName?: string;\n  /**\n   * The name of a service that the generator will use in order to read the values that\n   * will be replaced on the template. If the service is available, the values from\n   * `configKeys` will be ignored.\n   *\n   * @default 'htmlGeneratorValues'\n   */\n  valuesServiceName?: string;\n};\n/**\n * This is a utility service that generates an HTML file with custom information when the\n * application is started.\n *\n * @group Services\n * @group Services/HTMLGenerator\n */\nexport class HTMLGenerator {\n  /**\n   * The service customization options.\n   */\n  protected readonly _options: HTMLGeneratorOptions;\n  /**\n   * The application configuration service, to get the settings specified by the\n   * `configKeys` option.\n   */\n  protected readonly _config: Config;\n  /**\n   * The service that logs messages on the terminal, in case the `silent` option is `false`.\n   */\n  protected readonly _logger: Logger;\n  /**\n   * The service that interacts with the filesystem.\n   */\n  protected readonly _frontendFs: FrontendFs;\n  /**\n   * A service that can provide values to be replaced in the template.\n   */\n  protected readonly _valuesService?: HTMLGeneratorValuesService;\n  /**\n   * Whether or not the file was already generated.\n   */\n  protected _fileReady: boolean = false;\n  /**\n   * A deferred promise to return when another service asks if the file has been\n   * generated. Once this sevice finishes generating the file, the promise will be\n   * resolved for all implementations that hold a reference to this deferred.\n   */\n  protected _fileDeferred?: DeferredPromise<void>;\n  /**\n   * @param options  The options to construct the class.\n   * @throws If `valuesService` is specified but it doesn't have a `getValues`\n   *         method.\n   */\n  constructor({\n    inject: { config, logger, frontendFs, valuesService },\n    ...options\n  }: HTMLGeneratorConstructorOptions) {\n    this._config = config;\n    this._logger = logger;\n    this._frontendFs = frontendFs;\n    this._valuesService = valuesService;\n    this._options = deepAssignWithOverwrite(\n      {\n        template: 'index.tpl.html',\n        file: 'index.html',\n        silent: false,\n        deleteTemplateAfter: true,\n        replacePlaceholder: /\\{\\{appConfig(?:uration)?\\}\\}/,\n        placeholderExpression: /\\{\\{(.*?)\\}\\}/gi,\n        variableName: 'appConfig',\n        configKeys: ['features', 'version', 'postMessagesPrefix'],\n      },\n      options,\n    );\n\n    if (this._valuesService && typeof this._valuesService.getValues !== 'function') {\n      throw new Error('The HTMLGenerator values service must have a `getValues` method');\n    }\n  }\n  /**\n   * Gets a promise that will be resolved when the file has been generated.\n   */\n  whenReady(): Promise<void> {\n    return this._fileDeferred ? this._fileDeferred.promise : Promise.resolve();\n  }\n  /**\n   * Generates the HTML file.\n   */\n  async generateHTML(): Promise<void> {\n    // The file is already generated, and since this is async, return the promise.\n    if (this._fileReady) return undefined;\n    // If the file is not ready, but the deferred exists, return the reference to the promise.\n    if (this._fileDeferred) return this._fileDeferred.promise;\n    // Create the deferred promise.\n    this._fileDeferred = deferred<void>();\n    const { template, deleteTemplateAfter, file, silent } = this._options;\n    try {\n      // Get the template.\n      const templateContents = await this._frontendFs.read(template);\n      // Get the values to replace.\n      const values = await this._getValues();\n      // Replace/process the template.\n      const html = this._processHTML(templateContents, values);\n      // Write it in the filesystem.\n      await this._frontendFs.write(file, html);\n      if (!silent) {\n        this._logger.success(`The HTML file was successfully generated (${file})`);\n      }\n      // Delete the template, if specified by the options.\n      if (deleteTemplateAfter) {\n        await this._frontendFs.delete(template);\n        if (!silent) {\n          this._logger.info(`The HTML template was successfully removed (${template})`);\n        }\n      }\n\n      // Switch the flag, resolve the deferred promise, and delete it.\n      this._fileReady = true;\n      this._fileDeferred!.resolve();\n      this._fileDeferred = undefined;\n      return undefined;\n    } catch (error) {\n      this._fileDeferred!.reject(error);\n      this._fileDeferred = undefined;\n      if (!silent) {\n        this._logger.error('There was an error while generating the HTML');\n      }\n      throw error;\n    }\n  }\n  /**\n   * Gets the customization options.\n   */\n  get options(): Readonly<HTMLGeneratorOptions> {\n    return deepAssignWithOverwrite({}, this._options);\n  }\n  /**\n   * Helper method to get the values that will be replaced in the template. If a \"values\n   * service\" was specified in the constructor, it will get the values from there,\n   * otherwise, it will use the `configKeys` option to get the values from the\n   * application configuration.\n   */\n  protected _getValues(): Promise<Record<string, unknown>> {\n    if (this._valuesService) {\n      return this._valuesService.getValues(this._options);\n    }\n\n    const { configKeys } = this._options;\n    if (configKeys && configKeys.length) {\n      return Promise.resolve(this._config.get(configKeys));\n    }\n\n    return Promise.resolve({});\n  }\n  /**\n   * Processes the HTML template by replacing the placeholders with the actual values.\n   *\n   * @param template  The template for the HTML file.\n   * @param values    The values dictionary that should be replaced in the template.\n   */\n  protected _processHTML(template: string, values: Record<string, unknown>) {\n    const { replacePlaceholder, placeholderExpression, variableName } = this._options;\n    const htmlObject = JSON.stringify(values);\n    let code = template.replace(\n      replacePlaceholder,\n      `window.${variableName} = ${htmlObject}`,\n    );\n    const matches: Array<{ string: string; value: string }> = [];\n    let match = placeholderExpression.exec(code);\n    while (match) {\n      const [string, value] = match;\n      if (string && value) {\n        matches.push({\n          string,\n          value,\n        });\n      }\n\n      match = placeholderExpression.exec(code);\n    }\n\n    matches.forEach((info) => {\n      code = code.replace(info.string, String(get(values, info.value)));\n    });\n\n    return code;\n  }\n}\n/**\n * The service provider that once registered on the container will set an instance of\n * {@link HTMLGenerator} as the `htmlGenerator` service. it will also hook itself to the\n * `after-start` event of the application in order to trigger the generator of the HTML\n * file.\n *\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   // Register it on the container\n *   container.register(htmlGeneratorProvider);\n *   // Getting access to the service instance\n *   const htmlGenerator = container.get<HTMLGenerator>('htmlGenerator');\n *\n * @example\n *\n * <caption>Using with custom options</caption>\n *\n *   container.register(\n *     htmlGeneratorProvider({\n *       serviceName: 'myHtmlGenerator',\n *       valuesServiceName: 'myValuesService',\n *       template: 'my-template.tpl.html',\n *     }),\n *   );\n *\n * @group Providers\n * @group Services/HTMLGenerator\n */\nexport const htmlGeneratorProvider = providerCreator(\n  (options: HTMLGeneratorProviderOptions = {}) =>\n    (app) => {\n      const {\n        serviceName = 'htmlGenerator',\n        valuesServiceName = 'htmlGeneratorValues',\n        ...rest\n      } = options;\n      app.set(\n        serviceName,\n        () =>\n          new HTMLGenerator({\n            inject: {\n              config: app.get('config'),\n              logger: app.get('logger'),\n              frontendFs: app.get('frontendFs'),\n              valuesService: app.try(valuesServiceName),\n            },\n            ...rest,\n          }),\n      );\n\n      app.once('afterStart', () => {\n        app.get<HTMLGenerator>(serviceName).generateHTML();\n      });\n    },\n);\n"],"mappings":";;;AAAA,SAAS,WAAW;AACpB,SAAS,+BAA+B;AACxC,SAAS,gBAAsC;AAC/C,SAAS,uBAAuB;AA4HzB,MAAM,cAAc;AAAA,EAqCzB,YAAY;AAAA,IACV,QAAQ,EAAE,QAAQ,QAAQ,YAAY,cAAc;AAAA,OACjD;AAAA,EACL,GAAoC;AApCpC,wBAAmB;AAKnB,wBAAmB;AAInB,wBAAmB;AAInB,wBAAmB;AAInB,wBAAmB;AAInB,wBAAU,cAAsB;AAMhC,wBAAU;AAUR,SAAK,UAAU;AACf,SAAK,UAAU;AACf,SAAK,cAAc;AACnB,SAAK,iBAAiB;AACtB,SAAK,WAAW;AAAA,MACd;AAAA,QACE,UAAU;AAAA,QACV,MAAM;AAAA,QACN,QAAQ;AAAA,QACR,qBAAqB;AAAA,QACrB,oBAAoB;AAAA,QACpB,uBAAuB;AAAA,QACvB,cAAc;AAAA,QACd,YAAY,CAAC,YAAY,WAAW,oBAAoB;AAAA,MAC1D;AAAA,MACA;AAAA,IACF;AAEA,QAAI,KAAK,kBAAkB,OAAO,KAAK,eAAe,cAAc,YAAY;AAC9E,YAAM,IAAI,MAAM,iEAAiE;AAAA,IACnF;AAAA,EACF;AAAA,EAIA,YAA2B;AACzB,WAAO,KAAK,gBAAgB,KAAK,cAAc,UAAU,QAAQ,QAAQ;AAAA,EAC3E;AAAA,EAIA,MAAM,eAA8B;AAElC,QAAI,KAAK;AAAY,aAAO;AAE5B,QAAI,KAAK;AAAe,aAAO,KAAK,cAAc;AAElD,SAAK,gBAAgB,SAAe;AACpC,UAAM,EAAE,UAAU,qBAAqB,MAAM,OAAO,IAAI,KAAK;AAC7D,QAAI;AAEF,YAAM,mBAAmB,MAAM,KAAK,YAAY,KAAK,QAAQ;AAE7D,YAAM,SAAS,MAAM,KAAK,WAAW;AAErC,YAAM,OAAO,KAAK,aAAa,kBAAkB,MAAM;AAEvD,YAAM,KAAK,YAAY,MAAM,MAAM,IAAI;AACvC,UAAI,CAAC,QAAQ;AACX,aAAK,QAAQ,QAAQ,6CAA6C,OAAO;AAAA,MAC3E;AAEA,UAAI,qBAAqB;AACvB,cAAM,KAAK,YAAY,OAAO,QAAQ;AACtC,YAAI,CAAC,QAAQ;AACX,eAAK,QAAQ,KAAK,+CAA+C,WAAW;AAAA,QAC9E;AAAA,MACF;AAGA,WAAK,aAAa;AAClB,WAAK,cAAe,QAAQ;AAC5B,WAAK,gBAAgB;AACrB,aAAO;AAAA,IACT,SAAS,OAAP;AACA,WAAK,cAAe,OAAO,KAAK;AAChC,WAAK,gBAAgB;AACrB,UAAI,CAAC,QAAQ;AACX,aAAK,QAAQ,MAAM,8CAA8C;AAAA,MACnE;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAAA,EAIA,IAAI,UAA0C;AAC5C,WAAO,wBAAwB,CAAC,GAAG,KAAK,QAAQ;AAAA,EAClD;AAAA,EAOU,aAA+C;AACvD,QAAI,KAAK,gBAAgB;AACvB,aAAO,KAAK,eAAe,UAAU,KAAK,QAAQ;AAAA,IACpD;AAEA,UAAM,EAAE,WAAW,IAAI,KAAK;AAC5B,QAAI,cAAc,WAAW,QAAQ;AACnC,aAAO,QAAQ,QAAQ,KAAK,QAAQ,IAAI,UAAU,CAAC;AAAA,IACrD;AAEA,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAAA,EAOU,aAAa,UAAkB,QAAiC;AACxE,UAAM,EAAE,oBAAoB,uBAAuB,aAAa,IAAI,KAAK;AACzE,UAAM,aAAa,KAAK,UAAU,MAAM;AACxC,QAAI,OAAO,SAAS;AAAA,MAClB;AAAA,MACA,UAAU,kBAAkB;AAAA,IAC9B;AACA,UAAM,UAAoD,CAAC;AAC3D,QAAI,QAAQ,sBAAsB,KAAK,IAAI;AAC3C,WAAO,OAAO;AACZ,YAAM,CAAC,QAAQ,KAAK,IAAI;AACxB,UAAI,UAAU,OAAO;AACnB,gBAAQ,KAAK;AAAA,UACX;AAAA,UACA;AAAA,QACF,CAAC;AAAA,MACH;AAEA,cAAQ,sBAAsB,KAAK,IAAI;AAAA,IACzC;AAEA,YAAQ,QAAQ,CAAC,SAAS;AACxB,aAAO,KAAK,QAAQ,KAAK,QAAQ,OAAO,IAAI,QAAQ,KAAK,KAAK,CAAC,CAAC;AAAA,IAClE,CAAC;AAED,WAAO;AAAA,EACT;AACF;AA+BO,MAAM,wBAAwB;AAAA,EACnC,CAAC,UAAwC,CAAC,MACxC,CAAC,QAAQ;AACP,UAAM;AAAA,MACJ,cAAc;AAAA,MACd,oBAAoB;AAAA,SACjB;AAAA,IACL,IAAI;AACJ,QAAI;AAAA,MACF;AAAA,MACA,MACE,IAAI,cAAc;AAAA,QAChB,QAAQ;AAAA,UACN,QAAQ,IAAI,IAAI,QAAQ;AAAA,UACxB,QAAQ,IAAI,IAAI,QAAQ;AAAA,UACxB,YAAY,IAAI,IAAI,YAAY;AAAA,UAChC,eAAe,IAAI,IAAI,iBAAiB;AAAA,QAC1C;AAAA,QACA,GAAG;AAAA,MACL,CAAC;AAAA,IACL;AAEA,QAAI,KAAK,cAAc,MAAM;AAC3B,UAAI,IAAmB,WAAW,EAAE,aAAa;AAAA,IACnD,CAAC;AAAA,EACH;AACJ;","names":[]}

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

@@ -0,0 +1,11 @@
+import "../../chunk-T2T6Q22Z.js";
+import { providers } from "../../utils";
+import { htmlGeneratorProvider } from "./htmlGenerator";
+const htmlServicesProvider = providers({
+  htmlGeneratorProvider
+});
+export * from "./htmlGenerator";
+export {
+  htmlServicesProvider
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/html/index.ts"],"sourcesContent":["import { providers } from '../../utils';\nimport { htmlGeneratorProvider } from './htmlGenerator';\n/**\n * Registers all the HTML services on the container.\n *\n * - {@link HTMLGenerator | htmlGenerator}\n *\n * @example\n *\n *   // Register the collection on the container\n *   container.register(htmlServicesProvider);\n *   // Getting access to one the services instance\n *   const htmlGenerator = container.get<HTMLGenerator>('htmlGenerator');\n *\n * @group Providers\n */\nexport const htmlServicesProvider = providers({\n  htmlGeneratorProvider,\n});\n\nexport * from './htmlGenerator';\n"],"mappings":";AAAA,SAAS,iBAAiB;AAC1B,SAAS,6BAA6B;AAe/B,MAAM,uBAAuB,UAAU;AAAA,EAC5C;AACF,CAAC;AAED,cAAc;","names":[]}

package/dist/esm/services/http/apiClient.js

@@ -0,0 +1,71 @@
+import {
+  __publicField
+} from "../../chunk-T2T6Q22Z.js";
+import {
+  APIClient as APIClientBase
+} from "@homer0/api-utils";
+import { deepAssignWithOverwrite } from "@homer0/deep-assign";
+import { providerCreator } from "../../utils";
+class APIClient extends APIClientBase {
+  constructor({ inject: { http, HTTPError }, ...rest }) {
+    const { endpoints, gateway, url } = rest;
+    const useEndpoints = endpoints || gateway;
+    const apiConfig = {
+      url,
+      endpoints: useEndpoints
+    };
+    super({
+      ...apiConfig,
+      fetchClient: http.fetch
+    });
+    __publicField(this, "_http");
+    __publicField(this, "_HTTPError");
+    __publicField(this, "_apiConfig");
+    this._http = http;
+    this._HTTPError = HTTPError;
+    this._apiConfig = deepAssignWithOverwrite({}, apiConfig);
+  }
+  get apiConfig() {
+    return deepAssignWithOverwrite({}, this._apiConfig);
+  }
+  _getErrorMessageFromResponse(response) {
+    const res = response;
+    if (res.error)
+      return res.error;
+    if (res.data) {
+      if (res.data.message)
+        return res.data.message;
+      if (res.data.error)
+        return res.data.error;
+    }
+    return "Unexpected error";
+  }
+  formatError(response, status) {
+    return new this._HTTPError(this._getErrorMessageFromResponse(response), status);
+  }
+}
+const apiClientProvider = providerCreator(
+  (options = {}) => (app) => {
+    const defaultName = "apiClient";
+    const { serviceName = defaultName, clientClass: ClientClass = APIClient } = options;
+    let { configSetting } = options;
+    if (!configSetting) {
+      configSetting = serviceName === defaultName ? "api" : serviceName;
+    }
+    app.set(
+      serviceName,
+      () => new ClientClass({
+        inject: {
+          http: app.get("http"),
+          HTTPError: app.get("HTTPError")
+        },
+        ...app.getConfig(configSetting)
+      })
+    );
+  }
+);
+export {
+  APIClient,
+  apiClientProvider
+};
+//# sourceMappingURL=apiClient.js.map

package/dist/esm/services/http/apiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/http/apiClient.ts"],"sourcesContent":["import {\n  APIClient as APIClientBase,\n  type ErrorResponse,\n  type APIClientOptions,\n  type FetchClient,\n} from '@homer0/api-utils';\nimport { deepAssignWithOverwrite } from '@homer0/deep-assign';\nimport { providerCreator } from '../../utils';\nimport type { HTTP } from './http';\nimport type { HTTPErrorClass } from '../common';\n\nexport type { ErrorResponse };\n/**\n * The required settings needed to create the an API client.\n *\n * @group Services/APIClient\n */\nexport type APIClientConfig = Pick<APIClientOptions, 'url' | 'endpoints'>;\n/**\n * A dictionary of endpoints for the API client.\n * This is declared as standalone because it needs to reference them multiple times.\n *\n * @group Services/APIClient\n */\nexport type EndpointsType = APIClientOptions['endpoints'];\n/**\n * The format the settings needs to have in the application configuration in order to\n * create a valid API client.\n * The settings may include the endpoints dictionary in the `endpoints` property, or the\n * gateway `property`, with `endpoints` always having priority if both exists.\n * The reason for the `gateway` property to be valid, is in case the application also\n * implements a {@link GatewayController}, using the same property for both things will\n * help reduce the amount of duplicated definitions.\n *\n * @group Services/APIClient\n */\nexport type APIClientSettings = Omit<APIClientConfig, 'endpoints'> &\n  (\n    | {\n        endpoints: EndpointsType;\n        gateway?: EndpointsType;\n      }\n    | {\n        endpoints?: EndpointsType;\n        gateway: EndpointsType;\n      }\n  );\n/**\n * The options to construct a {@link APIClient}.\n *\n * @group Services/APIClient\n */\nexport type APIClientConstructorOptions = APIClientSettings & {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    http: HTTP;\n    HTTPError: HTTPErrorClass;\n  };\n};\n/**\n * An API client for the application to use. What makes this service special is that it\n * formats received errors using the {@link _HTTPError} class, and as fetch client, it\n * uses the {@link HTTP} service, allowing the application to to internally handle all the\n * requests and responses.\n *\n * The only reason to use the class directly is if you want to subclass it, as you would\n * normally just register the {@link apiClientProvider}.\n *\n * @group Services\n * @group Services/APIClient\n */\nexport class APIClient extends APIClientBase {\n  /**\n   * The service that makes the requests to the API.\n   */\n  protected readonly _http: HTTP;\n  /**\n   * The class to generate possible errors in the requests.\n   */\n  protected readonly _HTTPError: HTTPErrorClass;\n  /**\n   * The configuration of the API it uses.\n   */\n  protected readonly _apiConfig: APIClientConfig;\n  /**\n   * @param options  The options to construct the class.\n   */\n  constructor({ inject: { http, HTTPError }, ...rest }: APIClientConstructorOptions) {\n    const { endpoints, gateway, url } = rest;\n    const useEndpoints = (endpoints || gateway)!;\n    const apiConfig = {\n      url,\n      endpoints: useEndpoints,\n    };\n    super({\n      ...apiConfig,\n      fetchClient: http.fetch as unknown as FetchClient,\n    });\n\n    this._http = http;\n    this._HTTPError = HTTPError;\n    this._apiConfig = deepAssignWithOverwrite({}, apiConfig);\n  }\n  /**\n   * The configuration for the API.\n   */\n  get apiConfig(): Readonly<APIClientConfig> {\n    return deepAssignWithOverwrite({}, this._apiConfig);\n  }\n  /**\n   * Tries to obtain a message from an error caused on a failed request.\n   *\n   * @param response  The response from the failed request.\n   */\n  protected _getErrorMessageFromResponse(response: unknown) {\n    const res = response as {\n      error?: string;\n      data?: {\n        message?: string;\n        error?: string;\n      };\n    };\n    if (res.error) return res.error;\n    if (res.data) {\n      if (res.data.message) return res.data.message;\n      if (res.data.error) return res.data.error;\n    }\n\n    return 'Unexpected error';\n  }\n  /**\n   * Generates an {@link _HTTPError} from the response of a failed request.\n   *\n   * @param response  The response from the failed request.\n   * @param status    The status code of the response.\n   */\n  protected override formatError<ResponseType extends ErrorResponse>(\n    response: ResponseType,\n    status: number,\n  ): Error {\n    return new this._HTTPError(this._getErrorMessageFromResponse(response), status);\n  }\n}\n/**\n * The options for the provider creator that registers an {@link APIClient} in the\n * container.\n * These options allow the application to register multiple instances for different APIs.\n *\n * @group Services/APIClient\n */\nexport type APIClientProviderOptions = {\n  /**\n   * The name of the service that will be registered into the app.\n   *\n   * @default 'apiClient'\n   */\n  serviceName?: string;\n  /**\n   * The name of the configuration setting that has the API information.\n   *\n   * @default 'api'\n   */\n  configSetting?: string;\n  /**\n   * The class the service will instantiate. It has to extend {@link APIClient}.\n   *\n   * @default APIClient\n   */\n  clientClass?: typeof APIClient;\n};\n/**\n * The provider creator to register an instance of {@link APIClient} on the container.\n *\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   // Register it on the container\n *   container.register(apiClientProvider);\n *   // Getting access to the service instance\n *   const apiClient = container.get<APIClient>('apiClient');\n *\n * @example\n *\n * <caption>With custom options</caption>\n *\n *   container.register(\n *     apiClientProvider({\n *       serviceName: 'myApiClient',\n *       configSetting: 'myApi',\n *     }),\n *   );\n *\n * @group Providers\n * @group Services/APIClient\n */\nexport const apiClientProvider = providerCreator(\n  (options: APIClientProviderOptions = {}) =>\n    (app) => {\n      const defaultName = 'apiClient';\n      const { serviceName = defaultName, clientClass: ClientClass = APIClient } = options;\n      let { configSetting } = options;\n      if (!configSetting) {\n        configSetting = serviceName === defaultName ? 'api' : serviceName;\n      }\n\n      app.set(\n        serviceName,\n        () =>\n          new ClientClass({\n            inject: {\n              http: app.get('http'),\n              HTTPError: app.get('HTTPError'),\n            },\n            ...app.getConfig<APIClientSettings>(configSetting!),\n          }),\n      );\n    },\n);\n"],"mappings":";;;AAAA;AAAA,EACE,aAAa;AAAA,OAIR;AACP,SAAS,+BAA+B;AACxC,SAAS,uBAAuB;AAkEzB,MAAM,kBAAkB,cAAc;AAAA,EAgB3C,YAAY,EAAE,QAAQ,EAAE,MAAM,UAAU,MAAM,KAAK,GAAgC;AACjF,UAAM,EAAE,WAAW,SAAS,IAAI,IAAI;AACpC,UAAM,eAAgB,aAAa;AACnC,UAAM,YAAY;AAAA,MAChB;AAAA,MACA,WAAW;AAAA,IACb;AACA,UAAM;AAAA,MACJ,GAAG;AAAA,MACH,aAAa,KAAK;AAAA,IACpB,CAAC;AAtBH,wBAAmB;AAInB,wBAAmB;AAInB,wBAAmB;AAgBjB,SAAK,QAAQ;AACb,SAAK,aAAa;AAClB,SAAK,aAAa,wBAAwB,CAAC,GAAG,SAAS;AAAA,EACzD;AAAA,EAIA,IAAI,YAAuC;AACzC,WAAO,wBAAwB,CAAC,GAAG,KAAK,UAAU;AAAA,EACpD;AAAA,EAMU,6BAA6B,UAAmB;AACxD,UAAM,MAAM;AAOZ,QAAI,IAAI;AAAO,aAAO,IAAI;AAC1B,QAAI,IAAI,MAAM;AACZ,UAAI,IAAI,KAAK;AAAS,eAAO,IAAI,KAAK;AACtC,UAAI,IAAI,KAAK;AAAO,eAAO,IAAI,KAAK;AAAA,IACtC;AAEA,WAAO;AAAA,EACT;AAAA,EAOmB,YACjB,UACA,QACO;AACP,WAAO,IAAI,KAAK,WAAW,KAAK,6BAA6B,QAAQ,GAAG,MAAM;AAAA,EAChF;AACF;AAsDO,MAAM,oBAAoB;AAAA,EAC/B,CAAC,UAAoC,CAAC,MACpC,CAAC,QAAQ;AACP,UAAM,cAAc;AACpB,UAAM,EAAE,cAAc,aAAa,aAAa,cAAc,UAAU,IAAI;AAC5E,QAAI,EAAE,cAAc,IAAI;AACxB,QAAI,CAAC,eAAe;AAClB,sBAAgB,gBAAgB,cAAc,QAAQ;AAAA,IACxD;AAEA,QAAI;AAAA,MACF;AAAA,MACA,MACE,IAAI,YAAY;AAAA,QACd,QAAQ;AAAA,UACN,MAAM,IAAI,IAAI,MAAM;AAAA,UACpB,WAAW,IAAI,IAAI,WAAW;AAAA,QAChC;AAAA,QACA,GAAG,IAAI,UAA6B,aAAc;AAAA,MACpD,CAAC;AAAA,IACL;AAAA,EACF;AACJ;","names":[]}