@jupytergis/base 0.5.0 → 0.6.1

package/lib/stacBrowser/constants.js

@@ -0,0 +1,197 @@
+export const datasets = [
+    { collection: 'Sentinel 1', datasets: ['PEPS_S1_L1', 'PEPS_S1_L2'] },
+    {
+        collection: 'Sentinel 2',
+        datasets: [
+            'PEPS_S2_L1C',
+            'MUSCATE_SENTINEL2_SENTINEL2_L2A',
+            'MUSCATE_Snow_SENTINEL2_L2B-SNOW',
+            'MUSCATE_WaterQual_SENTINEL2_L2B-WATER',
+            'MUSCATE_SENTINEL2_SENTINEL2_L3A',
+        ],
+    },
+    {
+        collection: 'Venus',
+        datasets: [
+            'MUSCATE_VENUS_VM1_L1C',
+            'MUSCATE_VENUSVM05_VM5_L1C',
+            'MUSCATE_VENUS_VM1_L2A',
+            'MUSCATE_VENUSVM05_VM5_L2A',
+            'MUSCATE_VENUS_VM1_L3A',
+            'MUSCATE_VENUSVM05_VM5_L3A',
+        ],
+    },
+    {
+        collection: 'Spot',
+        datasets: [
+            'MUSCATE_SPOTWORLDHERITAGE_SPOT1_L1C',
+            'MUSCATE_SPOTWORLDHERITAGE_SPOT2_L1C',
+            'MUSCATE_SPOTWORLDHERITAGE_SPOT3_L1C',
+            'TAKE5_SPOT4_L1C',
+            'MUSCATE_SPOTWORLDHERITAGE_SPOT4_L1C',
+            'TAKE5_SPOT4_L2A',
+            'TAKE5_SPOT5_L2A',
+            'TAKE5_SPOT5_L1C',
+            'MUSCATE_SPOTWORLDHERITAGE_SPOT5_L1C',
+            'MUSCATE_Spirit_SPOT5_L1A',
+            'SWH_SPOT123_L1',
+            'SWH_SPOT4_L1',
+            'SWH_SPOT5_L1',
+        ],
+    },
+    {
+        collection: 'Landsat',
+        datasets: [
+            'MUSCATE_Landsat57_LANDSAT5_N2A',
+            'MUSCATE_Landsat57_LANDSAT7_N2A',
+            'MUSCATE_LANDSAT_LANDSAT8_L2A',
+            'MUSCATE_Snow_LANDSAT8_L2B-SNOW',
+        ],
+    },
+    {
+        collection: 'OSO',
+        datasets: ['MUSCATE_OSO_RASTER_L3B-OSO', 'MUSCATE_OSO_VECTOR_L3B-OSO'],
+    },
+    {
+        collection: 'Postel',
+        datasets: [
+            'POSTEL_VEGETATION_LAI',
+            'POSTEL_VEGETATION_FCOVER',
+            'POSTEL_VEGETATION_FAPAR',
+            'POSTEL_VEGETATION_NDVI',
+            'POSTEL_VEGETATION_SURFACEREFLECTANCE',
+            'POSTEL_RADIATION_BRDF',
+            'POSTEL_RADIATION_DLR',
+            'POSTEL_RADIATION_SURFACEREFLECTANCE',
+            'POSTEL_RADIATION_SURFACEALBEDO',
+            'POSTEL_WATER_SOILMOISTURE',
+            'POSTEL_WATER_SWI',
+            'POSTEL_WATER_SURFWET',
+            'POSTEL_WATER_PRECIP',
+            'POSTEL_LANDCOVER_GLOBCOVER',
+        ],
+    },
+    {
+        collection: 'GEOV2 AVHRR',
+        datasets: [
+            'POSTEL_VEGETATION_LAI',
+            'POSTEL_VEGETATION_FCOVER',
+            'POSTEL_VEGETATION_FAPAR',
+            'POSTEL_VEGETATION_NDVI',
+        ],
+    },
+];
+// map collection names to available platforms
+export const platforms = {
+    'Sentinel 1': ['S1A', 'S1B'],
+    'Sentinel 2': ['S2A', 'S2B', 'S2X'],
+    Venus: ['VM1', 'VM5'],
+    Spot: [
+        'SPOT1',
+        'SPOT2',
+        'SPOT3',
+        'SPOT4',
+        'SPOT5',
+        'SPOT4_TAKE5',
+        'SPOT5_TAKE5',
+    ],
+    Landsat: ['LANDSAT5', 'LANDSAT7', 'LANDSAT8'],
+    // OSO, Postel, and GEOV2 don't have platforms
+};
+export const products = [
+    {
+        productCode: 'SLC',
+        productType: ['SLC'],
+        processingLevel: 'L1',
+        collections: ['Sentinel 1'],
+    },
+    {
+        productCode: 'GRD',
+        productType: ['GRD'],
+        processingLevel: 'L1',
+        collections: ['Sentinel 1'],
+    },
+    {
+        productCode: 'OCN',
+        productType: ['OCN'],
+        processingLevel: 'L2',
+        collections: ['Sentinel 1'],
+    },
+    {
+        productCode: 'L1C',
+        productType: ['REFLECTANCE', 'REFLECTANCETOA', 'S2MSI1C'],
+        processingLevel: 'L1C',
+        collections: ['Sentinel 2', 'Venus', 'Spot'],
+    },
+    {
+        productCode: 'L2A',
+        productType: ['REFLECTANCE'],
+        processingLevel: 'L2A',
+        collections: ['Sentinel 2', 'Venus', 'Spot', 'Landsat'],
+    },
+    {
+        productCode: 'L2B SNOW',
+        productType: ['SNOW_MASK'],
+        processingLevel: 'L2B-SNOW',
+        collections: ['Sentinel 2', 'Landsat'],
+    },
+    {
+        productCode: 'L2B WATER',
+        productType: ['REFLECTANCE'],
+        processingLevel: 'L2B-WATER',
+        collections: ['Sentinel 2'],
+    },
+    {
+        productCode: 'L3A',
+        productType: ['REFLECTANCE'],
+        processingLevel: 'L3A',
+        collections: ['Sentinel 2', 'Venus'],
+    },
+    {
+        productCode: 'L1A',
+        productType: [
+            'DEM',
+            'REFLECTANCETOA',
+            'DEM9V20',
+            'DEMS9V20',
+            'DEMS09V20',
+            'DEMSV20',
+            'DEPS9V20',
+            'SPOTDEM',
+        ],
+        processingLevel: 'L1A',
+        collections: ['Spot'],
+    },
+    {
+        productCode: 'N2A',
+        productType: ['REFLECTANCE'],
+        processingLevel: 'N2A',
+        collections: ['Landsat'],
+    },
+    {
+        productCode: 'L3B-OSO',
+        productType: ['REFLECTANCE'],
+        processingLevel: 'L3B-OSO',
+        collections: ['OSO'],
+    },
+    {
+        productCode: 'Vegetation',
+        productType: ['Vegetation'],
+        collections: ['Postel', 'GEOV2 AVHRR'],
+    },
+    {
+        productCode: 'Radiation',
+        productType: ['Radiation'],
+        collections: ['Postel'],
+    },
+    {
+        productCode: 'Water',
+        productType: ['Water'],
+        collections: ['Postel'],
+    },
+    {
+        productCode: 'LandCover',
+        productType: ['LandCover'],
+        collections: ['Postel'],
+    },
+];

