velocious 1.0.428 → 1.0.430

package/build/src/controller.d.ts

@@ -1,10 +1,12 @@
 export default class VelociousController {
     /**
+     * Runs before action.
      * @param {string} methodName - Method name.
      * @returns {void} - No return value.
      */
     static beforeAction(methodName: string): void;
     /**
+     * Runs constructor.
      * @param {object} args - Options object.
      * @param {string} args.action - Action.
      * @param {import("./configuration.js").default} args.configuration - Configuration instance.
@@ -32,17 +34,30 @@ export default class VelociousController {
     _response: import("./http-server/client/response.js").default;
     viewParams: {};
     _viewPath: string;
-    /** @returns {string} - The action.  */
+    /**
+     * Runs get action.
+     * @returns {string} - The action.
+     */
     getAction(): string;
-    /** @returns {import("./configuration.js").default} - The configuration.  */
+    /**
+     * Runs get configuration.
+     * @returns {import("./configuration.js").default} - The configuration.
+     */
     getConfiguration(): import("./configuration.js").default;
-    /** @returns {Record<string, any>} - The params.  */
-    getParams(): Record<string, any>;
-    /** @returns {import("./http-server/client/request.js").default} - The request.  */
+    /**
+     * Runs get params.
+     * @returns {Record<string, ?>} - The params.
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Runs get request.
+     * @returns {import("./http-server/client/request.js").default} - The request.
+     */
     getRequest(): import("./http-server/client/request.js").default;
     /**
+     * Runs set cookie.
      * @param {string} name - Cookie name.
-     * @param {unknown} value - Cookie value.
+     * @param {?} value - Cookie value.
      * @param {object} [args] - Options object.
      * @param {string} [args.domain] - Domain.
      * @param {Date} [args.expires] - Expires date.
@@ -64,20 +79,31 @@ export default class VelociousController {
         sameSite?: "Strict" | "Lax" | "None" | undefined;
         encrypted?: boolean | undefined;
     }): Cookie;
-    /** @returns {Cookie[]} - Cookies from the request. */
+    /**
+     * Runs get cookies.
+     * @returns {Cookie[]} - Cookies from the request.
+     */
     getCookies(): Cookie[];
     _cookies: Cookie[] | undefined;
     /**
+     * Runs get controller class.
      * @private
      * @returns {typeof VelociousController} - The controller class.
      */
     private _getControllerClass;
     _runBeforeCallbacks(): Promise<void>;
-    /** @returns {Record<string, any>} - The params.  */
-    params(): Record<string, any>;
-    /** @returns {Record<string, any>} - The query parameters.  */
-    queryParameters(): Record<string, any>;
     /**
+     * Runs params.
+     * @returns {Record<string, ?>} - The params.
+     */
+    params(): Record<string, unknown>;
+    /**
+     * Runs query parameters.
+     * @returns {Record<string, ?>} - The query parameters.
+     */
+    queryParameters(): Record<string, unknown>;
+    /**
+     * Runs render.
      * @param {object} [args] - Options object.
      * @param {object} [args.json] - Json.
      * @param {number | string} [args.status] - Status.
@@ -87,13 +113,25 @@ export default class VelociousController {
         json?: object | undefined;
         status?: string | number | undefined;
     }): Promise<void>;
-    /** @param {object} json - JSON payload. */
+    /**
+     * Runs render json arg.
+     * @param {object} json - JSON payload.
+     */
     renderJsonArg(json: object): void;
-    /** @returns {Promise<void>} - Resolves when complete.  */
+    /**
+     * Runs render view.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
     renderView(): Promise<void>;
-    /** @returns {Promise<void>} - Resolves when complete. */
+    /**
+     * Runs render view actual.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
     _renderViewActual(): Promise<void>;
-    /** @returns {void} - No return value.  */
+    /**
+     * Runs render text.
+     * @returns {void} - No return value.
+     */
     renderText(): void;
     /**
      * Streams a file response from disk without loading the full file into controller memory.
@@ -108,21 +146,32 @@ export default class VelociousController {
         status?: string | number | undefined;
     }): void;
     /**
+     * Runs measure view render.
      * @template T
      * @param {() => T} callback - Callback to measure.
      * @returns {T} - Callback result.
      */
     _measureViewRender<T>(callback: () => T): T;
     /**
+     * Runs send file content type.
      * @param {string} filePath - File path.
      * @returns {string} - Content type value.
      */
     sendFileContentType(filePath: string): string;
-    /** @returns {import("./authorization/ability.js").default | undefined} - Current ability for request scope. */
+    /**
+     * Runs current ability.
+     * @returns {import("./authorization/ability.js").default | undefined} - Current ability for request scope.
+     */
     currentAbility(): import("./authorization/ability.js").default | undefined;
-    /** @returns {import("./http-server/client/request.js").default} - The request.  */
+    /**
+     * Runs request.
+     * @returns {import("./http-server/client/request.js").default} - The request.
+     */
     request(): import("./http-server/client/request.js").default;
-    /** @returns {import("./http-server/client/response.js").default} - The response.  */
+    /**
+     * Runs response.
+     * @returns {import("./http-server/client/response.js").default} - The response.
+     */
     response(): import("./http-server/client/response.js").default;
 }
 import Logger from "./logger.js";

