@jupytergis/base 0.14.1 → 0.16.0-alpha.0

package/lib/{processing → features/processing}/processingCommands.d.ts

@@ -1,6 +1,6 @@
 import { IDict, IJGISFormSchemaRegistry } from '@jupytergis/schema';
 import { JupyterFrontEnd } from '@jupyterlab/application';
 import { CommandRegistry } from '@lumino/commands';
-import { JupyterGISTracker } from '../types';
+import { JupyterGISTracker } from '../../types';
 export declare function replaceInSql(sql: string, keyToVal: IDict<string>, layerName: string): string;
 export declare function addProcessingCommands(app: JupyterFrontEnd, commands: CommandRegistry, tracker: JupyterGISTracker, trans: any, formSchemaRegistry: IJGISFormSchemaRegistry, processingSchemas: Record<string, any>): void;

package/lib/features/processing/processingCommands.js

@@ -0,0 +1,168 @@
+import { ProcessingMerge, ProcessingLogicType, } from '@jupytergis/schema';
+import { selectedLayerIsOfType, processLayer, rasterizeLayer, clipRasterByExtent, clipRasterByVector, clipVectorByMaskLayer, } from './index';
+export function replaceInSql(sql, keyToVal, layerName) {
+    const replaceTemplateString = (args) => args.template.replace(RegExp(`{${args.variableName}}`, 'g'), args.value);
+    let out = replaceTemplateString({
+        variableName: 'layerName',
+        template: sql,
+        value: layerName,
+    });
+    for (const [key, value] of Object.entries(keyToVal)) {
+        out = replaceTemplateString({
+            variableName: key,
+            template: out,
+            value: value,
+        });
+    }
+    return out;
+}
+export function addProcessingCommands(app, commands, tracker, trans, formSchemaRegistry, processingSchemas) {
+    for (const processingElement of ProcessingMerge) {
+        const schemaKey = Object.keys(processingSchemas).find(k => k.toLowerCase() === processingElement.description.toLowerCase() ||
+            k.toLowerCase() === processingElement.name.toLowerCase());
+        if (!schemaKey) {
+            continue;
+        }
+        if (processingElement.type === ProcessingLogicType.vector) {
+            commands.addCommand(`jupytergis:${processingElement.name}`, {
+                label: trans.__(processingElement.label),
+                describedBy: {
+                    args: {
+                        type: 'object',
+                        properties: {
+                            filePath: {
+                                type: 'string',
+                                description: 'Path to the .jGIS file',
+                            },
+                            layerId: {
+                                type: 'string',
+                                description: 'Layer ID to process',
+                            },
+                            params: processingSchemas[schemaKey],
+                        },
+                    },
+                },
+                isEnabled: () => selectedLayerIsOfType(['VectorLayer'], tracker),
+                execute: async (args) => {
+                    await processLayer(tracker, formSchemaRegistry, processingElement.description, {
+                        sqlQueryFn: (layerName, keyToVal) => replaceInSql(processingElement.operations.sql, keyToVal, layerName),
+                        gdalFunction: processingElement.operations.gdalFunction,
+                        options: (sqlQuery) => [
+                            '-f',
+                            'GeoJSON',
+                            '-dialect',
+                            'SQLITE',
+                            '-sql',
+                            sqlQuery,
+                            '{outputName}',
+                        ],
+                    }, app, args === null || args === void 0 ? void 0 : args.filePath, args === null || args === void 0 ? void 0 : args.processingInputs);
+                },
+            });
+        }
+        else if (processingElement.type === ProcessingLogicType.raster) {
+            commands.addCommand(`jupytergis:${processingElement.name}`, {
+                label: trans.__(processingElement.label),
+                describedBy: {
+                    args: {
+                        type: 'object',
+                        properties: {
+                            filePath: {
+                                type: 'string',
+                                description: 'Path to the .jGIS file',
+                            },
+                            layerId: {
+                                type: 'string',
+                                description: 'Layer ID to process',
+                            },
+                            params: processingSchemas[schemaKey],
+                        },
+                    },
+                },
+                isEnabled: () => selectedLayerIsOfType(['VectorLayer'], tracker),
+                execute: async (args) => {
+                    await rasterizeLayer(tracker, formSchemaRegistry, processingElement.description, processingElement.operations.gdalFunction, app, args === null || args === void 0 ? void 0 : args.filePath, args === null || args === void 0 ? void 0 : args.processingInputs);
+                },
+            });
+        }
+        else if (processingElement.type === ProcessingLogicType.rasterClip) {
+            commands.addCommand(`jupytergis:${processingElement.name}`, {
+                label: trans.__(processingElement.label),
+                describedBy: {
+                    args: {
+                        type: 'object',
+                        properties: {
+                            filePath: {
+                                type: 'string',
+                                description: 'Path to the .jGIS file',
+                            },
+                            layerId: {
+                                type: 'string',
+                                description: 'Layer ID to process',
+                            },
+                            params: processingSchemas[schemaKey],
+                        },
+                    },
+                },
+                isEnabled: () => selectedLayerIsOfType(['GeoTiffLayer'], tracker),
+                execute: async (args) => {
+                    await clipRasterByExtent(tracker, formSchemaRegistry, app, args === null || args === void 0 ? void 0 : args.filePath, args === null || args === void 0 ? void 0 : args.processingInputs);
+                },
+            });
+        }
+        else if (processingElement.type === ProcessingLogicType.rasterClipVector) {
+            commands.addCommand(`jupytergis:${processingElement.name}`, {
+                label: trans.__(processingElement.label),
+                describedBy: {
+                    args: {
+                        type: 'object',
+                        properties: {
+                            filePath: {
+                                type: 'string',
+                                description: 'Path to the .jGIS file',
+                            },
+                            layerId: {
+                                type: 'string',
+                                description: 'Layer ID to process',
+                            },
+                            params: processingSchemas[schemaKey],
+                        },
+                    },
+                },
+                isEnabled: () => selectedLayerIsOfType(['GeoTiffLayer'], tracker),
+                execute: async (args) => {
+                    await clipRasterByVector(tracker, formSchemaRegistry, app, args === null || args === void 0 ? void 0 : args.filePath, args === null || args === void 0 ? void 0 : args.processingInputs);
+                },
+            });
+        }
+        else if (processingElement.type === ProcessingLogicType.clip) {
+            commands.addCommand(`jupytergis:${processingElement.name}`, {
+                label: trans.__(processingElement.label),
+                describedBy: {
+                    args: {
+                        type: 'object',
+                        properties: {
+                            filePath: {
+                                type: 'string',
+                                description: 'Path to the .jGIS file',
+                            },
+                            layerId: {
+                                type: 'string',
+                                description: 'Layer ID to process',
+                            },
+                            params: processingSchemas[schemaKey],
+                        },
+                    },
+                },
+                isEnabled: () => selectedLayerIsOfType(['VectorLayer'], tracker),
+                execute: async (args) => {
+                    await clipVectorByMaskLayer(tracker, formSchemaRegistry, app, args === null || args === void 0 ? void 0 : args.filePath, args === null || args === void 0 ? void 0 : args.processingInputs);
+                },
+            });
+        }
+        else {
+            console.error('Unsupported process type');
+            return;
+        }
+    }
+}