package/lib/stacBrowser/hooks/useStacSearch.d.ts

@@ -0,0 +1,30 @@
+import { IJupyterGISModel } from '@jupytergis/schema';
+import { IStacItem, StacFilterState, StacFilterSetters } from "../types/types";
+interface IUseStacSearchProps {
+    model: IJupyterGISModel | undefined;
+}
+interface IUseStacSearchReturn {
+    filterState: StacFilterState;
+    filterSetters: StacFilterSetters;
+    results: IStacItem[];
+    startTime: Date | undefined;
+    setStartTime: (date: Date | undefined) => void;
+    endTime: Date | undefined;
+    setEndTime: (date: Date | undefined) => void;
+    totalPages: number;
+    currentPage: number;
+    totalResults: number;
+    handlePaginationClick: (page: number) => Promise<void>;
+    handleResultClick: (id: string) => Promise<void>;
+    formatResult: (item: IStacItem) => string;
+    isLoading: boolean;
+    useWorldBBox: boolean;
+    setUseWorldBBox: (val: boolean) => void;
+}
+/**
+ * Custom hook for managing STAC search functionality
+ * @param props - Configuration object containing datasets, platforms, products, and model
+ * @returns Object containing state and handlers for STAC search
+ */
+declare function useStacSearch({ model }: IUseStacSearchProps): IUseStacSearchReturn;
+export default useStacSearch;

package/lib/stacBrowser/hooks/useStacSearch.js

