@eodash/eodash 5.0.0-rc.1 → 5.0.0-rc.1.5

package/dist/types/core/client/components/MobileLayout.vue.d.ts

@@ -0,0 +1,312 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
+    tabs: import("vue").CreateComponentPublicInstance<{
+        symbol: any;
+        direction: "horizontal" | "vertical";
+        style: import("vue").StyleValue;
+        mobile: boolean | null;
+        disabled: boolean;
+        multiple: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        items: readonly (string | number | Record<string, any>)[];
+        density: "default" | "comfortable" | "compact" | null;
+        selectedClass: string;
+        stacked: boolean;
+        centerActive: boolean;
+        nextIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        prevIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        grow: boolean;
+        hideSlider: boolean;
+        alignTabs: "center" | "end" | "start" | "title";
+        fixedTabs: boolean;
+    } & {
+        max?: number | undefined;
+        height?: string | number | undefined;
+        color?: string | undefined;
+        class?: any;
+        mobileBreakpoint?: number | ("sm" | "md" | "lg" | "xl" | "xxl" | "xs") | undefined;
+        modelValue?: any;
+        bgColor?: string | undefined;
+        showArrows?: string | boolean | undefined;
+        sliderColor?: string | undefined;
+    } & {
+        $children?: import("vue").VNodeChild | (() => import("vue").VNodeChild) | {
+            [x: `tab.${string}`]: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            [x: `item.${string}`]: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            default?: (() => import("vue").VNodeChild) | undefined;
+            tab?: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            item?: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            window?: (() => import("vue").VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            [x: `tab.${string}`]: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            [x: `item.${string}`]: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            default?: false | (() => import("vue").VNodeChild) | undefined;
+            tab?: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            item?: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            window?: false | (() => import("vue").VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        [x: `v-slot:tab.${string}`]: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        [x: `v-slot:item.${string}`]: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:default"?: false | (() => import("vue").VNodeChild) | undefined;
+        "v-slot:tab"?: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:item"?: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:window"?: false | (() => import("vue").VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: unknown) => any) | undefined;
+    }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:modelValue': (v: unknown) => true;
+    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        symbol: any;
+        direction: "horizontal" | "vertical";
+        style: import("vue").StyleValue;
+        mobile: boolean | null;
+        disabled: boolean;
+        multiple: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        items: readonly (string | number | Record<string, any>)[];
+        density: "default" | "comfortable" | "compact" | null;
+        selectedClass: string;
+        stacked: boolean;
+        centerActive: boolean;
+        nextIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        prevIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        grow: boolean;
+        hideSlider: boolean;
+        alignTabs: "center" | "end" | "start" | "title";
+        fixedTabs: boolean;
+    } & {
+        max?: number | undefined;
+        height?: string | number | undefined;
+        color?: string | undefined;
+        class?: any;
+        mobileBreakpoint?: number | ("sm" | "md" | "lg" | "xl" | "xxl" | "xs") | undefined;
+        modelValue?: any;
+        bgColor?: string | undefined;
+        showArrows?: string | boolean | undefined;
+        sliderColor?: string | undefined;
+    } & {
+        $children?: import("vue").VNodeChild | (() => import("vue").VNodeChild) | {
+            [x: `tab.${string}`]: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            [x: `item.${string}`]: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            default?: (() => import("vue").VNodeChild) | undefined;
+            tab?: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            item?: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            window?: (() => import("vue").VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            [x: `tab.${string}`]: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            [x: `item.${string}`]: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            default?: false | (() => import("vue").VNodeChild) | undefined;
+            tab?: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            item?: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            window?: false | (() => import("vue").VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        [x: `v-slot:tab.${string}`]: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        [x: `v-slot:item.${string}`]: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:default"?: false | (() => import("vue").VNodeChild) | undefined;
+        "v-slot:tab"?: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:item"?: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:window"?: false | (() => import("vue").VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: unknown) => any) | undefined;
+    }, {
+        symbol: any;
+        height: string | number;
+        direction: "horizontal" | "vertical";
+        style: import("vue").StyleValue;
+        mobile: boolean | null;
+        disabled: boolean;
+        multiple: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        modelValue: any;
+        items: readonly (string | number | Record<string, any>)[];
+        density: "default" | "comfortable" | "compact" | null;
+        selectedClass: string;
+        stacked: boolean;
+        centerActive: boolean;
+        nextIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        prevIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        grow: boolean;
+        hideSlider: boolean;
+        alignTabs: "center" | "end" | "start" | "title";
+        fixedTabs: boolean;
+    }, true, {}, import("vue").SlotsType<Partial<{
+        [x: `tab.${string}`]: (arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNode[];
+        [x: `item.${string}`]: (arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNode[];
+        default: () => import("vue").VNode[];
+        tab: (arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNode[];
+        item: (arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNode[];
+        window: () => import("vue").VNode[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        symbol: any;
+        direction: "horizontal" | "vertical";
+        style: import("vue").StyleValue;
+        mobile: boolean | null;
+        disabled: boolean;
+        multiple: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        items: readonly (string | number | Record<string, any>)[];
+        density: "default" | "comfortable" | "compact" | null;
+        selectedClass: string;
+        stacked: boolean;
+        centerActive: boolean;
+        nextIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        prevIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        grow: boolean;
+        hideSlider: boolean;
+        alignTabs: "center" | "end" | "start" | "title";
+        fixedTabs: boolean;
+    } & {
+        max?: number | undefined;
+        height?: string | number | undefined;
+        color?: string | undefined;
+        class?: any;
+        mobileBreakpoint?: number | ("sm" | "md" | "lg" | "xl" | "xxl" | "xs") | undefined;
+        modelValue?: any;
+        bgColor?: string | undefined;
+        showArrows?: string | boolean | undefined;
+        sliderColor?: string | undefined;
+    } & {
+        $children?: import("vue").VNodeChild | (() => import("vue").VNodeChild) | {
+            [x: `tab.${string}`]: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            [x: `item.${string}`]: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            default?: (() => import("vue").VNodeChild) | undefined;
+            tab?: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            item?: ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            window?: (() => import("vue").VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            [x: `tab.${string}`]: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            [x: `item.${string}`]: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            default?: false | (() => import("vue").VNodeChild) | undefined;
+            tab?: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            item?: false | ((arg: {
+                item: string | number | Record<string, any>;
+            }) => import("vue").VNodeChild) | undefined;
+            window?: false | (() => import("vue").VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        [x: `v-slot:tab.${string}`]: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        [x: `v-slot:item.${string}`]: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:default"?: false | (() => import("vue").VNodeChild) | undefined;
+        "v-slot:tab"?: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:item"?: false | ((arg: {
+            item: string | number | Record<string, any>;
+        }) => import("vue").VNodeChild) | undefined;
+        "v-slot:window"?: false | (() => import("vue").VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: unknown) => any) | undefined;
+    }, {}, {}, {}, {}, {
+        symbol: any;
+        height: string | number;
+        direction: "horizontal" | "vertical";
+        style: import("vue").StyleValue;
+        mobile: boolean | null;
+        disabled: boolean;
+        multiple: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        modelValue: any;
+        items: readonly (string | number | Record<string, any>)[];
+        density: "default" | "comfortable" | "compact" | null;
+        selectedClass: string;
+        stacked: boolean;
+        centerActive: boolean;
+        nextIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        prevIcon: string | (string | [path: string, opacity: number])[] | ((new () => any) | import("vue").FunctionalComponent<any, {}, any, {}>);
+        grow: boolean;
+        hideSlider: boolean;
+        alignTabs: "center" | "end" | "start" | "title";
+        fixedTabs: boolean;
+    }> | null;
+}, any>;
+export default _default;

package/dist/types/core/client/composables/DefineEodash.d.ts

@@ -0,0 +1,2 @@
+export function useEodashRuntime(runtimeConfig: string | undefined): Promise<import("../types").Eodash>;
+export function createEodash(config: ((store: typeof import("../store").default) => (Promise<import("../types").Eodash> | import("../types").Eodash)) | import("../types").Eodash): Promise<import("../types").Eodash<"compiletime">>;

package/dist/types/core/client/composables/DefineTemplate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @typedef {{
+ * bgWidget:ReturnType< typeof import("./DefineWidgets").useDefineWidgets>[number]| import("vue").ShallowRef<null>
+ * loading: ReturnType< typeof import("./DefineWidgets").useDefineWidgets>[number]| import("vue").ShallowRef<null>
+ * importedWidgets:ReturnType< typeof import("./DefineWidgets").useDefineWidgets>
+ * gap: import("vue").Ref<number>
+ * }} DefinedTemplate
+ **/
+export function useDefineTemplate(): import("vue").ToRefs<DefinedTemplate>;
+export type DefinedTemplate = {
+    bgWidget: ReturnType<typeof import("./DefineWidgets").useDefineWidgets>[number] | import("vue").ShallowRef<null>;
+    loading: ReturnType<typeof import("./DefineWidgets").useDefineWidgets>[number] | import("vue").ShallowRef<null>;
+    importedWidgets: ReturnType<typeof import("./DefineWidgets").useDefineWidgets>;
+    gap: import("vue").Ref<number>;
+};

package/dist/types/core/client/composables/DefineWidgets.d.ts

@@ -0,0 +1,14 @@
+export function useDefineWidgets(widgetConfigs: (import("../types").Widget | import("../types").BackgroundWidget | Omit<import("../types").Widget, "layout"> | undefined)[] | undefined): ReactiveDefinedWidget[];
+export type DefinedWidget = {
+    component: import("vue").Component | null;
+    props: Record<string, unknown>;
+    title: string;
+    id: string | number | symbol;
+    layout: {
+        x: number;
+        y: number;
+        h: number;
+        w: number;
+    };
+};
+export type ReactiveDefinedWidget = import("vue").ShallowRef<DefinedWidget>;

package/dist/types/core/client/composables/EodashMap.d.ts

@@ -0,0 +1,5 @@
+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<(HTMLElement & Record<string, any>) | null>, selectedIndicator: import("vue").Ref<import("stac-ts").StacCollection | null>, eodashCols: EodashCollection[], datetime: import("vue").Ref<string>, mapLayers: import("vue").Ref<Record<string, any>[]>, partnerMap: import("vue").Ref<(HTMLElement & Record<string, any>) | null>): void;
+import { EodashCollection } from "../eodashSTAC/EodashCollection";

package/dist/types/core/client/composables/EodashProcess.d.ts

@@ -0,0 +1,156 @@
+/**
+ * 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.
+ */
+export function pollProcessStatus({ processUrl, isPolling, pollInterval, maxRetries, }: {
+    processUrl: string;
+    isPolling: import("vue").Ref<boolean>;
+    pollInterval?: number | undefined;
+    maxRetries?: number | undefined;
+}): Promise<JSON>;
+/**
+ * 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
+ **/
+export function useAutoExec(autoExec: import("vue").Ref<boolean>, jsonformEl: import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>, jsonformSchema: import("vue").Ref<Record<string, any> | null>, startProcess: () => Promise<void>): void;
+/**
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+export function getBboxProperty(jsonformSchema?: Record<string, any> | null): string;
+/**
+ * Extracts the keys of type "geojson" from the jsonform schema
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+export function getGeoJsonProperties(jsonformSchema?: Record<string, any> | null): string[];
+/**
+ * Converts jsonform geojson values to stringified geometries
+ * @param {Record<string,any> |null} [jsonformSchema]
+ * @param {Record<string,any>} jsonformValue
+ **/
+export function extractGeometries(jsonformValue: Record<string, any>, jsonformSchema?: Record<string, any> | null): void;
+/**
+ * Injects CSS to remove the borders of the jsonform from inside the shadowRoot
+ * @param {import("@eox/jsonform").EOxJSONForm | null} jsonFormEl
+ **/
+export function injectJsonformCSS(jsonFormEl: import("@eox/jsonform").EOxJSONForm | null): void;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any>|undefined} jsonformValue
+ * @param {number[]} origBbox
+ */
+export function processImage(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, origBbox: number[]): {
+    type: string;
+    properties: {
+        id: unknown;
+        title: string;
+    };
+    source: {
+        type: string;
+        imageExtent: number[];
+        url: string;
+    };
+}[] | undefined;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {string} layerId
+ */
+export function processVector(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, layerId: string): Promise<Record<string, any>[] | undefined>;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {import("vue").Ref<boolean>} isPolling
+ * @param {string} layerId
+ */
+export function processGeoTiff(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, layerId: string, isPolling: import("vue").Ref<boolean>): Promise<{
+    style?: Record<string, any> | undefined;
+    type: string;
+    source: {
+        type: string;
+        normalize: boolean;
+        sources: {
+            url: string;
+        }[];
+    };
+    properties: {
+        layerConfig?: Record<string, any> | undefined;
+        id: string;
+        title: string;
+    };
+} | undefined>;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {string} specUrl
+ * @returns {Promise<[import("vega").Spec|null,Record<string,any>|null]>}
+ **/
+export function getChartValues(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, specUrl: string): Promise<[import("vega").Spec | null, Record<string, any> | null]>;
+/**
+ * @param {Object} params
+ * @param {import("vue").Ref<boolean>} params.loading
+ * @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"]>} params.chartSpec
+ * @param {import("vue").Ref<Record<string, any> | null>} params.chartData
+ * @param {import("vue").Ref<boolean>} params.isPolling
+ */
+export function handleProcesses({ loading, selectedStac, jsonformEl, jsonformSchema, chartSpec, chartData, isPolling, }: {
+    loading: import("vue").Ref<boolean>;
+    selectedStac: import("vue").Ref<import("stac-ts").StacCollection | null>;
+    jsonformEl: import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>;
+    jsonformSchema: import("vue").Ref<Record<string, any> | null>;
+    chartSpec: import("vue").Ref<import("@eox/chart").EOxChart["spec"]>;
+    chartData: import("vue").Ref<Record<string, any> | null>;
+    isPolling: import("vue").Ref<boolean>;
+}): Promise<void>;
+/**
+ * Reset the process state
+ * @param {Object} params
+ * @param {import("vue").Ref<boolean>} params.loading
+ * @param {import("vue").Ref<boolean>} params.isProcessed
+ * @param {import("vue").Ref<import("@eox/chart").EOxChart["spec"]>} params.chartSpec
+ * @param {import("vue").Ref<boolean>} params.isPolling
+ * @param {import("vue").Ref<Record<string,any>|null>} params.jsonformSchema
+ */
+export function resetProcess({ loading, isProcessed, chartSpec, jsonformSchema, isPolling, }: {
+    loading: import("vue").Ref<boolean>;
+    isProcessed: import("vue").Ref<boolean>;
+    chartSpec: import("vue").Ref<import("@eox/chart").EOxChart["spec"]>;
+    isPolling: import("vue").Ref<boolean>;
+    jsonformSchema: import("vue").Ref<Record<string, any> | null>;
+}): void;
+/**
+ * Description placeholder
+ *
+ * @export
+ * @async
+ * @param {Object} params
+ * @param {import("vue").Ref<import("stac-ts").StacCollection>} 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"]>} params.chartSpec
+ * @param {import("vue").Ref<boolean>} params.isProcessed
+ * @param {import("vue").Ref<boolean>} params.loading
+ * @param {import("vue").Ref<boolean>} params.isPolling
+ */
+export function initProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpec, isProcessed, loading, isPolling, }: {
+    selectedStac: import("vue").Ref<import("stac-ts").StacCollection>;
+    jsonformEl: import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>;
+    jsonformSchema: import("vue").Ref<Record<string, any> | null>;
+    chartSpec: import("vue").Ref<import("@eox/chart").EOxChart["spec"]>;
+    isProcessed: import("vue").Ref<boolean>;
+    loading: import("vue").Ref<boolean>;
+    isPolling: import("vue").Ref<boolean>;
+}): Promise<void>;

package/dist/types/core/client/composables/index.d.ts

@@ -0,0 +1,9 @@
+export function useAbsoluteUrl(rel?: string, base?: string): import("vue").Ref<string>;
+export function useCompareAbsoluteUrl(rel?: string, base?: string): import("vue").Ref<string>;
+export function useUpdateTheme(themeName: string, themeDefinition?: import("vuetify").ThemeDefinition): import("vuetify").ThemeInstance;
+export function useURLSearchParametersSync(): void;
+export function makePanelTransparent(root: import("vue").Ref<HTMLElement | null>): void;
+export function useGetTemplates(): string[];
+export function useOnLayersUpdate(listener: import("@vueuse/core").EventBusListener<"layers:updated" | "time:updated", {
+    layers: Record<string, any>[] | undefined;
+}>): void;

package/dist/types/core/client/eodash.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reactive Edoash Instance Object. provided globally in the app, and used as an
+ * intermediate object to make user defined instances config reactive.
+ *
+ * @type {import("./types").Eodash}
+ */
+export const eodash: import("./types").Eodash;
+export default eodash;

package/dist/types/core/client/eodashSTAC/EodashCollection.d.ts

@@ -0,0 +1,108 @@
+export class EodashCollection {
+    /**
+     * Returns base layers and overlay layers of a STAC Collection
+     *
+     * @param {import("stac-ts").StacCollection} indicator */
+    static getIndicatorLayers(indicator: import("stac-ts").StacCollection): Promise<(Record<string, any> | {
+        style?: import("ol/layer/WebGLTile").Style | undefined;
+        type: string;
+        source: {
+            type: string;
+            url: string;
+            format: string;
+        };
+        properties: {
+            layerConfig?: {
+                style: import("ol/layer/WebGLTile").Style | undefined;
+            } | undefined;
+            id: string;
+            title: string;
+            layerDatetime: Record<string, unknown> | undefined;
+        };
+    } | {
+        type: string;
+        source: {
+            type: string;
+            normalize: boolean;
+            interpolate: boolean;
+            sources: {
+                url: string;
+            }[];
+        };
+        properties: {
+            id: string;
+            title: string;
+            layerConfig: Record<string, unknown> | undefined;
+            layerDatetime: Record<string, unknown> | undefined;
+        };
+        style: import("ol/layer/WebGLTile").Style | undefined;
+    })[]>;
+    /**
+     * Returns GeoDB layer from a list of EodashCollections
+     *
+     * @param {EodashCollection[]} eodashCollections
+     *
+     **/
+    static getGeoDBLayer(eodashCollections: EodashCollection[]): {
+        type: string;
+        properties: {
+            id: string;
+            title: string;
+        };
+        source: {
+            type: string;
+            url: string;
+            format: string;
+        };
+        style: {
+            "circle-radius": number;
+            "circle-fill-color": string;
+            "circle-stroke-color": string;
+            "fill-color": string;
+            "stroke-color": string;
+        };
+        interactions: never[];
+    } | null;
+    /** @param {string} collectionUrl */
+    constructor(collectionUrl: string);
+    /**
+     * @type {import("stac-ts").StacLink
+     *   | import("stac-ts").StacItem
+     *   | undefined}
+     */
+    selectedItem: import("stac-ts").StacLink | import("stac-ts").StacItem | undefined;
+    get collectionStac(): import("stac-ts").StacCollection | undefined;
+    /**
+     * @async
+     * @param {import('stac-ts').StacLink | Date} [linkOrDate]
+     * @returns
+     */
+    createLayersJson: (linkOrDate?: import("stac-ts").StacLink | Date) => Promise<Record<string, any>[]>;
+    /**
+     * @param {import("stac-ts").StacItem} item
+     * @param {string} itemUrl
+     * @param {string} title
+     * @param {boolean} isGeoDB
+     * @param {string} [itemDatetime]
+     * @returns {Promise<Record<string,any>[]>} layers
+     * */
+    buildJsonArray(item: import("stac-ts").StacItem, itemUrl: string, title: string, isGeoDB: boolean, itemDatetime?: string): Promise<Record<string, any>[]>;
+    fetchCollection(): Promise<import("stac-ts").StacCollection>;
+    getItems(): import("stac-ts").StacLink[] | undefined;
+    getDates(): Date[] | undefined;
+    getExtent(): Promise<import("stac-ts").Extents | undefined>;
+    /**
+     * Get closest Item Link from a certain date,
+     * get the latest if no date provided
+     *  @param {Date} [date]
+     **/
+    getItem(date?: Date): import("stac-ts").StacLink | undefined;
+    /**
+     *
+     * @param {string} datetime
+     * @param {string} layer
+     * @param {string} map
+     */
+    updateLayerJson(datetime: string, layer: string, map: string): Promise<Record<string, any>[] | undefined>;
+    #private;
+}