@knime/product-features 0.3.0 → 0.4.1

package/dist/dataTransfer.js

@@ -0,0 +1,1385 @@
+import { computed, defineComponent, useModel, useId, openBlock, createElementBlock, normalizeClass, createElementVNode, createTextVNode, toDisplayString, createVNode, unref, normalizeStyle, createBlock, createCommentVNode, Transition, withCtx, withDirectives, renderSlot, vShow, mergeModels, Fragment, renderList, watch, ref, reactive, readonly } from 'vue';
+import { KdsButton, KdsIcon, KdsBadge, KdsProgressBar, KdsLoadingSkeleton } from '@knime/kds-components';
+import { _ as _export_sfc } from './_plugin-vue_export-helper-pcqpp-6-.js';
+import { f as formatFileSize } from './format-ra_vlnN7.js';
+import { rfcErrors } from './rfcErrors.js';
+import { ofetch, FetchError } from 'ofetch';
+
+import './dataTransfer.css';const useIconFlipper = (options) => {
+  const iconFlipStyles = computed(() => {
+    const declaration = {
+      transition: "transform 0.2s linear",
+      transform: "scaleY(1)"
+    };
+    if (options.initialRotation) {
+      declaration.rotate = `${options.initialRotation}`;
+    }
+    const transform = options.active.value ? "scaleY(-1)" : void 0;
+    return { ...declaration, transform };
+  });
+  return { iconFlipStyles };
+};
+
+const _hoisted_1$4 = { class: "title-bar" };
+const _hoisted_2$2 = { class: "actions" };
+const _hoisted_3$1 = ["id"];
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "CollapsiblePanel",
+  props: /* @__PURE__ */ mergeModels({
+    title: {},
+    canBeDismissed: { type: Boolean, default: false }
+  }, {
+    "modelValue": { type: Boolean, ...{ default: true } },
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(["close"], ["update:modelValue"]),
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const modelValue = useModel(__props, "modelValue");
+    const { iconFlipStyles } = useIconFlipper({
+      active: computed(() => modelValue.value),
+      initialRotation: "180deg"
+    });
+    const panelContentId = useId();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["collapsible-panel", { collapsed: !modelValue.value }])
+      }, [
+        createElementVNode("div", _hoisted_1$4, [
+          createTextVNode(toDisplayString(__props.title) + " ", 1),
+          createElementVNode("div", _hoisted_2$2, [
+            createVNode(unref(KdsButton), {
+              size: "small",
+              variant: "transparent",
+              "leading-icon": "chevron-up",
+              "aria-expanded": modelValue.value,
+              "aria-controls": unref(panelContentId),
+              ariaLabel: modelValue.value ? "Collapse" : "Expand",
+              style: normalizeStyle(unref(iconFlipStyles)),
+              onClick: _cache[0] || (_cache[0] = ($event) => modelValue.value = !modelValue.value)
+            }, null, 8, ["aria-expanded", "aria-controls", "ariaLabel", "style"]),
+            __props.canBeDismissed ? (openBlock(), createBlock(unref(KdsButton), {
+              key: 0,
+              size: "small",
+              variant: "transparent",
+              ariaLabel: "Close",
+              "leading-icon": "x-close",
+              onClick: _cache[1] || (_cache[1] = ($event) => emit("close"))
+            })) : createCommentVNode("", true)
+          ])
+        ]),
+        createVNode(Transition, { name: "expand" }, {
+          default: withCtx(() => [
+            withDirectives(createElementVNode("div", {
+              id: unref(panelContentId),
+              class: "panel-content"
+            }, [
+              renderSlot(_ctx.$slots, "default", {}, void 0, true)
+            ], 8, _hoisted_3$1), [
+              [vShow, modelValue.value]
+            ])
+          ]),
+          _: 3
+        })
+      ], 2);
+    };
+  }
+});
+
+const CollapsiblePanel = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-3fdfcc1c"]]);
+
+const _hoisted_1$3 = { class: "progress-wrapper" };
+const _hoisted_2$1 = { class: "item-info" };
+const _hoisted_3 = { class: "item-name" };
+const _hoisted_4 = ["title"];
+const _hoisted_5 = {
+  key: 0,
+  class: "subtitle"
+};
+const _hoisted_6 = { class: "item-action" };
+const _hoisted_7 = {
+  key: 0,
+  class: "progress"
+};
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "ProgressItem",
+  props: {
+    id: {},
+    title: {},
+    icon: {},
+    actions: {},
+    subtitle: {},
+    progress: {},
+    badge: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$3, [
+        createElementVNode("div", {
+          class: normalizeClass(["progress-item", { padded: __props.progress === void 0 }])
+        }, [
+          createElementVNode("div", _hoisted_2$1, [
+            createVNode(unref(KdsIcon), { name: __props.icon }, null, 8, ["name"]),
+            createElementVNode("div", _hoisted_3, [
+              createElementVNode("div", {
+                class: "title",
+                title: __props.title
+              }, toDisplayString(__props.title), 9, _hoisted_4),
+              __props.subtitle ? (openBlock(), createElementBlock("span", _hoisted_5, toDisplayString(__props.subtitle), 1)) : createCommentVNode("", true)
+            ])
+          ]),
+          createElementVNode("div", _hoisted_6, [
+            __props.badge ? (openBlock(), createBlock(unref(KdsBadge), {
+              key: 0,
+              variant: __props.badge.variant,
+              label: __props.badge.text,
+              "leading-icon": __props.badge.icon,
+              size: "xxsmall"
+            }, null, 8, ["variant", "label", "leading-icon"])) : createCommentVNode("", true),
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.actions.slice(0, 2), (action) => {
+              return openBlock(), createBlock(unref(KdsButton), {
+                key: action.id,
+                "leading-icon": action.icon,
+                ariaLabel: action.label,
+                variant: "transparent",
+                onClick: action.handler
+              }, null, 8, ["leading-icon", "ariaLabel", "onClick"]);
+            }), 128))
+          ])
+        ], 2),
+        typeof __props.progress === "number" ? (openBlock(), createElementBlock("div", _hoisted_7, [
+          createVNode(unref(KdsProgressBar), {
+            percentage: __props.progress,
+            size: "medium"
+          }, null, 8, ["percentage"])
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+
+const ProgressItem = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-80e5d197"]]);
+
+const _sfc_main$4 = {  };
+
+const _hoisted_1$2 = { class: "progress-list" };
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("div", _hoisted_1$2, [
+    renderSlot(_ctx.$slots, "default", {}, undefined, true)
+  ]))
+}
+const ProgressList = /*#__PURE__*/_export_sfc(_sfc_main$4, [['render',_sfc_render],['__scopeId',"data-v-66f55049"]]);
+
+class AbortError extends Error {
+}
+const createAbortablePromise = () => {
+  const abortController = new AbortController();
+  const runAbortablePromise = (request) => {
+    return new Promise((resolve, reject) => {
+      const abortListener = ({ target }) => {
+        abortController.signal.removeEventListener("abort", abortListener);
+        const reason = target.reason;
+        reject(reason instanceof AbortError ? reason : new AbortError(reason));
+      };
+      request().then(resolve).catch((error) => {
+        if (error instanceof AbortError) {
+          return;
+        }
+        reject(error);
+      });
+      abortController.signal.addEventListener("abort", abortListener);
+    });
+  };
+  return { abortController, runAbortablePromise };
+};
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+const DEFAULT_RETRY_DELAY_MS$2 = 0;
+const DEFAULT_RETRY_COUNT$1 = 5;
+async function retryPromise({
+  fn,
+  retryCount = DEFAULT_RETRY_COUNT$1,
+  retryDelayMS = DEFAULT_RETRY_DELAY_MS$2,
+  excludeError
+}) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (excludeError?.(error)) {
+      throw error;
+    }
+    if (retryCount > 0) {
+      await sleep(retryDelayMS);
+      return await retryPromise({
+        fn,
+        retryCount: retryCount - 1,
+        retryDelayMS,
+        excludeError
+      });
+    }
+    throw error;
+  }
+}
+
+const getFileExtension = (nameOrPath) => {
+  const basename = nameOrPath.split(/[\\/]/).pop() ?? "";
+  const parts = basename.split(".");
+  if (basename === "" || parts.length === 1) {
+    return "";
+  }
+  return parts.at(-1) ?? "";
+};
+const KNAR = Object.freeze({
+  extension: "knar",
+  mimeType: "application/vnd.knime.workflow-group+zip",
+  matches(file) {
+    const extension = getFileExtension(file.name);
+    return extension === this.extension;
+  }
+});
+const KNWF = Object.freeze({
+  extension: "knwf",
+  mimeType: "application/vnd.knime.workflow+zip",
+  matches(file) {
+    const extension = getFileExtension(file.name);
+    return extension === this.extension;
+  },
+  /**
+   * Gets the name of a .knwf file without the extension. If the file is not
+   * matched as a .knwf file then this function will return the default value,
+   * which is empty string ("") if param is not provided
+   */
+  getNameOrDefault(file, defaultValue = "") {
+    if (!this.matches(file)) {
+      return defaultValue;
+    }
+    return file.name.replace(`.${this.extension}`, "");
+  }
+});
+const knimeFileFormats = { KNWF };
+const getFileMimeType = (file) => {
+  const DEFAULT_MIMETYPE = "application/octet-stream";
+  const extension = getFileExtension(file.name);
+  if (!extension) {
+    return DEFAULT_MIMETYPE;
+  }
+  if (KNWF.matches(file)) {
+    return KNWF.mimeType;
+  }
+  if (KNAR.matches(file)) {
+    return KNAR.mimeType;
+  }
+  if (!file.type) {
+    return DEFAULT_MIMETYPE;
+  }
+  return file.type;
+};
+
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "UploadProgressPanelItem",
+  props: {
+    item: {},
+    allowCancel: { type: Boolean },
+    allowRemove: { type: Boolean }
+  },
+  emits: ["remove", "cancel"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const hasProgress = (item) => {
+      return item.status === "inprogress" || item.status === "complete";
+    };
+    const totalFormatted = computed(() => {
+      return formatFileSize(props.item.size);
+    });
+    const progressedFormatted = computed(() => {
+      if (hasProgress(props.item)) {
+        const sizePercentage = props.item.size / 100 * (props.item.progress ?? 0);
+        return formatFileSize(sizePercentage);
+      }
+      return 0;
+    });
+    const subtitle = computed(
+      () => props.item.status === "inprogress" ? `${progressedFormatted.value} of ${totalFormatted.value}` : `${totalFormatted.value}`
+    );
+    const statusMapper = {
+      inprogress: ["Uploading", "info", "reload"],
+      failed: ["Failed", "error", "circle-error"],
+      complete: ["Uploaded", "success", "circle-success"],
+      cancelled: ["Cancelled", "error", "circle-error"],
+      processing: ["Processing", "info", "reload"]
+    };
+    const itemIcon = computed(() => {
+      const extension = getFileExtension(props.item.name);
+      return extension === knimeFileFormats.KNWF.extension ? "workflow" : "file";
+    });
+    const badge = computed(() => {
+      if (!props.item.status) {
+        return void 0;
+      }
+      const [text, variant, icon] = statusMapper[props.item.status];
+      return { text, variant, icon };
+    });
+    const shouldShowCancelAction = computed(
+      () => props.allowCancel && props.item.status === "inprogress"
+    );
+    const shouldShowRemoveAction = computed(() => {
+      const allowedRemoveStatuses = [
+        "complete",
+        "failed",
+        "cancelled"
+      ];
+      const showRemove = props.allowRemove && props.item.status && allowedRemoveStatuses.includes(props.item.status);
+      return showRemove;
+    });
+    const actions = computed(() => {
+      const actions2 = [];
+      if (shouldShowCancelAction.value) {
+        actions2.push({
+          id: "cancel",
+          icon: "x-close",
+          label: "Cancel",
+          handler: () => emit("cancel")
+        });
+      }
+      if (shouldShowRemoveAction.value) {
+        actions2.push({
+          id: "remove",
+          icon: "trash",
+          label: "Remove",
+          handler: () => emit("remove")
+        });
+      }
+      return actions2;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ProgressItem), {
+        id: __props.item.id,
+        title: __props.item.name,
+        subtitle: subtitle.value,
+        icon: itemIcon.value,
+        progress: hasProgress(__props.item) ? __props.item.progress : void 0,
+        badge: badge.value,
+        actions: actions.value
+      }, null, 8, ["id", "title", "subtitle", "icon", "progress", "badge", "actions"]);
+    };
+  }
+});
+
+const _hoisted_1$1 = { class: "upload-panel-content" };
+const _hoisted_2 = { class: "skeleton-text-content" };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "UploadProgressPanel",
+  props: /* @__PURE__ */ mergeModels({
+    items: {},
+    allowCancel: { type: Boolean, default: true },
+    allowRemove: { type: Boolean, default: true },
+    placeholderItems: { default: 0 }
+  }, {
+    "expanded": { type: Boolean, ...{ default: true } },
+    "expandedModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(["remove", "cancel", "close"], ["update:expanded"]),
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const expanded = useModel(__props, "expanded");
+    const totalItems = computed(() => __props.items.length);
+    const uploadedItems = computed(
+      () => __props.items.filter(({ status }) => status === "complete").length
+    );
+    const title = computed(() => {
+      const suffix = `file${totalItems.value > 1 ? "s" : ""}`;
+      return `Uploaded ${uploadedItems.value} of ${totalItems.value} ${suffix}`;
+    });
+    const hasSomeItemInProgress = computed(
+      () => __props.items.some(
+        ({ status }) => status === "inprogress" || status === "processing"
+      ) || __props.placeholderItems > 0
+    );
+    watch(
+      () => __props.items,
+      (newItems, prevItems) => {
+        if (prevItems?.length > 0 && newItems.length === 0) {
+          emit("close");
+        }
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(CollapsiblePanel), {
+        modelValue: expanded.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => expanded.value = $event),
+        title: title.value,
+        class: "upload-panel",
+        "can-be-dismissed": !hasSomeItemInProgress.value,
+        onClose: _cache[1] || (_cache[1] = ($event) => emit("close"))
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1$1, [
+            createVNode(unref(ProgressList), null, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(__props.items, (item) => {
+                  return openBlock(), createBlock(_sfc_main$3, {
+                    key: item.id,
+                    item,
+                    "allow-cancel": __props.allowCancel,
+                    "allow-remove": __props.allowRemove,
+                    onRemove: ($event) => emit("remove", item),
+                    onCancel: ($event) => emit("cancel", item)
+                  }, null, 8, ["item", "allow-cancel", "allow-remove", "onRemove", "onCancel"]);
+                }), 128))
+              ]),
+              _: 1
+            }),
+            __props.placeholderItems > 0 ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(__props.placeholderItems, (skeleton) => {
+              return openBlock(), createElementBlock("div", {
+                key: skeleton,
+                class: "skeleton-container"
+              }, [
+                createVNode(unref(KdsLoadingSkeleton), { variant: "icon-large" }),
+                createElementVNode("div", _hoisted_2, [
+                  createVNode(unref(KdsLoadingSkeleton), { variant: "label" }),
+                  createVNode(unref(KdsLoadingSkeleton), { variant: "text" })
+                ])
+              ]);
+            }), 128)) : createCommentVNode("", true)
+          ])
+        ]),
+        _: 1
+      }, 8, ["modelValue", "title", "can-be-dismissed"]);
+    };
+  }
+});
+
+const UploadProgressPanel = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-7d4c779e"]]);
+
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "DownloadProgressPanelItem",
+  props: {
+    item: {}
+  },
+  emits: ["remove", "cancel", "download"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const statusMapper = {
+      IN_PROGRESS: ["Zipping", "info", "reload"],
+      READY: ["Ready", "success", "circle-info"],
+      CANCELLED: ["Cancelled", "error", "circle-error"],
+      FAILED: ["Failed", "error", "circle-error"]
+    };
+    const badge = computed(() => {
+      const [text, variant, icon] = statusMapper[props.item.status];
+      return {
+        text,
+        variant,
+        icon
+      };
+    });
+    const isCancellable = computed(() => props.item.status === "IN_PROGRESS");
+    const isReady = computed(() => props.item.status === "READY");
+    const isRemovable = computed(
+      () => props.item.status === "CANCELLED" || props.item.status === "FAILED" || props.item.status === "READY"
+    );
+    const actions = computed(() => {
+      const actions2 = [];
+      if (isCancellable.value) {
+        actions2.push({
+          id: "cancel",
+          icon: "x-close",
+          label: "Cancel",
+          handler: () => emit("cancel")
+        });
+      }
+      if (isReady.value) {
+        actions2.push({
+          id: "download",
+          icon: "cloud-download",
+          label: "Download again",
+          handler: () => emit("download")
+        });
+      }
+      if (isRemovable.value) {
+        actions2.push({
+          id: "remove",
+          icon: "trash",
+          label: "Remove",
+          handler: () => emit("remove")
+        });
+      }
+      return actions2;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ProgressItem), {
+        id: __props.item.downloadId,
+        icon: "file",
+        title: __props.item.name,
+        badge: badge.value,
+        actions: actions.value
+      }, null, 8, ["id", "title", "badge", "actions"]);
+    };
+  }
+});
+
+const _hoisted_1 = { class: "download-panel-content" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DownloadProgressPanel",
+  props: /* @__PURE__ */ mergeModels({
+    items: {}
+  }, {
+    "expanded": { type: Boolean, ...{ default: true } },
+    "expandedModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(["remove", "cancel", "download", "close"], ["update:expanded"]),
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const expanded = useModel(__props, "expanded");
+    const totalItems = computed(() => props.items.length);
+    const totalDownloadedItems = computed(
+      () => props.items.filter(({ status }) => status === "READY").length
+    );
+    const title = computed(() => {
+      const suffix = `file${totalItems.value > 1 ? "s" : ""}`;
+      return `Downloaded ${totalDownloadedItems.value} of ${totalItems.value} ${suffix}`;
+    });
+    const hasItemsInProgress = computed(
+      () => props.items.some(({ status }) => status === "IN_PROGRESS")
+    );
+    watch(
+      () => props.items?.length,
+      (newValue, oldValue) => {
+        if (oldValue > 0 && !newValue) {
+          emit("close");
+        }
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(CollapsiblePanel), {
+        modelValue: expanded.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => expanded.value = $event),
+        title: title.value,
+        class: "download-panel",
+        "can-be-dismissed": !hasItemsInProgress.value,
+        onClose: _cache[1] || (_cache[1] = ($event) => emit("close"))
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1, [
+            createVNode(unref(ProgressList), null, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(__props.items, (item) => {
+                  return openBlock(), createBlock(_sfc_main$1, {
+                    key: item.downloadId,
+                    item,
+                    onRemove: ($event) => emit("remove", item),
+                    onCancel: ($event) => emit("cancel", item),
+                    onDownload: ($event) => emit("download", item)
+                  }, null, 8, ["item", "onRemove", "onCancel", "onDownload"]);
+                }), 128))
+              ]),
+              _: 1
+            })
+          ])
+        ]),
+        _: 1
+      }, 8, ["modelValue", "title", "can-be-dismissed"]);
+    };
+  }
+});
+
+const DownloadProgressPanel = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-f5f774fd"]]);
+
+//#region src/predicate/isPlainObject.ts
+/**
+* Checks if a given value is a plain object.
+*
+* @param {object} value - The value to check.
+* @returns {value is Record<PropertyKey, any>} - True if the value is a plain object, otherwise false.
+*
+* @example
+* ```typescript
+* // ✅👇 True
+*
+* isPlainObject({ });                       // ✅
+* isPlainObject({ key: 'value' });          // ✅
+* isPlainObject({ key: new Date() });       // ✅
+* isPlainObject(new Object());              // ✅
+* isPlainObject(Object.create(null));       // ✅
+* isPlainObject({ nested: { key: true} });  // ✅
+* isPlainObject(new Proxy({}, {}));         // ✅
+* isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
+*
+* // ✅👇 (cross-realms, node context, workers, ...)
+* const runInNewContext = await import('node:vm').then(
+*     (mod) => mod.runInNewContext
+* );
+* isPlainObject(runInNewContext('({})'));   // ✅
+*
+* // ❌👇 False
+*
+* class Test { };
+* isPlainObject(new Test())           // ❌
+* isPlainObject(10);                  // ❌
+* isPlainObject(null);                // ❌
+* isPlainObject('hello');             // ❌
+* isPlainObject([]);                  // ❌
+* isPlainObject(new Date());          // ❌
+* isPlainObject(new Uint8Array([1])); // ❌
+* isPlainObject(Buffer.from('ABC'));  // ❌
+* isPlainObject(Promise.resolve({})); // ❌
+* isPlainObject(Object.create({}));   // ❌
+* isPlainObject(new (class Cls {}));  // ❌
+* isPlainObject(globalThis);          // ❌,
+* ```
+*/
+function isPlainObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+//#region src/_internal/isUnsafeProperty.ts
+/**
+* Checks if a property key is unsafe to modify directly.
+*
+* This function is used in functions like `merge` to prevent prototype pollution attacks
+* by identifying property keys that could modify the object's prototype chain or constructor.
+*
+* @param key - The property key to check
+* @returns `true` if the property is unsafe to modify directly, `false` otherwise
+* @internal
+*/
+function isUnsafeProperty(key) {
+	return key === "__proto__";
+}
+
+//#region src/object/merge.ts
+/**
+* Merges the properties of the source object into the target object.
+*
+* This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+* If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged.
+* If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+*
+* Note that this function mutates the target object.
+*
+* @param {T} target - The target object into which the source object properties will be merged. This object is modified in place.
+* @param {S} source - The source object whose properties will be merged into the target object.
+* @returns {T & S} The updated target object with properties from the source object merged in.
+*
+* @template T - Type of the target object.
+* @template S - Type of the source object.
+*
+* @example
+* const target = { a: 1, b: { x: 1, y: 2 } };
+* const source = { b: { y: 3, z: 4 }, c: 5 };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+*
+* @example
+* const target = { a: [1, 2], b: { x: 1 } };
+* const source = { a: [3], b: { y: 2 } };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+*
+* @example
+* const target = { a: null };
+* const source = { a: [1, 2, 3] };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: [1, 2, 3] }
+*/
+function merge(target, source) {
+	const sourceKeys = Object.keys(source);
+	for (let i = 0; i < sourceKeys.length; i++) {
+		const key = sourceKeys[i];
+		if (isUnsafeProperty(key)) continue;
+		const sourceValue = source[key];
+		const targetValue = target[key];
+		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = merge(targetValue, sourceValue);
+		else if (Array.isArray(sourceValue)) target[key] = merge([], sourceValue);
+		else if (isPlainObject(sourceValue)) target[key] = merge({}, sourceValue);
+		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
+	}
+	return target;
+}
+function isMergeableValue(value) {
+	return isPlainObject(value) || Array.isArray(value);
+}
+
+const API_BASE_URL = "/_/api";
+
+const defaultConfig = {
+  baseURL: API_BASE_URL,
+  headers: {
+    "Content-Type": "application/json",
+    // see: https://knime-com.atlassian.net/wiki/spaces/SPECS/pages/4126769212/API+Errors#Client-Request-Headers
+    Accept: "application/json; application/problem+json"
+  }
+};
+const createHttpClient = (customOptions) => {
+  const { baseURL = API_BASE_URL, ...otherCustomOptions } = customOptions ?? {};
+  return ofetch.create(
+    merge({ baseURL, ...otherCustomOptions }, defaultConfig)
+  );
+};
+
+const CHUNK_SIZE = 50 * 1024 * 1024;
+const DEFAULT_RETRY_COUNT = 5;
+const DEFAULT_RETRY_DELAY_MS$1 = 50;
+const uploadChunkWithProgress = (params) => {
+  const { method, url, chunk, chunkIndex, onProgress, abortSignal } = params;
+  const OK = 200;
+  const CREATED = 201;
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url, true);
+    abortSignal.addEventListener("abort", () => xhr.abort());
+    xhr.upload.onprogress = (event) => {
+      if (event.lengthComputable) {
+        onProgress(event.loaded);
+      }
+    };
+    xhr.onload = () => {
+      if (xhr.status === OK || xhr.status === CREATED) {
+        const etag = xhr.getResponseHeader("ETag");
+        resolve({ partId: etag?.replace(/^(?:W\/)?"|"$/g, "") ?? "" });
+      } else {
+        consola.error("Failed or unexpected XHR response", {
+          xhrStatus: xhr.status,
+          xhrResponse: xhr.response,
+          chunkIndex
+        });
+        reject(new Error("Failed to upload file"));
+      }
+    };
+    xhr.onerror = (event) => {
+      consola.error("Failed to upload chunk", {
+        xhrErrorEvent: event,
+        chunkIndex
+      });
+      reject(new Error("Failed to upload file"));
+    };
+    xhr.send(chunk);
+  });
+};
+const createUploadManager = (config) => {
+  const {
+    resolveFilePartUploadURL: getUploadFilePartUrl,
+    onFileUploadComplete,
+    onFileUploadFailed
+  } = config;
+  const uploadStateMap = /* @__PURE__ */ new Map();
+  const completedUploads = /* @__PURE__ */ new Set();
+  const cancelledUploads = /* @__PURE__ */ new Set();
+  const failedUploads = /* @__PURE__ */ new Set();
+  const assertState = (uploadId, state) => uploadStateMap.has(uploadId) && uploadStateMap.get(uploadId).state === state;
+  const getUploadState = (uploadId) => uploadStateMap.get(uploadId);
+  const setUploadState = (uploadId, state) => {
+    uploadStateMap.set(uploadId, {
+      ...uploadStateMap.get(uploadId),
+      ...state
+    });
+  };
+  const isFailed = (uploadId) => assertState(uploadId, "failed");
+  const isCancelled = (uploadId) => assertState(uploadId, "cancelled");
+  const getTotalFileParts = (file) => Math.ceil(file.size / CHUNK_SIZE);
+  const abortInFlightUpload = (uploadId, reason) => {
+    const currentState = uploadStateMap.get(uploadId);
+    if (!currentState) {
+      return;
+    }
+    currentState.abortController.abort(
+      new AbortError(
+        `Upload (${currentState.uploadId}) for file "${currentState.file.name}" aborted. Reason: "${reason}"`
+      )
+    );
+  };
+  const cancel = (uploadId) => {
+    if (!uploadStateMap.has(uploadId)) {
+      consola.error("cancel:: Invalid upload id");
+      return;
+    }
+    setUploadState(uploadId, { state: "cancelled" });
+    abortInFlightUpload(uploadId, "upload cancelled");
+    cancelledUploads.add(uploadId);
+  };
+  const setFailed = (uploadId, error) => {
+    if (!uploadStateMap.has(uploadId)) {
+      consola.error("failed:: Invalid upload id");
+      return;
+    }
+    setUploadState(uploadId, { state: "failed" });
+    onFileUploadFailed?.({ uploadId, error });
+    failedUploads.add(uploadId);
+    if (completedUploads.has(uploadId)) {
+      completedUploads.delete(uploadId);
+    }
+  };
+  const uploadFileFromChunkIndex = async (uploadId, file, initialChunkIndex = 0) => {
+    const totalChunks = getTotalFileParts(file);
+    const totalBytes = file.size;
+    const completedPartIds = {};
+    const { abortController, runAbortablePromise } = createAbortablePromise();
+    uploadStateMap.set(uploadId, {
+      uploadId,
+      file,
+      state: "inprogress",
+      uploadedByteCount: uploadStateMap.get(uploadId)?.uploadedByteCount ?? 0,
+      completedChunkCount: uploadStateMap.get(uploadId)?.completedChunkCount ?? 0,
+      abortController
+    });
+    let chunkIndex = initialChunkIndex;
+    let uploadedBytes = uploadStateMap.get(uploadId)?.uploadedByteCount;
+    while (chunkIndex < totalChunks) {
+      if (isCancelled(uploadId) || isFailed(uploadId)) {
+        break;
+      }
+      const start = chunkIndex * CHUNK_SIZE;
+      const end = Math.min(start + CHUNK_SIZE, file.size);
+      const chunk = file.slice(start, end);
+      try {
+        const { method, url } = await retryPromise({
+          fn: () => getUploadFilePartUrl(uploadId, chunkIndex + 1),
+          retryCount: DEFAULT_RETRY_COUNT,
+          retryDelayMS: DEFAULT_RETRY_DELAY_MS$1
+        });
+        consola.trace("File part upload url resolved", { method, url });
+        const onChunkUploadProgress = (uploadedChunkBytes) => {
+          uploadedBytes = uploadedChunkBytes + start;
+          setUploadState(uploadId, { uploadedByteCount: uploadedBytes });
+          const progress = Math.round(uploadedBytes / totalBytes * 100);
+          config.onProgress?.(uploadId, progress);
+        };
+        const filePartResponse = await runAbortablePromise(
+          () => retryPromise({
+            fn: () => uploadChunkWithProgress({
+              method,
+              url,
+              chunk,
+              chunkIndex,
+              onProgress: onChunkUploadProgress,
+              abortSignal: abortController.signal
+            }),
+            retryCount: DEFAULT_RETRY_COUNT,
+            retryDelayMS: DEFAULT_RETRY_DELAY_MS$1
+          })
+        );
+        consola.trace(
+          `${file.name}: Chunk ${chunkIndex + 1} of ${totalChunks} uploaded successfully`
+        );
+        completedPartIds[chunkIndex + 1] = filePartResponse.partId;
+        setUploadState(uploadId, {
+          completedChunkCount: uploadStateMap.get(uploadId).completedChunkCount + 1
+        });
+      } catch (error) {
+        if (error instanceof AbortError) {
+          consola.info("Aborted::", error);
+          return;
+        }
+        setFailed(
+          uploadId,
+          error instanceof Error ? error : new Error(error)
+        );
+        return;
+      }
+      chunkIndex++;
+    }
+    if (isCancelled(uploadId) || isFailed(uploadId)) {
+      return;
+    }
+    setUploadState(uploadId, {
+      completedChunkCount: totalChunks,
+      state: "complete"
+    });
+    completedUploads.add(uploadId);
+    onFileUploadComplete?.({ uploadId, filePartIds: completedPartIds });
+  };
+  const uploadFiles = (files) => {
+    const result = [];
+    for (const { uploadId, file } of files) {
+      result.push(uploadFileFromChunkIndex(uploadId, file));
+    }
+    return Promise.allSettled(result).then(() => {
+      const completed = [...completedUploads.values()];
+      const cancelled = [...cancelledUploads.values()];
+      const failed = [...failedUploads.values()];
+      [...completed, ...cancelled, ...failed].forEach(
+        (uploadId) => uploadStateMap.delete(uploadId)
+      );
+      completedUploads.clear();
+      cancelledUploads.clear();
+      failedUploads.clear();
+      return {
+        completed,
+        cancelled,
+        failed
+      };
+    });
+  };
+  return {
+    uploadFiles,
+    getUploadState,
+    isFailed,
+    isCancelled,
+    cancel,
+    setFailed
+  };
+};
+
+const useUploadManager = (options) => {
+  const uploadState = ref({});
+  const { uploadFiles, cancel, setFailed } = createUploadManager({
+    ...options,
+    onFileUploadComplete: (params) => {
+      const { parentId, name } = uploadState.value[params.uploadId];
+      uploadState.value[params.uploadId].status = "complete";
+      options.onFileUploadComplete?.({ ...params, parentId, name });
+    },
+    onFileUploadFailed: ({ uploadId, error }) => {
+      const { parentId } = uploadState.value[uploadId];
+      uploadState.value[uploadId] = {
+        ...uploadState.value[uploadId],
+        status: "failed",
+        failureDetails: error.message
+      };
+      options.onFileUploadFailed?.({ uploadId, error, parentId });
+    },
+    onProgress: (uploadId, progress) => {
+      if (uploadState.value[uploadId].status === "inprogress") {
+        uploadState.value[uploadId].progress = progress;
+      }
+    }
+  });
+  const start = async (parentId, uploadPayload) => {
+    try {
+      uploadPayload.forEach(({ uploadId, file }) => {
+        uploadState.value[uploadId] = {
+          id: uploadId,
+          name: file.name,
+          size: file.size,
+          progress: 0,
+          status: "inprogress",
+          parentId
+        };
+      });
+      await uploadFiles(uploadPayload);
+    } catch (error) {
+      consola.error("Error uploading files", error);
+    }
+  };
+  const canCancel = (uploadId) => uploadState.value[uploadId]?.status === "inprogress" || uploadState.value[uploadId]?.status === "failed";
+  const removeItem = (uploadId) => {
+    if (canCancel(uploadId)) {
+      cancel(uploadId);
+    }
+    delete uploadState.value[uploadId];
+  };
+  const resetState = () => {
+    uploadState.value = {};
+  };
+  const uploadItems = computed(() => Object.values(uploadState.value));
+  const hasPendingUploads = computed(
+    () => uploadItems.value.some(({ status }) => status === "inprogress")
+  );
+  const totalPendingUploads = computed(
+    () => uploadItems.value.filter(({ status }) => status === "inprogress").length
+  );
+  return {
+    uploadState,
+    hasPendingUploads,
+    totalPendingUploads,
+    start,
+    cancel: (uploadId) => {
+      cancel(uploadId);
+      uploadState.value[uploadId].status = "cancelled";
+    },
+    canCancel,
+    removeItem,
+    resetState,
+    setFailed: (uploadId, error) => {
+      uploadState.value[uploadId] = {
+        ...uploadState.value[uploadId],
+        status: "failed",
+        failureDetails: error.message
+      };
+      setFailed(uploadId, error);
+    }
+  };
+};
+
+const DEFAULT_MAX_UPLOAD_QUEUE_SIZE = 10;
+const DEFAULT_UPLOAD_SIZE_LIMIT_BYTES = 5 * 1024 * 1024 * 1024;
+const DEFAULT_RETRY_DELAY_MS = 50;
+const getUploadSizeLimitBytes = () => DEFAULT_UPLOAD_SIZE_LIMIT_BYTES;
+const useFileUpload = (options = {}) => {
+  const $ofetch = createHttpClient(options.customFetchClientOptions);
+  const prepareUpload = (parentId, files) => {
+    const fileDictionary = Object.fromEntries(
+      files.map((file) => {
+        const name = knimeFileFormats.KNWF.getNameOrDefault(file, file.name);
+        return [name, file];
+      })
+    );
+    const items = Object.fromEntries(
+      Object.entries(fileDictionary).map(([name, file]) => [
+        name,
+        {
+          itemContentType: getFileMimeType(file),
+          itemContentSize: file.size
+        }
+      ])
+    );
+    return $ofetch(`/repository/${parentId}/manifest`, {
+      method: "POST",
+      body: { items }
+    }).then(({ items: items2 }) => {
+      return Object.keys(items2).map((name) => {
+        const { uploadId } = items2[name];
+        const file = fileDictionary[name];
+        return { uploadId, file };
+      });
+    });
+  };
+  const resolveFilePartUploadURL = (uploadId, partNumber) => {
+    return $ofetch(
+      `/uploads/${uploadId}/parts/?partNumber=${partNumber}`,
+      { method: "POST" }
+    );
+  };
+  const completeUpload = (uploadId, partIds) => {
+    return $ofetch(`/uploads/${uploadId}`, {
+      method: "POST",
+      body: partIds
+    });
+  };
+  const cancelUpload = (uploadId) => {
+    return $ofetch(`/uploads/${uploadId}`, {
+      method: "DELETE"
+    });
+  };
+  const unprocessedUploads = reactive(/* @__PURE__ */ new Set());
+  const isKNWFFile = (file) => knimeFileFormats.KNWF.matches(file);
+  let useUploadManagerResult = null;
+  const setProcessingCompleted = ({ uploadId }) => {
+    unprocessedUploads.delete(uploadId);
+  };
+  const setProcessingFailed = ({
+    uploadId,
+    error
+  }) => {
+    unprocessedUploads.delete(uploadId);
+    useUploadManagerResult?.setFailed(
+      uploadId,
+      error ?? new Error("An error occurred when processing the file")
+    );
+  };
+  useUploadManagerResult = useUploadManager({
+    resolveFilePartUploadURL,
+    onFileUploadComplete: ({ uploadId, filePartIds, parentId, name }) => {
+      retryPromise({ fn: () => completeUpload(uploadId, filePartIds) }).then(() => {
+        options.onFileUploadComplete?.({
+          uploadId,
+          filePartIds,
+          parentId,
+          name
+        });
+      }).catch((error) => {
+        consola.error("Error attempting to complete upload", { error });
+        setProcessingFailed({ uploadId, error });
+      });
+    },
+    onFileUploadFailed: ({ uploadId, error, parentId }) => {
+      options?.onFileUploadFailed?.({ uploadId, error, parentId });
+    }
+  });
+  const getEnqueueableFiles = (files) => {
+    const { totalPendingUploads } = useUploadManagerResult;
+    const { maxUploadQueueSize = DEFAULT_MAX_UPLOAD_QUEUE_SIZE } = options;
+    if (files.length + totalPendingUploads.value > maxUploadQueueSize) {
+      options.onUploadQueueSizeExceeded?.(maxUploadQueueSize);
+    }
+    const effectiveQueueSize = Math.max(
+      0,
+      maxUploadQueueSize - totalPendingUploads.value
+    );
+    return files.slice(0, effectiveQueueSize);
+  };
+  const { uploadState, ...uploadManagerResultRest } = useUploadManagerResult;
+  const uploadQueue = computed(() => {
+    return Object.values(uploadState.value).map((uploadItem) => {
+      if (uploadItem.status === "complete" && unprocessedUploads.has(uploadItem.id)) {
+        return {
+          id: uploadItem.id,
+          name: uploadItem.name,
+          parentId: uploadItem.parentId,
+          size: uploadItem.size,
+          status: "processing"
+        };
+      }
+      return uploadItem;
+    });
+  });
+  const prepareQueueSize = ref(0);
+  return {
+    ...uploadManagerResultRest,
+    uploadQueue,
+    unprocessedUploads: readonly(unprocessedUploads),
+    setProcessingCompleted,
+    setProcessingFailed,
+    isPreparingUpload: computed(() => prepareQueueSize.value > 0),
+    totalFilesBeingPrepared: computed(() => prepareQueueSize.value),
+    start: async (parentId, files, options2 = {}) => {
+      const { isFileWithProcessing = isKNWFFile } = options2;
+      const enqueueableFiles = getEnqueueableFiles(files);
+      const uploadSizeLimitBytes = getUploadSizeLimitBytes();
+      const oversizedFiles = enqueueableFiles.filter(
+        (file) => file.size > uploadSizeLimitBytes
+      );
+      if (oversizedFiles.length > 0) {
+        throw new rfcErrors.RFCError({
+          title: "Upload size limit exceeded",
+          status: 413,
+          details: oversizedFiles.map(
+            (file) => `${file.name} (${formatFileSize(file.size)}) exceeds the upload limit of ${formatFileSize(uploadSizeLimitBytes)}.`
+          )
+        });
+      }
+      try {
+        if (enqueueableFiles.length === 0) {
+          return [];
+        }
+        prepareQueueSize.value += enqueueableFiles.length;
+        const uploadPayload = await retryPromise({
+          fn: () => prepareUpload(parentId, enqueueableFiles),
+          excludeError: (error) => (
+            // eslint-disable-next-line no-magic-numbers
+            Boolean(error.statusCode && error.statusCode < 500)
+          ),
+          retryDelayMS: DEFAULT_RETRY_DELAY_MS
+        });
+        uploadPayload.forEach(({ uploadId, file }) => {
+          if (isFileWithProcessing(file)) {
+            unprocessedUploads.add(uploadId);
+          }
+        });
+        const uploadIds = uploadPayload.map((upload) => upload.uploadId);
+        useUploadManagerResult.start(parentId, uploadPayload);
+        return uploadIds;
+      } catch (error) {
+        throw rfcErrors.tryParse(error) ?? error;
+      } finally {
+        prepareQueueSize.value -= enqueueableFiles.length;
+      }
+    },
+    cancel: (uploadId) => {
+      useUploadManagerResult.cancel(uploadId);
+      cancelUpload(uploadId).catch((error) => {
+        consola.error("There was a problem cancelling the upload", { error });
+      });
+    }
+  };
+};
+
+const DEFAULT_MAX_RETRIES = null;
+const DEFAULT_POLLING_INTERVAL = 2e3;
+const hasDownloadUrl = (response) => {
+  return "downloadUrl" in response;
+};
+const isAbortError = (error) => error instanceof DOMException && error.name === "AbortError";
+const useDownloadArtifact = (options = {}) => {
+  const $ofetch = createHttpClient(options.customFetchClientOptions);
+  const downloadItems = ref({});
+  const abortControllers = {};
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const pollingInterval = options.pollingInterval ?? DEFAULT_POLLING_INTERVAL;
+  const cancel = (downloadId) => {
+    const itemController = abortControllers[downloadId];
+    if (itemController) {
+      itemController.abort();
+      delete abortControllers[downloadId];
+    }
+  };
+  const removeItem = (downloadId) => {
+    cancel(downloadId);
+    delete downloadItems.value[downloadId];
+  };
+  const fetchDownloadStatus = ({
+    downloadId,
+    signal
+  }) => {
+    return $ofetch(`/downloads/${downloadId}/status`, {
+      method: "GET",
+      signal
+    });
+  };
+  const openDownload = (downloadUrl) => {
+    const a = document.createElement("a");
+    a.target = "_blank";
+    a.href = downloadUrl;
+    a.download = "";
+    a.style.display = "none";
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+  };
+  const handlePollingResult = async ({
+    downloadId,
+    signal
+  }) => {
+    try {
+      const statusResponse = await fetchDownloadStatus({
+        downloadId,
+        signal
+      });
+      if (statusResponse?.status === "READY" && statusResponse?.downloadUrl) {
+        downloadItems.value[downloadId].status = "READY";
+        downloadItems.value[downloadId].downloadUrl = statusResponse.downloadUrl;
+        openDownload(statusResponse.downloadUrl);
+        return true;
+      } else if (statusResponse?.status === "FAILED") {
+        let details = "Download failed";
+        if (statusResponse?.statusMessage) {
+          details += `: ${statusResponse.statusMessage}`;
+        }
+        throw new Error(details);
+      }
+    } catch (error) {
+      consola.error("Error fetching status:", error);
+      const isAborted = isAbortError(error) || error instanceof FetchError && isAbortError(error.cause);
+      if (!isAborted) {
+        downloadItems.value[downloadId].status = "FAILED";
+        downloadItems.value[downloadId].failureDetails = error instanceof Error ? error.message : error;
+      }
+      return true;
+    }
+    return false;
+  };
+  const pollDownloadItem = async ({
+    itemId,
+    downloadId,
+    version,
+    name
+  }) => {
+    const controller = new AbortController();
+    abortControllers[downloadId] = controller;
+    const signal = controller.signal;
+    let itemName = `${name}`;
+    if (version) {
+      itemName += ` (${version})`;
+    }
+    downloadItems.value[downloadId] = {
+      itemId,
+      ...version && { version },
+      downloadId,
+      name: itemName,
+      status: "IN_PROGRESS"
+    };
+    const abortListener = () => {
+      controller.signal.removeEventListener("abort", abortListener);
+      if (!downloadItems.value[downloadId]) {
+        return;
+      }
+      downloadItems.value[downloadId].status = "CANCELLED";
+      downloadItems.value[downloadId].failureDetails = "Download was cancelled manually";
+    };
+    controller.signal.addEventListener("abort", abortListener);
+    let tries = 0;
+    while (maxRetries === null || tries < maxRetries) {
+      tries++;
+      await sleep(pollingInterval);
+      const isTerminalState = await handlePollingResult({ downloadId, signal });
+      if (isTerminalState) {
+        break;
+      }
+    }
+    delete abortControllers[downloadId];
+    if (maxRetries !== null && tries >= maxRetries) {
+      downloadItems.value[downloadId].status = "FAILED";
+      downloadItems.value[downloadId].failureDetails = "Download timed out";
+    }
+  };
+  const start = async ({
+    itemId,
+    version,
+    name
+  }) => {
+    try {
+      const response = await $ofetch(
+        `/repository/${itemId}/artifact`,
+        {
+          method: "GET",
+          query: { version }
+        }
+      );
+      if (hasDownloadUrl(response)) {
+        openDownload(response.downloadUrl);
+        return;
+      }
+      await pollDownloadItem({
+        itemId,
+        version,
+        downloadId: response.downloadId,
+        name
+      });
+    } catch (error) {
+      throw rfcErrors.tryParse(error) ?? error;
+    }
+  };
+  const totalItemsBeingZipped = computed(
+    () => Object.values(downloadItems.value).filter(
+      ({ status }) => status === "IN_PROGRESS"
+    ).length
+  );
+  const resetState = () => {
+    for (const [downloadId, controller] of Object.entries(abortControllers)) {
+      controller?.abort();
+      delete abortControllers[downloadId];
+    }
+    downloadItems.value = {};
+  };
+  const downloadItemsArray = computed(() => Object.values(downloadItems.value));
+  return {
+    /**
+     * Initiates a download of the given itemId and version.
+     */
+    start,
+    /**
+     * Cancels the ongoing download for a given itemId (if any).
+     * Sets the status in `downloadItems` to `CANCELLED`.
+     */
+    cancel,
+    /**
+     * Removes item from `downloadItems`.
+     */
+    removeItem,
+    /**
+     * A computed array of all current items that are being zipped and prepared for download.
+     */
+    downloadItems: downloadItemsArray,
+    /**
+     * The total number of zipping items in progress.
+     */
+    totalItemsBeingZipped,
+    /**
+     * Resets the state of the composable, clearing all downloads and controllers.
+     */
+    resetState,
+    /**
+     * Opens a download from the given url
+     */
+    openDownload
+  };
+};
+
+export { API_BASE_URL, DownloadProgressPanel, UploadProgressPanel, createHttpClient, defaultConfig, useDownloadArtifact, useFileUpload };
+//# sourceMappingURL=dataTransfer.js.map