@eodash/eodash 5.0.0 → 5.1.0

package/dist/client/async-DkSu_u2K.js

@@ -0,0 +1,740 @@
+import { n as getCompareLayers, l as getLayers, p as replaceLayer, h as extractLayerConfig, m as mergeGeojsons, f as axios, N as axios$1, C as compareIndicator, B as indicator } from './helpers-Dy0Q13tP.js';
+import { a4 as useEmitLayersUpdate } from './asWebComponent-By_7_JjS.js';
+import { isMulti } from '@eox/jsonform/src/custom-inputs/spatial/utils';
+import log from 'loglevel';
+
+/**
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+function getBboxProperty(jsonformSchema) {
+  return /** @type {string} */ (
+    Object.keys(jsonformSchema?.properties ?? {}).find(
+      (key) => jsonformSchema?.properties[key].format === "bounding-box",
+    )
+  );
+}
+
+/**
+ * Extracts the keys of type "geojson" from the jsonform schema
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+function getGeoJsonProperties(jsonformSchema) {
+  return /** @type {string[]} */ (
+    Object.keys(jsonformSchema?.properties ?? {}).filter(
+      (key) => jsonformSchema?.properties[key].type === "geojson",
+    )
+  );
+}
+
+/**
+ * Converts jsonform geojson values to stringified geometries
+ * @param {Record<string,any> |null} [jsonformSchema]
+ * @param {Record<string,any>} jsonformValue
+ **/
+function extractGeometries(jsonformValue, jsonformSchema) {
+  const geojsonKeys = getGeoJsonProperties(jsonformSchema);
+
+  for (const key of geojsonKeys) {
+    if (!jsonformValue[key]) {
+      continue;
+    }
+
+    if (isMulti(jsonformSchema?.properties[key])) {
+      // jsonformValue[key] is a feature collection
+      jsonformValue[key] =
+        /** @type {import("ol/format/GeoJSON").GeoJSONFeatureCollection} */ (
+          jsonformValue[key]
+        ).features.map((feature) => JSON.stringify(feature.geometry));
+    } else {
+      // jsonformValue[key] is a single feature
+      jsonformValue[key] = JSON.stringify(jsonformValue[key].geometry);
+    }
+  }
+}
+
+/**
+ *
+ * @param {import("stac-ts").StacLink} link
+ * @param {string} layerId
+ * @param {string[]} urls
+ * @param {import("openlayers").ProjectionLike} projection
+ * @param {string} processId
+ */
+async function createTiffLayerDefinition(
+  link,
+  layerId,
+  urls,
+  projection,
+  processId,
+) {
+  let flatStyleJSON = null;
+  if ("eox:flatstyle" in (link ?? {})) {
+    flatStyleJSON = await axios
+      .get(/** @type {string} */ (link["eox:flatstyle"]))
+      .then((resp) => resp.data);
+  }
+
+  let layerConfig;
+  let style;
+  if (flatStyleJSON) {
+    const extracted = extractLayerConfig(layerId ?? "", flatStyleJSON);
+    layerConfig = extracted.layerConfig;
+    style = extracted.style;
+  }
+  // We want to make sure the urls are alphabetically sorted
+  urls = urls.sort();
+  /** @type {import("@eox/map/src/layers").EOxLayerType<"WebGLTile","GeoTIFF"> | undefined} */
+  const layerdef =
+    urls.length > 0
+      ? {
+          type: "WebGLTile",
+          source: {
+            type: "GeoTIFF",
+            normalize: !style,
+            sources: urls.map((url) => ({ url })),
+          },
+          properties: {
+            id: link.id + "_process" + processId,
+            title: "Results " + layerId,
+            ...(layerConfig && { layerConfig: layerConfig }),
+            layerControlToolsExpand: true,
+          },
+          ...(style && { style: style }),
+        }
+      : undefined;
+
+  // We want to see if the currently selected indicator uses a
+  // specific map projection if it does we want to apply it
+  if (projection && layerdef) {
+    //@ts-expect-error TODO
+    layerdef.source.projection = projection;
+  }
+  return layerdef;
+}
+/**
+ * @param {string} fileName
+ * @param {string|Record<string,any>} content
+ * @returns
+ */
+const download = (fileName, content) => {
+  if (!content) {
+    return;
+  }
+  let url = /** @type string */ (content);
+  if (typeof content === "object") {
+    content = JSON.stringify(content);
+    const blob = new Blob([content], { type: "text" });
+    url = URL.createObjectURL(blob);
+  }
+  const link = document.createElement("a");
+  if (confirm(`Would you like to download ${fileName}?`)) {
+    link.href = url;
+    link.download = fileName;
+    link.click();
+  }
+  URL.revokeObjectURL(url);
+  link.remove();
+};
+
+/**
+ * Generate time pairs from a temporal extent
+ * @param {import("stac-ts").TemporalExtent} stacExtent - [start, end]
+ * @param {import("stac-ts").TemporalExtent} [userExtent] -[start, end]
+ * @param {string} [distribution] - daily, weekly, monthly, or yearly
+ */
+function generateTimePairs(stacExtent, userExtent, distribution) {
+  // check whether the userExtent is provided
+  // if it is check that it doesn't exceed the stacExtent
+  // and clamp it otherwise
+
+  /** @type {string|Date} */
+  let from = "";
+
+  /** @type {string|Date} */
+  let to = "";
+  [from, to] = /** @type {[string, string]} */ (userExtent ?? ["", ""]);
+
+  const [stacFrom, stacTo] = /** @type {[string, string]} */ (
+    stacExtent ?? ["", ""]
+  );
+
+  try {
+    if (from && to) {
+      from = new Date(from);
+      to = new Date(to);
+    } else {
+      from = new Date(stacFrom);
+      to = new Date(stacTo);
+    }
+
+    if (from < new Date(stacFrom) || from > new Date(stacTo)) {
+      console.warn(
+        "[eodash] warn: start date is outside of the collection temporal extent and will be clamped",
+        `\nprovided start date:${from.toISOString()}`,
+        `\ncollection start date:${stacFrom}`,
+      );
+      from = new Date(stacFrom);
+    }
+
+    if (to > new Date(stacTo) || to < new Date(stacFrom)) {
+      console.warn(
+        "[eodash] warn: end date is outside of the collection temporal extent and will be clamped",
+        `\nprovided end date:${to.toISOString()}`,
+        `\ncollection end date:${stacTo}`,
+      );
+      to = new Date(stacTo);
+    }
+
+    if (from > to) {
+      console.error(
+        "[eodash] Error: start date is greater than end date",
+        from,
+        to,
+      );
+      return [];
+    }
+  } catch (e) {
+    //@ts-expect-error e should be an error
+    console.error("[eodash] Invalid date:", e.message);
+    return [];
+  }
+
+  const startDate = /** @type {Date} */ (from).toISOString();
+  const endDate = /** @type {Date} */ (to).toISOString();
+
+  if (!startDate || !endDate) {
+    return [];
+  }
+  const times = [];
+  let latest = new Date(endDate);
+  const start = new Date(startDate);
+  const oneDay = 24 * 60 * 60 * 1000;
+  // Use fixed step of 1 day (in milliseconds)
+  const step =
+    distribution === "daily"
+      ? oneDay
+      : distribution === "weekly"
+        ? oneDay * 7
+        : distribution === "monthly"
+          ? oneDay * 30
+          : distribution === "yearly"
+            ? oneDay * 365
+            : oneDay;
+
+  // Add dates, limiting to 31 dates (30 pairs maximum)
+  while (latest >= start && times.length < 31) {
+    times.push(new Date(latest));
+    latest.setTime(latest.getTime() - step);
+  }
+
+  const timePairs = [];
+  for (let i = 0; i < times.length - 1; i++) {
+    timePairs.push([times[i].toISOString(), times[i + 1].toISOString()]);
+  }
+
+  return timePairs;
+}
+
+/**
+ * Filter links to separate those with and without endpoint property
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {string} [relType] - Optional relationship type
+ * @param {string} [contentType] - Optional content type
+ * @returns {[import("stac-ts").StacLink[], import("stac-ts").StacLink[]]}
+ */
+function separateEndpointLinks(links, relType, contentType) {
+  if (!links) return [[], []];
+  const standardLinks = [];
+  const endpointLinks = [];
+
+  for (const link of links) {
+    // Check if the link matches the specified relType and contentType (if provided)
+    const relTypeMatch = link.rel === relType ;
+    const contentTypeMatch = contentType ? link.type === contentType : true;
+
+    if (relTypeMatch && contentTypeMatch) {
+      if (link.endpoint) {
+        endpointLinks.push(link);
+      } else {
+        standardLinks.push(link);
+      }
+    }
+  }
+
+  return [standardLinks, endpointLinks];
+}
+
+/**
+ * Generates layer definitions for asynchronous process results.
+ * using AsyncProcessResults data structure.
+ * @param {import("^/EodashProcess/types").AsyncProcessResults} processResults
+ * @param {import("stac-ts").StacLink} endpointLink
+ * @param {import("stac-ts").StacCollection|null} selectedStac
+ * @param {string} [postfixId=""] - Optional layers id postfix
+ * @returns
+ */
+async function creatAsyncProcessLayerDefinitions(
+  processResults,
+  endpointLink,
+  selectedStac,
+  postfixId = "",
+) {
+  /** @type {import("@eox/map").EoxLayer[]} */
+  const layers = [];
+  const flatStyles = await fetchProcessStyles(endpointLink);
+
+  for (const resultItem of processResults) {
+    const flatStyleJSON = extractStyleFromResult(resultItem, flatStyles);
+    let style, layerConfig;
+    if (flatStyleJSON) {
+      const extracted = extractLayerConfig(
+        selectedStac?.id ?? "",
+        flatStyleJSON,
+      );
+      layerConfig = extracted.layerConfig;
+      style = extracted.style;
+    }
+
+    switch (resultItem.type) {
+      case "image/tiff": {
+        layers.push({
+          type: "WebGLTile",
+          properties: {
+            id: endpointLink.id + "_process" + resultItem.id + postfixId,
+            title:
+              "Results " +
+              (selectedStac?.id ?? "") +
+              " " +
+              (resultItem.id ?? ""),
+            layerControlToolsExpand: true,
+            ...(layerConfig && { layerConfig }),
+          },
+          source: {
+            type: "GeoTIFF",
+            normalize: !style,
+            sources: resultItem.urls.map((url) => ({ url })),
+            //@ts-expect-error TODO
+            ...(selectedStac["eodash:mapProjection"]?.["name"] && {
+              //@ts-expect-error TODO
+              projection: selectedStac["eodash:mapProjection"]["name"],
+            }),
+          },
+          ...(style && { style }),
+        });
+        break;
+      }
+      case "application/geo+json": {
+        const mergedUrl = await mergeGeojsons(resultItem.urls);
+        layers.push({
+          type: "Vector",
+          source: {
+            type: "Vector",
+            format: "GeoJSON",
+            ...(mergedUrl && { url: mergedUrl }),
+          },
+          properties: {
+            id: endpointLink.id + "_process_" + resultItem.id + postfixId,
+            title:
+              "Results " +
+              (selectedStac?.id ?? "") +
+              " " +
+              (resultItem.id ?? ""),
+            ...(layerConfig && {
+              layerConfig: {
+                ...layerConfig,
+                style,
+              },
+            }),
+          },
+          ...(!style?.variables && { style }),
+          interactions: [],
+        });
+        break;
+      }
+      default:
+        console.warn(
+          `[eodash] Unsupported result type "${resultItem.type}" for ${resultItem.id} layer creation.`,
+        );
+        break;
+    }
+  }
+  return layers;
+}
+
+/**
+ * @param {import("stac-ts").StacLink} endpointLink
+ * @returns
+ */
+async function fetchProcessStyles(endpointLink) {
+  /** @type {import("@/types").EodashStyleJson | (Record<string,import("@/types").EodashStyleJson> & {multipleStyles:true}) | null} */
+  let flatStyles = null;
+  if (endpointLink["eox:flatstyle"]) {
+    if (typeof endpointLink["eox:flatstyle"] === "string") {
+      flatStyles = await axios
+        .get(/** @type {string} */ (endpointLink["eox:flatstyle"]))
+        .then((resp) => /** @type {} */ resp.data);
+    } else if (
+      Array.isArray(endpointLink["eox:flatstyle"]) &&
+      endpointLink["eox:flatstyle"].length
+    ) {
+      // multipleStyles as a flag to indicate it
+      flatStyles = { multipleStyles: true };
+
+      await Promise.all(
+        /** @type {{id:string;url:string}[]} */
+        (endpointLink["eox:flatstyle"]).map(async (styleDict) => {
+          //@ts-expect-error TODO
+          flatStyles[styleDict.id] = await axios
+            .get(styleDict.url)
+            .then(
+              (resp) =>
+                /** @type {import("@/types").EodashStyleJson} */ (resp.data),
+            );
+        }),
+      );
+    } else {
+      // multipleStyles as a flag to indicate it
+      flatStyles = { multipleStyles: true };
+      await Promise.all(
+        Object.keys(endpointLink["eox:flatstyle"] ?? {}).map((key) => {
+          //@ts-expect-error TODO
+          flatStyles[key] = axios
+            //@ts-expect-error TODO
+            .get(endpointLink["eox:flatstyle"][key])
+            .then((resp) => resp.data);
+        }),
+      );
+    }
+  }
+  return flatStyles;
+}
+
+/**
+ *
+ * @param {import("^/EodashProcess/types").AsyncProcessResults[number]} processResult
+ * @param {null| import("@/types").EodashStyleJson | (Record<string,import("@/types").EodashStyleJson> & {multipleStyles:true})} flatStyles
+ */
+function extractStyleFromResult(processResult, flatStyles) {
+  if (!flatStyles) {
+    return undefined;
+  }
+  if (!("multipleStyles" in flatStyles)) {
+    return flatStyles;
+  }
+
+  const outputKey = processResult.id;
+  if (!outputKey || !(outputKey in flatStyles)) {
+    return undefined;
+  }
+  return flatStyles[outputKey];
+}
+
+/**
+ *
+ * @param {import("^/EodashProcess/types").EOxHubProcessResults} resultItem
+ * @returns {import("^/EodashProcess/types").AsyncProcessResults}
+ */
+function extractAsyncResults(resultItem) {
+  if (!resultItem) {
+    return [];
+  }
+  // if no type specified we assume the results are geotiff sources
+  if ("urls" in resultItem && Array.isArray(resultItem.urls)) {
+    return [{ id: "", urls: resultItem.urls, type: "image/tiff" }];
+  }
+
+  const extracted = [];
+  for (const key in resultItem) {
+    if (key === "id") {
+      continue;
+    }
+    extracted.push({
+      // used as a key to identify the corresponding style
+      id: key,
+      //@ts-expect-error TODO
+      urls: /** @type {string[]} */ (resultItem[key].urls),
+      //@ts-expect-error TODO
+      type: /** @type {string} */ (resultItem[key].mimetype),
+    });
+  }
+  return extracted;
+}
+/**
+ * @param {import("@eox/map").EOxMap | null} mapElement
+ * @param {import("@eox/map").EoxLayer[]} processLayers
+ */
+const applyProcessLayersToMap = (mapElement, processLayers) => {
+  if (!processLayers.length || !mapElement) {
+    return;
+  }
+  const getMapLayers =
+    mapElement.id === "compare" ? getCompareLayers : getLayers;
+  const currentLayers = [...getMapLayers()];
+
+  let analysisGroup =
+    /*** @type {import("@eox/map/src/layers").EOxLayerTypeGroup | undefined} */ (
+      currentLayers.find((l) => l.properties?.id.includes("AnalysisGroup"))
+    );
+  if (!analysisGroup) {
+    return;
+  }
+
+  for (const layer of processLayers) {
+    const exists = analysisGroup.layers.find(
+      (l) => l.properties?.id === layer.properties?.id,
+    );
+    if (!exists) {
+      analysisGroup.layers.unshift(layer);
+    } else {
+      analysisGroup.layers = replaceLayer(
+        analysisGroup.layers,
+        layer.properties?.id ?? "",
+        [layer],
+      );
+    }
+  }
+  if (mapElement) {
+    const layers = [...currentLayers];
+    const evtKey =
+      mapElement.id === "compare"
+        ? "compareProcess:updated"
+        : "process:updated";
+    useEmitLayersUpdate(evtKey, mapElement, layers);
+    mapElement.layers = layers;
+  }
+};
+/**
+ * Updates the jsonform schema to target the compare map
+ * @param {import("json-schema").JSONSchema7 | null | undefined} jsonformSchema
+ */
+function updateJsonformSchemaTarget(jsonformSchema) {
+  if (!jsonformSchema) {
+    return jsonformSchema;
+  }
+  const stringified = JSON.stringify(jsonformSchema).replaceAll(
+    "eox-map#main",
+    "eox-map#compare",
+  );
+  return /** @type {import("json-schema").JSONSchema7} */ (
+    JSON.parse(stringified)
+  );
+}
+
+/**
+ * Polls the process status and fetches a result item when the process is successful.
+ *
+ * @param {Object} params - Parameters for polling the process status.
+ * @param {import("vue").Ref<import("../types").AsyncJob[]>} params.jobs - The list of jobs to update.
+ * @param {string} params.processUrl - The URL of the process JSON report.
+ * @param {import("vue").Ref<boolean>} params.isPolling - checks wether the polling should continue
+ * @param {number} [params.pollInterval=5000] - The interval (in milliseconds) between polling attempts.
+ * @param {number} [params.maxRetries=60] - The maximum number of polling attempts.
+ * @param {boolean} [params.enableCompare=false] - Whether to enable comparison mode, affecting the indicator used.
+ * @returns {Promise<import("../types").EOxHubProcessResults>} The fetched results JSON.
+ * @throws {Error} If the process does not complete successfully within the maximum retries.
+ */
+async function pollProcessStatus({
+  jobs,
+  processUrl,
+  isPolling,
+  pollInterval = 10000,
+  maxRetries = 560,
+  enableCompare = false,
+}) {
+  let retries = 0;
+  isPolling.value = true;
+  // Ensure the jobs status is updated after the job has started and before polling
+  setTimeout(() => {
+    updateJobsStatus(
+      jobs,
+      enableCompare ? compareIndicator.value : indicator.value,
+    );
+  }, 500);
+
+  while (retries < maxRetries && isPolling.value) {
+    try {
+      // Fetch the process JSON report
+      const cacheBuster = new Date().getTime(); // Add a timestamp for cache busting
+      const response = await axios$1.get(`${processUrl}?t=${cacheBuster}`);
+      const processReport = response.data;
+
+      // Check if the status is "successful"
+      if (processReport.status === "successful") {
+        console.log("Process completed successfully. Fetching result item...");
+
+        // Extract the result item URL
+        const resultsUrl = processReport.links[1].href;
+        if (!resultsUrl) {
+          throw new Error(`Result links not found in the process report.`);
+        }
+
+        // Fetch the result item
+        const resultResponse = await axios$1.get(resultsUrl);
+        console.log("Result file fetched successfully:", resultResponse.data);
+        return resultResponse.data; // Return the json result list
+      }
+      if (processReport.status === "failed") {
+        isPolling.value = false;
+        throw new Error("Process failed.", processReport);
+      }
+
+      // Log the current status if not successful
+      console.log(
+        `Status: ${processReport.status}. Retrying in ${pollInterval / 1000} seconds...`,
+      );
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("Error while polling process status:", error.message);
+      } else {
+        console.error("Unknown error occurred:", error);
+      }
+    }
+
+    // Wait for the next poll
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    retries++;
+  }
+  if (!isPolling.value) {
+    console.warn("Polling was stopped before the process was completed.");
+    return JSON.parse("{}");
+  }
+
+  throw new Error(
+    "Max retries reached. Process did not complete successfully.",
+  );
+}
+
+/**
+ *
+ * @param {import("vue").Ref<import("../types").AsyncJob[]>} jobs
+ * @param {string} indicator
+ */
+async function updateJobsStatus(jobs, indicator) {
+  /** @type {string[]} */
+  const jobsUrls = JSON.parse(localStorage.getItem(indicator) || "[]");
+  /** @type {import("../types").AsyncJob[]} */
+  const jobResults = await Promise.all(
+    jobsUrls.map((url) =>
+      axios$1
+        .get(url, { params: { t: Date.now() } })
+        .then((response) => response.data),
+    ),
+  );
+  jobResults.sort((a, b) => {
+    return (
+      new Date(b.job_start_datetime).getTime() -
+      new Date(a.job_start_datetime).getTime()
+    );
+  });
+  jobs.value = jobResults;
+}
+
+/**
+ * Removes a job from the local storage and updates the job status
+ * @param {import("vue").Ref<import("../types").AsyncJob[]>} jobs
+ * @param {import("../types").AsyncJob} jobObject
+ * @param {string} indicator
+ */
+const deleteJob = async (jobs, jobObject, indicator) => {
+  /** @type {string[]} */
+  const jobsUrls = JSON.parse(localStorage.getItem(indicator) || "[]");
+  const newJobs = jobsUrls.filter((url) => !url.includes(jobObject.jobID));
+  localStorage.setItem(indicator, JSON.stringify(newJobs));
+  await updateJobsStatus(jobs, indicator);
+};
+
+/**
+ * Downloads an existing process results
+ * @param {import("../types").AsyncJob} jobObject
+ * @param {import("stac-ts").StacCollection | null} selectedStac
+ */
+const downloadPreviousResults = async (jobObject, selectedStac) => {
+  /** @type {string[]} */
+  const results = [];
+  const link = jobObject.links.find(
+    (link) => link.rel.includes("results") && link.type == "application/json",
+  );
+  if (!link) {
+    return;
+  }
+  await axios$1
+    .get(link.href)
+    .then((response) => response.data)
+    .then((data) => {
+      results.push(...data.urls);
+    });
+  results.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?.id + "_process_results.json";
+    }
+    download(fileName, result);
+  });
+};
+
+/**
+ * Load the process results and update the map layers.
+ *
+ * @async
+ * @param {import("../types").AsyncJob} jobObject
+ * @param {import("stac-ts").StacCollection | null} selectedStac
+ * @param {import("@eox/map").EOxMap | null} mapElement
+ */
+const loadProcess = async (jobObject, selectedStac, mapElement) => {
+  /** @type {import("../types").EOxHubProcessResults} */
+  const results = await axios$1
+    .get(jobObject.links[1].href)
+    .then((response) => response.data);
+
+  await loadPreviousProcess({
+    selectedStac,
+    results,
+    jobId: jobObject.jobID,
+    mapElement,
+  });
+};
+
+/**
+ * load a geotiff to the map from an existing process
+ *
+ * @param {Object} params
+ * @param {import("stac-ts").StacCollection | null} params.selectedStac
+ * @param {string} params.jobId
+ * @param {import("../types").EOxHubProcessResults} params.results
+ * @param {import("@eox/map").EOxMap | null} params.mapElement
+ */
+async function loadPreviousProcess({
+  selectedStac,
+  results,
+  jobId,
+  mapElement,
+}) {
+  const asyncLink = selectedStac?.links.find(
+    (link) => link.rel === "service" && link.endpoint == "eoxhub_workspaces",
+  );
+  if (!asyncLink) {
+    return;
+  }
+
+  const unifiedResult = extractAsyncResults(results);
+
+  const layers = await creatAsyncProcessLayerDefinitions(
+    unifiedResult,
+    asyncLink,
+    selectedStac,
+    jobId,
+  );
+
+  log.debug("rendered layers after loading previous process:", layers);
+  applyProcessLayersToMap(mapElement, layers);
+}
+
+export { creatAsyncProcessLayerDefinitions as a, generateTimePairs as b, createTiffLayerDefinition as c, download as d, extractAsyncResults as e, updateJsonformSchemaTarget as f, getBboxProperty as g, extractGeometries as h, applyProcessLayersToMap as i, downloadPreviousResults as j, deleteJob as k, loadProcess as l, pollProcessStatus as p, separateEndpointLinks as s, updateJobsStatus as u };