@jupytergis/schema 0.15.0 → 0.16.0-alpha.1

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 {
     /**

package/lib/model.js

@@ -2,8 +2,14 @@ import { UUID } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import Ajv from 'ajv';
 import { DEFAULT_PROJECTION, JupyterGISDoc } from './doc';
+import { AWARENESS_FIELD_KEYS, AWARENESS_STATE_FIELDS, } from './interfaces';
+import { migrateDocument } from './migrations';
 import jgisSchema from './schema/project/jgis.json';
 const SETTINGS_ID = '@jupytergis/jupytergis-core:jupytergis-settings';
+const SPECTA_STORY_TYPES = [
+    'guided',
+    'Vertical Scroll',
+];
 const DEFAULT_SETTINGS = {
     proxyUrl: 'https://corsproxy.io',
     leftPanelDisabled: false,
@@ -15,6 +21,7 @@ const DEFAULT_SETTINGS = {
     identifyDisabled: false,
     storyMapsDisabled: false,
     zoomButtonsEnabled: false,
+    useServerGdalProcessing: null,
 };
 export class JupyterGISModel {
     constructor(options) {
@@ -29,12 +36,11 @@ export class JupyterGISModel {
         this.flyToGeometrySignal = new Signal(this);
         this.highlightFeatureSignal = new Signal(this);
         this.updateBboxSignal = new Signal(this);
+        this.editingVectorLayerChanged = new Signal(this);
         this._onClientStateChanged = (changed) => {
             const clients = this.sharedModel.awareness.getStates();
-            this._clientStateChanged.emit(clients);
-            if (changed.added.length || changed.removed.length) {
-                this._userChanged.emit(this.users);
-            }
+            this._emitAwarenessFieldDeltas(changed, clients);
+            this._previousClientStates = new Map(clients);
         };
         this.addFeatureAsMs = (id, selectedFeature) => {
             this.addFeatureAsMsSignal.emit(JSON.stringify({ id, selectedFeature }));
@@ -52,7 +58,13 @@ export class JupyterGISModel {
         this._contentChanged = new Signal(this);
         this._stateChanged = new Signal(this);
         this._themeChanged = new Signal(this);
-        this._clientStateChanged = new Signal(this);
+        this._selectedChanged = new Signal(this);
+        this._pointerChanged = new Signal(this);
+        this._viewportStateChanged = new Signal(this);
+        this._identifiedFeaturesChanged = new Signal(this);
+        this._remoteUserChanged = new Signal(this);
+        this._temporalControllerActiveChanged = new Signal(this);
+        this._previousClientStates = new Map();
         this._sharedMetadataChanged = new Signal(this);
         this._zoomToPositionSignal = new Signal(this);
         this._addFeatureAsMsSignal = new Signal(this);
@@ -65,6 +77,8 @@ export class JupyterGISModel {
         this._tileFeatureCache = new Map();
         this._currentSegmentIndexChanged = new Signal(this);
         this.stories = new Map();
+        this._localUIState = {};
+        this._uiStateChanged = new Signal(this);
         const { annotationModel, sharedModel, settingRegistry } = options;
         if (sharedModel) {
             this._sharedModel = sharedModel;
@@ -79,7 +93,12 @@ export class JupyterGISModel {
         this.settingRegistry = settingRegistry;
         this._pathChanged = new Signal(this);
         this._settingsChanged = new Signal(this);
+        this._editingVectorLayer = false;
         this._jgisSettings = Object.assign({}, DEFAULT_SETTINGS);
+        this._viewState = {};
+        this.settingsReady = new Promise(resolve => {
+            this._settingsReadyResolve = resolve;
+        });
         this.initSettings();
     }
     /**
@@ -91,6 +110,7 @@ export class JupyterGISModel {
                 const setting = await this.settingRegistry.load(SETTINGS_ID);
                 this._settings = setting;
                 this._updateLocalSettings();
+                this._settingsReadyResolve();
                 setting.changed.connect(() => {
                     const oldSettings = Object.assign({}, this._jgisSettings);
                     this._updateLocalSettings();
@@ -106,8 +126,12 @@ export class JupyterGISModel {
             catch (error) {
                 console.error(`Failed to load settings for ${SETTINGS_ID}:`, error);
                 this._jgisSettings = Object.assign({}, DEFAULT_SETTINGS);
+                this._settingsReadyResolve();
             }
         }
+        else {
+            this._settingsReadyResolve();
+        }
     }
     _updateLocalSettings() {
         const composite = this._settings.composite;
@@ -196,8 +220,23 @@ export class JupyterGISModel {
     get localState() {
         return this.sharedModel.awareness.getLocalState();
     }
-    get clientStateChanged() {
-        return this._clientStateChanged;
+    get selectedChanged() {
+        return this._selectedChanged;
+    }
+    get pointerChanged() {
+        return this._pointerChanged;
+    }
+    get viewportStateChanged() {
+        return this._viewportStateChanged;
+    }
+    get identifiedFeaturesChanged() {
+        return this._identifiedFeaturesChanged;
+    }
+    get remoteUserChanged() {
+        return this._remoteUserChanged;
+    }
+    get temporalControllerActiveChanged() {
+        return this._temporalControllerActiveChanged;
     }
     get sharedOptionsChanged() {
         return this.sharedModel.optionsChanged;
@@ -248,10 +287,11 @@ export class JupyterGISModel {
         Signal.clearData(this);
     }
     toString() {
-        return JSON.stringify(this.getContent(), null, 2);
+        // Trailing newline for POSIX compliance (e.g. end-of-file-fixer pre-commit hook)
+        return JSON.stringify(this.getContent(), null, 2) + '\n';
     }
     fromString(data) {
-        const jsonData = JSON.parse(data);
+        const jsonData = migrateDocument(JSON.parse(data));
         const ajv = new Ajv();
         const validate = ajv.compile(jgisSchema);
         const valid = validate(jsonData);
@@ -301,6 +341,9 @@ export class JupyterGISModel {
             metadata: this.sharedModel.metadata,
         };
     }
+    getViewState() {
+        return this._viewState;
+    }
     /**
      * Getter for the contents manager.
      */
@@ -339,6 +382,10 @@ export class JupyterGISModel {
     getLayer(id) {
         return this.sharedModel.getLayer(id);
     }
+    getExtent(id) {
+        var _a;
+        return (_a = this._viewState[id]) === null || _a === void 0 ? void 0 : _a.extent;
+    }
     getLayerOrSource(id) {
         var _a;
         return (_a = this.sharedModel.getLayer(id)) !== null && _a !== void 0 ? _a : this.sharedModel.getLayerSource(id);
@@ -394,9 +441,16 @@ export class JupyterGISModel {
     addLayer(id, layer, groupName, position) {
         if (!this.getLayer(id)) {
             this.sharedModel.addLayer(id, layer);
+            this.syncLastAddedLayer(id);
         }
         this._addLayerTreeItem(id, groupName, position);
-        this.syncSelected({ [id]: { type: 'layer' } }, this.getClientId().toString());
+    }
+    /**
+     * Update layer's extent and zoom in model's view state
+     */
+    updateLayerViewState(id, view) {
+        const layer = this.getLayer(id);
+        this._viewState[id] = Object.assign(Object.assign(Object.assign({}, this._viewState[id]), view), { layerId: id, layerName: layer === null || layer === void 0 ? void 0 : layer.name });
     }
     removeLayer(layer_id) {
         var _a;
@@ -430,23 +484,28 @@ export class JupyterGISModel {
         return this._sharedModel.options;
     }
     syncViewport(viewport, emitter) {
-        this.sharedModel.awareness.setLocalStateField('viewportState', {
+        this.sharedModel.awareness.setLocalStateField(AWARENESS_STATE_FIELDS.viewportState, {
             value: viewport,
             emitter,
         });
     }
     syncPointer(pointer, emitter) {
-        this.sharedModel.awareness.setLocalStateField('pointer', {
+        this.sharedModel.awareness.setLocalStateField(AWARENESS_STATE_FIELDS.pointer, {
             value: pointer,
             emitter,
         });
     }
     syncSelected(value, emitter) {
-        this.sharedModel.awareness.setLocalStateField('selected', {
+        this.sharedModel.awareness.setLocalStateField(AWARENESS_STATE_FIELDS.selected, {
             value,
             emitter,
         });
     }
+    syncLastAddedLayer(layerId) {
+        this.sharedModel.awareness.setLocalStateField(AWARENESS_STATE_FIELDS.lastAddedLayer, {
+            layerId,
+        });
+    }
     get selected() {
         var _a, _b;
         return (_b = (_a = this.localState) === null || _a === void 0 ? void 0 : _a.selected) === null || _b === void 0 ? void 0 : _b.value;
@@ -455,14 +514,14 @@ export class JupyterGISModel {
         this.syncSelected(value || {}, this.getClientId().toString());
     }
     syncIdentifiedFeatures(features, emitter) {
-        this.sharedModel.awareness.setLocalStateField('identifiedFeatures', {
+        this.sharedModel.awareness.setLocalStateField(AWARENESS_STATE_FIELDS.identifiedFeatures, {
             value: features,
             emitter,
         });
     }
     setUserToFollow(userId) {
         if (this._sharedModel) {
-            this._sharedModel.awareness.setLocalStateField('remoteUser', userId);
+            this._sharedModel.awareness.setLocalStateField(AWARENESS_STATE_FIELDS.remoteUser, userId);
         }
     }
     setEditingItem(type, itemId) {
@@ -492,8 +551,9 @@ export class JupyterGISModel {
         var _a;
         const hasStories = Object.keys(this.sharedModel.stories).length > 0;
         const isSpecta = !!document.querySelector('meta[name="specta-config"]');
-        const guidedMode = ((_a = this.getSelectedStory().story) === null || _a === void 0 ? void 0 : _a.storyType) === 'guided';
-        return isSpecta && hasStories && guidedMode;
+        const storyType = (_a = this.getSelectedStory().story) === null || _a === void 0 ? void 0 : _a.storyType;
+        const isModeForSpecta = storyType !== undefined && SPECTA_STORY_TYPES.includes(storyType);
+        return isSpecta && hasStories && isModeForSpecta;
     }
     /**
      * Placeholder in case we eventually want to support multiple stories
@@ -527,9 +587,11 @@ export class JupyterGISModel {
      * Adds a story segment from the current map view
      * @returns Object with storySegmentId and storyMapId, or null if no extent/zoom found
      */
-    addStorySegment() {
+    addStorySegment(viewState) {
         var _a;
-        const { zoom, extent } = this.getOptions();
+        const state = viewState !== null && viewState !== void 0 ? viewState : this.getOptions();
+        const extent = state === null || state === void 0 ? void 0 : state.extent;
+        const zoom = state === null || state === void 0 ? void 0 : state.zoom;
         const { storyId } = this.getSelectedStory();
         if (!zoom || !extent) {
             console.warn('No extent or zoom found');
@@ -540,11 +602,16 @@ export class JupyterGISModel {
             extent,
             zoom,
             transition: { type: 'linear', time: 1 },
+            content: {
+                contentMode: 'map',
+                title: '',
+                image: '',
+            },
         };
         const layerModel = {
             type: 'StorySegmentLayer',
             visible: true,
-            name: 'Story Segment',
+            name: this._generateStorySegmentName(viewState),
             parameters: layerParams,
         };
         this.addLayer(newStorySegmentId, layerModel);
@@ -578,6 +645,52 @@ export class JupyterGISModel {
             return { storySegmentId: newStorySegmentId, storyId };
         }
     }
+    /**
+     * Generates a name for the next story segment based on the number of existing segments in the current story.
+     */
+    _generateStorySegmentName(viewState) {
+        var _a, _b;
+        const { story } = this.getSelectedStory();
+        const count = (_b = (_a = story === null || story === void 0 ? void 0 : story.storySegments) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        const basename = count === 0 ? 'Story Segment' : `Story Segment ${count}`;
+        return (viewState === null || viewState === void 0 ? void 0 : viewState.layerName)
+            ? `${viewState.layerName} - ${basename}`
+            : basename;
+    }
+    /**
+     * Adds a story segment from a layer
+     * @returns Object with storySegmentId and storyMapId, or null if no extent/zoom found
+     */
+    createStorySegmentFromLayer(layerId) {
+        const layer = this.getLayer(layerId);
+        if (!layer) {
+            return null;
+        }
+        const viewState = this.getViewState()[layerId];
+        if (!viewState) {
+            return null;
+        }
+        const segment = this.addStorySegment(viewState);
+        if (!segment) {
+            return null;
+        }
+        const segmentLayer = this.getLayer(segment.storySegmentId);
+        if (!segmentLayer) {
+            return null;
+        }
+        const segmentParams = segmentLayer.parameters;
+        const layerParams = layer.parameters;
+        const override = {
+            targetLayer: layerId,
+            visible: layer.visible,
+            color: layerParams === null || layerParams === void 0 ? void 0 : layerParams.color,
+            opacity: layerParams === null || layerParams === void 0 ? void 0 : layerParams.opacity,
+            symbologyState: layerParams === null || layerParams === void 0 ? void 0 : layerParams.symbologyState,
+        };
+        segmentParams.layerOverride = [override];
+        segmentLayer.parameters = segmentParams;
+        return segment;
+    }
     get segmentAdded() {
         return this._segmentAdded;
     }
@@ -735,9 +848,19 @@ export class JupyterGISModel {
     set currentMode(value) {
         this._currentMode = value;
     }
+    setUIState(value) {
+        this._localUIState = Object.assign(Object.assign({}, this._localUIState), value);
+        this._uiStateChanged.emit(this._localUIState);
+    }
+    getUIState() {
+        return this._localUIState;
+    }
+    get uiStateChanged() {
+        return this._uiStateChanged;
+    }
     toggleTemporalController() {
         this._isTemporalControllerActive = !this._isTemporalControllerActive;
-        this.sharedModel.awareness.setLocalStateField('isTemporalControllerActive', this._isTemporalControllerActive);
+        this.sharedModel.awareness.setLocalStateField(AWARENESS_STATE_FIELDS.isTemporalControllerActive, this._isTemporalControllerActive);
     }
     _getLayerTreeInfo(groupName) {
         const layerTree = this.getLayerTree();
@@ -765,12 +888,80 @@ export class JupyterGISModel {
             mainGroupIndex,
         };
     }
+    _emitAwarenessFieldDeltas(changed, clients) {
+        var _a, _b, _c;
+        const changedClientIds = new Set([
+            ...((_a = changed.added) !== null && _a !== void 0 ? _a : []),
+            ...((_b = changed.updated) !== null && _b !== void 0 ? _b : []),
+            ...((_c = changed.removed) !== null && _c !== void 0 ? _c : []),
+        ]);
+        if (!changedClientIds.size) {
+            return;
+        }
+        const fields = AWARENESS_FIELD_KEYS;
+        const localClientId = this.getClientId();
+        changedClientIds.forEach(clientId => {
+            const previousState = this._previousClientStates.get(clientId);
+            const currentState = clients.get(clientId);
+            fields.forEach(field => {
+                const previousValue = previousState === null || previousState === void 0 ? void 0 : previousState[field];
+                const currentValue = currentState === null || currentState === void 0 ? void 0 : currentState[field];
+                if (previousValue === currentValue) {
+                    return;
+                }
+                const payload = {
+                    clientId,
+                    field,
+                    previousValue,
+                    currentValue,
+                    fullState: currentState,
+                    isLocalClient: clientId === localClientId,
+                };
+                switch (field) {
+                    case AWARENESS_STATE_FIELDS.selected:
+                        this._selectedChanged.emit(payload);
+                        break;
+                    case AWARENESS_STATE_FIELDS.pointer:
+                        this._pointerChanged.emit(payload);
+                        break;
+                    case AWARENESS_STATE_FIELDS.viewportState:
+                        this._viewportStateChanged.emit(payload);
+                        break;
+                    case AWARENESS_STATE_FIELDS.identifiedFeatures:
+                        this._identifiedFeaturesChanged.emit(payload);
+                        break;
+                    case AWARENESS_STATE_FIELDS.remoteUser:
+                        this._remoteUserChanged.emit(payload);
+                        break;
+                    case AWARENESS_STATE_FIELDS.isTemporalControllerActive:
+                        this._temporalControllerActiveChanged.emit(payload);
+                        break;
+                }
+            });
+        });
+    }
     get addFeatureAsMsSignal() {
         return this._addFeatureAsMsSignal;
     }
     get updateLayerSignal() {
         return this._updateLayerSignal;
     }
+    checkIfIsADrawVectorLayer(layer) {
+        var _a, _b, _c;
+        const selectedSource = this.getSource((_a = layer.parameters) === null || _a === void 0 ? void 0 : _a.source);
+        return ((selectedSource === null || selectedSource === void 0 ? void 0 : selectedSource.type) === 'GeoJSONSource' &&
+            ((_c = (_b = selectedSource === null || selectedSource === void 0 ? void 0 : selectedSource.parameters) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.type) === 'FeatureCollection');
+    }
+    updateEditingVectorLayer() {
+        this.editingVectorLayerChanged.emit(this._editingVectorLayer);
+    }
+    get editingVectorLayer() {
+        return this._editingVectorLayer;
+    }
+    set editingVectorLayer(editingVectorLayer) {
+        this._editingVectorLayer = editingVectorLayer;
+        this.editingVectorLayerChanged.emit(this._editingVectorLayer);
+    }
     get geolocation() {
         return this._geolocation;
     }

package/lib/processing/ProcessingMerge.d.ts

@@ -9,6 +9,10 @@ type ProcessingElement = {
 };
 export declare const ProcessingLogicType: {
     vector: string;
+    raster: string;
+    rasterClip: string;
+    rasterClipVector: string;
+    clip: string;
 };
 export declare const ProcessingMerge: ProcessingElement[];
 export declare const ProcessingCommandIDs: IDict;

package/lib/processing/ProcessingMerge.js

@@ -1,6 +1,10 @@
 import _ProcessingMerge from './_generated/processing_merge.json';
 export const ProcessingLogicType = {
     vector: 'vector',
+    raster: 'raster',
+    rasterClip: 'rasterClip',
+    rasterClipVector: 'rasterClipVector',
+    clip: 'clip',
 };
 export const ProcessingMerge = _ProcessingMerge;
 export const ProcessingCommandIDs = {};

package/lib/processing/_generated/exportProcessingSchema.d.ts

@@ -1,6 +1,10 @@
-export * from '../../_interface/processing/boundingBoxes';
 export * from '../../_interface/processing/concaveHull';
-export * from '../../_interface/processing/dissolve';
-export * from '../../_interface/processing/buffer';
-export * from '../../_interface/processing/convexHull';
 export * from '../../_interface/processing/centroids';
+export * from '../../_interface/processing/clipRasterByVector';
+export * from '../../_interface/processing/boundingBoxes';
+export * from '../../_interface/processing/convexHull';
+export * from '../../_interface/processing/clipVectorByMaskLayer';
+export * from '../../_interface/processing/clipRasterByExtent';
+export * from '../../_interface/processing/rasterize';
+export * from '../../_interface/processing/buffer';
+export * from '../../_interface/processing/dissolve';

package/lib/processing/_generated/exportProcessingSchema.js

@@ -1,7 +1,11 @@
 //Generated automatically please don't modify directly
-export * from '../../_interface/processing/boundingBoxes';
 export * from '../../_interface/processing/concaveHull';
-export * from '../../_interface/processing/dissolve';
-export * from '../../_interface/processing/buffer';
-export * from '../../_interface/processing/convexHull';
 export * from '../../_interface/processing/centroids';
+export * from '../../_interface/processing/clipRasterByVector';
+export * from '../../_interface/processing/boundingBoxes';
+export * from '../../_interface/processing/convexHull';
+export * from '../../_interface/processing/clipVectorByMaskLayer';
+export * from '../../_interface/processing/clipRasterByExtent';
+export * from '../../_interface/processing/rasterize';
+export * from '../../_interface/processing/buffer';
+export * from '../../_interface/processing/dissolve';

package/lib/processing/_generated/processingType.d.ts

@@ -1,2 +1,2 @@
-export type ProcessingType = 'BoundingBoxes' | 'ConcaveHull' | 'Dissolve' | 'Buffer' | 'ConvexHull' | 'Centroids';
+export type ProcessingType = 'ConcaveHull' | 'Centroids' | 'ClipRasterByVector' | 'BoundingBoxes' | 'ConvexHull' | 'ClipVectorByMaskLayer' | 'ClipRasterByExtent' | 'Rasterize' | 'Buffer' | 'Dissolve';
 export declare const processingList: string[];

package/lib/processing/_generated/processingType.js

@@ -1,8 +1,12 @@
 export const processingList = [
-    'BoundingBoxes',
     'ConcaveHull',
-    'Dissolve',
-    'Buffer',
-    'ConvexHull',
     'Centroids',
+    'ClipRasterByVector',
+    'BoundingBoxes',
+    'ConvexHull',
+    'ClipVectorByMaskLayer',
+    'ClipRasterByExtent',
+    'Rasterize',
+    'Buffer',
+    'Dissolve',
 ];