@aerokit/sdk 12.44.0

package/dist/esm/io/files.mjs

@@ -0,0 +1,325 @@
+import { InputStream, OutputStream } from "@aerokit/sdk/io/streams";
+import { Bytes } from "@aerokit/sdk/io/bytes";
+const FilesFacade = Java.type("org.eclipse.dirigible.components.api.io.FilesFacade");
+const File = Java.type("java.io.File");
+class Files {
+  static {
+    /**
+     * The file system-dependent name separator character (e.g., "/" on Unix, "\" on Windows).
+     */
+    this.separator = File.separator;
+  }
+  /**
+  * Checks if a file or directory exists at the given path.
+  * @param path The path to check.
+  * @returns True if the path exists, false otherwise.
+  */
+  static exists(path) {
+    return FilesFacade.exists(path);
+  }
+  /**
+   * Checks if the file or directory at the given path is executable.
+   * @param path The path to check.
+   * @returns True if executable, false otherwise.
+   */
+  static isExecutable(path) {
+    return FilesFacade.isExecutable(path);
+  }
+  /**
+   * Checks if the file or directory at the given path is readable.
+   * @param path The path to check.
+   * @returns True if readable, false otherwise.
+   */
+  static isReadable(path) {
+    return FilesFacade.isReadable(path);
+  }
+  /**
+   * Checks if the file or directory at the given path is writable.
+   * @param path The path to check.
+   * @returns True if writable, false otherwise.
+   */
+  static isWritable(path) {
+    return FilesFacade.isWritable(path);
+  }
+  /**
+   * Checks if the file or directory at the given path is hidden.
+   * @param path The path to check.
+   * @returns True if hidden, false otherwise.
+   */
+  static isHidden(path) {
+    return FilesFacade.isHidden(path);
+  }
+  /**
+   * Checks if the path refers to a directory.
+   * @param path The path to check.
+   * @returns True if it's a directory, false otherwise.
+   */
+  static isDirectory(path) {
+    return FilesFacade.isDirectory(path);
+  }
+  /**
+   * Checks if the path refers to a regular file.
+   * @param path The path to check.
+   * @returns True if it's a file, false otherwise.
+   */
+  static isFile(path) {
+    return FilesFacade.isFile(path);
+  }
+  /**
+   * Checks if two paths refer to the same underlying file system object.
+   * @param path1 The first path.
+   * @param path2 The second path.
+   * @returns True if they reference the same file/directory, false otherwise.
+   */
+  static isSameFile(path1, path2) {
+    return FilesFacade.isSameFile(path1, path2);
+  }
+  /**
+   * Returns the canonical (absolute and normalized) path for the given path.
+   * @param path The path to normalize.
+   * @returns The canonical path string.
+   */
+  static getCanonicalPath(path) {
+    return FilesFacade.getCanonicalPath(path);
+  }
+  /**
+   * Gets the simple name of the file or directory at the given path (the last element).
+   * @param path The path.
+   * @returns The name.
+   */
+  static getName(path) {
+    return FilesFacade.getName(path);
+  }
+  /**
+   * Gets the path of the parent directory.
+   * @param path The path.
+   * @returns The parent path string, or null/empty if none exists.
+   */
+  static getParentPath(path) {
+    return FilesFacade.getParentPath(path);
+  }
+  /**
+   * Reads all bytes from a file into a JavaScript byte array (an array of numbers).
+   *
+   * Note: This method automatically converts the native Java byte array to a
+   * JavaScript array using `Bytes.toJavaScriptBytes()`.
+   * @param path The path to the file.
+   * @returns A JavaScript array of byte values.
+   */
+  static readBytes(path) {
+    const native = FilesFacade.readBytes(path);
+    return Bytes.toJavaScriptBytes(native);
+  }
+  /**
+   * Reads all bytes from a file and returns the native Java byte array object.
+   * @param path The path to the file.
+   * @returns The native Java byte array.
+   */
+  static readBytesNative(path) {
+    return FilesFacade.readBytes(path);
+  }
+  /**
+   * Reads all text content from a file using the platform's default character encoding.
+   * @param path The path to the file.
+   * @returns The content of the file as a string.
+   */
+  static readText(path) {
+    return FilesFacade.readText(path);
+  }
+  /**
+   * Writes the content of a JavaScript byte array to a file. Overwrites existing content.
+   *
+   * Note: This method automatically converts the JavaScript array to a native
+   * Java byte array using `Bytes.toJavaBytes()` before writing.
+   * @param path The path to the file.
+   * @param data The JavaScript array of byte values to write.
+   */
+  static writeBytes(path, data) {
+    const native = Bytes.toJavaBytes(data);
+    FilesFacade.writeBytesNative(path, native);
+  }
+  /**
+   * Writes the content of a native Java byte array to a file. Overwrites existing content.
+   * @param path The path to the file.
+   * @param data The native Java byte array to write.
+   */
+  static writeBytesNative(path, data) {
+    FilesFacade.writeBytesNative(path, data);
+  }
+  /**
+   * Writes a string of text to a file using the platform's default character encoding. Overwrites existing content.
+   * @param path The path to the file.
+   * @param text The string content to write.
+   */
+  static writeText(path, text) {
+    FilesFacade.writeText(path, text);
+  }
+  /**
+   * Gets the last modified time of the file or directory.
+   * @param path The path to the file or directory.
+   * @returns A JavaScript Date object representing the last modified time.
+   */
+  static getLastModified(path) {
+    return new Date(FilesFacade.getLastModified(path));
+  }
+  /**
+   * Sets the last modified time of the file or directory.
+   * @param path The path to the file or directory.
+   * @param time The new Date object to set as the last modified time.
+   */
+  static setLastModified(path, time) {
+    FilesFacade.setLastModified(path, time.getTime());
+  }
+  /**
+   * Gets the owner of the file or directory.
+   * @param path The path to the file or directory.
+   * @returns The owner name as a string.
+   */
+  static getOwner(path) {
+    return FilesFacade.getOwner(path);
+  }
+  /**
+   * Sets the owner of the file or directory.
+   * @param path The path to the file or directory.
+   * @param owner The new owner name.
+   */
+  static setOwner(path, owner) {
+    FilesFacade.setOwner(path, owner);
+  }
+  /**
+   * Gets the permissions string for the file or directory (implementation dependent).
+   * @param path The path to the file or directory.
+   * @returns The permissions string.
+   */
+  static getPermissions(path) {
+    return FilesFacade.getPermissions(path);
+  }
+  /**
+   * Sets the permissions for the file or directory (implementation dependent).
+   * @param path The path to the file or directory.
+   * @param permissions The permissions string.
+   */
+  static setPermissions(path, permissions) {
+    FilesFacade.setPermissions(path, permissions);
+  }
+  /**
+   * Gets the size of the file in bytes.
+   * @param path The path to the file.
+   * @returns The size in bytes.
+   */
+  static size(path) {
+    return FilesFacade.size(path);
+  }
+  /**
+   * Creates a new, empty file at the specified path.
+   * @param path The path where the file should be created.
+   */
+  static createFile(path) {
+    FilesFacade.createFile(path);
+  }
+  /**
+   * Creates a new directory at the specified path.
+   * @param path The path where the directory should be created.
+   */
+  static createDirectory(path) {
+    FilesFacade.createDirectory(path);
+  }
+  /**
+   * Copies a file or directory from a source path to a target path.
+   * @param source The source path.
+   * @param target The target path.
+   */
+  static copy(source, target) {
+    FilesFacade.copy(source, target);
+  }
+  /**
+   * Moves or renames a file or directory.
+   * @param source The source path.
+   * @param target The target path.
+   */
+  static move(source, target) {
+    FilesFacade.move(source, target);
+  }
+  /**
+   * Deletes the file at the specified path.
+   * @param path The path to the file to delete.
+   */
+  static deleteFile(path) {
+    FilesFacade.deleteFile(path);
+  }
+  /**
+   * Deletes the directory at the specified path.
+   * @param path The path to the directory to delete.
+   * @param forced If true, recursively deletes the directory and its contents.
+   */
+  static deleteDirectory(path, forced) {
+    FilesFacade.deleteDirectory(path, forced);
+  }
+  /**
+   * Creates a new temporary file with the given prefix and suffix.
+   * @param prefix The prefix string to be used in generating the file's name.
+   * @param suffix The suffix string to be used in generating the file's name.
+   * @returns The path of the created temporary file.
+   */
+  static createTempFile(prefix, suffix) {
+    return FilesFacade.createTempFile(prefix, suffix);
+  }
+  /**
+   * Creates a new temporary directory with the given prefix.
+   * @param prefix The prefix string to be used in generating the directory's name.
+   * @returns The path of the created temporary directory.
+   */
+  static createTempDirectory(prefix) {
+    return FilesFacade.createTempDirectory(prefix);
+  }
+  /**
+   * Creates and returns a new {@link InputStream} for reading data from the file.
+   * @param path The path to the file.
+   * @returns A new InputStream instance.
+   */
+  static createInputStream(path) {
+    const native = FilesFacade.createInputStream(path);
+    return new InputStream(native);
+  }
+  /**
+   * Creates and returns a new {@link OutputStream} for writing data to the file.
+   * @param path The path to the file.
+   * @returns A new OutputStream instance.
+   */
+  static createOutputStream(path) {
+    const native = FilesFacade.createOutputStream(path);
+    return new OutputStream(native);
+  }
+  /**
+   * Traverses a directory and returns a structured {@link FolderObject} hierarchy.
+   * @param path The path to the folder to traverse.
+   * @returns The root FolderObject containing the file system tree structure.
+   */
+  static traverse(path) {
+    return JSON.parse(FilesFacade.traverse(path));
+  }
+  /**
+   * Lists the direct children (files and folders) of a directory, returning only their paths.
+   * @param path The path to the directory.
+   * @returns An array of string paths for the contents of the directory.
+   */
+  static list(path) {
+    return JSON.parse(FilesFacade.list(path)).map((e) => e.path);
+  }
+  /**
+   * Finds files and directories matching a specified glob pattern within a directory tree.
+   * @param path The starting path for the search.
+   * @param pattern The glob pattern to match (e.g., "*.js", "**.txt").
+   * @returns An array of string paths that match the pattern.
+   */
+  static find(path, pattern) {
+    return JSON.parse(FilesFacade.find(path, pattern));
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Files;
+}
+export {
+  Files
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/io/files.ts"],
  "sourcesContent": ["/**\n * Provides a comprehensive static fa\u00E7ade for file and directory operations,\n * abstracting the underlying Java file system implementation.\n */\nimport { InputStream, OutputStream } from \"@aerokit/sdk/io/streams\";\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\n\nconst FilesFacade = Java.type(\"org.eclipse.dirigible.components.api.io.FilesFacade\");\nconst File = Java.type(\"java.io.File\")\n\n/**\n * Represents a generic file system object (file or directory).\n */\nexport interface FileObject {\n    /** The simple name of the file or folder. */\n    name: string;\n    /** The absolute path of the file or folder. */\n    path: string;\n}\n\n/**\n * Represents a folder object, extending the basic file object with lists of its contents.\n */\nexport interface FolderObject extends FileObject {\n    /** A list of file objects contained within this folder. */\n    files: FileObject[];\n    /** A list of sub-folder objects contained within this folder. */\n    folders: FolderObject[];\n}\n\n/**\n * The Files class provides static methods for high-level file system manipulation,\n * including checking properties, reading/writing content, and navigating the structure.\n */\nexport class Files {\n\n\t/**\n\t * The file system-dependent name separator character (e.g., \"/\" on Unix, \"\\\" on Windows).\n\t */\n\tpublic static readonly separator: string = File.separator;\n\n    /**\n\t * Checks if a file or directory exists at the given path.\n\t * @param path The path to check.\n\t * @returns True if the path exists, false otherwise.\n\t */\n\tpublic static exists(path: string): boolean {\n\t\treturn FilesFacade.exists(path);\n\t}\n\n\t/**\n\t * Checks if the file or directory at the given path is executable.\n\t * @param path The path to check.\n\t * @returns True if executable, false otherwise.\n\t */\n\tpublic static isExecutable(path: string): boolean {\n\t\treturn FilesFacade.isExecutable(path);\n\t}\n\n\t/**\n\t * Checks if the file or directory at the given path is readable.\n\t * @param path The path to check.\n\t * @returns True if readable, false otherwise.\n\t */\n\tpublic static isReadable(path: string): boolean {\n\t\treturn FilesFacade.isReadable(path);\n\t}\n\n\t/**\n\t * Checks if the file or directory at the given path is writable.\n\t * @param path The path to check.\n\t * @returns True if writable, false otherwise.\n\t */\n\tpublic static isWritable(path: string): boolean {\n\t\treturn FilesFacade.isWritable(path);\n\t}\n\n\t/**\n\t * Checks if the file or directory at the given path is hidden.\n\t * @param path The path to check.\n\t * @returns True if hidden, false otherwise.\n\t */\n\tpublic static isHidden(path: string): boolean {\n\t\treturn FilesFacade.isHidden(path);\n\t}\n\n\t/**\n\t * Checks if the path refers to a directory.\n\t * @param path The path to check.\n\t * @returns True if it's a directory, false otherwise.\n\t */\n\tpublic static isDirectory(path: string): boolean {\n\t\treturn FilesFacade.isDirectory(path);\n\t}\n\n\t/**\n\t * Checks if the path refers to a regular file.\n\t * @param path The path to check.\n\t * @returns True if it's a file, false otherwise.\n\t */\n\tpublic static isFile(path: string): boolean {\n\t\treturn FilesFacade.isFile(path);\n\t}\n\n\t/**\n\t * Checks if two paths refer to the same underlying file system object.\n\t * @param path1 The first path.\n\t * @param path2 The second path.\n\t * @returns True if they reference the same file/directory, false otherwise.\n\t */\n\tpublic static isSameFile(path1: string, path2: string): boolean {\n\t\treturn FilesFacade.isSameFile(path1, path2);\n\t}\n\n\t/**\n\t * Returns the canonical (absolute and normalized) path for the given path.\n\t * @param path The path to normalize.\n\t * @returns The canonical path string.\n\t */\n\tpublic static getCanonicalPath(path: string): string {\n\t\treturn FilesFacade.getCanonicalPath(path);\n\t}\n\n\t/**\n\t * Gets the simple name of the file or directory at the given path (the last element).\n\t * @param path The path.\n\t * @returns The name.\n\t */\n\tpublic static getName(path: string): string {\n\t\treturn FilesFacade.getName(path);\n\t}\n\n\t/**\n\t * Gets the path of the parent directory.\n\t * @param path The path.\n\t * @returns The parent path string, or null/empty if none exists.\n\t */\n\tpublic static getParentPath(path: string): string {\n\t\treturn FilesFacade.getParentPath(path);\n\t}\n\n\t/**\n\t * Reads all bytes from a file into a JavaScript byte array (an array of numbers).\n\t *\n\t * Note: This method automatically converts the native Java byte array to a\n\t * JavaScript array using `Bytes.toJavaScriptBytes()`.\n\t * @param path The path to the file.\n\t * @returns A JavaScript array of byte values.\n\t */\n\tpublic static readBytes(path: string): any[] {\n\t\tconst native = FilesFacade.readBytes(path);\n\t\treturn Bytes.toJavaScriptBytes(native);\n\t}\n\n\t/**\n\t * Reads all bytes from a file and returns the native Java byte array object.\n\t * @param path The path to the file.\n\t * @returns The native Java byte array.\n\t */\n\tpublic static readBytesNative(path: string): any[] {\n\t\treturn FilesFacade.readBytes(path);\n\t}\n\n\t/**\n\t * Reads all text content from a file using the platform's default character encoding.\n\t * @param path The path to the file.\n\t * @returns The content of the file as a string.\n\t */\n\tpublic static readText(path: string): string {\n\t\treturn FilesFacade.readText(path);\n\t}\n\n\t/**\n\t * Writes the content of a JavaScript byte array to a file. Overwrites existing content.\n\t *\n\t * Note: This method automatically converts the JavaScript array to a native\n\t * Java byte array using `Bytes.toJavaBytes()` before writing.\n\t * @param path The path to the file.\n\t * @param data The JavaScript array of byte values to write.\n\t */\n\tpublic static writeBytes(path: string, data: any[]): void {\n\t\tconst native = Bytes.toJavaBytes(data);\n\t\tFilesFacade.writeBytesNative(path, native);\n\t}\n\n\t/**\n\t * Writes the content of a native Java byte array to a file. Overwrites existing content.\n\t * @param path The path to the file.\n\t * @param data The native Java byte array to write.\n\t */\n\tpublic static writeBytesNative(path: string, data: any[]): void {\n\t\tFilesFacade.writeBytesNative(path, data);\n\t}\n\n\t/**\n\t * Writes a string of text to a file using the platform's default character encoding. Overwrites existing content.\n\t * @param path The path to the file.\n\t * @param text The string content to write.\n\t */\n\tpublic static writeText(path: string, text: string): void {\n\t\tFilesFacade.writeText(path, text);\n\t}\n\n\t/**\n\t * Gets the last modified time of the file or directory.\n\t * @param path The path to the file or directory.\n\t * @returns A JavaScript Date object representing the last modified time.\n\t */\n\tpublic static getLastModified(path: string): Date {\n\t\treturn new Date(FilesFacade.getLastModified(path));\n\t}\n\n\t/**\n\t * Sets the last modified time of the file or directory.\n\t * @param path The path to the file or directory.\n\t * @param time The new Date object to set as the last modified time.\n\t */\n\tpublic static setLastModified(path: string, time: Date): void {\n\t\tFilesFacade.setLastModified(path, time.getTime());\n\t}\n\n\t/**\n\t * Gets the owner of the file or directory.\n\t * @param path The path to the file or directory.\n\t * @returns The owner name as a string.\n\t */\n\tpublic static getOwner(path: string): string {\n\t\treturn FilesFacade.getOwner(path);\n\t}\n\n\t/**\n\t * Sets the owner of the file or directory.\n\t * @param path The path to the file or directory.\n\t * @param owner The new owner name.\n\t */\n\tpublic static setOwner(path: string, owner: string): void {\n\t\tFilesFacade.setOwner(path, owner);\n\t}\n\n\t/**\n\t * Gets the permissions string for the file or directory (implementation dependent).\n\t * @param path The path to the file or directory.\n\t * @returns The permissions string.\n\t */\n\tpublic static getPermissions(path: string): string {\n\t\treturn FilesFacade.getPermissions(path);\n\t}\n\n\t/**\n\t * Sets the permissions for the file or directory (implementation dependent).\n\t * @param path The path to the file or directory.\n\t * @param permissions The permissions string.\n\t */\n\tpublic static setPermissions(path: string, permissions: string): void {\n\t\tFilesFacade.setPermissions(path, permissions);\n\t}\n\n\t/**\n\t * Gets the size of the file in bytes.\n\t * @param path The path to the file.\n\t * @returns The size in bytes.\n\t */\n\tpublic static size(path: string): number {\n\t\treturn FilesFacade.size(path);\n\t}\n\n\t/**\n\t * Creates a new, empty file at the specified path.\n\t * @param path The path where the file should be created.\n\t */\n\tpublic static createFile(path: string): void {\n\t\tFilesFacade.createFile(path);\n\t}\n\n\t/**\n\t * Creates a new directory at the specified path.\n\t * @param path The path where the directory should be created.\n\t */\n\tpublic static createDirectory(path: string): void {\n\t\tFilesFacade.createDirectory(path);\n\t}\n\n\t/**\n\t * Copies a file or directory from a source path to a target path.\n\t * @param source The source path.\n\t * @param target The target path.\n\t */\n\tpublic static copy(source: string, target: string): void {\n\t\tFilesFacade.copy(source, target);\n\t}\n\n\t/**\n\t * Moves or renames a file or directory.\n\t * @param source The source path.\n\t * @param target The target path.\n\t */\n\tpublic static move(source: string, target: string): void {\n\t\tFilesFacade.move(source, target);\n\t}\n\n\t/**\n\t * Deletes the file at the specified path.\n\t * @param path The path to the file to delete.\n\t */\n\tpublic static deleteFile(path: string): void {\n\t\tFilesFacade.deleteFile(path);\n\t}\n\n\t/**\n\t * Deletes the directory at the specified path.\n\t * @param path The path to the directory to delete.\n\t * @param forced If true, recursively deletes the directory and its contents.\n\t */\n\tpublic static deleteDirectory(path: string, forced?: boolean): void {\n\t\tFilesFacade.deleteDirectory(path, forced);\n\t}\n\n\t/**\n\t * Creates a new temporary file with the given prefix and suffix.\n\t * @param prefix The prefix string to be used in generating the file's name.\n\t * @param suffix The suffix string to be used in generating the file's name.\n\t * @returns The path of the created temporary file.\n\t */\n\tpublic static createTempFile(prefix: string, suffix: string): string {\n\t\treturn FilesFacade.createTempFile(prefix, suffix);\n\t}\n\n\t/**\n\t * Creates a new temporary directory with the given prefix.\n\t * @param prefix The prefix string to be used in generating the directory's name.\n\t * @returns The path of the created temporary directory.\n\t */\n\tpublic static createTempDirectory(prefix: string): string {\n\t\treturn FilesFacade.createTempDirectory(prefix);\n\t}\n\n\t/**\n\t * Creates and returns a new {@link InputStream} for reading data from the file.\n\t * @param path The path to the file.\n\t * @returns A new InputStream instance.\n\t */\n\tpublic static createInputStream(path: string): InputStream {\n\t\tconst native = FilesFacade.createInputStream(path);\n\t\treturn new InputStream(native);\n\t}\n\n\t/**\n\t * Creates and returns a new {@link OutputStream} for writing data to the file.\n\t * @param path The path to the file.\n\t * @returns A new OutputStream instance.\n\t */\n\tpublic static createOutputStream(path: string): OutputStream {\n\t\tconst native = FilesFacade.createOutputStream(path);\n\t\treturn new OutputStream(native);\n\t}\n\n\t/**\n\t * Traverses a directory and returns a structured {@link FolderObject} hierarchy.\n\t * @param path The path to the folder to traverse.\n\t * @returns The root FolderObject containing the file system tree structure.\n\t */\n\tpublic static traverse(path: string): FolderObject[] {\n\t\treturn JSON.parse(FilesFacade.traverse(path));\n\t}\n\n\t/**\n\t * Lists the direct children (files and folders) of a directory, returning only their paths.\n\t * @param path The path to the directory.\n\t * @returns An array of string paths for the contents of the directory.\n\t */\n\tpublic static list(path: string): string[] {\n\t\t// The native facade returns a JSON array of objects, which is then mapped to an array of paths.\n\t\treturn JSON.parse(FilesFacade.list(path)).map(e => e.path);\n\t}\n\n\t/**\n\t * Finds files and directories matching a specified glob pattern within a directory tree.\n\t * @param path The starting path for the search.\n\t * @param pattern The glob pattern to match (e.g., \"*.js\", \"**.txt\").\n\t * @returns An array of string paths that match the pattern.\n\t */\n\tpublic static find(path: string, pattern: string): string[] {\n\t\treturn JSON.parse(FilesFacade.find(path, pattern));\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Files;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/io/image.mjs

@@ -0,0 +1,24 @@
+import { InputStream } from "@aerokit/sdk/io/streams";
+const ImageFacade = Java.type("org.eclipse.dirigible.components.api.io.ImageFacade");
+class Image {
+  /**
+   * Resizes an image contained within an InputStream to the specified dimensions.
+   *
+   * @param original The InputStream containing the original image data.
+   * @param type The target format of the resized image (e.g., "png", "jpeg", "gif").
+   * @param width The target width in pixels.
+   * @param height The target height in pixels.
+   * @returns A new InputStream containing the resized image data in the specified format.
+   */
+  static resize(original, type, width, height) {
+    const native = ImageFacade.resize(original.native, type, width, height);
+    return new InputStream(native);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Image;
+}
+export {
+  Image
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/io/index.mjs

@@ -0,0 +1,18 @@
+export * from "./bytes";
+import { Bytes } from "./bytes";
+export * from "./files";
+import { Files } from "./files";
+export * from "./image";
+import { Image } from "./image";
+export * from "./streams";
+import { Streams } from "./streams";
+export * from "./zip";
+import { Zip } from "./zip";
+export {
+  Bytes as bytes,
+  Files as files,
+  Image as image,
+  Streams as streams,
+  Zip as zip
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2lvL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi9ieXRlc1wiO1xuZXhwb3J0IHsgQnl0ZXMgYXMgYnl0ZXMgfSBmcm9tIFwiLi9ieXRlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZmlsZXNcIjtcbmV4cG9ydCB7IEZpbGVzIGFzIGZpbGVzIH0gZnJvbSBcIi4vZmlsZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ltYWdlXCI7XG5leHBvcnQgeyBJbWFnZSBhcyBpbWFnZSB9IGZyb20gXCIuL2ltYWdlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdHJlYW1zXCI7XG5leHBvcnQgeyBTdHJlYW1zIGFzIHN0cmVhbXMgfSBmcm9tIFwiLi9zdHJlYW1zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi96aXBcIjtcbmV4cG9ydCB7IFppcCBhcyB6aXAgfSBmcm9tIFwiLi96aXBcIjtcbiJdLAogICJtYXBwaW5ncyI6ICJBQUFBLGNBQWM7QUFDZCxTQUFrQixhQUFhO0FBQy9CLGNBQWM7QUFDZCxTQUFrQixhQUFhO0FBQy9CLGNBQWM7QUFDZCxTQUFrQixhQUFhO0FBQy9CLGNBQWM7QUFDZCxTQUFvQixlQUFlO0FBQ25DLGNBQWM7QUFDZCxTQUFnQixXQUFXOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/io/streams.mjs

@@ -0,0 +1,224 @@
+import { Bytes } from "@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 = 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 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 = 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 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;
+}
+export {
+  InputStream,
+  OutputStream,
+  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": "AAIA,SAAS,aAAa;AAEtB,MAAM,gBAAgB,KAAK,KAAK,uDAAuD;AAMhF,MAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASpB,OAAc,KAAK,OAAoB,QAA4B;AAClE,kBAAc,KAAK,MAAM,QAAQ,OAAO,MAAM;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,UAAU,OAAoB,QAA4B;AACvE,kBAAc,UAAU,MAAM,QAAQ,OAAO,MAAM;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,kCAAkC,MAA2B;AAC1E,UAAM,SAAS,cAAc,kCAAkC,IAAI;AACnE,WAAO,IAAI,YAAY,MAAM;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,2BAA2B,MAA0B;AAElE,UAAM,QAAQ,MAAM,YAAY,IAAI;AACpC,UAAM,SAAS,cAAc,2BAA2B,KAAK;AAC7D,WAAO,IAAI,YAAY,MAAM;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,8BAA4C;AACzD,UAAM,SAAS,cAAc,4BAA4B;AACzD,WAAO,IAAI,aAAa,MAAM;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,kBAAkB,QAA0B;AACzD,UAAM,cAAc,IAAI,YAAY,MAAM;AAC1C,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,mBAAmB,QAA2B;AACpD,UAAM,eAAe,IAAI,aAAa,MAAM;AAC5C,WAAO;AAAA,EACR;AACD;AAMO,MAAM,YAAY;AAAA;AAAA;AAAA;AAAA,EAQxB,YAAY,QAAa;AACxB,SAAK,SAAS;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,OAAe;AACrB,WAAO,cAAc,KAAK,KAAK,MAAM;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,YAAmB;AACzB,UAAM,SAAS,cAAc,UAAU,KAAK,MAAM;AAClD,WAAO,MAAM,kBAAkB,MAAM;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,kBAAyB;AAC/B,WAAO,cAAc,UAAU,KAAK,MAAM;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,WAAmB;AACzB,WAAO,cAAc,SAAS,KAAK,MAAM;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKO,QAAc;AACpB,kBAAc,MAAM,KAAK,MAAM;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAmB;AACzB,WAAO,KAAK,WAAW,UAAa,KAAK,WAAW;AAAA,EACrD;AACD;AAMO,MAAM,aAAa;AAAA;AAAA;AAAA;AAAA,EAQzB,YAAY,QAAa;AACxB,SAAK,SAAS;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,MAAM,MAAoB;AAChC,kBAAc,MAAM,KAAK,QAAQ,IAAI;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,WAAW,MAAmB;AAEpC,UAAM,SAAS,MAAM,YAAY,IAAI;AACrC,kBAAc,WAAW,KAAK,QAAQ,MAAM;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,iBAAiB,MAAmB;AAC1C,kBAAc,WAAW,KAAK,QAAQ,IAAI;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,UAAU,MAAoB;AACpC,kBAAc,UAAU,KAAK,QAAQ,IAAI;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKO,QAAc;AACpB,kBAAc,MAAM,KAAK,MAAM;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,WAAkB;AACxB,UAAM,SAAS,cAAc,SAAS,KAAK,MAAM;AACjD,WAAO,MAAM,kBAAkB,MAAM;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,iBAAwB;AAC9B,WAAO,cAAc,SAAS,KAAK,MAAM;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,UAAkB;AACxB,WAAO,cAAc,QAAQ,KAAK,MAAM;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAmB;AACzB,WAAO,KAAK,WAAW,UAAa,KAAK,WAAW;AAAA,EACrD;AACD;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}
