@eodash/eodash 5.0.0-rc.3 → 5.1.0

package/dist/client/index-Da5xXX6Q.js

@@ -1,780 +0,0 @@
-import { onMounted, watch, nextTick, ref, useTemplateRef, computed, createElementBlock, openBlock, createVNode, createCommentVNode, createElementVNode, normalizeStyle, unref, toRaw, createBlock, withCtx, createTextVNode } from 'vue';
-import '@eox/chart';
-import '@eox/drawtools';
-import '@eox/jsonform';
-import { ai as axios, aj as indicator, ak as extractLayerConfig, Y as datetime, al as getLayers, a3 as mapEl, a9 as eoxLayersKey, ac as useOnLayersUpdate, Z as useSTAcStore, V as VBtn } from './asWebComponent-BJ2NWunV.js';
-import { storeToRefs } from 'pinia';
-import { p as pollProcessStatus, c as createLayerDefinition, g as getBboxProperty, e as extractGeometries, _ as _sfc_main$1, u as updateJobsStatus, d as download, j as jobs } from './ProcessList-C62SOVO6.js';
-import log from 'loglevel';
-import mustache from 'mustache';
-import { useEventBus } from '@vueuse/core';
-
-/**
- * @param {import("stac-ts").StacLink[] | undefined} links
- * @param {Record<string,any>|undefined} jsonformValue
- * @param {number[]} origBbox
- */
-function processImage(links, jsonformValue, origBbox) {
-  if (!links) return;
-  const imageLinks = links.filter(
-    (link) => link.rel === "service" && link.type === "image/png",
-  );
-  const layers = [];
-  for (const link of imageLinks) {
-    layers.push({
-      type: "Image",
-      properties: {
-        id: link.id,
-        title: "Results " + link.id,
-      },
-      source: {
-        type: "ImageStatic",
-        imageExtent: origBbox,
-        url: mustache.render(link.href, {
-          ...(jsonformValue ?? {}),
-        }),
-      },
-    });
-  }
-  return layers;
-}
-
-/**
- * @param {import("stac-ts").StacLink[] | undefined} links
- * @param {Record<string,any> | undefined} jsonformValue
- * @param {string} layerId
- */
-async function processVector(links, jsonformValue, layerId) {
-  if (!links) return;
-  /** @type {Record<string,any>[]} */
-  const layers = [];
-  const vectorLinks = links.filter(
-    (link) => link.rel === "service" && link.type === "application/geo+json",
-  );
-  if (vectorLinks.length === 0) return layers;
-
-  let flatStyleJSON = null;
-
-  for (const link of vectorLinks) {
-    if ("eox:flatstyle" in (link ?? {})) {
-      flatStyleJSON = await axios
-        .get(/** @type {string} */ (link["eox:flatstyle"]))
-        .then((resp) => resp.data);
-    }
-
-    /** @type {Record<string,any>|undefined} */
-    let layerConfig;
-    /** @type {Record<string,any>|undefined} */
-    let style;
-    if (flatStyleJSON) {
-      const extracted = extractLayerConfig(flatStyleJSON);
-      layerConfig = extracted.layerConfig;
-      style = extracted.style;
-    }
-
-    layers.push({
-      type: "Vector",
-      source: {
-        type: "Vector",
-        url: mustache.render(link.href, {
-          ...(jsonformValue ?? {}),
-        }),
-        format: "GeoJSON",
-      },
-      properties: {
-        id: layerId + "_vector_process",
-        title: "Results " + layerId,
-        ...(layerConfig && { ...layerConfig, ...(style && { style: style }) }),
-      },
-    });
-  }
-  return layers;
-}
-
-/**
- * @param {import("stac-ts").StacLink[] | undefined} links
- * @param {Record<string,any> | undefined} jsonformValue
- * @param {string} specUrl
- * @returns {Promise<[import("@eox/chart").EOxChart["spec"] | null,Record<string,any>|null]>}
- **/
-async function getChartValues(links, jsonformValue, specUrl) {
-  if (!specUrl || !links) return [null, null];
-  /** @type {import("vega").Spec} */
-  const spec = await axios.get(specUrl).then((resp) => {
-    return resp.data;
-  });
-  // //@ts-expect-error NamedData
-  // const dataName = spec?.data?.name;
-  const dataLinks = links.filter(
-    (link) => link.rel === "service", // && dataName && link.id === dataName,
-  );
-
-  /** @type {Record<string,any>}  */
-  const dataValues = {};
-  for (const link of dataLinks ?? []) {
-    if (link.type && ["application/json", "text/csv"].includes(link.type)) {
-      const dataUrl = mustache.render(link.href, {
-        ...(jsonformValue ?? {}),
-        ...(link["eox:flatstyle"] ?? {}),
-      });
-
-      // Wait for data to be retrieved
-      const data = await axios.get(dataUrl).then((resp) => {
-        return resp.data;
-      });
-      // @ts-expect-error we assume data to exist in spec
-      spec.data.values = data;
-      continue;
-    }
-
-    dataValues[/** @type {string} */ (link.id)] = await axios
-      .get(
-        mustache.render(link.href, {
-          ...(jsonformValue ?? {}),
-          ...(link["eox:flatstyle"] ?? {}),
-        }),
-      )
-      .then((resp) => resp.data);
-  }
-
-  return [spec, dataValues];
-}
-
-/**
- * @param {import("stac-ts").StacLink[] | undefined} links
- * @param {Record<string,any> | undefined} jsonformValue
- * @param {import("vue").Ref<boolean>} isPolling
- * @param {string} layerId
- * @param {string} projection
- */
-async function processGeoTiff(
-  links,
-  jsonformValue,
-  layerId,
-  isPolling,
-  projection,
-) {
-  if (!links) return;
-  const geotiffLinks = links.filter(
-    (link) => link.rel === "service" && link.type === "image/tiff",
-  );
-  let urls = [];
-  let processId = "";
-  for (const link of geotiffLinks ?? []) {
-    if (link.endpoint === "eoxhub_workspaces") {
-      // TODO: prove of concept, needs to be reworked for sure
-      // Special handling for eoxhub workspace process endpoints
-      const postBody = await axios
-        .get(/** @type {string} */ (link["body"]), { responseType: "text" })
-        .then((resp) => resp.data);
-      const jsonData = JSON.parse(
-        mustache.render(postBody, { ...(jsonformValue ?? {}) }),
-      );
-      try {
-        const responseProcess = await axios.post(link.href, jsonData, {
-          headers: {
-            "Content-Type": "application/json",
-          },
-        });
-        console.log(responseProcess.headers.location);
-        // We save the process status url into localstorage assigning it to the indicator id
-        const currentJobs = JSON.parse(
-          localStorage.getItem(indicator.value) || "[]",
-        );
-        currentJobs.push(responseProcess.headers.location);
-        localStorage.setItem(indicator.value, JSON.stringify(currentJobs));
-        await pollProcessStatus({
-          processUrl: responseProcess.headers.location,
-          isPolling,
-        })
-          .then((resultItem) => {
-            // @ts-expect-error we have currently no definition of what is allowed as response
-            const resultUrls = resultItem?.urls;
-            if (resultUrls?.length < 1) {
-              return;
-            }
-            //@ts-expect-error todo
-            processId = resultItem?.id;
-            urls = resultUrls;
-          })
-          .catch((error) => {
-            if (error instanceof Error) {
-              console.error("Polling failed:", error.message);
-            } else {
-              console.error("Unknown error occurred during polling:", error);
-            }
-          });
-      } catch (error) {
-        if (error instanceof Error) {
-          console.error("Error sending POST request:", error.message);
-        } else {
-          console.error("Unknown error occurred:", error);
-        }
-      }
-    } else {
-      urls.push(mustache.render(link.href, { ...(jsonformValue ?? {}) }));
-    }
-  }
-
-  return createLayerDefinition(links[0], layerId, urls, projection, processId);
-}
-
-/**
- * Fetch and set the jsonform schema to initialize the process
- *
- * @export
- * @async
- * @param {Object} params
- * @param {import("vue").Ref<import("stac-ts").StacCollection>} params.selectedStac
- * @param {import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>} params.jsonformEl
- * @param {import("vue").Ref<Record<string,any> | null>} params.jsonformSchema
- * @param {import("vue").Ref<import("@eox/chart").EOxChart["spec"] | null>} params.chartSpec
- * @param {import("vue").Ref<any[]>} params.processResults
- * @param {import("vue").Ref<boolean>} params.isProcessed
- * @param {import("vue").Ref<boolean>} params.loading
- * @param {import("vue").Ref<boolean>} params.isPolling
- */
-async function initProcess({
-  selectedStac,
-  jsonformEl,
-  jsonformSchema,
-  chartSpec,
-  isProcessed,
-  processResults,
-  loading,
-  isPolling,
-}) {
-  if (!selectedStac.value) {
-    return;
-  }
-  resetProcess({
-    loading,
-    isProcessed,
-    chartSpec,
-    jsonformSchema,
-    isPolling,
-    processResults,
-  });
-  if (selectedStac.value["eodash:jsonform"]) {
-    jsonformEl.value?.editor.destroy();
-    // wait for the layers to be rendered
-    jsonformSchema.value = await axios
-      //@ts-expect-error eodash extention
-      .get(selectedStac.value["eodash:jsonform"])
-      .then((resp) => resp.data);
-    // remove borders from jsonform
-  } else {
-    if (!jsonformSchema.value) {
-      return;
-    }
-    jsonformSchema.value = null;
-  }
-}
-
-/**
- *
- * @param {Object} params
- * @param {import("vue").Ref<boolean>} params.loading
- * @param {import("vue").Ref<import("stac-ts").StacCollection | null>} params.selectedStac
- * @param {import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>} params.jsonformEl
- * @param {import("vue").Ref<Record<string,any>|null>} params.jsonformSchema
- * @param {import("vue").Ref<import("@eox/chart").EOxChart["spec"] | null>} params.chartSpec
- * @param {import("vue").Ref<Record<string, any> | null>} params.chartData
- * @param {import("vue").Ref<boolean>} params.isPolling
- * @param {import("vue").Ref<any[]>} params.processResults
- */
-async function handleProcesses({
-  loading,
-  selectedStac,
-  jsonformEl,
-  jsonformSchema,
-  chartSpec,
-  chartData,
-  isPolling,
-  processResults,
-}) {
-  if (!jsonformEl.value || !jsonformSchema.value || !selectedStac.value) {
-    return;
-  }
-  log.debug("Processing...");
-  loading.value = true;
-  try {
-    const serviceLinks = selectedStac.value?.links?.filter(
-      (l) => l.rel === "service",
-    );
-    const bboxProperty = getBboxProperty(jsonformSchema.value);
-    const jsonformValue = /** @type {Record<string,any>} */ (
-      jsonformEl.value?.value
-    );
-
-    extractGeometries(jsonformValue, jsonformSchema.value);
-
-    const origBbox = jsonformValue[bboxProperty];
-
-    const specUrl = /** @type {string} */ (
-      selectedStac.value?.["eodash:vegadefinition"]
-    );
-
-    [chartSpec.value, chartData.value] = await getChartValues(
-      serviceLinks,
-      { ...(jsonformValue ?? {}) },
-      specUrl,
-    );
-    if (Object.keys(chartData.value ?? {}).length) {
-      processResults.value.push(chartData.value);
-    }
-
-    //@ts-expect-error we assume that the spec data is of type InlineData
-    if (chartSpec.value?.data?.values?.length) {
-      //@ts-expect-error we assume that the spec data is of type InlineData
-      processResults.value.push(chartSpec.value?.data.values);
-    }
-
-    if (chartSpec.value && !("background" in chartSpec.value)) {
-      chartSpec.value["background"] = "transparent";
-    }
-
-    const geotiffLayer = await processGeoTiff(
-      serviceLinks,
-      jsonformValue,
-      selectedStac.value?.id ?? "",
-      isPolling,
-      //@ts-expect-error TODO
-      selectedStac.value?.["eodash:mapProjection"]?.["name"] ?? null,
-    );
-
-    if (geotiffLayer && geotiffLayer.source?.sources.length) {
-      processResults.value.push(
-        ...(geotiffLayer.source?.sources?.map((source) => source.url) ?? []),
-      );
-    }
-    // 3. vector geojson
-    const vectorLayers = await processVector(
-      serviceLinks,
-      jsonformValue,
-      selectedStac.value?.id ?? "",
-    );
-
-    if (vectorLayers?.length) {
-      processResults.value.push(
-        ...vectorLayers.map((layer) => layer.source?.url),
-      );
-    }
-
-    const imageLayers = processImage(serviceLinks, jsonformValue, origBbox);
-    if (imageLayers?.length) {
-      processResults.value.push(
-        ...imageLayers.map((layer) => layer.source?.url),
-      );
-    }
-
-    log.debug(
-      "rendered layers after processing:",
-      geotiffLayer,
-      vectorLayers,
-      imageLayers,
-    );
-
-    if (geotiffLayer || vectorLayers?.length || imageLayers?.length) {
-      const layers = [
-        ...(geotiffLayer ? [geotiffLayer] : []),
-        ...(vectorLayers ?? []),
-        ...(imageLayers ?? []),
-      ];
-      let currentLayers = [...getLayers()];
-      let analysisGroup = currentLayers.find((l) =>
-        l.properties.id.includes("AnalysisGroup"),
-      );
-      analysisGroup?.layers.push(...layers);
-
-      if (mapEl.value) {
-        mapEl.value.layers = [...currentLayers];
-      }
-    }
-    loading.value = false;
-  } catch (error) {
-    console.error("[eodash] Error while running process:", error);
-    loading.value = false;
-    throw error;
-  }
-}
-
-/**
- * Reset the process state
- * @param {Object} params
- * @param {import("vue").Ref<boolean>} params.loading
- * @param {import("vue").Ref<boolean>} params.isProcessed
- * @param {import("vue").Ref<import("@eox/chart").EOxChart["spec"] | null>} params.chartSpec
- * @param {import("vue").Ref<boolean>} params.isPolling
- * @param {import("vue").Ref<any[]>} params.processResults
- * @param {import("vue").Ref<Record<string,any>|null>} params.jsonformSchema
- */
-function resetProcess({
-  loading,
-  isProcessed,
-  chartSpec,
-  jsonformSchema,
-  processResults,
-  isPolling,
-}) {
-  loading.value = false;
-  isProcessed.value = false;
-  isPolling.value = false;
-  chartSpec.value = null;
-  processResults.value = [];
-  jsonformSchema.value = null;
-}
-
-/**
- * Handles the click event on a chart to extract temporal information and update the global datetime value.
- *
- * @param {object} evt - The click event object.
- * @param {object} evt.target - The target of the event, expected to have a Vega-Lite specification (`spec`).
- * @param {object} evt.target.spec - The Vega-Lite specification of the chart.
- * @param {Record<string,{type?:string;field?:string;}>} [evt.target.spec.encoding] - The encoding specification of the chart.
- * @param {object} evt.detail - The detail of the event, containing information about the clicked item.
- * @param {import("vega").Item} evt.detail.item - The Vega item that was clicked.
- */
-const onChartClick = (evt) => {
-  const chartSpec = evt.target?.spec;
-  if (!chartSpec) {
-    return;
-  }
-  const encodingKey = Object.keys(chartSpec.encoding ?? {}).find(
-    (key) => chartSpec.encoding?.[key].type === "temporal",
-  );
-  if (!encodingKey) {
-    return;
-  }
-  const temporalKey = chartSpec.encoding?.[encodingKey].field;
-  if (!temporalKey) {
-    return;
-  }
-  try {
-    const vegaItem = evt.detail.item;
-    const temporalValue = new Date(vegaItem.datum.datum[temporalKey]);
-    datetime.value = temporalValue.toISOString();
-  } catch (error) {
-    console.warn(
-      "[eodash] Error while setting datetime from eox-chart:",
-      error,
-    );
-  }
-};
-
-/**
- * Composable resposible of timing the Initialization of the process
- *
- * @export
- * @async
- * @param {Object} params
- * @param {import("vue").Ref<import("stac-ts").StacCollection>} params.selectedStac
- * @param {import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>} params.jsonformEl
- * @param {import("vue").Ref<Record<string,any> | null>} params.jsonformSchema
- * @param {import("vue").Ref<import("@eox/chart").EOxChart["spec"] | null>} params.chartSpec
- * @param {import("vue").Ref<any[]>} params.processResults
- * @param {import("vue").Ref<boolean>} params.isProcessed
- * @param {import("vue").Ref<boolean>} params.loading
- * @param {import("vue").Ref<boolean>} params.isPolling
- */
-const useInitProcess = ({
-  selectedStac,
-  jsonformEl,
-  jsonformSchema,
-  chartSpec,
-  isProcessed,
-  processResults,
-  loading,
-  isPolling,
-}) => {
-  const layersEvents = useEventBus(eoxLayersKey);
-
-  onMounted(async () => {
-    // wait for the layers to be rendered
-    if (mapEl.value?.layers.length > 1) {
-      await initProcess({
-        selectedStac,
-        jsonformEl,
-        jsonformSchema,
-        chartSpec,
-        isProcessed,
-        processResults,
-        loading,
-        isPolling,
-      });
-    } else {
-      layersEvents.once(async () => {
-        await initProcess({
-          selectedStac,
-          jsonformEl,
-          jsonformSchema,
-          chartSpec,
-          isProcessed,
-          loading,
-          processResults,
-          isPolling,
-        });
-      });
-    }
-  });
-
-  useOnLayersUpdate(async (evt, _payload) => {
-    if (evt === "layers:updated") {
-      await initProcess({
-        selectedStac,
-        jsonformEl,
-        jsonformSchema,
-        chartSpec,
-        isProcessed,
-        processResults,
-        loading,
-        isPolling,
-      });
-    }
-  });
-};
-
-/**
- * Auto execute the process when the jsonform has the execute option
- *
- * @param {import("vue").Ref<boolean>} autoExec
- * @param {import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>} jsonformEl
- * @param {import("vue").Ref<Record<string,any> | null>} jsonformSchema
- * @param {() => Promise<void>} startProcess
- **/
-function useAutoExec(
-  autoExec,
-  jsonformEl,
-  jsonformSchema,
-  startProcess,
-) {
-  /**
-   * @param {CustomEvent} _e
-   **/
-  const onJsonFormChange = async (_e) => {
-    await startProcess();
-  };
-
-  const addEventListener = async () => {
-    await nextTick(() => {
-      //@ts-expect-error TODO
-      jsonformEl.value?.addEventListener("change", onJsonFormChange);
-    });
-  };
-  const removeEventListener = () => {
-    //@ts-expect-error TODO
-    jsonformEl.value?.removeEventListener("change", onJsonFormChange);
-  };
-
-  watch(jsonformSchema, (updatedSchema) => {
-    autoExec.value = updatedSchema?.options?.["execute"] || false;
-  });
-
-  onMounted(() => {
-    watch(
-      autoExec,
-      async (exec) => {
-        if (exec) {
-          await addEventListener();
-        } else {
-          removeEventListener();
-        }
-      },
-      { immediate: true },
-    );
-  });
-}
-
-const _hoisted_1 = {
-  ref: "container",
-  class: "process-container"
-};
-const _hoisted_2 = [".schema"];
-const _hoisted_3 = [".spec", ".dataValues"];
-const _hoisted_4 = { style: {"text-align":"right"} };
-
-/** @type {import("vue").Ref<import("vega").Spec|null>} */
-
-const _sfc_main = {
-  __name: 'index',
-  setup(__props) {
-
-const chartSpec = ref(null);
-
-/** @type {import("vue").Ref<Record<string,any>|null>}  */
-const chartData = ref(null);
-const isProcessed = ref(false);
-
-/** @type {import("vue").Ref<Record<string,any>|null>} */
-const jsonformSchema = ref(null);
-
-const jsonformEl =
-  /** @type {Readonly<import("vue").ShallowRef<import("@eox/jsonform").EOxJSONForm | null>>} */ (
-    useTemplateRef("jsonformEl")
-  );
-const isAsync = computed(
-  () =>
-    selectedStac.value?.links.filter((l) => l.endpoint === "eoxhub_workspaces")
-      .length,
-);
-const containerEl = useTemplateRef("container");
-
-const loading = ref(false);
-
-const autoExec = ref(false);
-
-const isPolling = ref(false);
-/** @type {import("vue").Ref<any[]>} */
-const processResults = ref([]);
-
-const { selectedStac } = storeToRefs(useSTAcStore());
-
-useInitProcess({
-  //@ts-expect-error TODO
-  selectedStac,
-  jsonformEl,
-  jsonformSchema,
-  chartSpec,
-  isProcessed,
-  processResults,
-  loading,
-  isPolling,
-});
-
-const downloadResults = () => {
-  processResults.value.forEach((result) => {
-    if (!result) {
-      return;
-    }
-    let fileName = "";
-    if (typeof result === "string") {
-      fileName = result.includes("/")
-        ? (result.split("/").pop() ?? "")
-        : result;
-      fileName = fileName.includes("?") ? fileName.split("?")[0] : fileName;
-    } else {
-      fileName = selectedStac.value?.id + "_process_results.json";
-    }
-    download(fileName, result);
-  });
-};
-
-const startProcess = async () => {
-  /** @param {*} jsonformSchema */
-  const getDrawToolsProperty = (jsonformSchema) => {
-    for (const property in jsonformSchema.properties) {
-      if (jsonformSchema.properties[property]?.options?.drawtools) {
-        return property;
-      }
-    }
-  };
-  const drawToolsProperty = getDrawToolsProperty(jsonformSchema.value);
-  const propertyIsEmpty =
-    drawToolsProperty &&
-    //@ts-expect-error jsonfrom.value is not typed
-    Array.isArray(jsonformEl.value?.value[drawToolsProperty]) &&
-    //@ts-expect-error jsonfrom.value is not typed
-    !jsonformEl.value?.value[drawToolsProperty].length;
-
-  if (propertyIsEmpty) {
-    isProcessed.value = false;
-    chartSpec.value = null;
-    return;
-  }
-  const errors = jsonformEl.value?.editor.validate();
-  if (errors?.length) {
-    console.warn("[eodash] Form validation failed", errors);
-    return;
-  }
-
-  processResults.value = [];
-
-  await handleProcesses({
-    jsonformEl,
-    jsonformSchema,
-    chartSpec,
-    chartData,
-    loading,
-    //@ts-expect-error TODO
-    selectedStac,
-    isPolling,
-    processResults,
-  });
-
-  isProcessed.value = true;
-  if (isAsync.value) updateJobsStatus(jobs, indicator);
-};
-useAutoExec(autoExec, jsonformEl, jsonformSchema, startProcess);
-
-const chartStyles = computed(() => {
-  /** @type {Record<string,string> }*/
-  const styles = {};
-  if (!chartSpec.value?.["height"]) {
-    styles["height"] =
-      Math.max(
-        (containerEl.value?.offsetHeight ?? 0) -
-          (jsonformEl.value?.offsetHeight ?? 0),
-        200,
-      ) + "px";
-  }
-  return styles;
-});
-
-return (_ctx, _cache) => {
-                                                     
-
-  return (openBlock(), createElementBlock("div", _hoisted_1, [
-    createVNode(_sfc_main$1),
-    (jsonformSchema.value)
-      ? (openBlock(), createElementBlock("eox-jsonform", {
-          key: 0,
-          ref_key: "jsonformEl",
-          ref: jsonformEl,
-          ".schema": jsonformSchema.value
-        }, null, 40 /* PROPS, NEED_HYDRATION */, _hoisted_2))
-      : createCommentVNode("v-if", true),
-    (isProcessed.value && chartSpec.value)
-      ? (openBlock(), createElementBlock("eox-chart", {
-          key: 1,
-          class: "chart",
-          ".spec": toRaw(chartSpec.value),
-          ".dataValues": toRaw(chartData.value),
-          "onClick:item": _cache[0] || (_cache[0] = (...args) => (unref(onChartClick) && unref(onChartClick)(...args))),
-          style: normalizeStyle(chartStyles.value)
-        }, null, 44 /* STYLE, PROPS, NEED_HYDRATION */, _hoisted_3))
-      : createCommentVNode("v-if", true),
-    createElementVNode("div", _hoisted_4, [
-      (!autoExec.value)
-        ? (openBlock(), createBlock(VBtn, {
-            key: 0,
-            loading: loading.value,
-            style: {"margin-right":"20px"},
-            onClick: startProcess,
-            color: "primary"
-          }, {
-            default: withCtx(() => _cache[1] || (_cache[1] = [
-              createTextVNode(" Execute ")
-            ])),
-            _: 1 /* STABLE */
-          }, 8 /* PROPS */, ["loading"]))
-        : createCommentVNode("v-if", true),
-      (processResults.value.length && isProcessed.value && !isAsync.value)
-        ? (openBlock(), createBlock(VBtn, {
-            key: 1,
-            color: "primary",
-            onClick: downloadResults
-          }, {
-            default: withCtx(() => _cache[2] || (_cache[2] = [
-              createTextVNode(" Download ")
-            ])),
-            _: 1 /* STABLE */
-          }))
-        : createCommentVNode("v-if", true)
-    ])
-  ], 512 /* NEED_PATCH */))
-}
-}
-
-};
-
-export { _sfc_main as default };