@eodash/eodash 5.6.1 → 5.7.1

package/dist/types/widgets/EodashMap/index.vue.d.ts

@@ -1,51 +1,71 @@
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    baseLayers: {
+        /** @type {import("vue").PropType<import("@eox/map").EoxLayer[]>} */
+        type: import("vue").PropType<import("@eox/map").EoxLayer[]>;
+        default: () => {
+            type: string;
+            source: {
+                type: string;
+            };
+            properties: {
+                id: string;
+                title: string;
+                layerControlExclusive: boolean;
+            };
+        }[];
+    };
     enableCompare: {
         type: BooleanConstructor;
         default: boolean;
     };
-    /** @type {import("vue").PropType<[number,number]>} */
-    center: import("vue").PropType<[number, number]>;
+    /**
+     * Initial map center as [lon, lat]; falls back to the last stored map position.
+     * @default [15, 48]
+     */
+    center: {
+        type: import("vue").PropType<[number, number]>;
+        default: () => number[];
+    };
+    /**
+     * Initial zoom level; falls back to the last stored map position.
+     * @default 4
+     */
     zoom: {
         type: NumberConstructor;
         default: number;
     };
+    /** Fly to the selected collection's spatial extent on selection. */
     zoomToExtent: {
         type: BooleanConstructor;
         default: boolean;
     };
+    /** Show live cursor coordinates as a fixed overlay at the bottom-left of the map. */
     enableCursorCoordinates: {
         type: BooleanConstructor;
         default: boolean;
     };
+    /** Show an OpenLayers scale-line control at the bottom-left of the map. */
     enableScaleLine: {
         type: BooleanConstructor;
         default: boolean;
     };
+    /** Grid position of the floating button toolbar. `x` accepts responsive `"mobile/tablet/desktop"` column notation. */
     btnsPosition: {
-        type: ObjectConstructor;
+        type: import("vue").PropType<{
+            x: string | number;
+            y: number;
+            gap: number;
+        }>;
         default: () => {
             x: string;
             y: number;
             gap: number;
         };
     };
