@eodash/eodash 5.0.0 → 5.2.0

package/dist/client/index-4UCzZi8B.js

@@ -0,0 +1,376 @@
+import { onMounted, watch, nextTick, ref, useTemplateRef, computed, createElementBlock, openBlock, createVNode, createCommentVNode, createElementVNode, unref, normalizeStyle, toRaw, createBlock, withCtx, createTextVNode } from 'vue';
+import '@eox/chart';
+import '@eox/drawtools';
+import '@eox/jsonform';
+import { Q as eoxLayersKey, P as useOnLayersUpdate, _ as _export_sfc, E as useSTAcStore, G as VBtn } from './asWebComponent-ZyEzWOOf.js';
+import { storeToRefs } from 'pinia';
+import { P as ProcessList, c as compareJobs, j as jobs } from './ProcessList-vecpxThi.js';
+import { i as initProcess, o as onChartClick, h as handleProcesses } from './handling-BS24aG1q.js';
+import { useEventBus } from '@vueuse/core';
+import { u as updateJobsStatus, d as download } from './async-B7jIrM53.js';
+import { D as compareIndicator, C as indicator, I as mapCompareEl, d as mapEl } from './helpers-wXK7Ywio.js';
+import { mdiCogPlayOutline, mdiDownloadCircleOutline } from '@mdi/js';
+
+/**
+ * Composable resposible of timing the Initialization of the process
+ *
+ * @export
+ * @async
+ * @param {Object} params
+ * @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<any[]>} params.processResults
+ * @param {import("vue").Ref<boolean>} params.isProcessed
+ * @param {import("vue").Ref<boolean>} params.loading
+ * @param {import("vue").Ref<boolean>} params.isPolling
+ * @param {import("@eox/map").EOxMap | null} params.mapElement
+ */
+const useInitProcess = ({
+  selectedStac,
+  jsonformEl,
+  jsonformSchema,
+  chartSpec,
+  isProcessed,
+  processResults,
+  loading,
+  isPolling,
+  mapElement,
+}) => {
+  const layersEvents = useEventBus(eoxLayersKey);
+
+  onMounted(async () => {
+    // wait for the layers to be rendered
+    if ((mapElement?.layers.length ?? 0) > 1) {
+      await initProcess({
+        enableCompare: mapElement?.id === "compare",
+        selectedStac,
+        jsonformEl,
+        jsonformSchema,
+        chartSpec,
+        isProcessed,
+        processResults,
+        loading,
+        isPolling,
+      });
+    } else {
+      layersEvents.once(async () => {
+        await initProcess({
+          enableCompare: mapElement?.id === "compare",
+          selectedStac,
+          jsonformEl,
+          jsonformSchema,
+          chartSpec,
+          isProcessed,
+          loading,
+          processResults,
+          isPolling,
+        });
+      });
+    }
+  });
+
+  const evtKey =
+    mapElement?.id === "compare" ? "compareLayers:updated" : "layers:updated";
+  useOnLayersUpdate(async (evt, _payload) => {
+    if (evt !== evtKey) {
+      return;
+    }
+    await initProcess({
+      enableCompare: mapElement?.id === "compare",
+      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 _style_0 = "eox-chart{--background-color: transparent;padding-top:1em}eox-jsonform{padding:.7em;min-height:0px}";
+
+const _hoisted_1 = {
+  ref: "container",
+  class: "pb-4"
+};
+const _hoisted_2 = [".schema"];
+const _hoisted_3 = [".spec", ".dataValues", ".opt"];
+const _hoisted_4 = { class: "mt-4 text-right" };
+
+
+const _sfc_main = {
+  __name: 'index',
+  props: {
+  enableCompare: {
+    type: Boolean,
+    default: false,
+  },
+  vegaEmbedOptions: {
+    type: Object,
+    default() {
+      return { actions: true };
+    },
+  },
+},
+  setup(__props) {
+
+
+/** @type {import("vue").Ref<import("vega").Spec|null>} */
+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 showExecBtn = computed(
+  () =>
+    !autoExec.value &&
+    (!!jsonformSchema.value || !!chartSpec.value) &&
+    !!jsonformEl.value,
+);
+const { selectedStac, selectedCompareStac } = storeToRefs(useSTAcStore());
+const currentSelectedStac = __props.enableCompare ? selectedCompareStac : selectedStac;
+const mapElement = __props.enableCompare ? mapCompareEl : mapEl;
+const currentIndicator = __props.enableCompare ? compareIndicator : indicator;
+const currentJobs = __props.enableCompare ? compareJobs : jobs;
+
+const jsonformKey = computed(
+  () => currentIndicator.value + mapElement.value?.id,
+);
+
+useInitProcess({
+  selectedStac: currentSelectedStac,
+  mapElement: mapElement.value,
+  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 = currentSelectedStac.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({
+    jobs: currentJobs,
+    selectedStac: currentSelectedStac,
+    jsonformEl,
+    jsonformSchema,
+    chartSpec,
+    chartData,
+    loading,
+    isPolling,
+    processResults,
+    mapElement: mapElement.value,
+  });
+
+  isProcessed.value = true;
+  if (isAsync.value) updateJobsStatus(currentJobs, currentIndicator.value);
+};
+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(ProcessList, {
+      "map-element": unref(mapElement),
+      "enable-compare": __props.enableCompare
+    }, null, 8 /* PROPS */, ["map-element", "enable-compare"]),
+    (jsonformSchema.value)
+      ? (openBlock(), createElementBlock("eox-jsonform", {
+          key: jsonformKey.value,
+          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),
+          ".opt": __props.vegaEmbedOptions
+        }, null, 44 /* STYLE, PROPS, NEED_HYDRATION */, _hoisted_3))
+      : createCommentVNode("v-if", true),
+    createElementVNode("div", _hoisted_4, [
+      (showExecBtn.value)
+        ? (openBlock(), createBlock(VBtn, {
+            key: 0,
+            loading: loading.value,
+            style: {"margin-right":"20px"},
+            "append-icon": [unref(mdiCogPlayOutline)],
+            onClick: startProcess,
+            color: "primary"
+          }, {
+            default: withCtx(() => _cache[1] || (_cache[1] = [
+              createTextVNode(" Execute ", -1 /* CACHED */)
+            ])),
+            _: 1 /* STABLE */,
+            __: [1]
+          }, 8 /* PROPS */, ["loading", "append-icon"]))
+        : createCommentVNode("v-if", true),
+      (processResults.value.length && isProcessed.value && !isAsync.value)
+        ? (openBlock(), createBlock(VBtn, {
+            key: 1,
+            color: "primary",
+            "append-icon": [unref(mdiDownloadCircleOutline)],
+            onClick: downloadResults
+          }, {
+            default: withCtx(() => _cache[2] || (_cache[2] = [
+              createTextVNode(" Download ", -1 /* CACHED */)
+            ])),
+            _: 1 /* STABLE */,
+            __: [2]
+          }, 8 /* PROPS */, ["append-icon"]))
+        : createCommentVNode("v-if", true)
+    ])
+  ], 512 /* NEED_PATCH */))
+}
+}
+
+};
+const index = /*#__PURE__*/_export_sfc(_sfc_main, [['styles',[_style_0]]]);
+
+export { index as default };

package/dist/client/{index-4CT7Tz83.js → index-9KR-G20t.js}

@@ -1,6 +1,6 @@
 import { resolveComponent, render, h, mergeProps } from 'vue';
-import { E as isObject, an as consoleError } from './asWebComponent-CLhcT715.js';
-import { V as VTooltip } from './VTooltip-CfeefrXI.js';
+import { W as consoleError, X as isObject } from './asWebComponent-ZyEzWOOf.js';
+import { V as VTooltip } from './VTooltip-J4ac48X7.js';
 
 // Utilities
 function useDirectiveComponent(component, props) {