@elixir-cloud/trs-filer 2.0.0-alpha.2 → 2.0.0-alpha.28

package/dist/chunks/chunk.3S22ENXV.js

@@ -0,0 +1,252 @@
+// src/providers/rest-trs-filer-provider.ts
+var RestTrsFilerProvider = class {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  async getToolClasses() {
+    const url = `${this.baseUrl}/toolClasses`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tool classes: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getToolsList(limit, offset, filters, query) {
+    let url = `${this.baseUrl}/tools?${limit ? `limit=${limit}&` : ""}${offset ? `offset=${offset}&` : ""}`;
+    if (query && query.length > 0) {
+      url += `&name=${encodeURIComponent(query)}`;
+    }
+    Object.entries(filters).forEach(([key, value]) => {
+      if (value !== "" && value !== void 0 && key !== "offset") {
+        url += `&${key}=${encodeURIComponent(String(value))}`;
+      }
+    });
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tools: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getTool(url, id) {
+    const encodedToolId = encodeURIComponent(id);
+    const response = await fetch(`${this.baseUrl}/tools/${encodedToolId}`);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tool: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getToolVersions(url, id) {
+    const encodedToolId = encodeURIComponent(id);
+    const response = await fetch(
+      `${this.baseUrl}/tools/${encodedToolId}/versions`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tool versions: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getToolVersion(url, id, versionId) {
+    const encodedToolId = encodeURIComponent(id);
+    const version = versionId.split(":")[1] ? versionId.split(":")[1] : versionId;
+    const encodedVersionId = encodeURIComponent(version);
+    const response = await fetch(
+      `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tool version: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getToolFiles(url, id, version, descriptorType, format) {
+    const encodedToolId = encodeURIComponent(id);
+    const versionPart = version.split(":")[1] ? version.split(":")[1] : version;
+    const encodedVersionId = encodeURIComponent(versionPart);
+    const encodedType = encodeURIComponent(descriptorType);
+    let requestUrl = `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}/${encodedType}/files`;
+    if (format) {
+      requestUrl += `?format=${format}`;
+    }
+    const response = await fetch(requestUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tool files: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getToolDescriptor(url, id, version, descriptorType) {
+    const encodedToolId = encodeURIComponent(id);
+    const versionPart = version.split(":")[1] ? version.split(":")[1] : version;
+    const encodedVersionId = encodeURIComponent(versionPart);
+    const encodedType = encodeURIComponent(descriptorType);
+    const response = await fetch(
+      `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}/${encodedType}/descriptor`
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch tool descriptor: ${response.statusText}`
+      );
+    }
+    return response.json();
+  }
+  async getToolDescriptorByPath(url, id, version, descriptorType, path) {
+    const encodedToolId = encodeURIComponent(id);
+    const versionPart = version.split(":")[1] ? version.split(":")[1] : version;
+    const encodedVersionId = encodeURIComponent(versionPart);
+    const encodedType = encodeURIComponent(descriptorType);
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}/${encodedType}/descriptor/${path}`
+      );
+      if (response.ok) {
+        return response.json();
+      }
+      const encodedPath = encodeURIComponent(path);
+      const encodedResponse = await fetch(
+        `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}/${encodedType}/descriptor/${encodedPath}`
+      );
+      if (encodedResponse.ok) {
+        return encodedResponse.json();
+      }
+      throw new Error(
+        `Failed to fetch tool descriptor by path: ${encodedResponse.statusText}`
+      );
+    } catch (error) {
+      const encodedPath = encodeURIComponent(path);
+      try {
+        const encodedResponse = await fetch(
+          `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}/${encodedType}/descriptor/${encodedPath}`
+        );
+        if (encodedResponse.ok) {
+          return encodedResponse.json();
+        }
+        throw new Error(
+          `Failed to fetch tool descriptor by path: ${encodedResponse.statusText}`
+        );
+      } catch (encodedError) {
+        throw error;
+      }
+    }
+  }
+  async getContainerfile(url, id, version) {
+    const encodedToolId = encodeURIComponent(id);
+    const versionPart = version.split(":")[1] ? version.split(":")[1] : version;
+    const encodedVersionId = encodeURIComponent(versionPart);
+    const response = await fetch(
+      `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}/containerfile`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch containerfile: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getToolTests(url, id, version, descriptorType) {
+    const encodedToolId = encodeURIComponent(id);
+    const versionPart = version.split(":")[1] ? version.split(":")[1] : version;
+    const encodedVersionId = encodeURIComponent(versionPart);
+    const encodedType = encodeURIComponent(descriptorType);
+    const response = await fetch(
+      `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}/${encodedType}/tests`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tool tests: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  // Creation methods (TRS-Filer specific functionality)
+  async createTool(tool) {
+    console.log("Creating tool:", tool);
+    const response = await fetch(`${this.baseUrl}/tools`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(tool)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create tool: ${response.statusText}`);
+    }
+    return response.text();
+  }
+  async createToolWithId(id, tool) {
+    const encodedToolId = encodeURIComponent(id);
+    const response = await fetch(`${this.baseUrl}/tools/${encodedToolId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(tool)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create/update tool: ${response.statusText}`);
+    }
+    return response.text();
+  }
+  async createToolVersion(toolId, version) {
+    const encodedToolId = encodeURIComponent(toolId);
+    const response = await fetch(
+      `${this.baseUrl}/tools/${encodedToolId}/versions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(version)
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to create tool version: ${response.statusText}`);
+    }
+    return response.text();
+  }
+  async createToolVersionWithId(toolId, versionId, version) {
+    const encodedToolId = encodeURIComponent(toolId);
+    const encodedVersionId = encodeURIComponent(versionId);
+    const response = await fetch(
+      `${this.baseUrl}/tools/${encodedToolId}/versions/${encodedVersionId}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(version)
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to create/update tool version: ${response.statusText}`
+      );
+    }
+    return response.text();
+  }
+  async createToolClass(toolClass) {
+    const response = await fetch(`${this.baseUrl}/toolClasses`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(toolClass)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create tool class: ${response.statusText}`);
+    }
+    return response.text();
+  }
+  async createToolClassWithId(id, toolClass) {
+    const encodedId = encodeURIComponent(id);
+    const response = await fetch(`${this.baseUrl}/toolClasses/${encodedId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(toolClass)
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to create/update tool class: ${response.statusText}`
+      );
+    }
+    return response.text();
+  }
+};
+
+export { RestTrsFilerProvider };

package/dist/chunks/{chunk.II7PIADM.js → chunk.5M5UHQTG.js}

@@ -1,9 +1,9 @@
-import { ECCClientElixirTrsToolCreate } from './chunk.FZDL764O.js';
+import { ECCClientElixirTrsToolCreate } from './chunk.PNFA44FN.js';
 import * as React from 'react';
 import { createComponent } from '@lit/react';
 
 var tagName = "ecc-client-elixir-trs-tool-create";
-if (!window.customElements.get("ecc-client-elixir-trs-tool-create")) {
+if (typeof window !== "undefined" && window.customElements && !window.customElements.get("ecc-client-elixir-trs-tool-create")) {
   window.customElements.define("ecc-client-elixir-trs-tool-create", ECCClientElixirTrsToolCreate);
 }
 var reactWrapper = createComponent({
@@ -11,9 +11,9 @@ var reactWrapper = createComponent({
   elementClass: ECCClientElixirTrsToolCreate,
   react: React,
   events: {
-    onEccToolCreateValidationError: "ecc-tool-create-validation-error",
-    onEccToolCreateError: "ecc-tool-create-error",
-    onEccToolCreateSuccess: "ecc-tool-create-success"
+    onEccToolCreateValidationFailed: "ecc-tool-create-validation-failed",
+    onEccToolCreateFailed: "ecc-tool-create-failed",
+    onEccToolCreated: "ecc-tool-created"
   },
   displayName: "EccClientElixirTrsToolCreate"
 });

package/dist/chunks/{chunk.Q5GOJN3Z.js → chunk.D4A7TFU2.js}

@@ -1,34 +1,6 @@
 import { css } from 'lit';
 
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
+// src/components/tool-create/tw-styles.ts
 var ComponentStyles = css` /*! tailwindcss v4.1.4 | MIT License | https://tailwindcss.com */
 @layer properties;
 @layer theme, base, components, utilities;
@@ -712,6 +684,80 @@ var ComponentStyles = css` /*! tailwindcss v4.1.4 | MIT License | https://tailwi
     }
   }
 }
+@property --tw-animation-delay {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0s;
+}
+@property --tw-animation-direction {
+  syntax: "*";
+  inherits: false;
+  initial-value: normal;
+}
+@property --tw-animation-duration {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-animation-fill-mode {
+  syntax: "*";
+  inherits: false;
+  initial-value: none;
+}
+@property --tw-animation-iteration-count {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-enter-opacity {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-enter-rotate {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-enter-scale {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-enter-translate-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-enter-translate-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-exit-opacity {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-exit-rotate {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-exit-scale {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-exit-translate-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-exit-translate-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
 @layer base {
   * {
     border-color: var(--border);
@@ -725,6 +771,10 @@ var ComponentStyles = css` /*! tailwindcss v4.1.4 | MIT License | https://tailwi
     color: var(--foreground);
   }
 }
+:host {
+  font-family: inherit;
+  line-height: inherit;
+}
 @property --tw-space-y-reverse {
   syntax: "*";
   inherits: false;
@@ -841,9 +891,24 @@ var ComponentStyles = css` /*! tailwindcss v4.1.4 | MIT License | https://tailwi
       --tw-ring-offset-width: 0px;
       --tw-ring-offset-color: #fff;
       --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-animation-delay: 0s;
+      --tw-animation-direction: normal;
+      --tw-animation-duration: initial;
+      --tw-animation-fill-mode: none;
+      --tw-animation-iteration-count: 1;
+      --tw-enter-opacity: 1;
+      --tw-enter-rotate: 0;
+      --tw-enter-scale: 1;
+      --tw-enter-translate-x: 0;
+      --tw-enter-translate-y: 0;
+      --tw-exit-opacity: 1;
+      --tw-exit-rotate: 0;
+      --tw-exit-scale: 1;
+      --tw-exit-translate-x: 0;
+      --tw-exit-translate-y: 0;
     }
   }
 }
  `;
 
-export { ComponentStyles, __decorateClass, __spreadProps, __spreadValues };
+export { ComponentStyles };