+    /** Toolbar feature flags; set any flag to `false` to hide the corresponding button. */
     btns: {
-        /** @type {import("vue").PropType<{
-         * enableExportMap?: boolean;
-         * enableChangeProjection?: boolean;
-         * enableBackToPOIs?: boolean;
-         * enableSearch?: boolean;
-         * searchParams?: object;
-         * enableZoom?: boolean;
-         * enableGlobe?: boolean;
-         * enableCompareIndicators?: boolean | {
-         *   compareTemplate?:string;
-         *   fallbackTemplate?:string;
-         *   itemFilterConfig?:InstanceType<import("../EodashItemFilter.vue").default>["$props"]
-         * };
-         * }> }*/
         type: import("vue").PropType<{
             enableExportMap?: boolean;
             enableChangeProjection?: boolean;
@@ -54,6 +74,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
             searchParams?: object;
             enableZoom?: boolean;
             enableGlobe?: boolean;
+            enableMosaic?: boolean;
+            enableFeedback?: boolean;
             enableCompareIndicators?: boolean | {
                 compareTemplate?: string;
                 fallbackTemplate?: string;
@@ -240,55 +262,77 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
             enableSearch: boolean;
             enableZoom: boolean;
             enableGlobe: boolean;
+            enableMosaic: boolean;
+            enableFeedback: boolean;
             searchParams: {};
         };
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    baseLayers: {
+        /** @type {import("vue").PropType<import("@eox/map").EoxLayer[]>} */
+        type: import("vue").PropType<import("@eox/map").EoxLayer[]>;
+        default: () => {
+            type: string;
+            source: {
+                type: string;
+            };
+            properties: {
+                id: string;
+                title: string;
+                layerControlExclusive: boolean;
+            };
+        }[];
+    };
     enableCompare: {
         type: BooleanConstructor;
         default: boolean;
     };
-    /** @type {import("vue").PropType<[number,number]>} */
-    center: import("vue").PropType<[number, number]>;
+    /**
+     * Initial map center as [lon, lat]; falls back to the last stored map position.
+     * @default [15, 48]
+     */
+    center: {
+        type: import("vue").PropType<[number, number]>;
+        default: () => number[];
+    };
+    /**
+     * Initial zoom level; falls back to the last stored map position.
+     * @default 4
+     */
     zoom: {
         type: NumberConstructor;
         default: number;
     };
+    /** Fly to the selected collection's spatial extent on selection. */
     zoomToExtent: {
         type: BooleanConstructor;
         default: boolean;
     };
+    /** Show live cursor coordinates as a fixed overlay at the bottom-left of the map. */
     enableCursorCoordinates: {
         type: BooleanConstructor;
         default: boolean;
     };
+    /** Show an OpenLayers scale-line control at the bottom-left of the map. */
     enableScaleLine: {
         type: BooleanConstructor;
         default: boolean;
     };
+    /** Grid position of the floating button toolbar. `x` accepts responsive `"mobile/tablet/desktop"` column notation. */
     btnsPosition: {
-        type: ObjectConstructor;
+        type: import("vue").PropType<{
+            x: string | number;
+            y: number;
+            gap: number;
+        }>;
         default: () => {
             x: string;
             y: number;
             gap: number;
         };
     };
+    /** Toolbar feature flags; set any flag to `false` to hide the corresponding button. */
     btns: {
-        /** @type {import("vue").PropType<{
-         * enableExportMap?: boolean;
-         * enableChangeProjection?: boolean;
-         * enableBackToPOIs?: boolean;
-         * enableSearch?: boolean;
-         * searchParams?: object;
-         * enableZoom?: boolean;
-         * enableGlobe?: boolean;
-         * enableCompareIndicators?: boolean | {
-         *   compareTemplate?:string;
-         *   fallbackTemplate?:string;
-         *   itemFilterConfig?:InstanceType<import("../EodashItemFilter.vue").default>["$props"]
-         * };
-         * }> }*/
         type: import("vue").PropType<{
             enableExportMap?: boolean;
             enableChangeProjection?: boolean;
@@ -297,6 +341,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
             searchParams?: object;
             enableZoom?: boolean;
             enableGlobe?: boolean;
+            enableMosaic?: boolean;
+            enableFeedback?: boolean;
             enableCompareIndicators?: boolean | {
                 compareTemplate?: string;
                 fallbackTemplate?: string;
@@ -483,16 +529,24 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
             enableSearch: boolean;
             enableZoom: boolean;
             enableGlobe: boolean;
+            enableMosaic: boolean;
+            enableFeedback: boolean;
             searchParams: {};
         };
     };
 }>> & Readonly<{}>, {
+    center: [number, number];
+    baseLayers: import("@eox/map/src/layers.js").EoxLayer[];
     enableCompare: boolean;
     zoom: number;
     zoomToExtent: boolean;
     enableCursorCoordinates: boolean;
     enableScaleLine: boolean;
-    btnsPosition: Record<string, any>;
+    btnsPosition: {
+        x: string | number;
+        y: number;
+        gap: number;
+    };
     btns: {
         enableExportMap?: boolean;
         enableChangeProjection?: boolean;
@@ -501,6 +555,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         searchParams?: object;
         enableZoom?: boolean;
         enableGlobe?: boolean;
+        enableMosaic?: boolean;
+        enableFeedback?: boolean;
         enableCompareIndicators?: boolean | {
             compareTemplate?: string;
             fallbackTemplate?: string;

package/dist/types/widgets/EodashMap/methods/create-layers-config.d.ts

@@ -1,9 +1,2 @@
-export function createLayersConfig(selectedIndicator: import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, eodashCols: EodashCollection[], timeOrItem?: string | import("stac-ts").StacItem | null): Promise<{
-    type: string;
-    properties: {
-        id: string;
-        title: string;
-    };
-    layers: Record<string, any>[];
-}[]>;
+export function createLayersConfig(selectedIndicator: import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, eodashCols: EodashCollection[], timeOrItem?: string | import("stac-ts").StacItem | null, defaultBaseLayers?: Record<string, any>[]): Promise<Record<string, any>[]>;
 import { EodashCollection } from "../../../core/client/eodashSTAC/EodashCollection";

package/dist/types/widgets/EodashMap/methods/index.d.ts

@@ -1,5 +1,9 @@
+export { useMapLoading } from "./use-map-loading";
 export function useHandleMapMoveEnd(mapElement: import("vue").Ref<(HTMLElement & Record<string, any> & {
     map: import("ol").Map;
 }) | null>, mapPosition: import("vue").Ref<(number | undefined)[]>): void;
-export function useInitMap(mapElement: import("vue").Ref<import("@eox/map").EOxMap | null>, selectedIndicator: import("vue").Ref<import("stac-ts").StacCollection | null>, eodashCols: import("../../../core/client/eodashSTAC/EodashCollection").EodashCollection[], datetime: import("vue").Ref<string>, mapLayers: import("vue").Ref<Record<string, any>[]>, partnerMap: import("vue").Ref<import("@eox/map").EOxMap | null>, zoomToExtent: boolean, selectedItem?: import("vue").Ref<import("stac-ts").StacItem | import("stac-ts").StacLink | null>): void;
+export function useInitMap(mapElement: import("vue").Ref<import("@eox/map").EOxMap | null>, selectedIndicator: import("vue").Ref<import("stac-ts").StacCollection | null>, eodashCols: import("../../../core/client/eodashSTAC/EodashCollection").EodashCollection[], datetime: import("vue").Ref<string>, mapLayers: import("vue").Ref<Record<string, any>[]>, partnerMap: import("vue").Ref<import("@eox/map").EOxMap | null>, zoomToExtent: boolean, selectedItem?: import("vue").Ref<import("stac-ts").StacItem | import("stac-ts").StacLink | null>, defaultBaseLayers?: Record<string, any>[]): void;
 export function useUpdateTooltipProperties(eodashCols: import("../../../core/client/eodashSTAC/EodashCollection").EodashCollection[], tooltipProperties: import("vue").Ref<Exclude<import("../../../core/client/types").EodashStyleJson["tooltip"], undefined>>, enableCompare?: boolean): void;
+import { useEmitLayersUpdate } from "../../../core/client/composables";
+import { useOnLayersUpdate } from "../../../core/client/composables";
+export { useEmitLayersUpdate, useOnLayersUpdate };

package/dist/types/widgets/EodashMap/methods/use-map-loading.d.ts

@@ -0,0 +1 @@
+export function useMapLoading(mapElement: import("vue").Ref<import("@eox/map").EOxMap | null>, compareMapElement: import("vue").Ref<import("@eox/map").EOxMap | null>): void;

package/dist/types/widgets/EodashProcess/index.vue.d.ts

@@ -6,7 +6,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         default: boolean;
     };
     vegaEmbedOptions: {
-        type: ObjectConstructor;
+        /** @type {import("vue").PropType<import("vega-embed").EmbedOptions>} */
+        type: import("vue").PropType<import("vega-embed").EmbedOptions>;
         default(): {
             actions: boolean;
         };
@@ -17,12 +18,13 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         default: boolean;
     };
     vegaEmbedOptions: {
-        type: ObjectConstructor;
+        /** @type {import("vue").PropType<import("vega-embed").EmbedOptions>} */
+        type: import("vue").PropType<import("vega-embed").EmbedOptions>;
         default(): {
             actions: boolean;
         };
     };
 }>> & Readonly<{}>, {
     enableCompare: boolean;
-    vegaEmbedOptions: Record<string, any>;
+    vegaEmbedOptions: import("vega-embed").EmbedOptions<string, import("vega-typings").Renderers>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/widgets/EodashProcess/methods/composables.d.ts

@@ -14,5 +14,5 @@ export function useInitProcess({ selectedStac, jsonformSchema, isProcessed, proc
     isProcessed: import("vue").Ref<boolean>;
     loading: import("vue").Ref<boolean>;
     isPolling: import("vue").Ref<boolean>;
-    mapElement: import("@eox/map").EOxMap | null;
+    mapElement: import("vue").Ref<import("@eox/map").EOxMap | null>;
 }): void;

package/dist/types/widgets/EodashProcess/methods/handling.d.ts

@@ -10,32 +10,37 @@
  * @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
  * @param {boolean} params.enableCompare
  */
-export function initProcess({ selectedStac, jsonformSchema, isProcessed, processResults, loading, isPolling, enableCompare, }: {
+export function initProcess({ selectedStac, jsonformSchema, isProcessed, processResults, loading, isPolling, enableCompare, mapElement, }: {
     selectedStac: import("vue").Ref<import("stac-ts").StacCollection | null>;
     jsonformSchema: import("vue").Ref<Record<string, any> | null>;
     processResults: import("vue").Ref<any[]>;
     isProcessed: import("vue").Ref<boolean>;
     loading: import("vue").Ref<boolean>;
     isPolling: import("vue").Ref<boolean>;
+    mapElement: import("@eox/map").EOxMap | null;
     enableCompare: boolean;
 }): Promise<void>;
 /**
- * Update the jsonform schema to have the correct layer id from the map
+ * Update the jsonform schema to have the correct layer id from the map.
+ * Returns null if any required layerId cannot be resolved (layer not yet in map).
+ * Callers should treat null as "retry when layers:updated fires".
  *
  * @export
- * @async
  * @param {Object} params
- * @param {Record<string,any> | null} params.jsonformSchema params.jsonformSchema
- * @param {Record<string, any>[] | undefined} params.newLayers params.newLayers
- * @param { boolean } params.enableCompare params.enableCompare
- * @returns {Promise<Record<string,any> | null>} updated jsonform schema
+ * @param {Record<string,any> | null} params.jsonformSchema
+ * @param {Record<string, any>[] | undefined} params.newLayers
+ * @param {boolean} params.enableCompare
+ * @param {import("@eox/map").EOxMap | null | undefined} params.mapElement
+ * @returns {Promise<Record<string,any> | null>} updated schema, or null if a layerId could not be resolved
  */
-export function updateJsonformIdentifier({ jsonformSchema, newLayers, enableCompare, }: {
+export function updateJsonformIdentifier({ jsonformSchema, newLayers, enableCompare, mapElement, }: {
     jsonformSchema: Record<string, any> | null;
     newLayers: Record<string, any>[] | undefined;
     enableCompare: boolean;
+    mapElement: import("@eox/map").EOxMap | null | undefined;
 }): Promise<Record<string, any> | null>;
 /**
  *

package/dist/types/widgets/EodashProcess/states.d.ts

@@ -2,7 +2,7 @@
  * The list of job result from the server
  * {job_start_datetime: string, job_end_datetime: string,status: string}
  *  @type {import("vue").Ref<import("./types").AsyncJob[]>}
- **/
+ */
 export const jobs: import("vue").Ref<import("./types").AsyncJob[]>;
 /**
  * The list of jobs results from the server for the compare map

package/dist/types/widgets/EodashStacInfo.vue.d.ts

@@ -1,6 +1,15 @@
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    level: {
+        type: import("vue").PropType<"item" | "collection">;
+        default: string;
+        validator: (v: string) => boolean;
+    };
+    styleOverride: {
+        type: StringConstructor;
+        default: string;
+    };
     allowHtml: {
         type: BooleanConstructor;
         default: boolean;
@@ -81,6 +90,15 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         default: () => string[];
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    level: {
+        type: import("vue").PropType<"item" | "collection">;
+        default: string;
+        validator: (v: string) => boolean;
+    };
+    styleOverride: {
+        type: StringConstructor;
+        default: string;
+    };
     allowHtml: {
         type: BooleanConstructor;
         default: boolean;
@@ -173,6 +191,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         key: string;
         filter?: (item: any) => boolean;
     })[];
+    styleOverride: string;
+    level: "collection" | "item";
     allowHtml: boolean;
     tags: (string | {
         key: string;

package/dist/types/widgets/EodashTimeSlider/index.vue.d.ts

@@ -0,0 +1,54 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    filters: {
+        /** @type {import("vue").PropType<import("@eox/itemfilter").EOxItemFilter["filterProperties"]>} */
+        type: import("vue").PropType<import("@eox/itemfilter").EOxItemFilter["filterProperties"]>;
+        default: () => never[];
+    };
+    animate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    useMosaic: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mosaicIndicators: {
+        /** @type {import("vue").PropType<string[]>} */
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    filters: {
+        /** @type {import("vue").PropType<import("@eox/itemfilter").EOxItemFilter["filterProperties"]>} */
+        type: import("vue").PropType<import("@eox/itemfilter").EOxItemFilter["filterProperties"]>;
+        default: () => never[];
+    };
+    animate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    useMosaic: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mosaicIndicators: {
+        /** @type {import("vue").PropType<string[]>} */
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    animate: boolean;
+    filters: {
+        key?: string;
+        keys?: Array<string>;
+        title: string;
+        type: string;
+        placeholder?: string;
+        format?: string;
+        state?: any;
+    }[];
+    useMosaic: boolean;
+    mosaicIndicators: string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/widgets/EodashTimeSlider/methods/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @param {string} stacEndpoint
+ * @param {[string, string]} selectedRange
+ * @param {import("../types").TimelineExportEventDetail["selectedRangeItems"]} selectedRangeItems
+ * @param {import("vue").Ref<import("stac-ts").StacCollection|null>} selectedStac
+ * @param {import("../../../core/client/types").ItemFilterFilters} filters
+ */
+export function createAnimationLayers(stacEndpoint: string, selectedRange: [string, string], selectedRangeItems: import("../types").TimelineExportEventDetail["selectedRangeItems"], selectedStac: import("vue").Ref<import("stac-ts").StacCollection | null>, filters: import("../../../core/client/types").ItemFilterFilters): Promise<{
+    layers: Record<string, any>[];
+    date: string;
+}[]>;
+/**
+ *
+ * @param {Record<string, any>[]} layers
+ * @returns {Record<string, any>[]}
+ */
+export function anonimizeLayersCORS(layers: Record<string, any>[]): Record<string, any>[];
+/**
+ * returns the list of layers that has visibility hidden
+ * @param {import("@eox/map").EoxLayer[]} layers
+ * @returns {{ collections: string[]; layers: string[] }}
+ */
+export function getHiddenLayers(layers: import("@eox/map").EoxLayer[]): {
+    collections: string[];
+    layers: string[];
+};
+/**
+ * Iterates through a list of layers and updates layer.properties.visible to true
+ * if it is set to false
+ * @param {import("@eox/map").EoxLayer[]} layers
+ * @returns {import("@eox/map").EoxLayer[]}
+ */
+export function restoreLayersVisibility(layers: import("@eox/map").EoxLayer[]): import("@eox/map").EoxLayer[];
+export { useScheduleMosaicUpdate } from "../../../core/client/eodashSTAC/mosaic";

package/dist/types/widgets/EodashTimeSlider/types.d.ts

@@ -0,0 +1,52 @@
+import type { ItemFilterFilters } from "../../core/client/types";
+export interface TimelineSelectionEventDetail {
+    date: [string, string];
+    instances: {
+        layer: import("ol/layer/Layer").default;
+        source: import("ol/source/Source").default;
+    };
+    filters: ItemFilterFilters;
+    selectedItems: {
+        [layerId: string]: SelectedItem[];
+    };
+}
+export interface SelectedItem {
+    className: string;
+    date: string;
+    group: string;
+    id: string;
+    itemId: string;
+    local: string;
+    originalDate: string;
+    property: string;
+    start: string;
+    type: string;
+    utc: string;
+}
+export interface TimelineExportEventDetail {
+    eoxMapConfig: {
+        layers: Record<string, any>[];
+        zoom: number;
+        center: [number, number];
+    };
+    filters: ItemFilterFilters;
+    instances: {
+        layer: import("ol/layer/Layer").default;
+        source: import("ol/source/Source").default;
+    };
+    selectedRangeItems: {
+        [layerId: string]: SelectedItem[];
+    };
+    generate: (args: {
+        mapLayers: Array<{
+            layers: Record<string, any>[];
+            date: string;
+        }>;
+        center?: [number, number];
+        zoom?: number;
+    }) => Promise<void>;
+}
+export interface ItemFilterEventDetail {
+    result: Record<string, any>;
+    filters: ItemFilterFilters;
+}

package/dist/types/widgets/EodashTools.vue.d.ts

@@ -397,6 +397,11 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         default: () => void;
     };
 }>> & Readonly<{}>, {
+    layoutIcon: string;
+    layoutTarget: string;
+    showIndicatorsBtn: boolean;
+    showLayoutSwitcher: boolean;
+    indicatorBtnText: string;
     itemFilterConfig: Partial<{
         enableCompare: boolean;
         filtersTitle: string;
@@ -439,9 +444,4 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         readonly aggregateResults?: string | undefined;
         readonly onSelect?: ((...args: any[]) => any) | undefined;
     } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "enableCompare" | "filtersTitle" | "resultsTitle" | "titleProperty" | "aggregateResults" | "imageProperty" | "subTitleProperty" | "resultType" | "cssVars" | "enableHighlighting" | "expandMultipleFilters" | "expandMultipleResults" | "styleOverride" | "filterProperties">;
-    showIndicatorsBtn: boolean;
-    showLayoutSwitcher: boolean;
-    layoutTarget: string;
-    layoutIcon: string;
-    indicatorBtnText: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;