package/build/src/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/controller.js"],"names":[],"mappings":"AAaA;IACE;;;OAGG;IACH,gCAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;;;;;;;OASG;IACH,wFARG;QAAqB,MAAM,EAAnB,MAAM;QACqC,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACvB,UAAU,EAAvB,MAAM;QACO,MAAM,EAAnB,MAAM;QACkD,OAAO,EAA/D,OAAO,iCAAiC,EAAE,OAAO;QACQ,QAAQ,EAAjE,OAAO,kCAAkC,EAAE,OAAO;QACrC,QAAQ,EAArB,MAAM;KAChB,EAmBA;IATC,gBAAqB;IACrB,oBAA6B;IAC7B,qDAAmC;IACnC,eAA8B;IAC9B,gBAAqB;IACrB,4DAAuB;IACvB,8DAAyB;IACzB,eAAoB;IACpB,kBAAyB;IAG3B,uCAAuC;IACvC,aADc,MAAM,CACe;IAEnC,4EAA4E;IAC5E,oBADc,OAAO,oBAAoB,EAAE,OAAO,CACD;IAEjD,oDAAoD;IACpD,aADc,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CACE;IAEnC,mFAAmF;IACnF,cADc,OAAO,iCAAiC,EAAE,OAAO,CAC1B;IAErC;;;;;;;;;;;;;OAaG;IACH,gBAbW,MAAM,SACN,OAAO,SAEf;QAAsB,MAAM;QACR,OAAO;QACJ,QAAQ;QACT,MAAM;QACN,IAAI;QACH,MAAM;QACY,QAAQ;QAC1B,SAAS;KAChC,GAAU,MAAM,CAoBlB;IAED,sDAAsD;IACtD,cADc,MAAM,EAAE,CAUrB;IAJG,+BAAuD;IAM3D;;;OAGG;IACH,4BAIC;IAED,qCA8BC;IAED,oDAAoD;IACpD,UADc,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQhC;IAED,8DAA8D;IAC9D,mBADc,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CA4BhC;IAED;;;;;OAKG;IACH,uCAJG;QAAsB,IAAI;QACK,MAAM;KACrC,GAAU,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED,2CAA2C;IAC3C,oBADY,MAAM,QAQjB;IAED,0DAA0D;IAC1D,cADc,OAAO,CAAC,IAAI,CAAC,CAO1B;IAED,yDAAyD;IACzD,qBADc,OAAO,CAAC,IAAI,CAAC,CAgC1B;IAED,0CAA0C;IAC1C,cADc,IAAI,CAGjB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,SAEd;QAAsB,WAAW;QACF,MAAM;KACrC,GAAU,IAAI,CAwBhB;IAED;;;;OAIG;IACH,mBAJa,CAAC,YACH,MAAM,CAAC,GACL,CAAC,CAQb;IAED;;;OAGG;IACH,8BAHW,MAAM,GACJ,MAAM,CAiBlB;IAED,+GAA+G;IAC/G,kBADc,OAAO,4BAA4B,EAAE,OAAO,GAAG,SAAS,CAGrE;IAED,mFAAmF;IACnF,WADc,OAAO,iCAAiC,EAAE,OAAO,CAC7B;IAElC,qFAAqF;IACrF,YADc,OAAO,kCAAkC,EAAE,OAAO,CAC5B;CACrC;mBA9VkB,aAAa;mBACb,yBAAyB"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/controller.js"],"names":[],"mappings":"AAaA;IACE;;;;OAIG;IACH,gCAHW,MAAM,GACJ,IAAI,CAWhB;IAED;;;;;;;;;;OAUG;IACH,wFARG;QAAqB,MAAM,EAAnB,MAAM;QACqC,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACvB,UAAU,EAAvB,MAAM;QACO,MAAM,EAAnB,MAAM;QACkD,OAAO,EAA/D,OAAO,iCAAiC,EAAE,OAAO;QACQ,QAAQ,EAAjE,OAAO,kCAAkC,EAAE,OAAO;QACrC,QAAQ,EAArB,MAAM;KAChB,EAmBA;IATC,gBAAqB;IACrB,oBAA6B;IAC7B,qDAAmC;IACnC,eAA8B;IAC9B,gBAAqB;IACrB,4DAAuB;IACvB,8DAAyB;IACzB,eAAoB;IACpB,kBAAyB;IAG3B;;;OAGG;IACH,aAFa,MAAM,CAEgB;IAEnC;;;OAGG;IACH,oBAFa,OAAO,oBAAoB,EAAE,OAAO,CAEA;IAEjD;;;OAGG;IACH,aAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAEK;IAEnC;;;OAGG;IACH,cAFa,OAAO,iCAAiC,EAAE,OAAO,CAEzB;IAErC;;;;;;;;;;;;;;OAcG;IACH,gBAbW,MAAM,SACN,OAAC,SAET;QAAsB,MAAM;QACR,OAAO;QACJ,QAAQ;QACT,MAAM;QACN,IAAI;QACH,MAAM;QACY,QAAQ;QAC1B,SAAS;KAChC,GAAU,MAAM,CAsBlB;IAED;;;OAGG;IACH,cAFa,MAAM,EAAE,CAWpB;IAJG,+BAAuD;IAM3D;;;;OAIG;IACH,4BAMC;IAED,qCAkCC;IAED;;;OAGG;IACH,UAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAS7B;IAED;;;OAGG;IACH,mBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAiC7B;IAED;;;;;;OAMG;IACH,uCAJG;QAAsB,IAAI;QACK,MAAM;KACrC,GAAU,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAShB;IAED;;;OAGG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;OAGG;IACH,qBAFa,OAAO,CAAC,IAAI,CAAC,CAmCzB;IAED;;;OAGG;IACH,cAFa,IAAI,CAIhB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,SAEd;QAAsB,WAAW;QACF,MAAM;KACrC,GAAU,IAAI,CAwBhB;IAED;;;;;OAKG;IACH,mBAJa,CAAC,YACH,MAAM,CAAC,GACL,CAAC,CAQb;IAED;;;;OAIG;IACH,8BAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;OAGG;IACH,kBAFa,OAAO,4BAA4B,EAAE,OAAO,GAAG,SAAS,CAIpE;IAED;;;OAGG;IACH,WAFa,OAAO,iCAAiC,EAAE,OAAO,CAE5B;IAElC;;;OAGG;IACH,YAFa,OAAO,kCAAkC,EAAE,OAAO,CAE3B;CACrC;mBA/ZkB,aAAa;mBACb,yBAAyB"}

package/build/src/controller.js

