@jupytergis/base 0.15.0 → 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

@@ -10,12 +10,12 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import React, { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
-import { Combobox } from "../../../shared/components/Combobox";
-import { Input } from "../../../shared/components/Input";
-import { Select } from "../../../shared/components/Select";
 import QueryableRow from "./QueryableRow";
-import { debounce } from "../../../tools";
-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);

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.js

@@ -11,11 +11,11 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import { endOfToday, startOfToday } from 'date-fns';
 import { useCallback, useEffect, useRef, useState } from 'react';
-import useIsFirstRender from "../../shared/hooks/useIsFirstRender";
 import { useStacResultsContext } from "../context/StacResultsContext";
 import { useStacSearch } from "./useStacSearch";
-import { GlobalStateDbManager } from "../../store";
-import { fetchWithProxies } from "../../tools";
+import useIsFirstRender from "../../../shared/hooks/useIsFirstRender";
+import { GlobalStateDbManager } from "../../../shared/store";
+import { fetchWithProxies } from "../../../tools";
 const STAC_FILTER_EXTENSION_STATE_KEY = 'jupytergis:stac-filter-extension-state';
 const STAC_COLLECTIONS_CACHE_STATE_KEY = 'jupytergis:stac-collections-cache';
 const STAC_QUERYABLES_CACHE_STATE_KEY = 'jupytergis:stac-queryables-cache';

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

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-import { GlobalStateDbManager } from "../../store";
+import { GlobalStateDbManager } from "../../../shared/store";
 const STAC_SEARCH_STATE_KEY = 'jupytergis:stac-search-state';
 /**
  * Base hook for managing STAC search - handles temporal/spatial filters

package/lib/features/stac-browser/types/types.js

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

package/lib/{panelview/story-maps → features/story}/SpectaPanel.d.ts

@@ -1,6 +1,7 @@
 import { IJGISLayer, IJupyterGISModel } from '@jupytergis/schema';
 import React, { RefObject } from 'react';
 import type { IStoryViewerPanelHandle } from './StoryViewerPanel';
+import type { IListStorySegmentTransition } from './types/types';
 interface ISpectaPanelProps {
     model: IJupyterGISModel;
     isSpecta: boolean;
@@ -10,6 +11,8 @@ interface ISpectaPanelProps {
     storyViewerPanelRef: RefObject<IStoryViewerPanelHandle>;
     addLayer?: (id: string, layer: IJGISLayer, index: number) => Promise<void>;
     removeLayer?: (id: string) => void;
+    /** List stories: segment handoff state for the map stage overlay. */
+    onSegmentTransitionChange?: (payload: IListStorySegmentTransition | null) => void;
 }
-export declare function SpectaPanel({ model, isSpecta, isMobile, onSegmentTransitionEnd, containerRef, storyViewerPanelRef, addLayer, removeLayer, }: ISpectaPanelProps): React.JSX.Element;
+export declare function SpectaPanel({ model, isSpecta, isMobile, onSegmentTransitionEnd, containerRef, storyViewerPanelRef, addLayer, removeLayer, onSegmentTransitionChange, }: ISpectaPanelProps): React.JSX.Element;
 export {};

package/lib/{panelview/story-maps → features/story}/SpectaPanel.js

@@ -2,7 +2,7 @@ import React, { useEffect, useRef } from 'react';
 import { SpectaDesktopView } from './components/SpectaDesktopView';
 import { SpectaMobileView } from './components/SpectaMobileView';
 import { useStoryMap } from './hooks/useStoryMap';
