@aerokit/sdk 12.44.0

package/dist/esm/platform/workspace.mjs

@@ -0,0 +1,555 @@
+import { Bytes } from "@aerokit/sdk/io/bytes";
+const WorkspaceFacade = Java.type("org.eclipse.dirigible.components.api.platform.WorkspaceFacade");
+class Workspace {
+  /**
+   * Creates a new workspace with the given name.
+   *
+   * @param {string} name The name of the workspace to create.
+   * @returns {Workspace} The newly created Workspace instance.
+   */
+  static createWorkspace(name) {
+    const native = WorkspaceFacade.createWorkspace(name);
+    return new Workspace(native);
+  }
+  /**
+   * Retrieves an existing workspace by name.
+   *
+   * @param {string} name The name of the workspace to retrieve.
+   * @returns {Workspace} The Workspace instance.
+   */
+  static getWorkspace(name) {
+    const native = WorkspaceFacade.getWorkspace(name);
+    return new Workspace(native);
+  }
+  /**
+   * Retrieves the names of all existing workspaces.
+   *
+   * @returns {string[]} An array of workspace names.
+   */
+  static getWorkspacesNames() {
+    const workspacesNames = WorkspaceFacade.getWorkspacesNames();
+    if (workspacesNames) {
+      return JSON.parse(workspacesNames);
+    }
+    return workspacesNames;
+  }
+  /**
+   * Deletes the workspace with the specified name.
+   *
+   * @param {string} name The name of the workspace to delete.
+   */
+  static deleteWorkspace(name) {
+    WorkspaceFacade.deleteWorkspace(name);
+  }
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the workspace.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets a collection of all projects within this workspace.
+   *
+   * @returns {Projects} A Projects collection instance.
+   */
+  getProjects() {
+    const native = this.native.getProjects();
+    return new Projects(native);
+  }
+  /**
+   * Creates a new project within this workspace.
+   *
+   * @param {string} name The name of the project to create.
+   * @returns {Project} The newly created Project instance.
+   */
+  createProject(name) {
+    const native = this.native.createProject(name);
+    return new Project(native);
+  }
+  /**
+   * Retrieves an existing project by name from this workspace.
+   *
+   * @param {string} name The name of the project to retrieve.
+   * @returns {Project} The Project instance.
+   */
+  getProject(name) {
+    const native = this.native.getProject(name);
+    return new Project(native);
+  }
+  /**
+   * Deletes a project from this workspace by name.
+   *
+   * @param {string} name The name of the project to delete.
+   */
+  deleteProject(name) {
+    this.native.deleteProject(name);
+  }
+  /**
+   * Checks if the workspace currently exists.
+   *
+   * @returns {boolean} True if the workspace exists, false otherwise.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if a specific folder path exists within the workspace's filesystem structure.
+   *
+   * @param {string} path The relative path to the folder.
+   * @returns {boolean} True if the folder exists.
+   */
+  existsFolder(path) {
+    return this.native.existsFolder(path);
+  }
+  /**
+   * Checks if a specific file path exists within the workspace's filesystem structure.
+   *
+   * @param {string} path The relative path to the file.
+   * @returns {boolean} True if the file exists.
+   */
+  existsFile(path) {
+    return this.native.existsFile(path);
+  }
+  /**
+   * Copies a project from a source name to a target name within the workspace.
+   *
+   * @param {string} source The name of the project to copy.
+   * @param {string} target The name of the new project copy.
+   */
+  copyProject(source, target) {
+    this.native.copyProject(source, target);
+  }
+  /**
+   * Moves a project from a source name to a target name (renaming it).
+   *
+   * @param {string} source The current name of the project.
+   * @param {string} target The new name/path of the project.
+   */
+  moveProject(source, target) {
+    this.native.moveProject(source, target);
+  }
+}
+class Projects {
+  /**
+   * @constructor
+   * @param {any} native The native Java object representing the list of projects.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the number of projects in the collection.
+   * @returns {number} The size of the collection.
+   */
+  size() {
+    return this.native.size();
+  }
+  /**
+   * Gets a Project instance at the specified index.
+   * @param {number} index The index of the project.
+   * @returns {Project} The Project instance.
+   */
+  get(index) {
+    const native = this.native.get(index);
+    return new Project(native);
+  }
+}
+class Project {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the project.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the project.
+   * @returns {string} The project name.
+   */
+  getName() {
+    const collection = this.native.getInternal();
+    return collection.getName();
+  }
+  /**
+   * Gets the path of the project.
+   * @returns {string} The project path (relative to the repository/workspace root).
+   */
+  getPath() {
+    const collection = this.native.getInternal();
+    return collection.getPath();
+  }
+  /**
+   * Creates a new folder within the project.
+   *
+   * @param {string} path The path of the folder to create (relative to the project root).
+   * @returns {Folder} The newly created Folder instance.
+   */
+  createFolder(path) {
+    const native = this.native.createFolder(path);
+    return new Folder(native);
+  }
+  /**
+   * Checks if the project itself exists.
+   * @returns {boolean} True if the project exists.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if a specific folder path exists within the project.
+   *
+   * @param {string} path The relative path to the folder.
+   * @returns {boolean} True if the folder exists.
+   */
+  existsFolder(path) {
+    return this.native.existsFolder(path);
+  }
+  /**
+   * Retrieves a folder by its path relative to the project root.
+   *
+   * @param {string} path The relative path to the folder.
+   * @returns {Folder} The Folder instance.
+   */
+  getFolder(path) {
+    const native = this.native.getFolder(path);
+    return new Folder(native);
+  }
+  /**
+   * Retrieves a collection of folders at a specific path.
+   *
+   * @param {string} path The path containing the folders to retrieve.
+   * @returns {Folders} The Folders collection instance.
+   */
+  getFolders(path) {
+    const native = this.native.getFolders(path);
+    return new Folders(native);
+  }
+  /**
+   * Deletes a folder from the project.
+   *
+   * @param {string} path The path of the folder to delete (relative to the project root).
+   */
+  deleteFolder(path) {
+    this.native.deleteFolder(path);
+  }
+  /**
+   * Creates a new file within the project.
+   *
+   * @param {string} path The path of the file to create (relative to the project root).
+   * @param {any[]} [input=[]] Optional initial content as a byte array.
+   * @returns {File} The newly created File instance.
+   */
+  createFile(path, input = []) {
+    const native = this.native.createFile(path, input);
+    return new File(native);
+  }
+  /**
+   * Checks if a specific file path exists within the project.
+   *
+   * @param {string} path The relative path to the file.
+   * @returns {boolean} True if the file exists.
+   */
+  existsFile(path) {
+    return this.native.existsFile(path);
+  }
+  /**
+   * Retrieves a file by its path relative to the project root.
+   *
+   * @param {string} path The relative path to the file.
+   * @returns {File} The File instance.
+   */
+  getFile(path) {
+    const native = this.native.getFile(path);
+    return new File(native);
+  }
+  /**
+   * Retrieves a collection of files at a specific path.
+   *
+   * @param {string} path The path containing the files to retrieve.
+   * @returns {Files} The Files collection instance.
+   */
+  getFiles(path) {
+    const native = this.native.getFiles(path);
+    return new Files(native);
+  }
+  /**
+   * Deletes a file from the project.
+   *
+   * @param {string} path The path of the file to delete (relative to the project root).
+   */
+  deleteFile(path) {
+    this.native.deleteFile(path);
+  }
+}
+class Folders {
+  /**
+   * @constructor
+   * @param {any} native The native Java object representing the list of folders.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the number of folders in the collection.
+   * @returns {number} The size of the collection.
+   */
+  size() {
+    return this.native.size();
+  }
+  /**
+   * Gets a Folder instance at the specified index.
+   * @param {number} index The index of the folder.
+   * @returns {Folder} The Folder instance.
+   */
+  get(index) {
+    const native = this.native.get(index);
+    return new Folder(native);
+  }
+}
+class Files {
+  /**
+   * @constructor
+   * @param {any} native The native Java object representing the list of files.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the number of files in the collection.
+   * @returns {number} The size of the collection.
+   */
+  size() {
+    return this.native.size();
+  }
+  /**
+   * Gets a File instance at the specified index.
+   * @param {number} index The index of the file.
+   * @returns {File} The File instance.
+   */
+  get(index) {
+    const native = this.native.get(index);
+    return new File(native);
+  }
+}
+class Folder {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the folder.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the folder.
+   * @returns {string} The folder name.
+   */
+  getName() {
+    const collection = this.native.getInternal();
+    return collection.getName();
+  }
+  /**
+   * Gets the full path of the folder.
+   * @returns {string} The folder path.
+   */
+  getPath() {
+    const collection = this.native.getInternal();
+    return collection.getPath();
+  }
+  /**
+   * Creates a new sub-folder within this folder.
+   *
+   * @param {string} path The path of the sub-folder to create (relative to this folder).
+   * @returns {Folder} The newly created Folder instance.
+   */
+  createFolder(path) {
+    const native = this.native.createFolder(path);
+    return new Folder(native);
+  }
+  /**
+   * Checks if the folder itself exists.
+   * @returns {boolean} True if the folder exists.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if a specific sub-folder path exists within this folder.
+   *
+   * @param {string} path The relative path to the sub-folder.
+   * @returns {boolean} True if the sub-folder exists.
+   */
+  existsFolder(path) {
+    return this.native.existsFolder(path);
+  }
+  /**
+   * Retrieves a sub-folder by its path relative to this folder.
+   *
+   * @param {string} path The relative path to the sub-folder.
+   * @returns {Folder} The Folder instance.
+   */
+  getFolder(path) {
+    const native = this.native.getFolder(path);
+    return new Folder(native);
+  }
+  /**
+   * Retrieves a collection of folders at a specific path relative to this folder.
+   *
+   * @param {string} path The path containing the folders to retrieve.
+   * @returns {Folders} The Folders collection instance.
+   */
+  getFolders(path) {
+    const native = this.native.getFolders(path);
+    return new Folders(native);
+  }
+  /**
+   * Deletes a sub-folder from this folder.
+   *
+   * @param {string} path The path of the sub-folder to delete (relative to this folder).
+   */
+  deleteFolder(path) {
+    this.native.deleteFolder(path);
+  }
+  /**
+   * Creates a new file within this folder.
+   *
+   * @param {string} path The path of the file to create (relative to this folder).
+   * @param {any[]} [input=[]] Optional initial content as a byte array.
+   * @returns {File} The newly created File instance.
+   */
+  createFile(path, input = []) {
+    const native = this.native.createFile(path, input);
+    return new File(native);
+  }
+  /**
+   * Checks if a specific file path exists within this folder.
+   *
+   * @param {string} path The relative path to the file.
+   * @returns {boolean} True if the file exists.
+   */
+  existsFile(path) {
+    return this.native.existsFile(path);
+  }
+  /**
+   * Retrieves a file by its path relative to this folder.
+   *
+   * @param {string} path The relative path to the file.
+   * @returns {File} The File instance.
+   */
+  getFile(path) {
+    const native = this.native.getFile(path);
+    return new File(native);
+  }
+  /**
+   * Retrieves a collection of files at a specific path relative to this folder.
+   *
+   * @param {string} path The path containing the files to retrieve.
+   * @returns {Files} The Files collection instance.
+   */
+  getFiles(path) {
+    const native = this.native.getFiles(path);
+    return new Files(native);
+  }
+  /**
+   * Deletes a file from this folder.
+   *
+   * @param {string} path The path of the file to delete (relative to this folder).
+   */
+  deleteFile(path) {
+    this.native.deleteFile(path);
+  }
+}
+class File {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the file.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the file.
+   * @returns {string} The file name.
+   */
+  getName() {
+    const collection = this.native.getInternal();
+    return collection.getName();
+  }
+  /**
+   * Gets the full path of the file.
+   * @returns {string} The file path.
+   */
+  getPath() {
+    const collection = this.native.getInternal();
+    return collection.getPath();
+  }
+  /**
+   * Gets the content type (MIME type) of the file.
+   * @returns {string} The content type string.
+   */
+  getContentType() {
+    return this.native.getContentType();
+  }
+  /**
+   * Checks if the file content is determined to be binary.
+   * @returns {boolean} True if binary, false if text.
+   */
+  isBinary() {
+    return this.native.isBinary();
+  }
+  /**
+   * Gets the content of the file as a JavaScript-friendly byte array.
+   * @returns {any[]} The content bytes.
+   */
+  getContent() {
+    const output = WorkspaceFacade.getContent(this.native);
+    if (output) {
+      return output;
+    }
+    return output;
+  }
+  /**
+   * Gets the content of the file as a text string.
+   * @returns {string} The text content.
+   */
+  getText() {
+    const bytesOutput = this.getContent();
+    return Bytes.byteArrayToText(bytesOutput);
+  }
+  /**
+   * Sets the content of the file using a byte array.
+   * @param {any[]} input The new content bytes.
+   */
+  setContent(input) {
+    WorkspaceFacade.setContent(this.native, input);
+  }
+  /**
+   * Sets the content of the file using a text string.
+   * The string is converted to a byte array before saving.
+   * @param {string} input The new text content.
+   */
+  setText(input) {
+    const bytesInput = Bytes.textToByteArray(input);
+    this.setContent(bytesInput);
+  }
+  /**
+   * Checks if the file exists.
+   * @returns {boolean} True if the file exists.
+   */
+  exists() {
+    return this.native.exists();
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Workspace;
+}
+export {
+  File,
+  Files,
+  Folder,
+  Folders,
+  Project,
+  Projects,
+  Workspace
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/platform/workspace.ts"],
  "sourcesContent": ["/**\n * Provides a wrapper for the platform's WorkspaceFacade to manage Workspaces,\n * Projects, Folders, and Files.\n */\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\n\nconst WorkspaceFacade = Java.type(\"org.eclipse.dirigible.components.api.platform.WorkspaceFacade\");\n\n/**\n * @class Workspace\n * @description Represents a logical container for projects, providing static methods for\n * high-level workspace management and instance methods for project management within the workspace.\n */\nexport class Workspace {\n\n\t/**\n\t * Creates a new workspace with the given name.\n\t *\n\t * @param {string} name The name of the workspace to create.\n\t * @returns {Workspace} The newly created Workspace instance.\n\t */\n\tpublic static createWorkspace(name: string): Workspace {\n\t\tconst native = WorkspaceFacade.createWorkspace(name);\n\t\treturn new Workspace(native);\n\t}\n\n\t/**\n\t * Retrieves an existing workspace by name.\n\t *\n\t * @param {string} name The name of the workspace to retrieve.\n\t * @returns {Workspace} The Workspace instance.\n\t */\n\tpublic static getWorkspace(name: string): Workspace {\n\t\tconst native = WorkspaceFacade.getWorkspace(name);\n\t\treturn new Workspace(native);\n\t}\n\n\t/**\n\t * Retrieves the names of all existing workspaces.\n\t *\n\t * @returns {string[]} An array of workspace names.\n\t */\n\tpublic static getWorkspacesNames(): string[] {\n\t\tconst workspacesNames = WorkspaceFacade.getWorkspacesNames();\n\t\tif (workspacesNames) {\n\t\t\t// The native method returns a JSON string array that needs to be parsed.\n\t\t\treturn JSON.parse(workspacesNames);\n\t\t}\n\t\t// If null or undefined is returned, return the raw value (which will be null/undefined).\n\t\treturn workspacesNames;\n\t}\n\n\t/**\n\t * Deletes the workspace with the specified name.\n\t *\n\t * @param {string} name The name of the workspace to delete.\n\t */\n\tpublic static deleteWorkspace(name: string): void {\n\t\tWorkspaceFacade.deleteWorkspace(name);\n\t}\n\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance representing the workspace.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets a collection of all projects within this workspace.\n\t *\n\t * @returns {Projects} A Projects collection instance.\n\t */\n\tpublic getProjects(): Projects {\n\t\tconst native = this.native.getProjects();\n\t\treturn new Projects(native);\n\t}\n\n\t/**\n\t * Creates a new project within this workspace.\n\t *\n\t * @param {string} name The name of the project to create.\n\t * @returns {Project} The newly created Project instance.\n\t */\n\tpublic createProject(name: string): Project {\n\t\tconst native = this.native.createProject(name);\n\t\treturn new Project(native);\n\t}\n\n\t/**\n\t * Retrieves an existing project by name from this workspace.\n\t *\n\t * @param {string} name The name of the project to retrieve.\n\t * @returns {Project} The Project instance.\n\t */\n\tpublic getProject(name: string): Project {\n\t\tconst native = this.native.getProject(name);\n\t\treturn new Project(native);\n\t}\n\n\t/**\n\t * Deletes a project from this workspace by name.\n\t *\n\t * @param {string} name The name of the project to delete.\n\t */\n\tpublic deleteProject(name: string): void {\n\t\tthis.native.deleteProject(name);\n\t}\n\n\t/**\n\t * Checks if the workspace currently exists.\n\t *\n\t * @returns {boolean} True if the workspace exists, false otherwise.\n\t */\n\tpublic exists(): boolean {\n\t\treturn this.native.exists();\n\t}\n\n\t/**\n\t * Checks if a specific folder path exists within the workspace's filesystem structure.\n\t *\n\t * @param {string} path The relative path to the folder.\n\t * @returns {boolean} True if the folder exists.\n\t */\n\tpublic existsFolder(path: string): boolean {\n\t\treturn this.native.existsFolder(path);\n\t}\n\n\t/**\n\t * Checks if a specific file path exists within the workspace's filesystem structure.\n\t *\n\t * @param {string} path The relative path to the file.\n\t * @returns {boolean} True if the file exists.\n\t */\n\tpublic existsFile(path: string): boolean {\n\t\treturn this.native.existsFile(path);\n\t}\n\n\t/**\n\t * Copies a project from a source name to a target name within the workspace.\n\t *\n\t * @param {string} source The name of the project to copy.\n\t * @param {string} target The name of the new project copy.\n\t */\n\tpublic copyProject(source: string, target: string): void {\n\t\tthis.native.copyProject(source, target);\n\t}\n\n\t/**\n\t * Moves a project from a source name to a target name (renaming it).\n\t *\n\t * @param {string} source The current name of the project.\n\t * @param {string} target The new name/path of the project.\n\t */\n\tpublic moveProject(source: string, target: string): void {\n\t\tthis.native.moveProject(source, target);\n\t}\n\n}\n\n/**\n * @class Projects\n * @description A collection/list of projects within a workspace.\n */\nexport class Projects {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object representing the list of projects.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the number of projects in the collection.\n\t * @returns {number} The size of the collection.\n\t */\n\tpublic size(): number {\n\t\treturn this.native.size();\n\t}\n\n\t/**\n\t * Gets a Project instance at the specified index.\n\t * @param {number} index The index of the project.\n\t * @returns {Project} The Project instance.\n\t */\n\tpublic get(index: number): Project {\n\t\tconst native = this.native.get(index);\n\t\treturn new Project(native);\n\t}\n\n}\n\n/**\n * @class Project\n * @description Represents a Project within a workspace. It provides methods for managing\n * folders and files within the project.\n */\nexport class Project {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance representing the project.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the project.\n\t * @returns {string} The project name.\n\t */\n\tpublic getName(): string {\n\t\tconst collection = this.native.getInternal();\n\t\treturn collection.getName();\n\t}\n\n\t/**\n\t * Gets the path of the project.\n\t * @returns {string} The project path (relative to the repository/workspace root).\n\t */\n\tpublic getPath(): string {\n\t\tconst collection = this.native.getInternal();\n\t\treturn collection.getPath();\n\t}\n\n\t/**\n\t * Creates a new folder within the project.\n\t *\n\t * @param {string} path The path of the folder to create (relative to the project root).\n\t * @returns {Folder} The newly created Folder instance.\n\t */\n\tpublic createFolder(path: string): Folder {\n\t\tconst native = this.native.createFolder(path);\n\t\treturn new Folder(native);\n\t}\n\n\t/**\n\t * Checks if the project itself exists.\n\t * @returns {boolean} True if the project exists.\n\t */\n\tpublic exists(): boolean {\n\t\treturn this.native.exists();\n\t}\n\n\t/**\n\t * Checks if a specific folder path exists within the project.\n\t *\n\t * @param {string} path The relative path to the folder.\n\t * @returns {boolean} True if the folder exists.\n\t */\n\tpublic existsFolder(path: string): boolean {\n\t\treturn this.native.existsFolder(path);\n\t}\n\n\t/**\n\t * Retrieves a folder by its path relative to the project root.\n\t *\n\t * @param {string} path The relative path to the folder.\n\t * @returns {Folder} The Folder instance.\n\t */\n\tpublic getFolder(path: string): Folder {\n\t\tconst native = this.native.getFolder(path);\n\t\treturn new Folder(native);\n\t}\n\n\t/**\n\t * Retrieves a collection of folders at a specific path.\n\t *\n\t * @param {string} path The path containing the folders to retrieve.\n\t * @returns {Folders} The Folders collection instance.\n\t */\n\tpublic getFolders(path: string): Folders {\n\t\tconst native = this.native.getFolders(path);\n\t\treturn new Folders(native);\n\t}\n\n\t/**\n\t * Deletes a folder from the project.\n\t *\n\t * @param {string} path The path of the folder to delete (relative to the project root).\n\t */\n\tpublic deleteFolder(path: string): void {\n\t\tthis.native.deleteFolder(path);\n\t}\n\n\t/**\n\t * Creates a new file within the project.\n\t *\n\t * @param {string} path The path of the file to create (relative to the project root).\n\t * @param {any[]} [input=[]] Optional initial content as a byte array.\n\t * @returns {File} The newly created File instance.\n\t */\n\tpublic createFile(path: string, input: any[] = []): File {\n\t\tconst native = this.native.createFile(path, input);\n\t\treturn new File(native);\n\t}\n\n\t/**\n\t * Checks if a specific file path exists within the project.\n\t *\n\t * @param {string} path The relative path to the file.\n\t * @returns {boolean} True if the file exists.\n\t */\n\tpublic existsFile(path: string): boolean {\n\t\treturn this.native.existsFile(path);\n\t}\n\n\t/**\n\t * Retrieves a file by its path relative to the project root.\n\t *\n\t * @param {string} path The relative path to the file.\n\t * @returns {File} The File instance.\n\t */\n\tpublic getFile(path: string): File {\n\t\tconst native = this.native.getFile(path);\n\t\treturn new File(native);\n\t}\n\n\t/**\n\t * Retrieves a collection of files at a specific path.\n\t *\n\t * @param {string} path The path containing the files to retrieve.\n\t * @returns {Files} The Files collection instance.\n\t */\n\tpublic getFiles(path: string): Files {\n\t\tconst native = this.native.getFiles(path);\n\t\treturn new Files(native);\n\t}\n\n\t/**\n\t * Deletes a file from the project.\n\t *\n\t * @param {string} path The path of the file to delete (relative to the project root).\n\t */\n\tpublic deleteFile(path: string): void {\n\t\tthis.native.deleteFile(path);\n\t}\n\n}\n\n/**\n * @class Folders\n * @description A collection/list of folders.\n */\nexport class Folders {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object representing the list of folders.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the number of folders in the collection.\n\t * @returns {number} The size of the collection.\n\t */\n\tpublic size(): number {\n\t\treturn this.native.size();\n\t}\n\n\t/**\n\t * Gets a Folder instance at the specified index.\n\t * @param {number} index The index of the folder.\n\t * @returns {Folder} The Folder instance.\n\t */\n\tpublic get(index: number): Folder {\n\t\tconst native = this.native.get(index);\n\t\treturn new Folder(native);\n\t}\n\n}\n\n/**\n * @class Files\n * @description A collection/list of files.\n */\nexport class Files {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object representing the list of files.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the number of files in the collection.\n\t * @returns {number} The size of the collection.\n\t */\n\tpublic size(): number {\n\t\treturn this.native.size();\n\t}\n\n\t/**\n\t * Gets a File instance at the specified index.\n\t * @param {number} index The index of the file.\n\t * @returns {File} The File instance.\n\t */\n\tpublic get(index: number): File {\n\t\tconst native = this.native.get(index);\n\t\treturn new File(native);\n\t}\n\n}\n\n/**\n * @class Folder\n * @description Represents a directory or folder within a project, providing methods for\n * managing sub-folders and files.\n */\nexport class Folder {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance representing the folder.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the folder.\n\t * @returns {string} The folder name.\n\t */\n\tpublic getName(): string {\n\t\tconst collection = this.native.getInternal();\n\t\treturn collection.getName();\n\t};\n\n\t/**\n\t * Gets the full path of the folder.\n\t * @returns {string} The folder path.\n\t */\n\tpublic getPath(): string {\n\t\tconst collection = this.native.getInternal();\n\t\treturn collection.getPath();\n\t}\n\n\t/**\n\t * Creates a new sub-folder within this folder.\n\t *\n\t * @param {string} path The path of the sub-folder to create (relative to this folder).\n\t * @returns {Folder} The newly created Folder instance.\n\t */\n\tpublic createFolder(path: string): Folder {\n\t\tconst native = this.native.createFolder(path);\n\t\treturn new Folder(native);\n\t}\n\n\t/**\n\t * Checks if the folder itself exists.\n\t * @returns {boolean} True if the folder exists.\n\t */\n\tpublic exists(): boolean {\n\t\treturn this.native.exists();\n\t}\n\n\t/**\n\t * Checks if a specific sub-folder path exists within this folder.\n\t *\n\t * @param {string} path The relative path to the sub-folder.\n\t * @returns {boolean} True if the sub-folder exists.\n\t */\n\tpublic existsFolder(path: string): boolean {\n\t\treturn this.native.existsFolder(path);\n\t}\n\n\t/**\n\t * Retrieves a sub-folder by its path relative to this folder.\n\t *\n\t * @param {string} path The relative path to the sub-folder.\n\t * @returns {Folder} The Folder instance.\n\t */\n\tpublic getFolder(path: string): Folder {\n\t\tconst native = this.native.getFolder(path);\n\t\treturn new Folder(native);\n\t}\n\n\t/**\n\t * Retrieves a collection of folders at a specific path relative to this folder.\n\t *\n\t * @param {string} path The path containing the folders to retrieve.\n\t * @returns {Folders} The Folders collection instance.\n\t */\n\tpublic getFolders(path: string): Folders {\n\t\tconst native = this.native.getFolders(path);\n\t\treturn new Folders(native);\n\t}\n\n\t/**\n\t * Deletes a sub-folder from this folder.\n\t *\n\t * @param {string} path The path of the sub-folder to delete (relative to this folder).\n\t */\n\tpublic deleteFolder(path: string): void {\n\t\tthis.native.deleteFolder(path);\n\t}\n\n\t/**\n\t * Creates a new file within this folder.\n\t *\n\t * @param {string} path The path of the file to create (relative to this folder).\n\t * @param {any[]} [input=[]] Optional initial content as a byte array.\n\t * @returns {File} The newly created File instance.\n\t */\n\tpublic createFile(path: string, input: any[] = []): File {\n\t\tconst native = this.native.createFile(path, input);\n\t\treturn new File(native);\n\t}\n\n\t/**\n\t * Checks if a specific file path exists within this folder.\n\t *\n\t * @param {string} path The relative path to the file.\n\t * @returns {boolean} True if the file exists.\n\t */\n\tpublic existsFile(path: string): boolean {\n\t\treturn this.native.existsFile(path);\n\t}\n\n\t/**\n\t * Retrieves a file by its path relative to this folder.\n\t *\n\t * @param {string} path The relative path to the file.\n\t * @returns {File} The File instance.\n\t */\n\tpublic getFile(path: string): File {\n\t\tconst native = this.native.getFile(path);\n\t\treturn new File(native);\n\t}\n\n\t/**\n\t * Retrieves a collection of files at a specific path relative to this folder.\n\t *\n\t * @param {string} path The path containing the files to retrieve.\n\t * @returns {Files} The Files collection instance.\n\t */\n\tpublic getFiles(path: string): Files {\n\t\tconst native = this.native.getFiles(path);\n\t\treturn new Files(native);\n\t}\n\n\t/**\n\t * Deletes a file from this folder.\n\t *\n\t * @param {string} path The path of the file to delete (relative to this folder).\n\t */\n\tpublic deleteFile(path: string): void {\n\t\tthis.native.deleteFile(path);\n\t}\n\n}\n\n/**\n * @class File\n * @description Represents a file (resource) within the workspace, providing methods for\n * content access and manipulation.\n */\nexport class File {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance representing the file.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the file.\n\t * @returns {string} The file name.\n\t */\n\tpublic getName(): string {\n\t\tconst collection = this.native.getInternal();\n\t\treturn collection.getName();\n\t}\n\n\t/**\n\t * Gets the full path of the file.\n\t * @returns {string} The file path.\n\t */\n\tpublic getPath(): string {\n\t\tconst collection = this.native.getInternal();\n\t\treturn collection.getPath();\n\t}\n\n\t/**\n\t * Gets the content type (MIME type) of the file.\n\t * @returns {string} The content type string.\n\t */\n\tpublic getContentType(): string {\n\t\treturn this.native.getContentType();\n\t}\n\n\t/**\n\t * Checks if the file content is determined to be binary.\n\t * @returns {boolean} True if binary, false if text.\n\t */\n\tpublic isBinary(): boolean {\n\t\treturn this.native.isBinary();\n\t}\n\n\t/**\n\t * Gets the content of the file as a JavaScript-friendly byte array.\n\t * @returns {any[]} The content bytes.\n\t */\n\tpublic getContent(): any[] {\n\t\tconst output = WorkspaceFacade.getContent(this.native);\n\t\tif (output) {\n\t\t\t// Ensure it's returned if it exists\n\t\t\treturn output;\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Gets the content of the file as a text string.\n\t * @returns {string} The text content.\n\t */\n\tpublic getText(): string {\n\t\tconst bytesOutput = this.getContent();\n\t\treturn Bytes.byteArrayToText(bytesOutput);\n\t}\n\n\t/**\n\t * Sets the content of the file using a byte array.\n\t * @param {any[]} input The new content bytes.\n\t */\n\tpublic setContent(input: any[]): void {\n\t\tWorkspaceFacade.setContent(this.native, input);\n\t}\n\n\t/**\n\t * Sets the content of the file using a text string.\n\t * The string is converted to a byte array before saving.\n\t * @param {string} input The new text content.\n\t */\n\tpublic setText(input: string): void {\n\t\tconst bytesInput = Bytes.textToByteArray(input);\n\t\tthis.setContent(bytesInput);\n\t}\n\n\t/**\n\t * Checks if the file exists.\n\t * @returns {boolean} True if the file exists.\n\t */\n\tpublic exists(): boolean {\n\t\treturn this.native.exists();\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Workspace;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/qldb/index.mjs

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

package/dist/esm/qldb/qldb.mjs

@@ -0,0 +1,5 @@
+const QLDBRepository = Java.type("org.eclipse.dirigible.components.api.qldb.QLDBRepository");
+export {
+  QLDBRepository
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3FsZGIvcWxkYi50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0IGNvbnN0IFFMREJSZXBvc2l0b3J5ID0gSmF2YS50eXBlKFwib3JnLmVjbGlwc2UuZGlyaWdpYmxlLmNvbXBvbmVudHMuYXBpLnFsZGIuUUxEQlJlcG9zaXRvcnlcIik7Il0sCiAgIm1hcHBpbmdzIjogIkFBQU8sTUFBTSxpQkFBaUIsS0FBSyxLQUFLLDBEQUEwRDsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/rabbitmq/consumer.mjs

@@ -0,0 +1,31 @@
+const RabbitMQFacade = Java.type("org.eclipse.dirigible.components.api.rabbitmq.RabbitMQFacade");
+class Consumer {
+  /**
+   * Starts listening for messages on a specified RabbitMQ queue.
+   * The handler is typically a service or script URI that will be executed
+   * when a message arrives.
+   *
+   * @param queue The name of the RabbitMQ queue to listen to.
+   * @param handler The URI/name of the component/script that will handle the message.
+   */
+  static startListening(queue, handler) {
+    RabbitMQFacade.startListening(queue, handler);
+  }
+  /**
+   * Stops the message listener previously started on a specified RabbitMQ queue
+   * for a given handler.
+   *
+   * @param queue The name of the RabbitMQ queue.
+   * @param handler The URI/name of the component/script whose listener should be stopped.
+   */
+  static stopListening(queue, handler) {
+    RabbitMQFacade.stopListening(queue, handler);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Consumer;
+}
+export {
+  Consumer
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/rabbitmq/index.mjs

@@ -0,0 +1,9 @@
+export * from "./consumer";
+import { Consumer } from "./consumer";
+export * from "./producer";
+import { Producer } from "./producer";
+export {
+  Consumer as consumer,
+  Producer as producer
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3JhYmJpdG1xL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi9jb25zdW1lclwiO1xuZXhwb3J0IHsgQ29uc3VtZXIgYXMgY29uc3VtZXIgfSBmcm9tIFwiLi9jb25zdW1lclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHJvZHVjZXJcIjtcbmV4cG9ydCB7IFByb2R1Y2VyIGFzIHByb2R1Y2VyIH0gZnJvbSBcIi4vcHJvZHVjZXJcIjtcbiJdLAogICJtYXBwaW5ncyI6ICJBQUFBLGNBQWM7QUFDZCxTQUFxQixnQkFBZ0I7QUFDckMsY0FBYztBQUNkLFNBQXFCLGdCQUFnQjsiLAogICJuYW1lcyI6IFtdCn0K