package/lib/features/processing/serverProcessing.d.ts

@@ -0,0 +1,51 @@
+export declare function isServerProcessingEnabled(): boolean;
+export declare function getServerProcessingToggle(): boolean;
+export declare function setServerProcessingEnabled(enabled: boolean): void;
+/**
+ * Check if the server-side GDAL endpoint is available.
+ * Caches the result after the first successful check.
+ */
+export declare function checkServerAvailability(): Promise<boolean>;
+/**
+ * Reset the cached availability (e.g. after environment change).
+ */
+export declare function resetServerAvailabilityCache(): void;
+export interface IServerProcessingRequest {
+    operation: string;
+    options: string[];
+    geojson: string;
+    outputName: string;
+}
+export interface IServerProcessingUrlRequest {
+    operation: string;
+    options: string[];
+    url: string;
+    outputName: string;
+}
+export interface IServerProcessingUrlWithCutlineRequest {
+    operation: string;
+    options: string[];
+    url: string;
+    cutlineGeojson: string;
+    outputName: string;
+}
+export interface IServerProcessingResponse {
+    result: string;
+    format: 'text' | 'base64';
+}
+/**
+ * Send a processing request to the server-side GDAL handler.
+ */
+export declare function runServerProcessing(request: IServerProcessingRequest): Promise<IServerProcessingResponse>;
+/**
+ * Send a URL-based processing request — the server uses /vsicurl/ so GDAL
+ * issues HTTP range requests instead of downloading the full file.
+ * Ideal for Cloud-Optimized GeoTIFFs (COGs).
+ */
+export declare function runServerProcessingUrl(request: IServerProcessingUrlRequest): Promise<IServerProcessingResponse>;
+/**
+ * Run a GDAL operation that needs both a remote raster URL and a vector
+ * cutline (e.g. `gdalwarp -cutline`). The server writes the cutline GeoJSON
+ * to a temp file and substitutes `{cutlinePath}` in the options list.
+ */
+export declare function runServerProcessingUrlWithCutline(request: IServerProcessingUrlWithCutlineRequest): Promise<IServerProcessingResponse>;

