@eodash/eodash 5.0.0-alpha.2.18 → 5.0.0-alpha.2.20

package/dist/client/DashboardLayout-CPIA_V5h.js

@@ -0,0 +1,86 @@
+import { inject, openBlock, createBlock, withCtx, createElementVNode, unref, createElementBlock, Suspense, resolveDynamicComponent, mergeProps, createCommentVNode, Fragment, renderList, Transition } from 'vue';
+import { _ as _export_sfc, F as eodashKey, G as useDefineWidgets } from './asWebComponent-CIm1IGNl.js';
+import '@eox/layout';
+import { V as VMain } from './VMain-nLmJhfgS.js';
+
+const _hoisted_1 = ["gap"];
+const _hoisted_2 = {
+  key: 0,
+  class: "bg-panel",
+  x: "0",
+  y: "0",
+  h: "12",
+  w: "12"
+};
+const _hoisted_3 = ["h", "w", "x", "y"];
+
+
+const _sfc_main = {
+  __name: 'DashboardLayout',
+  setup(__props) {
+
+const eodash = /** @type {import("@/types").Eodash} */ (inject(eodashKey));
+
+const [bgWidget] = useDefineWidgets([eodash.template?.background]);
+
+const importedWidgets = useDefineWidgets(eodash.template?.widgets);
+
+return (_ctx, _cache) => {
+                                                       
+
+  return (openBlock(), createBlock(VMain, null, {
+    default: withCtx(() => [
+      createElementVNode("eox-layout", {
+        gap: unref(eodash).template.gap ?? 2
+      }, [
+        (unref(bgWidget).component)
+          ? (openBlock(), createElementBlock("eox-layout-item", _hoisted_2, [
+              (openBlock(), createBlock(Suspense, { suspensible: "" }, {
+                default: withCtx(() => [
+                  (openBlock(), createBlock(resolveDynamicComponent(unref(bgWidget).component), mergeProps({ id: "bg-widget" }, unref(bgWidget).props), null, 16 /* FULL_PROPS */))
+                ]),
+                _: 1 /* STABLE */
+              }))
+            ]))
+          : createCommentVNode("v-if", true),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(importedWidgets), (importedWidget, idx) => {
+          return (openBlock(), createBlock(Transition, {
+            key: idx,
+            name: "fade"
+          }, {
+            default: withCtx(() => [
+              (importedWidget.value.component)
+                ? (openBlock(), createElementBlock("eox-layout-item", {
+                    key: importedWidget.value.id,
+                    class: "panel bg-surface",
+                    h: importedWidget.value.layout.h,
+                    w: importedWidget.value.layout.w,
+                    x: importedWidget.value.layout.x,
+                    y: importedWidget.value.layout.y
+                  }, [
+                    (openBlock(), createBlock(Suspense, { suspensible: "" }, {
+                      default: withCtx(() => [
+                        (openBlock(), createBlock(resolveDynamicComponent(importedWidget.value.component), mergeProps({
+                          key: importedWidget.value.id,
+                          ref_for: true
+                        }, importedWidget.value.props), null, 16 /* FULL_PROPS */))
+                      ]),
+                      _: 2 /* DYNAMIC */
+                    }, 1024 /* DYNAMIC_SLOTS */))
+                  ], 8 /* PROPS */, _hoisted_3))
+                : createCommentVNode("v-if", true)
+            ]),
+            _: 2 /* DYNAMIC */
+          }, 1024 /* DYNAMIC_SLOTS */))
+        }), 128 /* KEYED_FRAGMENT */))
+      ], 8 /* PROPS */, _hoisted_1)
+    ]),
+    _: 1 /* STABLE */
+  }))
+}
+}
+
+};
+const DashboardLayout = /*#__PURE__*/_export_sfc(_sfc_main, [['__scopeId',"data-v-a859692c"]]);
+
+export { DashboardLayout as default };

