@aerokit/sdk 12.44.0

package/dist/esm/net/soap.mjs

@@ -0,0 +1,209 @@
+import { Request } from "@aerokit/sdk/http/request";
+import { Base64 } from "@aerokit/sdk/utils/base64";
+import { Streams } from "@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 (Request.getMethod().toUpperCase() !== "POST") {
+      throw new Error("HTTP method used must be POST.");
+    }
+    const inputStream = 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 = 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 = 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;
+}
+export {
+  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/esm/net/websockets.mjs

@@ -0,0 +1,132 @@
+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;
+}
+export {
+  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": "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/esm/net/wrappers/onClose.mjs

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

package/dist/esm/net/wrappers/onError.mjs

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

package/dist/esm/net/wrappers/onMessage.mjs

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

package/dist/esm/net/wrappers/onOpen.mjs

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

package/dist/esm/pdf/index.mjs

@@ -0,0 +1,6 @@
+export * from "./pdf";
+import { PDF } from "./pdf";
+export {
+  PDF as pdf
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3BkZi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0ICogZnJvbSBcIi4vcGRmXCI7XG5leHBvcnQgeyBQREYgYXMgcGRmIH0gZnJvbSBcIi4vcGRmXCI7XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxjQUFjO0FBQ2QsU0FBZ0IsV0FBVzsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/pdf/pdf.mjs

@@ -0,0 +1,141 @@
+import { Registry } from "@aerokit/sdk/platform/registry";
+import { XML } from "@aerokit/sdk/utils/xml";
+import { TemplateEngines } from "@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 = Registry.getText(TEMPLATE_PATH_TABLE);
+    const pdfTemplate = TemplateEngines.generate(TEMPLATE_PATH_TABLE, template, templateParameters);
+    const xmlData = 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 = Registry.getText(templatePath);
+    const xmlData = 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;
+}
+export {
+  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": []
}


package/dist/esm/platform/command.mjs

@@ -0,0 +1,28 @@
+const CommandFacade = Java.type("org.eclipse.dirigible.components.api.platform.CommandFacade");
+const ProcessExecutionOptions = Java.type("org.eclipse.dirigible.commons.process.execution.ProcessExecutionOptions");
+class Command {
+  /**
+   * Executes a system command with specified configuration, environment variables, and exclusions.
+   *
+   * @param {string} command The command string to execute (e.g., "ls -l").
+   * @param {CommandOptions} [options] Optional configuration for the execution environment.
+   * @param {EnvironmentVariables} [add] Optional environment variables to add to the process.
+   * @param {string[]} [remove] Optional list of environment variable keys to remove from the process.
+   * @returns {CommandOutput} A structured object containing the exit code and output streams.
+   */
+  static execute(command, options, add, remove) {
+    const processExecutionOptions = new ProcessExecutionOptions();
+    if (options?.workingDirectory) {
+      processExecutionOptions.setWorkingDirectory(options.workingDirectory);
+    }
+    const resultJson = CommandFacade.execute(command, add, remove, processExecutionOptions);
+    return JSON.parse(resultJson);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Command;
+}
+export {
+  Command
+};
+//# sourceMappingURL=data:application/json;base64,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