@aerokit/sdk 12.44.0

package/dist/cjs/net/soap.js

@@ -0,0 +1,228 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var soap_exports = {};
+__export(soap_exports, {
+  SOAP: () => SOAP
+});
+module.exports = __toCommonJS(soap_exports);
+var import_request = require("@aerokit/sdk/http/request");
+var import_base64 = require("@aerokit/sdk/utils/base64");
+var import_streams = require("@aerokit/sdk/io/streams");
+const MessageFactory = Java.type("jakarta.xml.soap.MessageFactory");
+const MimeHeadersInternal = Java.type("jakarta.xml.soap.MimeHeaders");
+const SOAPConnectionFactory = Java.type("jakarta.xml.soap.SOAPConnectionFactory");
+class SOAP {
+  /**
+   * Call a given SOAP endpoint with a given request message
+   * @param message The SOAP Message wrapper object.
+   * @param url The target SOAP endpoint URL.
+   */
+  static call(message, url) {
+    const soapConnectionFactory = SOAPConnectionFactory.newInstance();
+    const internalConnection = soapConnectionFactory.createConnection();
+    const internalResponse = internalConnection.call(message.native, url);
+    return new Message(internalResponse);
+  }
+  static trustAll() {
+  }
+  /**
+   * Creates a new, empty SOAP message.
+   */
+  static createMessage() {
+    return new Message(MessageFactory.newInstance().createMessage());
+  }
+  /**
+   * Parses a SOAP message from an InputStream and MimeHeaders.
+   * @param mimeHeaders The MimeHeaders wrapper object.
+   * @param inputStream The InputStream wrapper object.
+   */
+  static parseMessage(mimeHeaders, inputStream) {
+    const internalFactory = MessageFactory.newInstance();
+    if (inputStream.native) {
+      try {
+        const internalMessage = internalFactory.createMessage(mimeHeaders.native, inputStream.native);
+        const internalPart = internalMessage.getSOAPPart();
+        internalPart.getEnvelope();
+        return new Message(internalMessage);
+      } catch (e) {
+        console.error(e);
+        throw new Error("Input provided is null or in a wrong format. HTTP method used must be POST. " + e.message);
+      }
+    }
+    throw new Error("Input provided is null.");
+  }
+  /**
+   * Parses a SOAP message from the current HTTP request input stream.
+   */
+  static parseRequest() {
+    if (import_request.Request.getMethod().toUpperCase() !== "POST") {
+      throw new Error("HTTP method used must be POST.");
+    }
+    const inputStream = import_request.Request.getInputStream();
+    const mimeHeaders = this.createMimeHeaders();
+    return this.parseMessage(mimeHeaders, inputStream);
+  }
+  /**
+   * Creates a new, empty MimeHeaders object.
+   */
+  static createMimeHeaders() {
+    const internalMimeHeaders = new MimeHeadersInternal();
+    return new MimeHeaders(internalMimeHeaders);
+  }
+}
+class Message {
+  constructor(native) {
+    this.native = native;
+  }
+  getPart() {
+    return new Part(this.native.getSOAPPart());
+  }
+  getMimeHeaders() {
+    return new MimeHeaders(this.native.getMimeHeaders());
+  }
+  save() {
+    this.native.saveChanges();
+  }
+  getText() {
+    const outputStream = import_streams.Streams.createByteArrayOutputStream();
+    this.native.writeTo(outputStream.native);
+    return outputStream.getText();
+  }
+}
+class Part {
+  constructor(native) {
+    this.native = native;
+  }
+  getEnvelope() {
+    return new Envelope(this.native.getEnvelope());
+  }
+}
+class MimeHeaders {
+  constructor(native) {
+    this.native = native;
+  }
+  addHeader(name, value) {
+    this.native.addHeader(name, value);
+  }
+  addBasicAuthenticationHeader(username, password) {
+    const userAndPassword = `${username}:${password}`;
+    const basicAuth = import_base64.Base64.encode(userAndPassword);
+    this.native.addHeader("Authorization", `Basic ${basicAuth}`);
+  }
+}
+class Envelope {
+  constructor(native) {
+    this.native = native;
+  }
+  addNamespaceDeclaration(prefix, uri) {
+    this.native.addNamespaceDeclaration(prefix, uri);
+  }
+  getBody() {
+    return new Body(this.native.getBody());
+  }
+  getHeader() {
+    return new Header(this.native.getHeader());
+  }
+  createName(localName, prefix, uri) {
+    return new Name(this.native.createName(localName, prefix, uri));
+  }
+}
+class Body {
+  constructor(native) {
+    this.native = native;
+  }
+  addChildElement(localName, prefix) {
+    return new Element(this.native.addChildElement(localName, prefix));
+  }
+  getChildElements() {
+    const childElements = [];
+    const internalElementsIterator = this.native.getChildElements();
+    while (internalElementsIterator.hasNext()) {
+      childElements.push(new Element(internalElementsIterator.next()));
+    }
+    return childElements;
+  }
+}
+class Header {
+  constructor(native) {
+    this.native = native;
+  }
+  addHeaderElement(element) {
+    this.native.addHeaderElement(element.native);
+  }
+}
+class Name {
+  constructor(native) {
+    this.native = native;
+  }
+  getNative() {
+    return this.native;
+  }
+  getLocalName() {
+    return this.native.getLocalName();
+  }
+  getPrefix() {
+    return this.native.getPrefix();
+  }
+  getQualifiedName() {
+    return this.native.getQualifiedName();
+  }
+  getURI() {
+    return this.native.getURI();
+  }
+}
+class Element {
+  constructor(native) {
+    this.native = native;
+  }
+  addChildElement(localName, prefix) {
+    return new Element(this.native.addChildElement(localName, prefix));
+  }
+  addTextNode(text) {
+    return new Element(this.native.addTextNode(text));
+  }
+  addAttribute(name, value) {
+    return new Element(this.native.addAttribute(name.getNative(), value));
+  }
+  getChildElements() {
+    const childElements = [];
+    const internalElementsIterator = this.native.getChildElements();
+    while (internalElementsIterator.hasNext()) {
+      childElements.push(new Element(internalElementsIterator.next()));
+    }
+    return childElements;
+  }
+  getElementName() {
+    try {
+      const internalName = this.native.getElementName();
+      return new Name(internalName);
+    } catch (e) {
+    }
+    return void 0;
+  }
+  getValue() {
+    return this.native.getValue();
+  }
+  isSOAPElement() {
+    return this.getElementName() !== void 0;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = SOAP;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/net/soap.ts"],
  "sourcesContent": ["import { Request } from \"@aerokit/sdk/http/request\";\nimport { Base64 } from \"@aerokit/sdk/utils/base64\";\nimport { Streams, InputStream } from \"@aerokit/sdk/io/streams\";\n\nconst MessageFactory = Java.type(\"jakarta.xml.soap.MessageFactory\");\nconst MimeHeadersInternal = Java.type(\"jakarta.xml.soap.MimeHeaders\");\nconst SOAPConnectionFactory = Java.type(\"jakarta.xml.soap.SOAPConnectionFactory\");\n\n/**\n * Utility class for creating, parsing, and calling SOAP messages.\n * It wraps the underlying Java javax.xml.soap API.\n */\nexport class SOAP {\n\n\t/**\n\t * Call a given SOAP endpoint with a given request message\n\t * @param message The SOAP Message wrapper object.\n\t * @param url The target SOAP endpoint URL.\n\t */\n\tpublic static call(message: Message, url: string) {\n\t\tconst soapConnectionFactory = SOAPConnectionFactory.newInstance();\n\t\tconst internalConnection = soapConnectionFactory.createConnection();\n\t\t// Accessing the internal property native (renamed from 'native' for better encapsulation)\n\t\tconst internalResponse = internalConnection.call(message.native, url);\n\t\treturn new Message(internalResponse);\n\t}\n\n\tpublic static trustAll() {\n\t\t// TODO: Implement logic for trusting all certificates if required by the SDK environment\n\t}\n\n\t/**\n\t * Creates a new, empty SOAP message.\n\t */\n\tpublic static createMessage(): Message {\n\t\treturn new Message(MessageFactory.newInstance().createMessage());\n\t}\n\n\t/**\n\t * Parses a SOAP message from an InputStream and MimeHeaders.\n\t * @param mimeHeaders The MimeHeaders wrapper object.\n\t * @param inputStream The InputStream wrapper object.\n\t */\n\tpublic static parseMessage(mimeHeaders: MimeHeaders, inputStream: InputStream): Message {\n\t\tconst internalFactory = MessageFactory.newInstance();\n\t\t// Use native for internal Java object access\n\t\tif (inputStream.native) {\n\t\t\ttry {\n\t\t\t\t// Use native for internal Java object access\n\t\t\t\tconst internalMessage = internalFactory.createMessage(mimeHeaders.native, inputStream.native);\n\t\t\t\tconst internalPart = internalMessage.getSOAPPart();\n\t\t\t\tinternalPart.getEnvelope();\n\t\t\t\treturn new Message(internalMessage);\n\t\t\t} catch (e: any) {\n\t\t\t\tconsole.error(e);\n\t\t\t\tthrow new Error(\"Input provided is null or in a wrong format. HTTP method used must be POST. \" + e.message);\n\t\t\t}\n\t\t}\n\t\tthrow new Error(\"Input provided is null.\");\n\t}\n\n\t/**\n\t * Parses a SOAP message from the current HTTP request input stream.\n\t */\n\tpublic static parseRequest(): Message {\n\t\tif (Request.getMethod().toUpperCase() !== \"POST\") {\n\t\t\tthrow new Error(\"HTTP method used must be POST.\");\n\t\t}\n\n\t\tconst inputStream = Request.getInputStream();\n\t\tconst mimeHeaders = this.createMimeHeaders();\n\n\t\treturn this.parseMessage(mimeHeaders, inputStream);\n\t}\n\n\t/**\n\t * Creates a new, empty MimeHeaders object.\n\t */\n\tpublic static createMimeHeaders(): MimeHeaders {\n\t\tconst internalMimeHeaders = new MimeHeadersInternal();\n\t\treturn new MimeHeaders(internalMimeHeaders);\n\t}\n}\n\n/**\n * SOAP Message Wrapper\n */\nclass Message {\n\n\t// Renamed to native to signal internal-use property, improving encapsulation\n\tpublic readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\tpublic getPart(): Part {\n\t\treturn new Part(this.native.getSOAPPart());\n\t}\n\n\tpublic getMimeHeaders(): MimeHeaders {\n\t\treturn new MimeHeaders(this.native.getMimeHeaders());\n\t}\n\n\tpublic save(): void {\n\t\tthis.native.saveChanges();\n\t}\n\n\tpublic getText(): string {\n\t\tconst outputStream = Streams.createByteArrayOutputStream();\n\t\t// Use native for internal Java object access\n\t\tthis.native.writeTo(outputStream.native);\n\t\treturn outputStream.getText();\n\t}\n}\n\n/**\n * SOAP Part Wrapper\n */\nclass Part {\n\n\t// Renamed to native\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\tpublic getEnvelope(): Envelope {\n\t\treturn new Envelope(this.native.getEnvelope());\n\t}\n}\n\n/**\n * SOAP Mime Headers Wrapper\n */\nclass MimeHeaders {\n\n\t// Renamed to native\n\tpublic readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\tpublic addHeader(name: string, value: string): void {\n\t\tthis.native.addHeader(name, value);\n\t}\n\n\tpublic addBasicAuthenticationHeader(username: string, password: string): void {\n\t\tconst userAndPassword = `${username}:${password}`;\n\t\tconst basicAuth = Base64.encode(userAndPassword);\n\t\tthis.native.addHeader(\"Authorization\", `Basic ${basicAuth}`);\n\t}\n}\n\n/**\n * SOAP Envelope Wrapper\n */\nclass Envelope {\n\t// Renamed to native\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\tpublic addNamespaceDeclaration(prefix: string, uri: string): void {\n\t\tthis.native.addNamespaceDeclaration(prefix, uri);\n\t}\n\n\tpublic getBody(): Body {\n\t\treturn new Body(this.native.getBody());\n\t}\n\n\tpublic getHeader(): Header {\n\t\treturn new Header(this.native.getHeader());\n\t}\n\n\tpublic createName(localName: string, prefix: string, uri: string): Name {\n\t\treturn new Name(this.native.createName(localName, prefix, uri));\n\t}\n}\n\n/**\n * SOAP Body Wrapper\n */\nclass Body {\n\t// Renamed to native\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\tpublic addChildElement(localName: string, prefix: string): Element {\n\t\treturn new Element(this.native.addChildElement(localName, prefix));\n\t}\n\n\tpublic getChildElements(): Element[] {\n\t\tconst childElements = [];\n\t\tconst internalElementsIterator = this.native.getChildElements();\n\t\twhile (internalElementsIterator.hasNext()) {\n\t\t\tchildElements.push(new Element(internalElementsIterator.next()));\n\t\t}\n\t\treturn childElements;\n\t}\n}\n\n/**\n * SOAP Header Wrapper\n */\nclass Header {\n\t// Renamed to native\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\tpublic addHeaderElement(element: Element): void {\n\t\tthis.native.addHeaderElement(element.native);\n\t}\n}\n\n/**\n * SOAP Name Wrapper\n */\nclass Name {\n\tprivate readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\t\n\tpublic getNative(): string {\n\t\treturn this.native;\n\t}\n\n\tpublic getLocalName(): string {\n\t\treturn this.native.getLocalName();\n\t}\n\n\tpublic getPrefix(): string {\n\t\treturn this.native.getPrefix();\n\t}\n\n\tpublic getQualifiedName(): string {\n\t\treturn this.native.getQualifiedName();\n\t}\n\n\tpublic getURI(): string {\n\t\treturn this.native.getURI();\n\t}\n}\n\n/**\n * SOAP Element Wrapper\n */\nclass Element {\n\tpublic readonly native: any;\n\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\tpublic addChildElement(localName: string, prefix: string) {\n\t\treturn new Element(this.native.addChildElement(localName, prefix));\n\t}\n\n\tpublic addTextNode(text: string): Element {\n\t\treturn new Element(this.native.addTextNode(text));\n\t}\n\n\tpublic addAttribute(name: Name, value: any): Element {\n\t\t// Use name.native for internal Java object access\n\t\treturn new Element(this.native.addAttribute(name.getNative(), value));\n\t}\n\n\tpublic getChildElements(): Element[] {\n\t\tconst childElements = [];\n\t\tconst internalElementsIterator = this.native.getChildElements();\n\t\twhile (internalElementsIterator.hasNext()) {\n\t\t\tchildElements.push(new Element(internalElementsIterator.next()));\n\t\t}\n\t\treturn childElements;\n\t}\n\n\tpublic getElementName(): Name | undefined {\n\t\ttry {\n\t\t\tconst internalName = this.native.getElementName();\n\t\t\treturn new Name(internalName);\n\t\t} catch (e) {\n\t\t\t// This catch handles cases where the element might not be a SOAPElement\n\t\t}\n\t\treturn undefined;\n\t}\n\n\tpublic getValue(): any {\n\t\treturn this.native.getValue();\n\t}\n\n\tpublic isSOAPElement(): boolean {\n\t\treturn this.getElementName() !== undefined;\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = SOAP;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/cjs/net/websockets.js

@@ -0,0 +1,151 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var websockets_exports = {};
+__export(websockets_exports, {
+  Websockets: () => Websockets
+});
+module.exports = __toCommonJS(websockets_exports);
+const WebsocketsFacade = Java.type("org.eclipse.dirigible.components.api.websockets.WebsocketsFacade");
+class Websockets {
+  /**
+   * Creates a new WebSocket client connection to a specified URI, managed by a handler script.
+   *
+   * @param uri The target WebSocket URI (e.g., 'ws://example.com/socket').
+   * @param handler The identifier or path of the script handling the WebSocket events.
+   * @returns A wrapper object for the new WebSocket session.
+   */
+  static createWebsocket(uri, handler) {
+    const session = WebsocketsFacade.createWebsocket(uri, handler);
+    return new WebsocketClient(session, uri, handler);
+  }
+  /**
+   * Retrieves a list of all active WebSocket clients.
+   *
+   * @returns An array of objects detailing the URI and handler of each client.
+   */
+  static getClients() {
+    return JSON.parse(WebsocketsFacade.getClientsAsJson());
+  }
+  /**
+   * Retrieves a specific WebSocket client wrapper by its session ID.
+   *
+   * @param id The session ID of the client.
+   * @returns The client wrapper or undefined if not found.
+   */
+  static getClient(id) {
+    const native = WebsocketsFacade.getClient(id);
+    return native ? new WebsocketClient(native.getSession(), native.getSession().getRequestURI(), native.getHandler()) : void 0;
+  }
+  /**
+   * Retrieves a specific WebSocket client wrapper by its handler identifier.
+   *
+   * @param handler The handler identifier associated with the client.
+   * @returns The client wrapper or undefined if not found.
+   */
+  static getClientByHandler(handler) {
+    const native = WebsocketsFacade.getClientByHandler(handler);
+    return native ? new WebsocketClient(native.getSession(), native.getSession().getRequestURI(), native.getHandler()) : void 0;
+  }
+  /**
+   * Retrieves the message payload from the current context, typically used inside an 'onmessage' handler.
+   *
+   * @returns The message content.
+   */
+  static getMessage() {
+    return __context.get("message");
+  }
+  /**
+   * Retrieves error details from the current context, typically used inside an 'onerror' handler.
+   *
+   * @returns The error object or string.
+   */
+  static getError() {
+    return __context.get("error");
+  }
+  /**
+   * Retrieves the event method name that triggered the current script execution (e.g., "onopen", "onmessage").
+   *
+   * @returns The name of the event method.
+   */
+  static getMethod() {
+    return __context.get("method");
+  }
+  /**
+   * Checks if the current event context is 'onopen'.
+   * @returns True if the method is 'onopen'.
+   */
+  static isOnOpen() {
+    return this.getMethod() === "onopen";
+  }
+  /**
+   * Checks if the current event context is 'onmessage'.
+   * @returns True if the method is 'onmessage'.
+   */
+  static isOnMessage() {
+    return this.getMethod() === "onmessage";
+  }
+  /**
+   * Checks if the current event context is 'onerror'.
+   * @returns True if the method is 'onerror'.
+   */
+  static isOnError() {
+    return this.getMethod() === "onerror";
+  }
+  /**
+   * Checks if the current event context is 'onclose'.
+   * @returns True if the method is 'onclose'.
+   */
+  static isOnClose() {
+    return this.getMethod() === "onclose";
+  }
+}
+class WebsocketClient {
+  /**
+   * @param session The native Java session object.
+   * @param uri The connected URI.
+   * @param handler The handler identifier.
+   */
+  constructor(session, uri, handler) {
+    this._session = session;
+    this.uri = uri;
+    this.handler = handler;
+  }
+  /**
+   * Sends a text message over the WebSocket connection.
+   * @param text The message to send.
+   */
+  send(text) {
+    if (!this._session || this._session === null) {
+      console.error("Websocket Session is null. Message not sent.");
+      return;
+    }
+    this._session.send(this.uri, text);
+  }
+  /**
+   * Closes the WebSocket connection.
+   */
+  close() {
+    if (this._session) {
+      this._session.close();
+    }
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Websockets;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/net/websockets.ts"],
  "sourcesContent": ["/**\n * Provides a high-level API for managing WebSocket clients and handling\n * lifecycle events within the application context. It wraps the internal Java\n * WebsocketsFacade.\n */\nconst WebsocketsFacade = Java.type(\"org.eclipse.dirigible.components.api.websockets.WebsocketsFacade\");\n\n/**\n * @class Websockets\n * @description Static utility class for accessing and managing WebSocket functionality.\n */\nexport class Websockets {\n\n\t/**\n\t * Creates a new WebSocket client connection to a specified URI, managed by a handler script.\n\t *\n\t * @param uri The target WebSocket URI (e.g., 'ws://example.com/socket').\n\t * @param handler The identifier or path of the script handling the WebSocket events.\n\t * @returns A wrapper object for the new WebSocket session.\n\t */\n\tpublic static createWebsocket(uri: string, handler: string): WebsocketClient {\n\t\tconst session = WebsocketsFacade.createWebsocket(uri, handler);\n\t\treturn new WebsocketClient(session, uri, handler);\n\t}\n\n\t/**\n\t * Retrieves a list of all active WebSocket clients.\n\t *\n\t * @returns An array of objects detailing the URI and handler of each client.\n\t */\n\tpublic static getClients(): { uri: string, handler: string }[] {\n\t\treturn JSON.parse(WebsocketsFacade.getClientsAsJson());\n\t}\n\n\t/**\n\t * Retrieves a specific WebSocket client wrapper by its session ID.\n\t *\n\t * @param id The session ID of the client.\n\t * @returns The client wrapper or undefined if not found.\n\t */\n\tpublic static getClient(id: string): WebsocketClient | undefined {\n\t\tconst native = WebsocketsFacade.getClient(id);\n\t\treturn native ? new WebsocketClient(native.getSession(), native.getSession().getRequestURI(), native.getHandler()) : undefined;\n\t}\n\n\t/**\n\t * Retrieves a specific WebSocket client wrapper by its handler identifier.\n\t *\n\t * @param handler The handler identifier associated with the client.\n\t * @returns The client wrapper or undefined if not found.\n\t */\n\tpublic static getClientByHandler(handler: string): WebsocketClient | undefined {\n\t\tconst native = WebsocketsFacade.getClientByHandler(handler);\n\t\treturn native ? new WebsocketClient(native.getSession(), native.getSession().getRequestURI(), native.getHandler()) : undefined;\n\t}\n\n\t/**\n\t * Retrieves the message payload from the current context, typically used inside an 'onmessage' handler.\n\t *\n\t * @returns The message content.\n\t */\n\tpublic static getMessage(): any {\n\t\treturn __context.get('message');\n\t}\n\n\t/**\n\t * Retrieves error details from the current context, typically used inside an 'onerror' handler.\n\t *\n\t * @returns The error object or string.\n\t */\n\tpublic static getError(): any {\n\t\treturn __context.get('error');\n\t}\n\n\t/**\n\t * Retrieves the event method name that triggered the current script execution (e.g., \"onopen\", \"onmessage\").\n\t *\n\t * @returns The name of the event method.\n\t */\n\tpublic static getMethod(): string {\n\t\t// Assumes __context is a global map provided by the execution environment\n\t\treturn __context.get('method');\n\t}\n\n\t/**\n\t * Checks if the current event context is 'onopen'.\n\t * @returns True if the method is 'onopen'.\n\t */\n\tpublic static isOnOpen(): boolean {\n\t\treturn this.getMethod() === \"onopen\";\n\t}\n\n\t/**\n\t * Checks if the current event context is 'onmessage'.\n\t * @returns True if the method is 'onmessage'.\n\t */\n\tpublic static isOnMessage(): boolean {\n\t\treturn this.getMethod() === \"onmessage\";\n\t}\n\n\t/**\n\t * Checks if the current event context is 'onerror'.\n\t * @returns True if the method is 'onerror'.\n\t */\n\tpublic static isOnError(): boolean {\n\t\treturn this.getMethod() === \"onerror\";\n\t}\n\n\t/**\n\t * Checks if the current event context is 'onclose'.\n\t * @returns True if the method is 'onclose'.\n\t */\n\tpublic static isOnClose(): boolean {\n\t\treturn this.getMethod() === \"onclose\";\n\t}\n}\n\n/**\n * @class WebsocketClient\n * @description Wrapper for a native WebSocket session, providing methods to send and close the connection.\n */\nclass WebsocketClient {\n\t// Renamed to _session for better encapsulation of the native Java object\n\tprivate readonly _session: null | any;\n\tprivate readonly uri: string;\n\tprivate readonly handler: string;\n\n\t/**\n\t * @param session The native Java session object.\n\t * @param uri The connected URI.\n\t * @param handler The handler identifier.\n\t */\n\tconstructor(session: null | any, uri: string, handler: string) {\n\t\tthis._session = session;\n\t\tthis.uri = uri;\n\t\tthis.handler = handler;\n\t}\n\n\t/**\n\t * Sends a text message over the WebSocket connection.\n\t * @param text The message to send.\n\t */\n\tpublic send(text: string): void {\n\t\tif (!this._session || this._session === null) {\n\t\t\tconsole.error(\"Websocket Session is null. Message not sent.\");\n\t\t\treturn;\n\t\t}\n\t\tthis._session.send(this.uri, text);\n\t};\n\n\t/**\n\t * Closes the WebSocket connection.\n\t */\n\tpublic close(): void {\n\t\tif (this._session) {\n\t\t\tthis._session.close();\n\t\t}\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Websockets;\n}"],
  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,MAAM,mBAAmB,KAAK,KAAK,kEAAkE;AAM9F,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASvB,OAAc,gBAAgB,KAAa,SAAkC;AAC5E,UAAM,UAAU,iBAAiB,gBAAgB,KAAK,OAAO;AAC7D,WAAO,IAAI,gBAAgB,SAAS,KAAK,OAAO;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,aAAiD;AAC9D,WAAO,KAAK,MAAM,iBAAiB,iBAAiB,CAAC;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,UAAU,IAAyC;AAChE,UAAM,SAAS,iBAAiB,UAAU,EAAE;AAC5C,WAAO,SAAS,IAAI,gBAAgB,OAAO,WAAW,GAAG,OAAO,WAAW,EAAE,cAAc,GAAG,OAAO,WAAW,CAAC,IAAI;AAAA,EACtH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,mBAAmB,SAA8C;AAC9E,UAAM,SAAS,iBAAiB,mBAAmB,OAAO;AAC1D,WAAO,SAAS,IAAI,gBAAgB,OAAO,WAAW,GAAG,OAAO,WAAW,EAAE,cAAc,GAAG,OAAO,WAAW,CAAC,IAAI;AAAA,EACtH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,aAAkB;AAC/B,WAAO,UAAU,IAAI,SAAS;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,WAAgB;AAC7B,WAAO,UAAU,IAAI,OAAO;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,YAAoB;AAEjC,WAAO,UAAU,IAAI,QAAQ;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,WAAoB;AACjC,WAAO,KAAK,UAAU,MAAM;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,cAAuB;AACpC,WAAO,KAAK,UAAU,MAAM;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,YAAqB;AAClC,WAAO,KAAK,UAAU,MAAM;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAc,YAAqB;AAClC,WAAO,KAAK,UAAU,MAAM;AAAA,EAC7B;AACD;AAMA,MAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrB,YAAY,SAAqB,KAAa,SAAiB;AAC9D,SAAK,WAAW;AAChB,SAAK,MAAM;AACX,SAAK,UAAU;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,KAAK,MAAoB;AAC/B,QAAI,CAAC,KAAK,YAAY,KAAK,aAAa,MAAM;AAC7C,cAAQ,MAAM,8CAA8C;AAC5D;AAAA,IACD;AACA,SAAK,SAAS,KAAK,KAAK,KAAK,IAAI;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA,EAKO,QAAc;AACpB,QAAI,KAAK,UAAU;AAClB,WAAK,SAAS,MAAM;AAAA,IACrB;AAAA,EACD;AACD;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/dist/cjs/net/wrappers/onClose.js

@@ -0,0 +1,2 @@
+dirigibleRequire(__context.get("handler")).onClose();
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL25ldC93cmFwcGVycy9vbkNsb3NlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJkaXJpZ2libGVSZXF1aXJlKF9fY29udGV4dC5nZXQoXCJoYW5kbGVyXCIpKS5vbkNsb3NlKCk7XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxpQkFBaUIsVUFBVSxJQUFJLFNBQVMsQ0FBQyxFQUFFLFFBQVE7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/cjs/net/wrappers/onError.js

@@ -0,0 +1,2 @@
+dirigibleRequire(__context.get("handler")).onError(__context.get("error"));
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL25ldC93cmFwcGVycy9vbkVycm9yLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJkaXJpZ2libGVSZXF1aXJlKF9fY29udGV4dC5nZXQoXCJoYW5kbGVyXCIpKS5vbkVycm9yKF9fY29udGV4dC5nZXQoXCJlcnJvclwiKSk7XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxpQkFBaUIsVUFBVSxJQUFJLFNBQVMsQ0FBQyxFQUFFLFFBQVEsVUFBVSxJQUFJLE9BQU8sQ0FBQzsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/cjs/net/wrappers/onMessage.js

@@ -0,0 +1,2 @@
+dirigibleRequire(__context.get("handler")).onMessage(__context.get("message"), __context.get("from"));
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL25ldC93cmFwcGVycy9vbk1lc3NhZ2UudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImRpcmlnaWJsZVJlcXVpcmUoX19jb250ZXh0LmdldChcImhhbmRsZXJcIikpLm9uTWVzc2FnZShfX2NvbnRleHQuZ2V0KFwibWVzc2FnZVwiKSwgX19jb250ZXh0LmdldChcImZyb21cIikpO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsaUJBQWlCLFVBQVUsSUFBSSxTQUFTLENBQUMsRUFBRSxVQUFVLFVBQVUsSUFBSSxTQUFTLEdBQUcsVUFBVSxJQUFJLE1BQU0sQ0FBQzsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/cjs/net/wrappers/onOpen.js

@@ -0,0 +1,2 @@
+dirigibleRequire(__context.get("handler")).onOpen();
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL25ldC93cmFwcGVycy9vbk9wZW4udHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImRpcmlnaWJsZVJlcXVpcmUoX19jb250ZXh0LmdldChcImhhbmRsZXJcIikpLm9uT3BlbigpO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsaUJBQWlCLFVBQVUsSUFBSSxTQUFTLENBQUMsRUFBRSxPQUFPOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/cjs/pdf/index.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pdf_exports = {};
+__export(pdf_exports, {
+  pdf: () => import_pdf.PDF
+});
+module.exports = __toCommonJS(pdf_exports);
+__reExport(pdf_exports, require("./pdf"), module.exports);
+var import_pdf = require("./pdf");
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3BkZi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0ICogZnJvbSBcIi4vcGRmXCI7XG5leHBvcnQgeyBQREYgYXMgcGRmIH0gZnJvbSBcIi4vcGRmXCI7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsd0JBQWMsa0JBQWQ7QUFDQSxpQkFBMkI7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/cjs/pdf/pdf.js

@@ -0,0 +1,160 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pdf_exports = {};
+__export(pdf_exports, {
+  PDF: () => PDF
+});
+module.exports = __toCommonJS(pdf_exports);
+var import_registry = require("@aerokit/sdk/platform/registry");
+var import_xml = require("@aerokit/sdk/utils/xml");
+var import_template = require("@aerokit/sdk/template");
+const PDFFacade = Java.type("org.eclipse.dirigible.components.api.pdf.PDFFacade");
+const TEMPLATE_PATH_TABLE = "pdf/templates/table.xml";
+class PDF {
+  /**
+   * Generates a PDF document containing a styled table based on the standard table template.
+   *
+   * @param {PDFTableData} data The structured data to populate the table.
+   * @param {PDFTableConfig} [config] Optional configuration for page size and alignment.
+   * @returns {any[]} The generated PDF content as a byte array (Array<number>).
+   */
+  static generateTable(data, config) {
+    const defaultTemplateParameters = {
+      // Default A4 size in mm
+      pageWidth: "210",
+      pageHeight: "297",
+      alignColumns: "center",
+      alignRows: "center"
+    };
+    let templateParameters = {
+      ...defaultTemplateParameters,
+      ...data
+    };
+    PDF.setTemplateParameters(templateParameters, config);
+    const template = import_registry.Registry.getText(TEMPLATE_PATH_TABLE);
+    const pdfTemplate = import_template.TemplateEngines.generate(TEMPLATE_PATH_TABLE, template, templateParameters);
+    const xmlData = import_xml.XML.fromJson({
+      content: data
+    });
+    return PDFFacade.generate(pdfTemplate, xmlData);
+  }
+  /**
+   * Generates a PDF document using a custom template path and data payload.
+   *
+   * @param {string} templatePath The path to the custom template file (e.g., in the Registry).
+   * @param {PDFTableData} data The data to be injected into the template.
+   * @returns {any[]} The generated PDF content as a byte array (Array<number>).
+   */
+  static generate(templatePath, data) {
+    const template = import_registry.Registry.getText(templatePath);
+    const xmlData = import_xml.XML.fromJson({
+      content: data
+    });
+    return PDFFacade.generate(template, xmlData);
+  }
+  /**
+   * Internal method to set template parameters based on optional configuration.
+   *
+   * @param {TemplateParameters} templateParameters The object containing parameters to be modified.
+   * @param {PDFTableConfig} [config] The optional configuration object.
+   */
+  static setTemplateParameters(templateParameters, config) {
+    PDF.setDocumentSize(templateParameters, config);
+    PDF.setDocumentAlign(templateParameters, config);
+  }
+  /**
+   * Internal method to set column and row alignment parameters.
+   *
+   * @param {TemplateParameters} templateParameters The object containing parameters to be modified.
+   * @param {PDFTableConfig} [config] The optional configuration object.
+   */
+  static setDocumentAlign(templateParameters, config) {
+    if (config?.alignColumns) {
+      templateParameters.alignColumns = config.alignColumns;
+    }
+    if (config?.alignRows) {
+      templateParameters.alignRows = config.alignRows;
+    }
+  }
+  /**
+   * Internal method to set the document size (width and height in mm) based on a standard 'size' or custom dimensions.
+   *
+   * @param {TemplateParameters} templateParameters The object containing parameters to be modified.
+   * @param {PDFTableConfig} [config] The optional configuration object.
+   */
+  static setDocumentSize(templateParameters, config) {
+    if (config?.pageWidth !== void 0) {
+      templateParameters.pageWidth = String(config.pageWidth);
+    }
+    if (config?.pageHeight !== void 0) {
+      templateParameters.pageHeight = String(config.pageHeight);
+    }
+    if (config?.size) {
+      switch (config.size.toLowerCase()) {
+        case "a0":
+          templateParameters.pageWidth = "841";
+          templateParameters.pageHeight = "1189";
+          break;
+        case "a1":
+          templateParameters.pageWidth = "594";
+          templateParameters.pageHeight = "841";
+          break;
+        case "a2":
+          templateParameters.pageWidth = "420";
+          templateParameters.pageHeight = "594";
+          break;
+        case "a3":
+          templateParameters.pageWidth = "297";
+          templateParameters.pageHeight = "420";
+          break;
+        case "a4":
+          templateParameters.pageWidth = "210";
+          templateParameters.pageHeight = "297";
+          break;
+        case "a5":
+          templateParameters.pageWidth = "148";
+          templateParameters.pageHeight = "210";
+          break;
+        case "a6":
+          templateParameters.pageWidth = "105";
+          templateParameters.pageHeight = "148";
+          break;
+        case "a7":
+          templateParameters.pageWidth = "74";
+          templateParameters.pageHeight = "105";
+          break;
+        case "a8":
+          templateParameters.pageWidth = "52";
+          templateParameters.pageHeight = "74";
+          break;
+        case "a9":
+          templateParameters.pageWidth = "37";
+          templateParameters.pageHeight = "52";
+          break;
+        case "a10":
+          templateParameters.pageWidth = "26";
+          templateParameters.pageHeight = "37";
+          break;
+      }
+    }
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = PDF;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/pdf/pdf.ts"],
  "sourcesContent": ["import { Registry } from \"@aerokit/sdk/platform/registry\";\nimport { XML } from \"@aerokit/sdk/utils/xml\";\nimport { TemplateEngines } from \"@aerokit/sdk/template\";\nconst PDFFacade = Java.type(\"org.eclipse.dirigible.components.api.pdf.PDFFacade\");\n\n// Path to the default table template\nconst TEMPLATE_PATH_TABLE = \"pdf/templates/table.xml\";\n\n/**\n * Interface defining the structured data required to generate a table in a PDF.\n */\nexport interface PDFTableData {\n    title: string;\n    description: string;\n    columns: {\n        name: string // Display name of the column\n        key: string  // Data key to look up in the rows\n    }[],\n    rows: { [key: string]: any }[] // Array of data objects for each row\n}\n\n/**\n * Interface defining optional configuration for PDF document layout.\n */\nexport interface PDFTableConfig {\n    /** Document width in mm. Overrides size if present. */\n    pageWidth?: number;\n    /** Document height in mm. Overrides size if present. */\n    pageHeight?: number;\n    /** Whether to apply column alignment (based on template default). */\n    alignColumns?: boolean;\n    /** Whether to apply row alignment (based on template default). */\n    alignRows?: boolean;\n    /** Standard ISO 216 paper size (A0-A10). Sets standard dimensions if custom width/height are not provided. */\n    size?: \"a0\" | \"a1\" | \"a2\" | \"a3\" | \"a4\" | \"a5\" | \"a6\" | \"a7\" | \"a8\" | \"a9\" | \"a10\";\n}\n\n/**\n * Internal interface for template parameters, including data and configuration.\n */\ninterface TemplateParameters extends PDFTableData {\n    pageWidth: string;\n    pageHeight: string;\n    // Note: alignColumns/Rows are typed as string here to match the default value (\"center\")\n    // but may be overwritten by booleans from config due to the original logic.\n    alignColumns: string | boolean;\n    alignRows: string | boolean;\n}\n\n/**\n * @class PDF\n * @description Utility class for generating PDF documents using a template engine and the PDFFacade.\n */\nexport class PDF {\n\n    /**\n     * Generates a PDF document containing a styled table based on the standard table template.\n     *\n     * @param {PDFTableData} data The structured data to populate the table.\n     * @param {PDFTableConfig} [config] Optional configuration for page size and alignment.\n     * @returns {any[]} The generated PDF content as a byte array (Array<number>).\n     */\n    public static generateTable(data: PDFTableData, config?: PDFTableConfig): any[] {\n        const defaultTemplateParameters: Omit<TemplateParameters, keyof PDFTableData> = {\n            // Default A4 size in mm\n            pageWidth: \"210\",\n            pageHeight: \"297\",\n            alignColumns: \"center\",\n            alignRows: \"center\"\n        };\n\n        let templateParameters: TemplateParameters = {\n            ...defaultTemplateParameters,\n            ...data\n        } as TemplateParameters; // Cast needed due to the merging of types\n\n        PDF.setTemplateParameters(templateParameters, config);\n\n        const template = Registry.getText(TEMPLATE_PATH_TABLE);\n        const pdfTemplate = TemplateEngines.generate(TEMPLATE_PATH_TABLE, template, templateParameters);\n\n        // Convert data payload to XML format expected by the underlying Java PDFFacade\n        const xmlData = XML.fromJson({\n            content: data\n        });\n        return PDFFacade.generate(pdfTemplate, xmlData);\n    }\n\n    /**\n     * Generates a PDF document using a custom template path and data payload.\n     *\n     * @param {string} templatePath The path to the custom template file (e.g., in the Registry).\n     * @param {PDFTableData} data The data to be injected into the template.\n     * @returns {any[]} The generated PDF content as a byte array (Array<number>).\n     */\n    public static generate(templatePath: string, data: PDFTableData): any[] {\n        const template = Registry.getText(templatePath);\n\n        // Convert data payload to XML format expected by the underlying Java PDFFacade\n        const xmlData = XML.fromJson({\n            content: data\n        });\n        return PDFFacade.generate(template, xmlData);\n    }\n\n    /**\n     * Internal method to set template parameters based on optional configuration.\n     *\n     * @param {TemplateParameters} templateParameters The object containing parameters to be modified.\n     * @param {PDFTableConfig} [config] The optional configuration object.\n     */\n    private static setTemplateParameters(templateParameters: TemplateParameters, config?: PDFTableConfig): void {\n        PDF.setDocumentSize(templateParameters, config);\n        PDF.setDocumentAlign(templateParameters, config);\n    }\n\n    /**\n     * Internal method to set column and row alignment parameters.\n     *\n     * @param {TemplateParameters} templateParameters The object containing parameters to be modified.\n     * @param {PDFTableConfig} [config] The optional configuration object.\n     */\n    private static setDocumentAlign(templateParameters: TemplateParameters, config?: PDFTableConfig): void {\n        // Only override if the config value is explicitly present and truthy (maintaining original behavior)\n        if (config?.alignColumns) {\n            templateParameters.alignColumns = config.alignColumns;\n        }\n        if (config?.alignRows) {\n            templateParameters.alignRows = config.alignRows;\n        }\n    }\n\n    /**\n     * Internal method to set the document size (width and height in mm) based on a standard 'size' or custom dimensions.\n     *\n     * @param {TemplateParameters} templateParameters The object containing parameters to be modified.\n     * @param {PDFTableConfig} [config] The optional configuration object.\n     */\n    private static setDocumentSize(templateParameters: TemplateParameters, config?: PDFTableConfig): void {\n        if (config?.pageWidth !== undefined) {\n            templateParameters.pageWidth = String(config.pageWidth);\n        }\n        if (config?.pageHeight !== undefined) {\n            templateParameters.pageHeight = String(config.pageHeight);\n        }\n\n        if (config?.size) {\n            // Mapping ISO 216 paper sizes (in millimeters)\n            switch (config.size.toLowerCase()) {\n                case \"a0\":\n                    templateParameters.pageWidth = \"841\";\n                    templateParameters.pageHeight = \"1189\";\n                    break;\n                case \"a1\":\n                    templateParameters.pageWidth = \"594\";\n                    templateParameters.pageHeight = \"841\";\n                    break;\n                case \"a2\":\n                    templateParameters.pageWidth = \"420\";\n                    templateParameters.pageHeight = \"594\";\n                    break;\n                case \"a3\":\n                    templateParameters.pageWidth = \"297\";\n                    templateParameters.pageHeight = \"420\";\n                    break;\n                case \"a4\": // Default\n                    templateParameters.pageWidth = \"210\";\n                    templateParameters.pageHeight = \"297\";\n                    break;\n                case \"a5\":\n                    templateParameters.pageWidth = \"148\";\n                    templateParameters.pageHeight = \"210\";\n                    break;\n                case \"a6\":\n                    templateParameters.pageWidth = \"105\";\n                    templateParameters.pageHeight = \"148\";\n                    break;\n                case \"a7\":\n                    templateParameters.pageWidth = \"74\";\n                    templateParameters.pageHeight = \"105\";\n                    break;\n                case \"a8\":\n                    templateParameters.pageWidth = \"52\";\n                    templateParameters.pageHeight = \"74\";\n                    break;\n                case \"a9\":\n                    templateParameters.pageWidth = \"37\";\n                    templateParameters.pageHeight = \"52\";\n                    break;\n                case \"a10\":\n                    templateParameters.pageWidth = \"26\";\n                    templateParameters.pageHeight = \"37\";\n                    break;\n            }\n        }\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = PDF;\n}\n"],
  "mappings": "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",
  "names": []
}
