@eodash/eodash 5.2.0 → 5.3.1

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

@@ -18,13 +18,18 @@ export function generateFeatures(links?: import("stac-ts").StacLink[], extraProp
  *
  * @param {string} collectionId
  *  @param { import("../types").EodashStyleJson} [style]
+ * @param {Record<string,any>} [rasterJsonform]
  * */
-export function extractLayerConfig(collectionId: string, style?: import("../types").EodashStyleJson): {
-    layerConfig: undefined;
-    style: undefined;
+export function extractLayerConfig(collectionId: string, style?: import("../types").EodashStyleJson, rasterJsonform?: Record<string, any>): {
+    layerConfig: {
+        schema: any;
+        legend: any;
+        type: string;
+    };
+    style: import("../types").EodashStyleJson | undefined;
 } | {
     layerConfig: Record<string, unknown> | undefined;
-    style: import("../types").EodashStyleJson;
+    style: import("../types").EodashStyleJson | undefined;
 };
 /**
  * Function to extract collection urls from an indicator
@@ -64,16 +69,32 @@ export function generateLinksFromItems(items: import("stac-ts").StacItem[]): any
 export function revokeCollectionBlobUrls(collection: import("../eodashSTAC/EodashCollection.js").EodashCollection): void;
 /**
  *
- * @param {import("stac-ts").StacLink[]} [links]
+ * @param {import("stac-ts").StacLink[] | import("stac-ts").StacItem[] |undefined |null} [linksOrItems]
+ */
+export function getDatetimeProperty(linksOrItems?: import("stac-ts").StacLink[] | import("stac-ts").StacItem[] | undefined | null): string | undefined;
+/**
+ *
+ * @param {*} stacObject
+ * @returns {stacObject is import("stac-ts").StacItem}
  */
-export function getDatetimeProperty(links?: import("stac-ts").StacLink[]): string | undefined;
+export function isSTACItem(stacObject: any): stacObject is import("stac-ts").StacItem;
+/**
+ * Fetch all STAC items from a STAC API endpoint.
+ * @param {string} itemsUrl
+ * @param {string} [query]
+ * @param {number} [limit=100] - The maximum number of items to fetch per request.
+ * @param {boolean} [returnFirst] - If true, only the first page of results will be returned.
+ * @param {number} [maxNumber=1000] - if the matched number of items exceed this, only the first page will be returned.
+ */
+export function fetchApiItems(itemsUrl: string, query?: string, limit?: number, returnFirst?: boolean, maxNumber?: number): Promise<import("stac-ts").StacItem[]>;
 /**
  * @param {import ("stac-ts").StacCollection | undefined | null} collection
  * @returns {object}
  */
 export function extractLayerLegend(collection: import("stac-ts").StacCollection | undefined | null): object;
+export function sanitizeBbox(bbox: number[]): number[];
 export function extractRoles(properties: Record<string, any>, linkOrAsset: import("stac-ts").StacLink | import("stac-ts").StacAsset): Record<string, any>;
-export function fetchStyle(item: import("stac-ts").StacItem, itemUrl: string): Promise<{
+export function fetchStyle(item: import("stac-ts").StacItem, itemUrl: string, key?: string | undefined): Promise<{
     "fill-color"?: import("ol/style/flat.js").ColorExpression | undefined;
     "fill-pattern-src"?: import("ol/style/flat.js").StringExpression | undefined;
     "fill-pattern-size"?: import("ol/style/flat.js").SizeExpression | undefined;
@@ -451,21 +472,31 @@ export function fetchStyle(item: import("stac-ts").StacItem, itemUrl: string): P
         appendix?: string;
     }[];
 } | undefined>;
+export function fetchAllStyles(item: import("stac-ts").StacItem, itemUrl: string): Promise<Array<import("../types").EodashStyleJson>>;
 export function getProjectionCode(projection?: string | number | {
     name: string;
     def: string;
 }): string;
-export function extractLayerDatetime(links?: import("stac-ts").StacLink[], currentStep?: string | null): {
-    controlValues: string[];
-    currentStep: string;
-    slider: boolean;
-    navigation: boolean;
-    play: boolean;
-    displayFormat: string;
-} | undefined;
+export function extractLayerTimeValues(items?: import("stac-ts").StacLink[] | import("stac-ts").StacItem[] | undefined, currentStep?: string | null): {
+    layerDatetime: undefined;
+    timeControlValues: undefined;
+} | {
+    layerDatetime: {
+        controlValues: string[];
+        currentStep: string;
+        slider: boolean;
+        navigation: boolean;
+        play: boolean;
+        displayFormat: string;
+    };
+    timeControlValues: {
+        date: string;
+        itemId: string;
+    }[];
+};
 export function findLayer(layers: import("@eox/map").EoxLayer[], layer: string): import("@eox/map").EoxLayer | undefined;
 export function replaceLayer(currentLayers: import("@eox/map").EoxLayer[], oldLayer: string, newLayers: import("@eox/map").EoxLayer[]): import("@eox/map").EoxLayer[];
-export function getColFromLayer(indicators: import("../eodashSTAC/EodashCollection.js").EodashCollection[], layer: import("ol/layer").Layer): import("../eodashSTAC/EodashCollection.js").EodashCollection | undefined;
+export function getColFromLayer(indicators: import("../eodashSTAC/EodashCollection.js").EodashCollection[], layer: import("ol/layer").Layer): Promise<import("../eodashSTAC/EodashCollection.js").EodashCollection | undefined>;
 export function createLayerID(collectionId: string, itemId: string, link: import("stac-ts").StacLink, projectionCode: string | import("ol/proj").ProjectionLike): string;
 export function createAssetID(collectionId: string, itemId: string, index: number): string;
 export function removeUnneededProperties(layers: Record<string, any>[]): Record<string, any>[];

package/dist/types/core/client/plugins/vuetify.d.ts

@@ -1,11 +1,11 @@
 export default vuetify;
 declare const vuetify: {
-    install: (app: import("vue").App) => void;
+    install: (app: import("vue").App<any>) => void;
     unmount: () => void;
     defaults: import("vue").Ref<import("vuetify").DefaultsInstance, import("vuetify").DefaultsInstance>;
     display: import("vuetify").DisplayInstance;
     theme: import("vuetify").ThemeInstance & {
-        install: (app: import("vue").App) => void;
+        install: (app: import("vue").App<any>) => void;
     };
     icons: {
         defaultSet: string;
@@ -13,17 +13,17 @@ declare const vuetify: {
         sets: Record<string, import("vuetify").IconSet>;
     };
     locale: {
-        isRtl: import("vue").Ref<boolean>;
-        rtl: import("vue").Ref<Record<string, boolean>>;
-        rtlClasses: import("vue").Ref<string>;
         name: string;
         decimalSeparator: import("vue").ShallowRef<string>;
-        messages: import("vue").Ref<import("vuetify").LocaleMessages>;
-        current: import("vue").Ref<string>;
-        fallback: import("vue").Ref<string>;
+        messages: import("vue").Ref<import("vuetify").LocaleMessages, import("vuetify").LocaleMessages>;
+        current: import("vue").Ref<string, string>;
+        fallback: import("vue").Ref<string, string>;
         t: (key: string, ...params: unknown[]) => string;
         n: (value: number) => string;
         provide: (props: import("vuetify").LocaleOptions) => import("vuetify").LocaleInstance;
+        isRtl: import("vue").Ref<boolean, boolean>;
+        rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
+        rtlClasses: import("vue").Ref<string, string>;
     };
     date: {
         options: {
@@ -35,7 +35,6 @@ declare const vuetify: {
             locale: Record<string, any>;
         };
         instance: {
-            locale?: any;
             date: (value?: any) => unknown;
             format: (date: unknown, formatString: string) => string;
             toJsDate: (value: unknown) => Date;
@@ -43,7 +42,7 @@ declare const vuetify: {
             toISO: (date: unknown) => string;
             startOfDay: (date: unknown) => unknown;
             endOfDay: (date: unknown) => unknown;
-            startOfWeek: (date: unknown, firstDayOfWeek?: number | string) => unknown;
+            startOfWeek: (date: unknown, firstDayOfWeek?: string | number | undefined) => unknown;
             endOfWeek: (date: unknown) => unknown;
             startOfMonth: (date: unknown) => unknown;
             endOfMonth: (date: unknown) => unknown;
@@ -65,10 +64,10 @@ declare const vuetify: {
             addMonths: (date: unknown, amount: number) => unknown;
             getYear: (date: unknown) => number;
             setYear: (date: unknown, year: number) => unknown;
-            getDiff: (date: unknown, comparing: unknown, unit?: string) => number;
-            getWeekArray: (date: unknown, firstDayOfWeek?: number | string) => unknown[][];
-            getWeekdays: (firstDayOfWeek?: number | string, weekdayFormat?: "long" | "short" | "narrow") => string[];
-            getWeek: (date: unknown, firstDayOfWeek?: number | string, firstWeekMinSize?: number) => number;
+            getDiff: (date: unknown, comparing: unknown, unit?: string | undefined) => number;
+            getWeekArray: (date: unknown, firstDayOfWeek?: string | number | undefined) => unknown[][];
+            getWeekdays: (firstDayOfWeek?: string | number | undefined, weekdayFormat?: "long" | "narrow" | "short" | undefined) => string[];
+            getWeek: (date: unknown, firstDayOfWeek?: string | number | undefined, firstDayOfYear?: string | number | undefined) => number;
             getMonth: (date: unknown) => number;
             setMonth: (date: unknown, month: number) => unknown;
             getDate: (date: unknown) => number;
@@ -79,6 +78,7 @@ declare const vuetify: {
             setHours: (date: unknown, hours: number) => unknown;
             getMinutes: (date: unknown) => number;
             setMinutes: (date: unknown, minutes: number) => unknown;
+            locale?: any;
         };
     };
     goTo: import("vuetify").GoToInstance;

package/dist/types/core/client/store/actions.d.ts

@@ -1,5 +1,7 @@
 export function getLayers(): import("@eox/map").EoxLayer[];
 export function getCompareLayers(): import("@eox/map").EoxLayer[];
+export function getChartSpec(): import("vega-embed").VisualizationSpec | null;
+export function getCompareChartSpec(): import("vega-embed").VisualizationSpec | null;
 export function registerProjection(projection?: string | number | {
     name: string;
     def: string;

package/dist/types/core/client/store/stac.d.ts

@@ -1,28 +1,37 @@
 export const useSTAcStore: import("pinia").StoreDefinition<"stac", Pick<{
+    stacEndpoint: import("vue").Ref<string | null, string | null>;
+    isApi: import("vue").Ref<boolean, boolean>;
     stac: import("vue").Ref<import("stac-ts").StacLink[] | null, import("stac-ts").StacLink[] | null>;
     init: (endpoint: import("../types").StacEndpoint) => void;
-    loadSTAC: (url?: import("../types").StacEndpoint) => Promise<void>;
-    loadSelectedSTAC: (relativePath?: string, isPoi?: boolean) => Promise<void>;
+    loadSTAC: (url?: string) => Promise<void>;
+    loadSelectedSTAC: (relativePath?: string, isPoi?: boolean, stacItem?: Object) => Promise<void>;
     loadSelectedCompareSTAC: (relativePath?: string, isPOI?: boolean) => Promise<void>;
     resetSelectedCompareSTAC: () => Promise<void>;
     selectedStac: import("vue").Ref<import("stac-ts").StacCollection | null, import("stac-ts").StacCollection | null>;
     selectedCompareStac: import("vue").Ref<import("stac-ts").StacCollection | null, import("stac-ts").StacCollection | null>;
-}, "stac" | "selectedStac" | "selectedCompareStac">, Pick<{
+    selectedItem: import("vue").Ref<import("stac-ts").StacLink | import("stac-ts").StacItem | null, import("stac-ts").StacLink | import("stac-ts").StacItem | null>;
+}, "stacEndpoint" | "isApi" | "stac" | "selectedStac" | "selectedCompareStac" | "selectedItem">, Pick<{
+    stacEndpoint: import("vue").Ref<string | null, string | null>;
+    isApi: import("vue").Ref<boolean, boolean>;
     stac: import("vue").Ref<import("stac-ts").StacLink[] | null, import("stac-ts").StacLink[] | null>;
     init: (endpoint: import("../types").StacEndpoint) => void;
-    loadSTAC: (url?: import("../types").StacEndpoint) => Promise<void>;
-    loadSelectedSTAC: (relativePath?: string, isPoi?: boolean) => Promise<void>;
+    loadSTAC: (url?: string) => Promise<void>;
+    loadSelectedSTAC: (relativePath?: string, isPoi?: boolean, stacItem?: Object) => Promise<void>;
     loadSelectedCompareSTAC: (relativePath?: string, isPOI?: boolean) => Promise<void>;
     resetSelectedCompareSTAC: () => Promise<void>;
     selectedStac: import("vue").Ref<import("stac-ts").StacCollection | null, import("stac-ts").StacCollection | null>;
     selectedCompareStac: import("vue").Ref<import("stac-ts").StacCollection | null, import("stac-ts").StacCollection | null>;
+    selectedItem: import("vue").Ref<import("stac-ts").StacLink | import("stac-ts").StacItem | null, import("stac-ts").StacLink | import("stac-ts").StacItem | null>;
 }, never>, Pick<{
+    stacEndpoint: import("vue").Ref<string | null, string | null>;
+    isApi: import("vue").Ref<boolean, boolean>;
     stac: import("vue").Ref<import("stac-ts").StacLink[] | null, import("stac-ts").StacLink[] | null>;
     init: (endpoint: import("../types").StacEndpoint) => void;
-    loadSTAC: (url?: import("../types").StacEndpoint) => Promise<void>;
-    loadSelectedSTAC: (relativePath?: string, isPoi?: boolean) => Promise<void>;
+    loadSTAC: (url?: string) => Promise<void>;
+    loadSelectedSTAC: (relativePath?: string, isPoi?: boolean, stacItem?: Object) => Promise<void>;
     loadSelectedCompareSTAC: (relativePath?: string, isPOI?: boolean) => Promise<void>;
     resetSelectedCompareSTAC: () => Promise<void>;
     selectedStac: import("vue").Ref<import("stac-ts").StacCollection | null, import("stac-ts").StacCollection | null>;
     selectedCompareStac: import("vue").Ref<import("stac-ts").StacCollection | null, import("stac-ts").StacCollection | null>;
+    selectedItem: import("vue").Ref<import("stac-ts").StacLink | import("stac-ts").StacItem | null, import("stac-ts").StacLink | import("stac-ts").StacItem | null>;
 }, "init" | "loadSTAC" | "loadSelectedSTAC" | "loadSelectedCompareSTAC" | "resetSelectedCompareSTAC">>;

package/dist/types/core/client/store/states.d.ts

@@ -30,3 +30,7 @@ export const poi: import("vue").Ref<string, string>;
  * Selected point of interest for comparison, used for location collections
  */
 export const comparePoi: import("vue").Ref<string, string>;
+/** @type {import("vue").Ref<import("@eox/chart").EOxChart | null>} */
+export const chartEl: import("vue").Ref<import("@eox/chart").EOxChart | null>;
+/** @type {import("vue").Ref<import("@eox/chart").EOxChart | null>} */
+export const compareChartEl: import("vue").Ref<import("@eox/chart").EOxChart | null>;

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

@@ -94,6 +94,11 @@ export interface TEodashDatePicker {
     properties?: InstanceType<typeof import("../../widgets/EodashDatePicker.vue").default>["$props"];
 }
 /** @group Widgets */
+export interface TEodashTimeSlider {
+    name: "EodashTimeSlider";
+    properties?: InstanceType<typeof import("../../widgets/EodashTimeSlider.vue").default>["$props"];
+}
+/** @group Widgets */
 export interface TEodashItemFilter {
     name: "EodashItemFilter";
     properties?: InstanceType<typeof import("../../widgets/EodashItemFilter.vue").default>["$props"];
@@ -128,6 +133,10 @@ export interface TEodashLayoutSwitcher {
     name: "EodashLayoutSwitcher";
     properties?: InstanceType<typeof import("../../widgets/EodashLayoutSwitcher.vue").default>["$props"];
 }
+export interface TEodashItemCatalog {
+    name: "EodashItemCatalog";
+    properties?: InstanceType<typeof import("../../widgets/EodashItemCatalog/index.vue").default>["$props"];
+}
 /** @group Widgets */
 export interface TExportState {
     name: "ExportState";
@@ -149,7 +158,7 @@ export interface TWidgetsContainer {
  * Referenced using their name without the .vue extention
  * @group Widgets
  */
-export type ComponentWidget = TEodashMap | TEodashDatePicker | TEodashItemFilter | TEodashLayerControl | TEodashStacInfo | TEodashProcess | TEodashMapBtns | TEodashTools | TEodashLayoutSwitcher | TExportState | TPopUp | TWidgetsContainer;
+export type ComponentWidget = TEodashMap | TEodashDatePicker | TEodashItemFilter | TEodashLayerControl | TEodashStacInfo | TEodashProcess | TEodashMapBtns | TEodashTools | TEodashLayoutSwitcher | TEodashItemCatalog | TExportState | TPopUp | TWidgetsContainer | TEodashTimeSlider;
 /**
  * Widget type: `internal` API. Internal widgets are Vue components provided by
  * eodash.
@@ -232,7 +241,12 @@ export interface Template {
 /** @group Eodash */
 export type MultiTemplates = Record<string, Template>;
 /** @ignore */
-export type StacEndpoint = `${string}/catalog.json`;
+export type StacEndpoint = string | {
+    endpoint: string;
+    api?: boolean;
+    rasterEndpoint?: string;
+    vectorEndpoint?: string;
+};
 /** @group Eodash */
 export interface EodashFont {
     /**
@@ -363,4 +377,158 @@ export type EodashStyleJson = import("ol/style/flat").FlatStyleLike & {
         appendix?: string;
     }[];
 };
+export type EodashRasterJSONForm = {
+    jsonform: Record<string, any>;
+    legend?: import("@eox/layercontrol/src/components/layer-config.js").EOxLayerControlLayerConfig["layerConfig"]["legend"];
+};
+/** @ignore */
 export type LayersEventBusKeys = "layers:updated" | "time:updated" | "process:updated" | "compareLayers:updated" | "compareTime:updated" | "compareProcess:updated";
+/** @ignore */
+export interface SearchParams {
+    /** Collection IDs to search within */
+    collections: string[];
+    /** Query parameters */
+    query: {
+        datetime?: {
+            eq?: string;
+            in?: string[];
+        };
+        geometry?: Record<string, any>;
+    };
+    /** Maximum number of results to return */
+    limit?: number;
+}
+export interface StacItemsAPIResponse {
+    type: "FeatureCollection";
+    features: import("stac-ts").StacItem[];
+}
+/** @ignore */
+export interface Render {
+    /** REQUIRED. Array of asset keys referencing the assets that are used to make the rendering */
+    assets: string[];
+    /** Optional title of the rendering */
+    title?: string;
+    /** 2 dimensions array of delimited Min,Max range per band. If not provided, the data will not be rescaled. */
+    rescale?: number[][];
+    /** Nodata value to use for the referenced assets. */
+    nodata?: number | string;
+    /** Color map identifier that must be applied for a raster band */
+    colormap_name?: string;
+    /** Color map JSON definition that must be applied for a raster band */
+    colormap?: Record<string, unknown>;
+    /** Color formula that must be applied for a raster band */
+    color_formula?: string;
+    /** Resampling algorithm to apply to the referenced assets. See GDAL resampling algorithm for some examples. */
+    resampling?: string;
+    /** Band arithmetic formula to apply to the referenced assets. */
+    expression?: string;
+    /** Zoom levels range applicable for the visualization */
+    minmax_zoom?: number[];
+}
+/** @ignore */
+export interface TitilerSTACParameters {
+    /** STAC Item URL. Required */
+    url: string;
+    /** asset names. */
+    assets?: string[];
+    /** rio-tiler's math expression with asset names (e.g Asset1_b1/Asset2_b1). */
+    expression?: string;
+    /** tell rio-tiler that each asset is a 1 band dataset, so expression Asset1/Asset2 can be passed. */
+    asset_as_band?: boolean;
+    /** Per asset band math expression (e.g Asset1|1,2,3). */
+    asset_bidx?: string[];
+    /** Overwrite internal Nodata value. */
+    nodata?: string | number;
+    /** Apply dataset internal Scale/Offset. */
+    unscale?: boolean;
+    /** RasterIO resampling algorithm. Defaults to nearest. */
+    resampling?: string;
+    /** WarpKernel resampling algorithm (only used when doing re-projection). Defaults to nearest. */
+    reproject?: string;
+    /** Comma (',') delimited Min,Max range (e.g rescale=0,1000, rescale=0,1000&rescale=0,3000&rescale=0,2000). */
+    rescale?: string[];
+    /** rio-color formula. */
+    color_formula?: string;
+    /** JSON encoded custom Colormap. */
+    colormap?: string;
+    /** rio-tiler color map name. */
+    colormap_name?: string;
+    /** Add mask to the output data. Default is True. */
+    return_mask?: boolean;
+    /** Buffer on each side of the given tile. It must be a multiple of 0.5. Output tilesize will be expanded to tilesize + 2 * buffer (e.g 0.5 = 257x257, 1.0 = 258x258). */
+    buffer?: number;
+    /** Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to 0. */
+    padding?: number;
+    /** Custom algorithm name (e.g hillshade). */
+    algorithm?: string;
+    /** JSON encoded algorithm parameters. */
+    algorithm_params?: string;
+}
+/**
+ * Generic GeoJSON Feature interface that can hold additional properties.
+ * @ignore
+ */
+export interface GeoJsonFeature<T = Record<string, any>, G = GeoJSON.Geometry> {
+    type: "Feature";
+    geometry: G;
+    properties: T & Record<string, any>;
+    id?: string | number;
+}
+/**
+ * Generic GeoJSON FeatureCollection interface that can hold additional properties.
+ * @ignore
+ */
+export interface GeoJsonFeatureCollection<T = Record<string, any>, G = GeoJSON.Geometry> {
+    type: "FeatureCollection";
+    features: Array<GeoJsonFeature<T, G>>;
+    properties?: T & Record<string, any>;
+}
+/**
+ * Partial STAC Authentication Extension v1.1.0
+ * Generated from https://stac-extensions.github.io/authentication/v1.1.0/schema.json
+ */
+export interface AuthScheme {
+    /** Scheme keyword, e.g. http, s3, signedUrl, oauth2, apiKey, openIdConnect */
+    type: "http" | "s3" | "signedUrl" | "oauth2" | "apiKey" | "openIdConnect" | string;
+    description?: string;
+    name?: string;
+    in?: string;
+    scheme?: string;
+    flows?: Record<string, OAuth2Flow | SignedUrlFlow>;
+    openIdConnectUrl?: string;
+}
+export interface OAuth2Flow {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
+}
+/** Signed URL flow configuration */
+export interface SignedUrlFlow {
+    authorizationApi: string;
+    method: string;
+    responseField?: string;
+    parameters?: Record<string, {
+        in: "query" | "header" | "body" | string;
+        required: boolean;
+        description?: string;
+        schema?: object;
+    }>;
+}
+export interface ApiKeyAuthScheme extends AuthScheme {
+    type: "apiKey";
+    name: string;
+    in: string;
+}
+import { StacItem, StacLink, StacAsset } from "stac-ts";
+export interface StacAuthItem extends StacItem {
+    "auth:schemes": {
+        [key: string]: AuthScheme;
+    };
+}
+export interface StacAuthLink extends StacLink {
+    "auth:refs": [string];
+}
+export interface StacAuthAsset extends StacAsset {
+    "auth:refs": [string];
+}

package/dist/types/core/client/utils/bands-editor/arithmetic.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Build the arithmetic expression interface
+ * @param {import("./index.js").BandsEditor} editor - The editor instance
+ * @param {Array<string>} colors - Array of color strings
+ * @param {Array<string>} bands - Array of band identifiers
+ * @param {Array<string>} bandTitles - Array of band titles
+ */
+export function buildArithmeticInterface(editor: import("./index.js").BandsEditor, colors: Array<string>, bands: Array<string>, bandTitles: Array<string>): void;

package/dist/types/core/client/utils/bands-editor/colors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generate band colors for the editor
+ * @param {Record<string,any>} schema - JSON schema
+ * @param {string} format - Format type ("bands" or "bands-arithmetic")
+ * @returns {string[]} Array of color strings
+ */
+export function generateBandColors(schema: Record<string, any>, format: string): string[];
+/**
+ * Get color for a specific band
+ * @param {string} band - Band identifier
+ * @param {string[]} bands - Array of band identifiers
+ * @param {string[]} colors - Array of color strings
+ * @returns {string} Color string
+ */
+export function getBandColor(band: string, bands: string[], colors: string[]): string;

package/dist/types/core/client/utils/bands-editor/dom.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Create band styles
+ * @param {string[]} bands - Array of band identifiers
+ * @param {string[]} colors - Array of color strings
+ * @param {string} additionalStyles - Additional CSS styles
+ * @returns {HTMLStyleElement} Style element
+ */
+export function createBandStyles(bands: string[], colors: string[], additionalStyles?: string): HTMLStyleElement;
+/**
+ * Create a draggable band element.
+ * @param {string} enumValue
+ * @param {string} title
+ */
+export function createBandDiv(enumValue: string, title: string): HTMLDivElement;
+/**
+ * Add draggable band elements
+ * @param {import("./index.js").BandsEditor} editor - The editor instance
+ * @param {Array<string>} bands - Array of band identifiers
+ * @param {Array<string>} bandTitles - Array of band titles
+ */
+export function addDraggableBands(editor: import("./index.js").BandsEditor, bands: Array<string>, bandTitles: Array<string>): void;
+/**
+ * Create unified styles for all slot types
+ * @param {string[]} bands - Array of band identifiers
+ * @param {string[]} colors - Array of color strings
+ * @returns {HTMLStyleElement} Style element with unified slot styles
+ */
+export function createSlotStyles(bands: string[], colors: string[]): HTMLStyleElement;
+/**
+ * Create a unified slot element for RGB or arithmetic use
+ * @param {string} identifier - RGB letter ("R", "G", "B") or variable name for arithmetic
+ * @param {(e: DragEvent) => void} onDrop - Drop handler function
+ * @returns {HTMLDivElement} Slot element
+ */
+export function createSlot(identifier: string, onDrop: (e: DragEvent) => void): HTMLDivElement;
+/**
+ * Fill a slot with a band
+ * @param {HTMLElement} slot - Slot element
+ * @param {string} enumValue - Band value
+ * @param {string} title - Band title
+ */
+export function fillSlotWithBand(slot: HTMLElement, enumValue: string, title: string): void;

package/dist/types/core/client/utils/bands-editor/index.d.ts

@@ -0,0 +1,20 @@
+export class BandsEditor extends AbstractEditor {
+    /** @type {Record<string, HTMLElement[]>} */
+    variableSlots: Record<string, HTMLElement[]>;
+    /** @type {Record<string, string>} */
+    variableValues: Record<string, string>;
+    /** @type {string[]} */
+    bands: string[];
+    /** @type {string[]} */
+    bandTitles: string[];
+    /** @type {string[]} */
+    colors: string[];
+    control: HTMLDivElement | undefined;
+}
+export const bandsEditorInterface: {
+    type: string;
+    format: string;
+    func: typeof BandsEditor;
+}[];
+export default bandsEditorInterface;
+import { AbstractEditor } from "@json-editor/json-editor/src/editor";

package/dist/types/core/client/utils/bands-editor/rgb.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Build the traditional RGB bands interface
+ * @param {import("./index.js").BandsEditor} editor - The editor instance
+ * @param {Array<string>} colors - Array of color strings
+ * @param {Array<string>} bands - Array of band identifiers
+ * @param {Array<string>} bandTitles - Array of band titles
+ */
+export function buildRGBInterface(editor: import("./index.js").BandsEditor, colors: Array<string>, bands: Array<string>, bandTitles: Array<string>): void;
+/**
+ * Add RGB slots for traditional bands interface using unified slot system
+ * @param {import("./index.js").BandsEditor} editor - The editor instance
+ * @param {Array<string>} bands - Array of band identifiers
+ * @param {Array<string>} bandTitles - Array of band titles
+ */
+export function addRGBSlots(editor: import("./index.js").BandsEditor, bands: Array<string>, bandTitles: Array<string>): void;

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

@@ -1,5 +1,5 @@
 export function loadFont(fontConfig: import("../types").Eodash["brand"]["font"], isWebComponent: boolean): Promise<string[]>;
 export function copyToClipBoard(text: string, showIcon: import("vue").Ref<boolean>): Promise<void>;
 export function setCollectionsPalette(colors: string[]): void;
-export function updateEodashCollections(eodashCollections: import("../eodashSTAC/EodashCollection").EodashCollection[], selectedStac: import("stac-ts").StacCollection, absoluteUrl: string, colorPalette: string[]): Promise<void>;
+export function updateEodashCollections(eodashCollections: import("../eodashSTAC/EodashCollection").EodashCollection[], selectedStac: import("stac-ts").StacCollection, absoluteUrl: string, colorPalette: string[], isAPI: boolean, rasterEndpoint?: string | null): Promise<void>;
 export function getElement(selector: Element | string): HTMLElement | null | undefined;

package/dist/types/templates/baseConfig.d.ts

@@ -1,4 +1,90 @@
-export function getBaseConfig(config: Partial<import("../core/client/types").Eodash>): import("../core/client/types").Eodash;
+export function getBaseConfig(config: import("vega-lite").DeepPartial<import("../core/client/types").Eodash>): ({
+    id?: string;
+    options?: {
+        useSubCode?: boolean;
+    };
+    stacEndpoint: import("../core/client/types").StacEndpoint;
+    brand: {
+        noLayout?: boolean;
+        errorMessage?: string;
+        font?: import("../core/client/types").EodashFont | {
+            body: import("../core/client/types").EodashFont;
+            headers: import("../core/client/types").EodashFont;
+        };
+        name: string;
+        logo?: string;
+        theme?: import("vuetify").ThemeDefinition & {
+            collectionsPalette?: string[];
+        };
+        footerText?: string;
+    };
+} & {
+    templates: import("../core/client/types").MultiTemplates;
+}) | {
+    id?: string | undefined;
+    options?: {
+        useSubCode?: boolean;
+    } | undefined;
+    stacEndpoint: import("../core/client/types").StacEndpoint & (string | {
+        endpoint: string;
+        api?: boolean;
+        rasterEndpoint?: string;
+        vectorEndpoint?: string;
+    });
+    brand: {
+        noLayout?: boolean;
+        errorMessage?: string;
+        font?: import("../core/client/types").EodashFont | {
+            body: import("../core/client/types").EodashFont;
+            headers: import("../core/client/types").EodashFont;
+        };
+        name: string;
+        logo?: string;
+        theme?: import("vuetify").ThemeDefinition & {
+            collectionsPalette?: string[];
+        };
+        footerText?: string;
+    } & {
+        name: string;
+        font?: import("../core/client/types").EodashFont | {
+            body: import("../core/client/types").EodashFont;
+            headers: import("../core/client/types").EodashFont;
+        } | undefined;
+        theme?: ({
+            dark?: boolean | undefined;
+            colors?: {
+                [x: string]: string | undefined;
+                background?: string | undefined;
+                surface?: string | undefined;
+                primary?: string | undefined;
+                secondary?: string | undefined;
+                success?: string | undefined;
+                warning?: string | undefined;
+                error?: string | undefined;
+                info?: string | undefined;
+                'on-background'?: string | undefined;
+                'on-surface'?: string | undefined;
+                'on-primary'?: string | undefined;
+                'on-secondary'?: string | undefined;
+                'on-success'?: string | undefined;
+                'on-warning'?: string | undefined;
+                'on-error'?: string | undefined;
+                'on-info'?: string | undefined;
+            } | undefined;
+            variables?: {
+                [x: string]: string | number | undefined;
+            } | undefined;
+        } & {
+            collectionsPalette?: string[];
+        }) | undefined;
+        noLayout?: boolean | undefined;
+        errorMessage?: string | undefined;
+        logo?: string | undefined;
+        footerText?: string | undefined;
+    };
+    template: import("../core/client/types").Template;
+    templates: import("../core/client/types").MultiTemplates;
+};
 export default baseConfig;
 /** @type {import("../core/client/types").Eodash} */
 declare const baseConfig: import("../core/client/types").Eodash;