@aerokit/sdk 12.44.0

package/dist/esm/utils/base64.mjs

@@ -0,0 +1,85 @@
+import { Streams } from "@aerokit/sdk/io/streams";
+import { Bytes } from "@aerokit/sdk/io/bytes";
+const Base64Facade = Java.type("org.eclipse.dirigible.components.api.utils.Base64Facade");
+class Base64 {
+  /**
+   * Base64 encoding: Converts the input data (text or byte array) into a
+   * standard **Base64 encoded string representation**.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting Base64 encoded string.
+   */
+  static encode(input) {
+    return Bytes.byteArrayToText(Base64.encodeAsNativeBytes(input));
+  }
+  /**
+   * Base64 encoding: Converts the input data (text or byte array) into a
+   * **JavaScript byte array (any[])** containing the Base64 encoded representation.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting byte array containing the Base64 encoded data.
+   */
+  static encodeAsBytes(input) {
+    return Bytes.toJavaScriptBytes(Base64.encodeAsNativeBytes(input));
+  }
+  /**
+   * Base64 encoding: Converts the input data (text or byte array) into a
+   * **native Java byte array** containing the Base64 encoded representation.
+   * This method is generally for internal use.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting native Java byte array containing the Base64 data.
+   */
+  static encodeAsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return Base64Facade.encodeNative(native);
+  }
+  /**
+   * Base64 decoding: Converts a Base64 input (text or byte array) back into
+   * the original **raw byte array (JavaScript any[])**.
+   *
+   * @param input The Base64 data to decode, either as a string or a JavaScript byte array (any[]).
+   * @returns The decoded raw byte array (any[]). Returns null if decoding fails or input is null.
+   */
+  static decode(input) {
+    const output = Base64.decodeAsNativeBytes(input);
+    if (output) {
+      return Bytes.toJavaScriptBytes(output);
+    }
+    return output;
+  }
+  /**
+   * Base64 decoding: Converts a Base64 input (text or byte array) back into
+   * the original **native Java raw byte array**. This method is generally for internal use.
+   *
+   * @param input The Base64 data to decode, either as a string or a JavaScript byte array (any[]).
+   * @returns The decoded native Java byte array.
+   */
+  static decodeAsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return Base64Facade.decodeNative(native);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Base64;
+}
+export {
+  Base64
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/converter.mjs

@@ -0,0 +1,59 @@
+class Converter {
+  /**
+   * Converts a date property value within an object into a Unix timestamp (milliseconds since epoch).
+   *
+   * @param obj The object containing the property to be converted.
+   * @param property The string name of the date property (e.g., 'dateCreated').
+   * @example
+   * // Before: { date: "2024-01-01T10:00:00Z" }
+   * Converter.setDate(obj, 'date');
+   * // After: { date: 1704096000000 }
+   */
+  static setDate(obj, property) {
+    if (obj && obj[property]) {
+      obj[property] = new Date(obj[property]).getTime();
+    }
+  }
+  /**
+   * Converts a date property value into an ISO 8601 string, adjusted to represent
+   * the start of that day (local midnight) to handle timezone offsets consistently.
+   * This is typically used for fields that should represent a date *only*, without time of day ambiguity.
+   *
+   * @param obj The object containing the property to be converted.
+   * @param property The string name of the date property (e.g., 'birthday').
+   * @example
+   * // If local timezone is EST (UTC-5):
+   * // Before: { date: "2024-01-01" }
+   * Converter.setLocalDate(obj, 'date');
+   * // After: { date: "2024-01-01T05:00:00.000Z" } (start of day UTC)
+   */
+  static setLocalDate(obj, property) {
+    if (obj && obj[property]) {
+      const date = new Date(obj[property]);
+      const offsetHours = -((/* @__PURE__ */ new Date()).getTimezoneOffset() / 60);
+      date.setHours(offsetHours, 0, 0, 0);
+      obj[property] = date.toISOString();
+    }
+  }
+  /**
+   * Explicitly coerces a property value to a strict boolean type (`true` or `false`).
+   * This handles truthy/falsy values like `1`, `0`, `null`, and empty strings.
+   *
+   * @param obj The object containing the property to be converted.
+   * @param property The string name of the boolean property (e.g., 'isActive').
+   * @example
+   * // Before: { flag: 1, other: null }
+   * Converter.setBoolean(obj, 'flag');
+   * Converter.setBoolean(obj, 'other');
+   * // After: { flag: true, other: false }
+   */
+  static setBoolean(obj, property) {
+    if (obj && obj[property] !== void 0) {
+      obj[property] = obj[property] ? true : false;
+    }
+  }
+}
+export {
+  Converter
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/digest.mjs

@@ -0,0 +1,148 @@
+import { Streams } from "@aerokit/sdk/io/streams";
+import { Bytes } from "@aerokit/sdk/io/bytes";
+const DigestFacade = Java.type("org.eclipse.dirigible.components.api.utils.DigestFacade");
+class Digest {
+  /**
+   * Calculate MD5 digest from input (text or byte array) and return result as byte array
+   */
+  static md5(input) {
+    return Bytes.toJavaScriptBytes(Digest.md5AsNativeBytes(input));
+  }
+  /**
+   * Calculate MD5 digest from input (text or byte array) and return result as 16 elements java native byte array
+   */
+  static md5AsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      var baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return DigestFacade.md5(native);
+  }
+  /**
+   * Calculate MD5 digest from input (text or byte array) and return result as 32 character hex string
+   */
+  static md5Hex(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return DigestFacade.md5Hex(native);
+  }
+  /**
+   * Calculate SHA1 digest from input (text or byte array) and return result as 20 elements byte array
+   */
+  static sha1(input) {
+    return Bytes.toJavaScriptBytes(Digest.sha1AsNativeBytes(input));
+  }
+  /**
+   * Calculate SHA1 digest from input (text or byte array) and return result as 20 elements java native byte array
+   */
+  static sha1AsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return DigestFacade.sha1(native);
+  }
+  /**
+   * Calculate SHA256 digest from input (text or byte array) and return result as 32 elements byte array
+   */
+  static sha256(input) {
+    return Bytes.toJavaScriptBytes(Digest.sha256AsNativeBytes(input));
+  }
+  /**
+   * Calculate SHA256 digest from input (text or byte array) and return result as 32 elements java native byte array
+   */
+  static sha256AsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return DigestFacade.sha256(native);
+  }
+  /**
+   * Calculate SHA384 digest from input (text or byte array) and return result as 48 elements byte array
+   */
+  static sha384(input) {
+    return Bytes.toJavaScriptBytes(Digest.sha384AsNativeBytes(input));
+  }
+  /**
+   * Calculate SHA384 digest from input (text or byte array) and return result as 48 elements java native byte array
+   */
+  static sha384AsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    const output = DigestFacade.sha384(native);
+    return output;
+  }
+  /**
+   * Calculate SHA512 digest from input (text or byte array) and return result as 64 elements byte array
+   */
+  static sha512(input) {
+    return Bytes.toJavaScriptBytes(Digest.sha512AsNativeBytes(input));
+  }
+  /**
+   * Calculate SHA512 digest from input (text or byte array) and return result as 64 elements java native byte array
+   */
+  static sha512AsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return DigestFacade.sha512(native);
+  }
+  /**
+   * Calculate SHA1 digest from input (text or byte array) and return result as 40 character hex string
+   */
+  static sha1Hex(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return DigestFacade.sha1Hex(native);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Digest;
+}
+export {
+  Digest
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/utils/digest.ts"],
  "sourcesContent": ["import { Streams } from \"@aerokit/sdk/io/streams\";\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\nconst DigestFacade = Java.type(\"org.eclipse.dirigible.components.api.utils.DigestFacade\");\n\nexport class Digest {\n\n\t/**\n\t * Calculate MD5 digest from input (text or byte array) and return result as byte array\n\t */\n\tpublic static md5(input: string | any[]): any[] {\n\t\treturn Bytes.toJavaScriptBytes(Digest.md5AsNativeBytes(input));\n\t}\n\n\t/**\n\t * Calculate MD5 digest from input (text or byte array) and return result as 16 elements java native byte array\n\t */\n\tpublic static md5AsNativeBytes(input: string | any[]): any[] {\n\t\tconst data = input;\n\t\tlet native;\n\t\tif (typeof data === 'string') {\n\t\t\tvar baos = Streams.createByteArrayOutputStream();\n\t\t\tbaos.writeText(data);\n\t\t\tnative = baos.getBytesNative();\n\t\t} else if (Array.isArray(data)) {\n\t\t\tnative = Bytes.toJavaBytes(data);\n\t\t}\n\n\t\treturn DigestFacade.md5(native);\n\t}\n\n\t/**\n\t * Calculate MD5 digest from input (text or byte array) and return result as 32 character hex string\n\t */\n\tpublic static md5Hex(input: string | any[]): string {\n\t\tconst data = input;\n\t\tlet native;\n\t\tif (typeof data === 'string') {\n\t\t\tconst baos = Streams.createByteArrayOutputStream();\n\t\t\tbaos.writeText(data);\n\t\t\tnative = baos.getBytesNative();\n\t\t} else if (Array.isArray(data)) {\n\t\t\tnative = Bytes.toJavaBytes(data);\n\t\t}\n\n\t\treturn DigestFacade.md5Hex(native);\n\t}\n\n\t/**\n\t * Calculate SHA1 digest from input (text or byte array) and return result as 20 elements byte array\n\t */\n\tpublic static sha1(input: string | any[]): any[] {\n\t\treturn Bytes.toJavaScriptBytes(Digest.sha1AsNativeBytes(input));\n\t}\n\n\t/**\n\t * Calculate SHA1 digest from input (text or byte array) and return result as 20 elements java native byte array\n\t */\n\tpublic static sha1AsNativeBytes(input: string | any[]): any[] {\n\t\tconst data = input;\n\t\tlet native;\n\t\tif (typeof data === 'string') {\n\t\t\tconst baos = Streams.createByteArrayOutputStream();\n\t\t\tbaos.writeText(data);\n\t\t\tnative = baos.getBytesNative();\n\t\t} else if (Array.isArray(data)) {\n\t\t\tnative = Bytes.toJavaBytes(data);\n\t\t}\n\n\t\treturn DigestFacade.sha1(native);\n\t}\n\n\t/**\n\t * Calculate SHA256 digest from input (text or byte array) and return result as 32 elements byte array\n\t */\n\tpublic static sha256(input: string | any[]): any[] {\n\t\treturn Bytes.toJavaScriptBytes(Digest.sha256AsNativeBytes(input));\n\t}\n\n\t/**\n\t * Calculate SHA256 digest from input (text or byte array) and return result as 32 elements java native byte array\n\t */\n\tpublic static sha256AsNativeBytes(input: string | any[]): any[] {\n\t\tconst data = input;\n\t\tlet native;\n\t\tif (typeof data === 'string') {\n\t\t\tconst baos = Streams.createByteArrayOutputStream();\n\t\t\tbaos.writeText(data);\n\t\t\tnative = baos.getBytesNative();\n\t\t} else if (Array.isArray(data)) {\n\t\t\tnative = Bytes.toJavaBytes(data);\n\t\t}\n\n\t\treturn DigestFacade.sha256(native);\n\t}\n\n\t/**\n\t * Calculate SHA384 digest from input (text or byte array) and return result as 48 elements byte array\n\t */\n\tpublic static sha384(input: string | any[]): any[] {\n\t\treturn Bytes.toJavaScriptBytes(Digest.sha384AsNativeBytes(input));\n\t}\n\n\t/**\n\t * Calculate SHA384 digest from input (text or byte array) and return result as 48 elements java native byte array\n\t */\n\tpublic static sha384AsNativeBytes(input: string | any[]): any[] {\n\t\tconst data = input;\n\t\tlet native;\n\t\tif (typeof data === 'string') {\n\t\t\tconst baos = Streams.createByteArrayOutputStream();\n\t\t\tbaos.writeText(data);\n\t\t\tnative = baos.getBytesNative();\n\t\t} else if (Array.isArray(data)) {\n\t\t\tnative = Bytes.toJavaBytes(data);\n\t\t}\n\n\t\tconst output = DigestFacade.sha384(native);\n\t\treturn output;\n\t}\n\n\t/**\n\t * Calculate SHA512 digest from input (text or byte array) and return result as 64 elements byte array\n\t */\n\tpublic static sha512(input: string | any[]): any[] {\n\t\treturn Bytes.toJavaScriptBytes(Digest.sha512AsNativeBytes(input));\n\t}\n\n\t/**\n\t * Calculate SHA512 digest from input (text or byte array) and return result as 64 elements java native byte array\n\t */\n\tpublic static sha512AsNativeBytes(input: string | any[]) {\n\t\tconst data = input;\n\t\tlet native;\n\t\tif (typeof data === 'string') {\n\t\t\tconst baos = Streams.createByteArrayOutputStream();\n\t\t\tbaos.writeText(data);\n\t\t\tnative = baos.getBytesNative();\n\t\t} else if (Array.isArray(data)) {\n\t\t\tnative = Bytes.toJavaBytes(data);\n\t\t}\n\n\t\treturn DigestFacade.sha512(native);\n\t}\n\n\t/**\n\t * Calculate SHA1 digest from input (text or byte array) and return result as 40 character hex string\n\t */\n\tpublic static sha1Hex(input: string | any[]): string {\n\t\tconst data = input;\n\t\tlet native;\n\t\tif (typeof data === 'string') {\n\t\t\tconst baos = Streams.createByteArrayOutputStream();\n\t\t\tbaos.writeText(data);\n\t\t\tnative = baos.getBytesNative();\n\t\t} else if (Array.isArray(data)) {\n\t\t\tnative = Bytes.toJavaBytes(data);\n\t\t}\n\n\t\treturn DigestFacade.sha1Hex(native);\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Digest;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/utils/escape.mjs

@@ -0,0 +1,141 @@
+const EscapeFacade = Java.type("org.eclipse.dirigible.components.api.utils.EscapeFacade");
+class Escape {
+  /**
+   * Escapes special characters in a string to make it safe for use as a value within a CSV file.
+   * Typically handles double quotes, commas, and newlines.
+   *
+   * @param input The string to be escaped.
+   * @returns The CSV-safe escaped string.
+   */
+  static escapeCsv(input) {
+    return EscapeFacade.escapeCsv(input);
+  }
+  /**
+   * Escapes characters in a string to create a valid JavaScript string literal.
+   * This makes it safe for embedding string values within JavaScript code blocks.
+   *
+   * @param input The string to be escaped.
+   * @returns The JavaScript-safe escaped string.
+   */
+  static escapeJavascript(input) {
+    return EscapeFacade.escapeJavascript(input);
+  }
+  /**
+   * Escapes characters in a string using HTML 3.2 entity references.
+   *
+   * @param input The string to be escaped.
+   * @returns The HTML 3.2 escaped string.
+   */
+  static escapeHtml3(input) {
+    return EscapeFacade.escapeHtml3(input);
+  }
+  /**
+   * Escapes characters in a string using HTML 4.0 entity references.
+   * This is the common standard for escaping characters like <, >, &, and ".
+   *
+   * @param input The string to be escaped.
+   * @returns The HTML 4.0 escaped string.
+   */
+  static escapeHtml4(input) {
+    return EscapeFacade.escapeHtml4(input);
+  }
+  /**
+   * Escapes characters in a string to create a valid Java string literal.
+   *
+   * @param input The string to be escaped.
+   * @returns The Java-safe escaped string.
+   */
+  static escapeJava(input) {
+    return EscapeFacade.escapeJava(input);
+  }
+  /**
+   * Escapes characters (like quotes, backslashes, and control characters) in a string
+   * to make it safe for embedding as a value within a JSON document.
+   *
+   * @param input The string to be escaped.
+   * @returns The JSON-safe escaped string.
+   */
+  static escapeJson(input) {
+    return EscapeFacade.escapeJson(input);
+  }
+  /**
+   * Escapes characters in a string to make it valid for use within an XML document.
+   * Typically handles characters like <, >, &, ", and '.
+   *
+   * @param input The string to be escaped.
+   * @returns The XML-safe escaped string.
+   */
+  static escapeXml(input) {
+    return EscapeFacade.escapeXml(input);
+  }
+  /**
+   * The inverse of `escapeCsv`: unescapes CSV-specific escape sequences back to their original form.
+   *
+   * @param input The CSV-escaped string.
+   * @returns The unescaped string.
+   */
+  static unescapeCsv(input) {
+    return EscapeFacade.unescapeCsv(input);
+  }
+  /**
+   * The inverse of `escapeJavascript`: unescapes JavaScript string literals.
+   *
+   * @param input The JavaScript-escaped string.
+   * @returns The unescaped string.
+   */
+  static unescapeJavascript(input) {
+    return EscapeFacade.unescapeJavascript(input);
+  }
+  /**
+   * The inverse of `escapeHtml3`: unescapes HTML 3.2 entity references.
+   *
+   * @param input The HTML 3.2 escaped string.
+   * @returns The unescaped string.
+   */
+  static unescapeHtml3(input) {
+    return EscapeFacade.unescapeHtml3(input);
+  }
+  /**
+   * The inverse of `escapeHtml4`: unescapes HTML 4.0 entity references.
+   *
+   * @param input The HTML 4.0 escaped string.
+   * @returns The unescaped string.
+   */
+  static unescapeHtml4(input) {
+    return EscapeFacade.unescapeHtml4(input);
+  }
+  /**
+   * The inverse of `escapeJava`: unescapes Java string literals.
+   *
+   * @param input The Java-escaped string.
+   * @returns The unescaped string.
+   */
+  static unescapeJava(input) {
+    return EscapeFacade.unescapeJava(input);
+  }
+  /**
+   * The inverse of `escapeJson`: unescapes JSON string escape sequences.
+   *
+   * @param input The JSON-escaped string.
+   * @returns The unescaped string.
+   */
+  static unescapeJson(input) {
+    return EscapeFacade.unescapeJson(input);
+  }
+  /**
+   * The inverse of `escapeXml`: unescapes XML entity references.
+   *
+   * @param input The XML-escaped string.
+   * @returns The unescaped string.
+   */
+  static unescapeXml(input) {
+    return EscapeFacade.unescapeXml(input);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Escape;
+}
+export {
+  Escape
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/utils/escape.ts"],
  "sourcesContent": ["const EscapeFacade = Java.type(\"org.eclipse.dirigible.components.api.utils.EscapeFacade\");\n\n/**\n * Utility class for performing context-aware string escaping and unescaping operations,\n * delegating to a native Java EscapeFacade. These methods are essential for security\n * (preventing injection attacks) and ensuring correct data serialization across different formats.\n */\nexport class Escape {\n\n\t/**\n\t * Escapes special characters in a string to make it safe for use as a value within a CSV file.\n\t * Typically handles double quotes, commas, and newlines.\n\t *\n\t * @param input The string to be escaped.\n\t * @returns The CSV-safe escaped string.\n\t */\n\tpublic static escapeCsv(input: string): string {\n\t\treturn EscapeFacade.escapeCsv(input);\n\t}\n\n\t/**\n\t * Escapes characters in a string to create a valid JavaScript string literal.\n\t * This makes it safe for embedding string values within JavaScript code blocks.\n\t *\n\t * @param input The string to be escaped.\n\t * @returns The JavaScript-safe escaped string.\n\t */\n\tpublic static escapeJavascript(input: string): string {\n\t\treturn EscapeFacade.escapeJavascript(input);\n\t}\n\n\t/**\n\t * Escapes characters in a string using HTML 3.2 entity references.\n\t *\n\t * @param input The string to be escaped.\n\t * @returns The HTML 3.2 escaped string.\n\t */\n\tpublic static escapeHtml3(input: string): string {\n\t\treturn EscapeFacade.escapeHtml3(input);\n\t}\n\n\t/**\n\t * Escapes characters in a string using HTML 4.0 entity references.\n\t * This is the common standard for escaping characters like <, >, &, and \".\n\t *\n\t * @param input The string to be escaped.\n\t * @returns The HTML 4.0 escaped string.\n\t */\n\tpublic static escapeHtml4(input: string): string {\n\t\treturn EscapeFacade.escapeHtml4(input);\n\t}\n\n\t/**\n\t * Escapes characters in a string to create a valid Java string literal.\n\t *\n\t * @param input The string to be escaped.\n\t * @returns The Java-safe escaped string.\n\t */\n\tpublic static escapeJava(input: string): string {\n\t\treturn EscapeFacade.escapeJava(input);\n\t}\n\n\t/**\n\t * Escapes characters (like quotes, backslashes, and control characters) in a string\n\t * to make it safe for embedding as a value within a JSON document.\n\t *\n\t * @param input The string to be escaped.\n\t * @returns The JSON-safe escaped string.\n\t */\n\tpublic static escapeJson(input: string): string {\n\t\treturn EscapeFacade.escapeJson(input);\n\t}\n\n\t/**\n\t * Escapes characters in a string to make it valid for use within an XML document.\n\t * Typically handles characters like <, >, &, \", and '.\n\t *\n\t * @param input The string to be escaped.\n\t * @returns The XML-safe escaped string.\n\t */\n\tpublic static escapeXml(input: string): string {\n\t\treturn EscapeFacade.escapeXml(input);\n\t}\n\n\t/**\n\t * The inverse of `escapeCsv`: unescapes CSV-specific escape sequences back to their original form.\n\t *\n\t * @param input The CSV-escaped string.\n\t * @returns The unescaped string.\n\t */\n\tpublic static unescapeCsv(input: string): string {\n\t\treturn EscapeFacade.unescapeCsv(input);\n\t}\n\n\t/**\n\t * The inverse of `escapeJavascript`: unescapes JavaScript string literals.\n\t *\n\t * @param input The JavaScript-escaped string.\n\t * @returns The unescaped string.\n\t */\n\tpublic static unescapeJavascript(input: string): string {\n\t\treturn EscapeFacade.unescapeJavascript(input);\n\t}\n\n\t/**\n\t * The inverse of `escapeHtml3`: unescapes HTML 3.2 entity references.\n\t *\n\t * @param input The HTML 3.2 escaped string.\n\t * @returns The unescaped string.\n\t */\n\tpublic static unescapeHtml3(input: string): string {\n\t\treturn EscapeFacade.unescapeHtml3(input);\n\t}\n\n\t/**\n\t * The inverse of `escapeHtml4`: unescapes HTML 4.0 entity references.\n\t *\n\t * @param input The HTML 4.0 escaped string.\n\t * @returns The unescaped string.\n\t */\n\tpublic static unescapeHtml4(input: string): string {\n\t\treturn EscapeFacade.unescapeHtml4(input);\n\t}\n\n\t/**\n\t * The inverse of `escapeJava`: unescapes Java string literals.\n\t *\n\t * @param input The Java-escaped string.\n\t * @returns The unescaped string.\n\t */\n\tpublic static unescapeJava(input: string): string {\n\t\treturn EscapeFacade.unescapeJava(input);\n\t}\n\n\t/**\n\t * The inverse of `escapeJson`: unescapes JSON string escape sequences.\n\t *\n\t * @param input The JSON-escaped string.\n\t * @returns The unescaped string.\n\t */\n\tpublic static unescapeJson(input: string): string {\n\t\treturn EscapeFacade.unescapeJson(input);\n\t}\n\n\t/**\n\t * The inverse of `escapeXml`: unescapes XML entity references.\n\t *\n\t * @param input The XML-escaped string.\n\t * @returns The unescaped string.\n\t */\n\tpublic static unescapeXml(input: string): string {\n\t\treturn EscapeFacade.unescapeXml(input);\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Escape;\n}"],
  "mappings": "AAAA,MAAM,eAAe,KAAK,KAAK,yDAAyD;AAOjF,MAAM,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASnB,OAAc,UAAU,OAAuB;AAC9C,WAAO,aAAa,UAAU,KAAK;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,iBAAiB,OAAuB;AACrD,WAAO,aAAa,iBAAiB,KAAK;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,YAAY,OAAuB;AAChD,WAAO,aAAa,YAAY,KAAK;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,YAAY,OAAuB;AAChD,WAAO,aAAa,YAAY,KAAK;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,WAAW,OAAuB;AAC/C,WAAO,aAAa,WAAW,KAAK;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,WAAW,OAAuB;AAC/C,WAAO,aAAa,WAAW,KAAK;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,UAAU,OAAuB;AAC9C,WAAO,aAAa,UAAU,KAAK;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,YAAY,OAAuB;AAChD,WAAO,aAAa,YAAY,KAAK;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,mBAAmB,OAAuB;AACvD,WAAO,aAAa,mBAAmB,KAAK;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,cAAc,OAAuB;AAClD,WAAO,aAAa,cAAc,KAAK;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,cAAc,OAAuB;AAClD,WAAO,aAAa,cAAc,KAAK;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,aAAa,OAAuB;AACjD,WAAO,aAAa,aAAa,KAAK;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,aAAa,OAAuB;AACjD,WAAO,aAAa,aAAa,KAAK;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,YAAY,OAAuB;AAChD,WAAO,aAAa,YAAY,KAAK;AAAA,EACtC;AACD;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/dist/esm/utils/hex.mjs

@@ -0,0 +1,85 @@
+import { Streams } from "@aerokit/sdk/io/streams";
+import { Bytes } from "@aerokit/sdk/io/bytes";
+const HexFacade = Java.type("org.eclipse.dirigible.components.api.utils.HexFacade");
+class Hex {
+  /**
+   * Hexadecimal encoding: Converts the input data (text or byte array) into a
+   * standard **hexadecimal string representation**.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting hexadecimal string.
+   */
+  static encode(input) {
+    return Bytes.byteArrayToText(Hex.encodeAsNativeBytes(input));
+  }
+  /**
+   * Hexadecimal encoding: Converts the input data (text or byte array) into a
+   * **JavaScript byte array (any[])** containing the hexadecimal representation.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting byte array containing the hexadecimal data.
+   */
+  static encodeAsBytes(input) {
+    return Bytes.toJavaScriptBytes(Hex.encodeAsNativeBytes(input));
+  }
+  /**
+   * Hexadecimal encoding: Converts the input data (text or byte array) into a
+   * **native Java byte array** containing the hexadecimal representation.
+   * This method is generally for internal use.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting native Java byte array.
+   */
+  static encodeAsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return HexFacade.encodeNative(native);
+  }
+  /**
+   * Hexadecimal decoding: Converts a hexadecimal input (text or byte array) back into
+   * the original **raw byte array (JavaScript any[])**.
+   *
+   * @param input The hexadecimal data to decode, either as a string or a JavaScript byte array (any[]).
+   * @returns The decoded raw byte array (any[]). Returns null if decoding fails or input is null.
+   */
+  static decode(input) {
+    const output = Hex.decodeAsNativeBytes(input);
+    if (output) {
+      return Bytes.toJavaScriptBytes(output);
+    }
+    return output;
+  }
+  /**
+   * Hexadecimal decoding: Converts a hexadecimal input (text or byte array) back into
+   * the original **native Java raw byte array**. This method is generally for internal use.
+   *
+   * @param input The hexadecimal data to decode, either as a string or a JavaScript byte array (any[]).
+   * @returns The decoded native Java byte array.
+   */
+  static decodeAsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = Bytes.toJavaBytes(data);
+    }
+    return HexFacade.decodeNative(native);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Hex;
+}
+export {
+  Hex
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/index.mjs

@@ -0,0 +1,38 @@
+export * from "./alphanumeric";
+import { Alphanumeric } from "./alphanumeric";
+export * from "./base64";
+import { Base64 } from "./base64";
+export * from "./digest";
+import { Digest } from "./digest";
+export * from "./escape";
+import { Escape } from "./escape";
+export * from "./hex";
+import { Hex } from "./hex";
+import * as jsonpath from "./jsonpath";
+export * from "./qrcode";
+import { QRCode } from "./qrcode";
+export * from "./url";
+import { URL } from "./url";
+export * from "./utf8";
+import { UTF8 } from "./utf8";
+export * from "./uuid";
+import { UUID } from "./uuid";
+export * from "./xml";
+import { XML } from "./xml";
+export * from "./converter";
+import { Converter } from "./converter";
+export {
+  Alphanumeric as alphanumeric,
+  Base64 as base64,
+  Converter as converter,
+  Digest as digest,
+  Escape as escape,
+  Hex as hex,
+  jsonpath,
+  QRCode as qrcode,
+  URL as url,
+  UTF8 as utf8,
+  UUID as uuid,
+  XML as xml
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3V0aWxzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi9hbHBoYW51bWVyaWNcIjtcbmV4cG9ydCB7IEFscGhhbnVtZXJpYyBhcyBhbHBoYW51bWVyaWMgfSBmcm9tIFwiLi9hbHBoYW51bWVyaWNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Jhc2U2NFwiO1xuZXhwb3J0IHsgQmFzZTY0IGFzIGJhc2U2NCB9IGZyb20gXCIuL2Jhc2U2NFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGlnZXN0XCI7XG5leHBvcnQgeyBEaWdlc3QgYXMgZGlnZXN0IH0gZnJvbSBcIi4vZGlnZXN0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lc2NhcGVcIjtcbmV4cG9ydCB7IEVzY2FwZSBhcyBlc2NhcGUgfSBmcm9tIFwiLi9lc2NhcGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2hleFwiO1xuZXhwb3J0IHsgSGV4IGFzIGhleCB9IGZyb20gXCIuL2hleFwiO1xuZXhwb3J0ICogYXMganNvbnBhdGggZnJvbSBcIi4vanNvbnBhdGhcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3FyY29kZVwiO1xuZXhwb3J0IHsgUVJDb2RlIGFzIHFyY29kZSB9IGZyb20gXCIuL3FyY29kZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXJsXCI7XG5leHBvcnQgeyBVUkwgYXMgdXJsIH0gZnJvbSBcIi4vdXJsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGY4XCI7XG5leHBvcnQgeyBVVEY4IGFzIHV0ZjggfSBmcm9tIFwiLi91dGY4XCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dWlkXCI7XG5leHBvcnQgeyBVVUlEIGFzIHV1aWQgfSBmcm9tIFwiLi91dWlkXCI7XG5leHBvcnQgKiBmcm9tIFwiLi94bWxcIjtcbmV4cG9ydCB7IFhNTCBhcyB4bWwgfSBmcm9tIFwiLi94bWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnZlcnRlclwiO1xuZXhwb3J0IHsgQ29udmVydGVyIGFzIGNvbnZlcnRlciB9IGZyb20gXCIuL2NvbnZlcnRlclwiO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsY0FBYztBQUNkLFNBQXlCLG9CQUFvQjtBQUM3QyxjQUFjO0FBQ2QsU0FBbUIsY0FBYztBQUNqQyxjQUFjO0FBQ2QsU0FBbUIsY0FBYztBQUNqQyxjQUFjO0FBQ2QsU0FBbUIsY0FBYztBQUNqQyxjQUFjO0FBQ2QsU0FBZ0IsV0FBVztBQUMzQixZQUFZLGNBQWM7QUFDMUIsY0FBYztBQUNkLFNBQW1CLGNBQWM7QUFDakMsY0FBYztBQUNkLFNBQWdCLFdBQVc7QUFDM0IsY0FBYztBQUNkLFNBQWlCLFlBQVk7QUFDN0IsY0FBYztBQUNkLFNBQWlCLFlBQVk7QUFDN0IsY0FBYztBQUNkLFNBQWdCLFdBQVc7QUFDM0IsY0FBYztBQUNkLFNBQXNCLGlCQUFpQjsiLAogICJuYW1lcyI6IFtdCn0K