@aerokit/sdk 12.44.0

package/dist/esm/git/client.mjs

@@ -0,0 +1,258 @@
+const GitFacade = Java.type("org.eclipse.dirigible.components.api.git.GitFacade");
+class Client {
+  /**
+   * Initializes a new Git repository for a project, performs an initial commit, and pushes.
+   *
+   * @param user The username of the committer.
+   * @param email The email address of the committer.
+   * @param workspaceName The name of the workspace.
+   * @param projectName The name of the project.
+   * @param repositoryName The name of the repository (where to put the git folder).
+   * @param commitMessage The initial commit message.
+   */
+  static initRepository(user, email, workspaceName, projectName, repositoryName, commitMessage) {
+    GitFacade.initRepository(user, email, workspaceName, projectName, repositoryName, commitMessage);
+  }
+  /**
+   * Performs a commit in the specified repository.
+   *
+   * @param user The username of the committer.
+   * @param email The email address of the committer.
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param commitMessage The commit message.
+   * @param all If true, automatically stages modified and deleted files before committing.
+   */
+  static commit(user, email, workspaceName, repositoryName, commitMessage, all) {
+    GitFacade.commit(user, email, workspaceName, repositoryName, commitMessage, all);
+  }
+  /**
+   * Retrieves a list of all Git repositories (projects) within the specified workspace.
+   *
+   * @param workspaceName The name of the workspace.
+   * @returns An array of {@link ProjectDescriptor} objects.
+   */
+  static getGitRepositories(workspaceName) {
+    return GitFacade.getGitRepositories(workspaceName);
+  }
+  /**
+   * Retrieves the commit history for the specified repository or a specific file path within it.
+   *
+   * @param repositoryName The name of the repository.
+   * @param workspaceName The name of the workspace.
+   * @param path The file path for history, or null/empty string for full repository history.
+   * @returns An array of {@link GitCommitInfo} objects.
+   */
+  static getHistory(repositoryName, workspaceName, path) {
+    return GitFacade.getHistory(repositoryName, workspaceName, path);
+  }
+  /**
+   * Deletes the specified Git repository.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository to delete.
+   */
+  static deleteRepository(workspaceName, repositoryName) {
+    return GitFacade.deleteRepository(workspaceName, repositoryName);
+  }
+  /**
+   * Clones a remote repository into the local workspace.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryUri The URI of the remote repository.
+   * @param username The username for authentication.
+   * @param password The password for authentication.
+   * @param branch The specific branch to checkout after cloning.
+   * @returns A GitConnector instance for interacting directly with the cloned repository.
+   */
+  static cloneRepository(workspaceName, repositoryUri, username, password, branch) {
+    return GitFacade.cloneRepository(workspaceName, repositoryUri, username, password, branch);
+  }
+  /**
+   * Pulls changes from the remote repository and attempts to merge them into the current branch.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param username The username for authentication.
+   * @param password The password for authentication.
+   */
+  static pull(workspaceName, repositoryName, username, password) {
+    GitFacade.pull(workspaceName, repositoryName, username, password);
+  }
+  /**
+   * Pushes the local commits to the remote repository.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param username The username for authentication.
+   * @param password The password for authentication.
+   */
+  static push(workspaceName, repositoryName, username, password) {
+    GitFacade.push(workspaceName, repositoryName, username, password);
+  }
+  /**
+   * Checks out a specific branch, commit, or tag in the repository.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param branch The branch or tree-ish object to check out.
+   */
+  static checkout(workspaceName, repositoryName, branch) {
+    GitFacade.checkout(workspaceName, repositoryName, branch);
+  }
+  /**
+   * Creates a new branch starting from a specified point (e.g., HEAD, a commit hash, or another branch).
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param branch The name of the new branch to create.
+   * @param startingPoint The tree-ish object to start the new branch from.
+   */
+  static createBranch(workspaceName, repositoryName, branch, startingPoint) {
+    GitFacade.createBranch(workspaceName, repositoryName, branch, startingPoint);
+  }
+  /**
+   * Deletes a local branch.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param branch The name of the branch to delete.
+   */
+  static deleteBranch(workspaceName, repositoryName, branch) {
+    GitFacade.deleteBranch(workspaceName, repositoryName, branch);
+  }
+  /**
+   * Renames a local branch.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param oldName The current name of the branch.
+   * @param newName The new name for the branch.
+   */
+  static renameBranch(workspaceName, repositoryName, oldName, newName) {
+    GitFacade.renameBranch(workspaceName, repositoryName, oldName, newName);
+  }
+  /**
+   * Creates a new remote branch on the Git server.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param branch The name of the remote branch to create.
+   * @param startingPoint The tree-ish object to start the new remote branch from.
+   * @param username The username for authentication.
+   * @param password The password for authentication.
+   */
+  static createRemoteBranch(workspaceName, repositoryName, branch, startingPoint, username, password) {
+    GitFacade.createRemoteBranch(workspaceName, repositoryName, branch, startingPoint, username, password);
+  }
+  /**
+   * Deletes a remote branch on the Git server.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param branch The name of the remote branch to delete.
+   * @param username The username for authentication.
+   * @param password The password for authentication.
+   */
+  static deleteRemoteBranch(workspaceName, repositoryName, branch, username, password) {
+    GitFacade.deleteRemoteBranch(workspaceName, repositoryName, branch, username, password);
+  }
+  /**
+   * Resets the repository, discarding all uncommitted changes in the working directory and index.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   */
+  static hardReset(workspaceName, repositoryName) {
+    GitFacade.hardReset(workspaceName, repositoryName);
+  }
+  /**
+   * Reapplies commits from the specified branch onto the current branch.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param branch The branch to rebase.
+   */
+  static rebase(workspaceName, repositoryName, branch) {
+    GitFacade.rebase(workspaceName, repositoryName, branch);
+  }
+  /**
+   * Retrieves the current status of the repository (staged, unstaged, untracked files).
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @returns A string representation of the repository status.
+   */
+  static status(workspaceName, repositoryName) {
+    return GitFacade.status(workspaceName, repositoryName);
+  }
+  /**
+   * Retrieves the name of the currently active branch.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @returns The name of the current branch.
+   */
+  static getBranch(workspaceName, repositoryName) {
+    return GitFacade.getBranch(workspaceName, repositoryName);
+  }
+  /**
+   * Retrieves a list of all local branches in the repository.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @returns An array of {@link GitBranch} objects representing local branches.
+   */
+  static getLocalBranches(workspaceName, repositoryName) {
+    return GitFacade.getLocalBranches(workspaceName, repositoryName);
+  }
+  /**
+   * Retrieves a list of all remote branches configured for the repository.
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @returns An array of {@link GitBranch} objects representing remote branches.
+   */
+  static getRemoteBranches(workspaceName, repositoryName) {
+    return GitFacade.getRemoteBranches(workspaceName, repositoryName);
+  }
+  /**
+   * Retrieves a list of all unstaged files (changes not yet added to the index).
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @returns An array of {@link GitChangedFile} objects.
+   */
+  static getUnstagedChanges(workspaceName, repositoryName) {
+    return GitFacade.getUnstagedChanges(workspaceName, repositoryName);
+  }
+  /**
+   * Retrieves a list of all staged files (changes added to the index, ready for commit).
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @returns An array of {@link GitChangedFile} objects.
+   */
+  static getStagedChanges(workspaceName, repositoryName) {
+    return GitFacade.getStagedChanges(workspaceName, repositoryName);
+  }
+  /**
+   * Retrieves the content of a file at a specific revision (commit, branch, or tag).
+   *
+   * @param workspaceName The name of the workspace.
+   * @param repositoryName The name of the repository.
+   * @param filePath The path to the file.
+   * @param revStr The revision string (e.g., commit hash or branch name).
+   * @returns The content of the file as a string.
+   */
+  static getFileContent(workspaceName, repositoryName, filePath, revStr) {
+    return GitFacade.getFileContent(workspaceName, repositoryName, filePath, revStr);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Client;
+}
+export {
+  Client
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/git/client.ts"],
  "sourcesContent": ["const GitFacade = Java.type(\"org.eclipse.dirigible.components.api.git.GitFacade\");\n\n/**\n * Describes a file within the workspace, potentially with Git status information.\n */\nexport interface FileDescriptor {\n    name: string;\n    path: string;\n    contentType: string;\n    status: string;\n}\n\n/**\n * Describes a folder within the workspace, potentially with Git status information.\n */\nexport interface FolderDescriptor {\n    name: string;\n    path: string;\n    status: string;\n    folders: FolderDescriptor[];\n    files: FileDescriptor[];\n}\n\n/**\n * Describes a Git-managed project/repository in the workspace.\n */\nexport interface ProjectDescriptor {\n    name: string;\n    path: string;\n    git: boolean;\n    gitName: string;\n    folders: FolderDescriptor[];\n    files: FileDescriptor[];\n}\n\n/**\n * Describes a single Git commit.\n */\nexport interface GitCommitInfo {\n    id: string;\n    author: string;\n    emailAddress: string;\n    dateTime: string;\n    message: string;\n}\n\n\n/**\n * Describes a Git branch (local or remote).\n */\nexport interface GitBranch {\n    name: string;\n    remote: boolean;\n    current: boolean;\n    commitObjectId: string;\n    commitShortId: string;\n    commitDate: string;\n    commitMessage: string;\n    commitAuthor: string;\n}\n\n/**\n * Describes a file that has been changed (staged or unstaged).\n */\nexport interface GitChangedFile {\n    path: string;\n    type: number;\n}\n\n/**\n* The IGitConnector provides the simplified methods for communicating with a Git SCM server.\n* This interface is primarily implemented by the object returned from the native Java facade.\n*/\nexport interface GitConnector {\n\n    /**\n     * Gets the origin urls.\n     *\n     * @returns An object containing the fetch and push URLs.\n     */\n    getOriginUrls(): { fetchUrl: string; pushUrl: string; };\n\n    /**\n     * Sets the fetch url.\n     *\n     * @param fetchUrl The new fetch URL.\n     * @throws URISyntaxException, GitAPIException\n     */\n    setFetchUrl(fetchUrl: string): void\n\n    /**\n     * Sets the push url.\n     *\n     * @param pushUrl The new push URL.\n     * @throws URISyntaxException, GitAPIException\n     */\n    setPushUrl(pushUrl: string): void\n\n    /**\n     * Adds file(s) to the staging index.\n     *\n     * @param filePattern File to add content from. Example: \".\" includes all files.\n     * @throws IOException, NoFilepatternException, GitAPIException\n     */\n    add(filePattern: string): void\n\n    /**\n     * Adds deleted file(s) to the staging index.\n     *\n     * @param filePattern File to add content from. Example: \".\" includes all files.\n     * @throws IOException, NoFilepatternException, GitAPIException\n     */\n    addDeleted(filePattern: string): void\n\n    /**\n     * Remove from the index.\n     *\n     * @param path The path to be removed.\n     * @throws IOException, NoFilepatternException, GitAPIException\n     */\n    remove(path: string): void\n\n    /**\n     * Revert to head revision.\n     *\n     * @param path The path to be reverted.\n     * @throws IOException, NoFilepatternException, GitAPIException\n     */\n    revert(path: string): void\n\n\n    /**\n     * Adds changes to the staging index, then performs a commit.\n     *\n     * @param message The commit message.\n     * @param name The name of the committer.\n     * @param email The email of the committer.\n     * @param all If true, automatically stages modified and deleted files.\n     * @throws Various Git exceptions\n     */\n    commit(message: string, name: string, email: string, all: boolean): void;\n\n    /**\n     * Creates new branch from a particular start point.\n     *\n     * @param name The new branch name.\n     * @param startPoint Valid tree-ish object (e.g., \"master\", \"HEAD\", commit hash).\n     * @throws RefAlreadyExistsException, GitAPIException\n     */\n    createBranch(name: string, startPoint: string): void\n\n    /**\n     * Deletes the branch.\n     *\n     * @param name The branch name to delete.\n     * @throws RefAlreadyExistsException, GitAPIException\n     */\n    deleteBranch(name: string): void\n\n    /**\n     * Renames the branch.\n     *\n     * @param oldName The old branch name.\n     * @param newName The new branch name.\n     * @throws RefAlreadyExistsException, GitAPIException\n     */\n    renameBranch(oldName: string, newName: string): void\n\n    /**\n     * Creates new remote branch from a particular start point.\n     *\n     * @param name The branch name.\n     * @param startPoint Valid tree-ish object.\n     * @param username Username for the remote repository.\n     * @param password Password for the remote repository.\n     * @throws RefAlreadyExistsException, GitAPIException\n     */\n    createRemoteBranch(name: string, startPoint: string, username: string, password: string): void\n\n    /**\n     * Deletes the remote branch.\n     *\n     * @param name The name of the remote branch to delete.\n     * @param username Username for the remote repository.\n     * @param password Password for the remote repository.\n     * @throws RefAlreadyExistsException, GitAPIException\n     */\n    deleteRemoteBranch(name: string, username: string, password: string): void\n\n    /**\n     * Checkout to a valid tree-ish object (e.g., branch name, commit hash).\n     *\n     * @param name The tree-ish object.\n     * @returns The JGit Ref object.\n     * @throws RefAlreadyExistsException, GitAPIException\n     */\n    checkout(name: string): any\n\n    /**\n     * Hard reset the repository. Resets working directory and staging index to match the Git repository HEAD.\n     *\n     * @throws CheckoutConflictException, GitAPIException\n     */\n    hardReset(): void\n\n    /**\n     * Fetches from a remote repository and tries to merge into the current branch (Pull).\n     *\n     * @throws Various Git exceptions\n     */\n    pull(): void\n\n    /**\n     * Fetches from a remote repository and tries to merge into the current branch (Pull).\n     *\n     * @param username Username for the remote repository.\n     * @param password Password for the remote repository.\n     * @throws Various Git exceptions\n     */\n    pull(username: string, password: string): void\n\n    /**\n     * Pushes the committed changes to the remote repository.\n     *\n     * @param username Username for the remote repository.\n     * @param password Password for the remote repository.\n     * @throws InvalidRemoteException, TransportException, GitAPIException\n     */\n    push(username: string, password: string): void\n\n    /**\n     * Tries to rebase the selected branch on top of the current one.\n     *\n     * @param name The branch to rebase.\n     * @throws NoHeadException, WrongRepositoryStateException, GitAPIException\n     */\n    rebase(name: string): void\n\n    /**\n     * Get the current status of the Git repository.\n     *\n     * @returns The JGit Status object.\n     * @throws NoWorkTreeException, GitAPIException\n     */\n    status(): any\n\n    /**\n     * Get the name of the current branch of the Git repository.\n     *\n     * @returns The branch name as a string.\n     * @throws IOException\n     */\n    getBranch(): string\n\n    /**\n     * List all the local branches info.\n     *\n     * @returns A list of local {@link GitBranch} objects.\n     * @throws GitConnectorException\n     */\n    getLocalBranches(): GitBranch[]\n\n    /**\n     * List all the remote branches info.\n     *\n     * @returns A list of remote {@link GitBranch} objects.\n     * @throws GitConnectorException\n     */\n    getRemoteBranches(): GitBranch[]\n\n\n    /**\n     * Get the list of the unstaged files.\n     *\n     * @returns A list of {@link GitChangedFile} objects.\n     * @throws GitConnectorException\n     */\n    getUnstagedChanges(): GitChangedFile[]\n\n    /**\n     * Get the list of the staged files.\n     *\n     * @returns A list of {@link GitChangedFile} objects.\n     * @throws GitConnectorException\n     */\n    getStagedChanges(): GitChangedFile[]\n\n    /**\n     * Get file content from the HEAD.\n     *\n     * @param path The file path.\n     * @param revStr The revision string (e.g., commit hash, branch name).\n     * @returns The content of the file as a string.\n     * @throws GitConnectorException\n     */\n    getFileContent(path: string, revStr: string): string\n\n    /**\n     * Get history of the repository or a specific file.\n     *\n     * @param path The file path or null to get the entire repository history.\n     * @returns A list of {@link GitCommitInfo} objects.\n     * @throws GitConnectorException\n     */\n    getHistory(path: string): GitCommitInfo[]\n}\n\n/**\n * Static client facade for workspace-level Git operations, abstracting the native GitFacade.\n */\nexport class Client {\n\n    /**\n     * Initializes a new Git repository for a project, performs an initial commit, and pushes.\n     *\n     * @param user The username of the committer.\n     * @param email The email address of the committer.\n     * @param workspaceName The name of the workspace.\n     * @param projectName The name of the project.\n     * @param repositoryName The name of the repository (where to put the git folder).\n     * @param commitMessage The initial commit message.\n     */\n    public static initRepository(user: string, email: string, workspaceName: string, projectName: string, repositoryName: string, commitMessage: string): void {\n        GitFacade.initRepository(user, email, workspaceName, projectName, repositoryName, commitMessage);\n    }\n\n    /**\n     * Performs a commit in the specified repository.\n     *\n     * @param user The username of the committer.\n     * @param email The email address of the committer.\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param commitMessage The commit message.\n     * @param all If true, automatically stages modified and deleted files before committing.\n     */\n    public static commit(user: string, email: string, workspaceName: string, repositoryName: string, commitMessage: string, all: boolean): void {\n        GitFacade.commit(user, email, workspaceName, repositoryName, commitMessage, all);\n    }\n\n    /**\n     * Retrieves a list of all Git repositories (projects) within the specified workspace.\n     *\n     * @param workspaceName The name of the workspace.\n     * @returns An array of {@link ProjectDescriptor} objects.\n     */\n    public static getGitRepositories(workspaceName: string): ProjectDescriptor[] {\n        return GitFacade.getGitRepositories(workspaceName);\n    }\n\n    /**\n     * Retrieves the commit history for the specified repository or a specific file path within it.\n     *\n     * @param repositoryName The name of the repository.\n     * @param workspaceName The name of the workspace.\n     * @param path The file path for history, or null/empty string for full repository history.\n     * @returns An array of {@link GitCommitInfo} objects.\n     */\n    public static getHistory(repositoryName: string, workspaceName: string, path: string): GitCommitInfo[] {\n        return GitFacade.getHistory(repositoryName, workspaceName, path);\n    }\n\n    /**\n     * Deletes the specified Git repository.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository to delete.\n     */\n    public static deleteRepository(workspaceName: string, repositoryName: string): void {\n        return GitFacade.deleteRepository(workspaceName, repositoryName);\n    }\n\n    /**\n     * Clones a remote repository into the local workspace.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryUri The URI of the remote repository.\n     * @param username The username for authentication.\n     * @param password The password for authentication.\n     * @param branch The specific branch to checkout after cloning.\n     * @returns A GitConnector instance for interacting directly with the cloned repository.\n     */\n    public static cloneRepository(workspaceName: string, repositoryUri: string, username: string, password: string, branch: string): GitConnector {\n        // The native GitFacade returns a Java object implementing GitConnector\n        return GitFacade.cloneRepository(workspaceName, repositoryUri, username, password, branch);\n    }\n\n    /**\n     * Pulls changes from the remote repository and attempts to merge them into the current branch.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param username The username for authentication.\n     * @param password The password for authentication.\n     */\n    public static pull(workspaceName: string, repositoryName: string, username: string, password: string): void {\n        GitFacade.pull(workspaceName, repositoryName, username, password);\n    }\n\n    /**\n     * Pushes the local commits to the remote repository.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param username The username for authentication.\n     * @param password The password for authentication.\n     */\n    public static push(workspaceName: string, repositoryName: string, username: string, password: string): void {\n        GitFacade.push(workspaceName, repositoryName, username, password);\n    }\n\n    /**\n     * Checks out a specific branch, commit, or tag in the repository.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param branch The branch or tree-ish object to check out.\n     */\n    public static checkout(workspaceName: string, repositoryName: string, branch: string): void {\n        GitFacade.checkout(workspaceName, repositoryName, branch);\n    }\n\n    /**\n     * Creates a new branch starting from a specified point (e.g., HEAD, a commit hash, or another branch).\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param branch The name of the new branch to create.\n     * @param startingPoint The tree-ish object to start the new branch from.\n     */\n    public static createBranch(workspaceName: string, repositoryName: string, branch: string, startingPoint: string): void {\n        GitFacade.createBranch(workspaceName, repositoryName, branch, startingPoint);\n    }\n\n    /**\n     * Deletes a local branch.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param branch The name of the branch to delete.\n     */\n    public static deleteBranch(workspaceName: string, repositoryName: string, branch: string): void {\n        GitFacade.deleteBranch(workspaceName, repositoryName, branch);\n    }\n\n    /**\n     * Renames a local branch.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param oldName The current name of the branch.\n     * @param newName The new name for the branch.\n     */\n    public static renameBranch(workspaceName: string, repositoryName: string, oldName: string, newName: string): void {\n        GitFacade.renameBranch(workspaceName, repositoryName, oldName, newName);\n    }\n\n    /**\n     * Creates a new remote branch on the Git server.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param branch The name of the remote branch to create.\n     * @param startingPoint The tree-ish object to start the new remote branch from.\n     * @param username The username for authentication.\n     * @param password The password for authentication.\n     */\n    public static createRemoteBranch(workspaceName: string, repositoryName: string, branch: string, startingPoint: string, username: string, password: string): void {\n        GitFacade.createRemoteBranch(workspaceName, repositoryName, branch, startingPoint, username, password);\n    }\n\n    /**\n     * Deletes a remote branch on the Git server.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param branch The name of the remote branch to delete.\n     * @param username The username for authentication.\n     * @param password The password for authentication.\n     */\n    public static deleteRemoteBranch(workspaceName: string, repositoryName: string, branch: string, username: string, password: string): void {\n        GitFacade.deleteRemoteBranch(workspaceName, repositoryName, branch, username, password);\n    }\n\n    /**\n     * Resets the repository, discarding all uncommitted changes in the working directory and index.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     */\n    public static hardReset(workspaceName: string, repositoryName: string): void {\n        GitFacade.hardReset(workspaceName, repositoryName);\n    }\n\n    /**\n     * Reapplies commits from the specified branch onto the current branch.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param branch The branch to rebase.\n     */\n    public static rebase(workspaceName: string, repositoryName: string, branch: string): void {\n        GitFacade.rebase(workspaceName, repositoryName, branch);\n    }\n\n    /**\n     * Retrieves the current status of the repository (staged, unstaged, untracked files).\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @returns A string representation of the repository status.\n     */\n    public static status(workspaceName: string, repositoryName: string): string {\n        return GitFacade.status(workspaceName, repositoryName);\n    }\n\n    /**\n     * Retrieves the name of the currently active branch.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @returns The name of the current branch.\n     */\n    public static getBranch(workspaceName: string, repositoryName: string): string {\n        return GitFacade.getBranch(workspaceName, repositoryName);\n    }\n\n    /**\n     * Retrieves a list of all local branches in the repository.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @returns An array of {@link GitBranch} objects representing local branches.\n     */\n    public static getLocalBranches(workspaceName: string, repositoryName: string): GitBranch[] {\n        return GitFacade.getLocalBranches(workspaceName, repositoryName);\n    }\n\n    /**\n     * Retrieves a list of all remote branches configured for the repository.\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @returns An array of {@link GitBranch} objects representing remote branches.\n     */\n    public static getRemoteBranches(workspaceName: string, repositoryName: string): GitBranch[] {\n        return GitFacade.getRemoteBranches(workspaceName, repositoryName);\n    }\n\n    /**\n     * Retrieves a list of all unstaged files (changes not yet added to the index).\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @returns An array of {@link GitChangedFile} objects.\n     */\n    public static getUnstagedChanges(workspaceName: string, repositoryName: string): GitChangedFile[] {\n        return GitFacade.getUnstagedChanges(workspaceName, repositoryName);\n    }\n\n    /**\n     * Retrieves a list of all staged files (changes added to the index, ready for commit).\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @returns An array of {@link GitChangedFile} objects.\n     */\n    public static getStagedChanges(workspaceName: string, repositoryName: string): GitChangedFile[] {\n        // Corrected return type to array of GitChangedFile\n        return GitFacade.getStagedChanges(workspaceName, repositoryName);\n    }\n\n    /**\n     * Retrieves the content of a file at a specific revision (commit, branch, or tag).\n     *\n     * @param workspaceName The name of the workspace.\n     * @param repositoryName The name of the repository.\n     * @param filePath The path to the file.\n     * @param revStr The revision string (e.g., commit hash or branch name).\n     * @returns The content of the file as a string.\n     */\n    public static getFileContent(workspaceName: string, repositoryName: string, filePath: string, revStr: string): string {\n        return GitFacade.getFileContent(workspaceName, repositoryName, filePath, revStr);\n    }\n}\n\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Client;\n}"],
  "mappings": "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",
  "names": []
}


package/dist/esm/git/index.mjs

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

package/dist/esm/http/client-async.mjs

@@ -0,0 +1,205 @@
+const HttpClientAsyncFacade = Java.type("org.eclipse.dirigible.components.api.http.HttpClientAsyncFacade");
+const SpringBeanProvider = Java.type("org.eclipse.dirigible.components.spring.SpringBeanProvider");
+const httpClient = SpringBeanProvider.getBean(HttpClientAsyncFacade.class);
+class HttpAsyncClient {
+  /**
+   * Executes an asynchronous HTTP GET request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options (e.g., headers, body, params).
+   */
+  getAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.getAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.getAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP POST request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  postAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.postAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.postAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP PUT request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  putAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.putAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.putAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP PATCH request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  patchAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.patchAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.patchAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP DELETE request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  deleteAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.deleteAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.deleteAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP HEAD request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  headAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.headAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.headAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP TRACE request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  traceAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.traceAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.traceAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Initiates the execution of queued asynchronous requests (depending on the underlying Java client's threading model).
+   */
+  execute() {
+    httpClient.execute();
+  }
+}
+function getInstance() {
+  return new HttpAsyncClient();
+}
+;
+function createHttpResponseCallback(httpClient2, successCallback, errorCallback, cancelCallback) {
+  return httpClient2.createCallback(
+    createSuccessCallback(successCallback),
+    createErrorCallback(errorCallback),
+    createCancelCallback(cancelCallback)
+  );
+}
+function createSuccessCallback(callback) {
+  return "(function(httpResponse, isBinary, context) {\nvar response = {};\nresponse.statusCode = httpResponse.getStatusLine().getStatusCode();\nresponse.statusMessage = httpResponse.getStatusLine().getReasonPhrase();\nresponse.protocol = httpResponse.getProtocolVersion();\nresponse.binary = isBinary;\nvar headers = httpResponse.getAllHeaders();\nresponse.headers = [];\nfor (var i = 0; i < headers.length; i ++) {\n    response.headers.push({\n        name: headers[i].getName(),\n        value: headers[i].getValue()\n    });\n}\nvar entity = httpResponse.getEntity();\nif (entity) {\n    var inputStream = entity.getContent();\n    if (isBinary) {\n        // Uses Java IOUtils to read binary data\n        response.data = org.apache.commons.io.IOUtils.toByteArray(inputStream);\n    } else {\n        // Uses Java IOUtils to read text data\n        response.text = org.apache.commons.io.IOUtils.toString(inputStream);\n    }\n}\n(" + callback + ")(response, JSON.parse(context));\n})(__context.get('response'), __context.get('httpClientRequestOptions').isBinary(), __context.get('httpClientRequestOptions').getContext());\n";
+}
+function createErrorCallback(callback) {
+  if (callback) {
+    return "(" + callback + ")(__context.get('exception'))";
+  }
+  return void 0;
+}
+function createCancelCallback(callback) {
+  if (callback) {
+    return "(" + callback + ")()";
+  }
+  return void 0;
+}
+function buildUrl(url, options) {
+  if (options === void 0 || options === null || options.params === void 0 || options.params === null || options.params.length === 0) {
+    return url;
+  }
+  let newUrl = url;
+  for (let i = 0; i < options.params.length; i++) {
+    const param = options.params[i];
+    if (i === 0) {
+      if (newUrl.includes("?")) {
+        newUrl += "&";
+      } else {
+        newUrl += "?";
+      }
+      newUrl += param.name + "=" + param.value;
+    } else {
+      newUrl += "&" + param.name + "=" + param.value;
+    }
+  }
+  return newUrl;
+}
+if (typeof module !== "undefined") {
+  module.exports = { HttpAsyncClient, getInstance };
+}
+export {
+  HttpAsyncClient,
+  getInstance
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/http/client-async.ts"],
  "sourcesContent": ["/**\n * Provides a JavaScript/TypeScript wrapper (Facade) for making asynchronous HTTP requests.\n *\n */\n\n// --- Shared Interfaces (for documentation clarity) ---\n\n/** Defines a single HTTP header, used for both request and response. */\nexport interface HttpClientHeader {\n    /** The name of the header (e.g., 'Content-Type', 'Authorization'). */\n    name: string;\n    /** The value of the header. */\n    value: string;\n}\n\n/** Defines a query parameter that will be appended to the URL. */\nexport interface HttpClientParam {\n    /** The name of the URL query parameter (e.g., 'id'). */\n    name: string;\n    /** The value of the URL query parameter. */\n    value: string;\n}\n\n/** Defines a file to be included in a multi-part form data request. */\nexport interface HttpClientFile {\n    /** The form field name for the file. */\n    name: string;\n    /** The file path or content. */\n    value: string;\n}\n\n/** Configuration options for an HTTP request, mirroring the capabilities of the underlying Java client. */\nexport interface HttpClientRequestOptions {\n    expectContinueEnabled?: boolean;\n    proxyHost?: string;\n    proxyPort?: number;\n    cookieSpec?: string;\n    redirectsEnabled?: boolean;\n    relativeRedirectsAllowed?: boolean;\n    circularRedirectsAllowed?: boolean;\n    maxRedirects?: number;\n    authenticationEnabled?: boolean;\n    targetPreferredAuthSchemes?: string[];\n    proxyPreferredAuthSchemes?: string[];\n    connectionRequestTimeout?: number;\n    connectTimeout?: number;\n    socketTimeout?: number;\n    contentCompressionEnabled?: boolean;\n    sslTrustAllEnabled?: boolean;\n    data?: any[];\n    text?: string;\n    files?: HttpClientFile[];\n    characterEncoding?: string;\n    characterEncodingEnabled?: boolean;\n    contentType?: string;\n    headers?: HttpClientHeader[];\n    params?: HttpClientParam[];\n    binary?: boolean;\n    context?: { [key: string]: any };\n}\n\n/** The structure of the response returned by the HttpClient methods. */\nexport interface HttpClientResponse {\n    /** The HTTP status code (e.g., 200, 404, 500). */\n    statusCode: number;\n    /** The status message returned by the server (e.g., 'OK', 'Not Found'). */\n    statusMessage: string;\n    /** Response body content as an array of bytes (if requested as binary). */\n    data: any[];\n    /** Response body content as a decoded string. */\n    text: string;\n    /** The protocol used (e.g., 'HTTP/1.1'). */\n    protocol: string;\n    /** Indicates if the response was processed as binary data. */\n    binary: boolean;\n    /** Array of all headers received in the response. */\n    headers: HttpClientHeader[]\n}\n\n// --- Asynchronous Client Interfaces ---\n\n/**\n * Defines the callback structure for asynchronous requests.\n * Note: Callbacks are provided as strings containing executable JavaScript code.\n */\nexport interface HttpClientAsyncConfig {\n    /**\n     * Mandatory success callback as a **string of JavaScript code**.\n     * It will be executed with signature: `(response: HttpClientResponse, context: { [key: string]: any }) => void`\n     */\n    success: string;\n    /**\n     * Optional error callback as a **string of JavaScript code**.\n     * It will be executed with signature: `(exception: any) => void`\n     */\n    error?: string;\n    /**\n     * Optional cancel callback as a **string of JavaScript code**.\n     * It will be executed with signature: `() => void`\n     */\n    cancel?: string;\n}\n\n\n// --- Java Type Imports (Crucial for JVM integration) ---\n\n/** Imports the native Java class responsible for asynchronous HTTP execution. */\nconst HttpClientAsyncFacade = Java.type(\"org.eclipse.dirigible.components.api.http.HttpClientAsyncFacade\");\n\n/** Imports the native Java class for retrieving Spring-managed beans. */\nconst SpringBeanProvider = Java.type(\"org.eclipse.dirigible.components.spring.SpringBeanProvider\");\n\n/** Retrieves the singleton instance of the asynchronous HTTP client from the Spring context. */\nconst httpClient = SpringBeanProvider.getBean(HttpClientAsyncFacade.class);\n\n\n/**\n * The asynchronous HTTP client class. All request methods return immediately\n * and execute callbacks upon completion.\n */\nexport class HttpAsyncClient {\n\n    /**\n     * Executes an asynchronous HTTP GET request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options (e.g., headers, body, params).\n     */\n\tgetAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.getAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.getAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP POST request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\tpostAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.postAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.postAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP PUT request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\tputAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.putAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.putAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP PATCH request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\tpatchAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.patchAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.patchAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP DELETE request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\tdeleteAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.deleteAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.deleteAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP HEAD request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\theadAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.headAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.headAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP TRACE request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\ttraceAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.traceAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.traceAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Initiates the execution of queued asynchronous requests (depending on the underlying Java client's threading model).\n     */\n\texecute(): void {\n\t\thttpClient.execute();\n\t};\n}\n\n/**\n * Factory function to retrieve a new instance of the asynchronous client.\n * @returns A new instance of HttpAsyncClient.\n */\nexport function getInstance(): HttpAsyncClient {\n\treturn new HttpAsyncClient();\n};\n\n/**\n * Creates a native Java callback object that wraps the JavaScript success, error, and cancel callbacks.\n * This function uses the underlying Java HTTP client instance to generate the final callback object.\n * @param httpClient The Java HttpClientAsyncFacade instance.\n * @param successCallback JS code string for success.\n * @param errorCallback JS code string for error.\n * @param cancelCallback JS code string for cancel.\n * @returns A Java callback object.\n */\nfunction createHttpResponseCallback(httpClient: any, successCallback: string, errorCallback?: string, cancelCallback?: string): any {\n\treturn httpClient.createCallback(\n\t\tcreateSuccessCallback(successCallback),\n\t\tcreateErrorCallback(errorCallback),\n\t\tcreateCancelCallback(cancelCallback)\n\t);\n}\n\n/**\n * Generates the raw JavaScript string that will be executed in the JVM environment upon successful request completion.\n * This string handles parsing the Java HTTP response object and executing the user's defined callback function.\n * @param callback The user-provided success callback function code string.\n * @returns The complex JavaScript string for the success handler.\n */\nfunction createSuccessCallback(callback: string): string {\n\t// Note: This string uses Java utility classes (org.apache.commons.io.IOUtils) and context variables \n    // (__context) that are available in the specific JVM environment.\n    \n    // The structure maps the Java HTTP Response object into the standard HttpClientResponse interface.\n\treturn \"(function(httpResponse, isBinary, context) {\\n\"\n\t\t+ \"var response = {};\\n\"\n\t\t+ \"response.statusCode = httpResponse.getStatusLine().getStatusCode();\\n\"\n\t\t+ \"response.statusMessage = httpResponse.getStatusLine().getReasonPhrase();\\n\"\n\t\t+ \"response.protocol = httpResponse.getProtocolVersion();\\n\"\n\t\t+ \"response.binary = isBinary;\\n\"\n\n\t\t+ \"var headers = httpResponse.getAllHeaders();\\n\"\n\t\t+ \"response.headers = [];\\n\"\n\t\t+ \"for (var i = 0; i < headers.length; i ++) {\\n\"\n\t\t+ \"    response.headers.push({\\n\"\n\t\t+ \"        name: headers[i].getName(),\\n\"\n\t\t+ \"        value: headers[i].getValue()\\n\"\n\t\t+ \"    });\\n\"\n\t\t+ \"}\\n\"\n\n\t\t+ \"var entity = httpResponse.getEntity();\\n\"\n\t\t+ \"if (entity) {\\n\"\n\t\t+ \"    var inputStream = entity.getContent();\\n\"\n\t\t+ \"    if (isBinary) {\\n\"\n\t\t+ \"        // Uses Java IOUtils to read binary data\\n\"\n\t\t+ \"        response.data = org.apache.commons.io.IOUtils.toByteArray(inputStream);\\n\"\n\t\t+ \"    } else {\\n\"\n\t\t+ \"        // Uses Java IOUtils to read text data\\n\"\n\t\t+ \"        response.text = org.apache.commons.io.IOUtils.toString(inputStream);\\n\"\n\t\t+ \"    }\\n\"\n\t\t+ \"}\\n\"\n\n\t\t+ \"(\" + callback + \")(response, JSON.parse(context));\\n\"\n\t\t+ \"})(__context.get('response'), __context.get('httpClientRequestOptions').isBinary(), __context.get('httpClientRequestOptions').getContext());\\n\";\n}\n\n/**\n * Generates the raw JavaScript string for the error callback.\n * @param callback The user-provided error callback function code string.\n * @returns The JavaScript string for the error handler, or undefined.\n */\nfunction createErrorCallback(callback?: string): string | undefined {\n\tif (callback) {\n\t\treturn \"(\" + callback + \")(__context.get('exception'))\";\n\t}\n    return undefined;\n}\n\n/**\n * Generates the raw JavaScript string for the cancel callback.\n * @param callback The user-provided cancel callback function code string.\n * @returns The JavaScript string for the cancel handler, or undefined.\n */\nfunction createCancelCallback(callback?: string): string | undefined {\n\tif (callback) {\n\t\treturn \"(\" + callback + \")()\";\n\t}\n    return undefined;\n}\n\n/**\n * Builds the final URL by appending all query parameters defined in options.params.\n * The parameters are not removed from the options object as they are for the synchronous client,\n * since the options are passed as JSON string to the facade anyway.\n * @param url The base URL.\n * @param options The request options which may contain `params`.\n * @returns The URL with appended query parameters.\n */\nfunction buildUrl(url: string, options?: HttpClientRequestOptions): string {\n\tif (options === undefined || options === null || options.params === undefined || options.params === null || options.params.length === 0) {\n\t\treturn url;\n\t}\n\tlet newUrl = url;\n\tfor (let i = 0; i < options.params.length; i ++) {\n        const param = options.params[i];\n\t\tif (i === 0) {\n            // Check if URL already contains '?' and use '&' if so (improves robustness)\n            if (newUrl.includes('?')) {\n                newUrl += '&';\n            } else {\n                newUrl += '?';\n            }\n\t\t\tnewUrl += param.name + '=' + param.value;\n\t\t} else {\n\t\t\tnewUrl += '&' + param.name + '=' + param.value;\n\t\t}\n\t}\n\treturn newUrl;\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = { HttpAsyncClient, getInstance };\n}"],
  "mappings": "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",
  "names": ["httpClient"]
}
