@jupytergis/base 0.14.1 → 0.16.0-alpha.0

package/lib/mainview/TemporalSlider.js

@@ -4,7 +4,7 @@ import { Button, Slider } from '@jupyter/react-components';
 import { format, isValid, parse } from 'date-fns';
 import { daysInYear, millisecondsInDay, millisecondsInHour, millisecondsInMinute, millisecondsInSecond, millisecondsInWeek, minutesInMonth, } from 'date-fns/constants';
 import React, { useEffect, useRef, useState } from 'react';
-import { useGetProperties } from "../dialogs/symbology/hooks/useGetProperties";
+import { useGetProperties } from "../features/layers/symbology/hooks/useGetProperties";
 // List of common date formats to try
 // TODO: Not even close to every valid format
 const commonDateFormats = [
@@ -45,7 +45,7 @@ const TemporalSlider = ({ model, filterStates, }) => {
     const { featureProperties } = useGetProperties({ layerId, model });
     useEffect(() => {
         // This is for when the selected layer changes
-        const handleClientStateChanged = () => {
+        const handleSelectedChanged = () => {
             var _a, _b;
             if (!((_b = (_a = model.localState) === null || _a === void 0 ? void 0 : _a.selected) === null || _b === void 0 ? void 0 : _b.value)) {
                 return;
@@ -59,7 +59,7 @@ const TemporalSlider = ({ model, filterStates, }) => {
             }
         };
         // this is for when the layer itself changes
-        const handleLayerChange = (_, change) => {
+        const handleSharedLayersChanged = (_, change) => {
             var _a;
             // Get the changes for the selected layer
             const selectedLayer = (_a = change.layerChange) === null || _a === void 0 ? void 0 : _a.find(layer => layer.id === layerIdRef.current);
@@ -71,16 +71,18 @@ const TemporalSlider = ({ model, filterStates, }) => {
             // If layer was deleted (empty object) or the layer type changed, close the temporal controller
             if (Object.keys(newValue).length === 0 ||
                 newValue.type !== oldValue.type) {
-                model.toggleTemporalController();
+                if (model.isTemporalControllerActive) {
+                    model.toggleTemporalController();
+                }
             }
         };
         // Initial state
-        handleClientStateChanged();
-        model.clientStateChanged.connect(handleClientStateChanged);
-        model.sharedLayersChanged.connect(handleLayerChange);
+        handleSelectedChanged();
+        model.selectedChanged.connect(handleSelectedChanged);
+        model.sharedLayersChanged.connect(handleSharedLayersChanged);
         return () => {
-            model.clientStateChanged.disconnect(handleClientStateChanged);
-            model.sharedLayersChanged.disconnect(handleLayerChange);
+            model.selectedChanged.disconnect(handleSelectedChanged);
+            model.sharedLayersChanged.disconnect(handleSharedLayersChanged);
             removeFilter();
             if (intervalRef.current) {
                 clearInterval(intervalRef.current);

package/lib/mainview/geoJsonFeaturePatch.d.ts

@@ -0,0 +1,9 @@
+import { IDict, IJGISSource, IJupyterGISModel } from '@jupytergis/schema';
+export interface IPatchGeoJSONFeatureContext {
+    model: IJupyterGISModel;
+    persistAndRefreshSource: (sourceId: string, source: IJGISSource) => Promise<void>;
+}
+export type PatchGeoJSONFeatureProperties = (sourceId: string, target: {
+    featureId: string;
+}, propertyUpdates: IDict<any>) => Promise<boolean>;
+export declare function createGeoJSONFeaturePatcher(context: IPatchGeoJSONFeatureContext): PatchGeoJSONFeatureProperties;

package/lib/mainview/geoJsonFeaturePatch.js

@@ -0,0 +1,43 @@
+import { deepCopy } from "../tools";
+/**
+ * Only concerned with features added via draw tool for now
+ */
+async function patchGeoJSONFeatureProperties(context, sourceId, target, propertyUpdates) {
+    var _a;
+    if (!context.model.sharedModel.editable) {
+        return false;
+    }
+    const source = context.model.getSource(sourceId);
+    if (!source || source.type !== 'GeoJSONSource') {
+        return false;
+    }
+    const parameters = source.parameters;
+    const data = parameters.data;
+    if (!data || data.type !== 'FeatureCollection') {
+        return false;
+    }
+    const features = data.features;
+    const featureId = target.featureId;
+    const index = features.findIndex(feature => { var _a; return ((_a = feature.properties) === null || _a === void 0 ? void 0 : _a._id) === featureId; });
+    if (index < 0 || index >= features.length) {
+        return false;
+    }
+    const updatedSource = deepCopy(source);
+    const updatedParameters = updatedSource.parameters;
+    const updatedData = updatedParameters.data;
+    const updatedFeature = updatedData.features[index];
+    const nextProperties = Object.assign({}, ((_a = updatedFeature.properties) !== null && _a !== void 0 ? _a : {}));
+    Object.entries(propertyUpdates).forEach(([key, value]) => {
+        if (value === undefined) {
+            delete nextProperties[key];
+            return;
+        }
+        nextProperties[key] = value;
+    });
+    updatedFeature.properties = nextProperties;
+    await context.persistAndRefreshSource(sourceId, updatedSource);
+    return true;
+}
+export function createGeoJSONFeaturePatcher(context) {
+    return (sourceId, target, propertyUpdates) => patchGeoJSONFeatureProperties(context, sourceId, target, propertyUpdates);
+}

package/lib/mainview/mainView.d.ts

@@ -1,15 +1,19 @@
 import { IAnnotation, IAnnotationModel, IDict, IJGISFilterItem, IJGISFormSchemaRegistry, IJGISLayer, IJGISSource, IJupyterGISSettings } from '@jupytergis/schema';
+import type { ILoggerRegistry } from '@jupyterlab/logconsole';
 import { User } from '@jupyterlab/services';
 import { IStateDB } from '@jupyterlab/statedb';
 import { Layer } from 'ol/layer';
+import { Rule } from 'ol/style/flat';
 import * as React from 'react';
 import { ClientPointer } from './CollaboratorPointers';
 import { MainViewModel } from './mainviewmodel';
+import type { IListStorySegmentTransition } from '../features/story/types/types';
 interface IMainViewProps {
     viewModel: MainViewModel;
     state?: IStateDB;
     formSchemaRegistry?: IJGISFormSchemaRegistry;
     annotationModel?: IAnnotationModel;
+    loggerRegistry?: ILoggerRegistry;
     /** True when viewport matches (max-width: 768px). Injected by MainViewWithMediaQuery. */
     isMobile: boolean;
 }
@@ -33,16 +37,21 @@ interface IStates {
     }>;
     displayTemporalController: boolean;
     filterStates: IDict<IJGISFilterItem | undefined>;
+    editingVectorLayer: boolean;
+    drawGeometryLabel: string | undefined;
     jgisSettings: IJupyterGISSettings;
     isSpectaPresentation: boolean;
     initialLayersReady: boolean;
+    identifyFeatureFloatersVersion: number;
+    /** List story segment handoff for the map stage overlay; null when off. */
+    segmentTransition: IListStorySegmentTransition | null;
 }
 export declare class MainView extends React.Component<IMainViewProps, IStates> {
     constructor(props: IMainViewProps);
     componentDidMount(): Promise<void>;
     componentDidUpdate(prevProps: IMainViewProps, prevState: IStates): void;
     componentWillUnmount(): void;
-    generateMap(center: number[], zoom: number): Promise<void>;
+    generateMap(center: number[], zoom: number, projection?: string): Promise<void>;
     updateCenter: () => void;
     getViewBbox: (targetProjection?: string) => import("ol/extent").Extent;
     createSelectInteraction: () => void;
@@ -98,11 +107,7 @@ export declare class MainView extends React.Component<IMainViewProps, IStates> {
      * @param index - expected index of the layer.
      */
     addLayer(id: string, layer: IJGISLayer, index: number): Promise<void>;
-    vectorLayerStyleRuleBuilder: (layer: IJGISLayer) => {
-        style: import("ol/style/flat").FlatStyle | Array<import("ol/style/flat").FlatStyle>;
-        filter?: import("ol/expr/expression").EncodedExpression | undefined;
-        else?: boolean | undefined;
-    }[] | undefined;
+    vectorLayerStyleRuleBuilder: (layer: IJGISLayer) => Rule[];
     /**
      * Taken from https://openlayers.org/en/latest/examples/webgl-shaded-relief.html
      * @returns
@@ -123,6 +128,32 @@ export declare class MainView extends React.Component<IMainViewProps, IStates> {
     handleTemporalController: (id: string, layer: IJGISLayer) => void;
     private flyToGeometry;
     private highlightFeatureOnMap;
+    private _ensureHighlightLayer;
+    /**
+     * Replace the highlight layer contents with the given geometries.
+     * Clears the source first so that stale highlights are always removed,
+     * including when the selection becomes empty (geometries = []).
+     */
+    private _setHighlightGeometries;
+    /**
+     * Replace the highlight layer contents with pre-styled features.
+     * Each feature carries its own highlight style via feature.setStyle().
+     */
+    private _setHighlightFeatures;
+    private _buildHighlightStyle;
+    /**
+     * Compute extent for layer or source
+     */
+    private _computeExtent;
+    private _computeZoomFromExtent;
+    /**
+     * Track layer's extent and zoom in model's view state
+     */
+    private _trackLayerViewState;
+    /**
+     * Track source's extent and zoom in model's view state
+     */
+    private _trackSourceExtZoom;
     /**
      * Wait for all layers to be loaded.
      */
@@ -138,7 +169,20 @@ export declare class MainView extends React.Component<IMainViewProps, IStates> {
      * @param id - the id of the layer.
      */
     removeLayer(id: string): void;
-    private _onClientSharedStateChanged;
+    private _handleSelectedChanged;
+    private _syncVectorDrawingFromSelection;
+    /**
+     * Decide how selection changes should affect vector drawing state.
+     *
+     * This helper only computes whether
+     * draw mode must be disabled (non-draw layer selected) and whether draw
+     * interactions should be rebound (draw mode enabled and selected draw layer
+     * changed).
+     */
+    private _getVectorDrawingSelectionDecision;
+    private _handleTemporalControllerActiveChanged;
+    private _handleRemoteUserChanged;
+    private _handlePointerChanged;
     private _onSharedOptionsChanged;
     private _syncSettingsFromRegistry;
     private _onSettingsChanged;
@@ -175,6 +219,8 @@ export declare class MainView extends React.Component<IMainViewProps, IStates> {
     private _onLayerTreeChange;
     private _onSourcesChange;
     private _onSharedModelStateChange;
+    private _clearHighlightWhenIdentifyDisabled;
+    private _handleIdentifiedFeaturesChanged;
     /**
      * Handler for when story maps change in the model.
      * Updates specta state and presentation colors when story data becomes available.
@@ -186,9 +232,13 @@ export declare class MainView extends React.Component<IMainViewProps, IStates> {
     private _onSharedMetadataChanged;
     private _computeAnnotationPosition;
     private _updateAnnotation;
+    private _computeFeatureFloaterPosition;
+    private _getVisibleDrawIdentifiedFeatures;
+    private _updateFeatureFloaters;
     private _onZoomToPosition;
     private _moveToPosition;
     private _flyToPosition;
+    private _lastPointerCoord;
     private _onPointerMove;
     private _syncPointer;
     private _addMarker;
@@ -198,13 +248,33 @@ export declare class MainView extends React.Component<IMainViewProps, IStates> {
     private _handleGeolocationChanged;
     private _handleThemeChange;
     private _handleWindowResize;
+    private _handleSegmentTransitionChange;
     private _handleSpectaTouchStart;
     private _handleSpectaTouchEnd;
+    private _updateEditingVectorLayer;
+    private _handleDrawGeometryTypeChange;
+    private _getVectorSourceFromLayerID;
+    _getDrawSourceFromSelectedLayer: () => void;
+    _onVectorSourceChange: () => void;
+    _updateDrawSource: () => void;
+    _updateInteractions: () => void;
+    private _handleDrawEnd;
+    _editVectorLayer: () => void;
+    private _removeDrawInteraction;
+    private _removeSelectInteraction;
+    private _removeSnapInteraction;
+    private _removeModifyInteraction;
+    /**
+     * Shared source update wrapper for child components that need to mutate a
+     * source and refresh corresponding map layers.
+     */
+    persistAndRefreshSource: (id: string, source: IJGISSource) => Promise<void>;
     render(): JSX.Element;
     private _clickCoords;
     private _commands;
     private _isPositionInitialized;
     private divRef;
+    private mainViewRef;
     private controlsToolbarRef;
     private spectaContainerRef;
     private storyViewerPanelRef;
@@ -219,11 +289,26 @@ export declare class MainView extends React.Component<IMainViewProps, IStates> {
     private _contextMenu;
     private _loadingLayers;
     private _originalFeatures;
-    private _highlightLayer;
+    private _highlightLayerRef;
+    private _draw;
+    private _snap;
+    private _modify;
+    private _select;
+    private _currentDrawLayerID;
+    private _previousDrawLayerID;
+    private _currentDrawSource;
+    private _currentVectorSource;
+    private _currentDrawSourceID;
+    private _currentDrawGeometry;
     private _updateCenter;
     private _state?;
     private _formSchemaRegistry?;
     private _annotationModel?;
+    private _loggerRegistry?;
+    private _addLayerForPanels;
+    private _removeLayerForPanels;
+    private _patchGeoJSONFeatureProperties;
+    private _log;
     private _featurePropertyCache;
     private _isSpectaPresentationInitialized;
     private _storyScrollHandler;