@eodash/eodash 5.0.0-rc.2.4 → 5.0.0-rc.3

package/dist/client/ProcessList-C62SOVO6.js

@@ -0,0 +1,484 @@
+import { ref, createVNode, toRefs, onMounted, createElementBlock, openBlock, createBlock, createCommentVNode, unref, withCtx, createElementVNode, Fragment, renderList, toDisplayString, withDirectives } from 'vue';
+import { mdiUploadBox, mdiDownloadBox, mdiTrashCanOutline } from '@mdi/js';
+import { ai as axios, ak as extractLayerConfig, am as axios$1, aj as indicator, al as getLayers, a3 as mapEl, g as genericComponent, p as propsFactory, b as provideTheme, A as useDensity, a as useRender, f as makeThemeProps, h as makeTagProps, D as makeDensityProps, i as makeComponentProps, q as convertToUnit, Z as useSTAcStore, V as VBtn } from './asWebComponent-BJ2NWunV.js';
+import { isMulti } from '@eox/jsonform/src/custom-inputs/spatial/utils';
+import log from 'loglevel';
+import { T as Tooltip } from './index-Cv7HBz49.js';
+
+/**
+ * @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 {*} link
+ * @param {*} layerId
+ * @param {string[]} urls
+ * @param {*} projection
+ * @param {*} processId
+ * @returns
+ */
+async function createLayerDefinition(
+  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);
+  }
+
+  /** @type {Record<string,any>|undefined} */
+  let layerConfig;
+  /** @type {Record<string,any>|undefined} */
+  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();
+  const layerdef =
+    urls.length > 0
+      ? {
+          type: "WebGLTile",
+          source: {
+            type: "GeoTIFF",
+            normalize: !style,
+            sources: urls.map((url) => ({ url })),
+          },
+          properties: {
+            id: layerId + "_geotiff_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();
+};
+
+/**
+ * The list of job result from the server
+ * {job_start_datetime: string, job_end_datetime: string,status: string}
+ *  @type {import("vue").Ref<any[]>}
+ **/
+const jobs = ref([]);
+
+/**
+ * Polls the process status and fetches a result item when the process is successful.
+ *
+ * @param {Object} params - Parameters for polling the process status.
+ * @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.
+ * @returns {Promise<JSON>} The fetched results JSON.
+ * @throws {Error} If the process does not complete successfully within the maximum retries.
+ */
+async function pollProcessStatus({
+  processUrl,
+  isPolling,
+  pollInterval = 10000,
+  maxRetries = 560,
+}) {
+  let retries = 0;
+  isPolling.value = true;
+  setTimeout(() => {
+    updateJobsStatus(jobs, indicator);
+  }, 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 {*} jobs
+ * @param {*} indicator
+ */
+async function updateJobsStatus(jobs, indicator) {
+  /** @type {string[]} */
+  const jobsUrls = JSON.parse(localStorage.getItem(indicator.value) || "[]");
+  const jobResults = await Promise.all(
+    jobsUrls.map((url) => fetch(url).then((response) => response.json())),
+  );
+  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 {*} jobObject
+ */
+const deleteJob = async (jobObject) => {
+  /** @type {string[]} */
+  const jobsUrls = JSON.parse(localStorage.getItem(indicator.value) || "[]");
+  const newJobs = jobsUrls.filter((url) => !url.includes(jobObject.jobID));
+  localStorage.setItem(indicator.value, JSON.stringify(newJobs));
+  updateJobsStatus(jobs, indicator);
+};
+
+/**
+ * Downloads an existing process results
+ *  @param {*} jobObject
+ * @param {*} selectedStac
+ */
+const downloadPreviousResults = async (jobObject, selectedStac) => {
+  /** @type {any[]} */
+  const results = [];
+  await fetch(jobObject.links[1].href)
+    .then((response) => response.json())
+    .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 {*} jobObject
+ * @param {*} selectedStac
+ */
+const loadProcess = async (jobObject, selectedStac) => {
+  /** @type {any[]} */
+  const results = [];
+  await axios$1
+    .get(jobObject.links[1].href)
+    .then((response) => results.push(response.data));
+
+  await loadPreviousProcess({
+    selectedStac,
+    results,
+    jobId: jobObject.jobID,
+  });
+};
+
+/**
+ * load a geotiff to the map from an existing process
+ *
+ * @param {Object} params
+ * @param {import("stac-ts").StacCollection | null} params.selectedStac
+ * @param {any[]} params.results
+ * @param {string} params.jobId
+ */
+async function loadPreviousProcess({ selectedStac, results, jobId }) {
+  const geotiffLinks = selectedStac?.links.filter(
+    (link) => link.rel === "service" && link.type === "image/tiff",
+  );
+  // const stacProjection = selectedStac
+  const geotiffLayer = await createLayerDefinition(
+    geotiffLinks?.[0],
+    selectedStac?.id ?? "",
+    results?.[0].urls,
+    //@ts-expect-error TODO
+    selectedStac?.["eodash:mapProjection"]?.["name"] ?? null,
+    jobId,
+  );
+
+  log.debug("rendered layers after loading previous process:", geotiffLayer);
+
+  if (geotiffLayer) {
+    const layers = [...(geotiffLayer ? [geotiffLayer] : [])];
+    let currentLayers = [...getLayers()];
+    let analysisGroup = currentLayers.find((l) =>
+      l.properties.id.includes("AnalysisGroup"),
+    );
+    analysisGroup?.layers.push(...layers);
+
+    if (mapEl.value) {
+      mapEl.value.layers = [...currentLayers];
+    }
+  }
+}
+
+const makeVTableProps = propsFactory({
+  fixedHeader: Boolean,
+  fixedFooter: Boolean,
+  height: [Number, String],
+  hover: Boolean,
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeTagProps(),
+  ...makeThemeProps()
+}, 'VTable');
+const VTable = genericComponent()({
+  name: 'VTable',
+  props: makeVTableProps(),
+  setup(props, _ref) {
+    let {
+      slots,
+      emit
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    useRender(() => createVNode(props.tag, {
+      "class": ['v-table', {
+        'v-table--fixed-height': !!props.height,
+        'v-table--fixed-header': props.fixedHeader,
+        'v-table--fixed-footer': props.fixedFooter,
+        'v-table--has-top': !!slots.top,
+        'v-table--has-bottom': !!slots.bottom,
+        'v-table--hover': props.hover
+      }, themeClasses.value, densityClasses.value, props.class],
+      "style": props.style
+    }, {
+      default: () => [slots.top?.(), slots.default ? createVNode("div", {
+        "class": "v-table__wrapper",
+        "style": {
+          height: convertToUnit(props.height)
+        }
+      }, [createVNode("table", null, [slots.default()])]) : slots.wrapper?.(), slots.bottom?.()]
+    }));
+    return {};
+  }
+});
+
+const _hoisted_1 = { style: {"padding":"0px"} };
+const _hoisted_2 = { style: {"padding":"0px"} };
+const _hoisted_3 = { style: {"padding":"0px"} };
+
+
+const _sfc_main = {
+  __name: 'ProcessList',
+  setup(__props) {
+
+const { selectedStac } = toRefs(useSTAcStore());
+
+onMounted(() => updateJobsStatus(jobs, indicator));
+
+return (_ctx, _cache) => {
+                                                     
+                                                         
+                                                         
+
+  return (openBlock(), createElementBlock("div", null, [
+    (unref(jobs).length)
+      ? (openBlock(), createBlock(VTable, {
+          key: 0,
+          density: "compact",
+          style: {"background-color":"transparent"}
+        }, {
+          default: withCtx(() => [
+            _cache[0] || (_cache[0] = createElementVNode("thead", null, [
+              createElementVNode("tr", null, [
+                createElementVNode("th", { class: "text-left" }, "Executed on"),
+                createElementVNode("th", { class: "text-left" }, "Status"),
+                createElementVNode("th", { class: "text-left" }),
+                createElementVNode("th", { class: "text-left" }),
+                createElementVNode("th", { class: "text-left" })
+              ])
+            ], -1 /* HOISTED */)),
+            createElementVNode("tbody", null, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(jobs), (item) => {
+                return (openBlock(), createElementBlock("tr", {
+                  key: item.date
+                }, [
+                  createElementVNode("td", null, toDisplayString(new Date(item.job_start_datetime).toISOString().slice(0, 16)), 1 /* TEXT */),
+                  createElementVNode("td", null, toDisplayString(item.status), 1 /* TEXT */),
+                  createElementVNode("td", _hoisted_1, [
+                    withDirectives(createVNode(VBtn, {
+                      disabled: item.status !== 'successful',
+                      color: "primary",
+                      onClick: $event => (unref(loadProcess)(item, unref(selectedStac))),
+                      icon: [unref(mdiUploadBox)],
+                      variant: "text"
+                    }, null, 8 /* PROPS */, ["disabled", "onClick", "icon"]), [
+                      [Tooltip, 'Load results to map']
+                    ])
+                  ]),
+                  createElementVNode("td", _hoisted_2, [
+                    withDirectives(createVNode(VBtn, {
+                      disabled: item.status !== 'successful',
+                      color: "primary",
+                      onClick: $event => (unref(downloadPreviousResults)(item, unref(selectedStac))),
+                      icon: [unref(mdiDownloadBox)],
+                      variant: "text"
+                    }, null, 8 /* PROPS */, ["disabled", "onClick", "icon"]), [
+                      [Tooltip, 'Download results']
+                    ])
+                  ]),
+                  createElementVNode("td", _hoisted_3, [
+                    withDirectives(createVNode(VBtn, {
+                      color: "#ff5252",
+                      onClick: $event => (unref(deleteJob)(item)),
+                      icon: [unref(mdiTrashCanOutline)],
+                      variant: "text"
+                    }, null, 8 /* PROPS */, ["onClick", "icon"]), [
+                      [Tooltip, 'Remove job']
+                    ])
+                  ])
+                ]))
+              }), 128 /* KEYED_FRAGMENT */))
+            ])
+          ]),
+          _: 1 /* STABLE */
+        }))
+      : createCommentVNode("v-if", true)
+  ]))
+}
+}
+
+};
+
+const ProcessList = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  default: _sfc_main
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { ProcessList as P, _sfc_main as _, createLayerDefinition as c, download as d, extractGeometries as e, getBboxProperty as g, jobs as j, pollProcessStatus as p, updateJobsStatus as u };

package/dist/client/{VImg-Yc9F9pYq.js → VImg-D4eT3IQ1.js}

@@ -1,6 +1,6 @@
 import { createVNode, computed, toRef, shallowRef, ref, watch, onBeforeMount, nextTick, onBeforeUnmount, withDirectives, mergeProps, Fragment, resolveDirective, vShow } from 'vue';
-import { aH as SUPPORTS_INTERSECTION, g as genericComponent, p as propsFactory, H as useDimension, a as useRender, J as makeDimensionProps, i as makeComponentProps, B as useBackgroundColor, M as useRounded, aI as getCurrentInstance, q as convertToUnit, O as makeRoundedProps } from './asWebComponent-DZpMGxEY.js';
-import { m as makeTransitionProps, M as MaybeTransition } from './transition-CtL4BoVi.js';
+import { aL as SUPPORTS_INTERSECTION, g as genericComponent, p as propsFactory, H as useDimension, a as useRender, J as makeDimensionProps, i as makeComponentProps, B as useBackgroundColor, M as useRounded, aM as getCurrentInstance, q as convertToUnit, O as makeRoundedProps } from './asWebComponent-BJ2NWunV.js';
+import { m as makeTransitionProps, M as MaybeTransition } from './transition-Cdb4K27U.js';
 
 // Utilities
 function mounted(el, binding) {

package/dist/client/{VMain-BiS7HPEk.js → VMain-C3hN2-H3.js}

@@ -1,5 +1,5 @@
 import { createVNode } from 'vue';
-import { g as genericComponent, p as propsFactory, H as useDimension, G as useLayout, a as useRender, h as makeTagProps, J as makeDimensionProps, i as makeComponentProps } from './asWebComponent-DZpMGxEY.js';
+import { g as genericComponent, p as propsFactory, H as useDimension, G as useLayout, a as useRender, h as makeTagProps, J as makeDimensionProps, i as makeComponentProps } from './asWebComponent-BJ2NWunV.js';
 import { u as useSsrBoot } from './ssrBoot-BP7SYRyC.js';
 
 const makeVMainProps = propsFactory({

package/dist/client/{VOverlay-B9mxXaCv.js → VOverlay-tAeNygaA.js}

@@ -1,7 +1,7 @@
 import { computed, watch, onScopeDispose, nextTick, ref, watchEffect, effectScope, inject, mergeProps, shallowRef, onMounted, reactive, provide, toRaw, readonly, warn, toRef, onBeforeUnmount, createVNode, Fragment, Teleport, withDirectives, vShow, resolveDirective, Transition } from 'vue';
-import { aK as isOn, aL as eventName, p as propsFactory, aM as destructComputed, aN as parseAnchor, aO as flipSide, aP as flipAlign, aQ as flipCorner, Y as consoleError, aR as getAxis, q as convertToUnit, R as clamp, I as IN_BROWSER, T as useToggleScope, aS as defer, aI as getCurrentInstance, aT as templateRef, aU as matchesSelector, r as useDisplay, f as makeThemeProps, J as makeDimensionProps, i as makeComponentProps, g as genericComponent, j as useProxiedModel, b as provideTheme, c as useRtl, B as useBackgroundColor, H as useDimension, aV as useRouter, aW as useBackButton, a as useRender } from './asWebComponent-DZpMGxEY.js';
-import { g as getTargetBox, B as Box, e as getOverflow, n as nullifyTransforms, m as makeLazyProps, u as useLazy, b as useScopeId, a as animate, s as standardEasing } from './forwardRefs-BtkfywIE.js';
-import { m as makeTransitionProps, M as MaybeTransition } from './transition-CtL4BoVi.js';
+import { aO as isOn, aP as eventName, p as propsFactory, aQ as destructComputed, aR as parseAnchor, aS as flipSide, aT as flipAlign, aU as flipCorner, an as consoleError, aV as getAxis, q as convertToUnit, R as clamp, I as IN_BROWSER, T as useToggleScope, aW as defer, aM as getCurrentInstance, aX as templateRef, aY as matchesSelector, r as useDisplay, f as makeThemeProps, J as makeDimensionProps, i as makeComponentProps, g as genericComponent, j as useProxiedModel, b as provideTheme, c as useRtl, B as useBackgroundColor, H as useDimension, aZ as useRouter, a_ as useBackButton, a as useRender } from './asWebComponent-BJ2NWunV.js';
+import { g as getTargetBox, B as Box, e as getOverflow, n as nullifyTransforms, m as makeLazyProps, u as useLazy, b as useScopeId, a as animate, s as standardEasing } from './forwardRefs-CIFAqXaZ.js';
+import { m as makeTransitionProps, M as MaybeTransition } from './transition-Cdb4K27U.js';
 
 // Utilities
 const handlers = new WeakMap();
@@ -1112,10 +1112,10 @@ function useStack(isActive, zIndex, disableGlobalStack) {
     activeChildren: new Set()
   });
   provide(StackSymbol, stack);
-  const _zIndex = shallowRef(+zIndex.value);
+  const _zIndex = shallowRef(Number(zIndex.value));
   useToggleScope(isActive, () => {
     const lastZIndex = globalStack.at(-1)?.[1];
-    _zIndex.value = lastZIndex ? lastZIndex + 10 : +zIndex.value;
+    _zIndex.value = lastZIndex ? lastZIndex + 10 : Number(zIndex.value);
     if (createStackEntry) {
       globalStack.push([vm.uid, _zIndex.value]);
     }
@@ -1229,6 +1229,7 @@ const VOverlay = genericComponent()({
   emits: {
     'click:outside': e => true,
     'update:modelValue': value => true,
+    keydown: e => true,
     afterEnter: () => true,
     afterLeave: () => true
   },
@@ -1341,6 +1342,9 @@ const VOverlay = genericComponent()({
     });
     function onKeydown(e) {
       if (e.key === 'Escape' && globalTop.value) {
+        if (!contentEl.value?.contains(document.activeElement)) {
+          emit('keydown', e);
+        }
         if (!props.persistent) {
           isActive.value = false;
           if (contentEl.value?.contains(document.activeElement)) {
@@ -1349,6 +1353,10 @@ const VOverlay = genericComponent()({
         } else animateClick();
       }
     }
+    function onKeydownSelf(e) {
+      if (e.key === 'Escape' && !globalTop.value) return;
+      emit('keydown', e);
+    }
     const router = useRouter();
     useToggleScope(() => props.closeOnBack, () => {
       useBackButton(router, next => {
@@ -1411,7 +1419,8 @@ const VOverlay = genericComponent()({
           '--v-overlay-opacity': props.opacity,
           top: convertToUnit(top.value)
         }, props.style],
-        "ref": root
+        "ref": root,
+        "onKeydown": onKeydownSelf
       }, scopeId, attrs), [createVNode(Scrim, mergeProps({
         "color": scrimColor,
         "modelValue": isActive.value && !!props.scrim,

package/dist/client/{VTooltip-XJLaLrZQ.js → VTooltip-B0Q3iHMZ.js}

@@ -1,7 +1,7 @@
 import { computed, ref, mergeProps, createVNode } from 'vue';
-import { m as makeVOverlayProps, V as VOverlay } from './VOverlay-B9mxXaCv.js';
-import { b as useScopeId, f as forwardRefs } from './forwardRefs-BtkfywIE.js';
-import { g as genericComponent, p as propsFactory, j as useProxiedModel, am as getUid, a as useRender, o as omit } from './asWebComponent-DZpMGxEY.js';
+import { m as makeVOverlayProps, V as VOverlay } from './VOverlay-tAeNygaA.js';
+import { b as useScopeId, f as forwardRefs } from './forwardRefs-CIFAqXaZ.js';
+import { g as genericComponent, p as propsFactory, j as useProxiedModel, aq as getUid, a as useRender, o as omit } from './asWebComponent-BJ2NWunV.js';
 
 const makeVTooltipProps = propsFactory({
   id: String,

package/dist/client/{WidgetsContainer-DRVb_73N.js → WidgetsContainer-CtDHfCYf.js}

@@ -1,5 +1,5 @@
 import { ref, onMounted, nextTick, createElementBlock, openBlock, Fragment, renderList, unref, createElementVNode, toDisplayString, normalizeStyle, createBlock, resolveDynamicComponent, mergeProps } from 'vue';
-import { aJ as useDefineWidgets, G as useLayout } from './asWebComponent-DZpMGxEY.js';
+import { aN as useDefineWidgets, G as useLayout } from './asWebComponent-BJ2NWunV.js';
 import 'animated-details';
 
 const _sfc_main = {