@aerokit/sdk 12.44.0

package/dist/cjs/extensions/extensions.js

@@ -0,0 +1,108 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var extensions_exports = {};
+__export(extensions_exports, {
+  Extensions: () => Extensions
+});
+module.exports = __toCommonJS(extensions_exports);
+const ExtensionsFacade = Java.type("org.eclipse.dirigible.components.api.extensions.ExtensionsFacade");
+class Extensions {
+  /**
+   * Retrieves the list of extension module paths registered for a specific extension point.
+   *
+   * @param extensionPoint The unique identifier of the extension point (e.g., "my.extension.point").
+   * @returns An array of string paths (modules) registered for the given extension point.
+   */
+  static getExtensions(extensionPoint) {
+    const extensions = ExtensionsFacade.getExtensions(extensionPoint);
+    return JSON.parse(JSON.stringify(extensions));
+  }
+  /**
+   * Retrieves all available extension point identifiers.
+   *
+   * @returns An array of strings representing all registered extension point IDs.
+   */
+  static getExtensionPoints() {
+    const extensionPoints = ExtensionsFacade.getExtensionPoints();
+    return JSON.parse(JSON.stringify(extensionPoints));
+  }
+  /**
+   * Loads extension modules registered for a specific extension point.
+   * It handles both synchronous (require) and asynchronous (import) loading.
+   *
+   * @param extensionPoint The unique identifier of the extension point.
+   * @param requiredFunctions An optional list of function names that the extension module must export to be included.
+   * @param throwError If true, throws an error on failure; otherwise, logs the error and continues.
+   * @returns A Promise that resolves to an array of successfully loaded and validated extension modules (exports).
+   */
+  static async loadExtensionModules(extensionPoint, requiredFunctions = [], throwError = false) {
+    const extensionModules = [];
+    const extensions = this.getExtensions(extensionPoint);
+    for (let i = 0; i < extensions?.length; i++) {
+      const module2 = extensions[i];
+      try {
+        let extensionModule;
+        try {
+          extensionModule = dirigibleRequire(module2);
+        } catch (e) {
+          extensionModule = await import(`../../../../${module2}`);
+        }
+        if (!extensionModule || Object.keys(extensionModule).length === 0) {
+          const errorMessage = `Extension '${module2}' for extension point '${extensionPoint}' doesn't provide any function(s) or was not properly loaded, consider publishing it.`;
+          this.logError(throwError, errorMessage);
+          continue;
+        }
+        let requiredFunctionsFound = true;
+        requiredFunctions.forEach((f) => {
+          requiredFunctionsFound &&= typeof extensionModule[f] === "function";
+        });
+        if (!requiredFunctionsFound) {
+          const errorMessage = `Extension '${module2}' for extension point '${extensionPoint}', doesn't provide the following required function(s): [
+	${requiredFunctions.join("(),\n	")}()
+]`;
+          this.logError(throwError, errorMessage);
+          continue;
+        }
+        extensionModules.push(extensionModule);
+      } catch (e) {
+        const errorMessage = `Error occurred while importing extension '${module2}' for extension point '${extensionPoint}'.`;
+        this.logError(throwError, errorMessage, e);
+      }
+    }
+    return extensionModules;
+  }
+  /**
+   * Logs an error to the console and optionally throws an exception.
+   * @param throwError If true, an exception is thrown.
+   * @param errorData The data/message to log and/or use for the error message.
+   */
+  static logError(throwError, ...errorData) {
+    console.error(errorData);
+    if (throwError) {
+      throw new Error(errorData[0]);
+    }
+  }
+  /** Alias for loadExtensionModules */
+  static async load(extensionPoint, requiredFunctions = [], throwError = false) {
+    return Extensions.loadExtensionModules(extensionPoint, requiredFunctions, throwError);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Extensions;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/extensions/extensions.ts"],
  "sourcesContent": ["/**\n * API Extensions\n *\n */\n\nconst ExtensionsFacade = Java.type(\"org.eclipse.dirigible.components.api.extensions.ExtensionsFacade\");\n\n/**\n * Provides functionality for discovering and loading extensions defined\n * against the Dirigible extension model.\n */\nexport class Extensions {\n\n\t/**\n\t * Retrieves the list of extension module paths registered for a specific extension point.\n\t *\n\t * @param extensionPoint The unique identifier of the extension point (e.g., \"my.extension.point\").\n\t * @returns An array of string paths (modules) registered for the given extension point.\n\t */\n\tpublic static getExtensions(extensionPoint: string): string[] {\n\t\tconst extensions = ExtensionsFacade.getExtensions(extensionPoint);\n\t\t// The native facade returns a Java List, which is converted to JSON string \n\t\t// and then parsed to a JavaScript array.\n\t\treturn JSON.parse(JSON.stringify(extensions));\n\t}\n\n\t/**\n\t * Retrieves all available extension point identifiers.\n\t *\n\t * @returns An array of strings representing all registered extension point IDs.\n\t */\n\tpublic static getExtensionPoints(): string[] {\n\t\tconst extensionPoints = ExtensionsFacade.getExtensionPoints();\n\t\treturn JSON.parse(JSON.stringify(extensionPoints));\n\t}\n\n\t/**\n\t * Loads extension modules registered for a specific extension point.\n\t * It handles both synchronous (require) and asynchronous (import) loading.\n\t *\n\t * @param extensionPoint The unique identifier of the extension point.\n\t * @param requiredFunctions An optional list of function names that the extension module must export to be included.\n\t * @param throwError If true, throws an error on failure; otherwise, logs the error and continues.\n\t * @returns A Promise that resolves to an array of successfully loaded and validated extension modules (exports).\n\t */\n\tpublic static async loadExtensionModules(extensionPoint: string, requiredFunctions: string[] = [], throwError: boolean = false): Promise<any[]> {\n\t\tconst extensionModules = [];\n\t\tconst extensions: string[] = this.getExtensions(extensionPoint);\n\n\t\tfor (let i = 0; i < extensions?.length; i++) {\n\t\t\tconst module: string = extensions[i];\n\t\t\ttry {\n\t\t\t\tlet extensionModule: any;\n\t\t\t\ttry {\n\t\t\t\t\t// Fallback to native require() (Dirigible-specific)\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\textensionModule = dirigibleRequire(module);\n\t\t\t\t} catch (e) {\n\t\t\t\t\t// Fallback to dynamic import (for environments supporting ESM/Async)\n\t\t\t\t\textensionModule = await import(`../../../../${module}`);\n\t\t\t\t}\n\n\t\t\t\tif (!extensionModule || Object.keys(extensionModule).length === 0) {\n\t\t\t\t\tconst errorMessage = `Extension '${module}' for extension point '${extensionPoint}' doesn't provide any function(s) or was not properly loaded, consider publishing it.`;\n\t\t\t\t\tthis.logError(throwError, errorMessage);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tlet requiredFunctionsFound = true;\n\t\t\t\trequiredFunctions.forEach(f => {\n\t\t\t\t\trequiredFunctionsFound &&= typeof extensionModule[f] === \"function\";\n\t\t\t\t});\n\n\t\t\t\tif (!requiredFunctionsFound) {\n\t\t\t\t\tconst errorMessage = `Extension '${module}' for extension point '${extensionPoint}', doesn't provide the following required function(s): [\\n\\t${requiredFunctions.join(\"(),\\n\\t\")}()\\n]`;\n\t\t\t\t\tthis.logError(throwError, errorMessage);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\textensionModules.push(extensionModule);\n\t\t\t} catch (e) {\n\t\t\t\tconst errorMessage = `Error occurred while importing extension '${module}' for extension point '${extensionPoint}'.`;\n\t\t\t\tthis.logError(throwError, errorMessage, e);\n\t\t\t}\n\t\t}\n\n\t\treturn extensionModules;\n\t}\n\n\t/**\n\t * Logs an error to the console and optionally throws an exception.\n\t * @param throwError If true, an exception is thrown.\n\t * @param errorData The data/message to log and/or use for the error message.\n\t */\n\tprivate static logError(throwError: boolean, ...errorData: any[]): void {\n\t\tconsole.error(errorData);\n\t\tif (throwError) {\n\t\t\tthrow new Error(errorData[0]);\n\t\t}\n\t}\n\t\n\t/** Alias for loadExtensionModules */\n\tpublic static async load(extensionPoint: string, requiredFunctions: string[] = [], throwError: boolean = false): Promise<any[]> {\n\t\treturn Extensions.loadExtensionModules(extensionPoint, requiredFunctions, throwError);\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Extensions;\n}"],
  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,MAAM,mBAAmB,KAAK,KAAK,kEAAkE;AAM9F,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQvB,OAAc,cAAc,gBAAkC;AAC7D,UAAM,aAAa,iBAAiB,cAAc,cAAc;AAGhE,WAAO,KAAK,MAAM,KAAK,UAAU,UAAU,CAAC;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,qBAA+B;AAC5C,UAAM,kBAAkB,iBAAiB,mBAAmB;AAC5D,WAAO,KAAK,MAAM,KAAK,UAAU,eAAe,CAAC;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,aAAoB,qBAAqB,gBAAwB,oBAA8B,CAAC,GAAG,aAAsB,OAAuB;AAC/I,UAAM,mBAAmB,CAAC;AAC1B,UAAM,aAAuB,KAAK,cAAc,cAAc;AAE9D,aAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AAC5C,YAAMA,UAAiB,WAAW,CAAC;AACnC,UAAI;AACH,YAAI;AACJ,YAAI;AAGH,4BAAkB,iBAAiBA,OAAM;AAAA,QAC1C,SAAS,GAAG;AAEX,4BAAkB,MAAM,OAAO,eAAeA,OAAM;AAAA,QACrD;AAEA,YAAI,CAAC,mBAAmB,OAAO,KAAK,eAAe,EAAE,WAAW,GAAG;AAClE,gBAAM,eAAe,cAAcA,OAAM,0BAA0B,cAAc;AACjF,eAAK,SAAS,YAAY,YAAY;AACtC;AAAA,QACD;AAEA,YAAI,yBAAyB;AAC7B,0BAAkB,QAAQ,OAAK;AAC9B,qCAA2B,OAAO,gBAAgB,CAAC,MAAM;AAAA,QAC1D,CAAC;AAED,YAAI,CAAC,wBAAwB;AAC5B,gBAAM,eAAe,cAAcA,OAAM,0BAA0B,cAAc;AAAA,GAA+D,kBAAkB,KAAK,QAAS,CAAC;AAAA;AACjL,eAAK,SAAS,YAAY,YAAY;AACtC;AAAA,QACD;AAEA,yBAAiB,KAAK,eAAe;AAAA,MACtC,SAAS,GAAG;AACX,cAAM,eAAe,6CAA6CA,OAAM,0BAA0B,cAAc;AAChH,aAAK,SAAS,YAAY,cAAc,CAAC;AAAA,MAC1C;AAAA,IACD;AAEA,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAe,SAAS,eAAwB,WAAwB;AACvE,YAAQ,MAAM,SAAS;AACvB,QAAI,YAAY;AACf,YAAM,IAAI,MAAM,UAAU,CAAC,CAAC;AAAA,IAC7B;AAAA,EACD;AAAA;AAAA,EAGA,aAAoB,KAAK,gBAAwB,oBAA8B,CAAC,GAAG,aAAsB,OAAuB;AAC/H,WAAO,WAAW,qBAAqB,gBAAgB,mBAAmB,UAAU;AAAA,EACrF;AACD;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": ["module"]
}


package/dist/cjs/extensions/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var extensions_exports = {};
+__export(extensions_exports, {
+  decorators: () => decorators,
+  extensions: () => import_extensions.Extensions
+});
+module.exports = __toCommonJS(extensions_exports);
+__reExport(extensions_exports, require("./extensions"), module.exports);
+var import_extensions = require("./extensions");
+var decorators = __toESM(require("./decorators"));
+__reExport(extensions_exports, require("./decorators"), module.exports);
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2V4dGVuc2lvbnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCAqIGZyb20gXCIuL2V4dGVuc2lvbnNcIjtcbmV4cG9ydCB7IEV4dGVuc2lvbnMgYXMgZXh0ZW5zaW9ucyB9IGZyb20gXCIuL2V4dGVuc2lvbnNcIjtcbmV4cG9ydCAqIGFzIGRlY29yYXRvcnMgZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiOyJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSwrQkFBYyx5QkFBZDtBQUNBLHdCQUF5QztBQUN6QyxpQkFBNEI7QUFDNUIsK0JBQWMseUJBSGQ7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/cjs/git/client.js

@@ -0,0 +1,277 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  Client: () => Client
+});
+module.exports = __toCommonJS(client_exports);
+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;
+}
+//# 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/cjs/git/index.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var git_exports = {};
+__export(git_exports, {
+  client: () => import_client.Client
+});
+module.exports = __toCommonJS(git_exports);
+__reExport(git_exports, require("./client"), module.exports);
+var import_client = require("./client");
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2dpdC9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0ICogZnJvbSBcIi4vY2xpZW50XCI7XG5leHBvcnQgeyBDbGllbnQgYXMgY2xpZW50IH0gZnJvbSBcIi4vY2xpZW50XCI7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsd0JBQWMscUJBQWQ7QUFDQSxvQkFBaUM7IiwKICAibmFtZXMiOiBbXQp9Cg==