package/dist/client/DynamicWebComponent-Bm2S0izi.js

@@ -0,0 +1,88 @@
+import { withAsyncContext, ref, onMounted, onUnmounted, openBlock, createElementBlock, createBlock, resolveDynamicComponent, mergeProps } from 'vue';
+import { $ as useSTAcStore } from './asWebComponent-CIm1IGNl.js';
+
+const _hoisted_1 = { class: "d-flex flex-column fill-height overflow-auto" };
+
+
+const _sfc_main = {
+  __name: 'DynamicWebComponent',
+  props: {
+    link: {
+      type: [String, Function],
+      required: true,
+    },
+    constructorProp: String,
+    tagName: {
+      type: String,
+      required: true,
+    },
+    properties: {
+      type: Object,
+      default: () => {
+        return {};
+      },
+    },
+    onMounted: Function,
+    onUnmounted: Function,
+  },
+  async setup(__props) {
+
+let __temp, __restore;
+
+const props = /** @type {import("@/types").WebComponentProps} */ (
+  __props
+);
+
+const getWebComponent = async () =>
+  typeof props.link === "string"
+    ? await import(/* @vite-ignore */ props.link)
+    : await props.link();
+
+const imported = !customElements.get(props.tagName)
+  ? (
+  ([__temp,__restore] = withAsyncContext(() => getWebComponent().catch((e) => {
+      console.error(e);
+    }))),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)
+  : null;
+
+const defined = customElements.get(props.tagName);
+
+// if the imported link doesn't define the custom tag provided
+if (!defined && props.constructorProp) {
+  const Constructor = imported[props.constructorProp];
+  customElements.define(props.tagName, Constructor);
+}
+
+const store = useSTAcStore();
+
+/**
+ * @typedef {HTMLElement & Record<string | number | symbol, unknown>} CustomElement
+ * @type {import("vue").Ref<CustomElement | null>}
+ */
+const elementRef = ref(null);
+
+onMounted(() => {
+  props.onMounted?.(elementRef.value, store);
+});
+
+onUnmounted(() => {
+  props.onUnmounted?.(elementRef.value, store);
+});
+
+return (_ctx, _cache) => {
+  return (openBlock(), createElementBlock("span", _hoisted_1, [
+    (openBlock(), createBlock(resolveDynamicComponent(__props.tagName), mergeProps(__props.properties, {
+      ref_key: "elementRef",
+      ref: elementRef
+    }), null, 16 /* FULL_PROPS */))
+  ]))
+}
+}
+
+};
+
+export { _sfc_main as default };

package/dist/client/EodashDatePicker-Tdk5Xx9F.js