@@ -0,0 +1,221 @@
+var _a;
+import { UUID } from '@lumino/coreutils';
+import { startOfYesterday } from 'date-fns';
+import { useEffect, useState } from 'react';
+import useIsFirstRender from "../../shared/hooks/useIsFirstRender";
+import { products } from "../constants";
+import { GlobalStateDbManager } from "../../store";
+import { fetchWithProxies } from "../../tools";
+const API_URL = 'https://geodes-portal.cnes.fr/api/stac/search';
+const XSRF_TOKEN = (_a = document.cookie.match(/_xsrf=([^;]+)/)) === null || _a === void 0 ? void 0 : _a[1];
+const STAC_FILTERS_KEY = 'jupytergis:stac-filters';
+/**
+ * Custom hook for managing STAC search functionality
+ * @param props - Configuration object containing datasets, platforms, products, and model
+ * @returns Object containing state and handlers for STAC search
+ */
+function useStacSearch({ model }) {
+    const isFirstRender = useIsFirstRender();
+    const stateDb = GlobalStateDbManager.getInstance().getStateDb();
+    const [results, setResults] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [totalPages, setTotalPages] = useState(1);
+    const [currentPage, setCurrentPage] = useState(1);
+    const [totalResults, setTotalResults] = useState(0);
+    const [startTime, setStartTime] = useState(undefined);
+    const [endTime, setEndTime] = useState(undefined);
+    const [currentBBox, setCurrentBBox] = useState([-180, -90, 180, 90]);
+    const [useWorldBBox, setUseWorldBBox] = useState(false);
+    const [filterState, setFilterState] = useState({
+        collections: new Set(),
+        datasets: new Set(),
+        platforms: new Set(),
+        products: new Set(),
+    });
+    const filterSetters = {
+        collections: val => setFilterState(s => (Object.assign(Object.assign({}, s), { collections: new Set(val) }))),
+        datasets: val => setFilterState(s => (Object.assign(Object.assign({}, s), { datasets: new Set(val) }))),
+        platforms: val => setFilterState(s => (Object.assign(Object.assign({}, s), { platforms: new Set(val) }))),
+        products: val => setFilterState(s => (Object.assign(Object.assign({}, s), { products: new Set(val) }))),
+    };
+    // On mount, fetch filterState and times from StateDB (if present)
+    useEffect(() => {
+        async function loadStacStateFromDb() {
+            var _a, _b, _c, _d;
+            const savedFilterState = (await (stateDb === null || stateDb === void 0 ? void 0 : stateDb.fetch(STAC_FILTERS_KEY)));
+            setFilterState({
+                collections: new Set((_a = savedFilterState === null || savedFilterState === void 0 ? void 0 : savedFilterState.collections) !== null && _a !== void 0 ? _a : []),
+                datasets: new Set((_b = savedFilterState === null || savedFilterState === void 0 ? void 0 : savedFilterState.datasets) !== null && _b !== void 0 ? _b : []),
+                platforms: new Set((_c = savedFilterState === null || savedFilterState === void 0 ? void 0 : savedFilterState.platforms) !== null && _c !== void 0 ? _c : []),
+                products: new Set((_d = savedFilterState === null || savedFilterState === void 0 ? void 0 : savedFilterState.products) !== null && _d !== void 0 ? _d : []),
+            });
+        }
+        loadStacStateFromDb();
+    }, [stateDb]);
+    // Save filterState to StateDB on change
+    useEffect(() => {
+        async function saveStacFilterStateToDb() {
+            await (stateDb === null || stateDb === void 0 ? void 0 : stateDb.save(STAC_FILTERS_KEY, {
+                collections: Array.from(filterState.collections),
+                datasets: Array.from(filterState.datasets),
+                platforms: Array.from(filterState.platforms),
+                products: Array.from(filterState.products),
+            }));
+        }
+        saveStacFilterStateToDb();
+    }, [filterState, stateDb]);
+    // Handle search when filters change
+    useEffect(() => {
+        if (model && !isFirstRender && filterState.datasets.size > 0) {
+            setCurrentPage(1);
+            fetchResults(1);
+        }
+    }, [filterState, startTime, endTime, currentBBox]);
+    // Listen for model updates to get current bounding box
+    useEffect(() => {
+        const listenToModel = (sender, bBoxIn4326) => {
+            if (useWorldBBox) {
+                setCurrentBBox([-180, -90, 180, 90]);
+            }
+            else {
+                setCurrentBBox(bBoxIn4326);
+            }
+        };
+        model === null || model === void 0 ? void 0 : model.updateBboxSignal.connect(listenToModel);
+        return () => {
+            model === null || model === void 0 ? void 0 : model.updateBboxSignal.disconnect(listenToModel);
+        };
+    }, [model, useWorldBBox]);
+    const fetchResults = async (page = 1) => {
+        const processingLevel = new Set();
+        const productType = new Set();
+        filterState.products.forEach(productCode => {
+            products
+                .filter(product => product.productCode === productCode)
+                .forEach(product => {
+                if (product.processingLevel) {
+                    processingLevel.add(product.processingLevel);
+                }
+                if (product.productType) {
+                    product.productType.forEach(type => productType.add(type));
+                }
+            });
+        });
+        const body = {
+            bbox: currentBBox,
+            limit: 12,
+            page,
+            query: Object.assign(Object.assign(Object.assign(Object.assign({ latest: { eq: true }, dataset: { in: Array.from(filterState.datasets) }, end_datetime: {
+                    gte: startTime
+                        ? startTime.toISOString()
+                        : startOfYesterday().toISOString(),
+                } }, (endTime && {
+                start_datetime: { lte: endTime.toISOString() },
+            })), (filterState.platforms.size > 0 && {
+                platform: { in: Array.from(filterState.platforms) },
+            })), (processingLevel.size > 0 && {
+                'processing:level': { in: Array.from(processingLevel) },
+            })), (productType.size > 0 && {
+                'product:type': { in: Array.from(productType) },
+            })),
+            sortBy: [{ direction: 'desc', field: 'start_datetime' }],
+        };
+        try {
+            setIsLoading(true);
+            const options = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-XSRFToken': XSRF_TOKEN,
+                    credentials: 'include',
+                },
+                body: JSON.stringify(body),
+            };
+            if (!model) {
+                return;
+            }
+            const data = (await fetchWithProxies(API_URL, model, async (response) => await response.json(), 
+            //@ts-expect-error Jupyter requires X-XSRFToken header
+            options, 'internal'));
+            if (!data) {
+                console.log('No Results found');
+                setResults([]);
+                setTotalPages(1);
+                setTotalResults(0);
+                return;
+            }
+            setResults(data.features);
+            const pages = data.context.matched / data.context.limit;
+            setTotalPages(Math.ceil(pages));
+            setTotalResults(data.context.matched);
+        }
+        catch (error) {
+            console.error('Error fetching data:', error);
+            setResults([]);
+            setTotalPages(1);
+            setTotalResults(0);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    /**
+     * Handles clicking on a result item
+     * @param id - ID of the clicked result
+     */
+    const handleResultClick = async (id) => {
+        var _a;
+        if (!results) {
+            return;
+        }
+        const layerId = UUID.uuid4();
+        const stacData = results.find(item => item.id === id);
+        if (!stacData) {
+            console.error('Result not found:', id);
+            return;
+        }
+        const layerModel = {
+            type: 'StacLayer',
+            parameters: { data: stacData },
+            visible: true,
+            name: (_a = stacData.properties.title) !== null && _a !== void 0 ? _a : stacData.id,
+        };
+        model && model.addLayer(layerId, layerModel);
+    };
+    /**
+     * Handles pagination clicks
+     * @param page - Page number to navigate to
+     */
+    const handlePaginationClick = async (page) => {
+        setCurrentPage(page);
+        model && fetchResults(page);
+    };
+    /**
+     * Formats a result item for display
+     * @param item - STAC item to format
+     * @returns Formatted string representation of the item
+     */
+    const formatResult = (item) => {
+        var _a;
+        return (_a = item.properties.title) !== null && _a !== void 0 ? _a : item.id;
+    };
+    return {
+        filterState,
+        filterSetters,
+        results,
+        startTime,
+        setStartTime,
+        endTime,
+        setEndTime,
+        totalPages,
+        currentPage,
+        totalResults,
+        handlePaginationClick,
+        handleResultClick,
+        formatResult,
+        isLoading,
+        useWorldBBox,
+        setUseWorldBBox,
+    };
+}
+export default useStacSearch;