package/lib/features/processing/serverProcessing.js

@@ -0,0 +1,99 @@
+import { ServerConnection } from '@jupyterlab/services';
+const PROCESSING_ENDPOINT = '/jupytergis_core/processing';
+/**
+ * Module-level state for server-side processing toggle.
+ */
+let _serverProcessingEnabled = false;
+let _serverAvailable = null;
+export function isServerProcessingEnabled() {
+    return _serverProcessingEnabled && _serverAvailable === true;
+}
+export function getServerProcessingToggle() {
+    return _serverProcessingEnabled;
+}
+export function setServerProcessingEnabled(enabled) {
+    _serverProcessingEnabled = enabled;
+}
+/**
+ * Check if the server-side GDAL endpoint is available.
+ * Caches the result after the first successful check.
+ */
+export async function checkServerAvailability() {
+    if (_serverAvailable !== null) {
+        return _serverAvailable;
+    }
+    try {
+        const settings = ServerConnection.makeSettings();
+        const url = `${settings.baseUrl}${PROCESSING_ENDPOINT.slice(1)}`;
+        const response = await ServerConnection.makeRequest(url, {}, settings);
+        if (response.ok) {
+            const data = await response.json();
+            _serverAvailable = data.available === true;
+        }
+        else {
+            _serverAvailable = false;
+        }
+    }
+    catch (_a) {
+        _serverAvailable = false;
+    }
+    return _serverAvailable;
+}
+/**
+ * Reset the cached availability (e.g. after environment change).
+ */
+export function resetServerAvailabilityCache() {
+    _serverAvailable = null;
+}
+/**
+ * Send a processing request to the server-side GDAL handler.
+ */
+export async function runServerProcessing(request) {
+    const settings = ServerConnection.makeSettings();
+    const url = `${settings.baseUrl}${PROCESSING_ENDPOINT.slice(1)}`;
+    const response = await ServerConnection.makeRequest(url, {
+        method: 'POST',
+        body: JSON.stringify(request),
+    }, settings);
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || `Server processing failed: ${response.status}`);
+    }
+    return await response.json();
+}
+/**
+ * Send a URL-based processing request — the server uses /vsicurl/ so GDAL
+ * issues HTTP range requests instead of downloading the full file.
+ * Ideal for Cloud-Optimized GeoTIFFs (COGs).
+ */
+export async function runServerProcessingUrl(request) {
+    const settings = ServerConnection.makeSettings();
+    const endpoint = `${settings.baseUrl}${PROCESSING_ENDPOINT.slice(1)}`;
+    const response = await ServerConnection.makeRequest(endpoint, {
+        method: 'POST',
+        body: JSON.stringify(request),
+    }, settings);
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || `Server processing failed: ${response.status}`);
+    }
+    return await response.json();
+}
+/**
+ * Run a GDAL operation that needs both a remote raster URL and a vector
+ * cutline (e.g. `gdalwarp -cutline`). The server writes the cutline GeoJSON
+ * to a temp file and substitutes `{cutlinePath}` in the options list.
+ */
+export async function runServerProcessingUrlWithCutline(request) {
+    const settings = ServerConnection.makeSettings();
+    const endpoint = `${settings.baseUrl}${PROCESSING_ENDPOINT.slice(1)}`;
+    const response = await ServerConnection.makeRequest(endpoint, {
+        method: 'POST',
+        body: JSON.stringify(request),
+    }, settings);
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || `Server processing failed: ${response.status}`);
+    }
+    return await response.json();
+}

