@aerokit/sdk 12.44.0

package/dist/esm/http/rs/resource-method.mjs

@@ -0,0 +1,199 @@
+import { handlerFunction } from "./resource-common";
+class ResourceMethod {
+  /**
+   * @param oConfiguration Initial configuration object.
+   * @param controller The HttpController instance.
+   * @param resource The parent Resource instance.
+   * @param mappings The parent ResourceMappings instance.
+   * @returns {ResourceMethod}
+   */
+  constructor(oConfiguration, controller, resource, mappings) {
+    this.cfg = oConfiguration || {};
+    this._resource = resource;
+    this.controller = controller;
+    if (mappings) {
+      this.resource = mappings.resource.bind(mappings);
+      this.resourcePath = this.path = this.resource;
+    }
+  }
+  /**
+   * Delegates to the HttpController's execute function to process the request.
+   */
+  execute() {
+    this.controller?.execute?.(...arguments);
+  }
+  // --- Delegation to Resource HTTP Methods for Chaining ---
+  /**
+   * Delegates to the parent Resource's 'get' method.
+   */
+  get() {
+    return this._resource?.["get"]?.(...arguments);
+  }
+  /**
+   * Delegates to the parent Resource's 'post' method.
+   */
+  post() {
+    return this._resource?.["post"]?.(...arguments);
+  }
+  /**
+   * Delegates to the parent Resource's 'put' method.
+   */
+  put() {
+    return this._resource?.["put"]?.(...arguments);
+  }
+  /**
+   * Delegates to the parent Resource's 'delete' method.
+   */
+  delete() {
+    return this._resource?.["delete"]?.(...arguments);
+  }
+  /**
+   * Delegates to the parent Resource's 'remove' method.
+   */
+  remove() {
+    return this._resource?.["remove"]?.(...arguments);
+  }
+  /**
+   * Delegates to the parent Resource's 'method' method.
+   */
+  method() {
+    return this._resource?.["method"]?.(...arguments);
+  }
+  /**
+   * Returns the configuration object for this ResourceMethod instance.
+   *
+   * @returns The configuration object.
+   */
+  configuration() {
+    return this.cfg;
+  }
+  // --- Handler Definition Methods ---
+  /**
+   * Applies a callback function for the **before** phase of processing a matched resource request.
+   *
+   * @param fHandler Callback function for the before phase.
+   * @returns The ResourceMethod instance for method chaining.
+   */
+  before(fHandler) {
+    return handlerFunction(this, this.configuration(), "before", fHandler);
+  }
+  /**
+   * Applies a callback function for processing a matched resource request (**serve** phase).
+   *
+   * @param fHandler Callback function for the serve phase.
+   * @returns The ResourceMethod instance for method chaining.
+   */
+  serve(fHandler) {
+    return handlerFunction(this, this.configuration(), "serve", fHandler);
+  }
+  /**
+   * Applies a callback function for the **catch** errors phase of processing a matched resource request.
+   *
+   * @param fHandler Callback function for the catch phase.
+   * @returns The ResourceMethod instance for method chaining.
+   */
+  catch(fHandler) {
+    return handlerFunction(this, this.configuration(), "catch", fHandler);
+  }
+  /**
+   * Applies a callback function for the **finally** phase of processing a matched resource request.
+   *
+   * @param fHandler Callback function for the finally phase.
+   * @returns The ResourceMethod instance for method chaining.
+   */
+  finally(fHandler) {
+    return handlerFunction(this, this.configuration(), "finally", fHandler);
+  }
+  // --- MIME Type Configuration Methods ---
+  /**
+   * Defines the content MIME type(s), which this ResourceMethod expects as input (**consumes**).
+   *
+   * @param mimeTypes Sets the mime types that this ResourceMethod is capable to consume.
+   * @returns The ResourceMethod instance for method chaining.
+   */
+  consumes(mimeTypes) {
+    return this.mimeSetting("consumes", mimeTypes);
+  }
+  /**
+  * Defines the HTTP response payload MIME type(s), which this ResourceMethod request processing function outputs, i.e.
+  * those that it 'produces'. At runtime, the Accept request header will be matched for compatibility with this setting
+  * to elicit request processing functions.
+  * Note that the matching is performed by compatibility, not strict equality, i.e. the MIME type format wildcards are
+  * considered too. For example, a request Accept header "*\/json" will match a produces setting "application\/json".
+  * 
+     * @example
+     * ```js
+     * rs.service()
+     *	.resource("")
+     * 		.get(function(){})
+     * 			.produces(["application\/json"])
+     * .execute();
+     * 	.
+     * ```
+     *
+     * Take care to make sure that the produces constraint correctly describes the response contenty MIME types that the request
+     * processing function can produce so that only client request that can accept them land there.
+     *
+     * A note about method argument multiplicity (string vs array of strings).
+     * One of the arguments of the produce method will translate to the response Content-Type property, which is known to be a
+     * single value header by [specification](https://tools.ietf.org/html/rfc7231#section-3.1.1.5). There are two reasons why
+     * the method accepts array and not a single value only:
+     *
+     * 1. Normally, when matched, content types are evaluated for semantic compatibility and not strict equality on both sides
+     *  - client and server. Providing a range of compatible MIME types instead of single value, increases the range of acceptable
+     * requests for procesing, while reducing the stricness of the requirements on the client making the request. For example,
+     * declaring ["text/json,"application/json"] as produced types makes requests with any of these accept headers (or a combination
+     * of them) acceptable for processing: "*\/json", "text/json", "application/json", "*\/*".
+     *
+     * 2. Although in most cases a handler function will produce payload in single format (media type), it is quite possible to
+     * desgin it also as a controller that produces alternative payload in different formats. In these cases you need produces
+     * that declares all supported media types so that the request with a relaxed Accept header matching any of them can land
+     * in this function. That makes the routing a bit less transparent and dependent on the client, but may prove valuable for
+     * certian cases.
+     *
+     * In any case it is responsibility of the request processing function to set the correct Content-Type header.
+     *
+     * @param mimeTypes Sets the mime type(s) that this ResourceMethod may produce.
+     * @returns The ResourceMethod instance for method chaining.
+     */
+  produces(mimeTypes) {
+    return this.mimeSetting("produces", mimeTypes);
+  }
+  /**
+   * Commmon function for initializng the 'consumes' and 'produces' arrays in the ResourceMethod instances.
+   * Before finalizing the configuration setup the function will remove duplicates with exact match filtering.
+   *
+   * @param mimeSettingName must be either 'consumes' or 'produces'.
+   * @param mimeTypes An array of strings formatted as mime types (type/subtype) or a single string.
+   * @returns The ResourceMethod instance to which the function is bound.
+   * @private
+   */
+  mimeSetting(mimeSettingName, mimeTypes) {
+    let arrMimeTypes;
+    if (typeof mimeTypes === "string") {
+      arrMimeTypes = [mimeTypes];
+    } else if (Array.isArray(mimeTypes)) {
+      arrMimeTypes = mimeTypes;
+    } else {
+      throw new Error("Invalid argument: " + mimeSettingName + " mime type argument must be valid MIME type string or array of such strings, but instead is " + typeof mimeTypes);
+    }
+    arrMimeTypes.forEach((mimeType) => {
+      const mt = mimeType.split("/");
+      if (mt.length !== 2 || !mt[0] || !mt[1])
+        throw new Error("Invalid argument. Not a valid MIME type format type/subtype: " + mimeType);
+    });
+    if (!this.cfg[mimeSettingName]) {
+      this.cfg[mimeSettingName] = [];
+    }
+    const existingMimes = this.cfg[mimeSettingName];
+    const newMimeTypes = arrMimeTypes.filter((mimeType) => {
+      return existingMimes.indexOf(mimeType) < 0;
+    });
+    this.cfg[mimeSettingName] = existingMimes.concat(newMimeTypes);
+    return this;
+  }
+}
+export {
+  ResourceMethod
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/http/rs/resource-method.ts"],
  "sourcesContent": ["import { handlerFunction } from \"./resource-common\";\n\n/**\n * Interface for the internal configuration object of a ResourceMethod.\n */\ninterface ResourceMethodConfig {\n    consumes?: string[];\n    produces?: string[];\n    before?: Function;\n    serve?: Function; // Could also be named 'handler'\n    catch?: Function;\n    finally?: Function;\n    // Add other relevant configuration properties as they become known\n    [key: string]: any;\n}\n\n/**\n * Constructor function for ResourceMethod instances.\n * This class handles the fluent configuration for a single HTTP method handler (e.g., GET)\n * attached to a Resource.\n * \n * /**\n * Constructor function for ResourceMethod instances.\n * All parameters of the function are optional.\n *\n * Providing oConfiguration will initialize this instance with some initial configuration instead of starting\n * entirely from scratch. Note that the configuration object schema must be compliant with the one produced by\n * the ResourceMethod itself. If this parameter is omited, setup will start from scratch.\n *\n * Provisioning controller, will inject a reference to the execute method of the controller so that it can be\n * fluently invoked in the scope of this ResourceMehtod instance as part of the method chaining flow. The execute\n * function scope is bound to the controller instance for this ResourceMethod.\n *\n * @example\n * ```js\n * rs.service()\n *  .resource('')\n * \t\t.get()\n * \t.execute();\n * ```\n *\n * Provisioning resource, will inject a reference ot the HTTP method functions of the Resource class (get, post,\n * put, delete, remove, method) so that they can be fluently invoked in the scope of this ResourceMethod instance\n * as part of the method chaining flow. The functions are bound to the resource instance for this ResourceMethod.\n *\n * @example\n * ```js\n * rs.service()\n *  .resource('')\n * \t\t.get(function(){})\n * \t\t.post(function(){})\n * \t\t.put(function(){})\n * \t\t.remove(function(){})\n * .execute();\n * ```\n *\n * Provisioning mappings, will inject a reference ot the resource method of the ResourceMappings class so that\n * it can be fluently invoked in the scope of this ResourceMethod instance as part of the method chaining flow.\n * The function is bound to the mappings instance for this ResourceMethod.\n *\n * @example\n * ```js\n * rs.service()\n *  .resource('')\n * \t\t.get(function(){})\n * \t.resource('{id}')\n * \t\t.get(function(){})\n * .execute();\n * ``\n * \n */\nexport class ResourceMethod {\n    cfg: ResourceMethodConfig;\n    _resource: any; // Reference to the parent Resource instance\n    controller: any; // Reference to the HttpController instance\n\n    // Fluent API aliases/delegates bound to ResourceMappings/Resource\n    resource: Function;\n    resourcePath: Function;\n    path: Function;\n\n    /**\n     * @param oConfiguration Initial configuration object.\n     * @param controller The HttpController instance.\n     * @param resource The parent Resource instance.\n     * @param mappings The parent ResourceMappings instance.\n     * @returns {ResourceMethod}\n     */\n    constructor(oConfiguration: any, controller: any, resource: any, mappings: any) {\n        this.cfg = oConfiguration || {};\n        this._resource = resource;\n        this.controller = controller;\n\n        if (mappings) {\n            // Bind the resource/path methods from ResourceMappings for method chaining\n            this.resource = mappings.resource.bind(mappings);\n            this.resourcePath = this.path = this.resource; // aliases\n        }\n    }\n\n    /**\n     * Delegates to the HttpController's execute function to process the request.\n     */\n    execute(): void {\n        // Use optional chaining as controller might not be available in all setups\n        this.controller?.execute?.(...arguments);\n    }\n\n    // --- Delegation to Resource HTTP Methods for Chaining ---\n\n    /**\n     * Delegates to the parent Resource's 'get' method.\n     */\n    get(): any {\n        return this._resource?.[\"get\"]?.(...arguments);\n    }\n\n    /**\n     * Delegates to the parent Resource's 'post' method.\n     */\n    post(): any {\n        return this._resource?.[\"post\"]?.(...arguments);\n    }\n\n    /**\n     * Delegates to the parent Resource's 'put' method.\n     */\n    put(): any {\n        return this._resource?.[\"put\"]?.(...arguments);\n    }\n\n    /**\n     * Delegates to the parent Resource's 'delete' method.\n     */\n    delete(): any {\n        return this._resource?.[\"delete\"]?.(...arguments);\n    }\n\n    /**\n     * Delegates to the parent Resource's 'remove' method.\n     */\n    remove(): any {\n        return this._resource?.[\"remove\"]?.(...arguments);\n    }\n\n    /**\n     * Delegates to the parent Resource's 'method' method.\n     */\n    method(): any {\n        return this._resource?.[\"method\"]?.(...arguments);\n    }\n\n    /**\n     * Returns the configuration object for this ResourceMethod instance.\n     *\n     * @returns The configuration object.\n     */\n    configuration(): ResourceMethodConfig {\n        return this.cfg;\n    };\n\n    // --- Handler Definition Methods ---\n\n    /**\n     * Applies a callback function for the **before** phase of processing a matched resource request.\n     *\n     * @param fHandler Callback function for the before phase.\n     * @returns The ResourceMethod instance for method chaining.\n     */\n    before(fHandler: Function): ResourceMethod {\n        return handlerFunction(this, this.configuration(), 'before', fHandler);\n    };\n\n    /**\n     * Applies a callback function for processing a matched resource request (**serve** phase).\n     *\n     * @param fHandler Callback function for the serve phase.\n     * @returns The ResourceMethod instance for method chaining.\n     */\n    serve(fHandler: Function): ResourceMethod {\n        return handlerFunction(this, this.configuration(), 'serve', fHandler);\n    };\n\n    /**\n     * Applies a callback function for the **catch** errors phase of processing a matched resource request.\n     *\n     * @param fHandler Callback function for the catch phase.\n     * @returns The ResourceMethod instance for method chaining.\n     */\n    catch(fHandler: Function): ResourceMethod {\n        return handlerFunction(this, this.configuration(), 'catch', fHandler);\n    };\n\n    /**\n     * Applies a callback function for the **finally** phase of processing a matched resource request.\n     *\n     * @param fHandler Callback function for the finally phase.\n     * @returns The ResourceMethod instance for method chaining.\n     */\n    finally(fHandler: Function): ResourceMethod {\n        return handlerFunction(this, this.configuration(), 'finally', fHandler);\n    };\n\n    // --- MIME Type Configuration Methods ---\n\n    /**\n     * Defines the content MIME type(s), which this ResourceMethod expects as input (**consumes**).\n     *\n     * @param mimeTypes Sets the mime types that this ResourceMethod is capable to consume.\n     * @returns The ResourceMethod instance for method chaining.\n     */\n    consumes(mimeTypes: string | string[]): ResourceMethod {\n        return this.mimeSetting('consumes', mimeTypes);\n    };\n\n    /**\n\t * Defines the HTTP response payload MIME type(s), which this ResourceMethod request processing function outputs, i.e.\n\t * those that it 'produces'. At runtime, the Accept request header will be matched for compatibility with this setting\n\t * to elicit request processing functions.\n\t * Note that the matching is performed by compatibility, not strict equality, i.e. the MIME type format wildcards are\n\t * considered too. For example, a request Accept header \"*\\/json\" will match a produces setting \"application\\/json\".\n\t * \n     * @example\n     * ```js\n     * rs.service()\n     *\t.resource(\"\")\n     * \t\t.get(function(){})\n     * \t\t\t.produces([\"application\\/json\"])\n     * .execute();\n     * \t.\n     * ```\n     *\n     * Take care to make sure that the produces constraint correctly describes the response contenty MIME types that the request\n     * processing function can produce so that only client request that can accept them land there.\n     *\n     * A note about method argument multiplicity (string vs array of strings).\n     * One of the arguments of the produce method will translate to the response Content-Type property, which is known to be a\n     * single value header by [specification](https://tools.ietf.org/html/rfc7231#section-3.1.1.5). There are two reasons why\n     * the method accepts array and not a single value only:\n     *\n     * 1. Normally, when matched, content types are evaluated for semantic compatibility and not strict equality on both sides\n     *  - client and server. Providing a range of compatible MIME types instead of single value, increases the range of acceptable\n     * requests for procesing, while reducing the stricness of the requirements on the client making the request. For example,\n     * declaring [\"text/json,\"application/json\"] as produced types makes requests with any of these accept headers (or a combination\n     * of them) acceptable for processing: \"*\\/json\", \"text/json\", \"application/json\", \"*\\/*\".\n     *\n     * 2. Although in most cases a handler function will produce payload in single format (media type), it is quite possible to\n     * desgin it also as a controller that produces alternative payload in different formats. In these cases you need produces\n     * that declares all supported media types so that the request with a relaxed Accept header matching any of them can land\n     * in this function. That makes the routing a bit less transparent and dependent on the client, but may prove valuable for\n     * certian cases.\n     *\n     * In any case it is responsibility of the request processing function to set the correct Content-Type header.\n     *\n     * @param mimeTypes Sets the mime type(s) that this ResourceMethod may produce.\n     * @returns The ResourceMethod instance for method chaining.\n     */\n    produces(mimeTypes: string | string[]): ResourceMethod {\n        return this.mimeSetting('produces', mimeTypes);\n    };\n\n    /**\n     * Commmon function for initializng the 'consumes' and 'produces' arrays in the ResourceMethod instances.\n     * Before finalizing the configuration setup the function will remove duplicates with exact match filtering.\n     *\n     * @param mimeSettingName must be either 'consumes' or 'produces'.\n     * @param mimeTypes An array of strings formatted as mime types (type/subtype) or a single string.\n     * @returns The ResourceMethod instance to which the function is bound.\n     * @private\n     */\n    private mimeSetting(mimeSettingName: 'consumes' | 'produces', mimeTypes: string | string[]): ResourceMethod {\n\n        let arrMimeTypes: string[];\n\n        if (typeof mimeTypes === 'string') {\n            arrMimeTypes = [mimeTypes];\n        } else if (Array.isArray(mimeTypes)) {\n            arrMimeTypes = mimeTypes;\n        } else {\n            throw new Error('Invalid argument: ' + mimeSettingName + ' mime type argument must be valid MIME type string or array of such strings, but instead is ' + (typeof mimeTypes));\n        }\n\n        arrMimeTypes.forEach((mimeType) => {\n            const mt = mimeType.split('/');\n            if (mt.length !== 2 || !mt[0] || !mt[1])\n                throw new Error('Invalid argument. Not a valid MIME type format type/subtype: ' + mimeType);\n            // Basic format check is sufficient\n        });\n\n        if (!this.cfg[mimeSettingName]) {\n            this.cfg[mimeSettingName] = [];\n        }\n\n        // Deduplicate entries before concatenation\n        const existingMimes: string[] = this.cfg[mimeSettingName];\n        const newMimeTypes = arrMimeTypes.filter((mimeType) => {\n            return existingMimes.indexOf(mimeType) < 0;\n        });\n\n        this.cfg[mimeSettingName] = existingMimes.concat(newMimeTypes);\n\n        return this;\n    };\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/http/rs/resource.mjs

@@ -0,0 +1,213 @@
+import { handlerFunction } from "./resource-common";
+import { ResourceMethod } from "./resource-method";
+function arrayEquals(source, target) {
+  if (source === target)
+    return true;
+  if (!Array.isArray(source) || !Array.isArray(target))
+    return false;
+  if (source !== void 0 && target === void 0 || source === void 0 && target !== void 0)
+    return false;
+  if (source.length !== target.length)
+    return false;
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] !== target[i])
+      return false;
+  }
+  return true;
+}
+class Resource {
+  /**
+      * @param sPath The base URL path for the resource.
+      * @param oConfiguration Optional configuration object (map of method handlers).
+      * @param controller Optional controller instance containing an execute method.
+      * @param mappings Optional object for resource mappings.
+      */
+  constructor(sPath, oConfiguration, controller, mappings) {
+    this.sPath = sPath;
+    this.cfg = oConfiguration || {};
+    if (controller) {
+      this.controller = controller;
+      this.execute = controller.execute.bind(controller);
+    }
+    if (mappings) {
+      this.mappings = mappings;
+    }
+  }
+  /**
+      * Sets the URL path for this resource, overriding the one specified upon its construction,
+      * if a path string is provided as argument ot the method (i.e. acts as setter),
+      * or returns the path set for this resource, if the method is invoked without arguments (i.e. acts as getter).
+      *
+      * @param sPath The path property to be set for this resource.
+      * @returns The resource instance for method chaining (setter mode), or the path set for this resource (getter mode).
+      */
+  path(sPath) {
+    if (arguments.length === 0)
+      return this.sPath;
+    this.sPath = sPath;
+    return this;
+  }
+  /**
+   * Creates a new HTTP method handling specification.
+   *
+   * @param sHttpMethod The HTTP method (method) (e.g., "GET").
+   * @param oConfiguration The handler specification(s) for this HTTP method. Can be a single object or array.
+   * @returns The ResourceMethod instance, or an array of ResourceMethod instances.
+   */
+  method(sHttpMethod, oConfiguration) {
+    if (sHttpMethod === void 0)
+      throw new Error("Illegal sHttpMethod argument: " + sHttpMethod);
+    const method = sHttpMethod.toLowerCase();
+    if (!this.cfg[method])
+      this.cfg[method] = [];
+    let arrConfig = oConfiguration || {};
+    if (!Array.isArray(arrConfig)) {
+      arrConfig = [arrConfig];
+    }
+    const handlers = [];
+    arrConfig.forEach((handlerSpec) => {
+      const consumes = handlerSpec.consumes;
+      const produces = handlerSpec.produces;
+      const _h = this.find(sHttpMethod, consumes, produces);
+      if (!_h) {
+        this.cfg[method].push(handlerSpec);
+      } else {
+        const existingSpec = this.cfg[method].find(
+          (spec) => arrayEquals(spec.consumes, consumes) && arrayEquals(spec.produces, produces)
+        );
+        if (existingSpec) {
+          for (const propName in handlerSpec) {
+            if (Object.prototype.hasOwnProperty.call(handlerSpec, propName)) {
+              existingSpec[propName] = handlerSpec[propName];
+            }
+          }
+        }
+      }
+      const finalHandlerSpec = this.cfg[method].find(
+        (spec) => arrayEquals(spec.consumes, consumes) && arrayEquals(spec.produces, produces)
+      );
+      if (finalHandlerSpec) {
+        handlers.push(new ResourceMethod(finalHandlerSpec, this.controller, this, this.mappings));
+      }
+    });
+    return handlers.length > 1 ? handlers : handlers[0];
+  }
+  /**
+      * Internal utility method to handle the logic for HTTP verb shortcut methods (get, post, etc.).
+      *
+      * @param sMethodName The HTTP method name (e.g., 'get').
+      * @param args The arguments passed to the shortcut method.
+      * @returns The ResourceMethod instance or an array of instances.
+      */
+  buildMethod(sMethodName, ...args) {
+    if (args.length > 0) {
+      if (typeof args[0] === "function") {
+        return this.method(sMethodName).serve(args[0]);
+      } else if (typeof args[0] === "object" && args[0] !== null) {
+        return this.method(sMethodName, args[0]);
+      } else {
+        throw new Error(`Invalid argument: Resource.${sMethodName} method first argument must be valid javascript function or configuration object, but instead is ${typeof args[0]} ${args[0]}`);
+      }
+    } else {
+      return this.method(sMethodName);
+    }
+  }
+  get() {
+    return this.buildMethod("get", ...arguments);
+  }
+  post() {
+    return this.buildMethod("post", ...arguments);
+  }
+  put() {
+    return this.buildMethod("put", ...arguments);
+  }
+  delete() {
+    return this.buildMethod("delete", ...arguments);
+  }
+  remove() {
+    return this.buildMethod("delete", ...arguments);
+  }
+  /**
+   * Finds a ResourceMethod with the given constraints.
+   *
+   * @param sVerb The name of the method property of the ResourceMethod in search (e.g., "GET").
+   * @param arrConsumesMimeTypeStrings The consumes constraint property of the ResourceMethod in search.
+   * @param arrProducesMimeTypeStrings The produces constraint property of the ResourceMethod in search.
+   * @returns The found ResourceMethod instance, or undefined if not found.
+   */
+  find(sVerb, arrConsumesMimeTypeStrings, arrProducesMimeTypeStrings) {
+    let hit;
+    const sVerbLower = sVerb.toLowerCase();
+    Object.keys(this.cfg).filter((sVerbName) => sVerbName === sVerbLower).forEach((sVerbName) => {
+      this.cfg[sVerbName].forEach((verbHandlerSpec) => {
+        if (arrayEquals(verbHandlerSpec.consumes, arrConsumesMimeTypeStrings) && arrayEquals(verbHandlerSpec.produces, arrProducesMimeTypeStrings)) {
+          hit = new ResourceMethod(verbHandlerSpec, this.controller, this, this.mappings);
+          return;
+        }
+      });
+      if (hit)
+        return;
+    });
+    return hit;
+  }
+  /**
+   * Returns the configuration of this resource.
+   *
+   * @returns The resource configuration object.
+   */
+  configuration() {
+    return this.cfg;
+  }
+  /**
+   * Instructs redirection of the request base don the parameter. If it is a stirng representing URI, the request will be
+   * redirected to this URI for any method. If it's a function it will be invoked and epxected to return a URI string to redirect to.
+   *
+   * @param fRedirector The function or string URI to redirect to.
+      * @returns The resource instance for method chaining.
+   */
+  redirect(fRedirector) {
+    if (typeof fRedirector === "string") {
+      const redirectUri = fRedirector;
+      fRedirector = function() {
+        return redirectUri;
+      };
+    }
+    return handlerFunction(this, this.configuration(), "redirect", fRedirector);
+  }
+  /**
+   * Disables the ResourceMethods that match the given constraints
+      *
+      * @param sVerb The HTTP verb (e.g., "GET").
+   * @param arrConsumesTypeStrings The consumes constraint property of the ResourceMethod in search.
+   * @param arrProducesTypeStrings The produces constraint property of the ResourceMethod in search.
+      * @returns The resource instance for method chaining.
+   */
+  disable(sVerb, arrConsumesTypeStrings, arrProducesTypeStrings) {
+    Object.keys(this.cfg).filter((sVerbName) => sVerb === void 0 || sVerb && sVerb.toLowerCase() === sVerbName).forEach((sVerbName) => {
+      for (let i = this.cfg[sVerbName].length - 1; i >= 0; i--) {
+        const verbHandlerSpec = this.cfg[sVerbName][i];
+        if (arrayEquals(verbHandlerSpec.consumes, arrConsumesTypeStrings) && arrayEquals(verbHandlerSpec.produces, arrProducesTypeStrings)) {
+          this.cfg[sVerbName].splice(i, 1);
+        }
+      }
+    });
+    return this;
+  }
+  /**
+   * Disables all but 'read' HTTP methods in this resource (GET, HEAD, TRACE).
+      *
+      * @returns The resource instance for method chaining.
+   */
+  readonly() {
+    Object.keys(this.cfg).forEach((method) => {
+      if (!["get", "head", "trace"].includes(method)) {
+        delete this.cfg[method];
+      }
+    });
+    return this;
+  }
+}
+export {
+  Resource
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/http/rs/resource.ts"],
  "sourcesContent": ["import { handlerFunction } from \"./resource-common\";\nimport { ResourceMethod } from \"./resource-method\";\n\n/**\n * Compares two arrays for equality by inspecting if they are arrays, refer to the same instance,\n * have same length and contain equal components in the same order.\n *\n * @param source The source array to compare to.\n * @param target The target array to compare with.\n * @returns true if the arrays are equal, false otherwise.\n */\nfunction arrayEquals(source: any[] | undefined, target: any[] | undefined): boolean {\n\tif (source === target)\n\t\treturn true;\n\tif (!Array.isArray(source) || !Array.isArray(target))\n\t\treturn false;\n\tif (source !== undefined && target === undefined || source === undefined && target !== undefined)\n\t\treturn false;\n\tif (source.length !== target.length)\n\t\treturn false;\n\tfor (let i = 0; i < source.length; i++) {\n\t\tif (source[i] !== target[i])\n\t\t\treturn false;\n\t}\n\treturn true;\n}\n\n/**\n * Constructs a new Resource instance, initialized with the supplied path parameter and optionally with the second, configuration object parameter.\n */\nexport class Resource {\n    /** The URL path for this resource. */\n\tsPath: string;\n    /** The resource configuration mapping methods to handler specifications. */\n\tcfg: any;\n    /** The optional controller instance. */\n\tcontroller: any;\n    /** Bound execute function from the controller. */\n\texecute: Function | undefined;\n    /** Additional mappings object. */\n\tmappings: any;\n\n\t/**\n     * @param sPath The base URL path for the resource.\n     * @param oConfiguration Optional configuration object (map of method handlers).\n     * @param controller Optional controller instance containing an execute method.\n     * @param mappings Optional object for resource mappings.\n     */\n\tconstructor(sPath: string, oConfiguration?: any, controller?: any, mappings?: any) {\n\t\tthis.sPath = sPath;\n\t\tthis.cfg = oConfiguration || {};\n\n\t\tif (controller) {\n\t\t\tthis.controller = controller;\n\t\t\t// Bind the controller's execute function\n\t\t\tthis.execute = controller.execute.bind(controller);\n\t\t}\n\t\tif (mappings) {\n\t\t\tthis.mappings = mappings;\n\t\t}\n\t}\n\n\t/**\n     * Sets the URL path for this resource, overriding the one specified upon its construction,\n     * if a path string is provided as argument ot the method (i.e. acts as setter),\n     * or returns the path set for this resource, if the method is invoked without arguments (i.e. acts as getter).\n     *\n     * @param sPath The path property to be set for this resource.\n     * @returns The resource instance for method chaining (setter mode), or the path set for this resource (getter mode).\n     */\n\tpath(sPath?: string): Resource | string {\n\t\tif (arguments.length === 0)\n\t\t\treturn this.sPath;\n\t\tthis.sPath = sPath!;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Creates a new HTTP method handling specification.\n\t *\n\t * @param sHttpMethod The HTTP method (method) (e.g., \"GET\").\n\t * @param oConfiguration The handler specification(s) for this HTTP method. Can be a single object or array.\n\t * @returns The ResourceMethod instance, or an array of ResourceMethod instances.\n\t */\n\tmethod(sHttpMethod: string, oConfiguration?: any | any[]): ResourceMethod | ResourceMethod[] {\n\t\tif (sHttpMethod === undefined)\n\t\t\tthrow new Error('Illegal sHttpMethod argument: ' + sHttpMethod);\n\n\t\tconst method = sHttpMethod.toLowerCase();\n\n\t\tif (!this.cfg[method])\n\t\t\tthis.cfg[method] = [];\n\n\t\tlet arrConfig: any[] = oConfiguration || {};\n\t\tif (!Array.isArray(arrConfig)) {\n\t\t\tarrConfig = [arrConfig];\n\t\t}\n\n\t\tconst handlers: ResourceMethod[] = [];\n\n\t\tarrConfig.forEach((handlerSpec) => {\n\t\t\t// Type casting to handle object property access for consumes/produces\n\t\t\tconst consumes = (handlerSpec as { consumes?: string[] }).consumes;\n\t\t\tconst produces = (handlerSpec as { produces?: string[] }).produces;\n\n\t\t\tconst _h = this.find(sHttpMethod, consumes, produces);\n\t\t\tif (!_h) {\n\t\t\t\t// create new\n\t\t\t\tthis.cfg[method].push(handlerSpec);\n\t\t\t} else {\n\t\t\t\t// update existing spec in cfg\n\t\t\t\tconst existingSpec = this.cfg[method].find(\n                    (spec: any) => arrayEquals(spec.consumes, consumes) && arrayEquals(spec.produces, produces)\n                );\n\t\t\t\tif (existingSpec) {\n\t\t\t\t\tfor (const propName in handlerSpec) {\n\t\t\t\t\t\tif (Object.prototype.hasOwnProperty.call(handlerSpec, propName)) {\n\t\t\t\t\t\t\texistingSpec[propName] = handlerSpec[propName];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n            // Create a new ResourceMethod instance for the (potentially updated) spec\n            const finalHandlerSpec = this.cfg[method].find(\n                (spec: any) => arrayEquals(spec.consumes, consumes) && arrayEquals(spec.produces, produces)\n            );\n\n            if (finalHandlerSpec) {\n                handlers.push(new ResourceMethod(finalHandlerSpec, this.controller, this, this.mappings));\n            }\n\t\t});\n\n\t\treturn handlers.length > 1 ? handlers : handlers[0];\n\t};\n\n\t/**\n     * Internal utility method to handle the logic for HTTP verb shortcut methods (get, post, etc.).\n     *\n     * @param sMethodName The HTTP method name (e.g., 'get').\n     * @param args The arguments passed to the shortcut method.\n     * @returns The ResourceMethod instance or an array of instances.\n     */\n\tprivate buildMethod(sMethodName: string, ...args: (Function | any)[]): ResourceMethod | ResourceMethod[] {\n\t\tif (args.length > 0) {\n\t\t\tif (typeof args[0] === 'function') {\n\t\t\t\t// .get(function) -> .method('get').serve(function)\n                // Note: We need to cast the result of method() to access serve() as it returns a ResourceMethod.\n\t\t\t\treturn (this.method(sMethodName) as ResourceMethod).serve(args[0]);\n\t\t\t} else if (typeof args[0] === 'object' && args[0] !== null) {\n\t\t\t\t// .get({config}) -> .method('get', {config})\n\t\t\t\treturn this.method(sMethodName, args[0]);\n\t\t\t} else {\n\t\t\t\tthrow new Error(`Invalid argument: Resource.${sMethodName} method first argument must be valid javascript function or configuration object, but instead is ${typeof args[0]} ${args[0]}`);\n\t\t\t}\n\t\t} else {\n\t\t\t// .get() -> .method('get')\n\t\t\treturn this.method(sMethodName) as ResourceMethod;\n\t\t}\n\t};\n\n\t/**\n\t * Creates a handling specification for the HTTP method \"GET\".\n\t * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.\n\t * @returns The ResourceMethod instance or array.\n\t */\n\tget(fServeCb: Function): ResourceMethod;\n    get(oConfiguration: any): ResourceMethod | ResourceMethod[];\n    get(): ResourceMethod;\n\tget(): ResourceMethod | ResourceMethod[] {\n\t\treturn this.buildMethod('get', ...arguments);\n\t};\n\n\t/**\n\t * Creates a handling specification for the HTTP method \"POST\".\n\t * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.\n\t * @returns The ResourceMethod instance or array.\n\t */\n\tpost(fServeCb: Function): ResourceMethod;\n    post(oConfiguration: any): ResourceMethod | ResourceMethod[];\n    post(): ResourceMethod;\n\tpost(): ResourceMethod | ResourceMethod[] {\n\t\treturn this.buildMethod('post', ...arguments);\n\t};\n\n\t/**\n\t * Creates a handling specification for the HTTP method \"PUT\".\n\t * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.\n\t * @returns The ResourceMethod instance or array.\n\t */\n\tput(fServeCb: Function): ResourceMethod;\n    put(oConfiguration: any): ResourceMethod | ResourceMethod[];\n    put(): ResourceMethod;\n\tput(): ResourceMethod | ResourceMethod[] {\n\t\treturn this.buildMethod('put', ...arguments);\n\t};\n\n\t/**\n\t * Creates a handling specification for the HTTP method \"DELETE\".\n\t * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.\n\t * @returns The ResourceMethod instance or array.\n\t */\n\tdelete(fServeCb: Function): ResourceMethod;\n    delete(oConfiguration: any): ResourceMethod | ResourceMethod[];\n    delete(): ResourceMethod;\n\tdelete(): ResourceMethod | ResourceMethod[] {\n\t\treturn this.buildMethod('delete', ...arguments);\n\t};\n\n    /**\n\t * Creates a handling specification for the HTTP method \"DELETE\" (alias for delete()).\n\t * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.\n\t * @returns The ResourceMethod instance or array.\n\t */\n    remove(fServeCb: Function): ResourceMethod;\n    remove(oConfiguration: any): ResourceMethod | ResourceMethod[];\n    remove(): ResourceMethod;\n\tremove(): ResourceMethod | ResourceMethod[] {\n\t\treturn this.buildMethod('delete', ...arguments);\n\t}\n\n\t/**\n\t * Finds a ResourceMethod with the given constraints.\n\t *\n\t * @param sVerb The name of the method property of the ResourceMethod in search (e.g., \"GET\").\n\t * @param arrConsumesMimeTypeStrings The consumes constraint property of the ResourceMethod in search.\n\t * @param arrProducesMimeTypeStrings The produces constraint property of the ResourceMethod in search.\n\t * @returns The found ResourceMethod instance, or undefined if not found.\n\t */\n\tfind(sVerb: string, arrConsumesMimeTypeStrings?: string[], arrProducesMimeTypeStrings?: string[]): ResourceMethod | undefined {\n\t\tlet hit: ResourceMethod | undefined;\n\t\tconst sVerbLower = sVerb.toLowerCase();\n\n\t\tObject.keys(this.cfg)\n            .filter((sVerbName) => sVerbName === sVerbLower)\n            .forEach((sVerbName) => {\n\t\t\t    this.cfg[sVerbName].forEach((verbHandlerSpec: any) => {\n\t\t\t\t    if (arrayEquals(verbHandlerSpec.consumes, arrConsumesMimeTypeStrings) && arrayEquals(verbHandlerSpec.produces, arrProducesMimeTypeStrings)) {\n\t\t\t\t\t    hit = new ResourceMethod(verbHandlerSpec, this.controller, this, this.mappings);\n\t\t\t\t\t    return;\n\t\t\t\t    }\n\t\t\t    });\n\t\t\t    if (hit)\n\t\t\t\t    return;\n\t\t});\n\t\treturn hit;\n\t};\n\n\t/**\n\t * Returns the configuration of this resource.\n\t *\n\t * @returns The resource configuration object.\n\t */\n\tconfiguration(): any {\n\t\treturn this.cfg;\n\t};\n\n\t/**\n\t * Instructs redirection of the request base don the parameter. If it is a stirng representing URI, the request will be\n\t * redirected to this URI for any method. If it's a function it will be invoked and epxected to return a URI string to redirect to.\n\t *\n\t * @param fRedirector The function or string URI to redirect to.\n     * @returns The resource instance for method chaining.\n\t */\n\tredirect(fRedirector: string | Function): Resource {\n\t\tif (typeof fRedirector === 'string') {\n\t\t\tconst redirectUri = fRedirector;\n\t\t\tfRedirector = function () {\n\t\t\t\treturn redirectUri;\n\t\t\t}\n\t\t}\n\t\t// The imported handlerFunction is used here\n\t\treturn handlerFunction(this, this.configuration(), 'redirect', fRedirector);\n\t};\n\n\t/**\n\t * Disables the ResourceMethods that match the given constraints\n     *\n     * @param sVerb The HTTP verb (e.g., \"GET\").\n\t * @param arrConsumesTypeStrings The consumes constraint property of the ResourceMethod in search.\n\t * @param arrProducesTypeStrings The produces constraint property of the ResourceMethod in search.\n     * @returns The resource instance for method chaining.\n\t */\n\tdisable(sVerb?: string, arrConsumesTypeStrings?: string[], arrProducesTypeStrings?: string[]): Resource {\n\t\tObject.keys(this.cfg)\n            .filter((sVerbName) => sVerb === undefined || (sVerb && sVerb.toLowerCase() === sVerbName))\n            .forEach((sVerbName) => {\n\t\t\t    // Use a reverse loop for safe splicing\n\t\t\t    for (let i = this.cfg[sVerbName].length - 1; i >= 0; i--) {\n                    const verbHandlerSpec = this.cfg[sVerbName][i];\n\t\t\t\t    if (arrayEquals(verbHandlerSpec.consumes, arrConsumesTypeStrings) && arrayEquals(verbHandlerSpec.produces, arrProducesTypeStrings)) {\n\t\t\t\t\t    this.cfg[sVerbName].splice(i, 1);\n                    }\n                }\n\t\t});\n\t\treturn this;\n\t};\n\n\t/**\n\t * Disables all but 'read' HTTP methods in this resource (GET, HEAD, TRACE).\n     *\n     * @returns The resource instance for method chaining.\n\t */\n\treadonly(): Resource {\n\t\tObject.keys(this.cfg).forEach((method) => {\n\t\t\tif (!['get', 'head', 'trace'].includes(method)) {\n\t\t\t\tdelete this.cfg[method];\n            }\n\t\t});\n\t\treturn this;\n\t};\n}"],
  "mappings": "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",
  "names": []
}