@@ -11,17 +11,21 @@ import querystring from "querystring";
 import { serializeFrontendModelTransportValue } from "./frontend-models/transport-serialization.js";
 export default class VelociousController {
     /**
+     * Runs before action.
      * @param {string} methodName - Method name.
      * @returns {void} - No return value.
      */
     static beforeAction(methodName) {
         if (!this._beforeActions) {
-            /** @type {Array<string>}  */
+            /**
+             * Stores the before actions value.
+              @type {Array<string>}  */
             this._beforeActions = [];
         }
         this._beforeActions.push(methodName);
     }
     /**
+     * Runs constructor.
      * @param {object} args - Options object.
      * @param {string} args.action - Action.
      * @param {import("./configuration.js").default} args.configuration - Configuration instance.
@@ -56,17 +60,30 @@ export default class VelociousController {
         this.viewParams = {};
         this._viewPath = viewPath;
     }
-    /** @returns {string} - The action.  */
+    /**
+     * Runs get action.
+     * @returns {string} - The action.
+     */
     getAction() { return this._action; }
-    /** @returns {import("./configuration.js").default} - The configuration.  */
+    /**
+     * Runs get configuration.
+     * @returns {import("./configuration.js").default} - The configuration.
+     */
     getConfiguration() { return this._configuration; }
-    /** @returns {Record<string, any>} - The params.  */
+    /**
+     * Runs get params.
+     * @returns {Record<string, ?>} - The params.
+     */
     getParams() { return this._params; }
-    /** @returns {import("./http-server/client/request.js").default} - The request.  */
+    /**
+     * Runs get request.
+     * @returns {import("./http-server/client/request.js").default} - The request.
+     */
     getRequest() { return this._request; }
     /**
+     * Runs set cookie.
      * @param {string} name - Cookie name.
-     * @param {unknown} value - Cookie value.
+     * @param {?} value - Cookie value.
      * @param {object} [args] - Options object.
      * @param {string} [args.domain] - Domain.
      * @param {Date} [args.expires] - Expires date.
@@ -80,7 +97,9 @@ export default class VelociousController {
      */
     setCookie(name, value, args = {}) {
         const { encrypted = false, ...options } = args;
-        /** @type {string} */
+        /**
+         * Types the following value.
+          @type {string} */
         let cookieValue;
         if (encrypted) {
             const secret = this.getConfiguration().getCookieSecret();
@@ -95,7 +114,10 @@ export default class VelociousController {
         this._response.addHeader("Set-Cookie", cookie.toHeader());
         return cookie;
     }
-    /** @returns {Cookie[]} - Cookies from the request. */
+    /**
+     * Runs get cookies.
+     * @returns {Cookie[]} - Cookies from the request.
+     */
     getCookies() {
         if (!this._cookies) {
             const secret = this.getConfiguration().getCookieSecret();
@@ -105,11 +127,14 @@ export default class VelociousController {
         return this._cookies;
     }
     /**
+     * Runs get controller class.
      * @private
      * @returns {typeof VelociousController} - The controller class.
      */
     _getControllerClass() {
-        const controllerClass = /** @type {typeof VelociousController} */ (this.constructor);
+        const controllerClass = /**
+                                 * Types the following value.
+                                  @type {typeof VelociousController} */ (this.constructor);
         return controllerClass;
     }
     async _runBeforeCallbacks() {
@@ -119,7 +144,11 @@ export default class VelociousController {
             await this.logger.debug(`Running callbacks for ${currentControllerClass.name}`);
             const beforeActions = currentControllerClass._beforeActions;
             if (beforeActions) {
-                const controllerPrototype = /** @type {Record<string, Function | undefined>} */ ( /** @type {unknown} */(currentControllerClass.prototype));
+                const controllerPrototype = /**
+                                             * Types the following value.
+                                              @type {Record<string, Function | undefined>} */ ( /**
+                                                                  * Types the following value.
+                                                                   @type {?} */(currentControllerClass.prototype));
                 for (const beforeActionName of beforeActions) {
                     const beforeAction = controllerPrototype[beforeActionName];
                     if (!beforeAction)
@@ -134,7 +163,10 @@ export default class VelociousController {
         }
         await this.logger.debug("After runBeforeCallbacks");
     }
-    /** @returns {Record<string, any>} - The params.  */
+    /**
+     * Runs params.
+     * @returns {Record<string, ?>} - The params.
+     */
     params() {
         // Merge query parameters so controllers can read them via params()
         const mergedParams = { ...this.queryParameters(), ...this._params };
@@ -142,19 +174,26 @@ export default class VelociousController {
             mergedParams.controller = this._controller;
         return mergedParams;
     }
-    /** @returns {Record<string, any>} - The query parameters.  */
+    /**
+     * Runs query parameters.
+     * @returns {Record<string, ?>} - The query parameters.
+     */
     queryParameters() {
         const query = this._request.path().split("?")[1];
         if (!query)
             return {};
         try {
-            /** @type {Record<string, any>} */
+            /**
+             * Unparsed params.
+              @type {Record<string, ?>} */
             const unparsedParams = querystring.parse(query);
             const paramsToObject = new ParamsToObject(unparsedParams);
             return paramsToObject.toObject();
         }
         catch (error) {
-            const ensuredError = /** @type {Error & {velociousContext?: Record<string, unknown>}} */ (error);
+            const ensuredError = /**
+                                  * Types the following value.
+                                   @type {Error & {velociousContext?: Record<string, ?>}} */ (error);
             ensuredError.velociousContext = {
                 ...(ensuredError.velociousContext || {}),
                 requestParsing: {
@@ -169,6 +208,7 @@ export default class VelociousController {
         }
     }
     /**
+     * Runs render.
      * @param {object} [args] - Options object.
      * @param {object} [args.json] - Json.
      * @param {number | string} [args.status] - Status.
@@ -188,7 +228,10 @@ export default class VelociousController {
         }
         return await this.renderView();
     }
-    /** @param {object} json - JSON payload. */
+    /**
+     * Runs render json arg.
+     * @param {object} json - JSON payload.
+     */
     renderJsonArg(json) {
         return this._measureViewRender(() => {
             const body = JSON.stringify(serializeFrontendModelTransportValue(json));
@@ -196,21 +239,29 @@ export default class VelociousController {
             this._response.setBody(body);
         });
     }
-    /** @returns {Promise<void>} - Resolves when complete.  */
+    /**
+     * Runs render view.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
     renderView() {
         const requestTiming = this.getConfiguration().getCurrentRequestTiming();
         return requestTiming
             ? requestTiming.measure("views", async () => await this._renderViewActual())
             : this._renderViewActual();
     }
-    /** @returns {Promise<void>} - Resolves when complete. */
+    /**
+     * Runs render view actual.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
     _renderViewActual() {
         return new Promise((resolve, reject) => {
             const viewPath = `${this._viewPath}/${inflection.dasherize(inflection.underscore(this._action))}.ejs`;
             const actualViewParams = incorporate({ controller: this }, this.viewParams);
             ejs.renderFile(viewPath, actualViewParams, {}, (err, str) => {
                 if (err) {
-                    const renderError = /** @type {Error & {code?: string}} */ (err);
+                    const renderError = /**
+                                         * Types the following value.
+                                          @type {Error & {code?: string}} */ (err);
                     if (renderError.code === "ENOENT") {
                         this.logger.warn(`Missing view file: ${viewPath}`);
                         if (this._response.getStatusCode() === 200) {
@@ -232,7 +283,10 @@ export default class VelociousController {
             });
         });
     }
-    /** @returns {void} - No return value.  */
+    /**
+     * Runs render text.
+     * @returns {void} - No return value.
+     */
     renderText() {
         throw new Error("renderText stub");
     }
@@ -262,6 +316,7 @@ export default class VelociousController {
         });
     }
     /**
+     * Runs measure view render.
      * @template T
      * @param {() => T} callback - Callback to measure.
      * @returns {T} - Callback result.
@@ -273,6 +328,7 @@ export default class VelociousController {
             : callback();
     }
     /**
+     * Runs send file content type.
      * @param {string} filePath - File path.
      * @returns {string} - Content type value.
      */
@@ -300,13 +356,22 @@ export default class VelociousController {
             return "image/gif";
         return "application/octet-stream";
     }
-    /** @returns {import("./authorization/ability.js").default | undefined} - Current ability for request scope. */
+    /**
+     * Runs current ability.
+     * @returns {import("./authorization/ability.js").default | undefined} - Current ability for request scope.
+     */
     currentAbility() {
         return this.getConfiguration().getCurrentAbility();
     }
-    /** @returns {import("./http-server/client/request.js").default} - The request.  */
+    /**
+     * Runs request.
+     * @returns {import("./http-server/client/request.js").default} - The request.
+     */
     request() { return this._request; }
-    /** @returns {import("./http-server/client/response.js").default} - The response.  */
+    /**
+     * Runs response.
+     * @returns {import("./http-server/client/response.js").default} - The response.
+     */
     response() { return this._response; }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../src/controller.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport ejs from \"ejs\"\nimport {incorporate} from \"incorporator\"\nimport * as inflection from \"inflection\"\nimport Logger from \"./logger.js\"\nimport Cookie from \"./http-server/cookie.js\"\nimport ParamsToObject from \"./http-server/client/params-to-object.js\"\nimport path from \"node:path\"\nimport restArgsError from \"./utils/rest-args-error.js\"\nimport querystring from \"querystring\"\nimport {serializeFrontendModelTransportValue} from \"./frontend-models/transport-serialization.js\"\n\nexport default class VelociousController {\n  /**\n   * @param {string} methodName - Method name.\n   * @returns {void} - No return value.\n   */\n  static beforeAction(methodName) {\n    if (!this._beforeActions) {\n      /** @type {Array<string>}  */\n      this._beforeActions = []\n    }\n\n    this._beforeActions.push(methodName)\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.action - Action.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} args.controller - Controller.\n   * @param {object} args.params - Parameters object.\n   * @param {import(\"./http-server/client/request.js\").default} args.request - Request object.\n   * @param {import(\"./http-server/client/response.js\").default} args.response - Response object.\n   * @param {string} args.viewPath - View path.\n   */\n  constructor({action, configuration, controller, params, request, response, viewPath}) {\n    if (!action) throw new Error(\"No action given\")\n    if (!configuration) throw new Error(\"No configuration given\")\n    if (!controller) throw new Error(\"No controller given\")\n    if (!params) throw new Error(\"No params given\")\n    if (!request) throw new Error(\"No request given\")\n    if (!response) throw new Error(\"No response given\")\n    if (!viewPath) throw new Error(\"No viewPath given\")\n\n    this._action = action\n    this._controller = controller\n    this._configuration = configuration\n    this.logger = new Logger(this)\n    this._params = params\n    this._request = request\n    this._response = response\n    this.viewParams = {}\n    this._viewPath = viewPath\n  }\n\n  /** @returns {string} - The action.  */\n  getAction() { return this._action }\n\n  /** @returns {import(\"./configuration.js\").default} - The configuration.  */\n  getConfiguration() { return this._configuration }\n\n  /** @returns {Record<string, any>} - The params.  */\n  getParams() { return this._params }\n\n  /** @returns {import(\"./http-server/client/request.js\").default} - The request.  */\n  getRequest() { return this._request }\n\n  /**\n   * @param {string} name - Cookie name.\n   * @param {unknown} value - Cookie value.\n   * @param {object} [args] - Options object.\n   * @param {string} [args.domain] - Domain.\n   * @param {Date} [args.expires] - Expires date.\n   * @param {boolean} [args.httpOnly] - HttpOnly flag.\n   * @param {number} [args.maxAge] - Max-Age in seconds.\n   * @param {string} [args.path] - Path.\n   * @param {boolean} [args.secure] - Secure flag.\n   * @param {\"Lax\" | \"Strict\" | \"None\"} [args.sameSite] - SameSite value.\n   * @param {boolean} [args.encrypted] - Whether to encrypt the cookie value.\n   * @returns {Cookie} - Cookie instance.\n   */\n  setCookie(name, value, args = {}) {\n    const {encrypted = false, ...options} = args\n    /** @type {string} */\n    let cookieValue\n\n    if (encrypted) {\n      const secret = this.getConfiguration().getCookieSecret()\n      if (!secret) throw new Error(\"Missing cookie secret for encrypted cookie\")\n      cookieValue = Cookie.encryptValue(value, secret)\n    } else {\n      cookieValue = String(value ?? \"\")\n    }\n\n    const cookie = new Cookie({name, value: cookieValue, options, encrypted})\n\n    this._response.addHeader(\"Set-Cookie\", cookie.toHeader())\n\n    return cookie\n  }\n\n  /** @returns {Cookie[]} - Cookies from the request. */\n  getCookies() {\n    if (!this._cookies) {\n      const secret = this.getConfiguration().getCookieSecret()\n      const headerValue = this._request.header(\"cookie\")\n\n      this._cookies = Cookie.parseHeader(headerValue, secret)\n    }\n\n    return this._cookies\n  }\n\n  /**\n   * @private\n   * @returns {typeof VelociousController} - The controller class.\n   */\n  _getControllerClass() {\n    const controllerClass = /** @type {typeof VelociousController} */ (this.constructor)\n\n    return controllerClass\n  }\n\n  async _runBeforeCallbacks() {\n    await this.logger.debug(\"_runBeforeCallbacks\")\n\n    let currentControllerClass = this._getControllerClass()\n\n    while (currentControllerClass) {\n      await this.logger.debug(`Running callbacks for ${currentControllerClass.name}`)\n\n      const beforeActions = currentControllerClass._beforeActions\n\n      if (beforeActions) {\n        const controllerPrototype = /** @type {Record<string, Function | undefined>} */ (/** @type {unknown} */ (currentControllerClass.prototype))\n\n        for (const beforeActionName of beforeActions) {\n          const beforeAction = controllerPrototype[beforeActionName]\n\n          if (!beforeAction) throw new Error(`No such before action: ${beforeActionName}`)\n\n          const boundBeforeAction = beforeAction.bind(this)\n\n          await boundBeforeAction()\n        }\n      }\n\n      currentControllerClass = Object.getPrototypeOf(currentControllerClass)\n\n      if (!currentControllerClass?.name?.endsWith(\"Controller\")) break\n    }\n\n    await this.logger.debug(\"After runBeforeCallbacks\")\n  }\n\n  /** @returns {Record<string, any>} - The params.  */\n  params() {\n    // Merge query parameters so controllers can read them via params()\n    const mergedParams = {...this.queryParameters(), ...this._params}\n\n    if (!mergedParams.controller) mergedParams.controller = this._controller\n\n    return mergedParams\n  }\n\n  /** @returns {Record<string, any>} - The query parameters.  */\n  queryParameters() {\n    const query = this._request.path().split(\"?\")[1]\n\n    if (!query) return {}\n\n    try {\n      /** @type {Record<string, any>} */\n      const unparsedParams = querystring.parse(query)\n      const paramsToObject = new ParamsToObject(unparsedParams)\n\n      return paramsToObject.toObject()\n    } catch (error) {\n      const ensuredError = /** @type {Error & {velociousContext?: Record<string, unknown>}} */ (error)\n\n      ensuredError.velociousContext = {\n        ...(ensuredError.velociousContext || {}),\n        requestParsing: {\n          httpMethod: this._request.httpMethod(),\n          parameterKeys: Object.keys(querystring.parse(query)),\n          path: this._request.path(),\n          queryPreview: query.length > 300 ? `${query.slice(0, 300)}...` : query,\n          stage: \"query-parameters\"\n        }\n      }\n\n      throw ensuredError\n    }\n  }\n\n  /**\n   * @param {object} [args] - Options object.\n   * @param {object} [args.json] - Json.\n   * @param {number | string} [args.status] - Status.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async render({json, status, ...restArgs} = {}) {\n    restArgsError(restArgs)\n\n    // Apply the status BEFORE delegating to renderJsonArg/renderView so\n    // `render({json: {...}, status: 422})` produces a 422 response with\n    // a JSON body. The previous order short-circuited via `return\n    // this.renderJsonArg(json)` and silently dropped the status arg.\n    if (status) {\n      this._response.setStatus(status)\n    }\n\n    if (json) {\n      return this.renderJsonArg(json)\n    }\n\n    return await this.renderView()\n  }\n\n  /** @param {object} json - JSON payload. */\n  renderJsonArg(json) {\n    return this._measureViewRender(() => {\n      const body = JSON.stringify(serializeFrontendModelTransportValue(json))\n\n      this._response.setHeader(\"Content-Type\", \"application/json; charset=UTF-8\")\n      this._response.setBody(body)\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  renderView() {\n    const requestTiming = this.getConfiguration().getCurrentRequestTiming()\n\n    return requestTiming\n      ? requestTiming.measure(\"views\", async () => await this._renderViewActual())\n      : this._renderViewActual()\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete. */\n  _renderViewActual() {\n    return new Promise((resolve, reject) => {\n      const viewPath = `${this._viewPath}/${inflection.dasherize(inflection.underscore(this._action))}.ejs`\n      const actualViewParams = incorporate({controller: this}, this.viewParams)\n\n      ejs.renderFile(viewPath, actualViewParams, {}, (err, str) => {\n        if (err) {\n          const renderError = /** @type {Error & {code?: string}} */ (err)\n\n          if (renderError.code === \"ENOENT\") {\n            this.logger.warn(`Missing view file: ${viewPath}`)\n\n            if (this._response.getStatusCode() === 200) {\n              this._response.setStatus(\"internal-server-error\")\n            }\n\n            this._response.setHeader(\"Content-Type\", \"text/plain; charset=UTF-8\")\n            this._response.setBody(`Missing view file: ${viewPath}`)\n\n            resolve(undefined)\n          } else {\n            reject(renderError)\n          }\n        } else {\n          this._response.setHeader(\"Content-Type\", \"text/html; charset=UTF-8\")\n          this._response.setBody(str)\n\n          resolve(undefined)\n        }\n      })\n    })\n  }\n\n  /** @returns {void} - No return value.  */\n  renderText() {\n    throw new Error(\"renderText stub\")\n  }\n\n  /**\n   * Streams a file response from disk without loading the full file into controller memory.\n   * @param {string} filePath - File path.\n   * @param {object} [args] - Options object.\n   * @param {string} [args.contentType] - Content type.\n   * @param {number | string} [args.status] - Status.\n   * @returns {void} - No return value.\n   */\n  sendFile(filePath, args = {}) {\n    this._measureViewRender(() => {\n      const {contentType, status, ...restArgs} = args\n\n      restArgsError(restArgs)\n\n      if (typeof filePath !== \"string\" || filePath.length < 1) {\n        throw new Error(`Expected file path to be a non-empty string, got: ${String(filePath)}`)\n      }\n\n      const detectedContentType = contentType || this.sendFileContentType(filePath)\n\n      if (detectedContentType) {\n        this._response.setHeader(\"Content-Type\", detectedContentType)\n      }\n\n      if (status) {\n        this._response.setStatus(status)\n      }\n\n      this._response.setFilePath(filePath)\n    })\n  }\n\n  /**\n   * @template T\n   * @param {() => T} callback - Callback to measure.\n   * @returns {T} - Callback result.\n   */\n  _measureViewRender(callback) {\n    const requestTiming = this.getConfiguration().getCurrentRequestTiming()\n\n    return requestTiming\n      ? requestTiming.measureSync(\"views\", callback)\n      : callback()\n  }\n\n  /**\n   * @param {string} filePath - File path.\n   * @returns {string} - Content type value.\n   */\n  sendFileContentType(filePath) {\n    const extension = path.extname(filePath).toLowerCase()\n\n    if (extension === \".wasm\") return \"application/wasm\"\n    if (extension === \".js\") return \"text/javascript; charset=UTF-8\"\n    if (extension === \".json\") return \"application/json; charset=UTF-8\"\n    if (extension === \".css\") return \"text/css; charset=UTF-8\"\n    if (extension === \".html\") return \"text/html; charset=UTF-8\"\n    if (extension === \".txt\") return \"text/plain; charset=UTF-8\"\n    if (extension === \".svg\") return \"image/svg+xml\"\n    if (extension === \".png\") return \"image/png\"\n    if (extension === \".jpg\" || extension === \".jpeg\") return \"image/jpeg\"\n    if (extension === \".gif\") return \"image/gif\"\n\n    return \"application/octet-stream\"\n  }\n\n  /** @returns {import(\"./authorization/ability.js\").default | undefined} - Current ability for request scope. */\n  currentAbility() {\n    return this.getConfiguration().getCurrentAbility()\n  }\n\n  /** @returns {import(\"./http-server/client/request.js\").default} - The request.  */\n  request() { return this._request }\n\n  /** @returns {import(\"./http-server/client/response.js\").default} - The response.  */\n  response() { return this._response }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../src/controller.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport ejs from \"ejs\"\nimport {incorporate} from \"incorporator\"\nimport * as inflection from \"inflection\"\nimport Logger from \"./logger.js\"\nimport Cookie from \"./http-server/cookie.js\"\nimport ParamsToObject from \"./http-server/client/params-to-object.js\"\nimport path from \"node:path\"\nimport restArgsError from \"./utils/rest-args-error.js\"\nimport querystring from \"querystring\"\nimport {serializeFrontendModelTransportValue} from \"./frontend-models/transport-serialization.js\"\n\nexport default class VelociousController {\n  /**\n   * Runs before action.\n   * @param {string} methodName - Method name.\n   * @returns {void} - No return value.\n   */\n  static beforeAction(methodName) {\n    if (!this._beforeActions) {\n      /**\n       * Stores the before actions value.\n        @type {Array<string>}  */\n      this._beforeActions = []\n    }\n\n    this._beforeActions.push(methodName)\n  }\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {string} args.action - Action.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} args.controller - Controller.\n   * @param {object} args.params - Parameters object.\n   * @param {import(\"./http-server/client/request.js\").default} args.request - Request object.\n   * @param {import(\"./http-server/client/response.js\").default} args.response - Response object.\n   * @param {string} args.viewPath - View path.\n   */\n  constructor({action, configuration, controller, params, request, response, viewPath}) {\n    if (!action) throw new Error(\"No action given\")\n    if (!configuration) throw new Error(\"No configuration given\")\n    if (!controller) throw new Error(\"No controller given\")\n    if (!params) throw new Error(\"No params given\")\n    if (!request) throw new Error(\"No request given\")\n    if (!response) throw new Error(\"No response given\")\n    if (!viewPath) throw new Error(\"No viewPath given\")\n\n    this._action = action\n    this._controller = controller\n    this._configuration = configuration\n    this.logger = new Logger(this)\n    this._params = params\n    this._request = request\n    this._response = response\n    this.viewParams = {}\n    this._viewPath = viewPath\n  }\n\n  /**\n   * Runs get action.\n   * @returns {string} - The action.\n   */\n  getAction() { return this._action }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"./configuration.js\").default} - The configuration.\n   */\n  getConfiguration() { return this._configuration }\n\n  /**\n   * Runs get params.\n   * @returns {Record<string, ?>} - The params.\n   */\n  getParams() { return this._params }\n\n  /**\n   * Runs get request.\n   * @returns {import(\"./http-server/client/request.js\").default} - The request.\n   */\n  getRequest() { return this._request }\n\n  /**\n   * Runs set cookie.\n   * @param {string} name - Cookie name.\n   * @param {?} value - Cookie value.\n   * @param {object} [args] - Options object.\n   * @param {string} [args.domain] - Domain.\n   * @param {Date} [args.expires] - Expires date.\n   * @param {boolean} [args.httpOnly] - HttpOnly flag.\n   * @param {number} [args.maxAge] - Max-Age in seconds.\n   * @param {string} [args.path] - Path.\n   * @param {boolean} [args.secure] - Secure flag.\n   * @param {\"Lax\" | \"Strict\" | \"None\"} [args.sameSite] - SameSite value.\n   * @param {boolean} [args.encrypted] - Whether to encrypt the cookie value.\n   * @returns {Cookie} - Cookie instance.\n   */\n  setCookie(name, value, args = {}) {\n    const {encrypted = false, ...options} = args\n    /**\n     * Types the following value.\n      @type {string} */\n    let cookieValue\n\n    if (encrypted) {\n      const secret = this.getConfiguration().getCookieSecret()\n      if (!secret) throw new Error(\"Missing cookie secret for encrypted cookie\")\n      cookieValue = Cookie.encryptValue(value, secret)\n    } else {\n      cookieValue = String(value ?? \"\")\n    }\n\n    const cookie = new Cookie({name, value: cookieValue, options, encrypted})\n\n    this._response.addHeader(\"Set-Cookie\", cookie.toHeader())\n\n    return cookie\n  }\n\n  /**\n   * Runs get cookies.\n   * @returns {Cookie[]} - Cookies from the request.\n   */\n  getCookies() {\n    if (!this._cookies) {\n      const secret = this.getConfiguration().getCookieSecret()\n      const headerValue = this._request.header(\"cookie\")\n\n      this._cookies = Cookie.parseHeader(headerValue, secret)\n    }\n\n    return this._cookies\n  }\n\n  /**\n   * Runs get controller class.\n   * @private\n   * @returns {typeof VelociousController} - The controller class.\n   */\n  _getControllerClass() {\n    const controllerClass = /**\n                             * Types the following value.\n                              @type {typeof VelociousController} */ (this.constructor)\n\n    return controllerClass\n  }\n\n  async _runBeforeCallbacks() {\n    await this.logger.debug(\"_runBeforeCallbacks\")\n\n    let currentControllerClass = this._getControllerClass()\n\n    while (currentControllerClass) {\n      await this.logger.debug(`Running callbacks for ${currentControllerClass.name}`)\n\n      const beforeActions = currentControllerClass._beforeActions\n\n      if (beforeActions) {\n        const controllerPrototype = /**\n                                     * Types the following value.\n                                      @type {Record<string, Function | undefined>} */ (/**\n                                                                                        * Types the following value.\n                                                                                         @type {?} */ (currentControllerClass.prototype))\n\n        for (const beforeActionName of beforeActions) {\n          const beforeAction = controllerPrototype[beforeActionName]\n\n          if (!beforeAction) throw new Error(`No such before action: ${beforeActionName}`)\n\n          const boundBeforeAction = beforeAction.bind(this)\n\n          await boundBeforeAction()\n        }\n      }\n\n      currentControllerClass = Object.getPrototypeOf(currentControllerClass)\n\n      if (!currentControllerClass?.name?.endsWith(\"Controller\")) break\n    }\n\n    await this.logger.debug(\"After runBeforeCallbacks\")\n  }\n\n  /**\n   * Runs params.\n   * @returns {Record<string, ?>} - The params.\n   */\n  params() {\n    // Merge query parameters so controllers can read them via params()\n    const mergedParams = {...this.queryParameters(), ...this._params}\n\n    if (!mergedParams.controller) mergedParams.controller = this._controller\n\n    return mergedParams\n  }\n\n  /**\n   * Runs query parameters.\n   * @returns {Record<string, ?>} - The query parameters.\n   */\n  queryParameters() {\n    const query = this._request.path().split(\"?\")[1]\n\n    if (!query) return {}\n\n    try {\n      /**\n       * Unparsed params.\n        @type {Record<string, ?>} */\n      const unparsedParams = querystring.parse(query)\n      const paramsToObject = new ParamsToObject(unparsedParams)\n\n      return paramsToObject.toObject()\n    } catch (error) {\n      const ensuredError = /**\n                            * Types the following value.\n                             @type {Error & {velociousContext?: Record<string, ?>}} */ (error)\n\n      ensuredError.velociousContext = {\n        ...(ensuredError.velociousContext || {}),\n        requestParsing: {\n          httpMethod: this._request.httpMethod(),\n          parameterKeys: Object.keys(querystring.parse(query)),\n          path: this._request.path(),\n          queryPreview: query.length > 300 ? `${query.slice(0, 300)}...` : query,\n          stage: \"query-parameters\"\n        }\n      }\n\n      throw ensuredError\n    }\n  }\n\n  /**\n   * Runs render.\n   * @param {object} [args] - Options object.\n   * @param {object} [args.json] - Json.\n   * @param {number | string} [args.status] - Status.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async render({json, status, ...restArgs} = {}) {\n    restArgsError(restArgs)\n\n    // Apply the status BEFORE delegating to renderJsonArg/renderView so\n    // `render({json: {...}, status: 422})` produces a 422 response with\n    // a JSON body. The previous order short-circuited via `return\n    // this.renderJsonArg(json)` and silently dropped the status arg.\n    if (status) {\n      this._response.setStatus(status)\n    }\n\n    if (json) {\n      return this.renderJsonArg(json)\n    }\n\n    return await this.renderView()\n  }\n\n  /**\n   * Runs render json arg.\n   * @param {object} json - JSON payload.\n   */\n  renderJsonArg(json) {\n    return this._measureViewRender(() => {\n      const body = JSON.stringify(serializeFrontendModelTransportValue(json))\n\n      this._response.setHeader(\"Content-Type\", \"application/json; charset=UTF-8\")\n      this._response.setBody(body)\n    })\n  }\n\n  /**\n   * Runs render view.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  renderView() {\n    const requestTiming = this.getConfiguration().getCurrentRequestTiming()\n\n    return requestTiming\n      ? requestTiming.measure(\"views\", async () => await this._renderViewActual())\n      : this._renderViewActual()\n  }\n\n  /**\n   * Runs render view actual.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  _renderViewActual() {\n    return new Promise((resolve, reject) => {\n      const viewPath = `${this._viewPath}/${inflection.dasherize(inflection.underscore(this._action))}.ejs`\n      const actualViewParams = incorporate({controller: this}, this.viewParams)\n\n      ejs.renderFile(viewPath, actualViewParams, {}, (err, str) => {\n        if (err) {\n          const renderError = /**\n                               * Types the following value.\n                                @type {Error & {code?: string}} */ (err)\n\n          if (renderError.code === \"ENOENT\") {\n            this.logger.warn(`Missing view file: ${viewPath}`)\n\n            if (this._response.getStatusCode() === 200) {\n              this._response.setStatus(\"internal-server-error\")\n            }\n\n            this._response.setHeader(\"Content-Type\", \"text/plain; charset=UTF-8\")\n            this._response.setBody(`Missing view file: ${viewPath}`)\n\n            resolve(undefined)\n          } else {\n            reject(renderError)\n          }\n        } else {\n          this._response.setHeader(\"Content-Type\", \"text/html; charset=UTF-8\")\n          this._response.setBody(str)\n\n          resolve(undefined)\n        }\n      })\n    })\n  }\n\n  /**\n   * Runs render text.\n   * @returns {void} - No return value.\n   */\n  renderText() {\n    throw new Error(\"renderText stub\")\n  }\n\n  /**\n   * Streams a file response from disk without loading the full file into controller memory.\n   * @param {string} filePath - File path.\n   * @param {object} [args] - Options object.\n   * @param {string} [args.contentType] - Content type.\n   * @param {number | string} [args.status] - Status.\n   * @returns {void} - No return value.\n   */\n  sendFile(filePath, args = {}) {\n    this._measureViewRender(() => {\n      const {contentType, status, ...restArgs} = args\n\n      restArgsError(restArgs)\n\n      if (typeof filePath !== \"string\" || filePath.length < 1) {\n        throw new Error(`Expected file path to be a non-empty string, got: ${String(filePath)}`)\n      }\n\n      const detectedContentType = contentType || this.sendFileContentType(filePath)\n\n      if (detectedContentType) {\n        this._response.setHeader(\"Content-Type\", detectedContentType)\n      }\n\n      if (status) {\n        this._response.setStatus(status)\n      }\n\n      this._response.setFilePath(filePath)\n    })\n  }\n\n  /**\n   * Runs measure view render.\n   * @template T\n   * @param {() => T} callback - Callback to measure.\n   * @returns {T} - Callback result.\n   */\n  _measureViewRender(callback) {\n    const requestTiming = this.getConfiguration().getCurrentRequestTiming()\n\n    return requestTiming\n      ? requestTiming.measureSync(\"views\", callback)\n      : callback()\n  }\n\n  /**\n   * Runs send file content type.\n   * @param {string} filePath - File path.\n   * @returns {string} - Content type value.\n   */\n  sendFileContentType(filePath) {\n    const extension = path.extname(filePath).toLowerCase()\n\n    if (extension === \".wasm\") return \"application/wasm\"\n    if (extension === \".js\") return \"text/javascript; charset=UTF-8\"\n    if (extension === \".json\") return \"application/json; charset=UTF-8\"\n    if (extension === \".css\") return \"text/css; charset=UTF-8\"\n    if (extension === \".html\") return \"text/html; charset=UTF-8\"\n    if (extension === \".txt\") return \"text/plain; charset=UTF-8\"\n    if (extension === \".svg\") return \"image/svg+xml\"\n    if (extension === \".png\") return \"image/png\"\n    if (extension === \".jpg\" || extension === \".jpeg\") return \"image/jpeg\"\n    if (extension === \".gif\") return \"image/gif\"\n\n    return \"application/octet-stream\"\n  }\n\n  /**\n   * Runs current ability.\n   * @returns {import(\"./authorization/ability.js\").default | undefined} - Current ability for request scope.\n   */\n  currentAbility() {\n    return this.getConfiguration().getCurrentAbility()\n  }\n\n  /**\n   * Runs request.\n   * @returns {import(\"./http-server/client/request.js\").default} - The request.\n   */\n  request() { return this._request }\n\n  /**\n   * Runs response.\n   * @returns {import(\"./http-server/client/response.js\").default} - The response.\n   */\n  response() { return this._response }\n}\n"]}

package/build/src/current-configuration.d.ts

@@ -1,8 +1,10 @@
 /**
+ * Types the following value.
  * @returns {import("./configuration.js").default} - Current configuration.
  */
 export function currentConfiguration(): import("./configuration.js").default;
 /**
+ * Types the following value.
  * @param {import("./configuration.js").default} configuration - Current configuration.
  * @returns {void} - No return value.
  */

package/build/src/current-configuration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"current-configuration.d.ts","sourceRoot":"","sources":["../../src/current-configuration.js"],"names":[],"mappings":"AASA;;GAEG;AACH,wCAFa,OAAO,oBAAoB,EAAE,OAAO,CAMhD;AAED;;;GAGG;AACH,uDAHW,OAAO,oBAAoB,EAAE,OAAO,GAClC,IAAI,CAIhB;AAjBD;CAAsD"}
+{"version":3,"file":"current-configuration.d.ts","sourceRoot":"","sources":["../../src/current-configuration.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH,wCAFa,OAAO,oBAAoB,EAAE,OAAO,CAMhD;AAED;;;;GAIG;AACH,uDAHW,OAAO,oBAAoB,EAAE,OAAO,GAClC,IAAI,CAIhB;AAnBD;CAAsD"}

package/build/src/current-configuration.js

@@ -1,11 +1,14 @@
 // @ts-check
-/** @type {{currentConfiguration: import("./configuration.js").default | null}} */
+/**
+ * Shared.
+  @type {{currentConfiguration: import("./configuration.js").default | null}} */
 const shared = {
     currentConfiguration: null
 };
 class CurrentConfigurationNotSetError extends Error {
 }
 /**
+ * Types the following value.
  * @returns {import("./configuration.js").default} - Current configuration.
  */
 export function currentConfiguration() {
@@ -14,6 +17,7 @@ export function currentConfiguration() {
     return shared.currentConfiguration;
 }
 /**
+ * Types the following value.
  * @param {import("./configuration.js").default} configuration - Current configuration.
  * @returns {void} - No return value.
  */
@@ -21,4 +25,4 @@ export function setCurrentConfiguration(configuration) {
     shared.currentConfiguration = configuration;
 }
 export { CurrentConfigurationNotSetError };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVudC1jb25maWd1cmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2N1cnJlbnQtY29uZmlndXJhdGlvbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVosa0ZBQWtGO0FBQ2xGLE1BQU0sTUFBTSxHQUFHO0lBQ2Isb0JBQW9CLEVBQUUsSUFBSTtDQUMzQixDQUFBO0FBRUQsTUFBTSwrQkFBZ0MsU0FBUSxLQUFLO0NBQUc7QUFFdEQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsb0JBQW9CO0lBQ2xDLElBQUksQ0FBQyxNQUFNLENBQUMsb0JBQW9CO1FBQUUsTUFBTSxJQUFJLCtCQUErQixDQUFDLHlDQUF5QyxDQUFDLENBQUE7SUFFdEgsT0FBTyxNQUFNLENBQUMsb0JBQW9CLENBQUE7QUFDcEMsQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sVUFBVSx1QkFBdUIsQ0FBQyxhQUFhO0lBQ25ELE1BQU0sQ0FBQyxvQkFBb0IsR0FBRyxhQUFhLENBQUE7QUFDN0MsQ0FBQztBQUVELE9BQU8sRUFBQywrQkFBK0IsRUFBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbi8qKiBAdHlwZSB7e2N1cnJlbnRDb25maWd1cmF0aW9uOiBpbXBvcnQoXCIuL2NvbmZpZ3VyYXRpb24uanNcIikuZGVmYXVsdCB8IG51bGx9fSAqL1xuY29uc3Qgc2hhcmVkID0ge1xuICBjdXJyZW50Q29uZmlndXJhdGlvbjogbnVsbFxufVxuXG5jbGFzcyBDdXJyZW50Q29uZmlndXJhdGlvbk5vdFNldEVycm9yIGV4dGVuZHMgRXJyb3Ige31cblxuLyoqXG4gKiBAcmV0dXJucyB7aW1wb3J0KFwiLi9jb25maWd1cmF0aW9uLmpzXCIpLmRlZmF1bHR9IC0gQ3VycmVudCBjb25maWd1cmF0aW9uLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY3VycmVudENvbmZpZ3VyYXRpb24oKSB7XG4gIGlmICghc2hhcmVkLmN1cnJlbnRDb25maWd1cmF0aW9uKSB0aHJvdyBuZXcgQ3VycmVudENvbmZpZ3VyYXRpb25Ob3RTZXRFcnJvcihcIkEgY3VycmVudCBjb25maWd1cmF0aW9uIGhhc24ndCBiZWVuIHNldFwiKVxuXG4gIHJldHVybiBzaGFyZWQuY3VycmVudENvbmZpZ3VyYXRpb25cbn1cblxuLyoqXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4vY29uZmlndXJhdGlvbi5qc1wiKS5kZWZhdWx0fSBjb25maWd1cmF0aW9uIC0gQ3VycmVudCBjb25maWd1cmF0aW9uLlxuICogQHJldHVybnMge3ZvaWR9IC0gTm8gcmV0dXJuIHZhbHVlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2V0Q3VycmVudENvbmZpZ3VyYXRpb24oY29uZmlndXJhdGlvbikge1xuICBzaGFyZWQuY3VycmVudENvbmZpZ3VyYXRpb24gPSBjb25maWd1cmF0aW9uXG59XG5cbmV4cG9ydCB7Q3VycmVudENvbmZpZ3VyYXRpb25Ob3RTZXRFcnJvcn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVudC1jb25maWd1cmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2N1cnJlbnQtY29uZmlndXJhdGlvbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVo7O2dGQUVnRjtBQUNoRixNQUFNLE1BQU0sR0FBRztJQUNiLG9CQUFvQixFQUFFLElBQUk7Q0FDM0IsQ0FBQTtBQUVELE1BQU0sK0JBQWdDLFNBQVEsS0FBSztDQUFHO0FBRXREOzs7R0FHRztBQUNILE1BQU0sVUFBVSxvQkFBb0I7SUFDbEMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxvQkFBb0I7UUFBRSxNQUFNLElBQUksK0JBQStCLENBQUMseUNBQXlDLENBQUMsQ0FBQTtJQUV0SCxPQUFPLE1BQU0sQ0FBQyxvQkFBb0IsQ0FBQTtBQUNwQyxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSx1QkFBdUIsQ0FBQyxhQUFhO0lBQ25ELE1BQU0sQ0FBQyxvQkFBb0IsR0FBRyxhQUFhLENBQUE7QUFDN0MsQ0FBQztBQUVELE9BQU8sRUFBQywrQkFBK0IsRUFBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbi8qKlxuICogU2hhcmVkLlxuICBAdHlwZSB7e2N1cnJlbnRDb25maWd1cmF0aW9uOiBpbXBvcnQoXCIuL2NvbmZpZ3VyYXRpb24uanNcIikuZGVmYXVsdCB8IG51bGx9fSAqL1xuY29uc3Qgc2hhcmVkID0ge1xuICBjdXJyZW50Q29uZmlndXJhdGlvbjogbnVsbFxufVxuXG5jbGFzcyBDdXJyZW50Q29uZmlndXJhdGlvbk5vdFNldEVycm9yIGV4dGVuZHMgRXJyb3Ige31cblxuLyoqXG4gKiBUeXBlcyB0aGUgZm9sbG93aW5nIHZhbHVlLlxuICogQHJldHVybnMge2ltcG9ydChcIi4vY29uZmlndXJhdGlvbi5qc1wiKS5kZWZhdWx0fSAtIEN1cnJlbnQgY29uZmlndXJhdGlvbi5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGN1cnJlbnRDb25maWd1cmF0aW9uKCkge1xuICBpZiAoIXNoYXJlZC5jdXJyZW50Q29uZmlndXJhdGlvbikgdGhyb3cgbmV3IEN1cnJlbnRDb25maWd1cmF0aW9uTm90U2V0RXJyb3IoXCJBIGN1cnJlbnQgY29uZmlndXJhdGlvbiBoYXNuJ3QgYmVlbiBzZXRcIilcblxuICByZXR1cm4gc2hhcmVkLmN1cnJlbnRDb25maWd1cmF0aW9uXG59XG5cbi8qKlxuICogVHlwZXMgdGhlIGZvbGxvd2luZyB2YWx1ZS5cbiAqIEBwYXJhbSB7aW1wb3J0KFwiLi9jb25maWd1cmF0aW9uLmpzXCIpLmRlZmF1bHR9IGNvbmZpZ3VyYXRpb24gLSBDdXJyZW50IGNvbmZpZ3VyYXRpb24uXG4gKiBAcmV0dXJucyB7dm9pZH0gLSBObyByZXR1cm4gdmFsdWUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZXRDdXJyZW50Q29uZmlndXJhdGlvbihjb25maWd1cmF0aW9uKSB7XG4gIHNoYXJlZC5jdXJyZW50Q29uZmlndXJhdGlvbiA9IGNvbmZpZ3VyYXRpb25cbn1cblxuZXhwb3J0IHtDdXJyZW50Q29uZmlndXJhdGlvbk5vdFNldEVycm9yfVxuIl19