package/lib/stacBrowser/index.d.ts

@@ -0,0 +1 @@
+export * from './StacBrowser';

package/lib/stacBrowser/index.js

@@ -0,0 +1 @@
+export * from './StacBrowser';

package/lib/stacBrowser/types/types.d.ts

@@ -0,0 +1,124 @@
+export interface IStacCollection {
+    type: 'Collection';
+    stac_version: string;
+    stac_extensions?: string[];
+    id: string;
+    title?: string;
+    description: string;
+    keywords?: string[];
+    license: string;
+    providers?: IStacProvider[];
+    extent: IStacExtent;
+    summaries?: {
+        [key: string]: IStacRange | JSON;
+    };
+    links: IStacLink[];
+    assets?: {
+        [key: string]: IStacAsset;
+    };
+}
+export interface IStacRange {
+    minimum: number | string;
+    maximum: number | string;
+}
+export interface IStacExtent {
+    spatial: IStacSpacialExtent;
+    temporal: IStacTemporalExtent;
+}
+export interface IStacTemporalExtent {
+    interval: Array<[string | null, string | null]>;
+}
+export interface IStacSpacialExtent {
+    bbox: number[][];
+}
+export interface IStacProvider {
+    name: string;
+    description?: string;
+    roles?: ['licensor' | 'producer' | 'processor' | 'host'];
+    url?: string;
+}
+export interface IStacLink {
+    rel: string;
+    href: string;
+    type?: string;
+    title?: string;
+}
+export interface IStacAsset {
+    href: string;
+    title?: string;
+    description?: string;
+    type?: string;
+    roles?: string[];
+}
+export interface IStacItem {
+    type: 'Feature';
+    stac_version: string;
+    stac_extensions?: string[];
+    id: string;
+    geometry: {
+        type: 'Polygon';
+        coordinates: number[];
+    } | null;
+    bbox: [number, number, number, number] | null;
+    properties: {
+        title: string;
+        description: string;
+        datetime: null | string;
+        start_datetime: string;
+        end_datetime: string;
+        created: string;
+        updated: string;
+        platform: string;
+        instruments: string[];
+        constellation: string;
+        mission: string;
+        gsd: number;
+        [key: string]: any;
+    };
+    links: IStacLink[];
+    assets: Record<string, IStacAsset>;
+    collection: string;
+}
+export interface IStacSearchResult {
+    context: {
+        returned: number;
+        limit: number;
+        matched: number;
+    };
+    features: IStacItem[];
+    links: IStacLink[];
+    stac_extensions: string[];
+    stac_version: string;
+    type: 'FeatureCollection';
+}
+export interface IStacQueryBody {
+    bbox: [number, number, number, number];
+    limit?: number;
+    page?: number;
+    query: {
+        dataset: {
+            in: string[];
+        };
+        end_datetime: {
+            gte: string;
+        };
+        latest: {
+            eq: true;
+        };
+        platform?: {
+            in: string[];
+        };
+    };
+    sortBy: [
+        {
+            direction: 'desc';
+            field: 'start_datetime';
+        }
+    ];
+}
+export type StacFilterKey = 'collections' | 'datasets' | 'platforms' | 'products';
+export type StacFilterState = Record<StacFilterKey, Set<string>>;
+export type StacFilterStateStateDb = {
+    [K in keyof StacFilterState]: string[];
+};
+export type StacFilterSetters = Record<StacFilterKey, (val: Set<string>) => void>;