package/dist/esm/http/rs.mjs

@@ -0,0 +1,12 @@
+import { service, HttpController } from "./rs/resource-http-controller";
+import { ResourceMethod } from "./rs/resource-method";
+import { ResourceMappings } from "./rs/resource-mappings";
+import { Resource } from "./rs/resource";
+export {
+  HttpController,
+  Resource,
+  ResourceMappings,
+  ResourceMethod,
+  service
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2h0dHAvcnMudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCB7IHNlcnZpY2UsIEh0dHBDb250cm9sbGVyIH0gZnJvbSBcIi4vcnMvcmVzb3VyY2UtaHR0cC1jb250cm9sbGVyXCI7XG5leHBvcnQgeyBSZXNvdXJjZU1ldGhvZCB9IGZyb20gXCIuL3JzL3Jlc291cmNlLW1ldGhvZFwiO1xuZXhwb3J0IHsgUmVzb3VyY2VNYXBwaW5ncyB9IGZyb20gXCIuL3JzL3Jlc291cmNlLW1hcHBpbmdzXCI7XG5leHBvcnQgeyBSZXNvdXJjZSB9IGZyb20gXCIuL3JzL3Jlc291cmNlXCI7Il0sCiAgIm1hcHBpbmdzIjogIkFBQUEsU0FBUyxTQUFTLHNCQUFzQjtBQUN4QyxTQUFTLHNCQUFzQjtBQUMvQixTQUFTLHdCQUF3QjtBQUNqQyxTQUFTLGdCQUFnQjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/http/session.mjs

@@ -0,0 +1,105 @@
+const HttpSessionFacade = Java.type("org.eclipse.dirigible.components.api.http.HttpSessionFacade");
+class Session {
+  /**
+   * Checks if a session is currently valid and active for the request context.
+   * @returns True if the session is valid, false otherwise (e.g., if it has been invalidated or timed out).
+   */
+  static isValid() {
+    return HttpSessionFacade.isValid();
+  }
+  /**
+   * Retrieves the value of a named attribute stored in the session.
+   * Note: The underlying Java facade typically stores strings, but the value may represent
+      * serialized data that should be parsed if complex.
+   * @param name The name of the attribute.
+   * @returns The attribute value as a string, or null/undefined if not found.
+   */
+  static getAttribute(name) {
+    return HttpSessionFacade.getAttribute(name);
+  }
+  /**
+   * Retrieves an array of all attribute names currently stored in the session.
+   * The names are retrieved as a JSON string from the facade and then parsed.
+   * @returns An array of attribute names (strings), or an empty array if no attributes are present.
+   */
+  static getAttributeNames() {
+    const attrNames = HttpSessionFacade.getAttributeNamesJson();
+    return attrNames ? JSON.parse(attrNames) : [];
+  }
+  /**
+   * Returns the time at which this session was created, converted to a JavaScript Date object.
+   * @returns A Date object representing the session's creation time.
+   */
+  static getCreationTime() {
+    return new Date(HttpSessionFacade.getCreationTime());
+  }
+  /**
+   * Returns the unique identifier assigned to this session.
+   * @returns The session ID string.
+   */
+  static getId() {
+    return HttpSessionFacade.getId();
+  }
+  /**
+   * Returns the last time the client accessed this session, converted to a JavaScript Date object.
+   * Access includes requests that retrieve or set session attributes.
+   * @returns A Date object representing the last access time.
+   */
+  static getLastAccessedTime() {
+    return new Date(HttpSessionFacade.getLastAccessedTime());
+  }
+  /**
+   * Returns the maximum time interval, in seconds, that the server should keep this session open
+   * between client requests. After this interval, the session will be invalidated.
+   * @returns The maximum inactive interval in seconds.
+   */
+  static getMaxInactiveInterval() {
+    return HttpSessionFacade.getMaxInactiveInterval();
+  }
+  /**
+   * Invalidates this session, unbinding any objects bound to it.
+   * After this call, the session is no longer valid.
+   */
+  static invalidate() {
+    HttpSessionFacade.invalidate();
+  }
+  /**
+   * Checks if the client does not yet know about the session, typically meaning
+   * the server has not yet returned the session ID via a cookie or encoded URL.
+   * @returns True if the session is new (not yet used in a response), false otherwise.
+   */
+  static isNew() {
+    return HttpSessionFacade.isNew();
+  }
+  /**
+   * Binds an object to this session, using the specified name.
+   * This is the primary way to store data in the user's session.
+   * @param name The name to bind the object under.
+   * @param value The value/object to store in the session.
+   */
+  static setAttribute(name, value) {
+    HttpSessionFacade.setAttribute(name, value);
+  }
+  /**
+   * Removes the attribute with the given name from the session.
+   * @param name The name of the attribute to remove.
+   */
+  static removeAttribute(name) {
+    HttpSessionFacade.removeAttribute(name);
+  }
+  /**
+   * Specifies the maximum time interval, in seconds, that the server should keep this session open
+   * between client requests before automatically invalidating it.
+   * @param interval The new interval in seconds.
+   */
+  static setMaxInactiveInterval(interval) {
+    HttpSessionFacade.setMaxInactiveInterval(interval);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Session;
+}
+export {
+  Session
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/http/session.ts"],
  "sourcesContent": ["/**\n * Provides a static fa\u00E7ade (`Session` class) for accessing and manipulating\n * the HTTP session associated with the current request. This module is often used\n * to store user-specific data during their interaction with the application.\n */\n\nconst HttpSessionFacade = Java.type(\"org.eclipse.dirigible.components.api.http.HttpSessionFacade\");\n\n/**\n * The static Session class provides methods to interact with the current user session\n * (e.g., storing attributes, checking status, managing lifetime).\n */\nexport class Session {\n\n\t/**\n\t * Checks if a session is currently valid and active for the request context.\n\t * @returns True if the session is valid, false otherwise (e.g., if it has been invalidated or timed out).\n\t */\n\tpublic static isValid(): boolean {\n\t\treturn HttpSessionFacade.isValid();\n\t}\n\n\t/**\n\t * Retrieves the value of a named attribute stored in the session.\n\t * Note: The underlying Java facade typically stores strings, but the value may represent\n     * serialized data that should be parsed if complex.\n\t * @param name The name of the attribute.\n\t * @returns The attribute value as a string, or null/undefined if not found.\n\t */\n\tpublic static getAttribute(name: string): string {\n\t\treturn HttpSessionFacade.getAttribute(name);\n\t}\n\n\t/**\n\t * Retrieves an array of all attribute names currently stored in the session.\n\t * The names are retrieved as a JSON string from the facade and then parsed.\n\t * @returns An array of attribute names (strings), or an empty array if no attributes are present.\n\t */\n\tpublic static getAttributeNames(): string[] {\n\t\tconst attrNames = HttpSessionFacade.getAttributeNamesJson();\n\t\treturn attrNames ? JSON.parse(attrNames) : [];\n\t}\n\n\t/**\n\t * Returns the time at which this session was created, converted to a JavaScript Date object.\n\t * @returns A Date object representing the session's creation time.\n\t */\n\tpublic static getCreationTime(): Date {\n\t\t// The facade returns time in milliseconds since the epoch, which Date() accepts.\n\t\treturn new Date(HttpSessionFacade.getCreationTime());\n\t}\n\n\t/**\n\t * Returns the unique identifier assigned to this session.\n\t * @returns The session ID string.\n\t */\n\tpublic static getId(): string {\n\t\treturn HttpSessionFacade.getId();\n\t}\n\n\t/**\n\t * Returns the last time the client accessed this session, converted to a JavaScript Date object.\n\t * Access includes requests that retrieve or set session attributes.\n\t * @returns A Date object representing the last access time.\n\t */\n\tpublic static getLastAccessedTime(): Date {\n\t\t// The facade returns time in milliseconds since the epoch.\n\t\treturn new Date(HttpSessionFacade.getLastAccessedTime());\n\t}\n\n\t/**\n\t * Returns the maximum time interval, in seconds, that the server should keep this session open\n\t * between client requests. After this interval, the session will be invalidated.\n\t * @returns The maximum inactive interval in seconds.\n\t */\n\tpublic static getMaxInactiveInterval(): number {\n\t\treturn HttpSessionFacade.getMaxInactiveInterval();\n\t}\n\n\t/**\n\t * Invalidates this session, unbinding any objects bound to it.\n\t * After this call, the session is no longer valid.\n\t */\n\tpublic static invalidate(): void {\n\t\tHttpSessionFacade.invalidate();\n\t}\n\n\t/**\n\t * Checks if the client does not yet know about the session, typically meaning\n\t * the server has not yet returned the session ID via a cookie or encoded URL.\n\t * @returns True if the session is new (not yet used in a response), false otherwise.\n\t */\n\tpublic static isNew(): boolean {\n\t\treturn HttpSessionFacade.isNew();\n\t}\n\n\t/**\n\t * Binds an object to this session, using the specified name.\n\t * This is the primary way to store data in the user's session.\n\t * @param name The name to bind the object under.\n\t * @param value The value/object to store in the session.\n\t */\n\tpublic static setAttribute(name: string, value: any): void {\n\t\tHttpSessionFacade.setAttribute(name, value);\n\t}\n\n\t/**\n\t * Removes the attribute with the given name from the session.\n\t * @param name The name of the attribute to remove.\n\t */\n\tpublic static removeAttribute(name: string): void {\n\t\tHttpSessionFacade.removeAttribute(name);\n\t}\n\n\t/**\n\t * Specifies the maximum time interval, in seconds, that the server should keep this session open\n\t * between client requests before automatically invalidating it.\n\t * @param interval The new interval in seconds.\n\t */\n\tpublic static setMaxInactiveInterval(interval: number): void {\n\t\tHttpSessionFacade.setMaxInactiveInterval(interval);\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Session;\n}"],
  "mappings": "AAMA,MAAM,oBAAoB,KAAK,KAAK,6DAA6D;AAM1F,MAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,EAMpB,OAAc,UAAmB;AAChC,WAAO,kBAAkB,QAAQ;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,aAAa,MAAsB;AAChD,WAAO,kBAAkB,aAAa,IAAI;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,oBAA8B;AAC3C,UAAM,YAAY,kBAAkB,sBAAsB;AAC1D,WAAO,YAAY,KAAK,MAAM,SAAS,IAAI,CAAC;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,kBAAwB;AAErC,WAAO,IAAI,KAAK,kBAAkB,gBAAgB,CAAC;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,QAAgB;AAC7B,WAAO,kBAAkB,MAAM;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,sBAA4B;AAEzC,WAAO,IAAI,KAAK,kBAAkB,oBAAoB,CAAC;AAAA,EACxD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,yBAAiC;AAC9C,WAAO,kBAAkB,uBAAuB;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,aAAmB;AAChC,sBAAkB,WAAW;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,QAAiB;AAC9B,WAAO,kBAAkB,MAAM;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,aAAa,MAAc,OAAkB;AAC1D,sBAAkB,aAAa,MAAM,KAAK;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,gBAAgB,MAAoB;AACjD,sBAAkB,gBAAgB,IAAI;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,uBAAuB,UAAwB;AAC5D,sBAAkB,uBAAuB,QAAQ;AAAA,EAClD;AACD;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}
