@aerokit/sdk 12.44.0

package/dist/cjs/platform/registry.js

@@ -0,0 +1,319 @@
+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 registry_exports = {};
+__export(registry_exports, {
+  Artefact: () => Artefact,
+  ArtefactInformation: () => ArtefactInformation,
+  Directory: () => Directory,
+  Registry: () => Registry
+});
+module.exports = __toCommonJS(registry_exports);
+var import_bytes = require("@aerokit/sdk/io/bytes");
+var import_repository = require("@aerokit/sdk/platform/repository");
+const RegistryFacade = Java.type("org.eclipse.dirigible.components.api.platform.RegistryFacade");
+class Registry {
+  /**
+   * Retrieves the content of a registry resource at the given path, converting it into a
+   * JavaScript-friendly byte array format.
+   *
+   * @param {string} path The absolute path to the resource (e.g., "/registry/public/myFile.txt").
+   * @returns {any[]} The resource content as a JavaScript byte array.
+   */
+  static getContent(path) {
+    return import_bytes.Bytes.toJavaScriptBytes(RegistryFacade.getContent(path));
+  }
+  /**
+   * Retrieves the content of a registry resource at the given path in its native Java byte array format.
+   *
+   * @param {string} path The absolute path to the resource.
+   * @returns {any[]} The resource content as a native Java byte array.
+   */
+  static getContentNative(path) {
+    return RegistryFacade.getContent(path);
+  }
+  /**
+   * Retrieves the content of a registry resource at the given path as a string.
+   *
+   * @param {string} path The absolute path to the resource.
+   * @returns {string} The resource content as plain text.
+   */
+  static getText(path) {
+    return RegistryFacade.getText(path);
+  }
+  /**
+   * Searches the registry starting from a given path for resources matching a glob pattern.
+   *
+   * @param {string} path The starting path for the search.
+   * @param {string} pattern The glob pattern to match resource names against (e.g., "*.js").
+   * @returns {string[]} An array of registry paths (strings) that match the search criteria.
+   */
+  static find(path, pattern) {
+    return JSON.parse(RegistryFacade.find(path, pattern));
+  }
+  /**
+   * Gets the root directory object for the public registry space.
+   *
+   * @returns {Directory} A Directory instance representing the root public collection.
+   */
+  static getRoot() {
+    return new Directory(import_repository.Repository.getCollection("/registry/public"));
+  }
+}
+class Artefact {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the repository resource.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the artefact (file name).
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full registry path of the artefact.
+   * @returns {string} The registry path.
+   */
+  getPath() {
+    return RegistryFacade.toRegistryPath(this.native.getPath());
+  }
+  /**
+   * Gets the parent directory of this artefact.
+   * @returns {Directory} The parent Directory instance.
+   */
+  getParent() {
+    const collectionInstance = this.native.getParent();
+    return new Directory(collectionInstance);
+  }
+  /**
+   * Gets detailed metadata about the artefact.
+   * @returns {ArtefactInformation} The metadata object.
+   */
+  getInformation() {
+    const informationInstance = this.native.getInformation();
+    return new ArtefactInformation(informationInstance);
+  }
+  /**
+   * Checks if the artefact currently exists in the registry.
+   * @returns {boolean} True if the artefact exists, false otherwise.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if the artefact (file) is empty (has zero size).
+   * @returns {boolean} True if the content is empty, false otherwise.
+   */
+  isEmpty() {
+    return this.native.isEmpty();
+  }
+  /**
+   * Gets the content of the artefact as a text string.
+   * @returns {string} The text content.
+   */
+  getText() {
+    return import_bytes.Bytes.byteArrayToText(this.getContent());
+  }
+  /**
+   * Gets the content of the artefact as a JavaScript-friendly byte array.
+   * @returns {any[]} The content bytes.
+   */
+  getContent() {
+    const nativeContent = this.native.getContent();
+    return import_bytes.Bytes.toJavaScriptBytes(nativeContent);
+  }
+  /**
+   * Gets the content of the artefact as its native Java byte array representation.
+   * @returns {any[]} The content bytes.
+   */
+  getContentNative() {
+    return this.native.getContent();
+  }
+  /**
+   * Checks if the artefact content is determined to be binary.
+   * @returns {boolean} True if binary, false if text.
+   */
+  isBinary() {
+    return this.native.isBinary();
+  }
+  /**
+   * Gets the content type (MIME type) of the artefact.
+   * @returns {string} The content type string.
+   */
+  getContentType() {
+    return this.native.getContentType();
+  }
+}
+class Directory {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance representing the repository collection.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the directory (folder name).
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full registry path of the directory.
+   * @returns {string} The registry path.
+   */
+  getPath() {
+    return RegistryFacade.toRegistryPath(this.native.getPath());
+  }
+  /**
+   * Gets the parent directory.
+   * @returns {Directory} The parent Directory instance.
+   */
+  getParent() {
+    const collectionInstance = this.native.getParent();
+    return new Directory(collectionInstance);
+  }
+  /**
+   * Gets detailed metadata about the directory.
+   * @returns {ArtefactInformation} The metadata object.
+   */
+  getInformation() {
+    const informationInstance = this.native.getInformation();
+    return new ArtefactInformation(informationInstance);
+  }
+  /**
+   * Checks if the directory currently exists in the registry.
+   * @returns {boolean} True if the directory exists, false otherwise.
+   */
+  exists() {
+    return this.native.exists();
+  }
+  /**
+   * Checks if the directory is empty (contains no files or sub-directories).
+   * @returns {boolean} True if empty, false otherwise.
+   */
+  isEmpty() {
+    return this.native.isEmpty();
+  }
+  /**
+   * Gets the names of all sub-directories within this directory.
+   * @returns {string[]} An array of sub-directory names.
+   */
+  getDirectoriesNames() {
+    return this.native.getCollectionsNames();
+  }
+  /**
+   * Gets a specific sub-directory by name.
+   * @param {string} name The name of the sub-directory.
+   * @returns {Directory} The child Directory instance.
+   */
+  getDirectory(name) {
+    const collectionInstance = this.native.getCollection(RegistryFacade.toResourcePath(name));
+    return new Directory(collectionInstance);
+  }
+  /**
+   * Gets the names of all files (artefacts) within this directory.
+   * @returns {string[]} An array of artefact names.
+   */
+  getArtefactsNames() {
+    return this.native.getResourcesNames();
+  }
+  /**
+   * Gets a specific file (artefact) by name.
+   * @param {string} name The name of the artefact.
+   * @returns {Artefact} The child Artefact instance.
+   */
+  getArtefact(name) {
+    const resourceInstance = this.native.getResource(RegistryFacade.toResourcePath(name));
+    return new Artefact(resourceInstance);
+  }
+}
+class ArtefactInformation {
+  /**
+   * @constructor
+   * @param {any} native The native Java object instance holding the artefact information.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the resource.
+   * @returns {string} The name.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the full registry path of the resource.
+   * @returns {string} The registry path.
+   */
+  getPath() {
+    return RegistryFacade.toRegistryPath(this.native.getPath());
+  }
+  /**
+   * Gets the access permissions for the resource (typically an integer bitmask).
+   * @returns {number} The permissions value.
+   */
+  getPermissions() {
+    return this.native.getPermissions();
+  }
+  /**
+   * Gets the size of the resource content in bytes.
+   * @returns {number} The size in bytes.
+   */
+  getSize() {
+    return this.native.getSize();
+  }
+  /**
+   * Gets the user who created the resource.
+   * @returns {string} The creator's name.
+   */
+  getCreatedBy() {
+    return this.native.getCreatedBy();
+  }
+  /**
+   * Gets the creation timestamp.
+   * @returns {Date} The creation date and time.
+   */
+  getCreatedAt() {
+    return this.native.getCreatedAt();
+  }
+  /**
+   * Gets the user who last modified the resource.
+   * @returns {string} The modifier's name.
+   */
+  getModifiedBy() {
+    return this.native.getModifiedBy();
+  }
+  /**
+   * Gets the last modification timestamp.
+   * @returns {Date} The modification date and time.
+   */
+  getModifiedAt() {
+    return this.native.getModifiedAt();
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Registry;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/platform/registry.ts"],
  "sourcesContent": ["/**\n * Provides a set of utilities and data structures for interacting with the platform's\n * Registry/Repository, which manages files and directories (Artefacts and Collections).\n */\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\nimport { Repository } from \"@aerokit/sdk/platform/repository\";\nconst RegistryFacade = Java.type(\"org.eclipse.dirigible.components.api.platform.RegistryFacade\");\n\n/**\n * @class Registry\n * @description Static utility class providing high-level access to the RegistryFacade for\n * retrieving content and metadata by path.\n */\nexport class Registry {\n\n\t/**\n\t * Retrieves the content of a registry resource at the given path, converting it into a\n\t * JavaScript-friendly byte array format.\n\t *\n\t * @param {string} path The absolute path to the resource (e.g., \"/registry/public/myFile.txt\").\n\t * @returns {any[]} The resource content as a JavaScript byte array.\n\t */\n\tpublic static getContent(path: string): any[] {\n\t\treturn Bytes.toJavaScriptBytes(RegistryFacade.getContent(path));\n\t}\n\n\t/**\n\t * Retrieves the content of a registry resource at the given path in its native Java byte array format.\n\t *\n\t * @param {string} path The absolute path to the resource.\n\t * @returns {any[]} The resource content as a native Java byte array.\n\t */\n\tpublic static getContentNative(path: string): any[] {\n\t\treturn RegistryFacade.getContent(path);\n\t}\n\n\t/**\n\t * Retrieves the content of a registry resource at the given path as a string.\n\t *\n\t * @param {string} path The absolute path to the resource.\n\t * @returns {string} The resource content as plain text.\n\t */\n\tpublic static getText(path: string): string {\n\t\treturn RegistryFacade.getText(path);\n\t}\n\n\t/**\n\t * Searches the registry starting from a given path for resources matching a glob pattern.\n\t *\n\t * @param {string} path The starting path for the search.\n\t * @param {string} pattern The glob pattern to match resource names against (e.g., \"*.js\").\n\t * @returns {string[]} An array of registry paths (strings) that match the search criteria.\n\t */\n\tpublic static find(path: string, pattern: string): string[] {\n\t\treturn JSON.parse(RegistryFacade.find(path, pattern));\n\t}\n\n\t/**\n\t * Gets the root directory object for the public registry space.\n\t *\n\t * @returns {Directory} A Directory instance representing the root public collection.\n\t */\n\tpublic static getRoot(): Directory {\n\t\treturn new Directory(Repository.getCollection(\"/registry/public\"));\n\t}\n}\n\n/**\n * @class Artefact\n * @description Represents a file or resource (non-collection) within the Registry.\n */\nexport class Artefact {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance representing the repository resource.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the artefact (file name).\n\t * @returns {string} The name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Gets the full registry path of the artefact.\n\t * @returns {string} The registry path.\n\t */\n\tpublic getPath(): string {\n\t\treturn RegistryFacade.toRegistryPath(this.native.getPath());\n\t}\n\n\t/**\n\t * Gets the parent directory of this artefact.\n\t * @returns {Directory} The parent Directory instance.\n\t */\n\tpublic getParent(): Directory {\n\t\tconst collectionInstance = this.native.getParent();\n\t\treturn new Directory(collectionInstance);\n\t}\n\n\t/**\n\t * Gets detailed metadata about the artefact.\n\t * @returns {ArtefactInformation} The metadata object.\n\t */\n\tpublic getInformation(): ArtefactInformation {\n\t\tconst informationInstance = this.native.getInformation();\n\t\treturn new ArtefactInformation(informationInstance);\n\t}\n\n\t/**\n\t * Checks if the artefact currently exists in the registry.\n\t * @returns {boolean} True if the artefact exists, false otherwise.\n\t */\n\tpublic exists(): boolean {\n\t\treturn this.native.exists();\n\t}\n\n\t/**\n\t * Checks if the artefact (file) is empty (has zero size).\n\t * @returns {boolean} True if the content is empty, false otherwise.\n\t */\n\tpublic isEmpty(): boolean {\n\t\treturn this.native.isEmpty();\n\t}\n\n\t/**\n\t * Gets the content of the artefact as a text string.\n\t * @returns {string} The text content.\n\t */\n\tpublic getText(): string {\n\t\treturn Bytes.byteArrayToText(this.getContent());\n\t}\n\n\t/**\n\t * Gets the content of the artefact as a JavaScript-friendly byte array.\n\t * @returns {any[]} The content bytes.\n\t */\n\tpublic getContent(): any[] {\n\t\tconst nativeContent = this.native.getContent();\n\t\treturn Bytes.toJavaScriptBytes(nativeContent);\n\t}\n\n\t/**\n\t * Gets the content of the artefact as its native Java byte array representation.\n\t * @returns {any[]} The content bytes.\n\t */\n\tpublic getContentNative(): any[] {\n\t\treturn this.native.getContent();\n\t}\n\n\t/**\n\t * Checks if the artefact content is determined to be binary.\n\t * @returns {boolean} True if binary, false if text.\n\t */\n\tpublic isBinary(): boolean {\n\t\treturn this.native.isBinary();\n\t}\n\n\t/**\n\t * Gets the content type (MIME type) of the artefact.\n\t * @returns {string} The content type string.\n\t */\n\tpublic getContentType(): string {\n\t\treturn this.native.getContentType();\n\t}\n}\n\n/**\n * @class Directory\n * @description Represents a collection or folder within the Registry.\n */\nexport class Directory {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance representing the repository collection.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the directory (folder name).\n\t * @returns {string} The name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Gets the full registry path of the directory.\n\t * @returns {string} The registry path.\n\t */\n\tpublic getPath(): string {\n\t\treturn RegistryFacade.toRegistryPath(this.native.getPath());\n\t}\n\n\t/**\n\t * Gets the parent directory.\n\t * @returns {Directory} The parent Directory instance.\n\t */\n\tpublic getParent(): Directory {\n\t\tconst collectionInstance = this.native.getParent();\n\t\treturn new Directory(collectionInstance);\n\t}\n\n\t/**\n\t * Gets detailed metadata about the directory.\n\t * @returns {ArtefactInformation} The metadata object.\n\t */\n\tpublic getInformation(): ArtefactInformation {\n\t\tconst informationInstance = this.native.getInformation();\n\t\treturn new ArtefactInformation(informationInstance);\n\t}\n\n\t/**\n\t * Checks if the directory currently exists in the registry.\n\t * @returns {boolean} True if the directory exists, false otherwise.\n\t */\n\tpublic exists(): boolean {\n\t\treturn this.native.exists();\n\t}\n\n\t/**\n\t * Checks if the directory is empty (contains no files or sub-directories).\n\t * @returns {boolean} True if empty, false otherwise.\n\t */\n\tpublic isEmpty(): boolean {\n\t\treturn this.native.isEmpty();\n\t}\n\n\t/**\n\t * Gets the names of all sub-directories within this directory.\n\t * @returns {string[]} An array of sub-directory names.\n\t */\n\tpublic getDirectoriesNames(): string[] {\n\t\treturn this.native.getCollectionsNames();\n\t}\n\n\t/**\n\t * Gets a specific sub-directory by name.\n\t * @param {string} name The name of the sub-directory.\n\t * @returns {Directory} The child Directory instance.\n\t */\n\tpublic getDirectory(name: string): Directory {\n\t\tconst collectionInstance = this.native.getCollection(RegistryFacade.toResourcePath(name));\n\t\treturn new Directory(collectionInstance);\n\t}\n\n\t/**\n\t * Gets the names of all files (artefacts) within this directory.\n\t * @returns {string[]} An array of artefact names.\n\t */\n\tpublic getArtefactsNames(): string[] {\n\t\treturn this.native.getResourcesNames();\n\t}\n\n\t/**\n\t * Gets a specific file (artefact) by name.\n\t * @param {string} name The name of the artefact.\n\t * @returns {Artefact} The child Artefact instance.\n\t */\n\tpublic getArtefact(name: string): Artefact {\n\t\tconst resourceInstance = this.native.getResource(RegistryFacade.toResourcePath(name));\n\t\treturn new Artefact(resourceInstance);\n\t}\n\n}\n\n/**\n * @class ArtefactInformation\n * @description Represents detailed metadata (creation date, size, permissions, etc.) for a\n * Directory or Artefact.\n */\nexport class ArtefactInformation {\n\tprivate readonly native: any;\n\n\t/**\n\t * @constructor\n\t * @param {any} native The native Java object instance holding the artefact information.\n\t */\n\tconstructor(native: any) {\n\t\tthis.native = native;\n\t}\n\n\t/**\n\t * Gets the name of the resource.\n\t * @returns {string} The name.\n\t */\n\tpublic getName(): string {\n\t\treturn this.native.getName();\n\t}\n\n\t/**\n\t * Gets the full registry path of the resource.\n\t * @returns {string} The registry path.\n\t */\n\tpublic getPath(): string {\n\t\treturn RegistryFacade.toRegistryPath(this.native.getPath());\n\t}\n\n\t/**\n\t * Gets the access permissions for the resource (typically an integer bitmask).\n\t * @returns {number} The permissions value.\n\t */\n\tpublic getPermissions(): number {\n\t\treturn this.native.getPermissions();\n\t}\n\n\t/**\n\t * Gets the size of the resource content in bytes.\n\t * @returns {number} The size in bytes.\n\t */\n\tpublic getSize(): number {\n\t\treturn this.native.getSize();\n\t}\n\n\t/**\n\t * Gets the user who created the resource.\n\t * @returns {string} The creator's name.\n\t */\n\tpublic getCreatedBy(): string {\n\t\treturn this.native.getCreatedBy();\n\t}\n\n\t/**\n\t * Gets the creation timestamp.\n\t * @returns {Date} The creation date and time.\n\t */\n\tpublic getCreatedAt(): Date {\n\t\treturn this.native.getCreatedAt();\n\t}\n\n\t/**\n\t * Gets the user who last modified the resource.\n\t * @returns {string} The modifier's name.\n\t */\n\tpublic getModifiedBy(): string {\n\t\treturn this.native.getModifiedBy();\n\t}\n\n\t/**\n\t * Gets the last modification timestamp.\n\t * @returns {Date} The modification date and time.\n\t */\n\tpublic getModifiedAt(): Date {\n\t\treturn this.native.getModifiedAt();\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Registry;\n}\n"],
  "mappings": "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",
  "names": []
}
