@aerokit/sdk 12.44.0

package/dist/cjs/io/streams.js

@@ -0,0 +1,243 @@
+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 streams_exports = {};
+__export(streams_exports, {
+  InputStream: () => InputStream,
+  OutputStream: () => OutputStream,
+  Streams: () => Streams
+});
+module.exports = __toCommonJS(streams_exports);
+var import_bytes = require("@aerokit/sdk/io/bytes");
+const StreamsFacade = Java.type("org.eclipse.dirigible.components.api.io.StreamsFacade");
+class Streams {
+  /**
+   * Copies all bytes from the input stream to the output stream.
+   * This method is generally used for smaller streams.
+   *
+   * @param input The source {@link InputStream}.
+   * @param output The destination {@link OutputStream}.
+   */
+  static copy(input, output) {
+    StreamsFacade.copy(input.native, output.native);
+  }
+  /**
+   * Copies all bytes from the input stream to the output stream using a large buffer,
+   * suitable for large file transfers.
+   *
+   * @param input The source {@link InputStream}.
+   * @param output The destination {@link OutputStream}.
+   */
+  static copyLarge(input, output) {
+    StreamsFacade.copyLarge(input.native, output.native);
+  }
+  /**
+   * Creates a new {@link InputStream} from a resource accessible via the class loader.
+   * This is typically used to read bundled resources within the application runtime.
+   *
+   * @param path The path to the resource.
+   * @returns A new {@link InputStream} instance for the resource.
+   */
+  static getResourceAsByteArrayInputStream(path) {
+    const native = StreamsFacade.getResourceAsByteArrayInputStream(path);
+    return new InputStream(native);
+  }
+  /**
+   * Creates a new {@link InputStream} from a JavaScript byte array (`any[]`).
+   *
+   * @param data The JavaScript array of byte values (`number[]`).
+   * @returns A new {@link InputStream} instance initialized with the byte data.
+   */
+  static createByteArrayInputStream(data) {
+    const array = import_bytes.Bytes.toJavaBytes(data);
+    const native = StreamsFacade.createByteArrayInputStream(array);
+    return new InputStream(native);
+  }
+  /**
+   * Creates a new {@link OutputStream} that writes data into an in-memory byte array.
+   * This is typically used as a buffer to capture output before processing it.
+   *
+   * @returns A new {@link OutputStream} instance backed by a byte array.
+   */
+  static createByteArrayOutputStream() {
+    const native = StreamsFacade.createByteArrayOutputStream();
+    return new OutputStream(native);
+  }
+  /**
+   * Wraps a native (Java) InputStream object into a new JavaScript {@link InputStream} instance.
+   *
+   * @param native The underlying native InputStream object.
+   * @returns A new {@link InputStream} wrapper.
+   */
+  static createInputStream(native) {
+    const inputStream = new InputStream(native);
+    return inputStream;
+  }
+  /**
+   * Wraps a native (Java) OutputStream object into a new JavaScript {@link OutputStream} instance.
+   *
+   * Note: This method is not static in the original definition, but is placed here for completeness
+   * and consistency with other factory methods.
+   *
+   * @param native The underlying native OutputStream object.
+   * @returns A new {@link OutputStream} wrapper.
+   */
+  createOutputStream(native) {
+    const outputStream = new OutputStream(native);
+    return outputStream;
+  }
+}
+class InputStream {
+  /**
+   * @param native The native Java InputStream object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Reads the next byte of data from this input stream.
+   * @returns The next byte of data, or -1 if the end of the stream is reached.
+   */
+  read() {
+    return StreamsFacade.read(this.native);
+  }
+  /**
+   * Reads all remaining bytes from the stream and returns them as a JavaScript array.
+   *
+   * @returns A JavaScript array (`number[]`) of the byte values.
+   */
+  readBytes() {
+    const native = StreamsFacade.readBytes(this.native);
+    return import_bytes.Bytes.toJavaScriptBytes(native);
+  }
+  /**
+   * Reads all remaining bytes from the stream and returns the native Java byte array.
+   *
+   * @returns The native Java byte array object.
+   */
+  readBytesNative() {
+    return StreamsFacade.readBytes(this.native);
+  }
+  /**
+   * Reads all remaining bytes from the stream and converts them to a string
+   * using the platform's default character encoding.
+   *
+   * @returns The content of the stream as a string.
+   */
+  readText() {
+    return StreamsFacade.readText(this.native);
+  }
+  /**
+   * Closes this input stream and releases any system resources associated with it.
+   */
+  close() {
+    StreamsFacade.close(this.native);
+  }
+  /**
+   * Checks if the underlying native stream object is defined and non-null.
+   * @returns True if the stream is valid, false otherwise.
+   */
+  isValid() {
+    return this.native !== void 0 && this.native !== null;
+  }
+}
+class OutputStream {
+  /**
+   * @param native The native Java OutputStream object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Writes the specified byte to this output stream.
+   * @param byte The byte (as a number 0-255) to write.
+   */
+  write(byte) {
+    StreamsFacade.write(this.native, byte);
+  }
+  /**
+   * Writes the entire content of a JavaScript byte array to this output stream.
+   *
+   * @param data The JavaScript array (`number[]`) of byte values to write.
+   */
+  writeBytes(data) {
+    const native = import_bytes.Bytes.toJavaBytes(data);
+    StreamsFacade.writeBytes(this.native, native);
+  }
+  /**
+   * Writes the entire content of a native Java byte array to this output stream.
+   *
+   * @param data The native Java byte array object to write.
+   */
+  writeBytesNative(data) {
+    StreamsFacade.writeBytes(this.native, data);
+  }
+  /**
+   * Converts the string to bytes using the platform's default character encoding
+   * and writes them to this output stream.
+   *
+   * @param text The string content to write.
+   */
+  writeText(text) {
+    StreamsFacade.writeText(this.native, text);
+  }
+  /**
+   * Closes this output stream and releases any system resources associated with it.
+   */
+  close() {
+    StreamsFacade.close(this.native);
+  }
+  /**
+   * Retrieves the content written to this stream as a JavaScript byte array.
+   * This is typically used with a ByteArrayOutputStream.
+   *
+   * @returns A JavaScript array (`number[]`) of the byte values written to the stream.
+   */
+  getBytes() {
+    const native = StreamsFacade.getBytes(this.native);
+    return import_bytes.Bytes.toJavaScriptBytes(native);
+  }
+  /**
+   * Retrieves the content written to this stream as the native Java byte array.
+   * This is typically used with a ByteArrayOutputStream.
+   *
+   * @returns The native Java byte array object.
+   */
+  getBytesNative() {
+    return StreamsFacade.getBytes(this.native);
+  }
+  /**
+   * Retrieves the content written to this stream as a string using the platform's
+   * default character encoding. This is typically used with a ByteArrayOutputStream.
+   *
+   * @returns The content of the stream as a string.
+   */
+  getText() {
+    return StreamsFacade.getText(this.native);
+  }
+  /**
+   * Checks if the underlying native stream object is defined and non-null.
+   * @returns True if the stream is valid, false otherwise.
+   */
+  isValid() {
+    return this.native !== void 0 && this.native !== null;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Streams;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/io/streams.ts"],
  "sourcesContent": ["/**\n * Provides core functionality for input/output stream management,\n * including stream creation, data transfer, and byte array handling.\n */\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\n\nconst StreamsFacade = Java.type(\"org.eclipse.dirigible.components.api.io.StreamsFacade\");\n\n/**\n * The Streams class provides static utility methods for stream creation,\n * manipulation, and data copying.\n */\nexport class Streams {\n\n\t/**\n\t * Copies all bytes from the input stream to the output stream.\n\t * This method is generally used for smaller streams.\n\t *\n\t * @param input The source {@link InputStream}.\n\t * @param output The destination {@link OutputStream}.\n\t */\n\tpublic static copy(input: InputStream, output: OutputStream): void {\n\t\tStreamsFacade.copy(input.native, output.native);\n\t}\n\n\t/**\n\t * Copies all bytes from the input stream to the output stream using a large buffer,\n\t * suitable for large file transfers.\n\t *\n\t * @param input The source {@link InputStream}.\n\t * @param output The destination {@link OutputStream}.\n\t */\n\tpublic static copyLarge(input: InputStream, output: OutputStream): void {\n\t\tStreamsFacade.copyLarge(input.native, output.native);\n\t}\n\n\t/**\n\t * Creates a new {@link InputStream} from a resource accessible via the class loader.\n\t * This is typically used to read bundled resources within the application runtime.\n\t *\n\t * @param path The path to the resource.\n\t * @returns A new {@link InputStream} instance for the resource.\n\t */\n\tpublic static getResourceAsByteArrayInputStream(path: string): InputStream {\n\t\tconst native = StreamsFacade.getResourceAsByteArrayInputStream(path);\n\t\treturn new InputStream(native);\n\t}\n\n\t/**\n\t * Creates a new {@link InputStream} from a JavaScript byte array (`any[]`).\n\t *\n\t * @param data The JavaScript array of byte values (`number[]`).\n\t * @returns A new {@link InputStream} instance initialized with the byte data.\n\t */\n\tpublic static createByteArrayInputStream(data: any[]): InputStream {\n\t\t// Convert JavaScript byte array to native Java byte array\n\t\tconst array = Bytes.toJavaBytes(data);\n\t\tconst native = StreamsFacade.createByteArrayInputStream(array);\n\t\treturn new InputStream(native);\n\t}\n\n\t/**\n\t * Creates a new {@link OutputStream} that writes data into an in-memory byte array.\n\t * This is typically used as a buffer to capture output before processing it.\n\t *\n\t * @returns A new {@link OutputStream} instance backed by a byte array.\n\t */\n\tpublic static createByteArrayOutputStream(): OutputStream {\n\t\tconst native = StreamsFacade.createByteArrayOutputStream();\n\t\treturn new OutputStream(native);\n\t}\n\n\t/**\n\t * Wraps a native (Java) InputStream object into a new JavaScript {@link InputStream} instance.\n\t *\n\t * @param native The underlying native InputStream object.\n\t * @returns A new {@link InputStream} wrapper.\n\t */\n\tpublic static createInputStream(native: any): InputStream {\n\t\tconst inputStream = new InputStream(native);\n\t\treturn inputStream;\n\t}\n\n\t/**\n\t * Wraps a native (Java) OutputStream object into a new JavaScript {@link OutputStream} instance.\n\t *\n\t * Note: This method is not static in the original definition, but is placed here for completeness\n\t * and consistency with other factory methods.\n\t *\n\t * @param native The underlying native OutputStream object.\n\t * @returns A new {@link OutputStream} wrapper.\n\t */\n\tpublic createOutputStream(native: any): OutputStream {\n\t\tconst outputStream = new OutputStream(native);\n\t\treturn outputStream;\n\t}\n}\n\n/**\n * Represents an input stream for reading bytes.\n * This class wraps a native stream object and provides methods for reading data.\n */\nexport class InputStream {\n\n\t/** The underlying native Java stream object. */\n\tpublic readonly native: any;\n\n\t/**\n\t * @param native The native Java InputStream object.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Reads the next byte of data from this input stream.\n\t * @returns The next byte of data, or -1 if the end of the stream is reached.\n\t */\n\tpublic read(): number {\n\t\treturn StreamsFacade.read(this.native);\n\t}\n\n\t/**\n\t * Reads all remaining bytes from the stream and returns them as a JavaScript array.\n\t *\n\t * @returns A JavaScript array (`number[]`) of the byte values.\n\t */\n\tpublic readBytes(): any[] {\n\t\tconst native = StreamsFacade.readBytes(this.native);\n\t\treturn Bytes.toJavaScriptBytes(native);\n\t}\n\n\t/**\n\t * Reads all remaining bytes from the stream and returns the native Java byte array.\n\t *\n\t * @returns The native Java byte array object.\n\t */\n\tpublic readBytesNative(): any[] {\n\t\treturn StreamsFacade.readBytes(this.native);\n\t}\n\n\t/**\n\t * Reads all remaining bytes from the stream and converts them to a string\n\t * using the platform's default character encoding.\n\t *\n\t * @returns The content of the stream as a string.\n\t */\n\tpublic readText(): string {\n\t\treturn StreamsFacade.readText(this.native);\n\t}\n\n\t/**\n\t * Closes this input stream and releases any system resources associated with it.\n\t */\n\tpublic close(): void {\n\t\tStreamsFacade.close(this.native);\n\t}\n\n\t/**\n\t * Checks if the underlying native stream object is defined and non-null.\n\t * @returns True if the stream is valid, false otherwise.\n\t */\n\tpublic isValid(): boolean {\n\t\treturn this.native !== undefined && this.native !== null;\n\t}\n}\n\n/**\n * Represents an output stream for writing bytes.\n * This class wraps a native stream object and provides methods for writing data.\n */\nexport class OutputStream {\n\n\t/** The underlying native Java stream object. */\n\tpublic readonly native: any;\n\n\t/**\n\t * @param native The native Java OutputStream object.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Writes the specified byte to this output stream.\n\t * @param byte The byte (as a number 0-255) to write.\n\t */\n\tpublic write(byte: number): void {\n\t\tStreamsFacade.write(this.native, byte);\n\t}\n\n\t/**\n\t * Writes the entire content of a JavaScript byte array to this output stream.\n\t *\n\t * @param data The JavaScript array (`number[]`) of byte values to write.\n\t */\n\tpublic writeBytes(data: any[]): void {\n\t\t// Convert JavaScript byte array to native Java byte array\n\t\tconst native = Bytes.toJavaBytes(data);\n\t\tStreamsFacade.writeBytes(this.native, native);\n\t}\n\n\t/**\n\t * Writes the entire content of a native Java byte array to this output stream.\n\t *\n\t * @param data The native Java byte array object to write.\n\t */\n\tpublic writeBytesNative(data: any[]): void {\n\t\tStreamsFacade.writeBytes(this.native, data);\n\t}\n\n\t/**\n\t * Converts the string to bytes using the platform's default character encoding\n\t * and writes them to this output stream.\n\t *\n\t * @param text The string content to write.\n\t */\n\tpublic writeText(text: string): void {\n\t\tStreamsFacade.writeText(this.native, text);\n\t}\n\n\t/**\n\t * Closes this output stream and releases any system resources associated with it.\n\t */\n\tpublic close(): void {\n\t\tStreamsFacade.close(this.native);\n\t}\n\n\t/**\n\t * Retrieves the content written to this stream as a JavaScript byte array.\n\t * This is typically used with a ByteArrayOutputStream.\n\t *\n\t * @returns A JavaScript array (`number[]`) of the byte values written to the stream.\n\t */\n\tpublic getBytes(): any[] {\n\t\tconst native = StreamsFacade.getBytes(this.native);\n\t\treturn Bytes.toJavaScriptBytes(native);\n\t}\n\n\t/**\n\t * Retrieves the content written to this stream as the native Java byte array.\n\t * This is typically used with a ByteArrayOutputStream.\n\t *\n\t * @returns The native Java byte array object.\n\t */\n\tpublic getBytesNative(): any[] {\n\t\treturn StreamsFacade.getBytes(this.native);\n\t}\n\n\t/**\n\t * Retrieves the content written to this stream as a string using the platform's\n\t * default character encoding. This is typically used with a ByteArrayOutputStream.\n\t *\n\t * @returns The content of the stream as a string.\n\t */\n\tpublic getText(): string {\n\t\treturn StreamsFacade.getText(this.native);\n\t}\n\n\t/**\n\t * Checks if the underlying native stream object is defined and non-null.\n\t * @returns True if the stream is valid, false otherwise.\n\t */\n\tpublic isValid(): boolean {\n\t\treturn this.native !== undefined && this.native !== null;\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Streams;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/cjs/io/zip.js

@@ -0,0 +1,251 @@
+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 zip_exports = {};
+__export(zip_exports, {
+  Zip: () => Zip,
+  ZipEntry: () => ZipEntry,
+  ZipInputStream: () => ZipInputStream,
+  ZipOutputStream: () => ZipOutputStream
+});
+module.exports = __toCommonJS(zip_exports);
+var import_bytes = require("@aerokit/sdk/io/bytes");
+const ZipFacade = Java.type("org.eclipse.dirigible.components.api.io.ZipFacade");
+class Zip {
+  /**
+   * Zips the content of a source directory or file into a target ZIP file.
+   *
+   * @param sourcePath The file system path to the content to be compressed.
+   * @param zipTargetPath The file system path where the resulting ZIP file should be saved.
+   */
+  static zip(sourcePath, zipTargetPath) {
+    ZipFacade.exportZip(sourcePath, zipTargetPath);
+  }
+  /**
+   * Unzips an existing ZIP file into a target directory.
+   *
+   * @param zipPath The file system path to the ZIP file to be extracted.
+   * @param targetPath The file system path to the directory where content should be extracted.
+   */
+  static unzip(zipPath, targetPath) {
+    ZipFacade.importZip(zipPath, targetPath);
+  }
+  /**
+   * Creates a {@link ZipInputStream} that reads ZIP archive data from a provided
+   * generic {@link InputStream}. This allows for reading ZIP entries without
+   * writing the archive to disk first.
+   *
+   * @param inputStream The source stream containing the raw ZIP data.
+   * @returns A new {@link ZipInputStream} instance.
+   */
+  static createZipInputStream(inputStream) {
+    const native = ZipFacade.createZipInputStream(inputStream.native);
+    return new ZipInputStream(native);
+  }
+  /**
+   * Creates a {@link ZipOutputStream} that writes compressed ZIP archive data
+   * to a provided generic {@link OutputStream}. This allows for creating ZIP archives
+   * in memory or streaming them directly.
+   *
+   * @param outputStream The destination stream where the raw ZIP data will be written.
+   * @returns A new {@link ZipOutputStream} instance.
+   */
+  static createZipOutputStream(outputStream) {
+    const native = ZipFacade.createZipOutputStream(outputStream.native);
+    return new ZipOutputStream(native);
+  }
+}
+class ZipInputStream {
+  /**
+   * @param native The underlying native ZipInputStream object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Reads the next ZIP file entry and positions the stream at the beginning of the entry data.
+   * Must be called before reading data for an entry.
+   *
+   * @returns The next {@link ZipEntry} object, or null if there are no more entries.
+   */
+  getNextEntry() {
+    const native = this.native.getNextEntry();
+    return new ZipEntry(native);
+  }
+  /**
+   * Reads the data for the current entry and returns it as a JavaScript byte array.
+   *
+   * @returns A JavaScript array (`number[]`) of the byte values for the current entry.
+   */
+  read() {
+    const native = ZipFacade.readNative(this.native);
+    return import_bytes.Bytes.toJavaScriptBytes(native);
+  }
+  /**
+   * Reads the data for the current entry and returns the native Java byte array.
+   *
+   * @returns The native Java byte array object.
+   */
+  readNative() {
+    return ZipFacade.readNative(this.native);
+  }
+  /**
+   * Reads the data for the current entry and converts it to a string
+   * using the platform's default character encoding.
+   *
+   * @returns The content of the current entry as a string.
+   */
+  readText() {
+    return ZipFacade.readText(this.native);
+  }
+  /**
+   * Closes the underlying native ZipInputStream.
+   */
+  close() {
+    this.native.close();
+  }
+}
+class ZipOutputStream {
+  /**
+   * @param native The underlying native ZipOutputStream object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Creates a new {@link ZipEntry} with the given name, and begins writing the
+   * entry's header to the archive stream. All subsequent write operations
+   * will apply to this entry until {@link closeEntry} is called.
+   *
+   * @param name The file or directory name to use inside the ZIP archive.
+   * @returns The newly created {@link ZipEntry} object.
+   */
+  createZipEntry(name) {
+    const nativeNext = ZipFacade.createZipEntry(name);
+    const zipEntry = new ZipEntry(nativeNext);
+    this.native.putNextEntry(nativeNext);
+    return zipEntry;
+  }
+  /**
+   * Writes the data from a JavaScript byte array to the current active entry in the stream.
+   *
+   * @param data The JavaScript array (`number[]`) of byte values to write.
+   */
+  write(data) {
+    const native = import_bytes.Bytes.toJavaBytes(data);
+    ZipFacade.writeNative(this.native, native);
+  }
+  /**
+   * Writes the data from a native Java byte array to the current active entry in the stream.
+   *
+   * @param data The native Java byte array object to write.
+   */
+  writeNative(data) {
+    ZipFacade.writeNative(this.native, data);
+  }
+  /**
+   * Converts the string to bytes and writes it to the current active entry in the stream.
+   *
+   * @param text The string content to write.
+   */
+  writeText(text) {
+    ZipFacade.writeText(this.native, text);
+  }
+  /**
+   * Closes the current active ZIP entry and positions the stream for the next entry.
+   */
+  closeEntry() {
+    this.native.closeEntry();
+  }
+  /**
+   * Finalizes the writing of the ZIP file, flushes the stream, and closes the native object.
+   * This must be called after all entries have been written.
+   */
+  close() {
+    this.native.finish();
+    this.native.flush();
+    this.native.close();
+  }
+}
+class ZipEntry {
+  /**
+   * @param native The underlying native ZipEntry object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the entry (path relative to the ZIP root).
+   * @returns The name of the entry.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the uncompressed size of the entry data.
+   * @returns The size in bytes.
+   */
+  getSize() {
+    return this.native.getSize();
+  }
+  /**
+   * Gets the compressed size of the entry data.
+   * @returns The compressed size in bytes.
+   */
+  getCompressedSize() {
+    return this.native.getCompressedSize();
+  }
+  /**
+   * Gets the modification time of the entry.
+   * @returns The time as a numerical timestamp.
+   */
+  getTime() {
+    return this.native.getTime();
+  }
+  /**
+   * Gets the CRC-32 checksum of the uncompressed entry data.
+   * @returns The CRC value.
+   */
+  getCrc() {
+    return this.native.getCrc();
+  }
+  /**
+   * Gets the optional comment for the entry.
+   * @returns The comment string.
+   */
+  getComment() {
+    return this.native.getComment();
+  }
+  /**
+   * Checks if the entry represents a directory.
+   * @returns True if it is a directory, false otherwise.
+   */
+  isDirectory() {
+    return this.native.isDirectory();
+  }
+  /**
+   * Checks if the underlying native ZipEntry object is defined and non-null.
+   * @returns True if the entry is valid, false otherwise.
+   */
+  isValid() {
+    return this.native !== void 0 && this.native !== null;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Zip;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/io/zip.ts"],
  "sourcesContent": ["/**\r\n * Provides a fa\u00E7ade for handling ZIP archive operations, including\r\n * file compression, decompression, and stream-based entry processing.\r\n */\r\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\r\nimport { InputStream, OutputStream } from \"@aerokit/sdk/io/streams\";\r\n\r\nconst ZipFacade = Java.type(\"org.eclipse.dirigible.components.api.io.ZipFacade\");\r\n\r\n/**\r\n * The Zip class provides static utility methods for managing ZIP archives\r\n * at both file path level and stream level.\r\n */\r\nexport class Zip {\r\n\r\n    /**\r\n     * Zips the content of a source directory or file into a target ZIP file.\r\n     *\r\n     * @param sourcePath The file system path to the content to be compressed.\r\n     * @param zipTargetPath The file system path where the resulting ZIP file should be saved.\r\n     */\r\n    public static zip(sourcePath: string, zipTargetPath: string): void {\r\n        ZipFacade.exportZip(sourcePath, zipTargetPath);\r\n    }\r\n\r\n    /**\r\n     * Unzips an existing ZIP file into a target directory.\r\n     *\r\n     * @param zipPath The file system path to the ZIP file to be extracted.\r\n     * @param targetPath The file system path to the directory where content should be extracted.\r\n     */\r\n    public static unzip(zipPath: string, targetPath: string): void {\r\n        ZipFacade.importZip(zipPath, targetPath);\r\n    }\r\n\r\n    /**\r\n     * Creates a {@link ZipInputStream} that reads ZIP archive data from a provided\r\n     * generic {@link InputStream}. This allows for reading ZIP entries without\r\n     * writing the archive to disk first.\r\n     *\r\n     * @param inputStream The source stream containing the raw ZIP data.\r\n     * @returns A new {@link ZipInputStream} instance.\r\n     */\r\n    public static createZipInputStream(inputStream: InputStream): ZipInputStream {\r\n        const native = ZipFacade.createZipInputStream(inputStream.native);\r\n        return new ZipInputStream(native);\r\n    }\r\n\r\n    /**\r\n     * Creates a {@link ZipOutputStream} that writes compressed ZIP archive data\r\n     * to a provided generic {@link OutputStream}. This allows for creating ZIP archives\r\n     * in memory or streaming them directly.\r\n     *\r\n     * @param outputStream The destination stream where the raw ZIP data will be written.\r\n     * @returns A new {@link ZipOutputStream} instance.\r\n     */\r\n    public static createZipOutputStream(outputStream: OutputStream): ZipOutputStream {\r\n        const native = ZipFacade.createZipOutputStream(outputStream.native);\r\n        return new ZipOutputStream(native);\r\n    }\r\n}\r\n\r\n/**\r\n * Represents an input stream for reading data from a ZIP archive.\r\n * Data is accessed sequentially by iterating through {@link ZipEntry} objects.\r\n */\r\nexport class ZipInputStream {\r\n\r\n    private readonly native: any;\r\n\r\n    /**\r\n     * @param native The underlying native ZipInputStream object.\r\n     */\r\n    constructor(native: any) {\r\n        this.native = native;\r\n    }\r\n\r\n    /**\r\n     * Reads the next ZIP file entry and positions the stream at the beginning of the entry data.\r\n     * Must be called before reading data for an entry.\r\n     *\r\n     * @returns The next {@link ZipEntry} object, or null if there are no more entries.\r\n     */\r\n    public getNextEntry(): ZipEntry {\r\n        const native = this.native.getNextEntry();\r\n        // If native is null (end of stream), the ZipEntry constructor will handle the null check or throw/return invalid.\r\n        return new ZipEntry(native);\r\n    }\r\n\r\n    /**\r\n     * Reads the data for the current entry and returns it as a JavaScript byte array.\r\n     *\r\n     * @returns A JavaScript array (`number[]`) of the byte values for the current entry.\r\n     */\r\n    public read(): any[] {\r\n        const native = ZipFacade.readNative(this.native);\r\n        return Bytes.toJavaScriptBytes(native);\r\n    }\r\n\r\n    /**\r\n     * Reads the data for the current entry and returns the native Java byte array.\r\n     *\r\n     * @returns The native Java byte array object.\r\n     */\r\n    public readNative(): any[] {\r\n        return ZipFacade.readNative(this.native);\r\n    }\r\n\r\n    /**\r\n     * Reads the data for the current entry and converts it to a string\r\n     * using the platform's default character encoding.\r\n     *\r\n     * @returns The content of the current entry as a string.\r\n     */\r\n    public readText(): string {\r\n        return ZipFacade.readText(this.native);\r\n    }\r\n\r\n    /**\r\n     * Closes the underlying native ZipInputStream.\r\n     */\r\n    public close(): void {\r\n        this.native.close();\r\n    }\r\n\r\n}\r\n\r\n/**\r\n * Represents an output stream for writing data to a ZIP archive.\r\n * Entries must be explicitly created and closed.\r\n */\r\nexport class ZipOutputStream {\r\n\r\n    private readonly native: any;\r\n\r\n    /**\r\n     * @param native The underlying native ZipOutputStream object.\r\n     */\r\n    constructor(native: any) {\r\n        this.native = native;\r\n    }\r\n\r\n    /**\r\n     * Creates a new {@link ZipEntry} with the given name, and begins writing the\r\n     * entry's header to the archive stream. All subsequent write operations\r\n     * will apply to this entry until {@link closeEntry} is called.\r\n     *\r\n     * @param name The file or directory name to use inside the ZIP archive.\r\n     * @returns The newly created {@link ZipEntry} object.\r\n     */\r\n    public createZipEntry(name: string): ZipEntry {\r\n        const nativeNext = ZipFacade.createZipEntry(name);\r\n        const zipEntry = new ZipEntry(nativeNext);\r\n        this.native.putNextEntry(nativeNext);\r\n        return zipEntry;\r\n    }\r\n\r\n    /**\r\n     * Writes the data from a JavaScript byte array to the current active entry in the stream.\r\n     *\r\n     * @param data The JavaScript array (`number[]`) of byte values to write.\r\n     */\r\n    public write(data: any[]): void {\r\n        const native = Bytes.toJavaBytes(data);\r\n        ZipFacade.writeNative(this.native, native);\r\n    }\r\n\r\n    /**\r\n     * Writes the data from a native Java byte array to the current active entry in the stream.\r\n     *\r\n     * @param data The native Java byte array object to write.\r\n     */\r\n    public writeNative(data: any[]): void {\r\n        ZipFacade.writeNative(this.native, data);\r\n    }\r\n\r\n    /**\r\n     * Converts the string to bytes and writes it to the current active entry in the stream.\r\n     *\r\n     * @param text The string content to write.\r\n     */\r\n    public writeText(text: string): void {\r\n        ZipFacade.writeText(this.native, text);\r\n    }\r\n\r\n    /**\r\n     * Closes the current active ZIP entry and positions the stream for the next entry.\r\n     */\r\n    public closeEntry(): void {\r\n        this.native.closeEntry();\r\n    }\r\n\r\n    /**\r\n     * Finalizes the writing of the ZIP file, flushes the stream, and closes the native object.\r\n     * This must be called after all entries have been written.\r\n     */\r\n    public close(): void {\r\n        this.native.finish();\r\n        this.native.flush();\r\n        this.native.close();\r\n    }\r\n}\r\n\r\n/**\r\n * Represents an entry (file or directory) within a ZIP archive.\r\n * It holds metadata about the archived item.\r\n */\r\nexport class ZipEntry {\r\n\r\n    private readonly native: any;\r\n\r\n    /**\r\n     * @param native The underlying native ZipEntry object.\r\n     */\r\n    constructor(native: any) {\r\n        this.native = native;\r\n    }\r\n\r\n    /**\r\n     * Gets the name of the entry (path relative to the ZIP root).\r\n     * @returns The name of the entry.\r\n     */\r\n    public getName(): string {\r\n        return this.native.getName();\r\n    }\r\n\r\n    /**\r\n     * Gets the uncompressed size of the entry data.\r\n     * @returns The size in bytes.\r\n     */\r\n    public getSize(): number {\r\n        return this.native.getSize();\r\n    }\r\n\r\n    /**\r\n     * Gets the compressed size of the entry data.\r\n     * @returns The compressed size in bytes.\r\n     */\r\n    public getCompressedSize(): number {\r\n        return this.native.getCompressedSize();\r\n    }\r\n\r\n    /**\r\n     * Gets the modification time of the entry.\r\n     * @returns The time as a numerical timestamp.\r\n     */\r\n    public getTime(): number {\r\n        return this.native.getTime();\r\n    }\r\n\r\n    /**\r\n     * Gets the CRC-32 checksum of the uncompressed entry data.\r\n     * @returns The CRC value.\r\n     */\r\n    public getCrc(): number {\r\n        return this.native.getCrc();\r\n    }\r\n\r\n    /**\r\n     * Gets the optional comment for the entry.\r\n     * @returns The comment string.\r\n     */\r\n    public getComment(): string {\r\n        return this.native.getComment();\r\n    }\r\n\r\n    /**\r\n     * Checks if the entry represents a directory.\r\n     * @returns True if it is a directory, false otherwise.\r\n     */\r\n    public isDirectory(): boolean {\r\n        return this.native.isDirectory();\r\n    }\r\n\r\n    /**\r\n     * Checks if the underlying native ZipEntry object is defined and non-null.\r\n     * @returns True if the entry is valid, false otherwise.\r\n     */\r\n    public isValid(): boolean {\r\n        return this.native !== undefined && this.native !== null;\r\n    }\r\n}\r\n\r\n// @ts-ignore\r\nif (typeof module !== 'undefined') {\r\n\t// @ts-ignore\r\n\tmodule.exports = Zip;\r\n}\r\n"],
  "mappings": "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",
  "names": []
}


package/dist/cjs/job/decorators.js

@@ -0,0 +1,40 @@
+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 decorators_exports = {};
+__export(decorators_exports, {
+  Scheduled: () => Scheduled
+});
+module.exports = __toCommonJS(decorators_exports);
+const SCHEDULED_METADATA_KEY = Symbol("scheduled:metadata");
+function Scheduled(options) {
+  return function(target, context) {
+    if (context.kind !== "class") {
+      throw new Error(`@Scheduled can only be used on classes.`);
+    }
+    Object.defineProperty(target, SCHEDULED_METADATA_KEY, {
+      value: {
+        expression: options.expression,
+        group: options.group
+      },
+      writable: false,
+      configurable: false,
+      enumerable: true
+    });
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/job/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var job_exports = {};
+__export(job_exports, {
+  decorators: () => decorators,
+  scheduler: () => import_scheduler.Scheduler
+});
+module.exports = __toCommonJS(job_exports);
+var import_scheduler = require("./scheduler");
+__reExport(job_exports, require("./scheduler"), module.exports);
+var decorators = __toESM(require("./decorators"));
+__reExport(job_exports, require("./decorators"), module.exports);
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2pvYi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0IHsgU2NoZWR1bGVyIGFzIHNjaGVkdWxlciB9IGZyb20gXCIuL3NjaGVkdWxlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2NoZWR1bGVyXCI7XG5leHBvcnQgKiBhcyBkZWNvcmF0b3JzIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjsiXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsdUJBQXVDO0FBQ3ZDLHdCQUFjLHdCQURkO0FBRUEsaUJBQTRCO0FBQzVCLHdCQUFjLHlCQUhkOyIsCiAgIm5hbWVzIjogW10KfQo=