@jupytergis/schema 0.14.1 → 0.16.0-alpha.0

package/lib/migrations/v0_5_to_v0_6.js

@@ -0,0 +1,154 @@
+/**
+ * Migration from schema version 0.5.0 to 0.6.0.
+ *
+ * Converts legacy representations to Grammar symbologyState in one pass:
+ *  - parameters.color (flat OL FlatStyle keys) → Grammar directly
+ *  - parameters.symbologyState with old render types → Grammar
+ *  - HeatmapLayer color array → symbologyState.gradient
+ *  - WebGlLayer type → GeoTiffLayer
+ *  - layer.filters → grammar layer-level when + whenOp (filters removed)
+ */
+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 { categorizedToGrammar, graduatedToGrammar, singleSymbolToGrammar, } from '../grammar/grammarConversions';
+export function migrate(doc) {
+    var _a, _b;
+    const layers = Object.assign({}, doc.layers);
+    for (const [id, layer] of Object.entries(layers)) {
+        const newType = layer.type === 'WebGlLayer' ? 'GeoTiffLayer' : layer.type;
+        const params = layer === null || layer === void 0 ? void 0 : layer.parameters;
+        if (!params) {
+            if (newType !== layer.type) {
+                layers[id] = Object.assign(Object.assign({}, layer), { type: newType });
+            }
+            continue;
+        }
+        const newParams = Object.assign({}, params);
+        if (layer.type === 'VectorLayer' || layer.type === 'VectorTileLayer') {
+            const color = newParams.color;
+            if (color && typeof color === 'object' && !Array.isArray(color)) {
+                // Flat OL color dict → Grammar (skip intermediate symbologyState format)
+                newParams.symbologyState = singleSymbolToGrammar(_colorToState(color));
+                delete newParams.color;
+            }
+            else {
+                // Handle files that already carry old-style symbologyState (defensive)
+                const state = newParams.symbologyState;
+                if ((state === null || state === void 0 ? void 0 : state.renderType) && state.renderType !== 'Grammar') {
+                    switch (state.renderType) {
+                        case 'Single Symbol':
+                            newParams.symbologyState = singleSymbolToGrammar(state);
+                            break;
+                        case 'Graduated':
+                            newParams.symbologyState = graduatedToGrammar(state);
+                            break;
+                        case 'Categorized':
+                            newParams.symbologyState = categorizedToGrammar(state);
+                            break;
+                    }
+                }
+            }
+        }
+        else if (layer.type === 'HeatmapLayer') {
+            if (Array.isArray(newParams.color)) {
+                const state = (_a = newParams.symbologyState) !== null && _a !== void 0 ? _a : { renderType: 'Heatmap' };
+                if (!state.gradient) {
+                    newParams.symbologyState = Object.assign(Object.assign({}, state), { gradient: newParams.color });
+                }
+                delete newParams.color;
+            }
+        }
+        // Convert legacy layer.filters → grammar layer-level when + whenOp.
+        const filters = layer.filters;
+        if ((_b = filters === null || filters === void 0 ? void 0 : filters.appliedFilters) === null || _b === void 0 ? void 0 : _b.length) {
+            const logicalOp = filters.logicalOp === 'any' ? 'any' : 'all';
+            const predicates = [];
+            for (const item of filters.appliedFilters) {
+                if (item.operator === 'between') {
+                    if (item.betweenMin !== undefined && item.betweenMax !== undefined) {
+                        predicates.push({
+                            type: 'between',
+                            field: item.feature,
+                            min: item.betweenMin,
+                            max: item.betweenMax,
+                        });
+                    }
+                }
+                else if (item.operator === '==') {
+                    predicates.push({
+                        type: 'fieldEquals',
+                        field: item.feature,
+                        value: item.value,
+                    });
+                }
+                else {
+                    predicates.push({
+                        type: 'fieldCompare',
+                        field: item.feature,
+                        op: item.operator,
+                        value: item.value,
+                    });
+                }
+            }
+            if (predicates.length) {
+                const symbologyState = newParams.symbologyState;
+                if (Array.isArray(symbologyState === null || symbologyState === void 0 ? void 0 : symbologyState.layers) &&
+                    symbologyState.layers.length > 0) {
+                    newParams.symbologyState = Object.assign(Object.assign({}, symbologyState), { layers: symbologyState.layers.map((gl) => {
+                            var _a, _b;
+                            return (Object.assign(Object.assign({}, gl), { when: [...((_a = gl.when) !== null && _a !== void 0 ? _a : []), ...predicates], whenOp: (_b = gl.whenOp) !== null && _b !== void 0 ? _b : logicalOp }));
+                        }) });
+                }
+            }
+        }
+        const _c = Object.assign(Object.assign({}, layer), { type: newType }), { filters: _ } = _c, layerWithoutFilters = __rest(_c, ["filters"]);
+        layers[id] = Object.assign(Object.assign({}, layerWithoutFilters), { parameters: newParams });
+    }
+    return Object.assign(Object.assign({}, doc), { layers });
+}
+/** Build a SymbologyState from a flat OL color dict. */
+function _colorToState(color) {
+    var _a;
+    const state = { renderType: 'Single Symbol' };
+    const fill = _firstSolidColor(color['fill-color'], color['circle-fill-color']);
+    if (fill) {
+        state.fillColor = fill;
+    }
+    const stroke = _firstSolidColor(color['stroke-color'], color['circle-stroke-color']);
+    if (stroke) {
+        state.strokeColor = stroke;
+    }
+    const sw = (_a = color['stroke-width']) !== null && _a !== void 0 ? _a : color['circle-stroke-width'];
+    if (typeof sw === 'number') {
+        state.strokeWidth = sw;
+    }
+    const r = color['circle-radius'];
+    if (typeof r === 'number') {
+        state.radius = r;
+    }
+    return state;
+}
+function _firstSolidColor(...candidates) {
+    for (const c of candidates) {
+        if (Array.isArray(c) && c.length >= 3 && typeof c[0] === 'number') {
+            const [r = 0, g = 0, b = 0, a = 1] = c;
+            return [r, g, b, a];
+        }
+        if (typeof c === 'string') {
+            const m = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(c);
+            if (m) {
+                return [parseInt(m[1], 16), parseInt(m[2], 16), parseInt(m[3], 16), 1];
+            }
+        }
+    }
+    return undefined;
+}