package/lib/{stacBrowser → features/stac-browser}/components/StacPanel.js

@@ -1,10 +1,10 @@
 import React from 'react';
-import { Select } from "../../shared/components/Select";
-import { Tabs, TabsContent, TabsList, TabsTrigger, } from "../../shared/components/Tabs";
 import StacFilterExtensionPanel from "./filter-extension/StacFilterExtensionPanel";
 import StacGeodesFilterPanel from "./geodes/StacGeodesFilterPanel";
 import StacPanelResults from "./shared/StacPanelResults";
 import { StacResultsProvider, useStacResultsContext, } from "../context/StacResultsContext";
+import { Select } from "../../../shared/components/Select";
+import { Tabs, TabsContent, TabsList, TabsTrigger, } from "../../../shared/components/Tabs";
 const GEODES_URL = 'https://geodes-portal.cnes.fr/api/stac/';
 const COPERNICUS_URL = 'https://stac.dataspace.copernicus.eu/v1/';
 const WORLDPOP_URL = 'https://api.stac.worldpop.org/';

package/lib/{stacBrowser → features/stac-browser}/components/filter-extension/QueryableComboBox.js

@@ -1,10 +1,55 @@
-import React, { useMemo } from 'react';
-import { Combobox } from "../../../shared/components/Combobox";
-import { Input } from "../../../shared/components/Input";
-import { Select } from "../../../shared/components/Select";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
 import QueryableRow from "./QueryableRow";