@@ -0,0 +1,393 @@
+import { computed, ref, mergeProps, createVNode, resolveComponent, render, h, useCssVars, customRef, reactive, watch, onMounted, openBlock, createElementBlock, Fragment, unref, createSlots, withCtx, createElementVNode, toHandlers, withDirectives, createBlock } from 'vue';
+import { DatePicker } from 'v-calendar';
+import { storeToRefs } from 'pinia';
+import { p as propsFactory, o as omit, g as genericComponent, j as useProxiedModel, Y as getUid, a as useRender, E as isObject, Z as datetime, $ as useSTAcStore, a0 as eodashCollections, a1 as VRow, V as VBtn, y as VIcon } from './asWebComponent-CIm1IGNl.js';
+import { mdiRayEndArrow, mdiRayStartArrow } from '@mdi/js';
+import log from 'loglevel';
+import { m as makeVOverlayProps, V as VOverlay } from './VOverlay-naLhQSyZ.js';
+import { b as useScopeId, f as forwardRefs } from './forwardRefs-q4ZkKtOv.js';
+
+const makeVTooltipProps = propsFactory({
+  id: String,
+  text: String,
+  ...omit(makeVOverlayProps({
+    closeOnBack: false,
+    location: 'end',
+    locationStrategy: 'connected',
+    eager: true,
+    minWidth: 0,
+    offset: 10,
+    openOnClick: false,
+    openOnHover: true,
+    origin: 'auto',
+    scrim: false,
+    scrollStrategy: 'reposition',
+    transition: false
+  }), ['absolute', 'persistent'])
+}, 'VTooltip');
+const VTooltip = genericComponent()({
+  name: 'VTooltip',
+  props: makeVTooltipProps(),
+  emits: {
+    'update:modelValue': value => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const isActive = useProxiedModel(props, 'modelValue');
+    const {
+      scopeId
+    } = useScopeId();
+    const uid = getUid();
+    const id = computed(() => props.id || `v-tooltip-${uid}`);
+    const overlay = ref();
+    const location = computed(() => {
+      return props.location.split(' ').length > 1 ? props.location : props.location + ' center';
+    });
+    const origin = computed(() => {
+      return props.origin === 'auto' || props.origin === 'overlap' || props.origin.split(' ').length > 1 || props.location.split(' ').length > 1 ? props.origin : props.origin + ' center';
+    });
+    const transition = computed(() => {
+      if (props.transition) return props.transition;
+      return isActive.value ? 'scale-transition' : 'fade-transition';
+    });
+    const activatorProps = computed(() => mergeProps({
+      'aria-describedby': id.value
+    }, props.activatorProps));
+    useRender(() => {
+      const overlayProps = VOverlay.filterProps(props);
+      return createVNode(VOverlay, mergeProps({
+        "ref": overlay,
+        "class": ['v-tooltip', props.class],
+        "style": props.style,
+        "id": id.value
+      }, overlayProps, {
+        "modelValue": isActive.value,
+        "onUpdate:modelValue": $event => isActive.value = $event,
+        "transition": transition.value,
+        "absolute": true,
+        "location": location.value,
+        "origin": origin.value,
+        "persistent": true,
+        "role": "tooltip",
+        "activatorProps": activatorProps.value,
+        "_disableGlobalStack": true
+      }, scopeId), {
+        activator: slots.activator,
+        default: function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          return slots.default?.(...args) ?? props.text;
+        }
+      });
+    });
+    return forwardRefs({}, overlay);
+  }
+});
+
+// Utilities
+function useDirectiveComponent(component, props) {
+  const concreteComponent = typeof component === 'string' ? resolveComponent(component) : component;
+  const hook = mountComponent(concreteComponent, props);
+  return {
+    mounted: hook,
+    updated: hook,
+    unmounted(el) {
+      render(null, el);
+    }
+  };
+}
+function mountComponent(component, props) {
+  return function (el, binding, vnode) {
+    const _props = typeof props === 'function' ? props(binding) : props;
+    const text = binding.value?.text ?? binding.value ?? _props?.text;
+    const value = isObject(binding.value) ? binding.value : {};
+
+    // Get the children from the props or directive value, or the element's children
+    const children = () => text ?? el.textContent;
+
+    // If vnode.ctx is the same as the instance, then we're bound to a plain element
+    // and need to find the nearest parent component instance to inherit provides from
+    const provides = (vnode.ctx === binding.instance.$ ? findComponentParent(vnode, binding.instance.$)?.provides : vnode.ctx?.provides) ?? binding.instance.$.provides;
+    const node = h(component, mergeProps(_props, value), children);
+    node.appContext = Object.assign(Object.create(null), binding.instance.$.appContext, {
+      provides
+    });
+    render(node, el);
+  };
+}
+function findComponentParent(vnode, root) {
+  // Walk the tree from root until we find the child vnode
+  const stack = new Set();
+  const walk = children => {
+    for (const child of children) {
+      if (!child) continue;
+      if (child === vnode) {
+        return true;
+      }
+      stack.add(child);
+      let result;
+      if (child.suspense) {
+        result = walk([child.ssContent]);
+      } else if (Array.isArray(child.children)) {
+        result = walk(child.children);
+      } else if (child.component?.vnode) {
+        result = walk([child.component?.subTree]);
+      }
+      if (result) {
+        return result;
+      }
+      stack.delete(child);
+    }
+    return false;
+  };
+  if (!walk([root.subTree])) {
+    throw new Error('Could not find original vnode');
+  }
+
+  // Return the first component parent
+  const result = Array.from(stack).reverse();
+  for (const child of result) {
+    if (child.component) {
+      return child.component;
+    }
+  }
+  return root;
+}
+
+// Components
+const Tooltip = useDirectiveComponent(VTooltip, binding => {
+  return {
+    activator: 'parent',
+    location: binding.arg?.replace('-', ' '),
+    text: typeof binding.value === 'boolean' ? undefined : binding.value
+  };
+});
+
+const _hoisted_1 = {
+  class: "flex rounded-lg border border-gray-300 dark:border-gray-600",
+  style: {"margin":"2px"}
+};
+const _hoisted_2 = ["value"];
+const _hoisted_3 = {
+  class: "w-full px-4 pb-3",
+  style: {"font-size":"12px"}
+};
+const _hoisted_4 = ["innerHTML"];
+
+// holds the number value of the datetime
+
+const _sfc_main = {
+  __name: 'EodashDatePicker',
+  props: {
+  hintText: {
+    type: String,
+    default: null,
+  },
+},
+  setup(__props) {
+
+useCssVars(_ctx => ({
+  "cd569fa8": (transform.value)
+}));
+
+const currentDate = customRef((track, trigger) => ({
+  get() {
+    track();
+    return new Date(datetime.value).getTime();
+  },
+  /** @param {number} num */
+  set(num) {
+    trigger();
+    log.debug("Datepicker setting currentDate", datetime.value);
+    datetime.value = new Date(num).toISOString();
+  },
+}));
+
+const masks = ref({
+  input: "YYYY-MM-DD",
+});
+
+
+
+/**
+ * Attributes displayed on datepicker
+ *
+ * @type {import("vue").Reactive<
+ *   (
+ *     | Partial<import("v-calendar/dist/types/src/utils/attribute").AttributeConfig>
+ *     | undefined
+ *   )[]
+ * >}
+ */
+const attributes = reactive([]);
+
+const { selectedStac } = storeToRefs(useSTAcStore());
+
+watch(
+  selectedStac,
+  async (updatedStac, previousStac) => {
+    if (updatedStac && previousStac?.id !== updatedStac.id) {
+      log.debug("Datepicker selected STAC change triggered");
+      const wongPalette = [
+        "#009E73",
+        "#0072B2",
+        "#E69F00",
+        "#CC79A7",
+        "#56B4E9",
+        "#D55E00",
+      ];
+      // remove old values
+      attributes.splice(0, attributes.length);
+
+      for (let idx = 0; idx < eodashCollections.length; idx++) {
+        log.debug("Retrieving dates", eodashCollections[idx]);
+        await eodashCollections[idx].fetchCollection();
+        const dates = [
+          ...new Set(
+            eodashCollections[idx].getItems()?.reduce((valid, it) => {
+              const parsed = Date.parse(/** @type {string} */ (it.datetime));
+              if (parsed) {
+                valid.push(new Date(parsed));
+              }
+              return valid;
+            }, /** @type {Date[]} */ ([])),
+          ),
+        ];
+        attributes.push({
+          key: "id-" + idx.toString() + Math.random().toString(16).slice(2),
+          bar: {
+            style: {
+              backgroundColor: wongPalette[idx % wongPalette.length],
+            },
+          },
+          dates,
+          content: {
+            style: {
+              color: "#000000",
+              "font-weight": "bold",
+            },
+          },
+        });
+      }
+    }
+  },
+  { immediate: true },
+);
+
+/**
+ * @param {boolean} reverse
+ */
+function jumpDate(reverse) {
+  if (attributes.length) {
+    let latestDateMS = reverse ? Infinity : -Infinity;
+    attributes.forEach((coll) => {
+      if (coll?.dates) {
+        coll.dates.forEach((d) => {
+          // TODO: we need to handle time ranges and other options here
+          if (d instanceof Date) {
+            const mathFun = reverse ? "min" : "max";
+            latestDateMS = Math[mathFun](latestDateMS, d.getTime());
+          }
+        });
+      }
+    });
+    currentDate.value =
+      latestDateMS === -Infinity
+        ? Date.now()
+        : latestDateMS === Infinity
+          ? 0
+          : latestDateMS;
+  }
+}
+
+// fixes calendar dispalcement on lib mode
+const transform = ref("");
+onMounted(() => {
+  transform.value = document.querySelector("eo-dash")
+    ? "translate3d(50px,-80px,0)"
+    : "translate3d(0px,-80px,0)";
+});
+
+return (_ctx, _cache) => {
+                                                       
+                                                     
+                                                     
+                                                         
+
+  return (openBlock(), createElementBlock(Fragment, null, [
+    createVNode(unref(DatePicker), {
+      modelValue: currentDate.value,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => ((currentDate).value = $event)),
+      modelModifiers: { number: true },
+      masks: masks.value,
+      attributes: attributes
+    }, createSlots({
+      default: withCtx(({ inputValue, inputEvents }) => [
+        createElementVNode("div", _hoisted_1, [
+          createElementVNode("input", mergeProps({ value: inputValue }, toHandlers(inputEvents, true), {
+            style: {"margin":"1px"},
+            class: "flex-grow px-1 py-1 bg-white dark:bg-gray-700"
+          }), null, 16 /* FULL_PROPS */, _hoisted_2)
+        ])
+      ]),
+      _: 2 /* DYNAMIC */
+    }, [
+      (__props.hintText)
+        ? {
+            name: "footer",
+            fn: withCtx(() => [
+              createElementVNode("div", _hoisted_3, [
+                createElementVNode("span", { innerHTML: __props.hintText }, null, 8 /* PROPS */, _hoisted_4)
+              ])
+            ]),
+            key: "0"
+          }
+        : undefined
+    ]), 1032 /* PROPS, DYNAMIC_SLOTS */, ["modelValue", "masks", "attributes"]),
+    createVNode(VRow, {
+      align: "center",
+      justify: "center",
+      style: {"margin-top":"6px"}
+    }, {
+      default: withCtx(() => [
+        withDirectives((openBlock(), createBlock(VBtn, {
+          style: {"padding":"0px","margin-right":"4px"},
+          density: "compact",
+          onClick: _cache[1] || (_cache[1] = $event => (jumpDate(true)))
+        }, {
+          default: withCtx(() => [
+            createVNode(VIcon, {
+              icon: [unref(mdiRayEndArrow)]
+            }, null, 8 /* PROPS */, ["icon"])
+          ]),
+          _: 1 /* STABLE */
+        })), [
+          [Tooltip, 'Set date to oldest available dataset', "bottom"]
+        ]),
+        withDirectives((openBlock(), createBlock(VBtn, {
+          style: {"padding":"0px","margin-left":"4px"},
+          density: "compact",
+          onClick: _cache[2] || (_cache[2] = $event => (jumpDate(false)))
+        }, {
+          default: withCtx(() => [
+            createVNode(VIcon, {
+              icon: [unref(mdiRayStartArrow)]
+            }, null, 8 /* PROPS */, ["icon"])
+          ]),
+          _: 1 /* STABLE */
+        })), [
+          [Tooltip, 'Set date to latest available dataset', "bottom"]
+        ])
+      ]),
+      _: 1 /* STABLE */
+    })
+  ], 64 /* STABLE_FRAGMENT */))
+}
+}
+
+};
+
+export { _sfc_main as default };