package/lib/model.d.ts

@@ -7,8 +7,8 @@ import { PartialJSONObject } from '@lumino/coreutils';
 import { ISignal, Signal } from '@lumino/signaling';
 import { FeatureLike } from 'ol/Feature';
 import { IJGISContent, IJGISLayer, IJGISLayerGroup, IJGISLayerTree, IJGISLayers, IJGISOptions, IJGISSource, IJGISSources, IJGISStoryMap } from './_interface/project/jgis';
-import { IAnnotationModel, IDict, IJGISLayerDocChange, IJGISLayerTreeDocChange, IJGISSourceDocChange, IJupyterGISClientState, IJupyterGISDoc, IJupyterGISModel, ISelection, IUserData, IViewPortState, JgisCoordinates, Pointer, IJupyterGISSettings, SelectionType } from './interfaces';
-import { Modes } from './types';
+import { IAwarenessFieldChange, IAnnotationModel, IIdentifiedFeatures, IJGISLayerDocChange, IJGISLayerTreeDocChange, IJGISSourceDocChange, IJGISUIState, IJupyterGISClientState, IJupyterGISDoc, IJupyterGISModel, ISelection, IStorySegmentRef, IUserData, IViewPortState, JgisCoordinates, Pointer, IJupyterGISSettings, SelectionType } from './interfaces';
+import { IViewState, Modes } from './types';
 export declare class JupyterGISModel implements IJupyterGISModel {
     constructor(options: JupyterGISModel.IOptions);
     /**
@@ -48,7 +48,12 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     get readOnly(): boolean;
     set readOnly(value: boolean);
     get localState(): IJupyterGISClientState | null;
-    get clientStateChanged(): ISignal<this, Map<number, IJupyterGISClientState>>;
+    get selectedChanged(): ISignal<this, IAwarenessFieldChange<IJupyterGISClientState['selected']>>;
+    get pointerChanged(): ISignal<this, IAwarenessFieldChange<IJupyterGISClientState['pointer']>>;
+    get viewportStateChanged(): ISignal<this, IAwarenessFieldChange<IJupyterGISClientState['viewportState']>>;
+    get identifiedFeaturesChanged(): ISignal<this, IAwarenessFieldChange<IJupyterGISClientState['identifiedFeatures']>>;
+    get remoteUserChanged(): ISignal<this, IAwarenessFieldChange<IJupyterGISClientState['remoteUser']>>;
+    get temporalControllerActiveChanged(): ISignal<this, IAwarenessFieldChange<IJupyterGISClientState['isTemporalControllerActive']>>;
     get sharedOptionsChanged(): ISignal<IJupyterGISDoc, MapChange>;
     get sharedLayersChanged(): ISignal<IJupyterGISDoc, IJGISLayerDocChange>;
     get sharedLayerTreeChanged(): ISignal<IJupyterGISDoc, IJGISLayerTreeDocChange>;
@@ -72,7 +77,9 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     readonly flyToGeometrySignal: Signal<this, any>;
     readonly highlightFeatureSignal: Signal<this, any>;
     readonly updateBboxSignal: Signal<this, any>;
+    readonly editingVectorLayerChanged: Signal<this, boolean>;
     getContent(): IJGISContent;
+    getViewState(): IViewState;
     /**
      * Getter for the contents manager.
      */
@@ -94,6 +101,7 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     getSources(): IJGISSources;
     getLayerTree(): IJGISLayerTree;
     getLayer(id: string): IJGISLayer | undefined;
+    getExtent(id: string): number[] | undefined;
     getLayerOrSource(id: string): IJGISLayer | IJGISSource | undefined;
     getSource(id: string): IJGISSource | undefined;
     /**
@@ -124,6 +132,10 @@ export declare class JupyterGISModel implements IJupyterGISModel {
      *   from root of layer tree.
      */
     addLayer(id: string, layer: IJGISLayer, groupName?: string, position?: number): void;
+    /**
+     * Update layer's extent and zoom in model's view state
+     */
+    updateLayerViewState(id: string, view: IViewState[string]): void;
     removeLayer(layer_id: string): void;
     removeSource(sourceId: string): void;
     setOptions(value: IJGISOptions): void;
@@ -133,13 +145,14 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     syncSelected(value: {
         [key: string]: ISelection;
     }, emitter?: string): void;
+    syncLastAddedLayer(layerId: string): void;
     get selected(): {
         [key: string]: ISelection;
     } | undefined;
     set selected(value: {
         [key: string]: ISelection;
     } | undefined);
-    syncIdentifiedFeatures(features: IDict<any>, emitter?: string): void;
+    syncIdentifiedFeatures(features: IIdentifiedFeatures, emitter?: string): void;
     setUserToFollow(userId?: number): void;
     setEditingItem(type: SelectionType, itemId: string): void;
     clearEditingItem(): void;
@@ -180,14 +193,17 @@ export declare class JupyterGISModel implements IJupyterGISModel {
      * Adds a story segment from the current map view
      * @returns Object with storySegmentId and storyMapId, or null if no extent/zoom found
      */
-    addStorySegment(): {
-        storySegmentId: string;
-        storyId: string;
-    } | null;
-    get segmentAdded(): ISignal<this, {
-        storySegmentId: string;
-        storyId: string;
-    }>;
+    addStorySegment(viewState?: IViewState[string]): IStorySegmentRef | null;
+    /**
+     * Generates a name for the next story segment based on the number of existing segments in the current story.
+     */
+    private _generateStorySegmentName;
+    /**
+     * Adds a story segment from a layer
+     * @returns Object with storySegmentId and storyMapId, or null if no extent/zoom found
+     */
+    createStorySegmentFromLayer(layerId: string): IStorySegmentRef | null;
+    get segmentAdded(): ISignal<this, IStorySegmentRef>;
     /**
      * Add an item in the layer tree.
      *
@@ -216,13 +232,21 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     toggleMode(mode: Modes): void;
     get currentMode(): Modes;
     set currentMode(value: Modes);
+    setUIState(value: Partial<IJGISUIState>): void;
+    getUIState(): IJGISUIState;
+    get uiStateChanged(): ISignal<this, IJGISUIState>;
     toggleTemporalController(): void;
     private _getLayerTreeInfo;
     private _onClientStateChanged;
+    private _emitAwarenessFieldDeltas;
     addFeatureAsMs: (id: string, selectedFeature: string) => void;
     get addFeatureAsMsSignal(): Signal<this, string>;
     get updateLayerSignal(): Signal<this, string>;
     triggerLayerUpdate: (layerId: string, layer: IJGISLayer | IJGISSource) => void;
+    checkIfIsADrawVectorLayer(layer: IJGISLayer): boolean;
+    updateEditingVectorLayer(): void;
+    get editingVectorLayer(): boolean;
+    set editingVectorLayer(editingVectorLayer: boolean);
     get geolocation(): JgisCoordinates;
     set geolocation(geolocation: JgisCoordinates);
     get geolocationChanged(): Signal<this, JgisCoordinates>;
@@ -230,6 +254,8 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     readonly defaultKernelLanguage: string;
     readonly annotationModel?: IAnnotationModel;
     readonly settingRegistry?: ISettingRegistry;
+    settingsReady: Promise<void>;
+    private _settingsReadyResolve;
     private _settings;
     private _settingsChanged;
     private _jgisSettings;
@@ -243,11 +269,18 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     private _userChanged;
     private _usersMap?;
     private _pathChanged;
+    private _viewState;
     private _disposed;
     private _contentChanged;
     private _stateChanged;
     private _themeChanged;
-    private _clientStateChanged;
+    private _selectedChanged;
+    private _pointerChanged;
+    private _viewportStateChanged;
+    private _identifiedFeaturesChanged;
+    private _remoteUserChanged;
+    private _temporalControllerActiveChanged;
+    private _previousClientStates;
     private _sharedMetadataChanged;
     private _zoomToPositionSignal;
     private _addFeatureAsMsSignal;
@@ -256,6 +289,7 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     private _isTemporalControllerActive;
     private _editing;
     private _editingChanged;
+    private _editingVectorLayer;
     static worker: Worker;
     private _geolocation;
     private _geolocationChanged;
@@ -263,6 +297,8 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     private _currentSegmentIndex;
     private _currentSegmentIndexChanged;
     stories: Map<string, IJGISStoryMap>;
+    private _localUIState;
+    private _uiStateChanged;
 }
 export declare namespace JupyterGISModel {
     /**