package/lib/stacBrowser/types/types.js

@@ -0,0 +1 @@
+export {};

package/lib/statusbar/StatusBar.d.ts

@@ -9,5 +9,5 @@ interface IStatusBarProps {
     };
     scale: number;
 }
-declare const StatusBar: ({ jgisModel, loading, projection, scale }: IStatusBarProps) => React.JSX.Element;
+declare const StatusBar: React.FC<IStatusBarProps>;
 export default StatusBar;

package/lib/statusbar/StatusBar.js

@@ -1,9 +1,9 @@
-import { faGlobe, faLocationDot, faRuler } from '@fortawesome/free-solid-svg-icons';
+import { faGlobe, faLocationDot, faRuler, } from '@fortawesome/free-solid-svg-icons';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { Progress } from '@jupyter/react-components';
 import React, { useEffect, useState } from 'react';
-import { version } from '../../package.json'; // Adjust the path as necessary
-const StatusBar = ({ jgisModel, loading, projection, scale }) => {
+import { version } from "../../package.json";
+const StatusBar = ({ jgisModel, loading, projection, scale, }) => {
     var _a;
     const [coords, setCoords] = useState({ x: 0, y: 0 });
     useEffect(() => {

package/lib/toolbar/index.d.ts

@@ -1,2 +1 @@
-export * from './usertoolbaritem';
 export * from './widget';

package/lib/toolbar/index.js

@@ -1,2 +1 @@
-export * from './usertoolbaritem';
 export * from './widget';

package/lib/toolbar/widget.d.ts

@@ -11,6 +11,7 @@ export declare class Separator extends Widget {
     constructor();
 }
 export declare class ToolbarWidget extends ReactiveToolbar {
+    private _model;
     constructor(options: ToolbarWidget.IOptions);
 }
 export declare namespace ToolbarWidget {