-export function SpectaPanel({ model, isSpecta, isMobile, onSegmentTransitionEnd, containerRef, storyViewerPanelRef, addLayer, removeLayer, }) {
+export function SpectaPanel({ model, isSpecta, isMobile, onSegmentTransitionEnd, containerRef, storyViewerPanelRef, addLayer, removeLayer, onSegmentTransitionChange, }) {
     const overrideLayerEntriesRef = useRef([]);
     const segmentContainerRef = useRef(null);
     const { storyData, currentIndex, setIndex, handlePrev, handleNext, hasPrev, hasNext, activeSlide, layerName, showGradient, } = useStoryMap({
@@ -10,7 +10,6 @@ export function SpectaPanel({ model, isSpecta, isMobile, onSegmentTransitionEnd,
         overrideLayerEntriesRef,
         removeLayer,
         addLayer,
-        panelRef: isMobile ? undefined : containerRef,
         isSpecta,
     });
     // Notify when segment transition animation ends
@@ -29,7 +28,7 @@ export function SpectaPanel({ model, isSpecta, isMobile, onSegmentTransitionEnd,
         return () => el.removeEventListener('animationend', handleAnimationEnd);
     }, [currentIndex, onSegmentTransitionEnd]);
     if (isMobile) {
-        return (React.createElement(SpectaMobileView, { model: model, segmentContainerRef: segmentContainerRef, storyData: storyData, currentIndex: currentIndex, activeSlide: activeSlide, layerName: layerName, handlePrev: handlePrev, handleNext: handleNext, hasPrev: hasPrev, hasNext: hasNext, setIndex: setIndex }));
+        return (React.createElement(SpectaMobileView, { segmentContainerRef: segmentContainerRef, storyData: storyData, currentIndex: currentIndex, activeSlide: activeSlide, layerName: layerName, handlePrev: handlePrev, handleNext: handleNext, hasPrev: hasPrev, hasNext: hasNext }));
     }
-    return (React.createElement(SpectaDesktopView, { model: model, isSpecta: isSpecta, containerRef: containerRef, storyViewerPanelRef: storyViewerPanelRef, segmentContainerRef: segmentContainerRef, storyData: storyData, currentIndex: currentIndex, activeSlide: activeSlide, layerName: layerName, handlePrev: handlePrev, handleNext: handleNext, hasPrev: hasPrev, hasNext: hasNext, showGradient: showGradient, setIndex: setIndex }));
+    return (React.createElement(SpectaDesktopView, { model: model, isSpecta: isSpecta, containerRef: containerRef, storyViewerPanelRef: storyViewerPanelRef, segmentContainerRef: segmentContainerRef, storyData: storyData, currentIndex: currentIndex, activeSlide: activeSlide, layerName: layerName, handlePrev: handlePrev, handleNext: handleNext, hasPrev: hasPrev, hasNext: hasNext, showGradient: showGradient, setIndex: setIndex, onSegmentTransitionChange: onSegmentTransitionChange }));
 }

package/lib/{panelview/story-maps → features/story}/StoryEditorPanel.js

@@ -3,8 +3,8 @@ import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import jgisSchema from '@jupytergis/schema/lib/schema/project/jgis.json';
 import React, { useMemo } from 'react';
 import { CommandIDs } from "../../constants";
-import { StoryEditorPropertiesForm } from "../../formbuilder/objectform/StoryEditorForm";
 import { Button } from "../../shared/components/Button";
+import { StoryEditorPropertiesForm } from "../../shared/formbuilder/objectform/StoryEditorForm";
 import { deepCopy } from "../../tools";
 const storyMapSchema = deepCopy(jgisSchema.definitions.jGISStoryMap);
 const AddStorySegmentButton = ({ model, commands }) => (React.createElement("div", { style: { display: 'flex', justifyContent: 'center' } },

package/lib/{panelview/story-maps → features/story}/StoryViewerPanel.d.ts

@@ -1,8 +1,13 @@
-import { IJGISStoryMap, IJupyterGISModel, IStorySegmentLayer } from '@jupytergis/schema';
+import { IJGISStoryMap, IStorySegmentLayer } from '@jupytergis/schema';
 import React, { RefObject } from 'react';
+export interface IStoryViewerPanelSegmentNav {
+    handlePrev: () => void;
+    handleNext: () => void;
+    hasPrev: boolean;
+    hasNext: boolean;
+}
 /** Props: story state and callbacks come from useStoryMap in parent (SpectaPanel or SpectaMobileView). */
 interface IStoryViewerPanelProps {
-    model: IJupyterGISModel;
     isSpecta: boolean;
     isMobile?: boolean;
     /** Ref for the segment container (SpectaPanel uses it for animationend). */
@@ -11,11 +16,10 @@ interface IStoryViewerPanelProps {
     currentIndex: number;
     activeSlide: IStorySegmentLayer['parameters'] | undefined;
     layerName: string;
-    handlePrev: () => void;
-    handleNext: () => void;
-    hasPrev: boolean;
-    hasNext: boolean;
-    setIndex: (index: number) => void;
+    /** Omit for list-story overlay; required when segment nav is shown. */
+    segmentNav?: IStoryViewerPanelSegmentNav;
+    /** Disable fade animation for list stories. */
+    disableSegmentAnimation?: boolean;
 }
 export interface IStoryViewerPanelHandle {
     handlePrev: () => void;
@@ -40,8 +44,5 @@ export type StoryNavPlacement = 'below-title' | 'over-image' | 'subtitle-specta'
  * Story viewer (presentational). Receives story state and callbacks from parent.
  * Desktop scroll/sentinel/imperative handle live in SpectaDesktopView.
  */
-declare function StoryViewerPanel({ model, isSpecta, isMobile, segmentContainerRef, storyData, currentIndex, activeSlide, layerName, handlePrev, handleNext, hasPrev, hasNext, setIndex, }: IStoryViewerPanelProps): React.JSX.Element;
-declare namespace StoryViewerPanel {
-    var displayName: string;
-}
+declare function StoryViewerPanel({ isSpecta, isMobile, segmentContainerRef, storyData, currentIndex, activeSlide, layerName, segmentNav, disableSegmentAnimation, }: IStoryViewerPanelProps): React.JSX.Element;
 export default StoryViewerPanel;