-import SingleDatePicker from '../../../shared/components/SingleDatePicker';
+import { Combobox } from "../../../../shared/components/Combobox";
+import { Input } from "../../../../shared/components/Input";
+import { Select } from "../../../../shared/components/Select";
+import { debounce } from "../../../../tools";
+import SingleDatePicker from '../../../../shared/components/SingleDatePicker';
 export function QueryableComboBox({ queryables, selectedQueryables, updateSelectedQueryables, }) {
+    const [draftValues, setDraftValues] = useState({});
+    const selectedQueryablesRef = useRef(selectedQueryables);
+    const debouncedCommitByKeyRef = useRef({});
+    useEffect(() => {
+        selectedQueryablesRef.current = selectedQueryables;
+    }, [selectedQueryables]);
+    const normalizeInputValue = useCallback((schema, value) => {
+        let valueToStore = value;
+        if (schema.type === 'string' &&
+            schema.format === 'date-time' &&
+            typeof value === 'string') {
+            try {
+                const localDate = new Date(value);
+                valueToStore = localDate.toISOString();
+            }
+            catch (_a) {
+                valueToStore = value;
+            }
+        }
+        return valueToStore;
+    }, []);
+    const scheduleQueryableCommit = useCallback((key, value) => {
+        if (!debouncedCommitByKeyRef.current[key]) {
+            debouncedCommitByKeyRef.current[key] = debounce((nextValue) => {
+                const latestFilter = selectedQueryablesRef.current[key];
+                if (!latestFilter) {
+                    return;
+                }
+                updateSelectedQueryables(key, Object.assign(Object.assign({}, latestFilter), { inputValue: nextValue }));
+            }, 500);
+        }
+        debouncedCommitByKeyRef.current[key](value);
+    }, [updateSelectedQueryables]);
     // Derive selected items from selectedQueryables
     const selectedItems = useMemo(() => {
         return queryables.filter(([key]) => key in selectedQueryables);
@@ -14,6 +59,11 @@ export function QueryableComboBox({ queryables, selectedQueryables, updateSelect
         const isCurrentlySelected = key in selectedQueryables;
         if (isCurrentlySelected) {
             // Remove if already selected - pass null to explicitly remove
+            delete debouncedCommitByKeyRef.current[key];
+            setDraftValues(prev => {
+                const _a = prev, _b = key, _ = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                return rest;
+            });
             updateSelectedQueryables(key, null);
         }
         else {
@@ -152,26 +202,19 @@ export function QueryableComboBox({ queryables, selectedQueryables, updateSelect
                 operator: ((_b = operators[0]) === null || _b === void 0 ? void 0 : _b.value) || '=',
                 inputValue: undefined,
             };
+            const inputValue = draftValues[key] !== undefined
+                ? draftValues[key]
+                : currentFilter.inputValue;
             const handleInputChange = (value) => {
-                // For datetime values, convert local time to UTC ISO string
-                let valueToStore = value;
-                if (val.type === 'string' &&
-                    val.format === 'date-time' &&
-                    typeof value === 'string') {
-                    try {
-                        // Parse local time and convert to UTC ISO string
-                        const localDate = new Date(value);
-                        valueToStore = localDate.toISOString();
-                    }
-                    catch (_a) {
-                        valueToStore = value;
-                    }
-                }
-                updateSelectedQueryables(key, Object.assign(Object.assign({}, currentFilter), { inputValue: valueToStore }));
+                const normalizedValue = normalizeInputValue(val, value);
+                setDraftValues(prev => (Object.assign(Object.assign({}, prev), { [key]: normalizedValue })));
+                // Uses a stable per-field debounced function
+                // inline debounce would recreate each render and reset its timer
+                scheduleQueryableCommit(key, normalizedValue);
             };
             const handleOperatorChange = (operator) => {
                 updateSelectedQueryables(key, Object.assign(Object.assign({}, currentFilter), { operator }));
             };
-            return (React.createElement(QueryableRow, { key: key, qKey: key, qVal: val, operators: operators, currentFilter: currentFilter, inputComponent: getInputBasedOnType(val, currentFilter.inputValue, handleInputChange), onOperatorChange: handleOperatorChange }));
+            return (React.createElement(QueryableRow, { key: key, qKey: key, qVal: val, operators: operators, currentFilter: currentFilter, inputComponent: getInputBasedOnType(val, inputValue, handleInputChange), onOperatorChange: handleOperatorChange }));
         }))));
 }

package/lib/{stacBrowser → features/stac-browser}/components/filter-extension/QueryableRow.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { Select } from "../../../shared/components/Select";
+import { Select } from "../../../../shared/components/Select";
 function QueryableRow({ qKey, qVal, operators, currentFilter, inputComponent, onOperatorChange, }) {
     const currentOperator = operators.find(op => op.value === currentFilter.operator);
     const buttonText = (currentOperator === null || currentOperator === void 0 ? void 0 : currentOperator.label) || 'Select operator...';

package/lib/{stacBrowser → features/stac-browser}/components/filter-extension/StacFilterExtensionPanel.js

@@ -1,11 +1,11 @@
 import React, { useState } from 'react';
-import { Input } from "../../../shared/components/Input";
-import { Select } from "../../../shared/components/Select";
 import StacQueryableFilters from "./StacQueryableFilters";
 import StacSpatialExtent from "../shared/StacSpatialExtent";
 import StacTemporalExtent from "../shared/StacTemporalExtent";
 import { useStacResultsContext } from "../../context/StacResultsContext";
 import { useStacFilterExtension } from "../../hooks/useStacFilterExtension";
+import { Input } from "../../../../shared/components/Input";
+import { Select } from "../../../../shared/components/Select";
 function StacFilterExtensionPanel({ model }) {
     var _a;
     const { selectedUrl } = useStacResultsContext();

package/lib/{stacBrowser → features/stac-browser}/components/filter-extension/StacQueryableFilters.js

@@ -1,6 +1,6 @@
 import React from 'react';
-import { RadioGroup, RadioGroupItem } from "../../../shared/components/RadioGroup";
 import { QueryableComboBox } from "./QueryableComboBox";
+import { RadioGroup, RadioGroupItem } from "../../../../shared/components/RadioGroup";
 const StacQueryableFilters = ({ queryableFields, selectedQueryables, updateSelectedQueryables, filterOperator, setFilterOperator, }) => {
     return (React.createElement("div", { className: "jgis-stac-queryable-filters" },
         React.createElement(RadioGroup, { className: "jgis-stac-queryable-filters-radio-group", value: filterOperator, onValueChange: (value) => {

package/lib/{stacBrowser → features/stac-browser}/components/geodes/StacFilterSection.js

@@ -2,9 +2,9 @@ import { faXmark } from '@fortawesome/free-solid-svg-icons';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { ChevronRight } from 'lucide-react';
 import React, { useMemo } from 'react';
-import Badge from "../../../shared/components/Badge";
-import { Button } from "../../../shared/components/Button";
-import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, } from "../../../shared/components/DropdownMenu";
+import Badge from "../../../../shared/components/Badge";
+import { Button } from "../../../../shared/components/Button";
+import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, } from "../../../../shared/components/DropdownMenu";
 const StacFilterSection = ({ section, data, selectedCollections, selectedData, handleCheckedChange, }) => {
     const items = useMemo(() => {
         if (section === 'Collection') {

package/lib/{stacBrowser → features/stac-browser}/components/shared/StacPanelResults.js

@@ -1,8 +1,8 @@
 import React from 'react';
-import { Button } from "../../../shared/components/Button";
-import { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, } from "../../../shared/components/Pagination";
-import { LoadingIcon } from "../../../shared/components/loading";
 import { useStacResultsContext } from "../../context/StacResultsContext";
+import { Button } from "../../../../shared/components/Button";
+import { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, } from "../../../../shared/components/Pagination";
+import { LoadingIcon } from "../../../../shared/components/loading";
 function getPageItems(currentPage, totalPages) {
     if (totalPages <= 5) {
         return Array.from({ length: totalPages }, (_, i) => i + 1);

package/lib/{stacBrowser → features/stac-browser}/components/shared/StacSpatialExtent.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import Checkbox from "../../../shared/components/Checkbox";
+import Checkbox from "../../../../shared/components/Checkbox";
 const StacSpatialExtent = ({ checked, onCheckedChange, label, }) => {
     return (React.createElement(React.Fragment, null,
         React.createElement("label", { className: "jgis-stac-filter-extension-label" }, "Spatial Extent"),

package/lib/{stacBrowser → features/stac-browser}/components/shared/StacTemporalExtent.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import SingleDatePicker from '../../../shared/components/SingleDatePicker';
+import SingleDatePicker from '../../../../shared/components/SingleDatePicker';
 function StacTemporalExtent({ startTime, endTime, setStartTime, setEndTime, }) {
     return (React.createElement("div", { className: "jgis-stac-filter-extension-section" },
         React.createElement("label", { className: "jgis-stac-filter-extension-label" }, "Temporal Extent"),

package/lib/{stacBrowser → features/stac-browser}/context/StacResultsContext.js

@@ -1,7 +1,7 @@
 import { UUID } from '@lumino/coreutils';
 import React, { createContext, useContext, useState, useCallback, useRef, useEffect, } from 'react';
-import { GlobalStateDbManager } from "../../store";
-import { fetchWithProxies } from "../../tools";
+import { GlobalStateDbManager } from "../../../shared/store";
+import { fetchWithProxies } from "../../../tools";
 const StacResultsContext = createContext(undefined);
 const STAC_SELECTED_URL_STATE_KEY = 'jupytergis:stac-selected-url';
 export function StacResultsProvider({ children, model, }) {

package/lib/{stacBrowser → features/stac-browser}/hooks/useGeodesSearch.js

@@ -1,10 +1,10 @@
 import { startOfYesterday } from 'date-fns';
 import { useCallback, useEffect, useState } from 'react';
-import useIsFirstRender from "../../shared/hooks/useIsFirstRender";
 import { products } from "../constants";
 import { useStacResultsContext } from "../context/StacResultsContext";
 import { useStacSearch } from "./useStacSearch";
-import { GlobalStateDbManager } from "../../store";
+import useIsFirstRender from "../../../shared/hooks/useIsFirstRender";
+import { GlobalStateDbManager } from "../../../shared/store";
 const GEODES_STAC_FILTERS_KEY = 'jupytergis:geodes-stac-filters';
 /**
  * Custom hook for managing GEODES-specific STAC search functionality

package/lib/{stacBrowser → features/stac-browser}/hooks/useStacFilterExtension.d.ts

@@ -14,7 +14,7 @@ export declare function useStacFilterExtension({ model, baseUrl, limit, }: IUseS
     queryableFields: IStacQueryables | undefined;
     collections: FilteredCollection[];
     selectedCollection: string;
-    setSelectedCollection: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setSelectedCollection: (nextSelectedCollection: string) => void;
     handleSubmit: () => Promise<void>;
     startTime: Date | undefined;
     endTime: Date | undefined;