@jupytergis/base 0.3.0 → 0.4.0

package/lib/panelview/components/layers.js

@@ -104,8 +104,8 @@ function LayersBodyComponent(props) {
      */
     (_b = props.model) === null || _b === void 0 ? void 0 : _b.documentChanged.connect((_, widget) => {
         var _a;
-        setModel(widget === null || widget === void 0 ? void 0 : widget.context.model);
-        setLayerTree(((_a = widget === null || widget === void 0 ? void 0 : widget.context.model) === null || _a === void 0 ? void 0 : _a.getLayerTree()) || []);
+        setModel(widget === null || widget === void 0 ? void 0 : widget.model);
+        setLayerTree(((_a = widget === null || widget === void 0 ? void 0 : widget.model) === null || _a === void 0 ? void 0 : _a.getLayerTree()) || []);
     });
     return (React.createElement("div", { id: "jp-gis-layer-tree" }, layerTree
         .slice()

package/lib/panelview/components/sources.js

@@ -55,7 +55,7 @@ function SourcesBodyComponent(props) {
      * Update the model when it changes.
      */
     (_b = props.model) === null || _b === void 0 ? void 0 : _b.documentChanged.connect((_, widget) => {
-        setModel(widget === null || widget === void 0 ? void 0 : widget.context.model);
+        setModel(widget === null || widget === void 0 ? void 0 : widget.model);
     });
     return (React.createElement("div", { id: "jp-gis-sources" }, sourceIds.map(sourceId => {
         return (React.createElement(SourceComponent, { key: `source-${sourceId}`, gisModel: model, sourceId: sourceId, onClick: onItemClick }));

package/lib/panelview/leftpanel.d.ts

@@ -4,6 +4,7 @@ import { SidePanel } from '@jupyterlab/ui-components';
 import { Message } from '@lumino/messaging';
 import { MouseEvent as ReactMouseEvent } from 'react';
 import { IControlPanelModel } from '../types';
+import { CommandRegistry } from '@lumino/commands';
 /**
  * Options of the left panel widget.
  */
@@ -37,12 +38,14 @@ export declare class LeftPanelWidget extends SidePanel {
     private _lastSelectedNodeId;
     private _model;
     private _state;
+    private _commands;
 }
 export declare namespace LeftPanelWidget {
     interface IOptions {
         model: IControlPanelModel;
         tracker: IJupyterGISTracker;
         state: IStateDB;
+        commands: CommandRegistry;
     }
     interface IProps {
         filePath?: string;

package/lib/panelview/leftpanel.js

@@ -3,6 +3,7 @@ import { LayersPanel } from './components/layers';
 import { SourcesPanel } from './components/sources';
 import { ControlPanelHeader } from './header';
 import { FilterPanel } from './components/filter-panel/Filter';
+import { CommandIDs } from '../constants';
 export class LeftPanelWidget extends SidePanel {
     constructor(options) {
         super();
@@ -50,11 +51,13 @@ export class LeftPanelWidget extends SidePanel {
                 const updatedSelectedValue = Object.assign(Object.assign({}, selectedValue), { [item]: { type, selectedNodeId: nodeId } });
                 this._lastSelectedNodeId = nodeId;
                 jGISModel.syncSelected(updatedSelectedValue, this.id);
+                this._commands.notifyCommandChanged(CommandIDs.temporalController);
             }
         };
         this.addClass('jGIS-sidepanel-widget');
         this._model = options.model;
         this._state = options.state;
+        this._commands = options.commands;
         const header = new ControlPanelHeader();
         this.header.addWidget(header);
         const sourcesPanel = new SourcesPanel({
@@ -81,7 +84,7 @@ export class LeftPanelWidget extends SidePanel {
         this.addWidget(filterPanel);
         options.tracker.currentChanged.connect((_, changed) => {
             if (changed) {
-                header.title.label = changed.context.localPath;
+                header.title.label = changed.model.filePath;
             }
             else {
                 header.title.label = '-';
@@ -129,5 +132,6 @@ export class LeftPanelWidget extends SidePanel {
             this._lastSelectedNodeId = nodeId;
         }
         (_b = (_a = this._model) === null || _a === void 0 ? void 0 : _a.jGISModel) === null || _b === void 0 ? void 0 : _b.syncSelected(selection, this.id);
+        this._commands.notifyCommandChanged(CommandIDs.temporalController);
     }
 }

package/lib/panelview/model.js

@@ -8,23 +8,23 @@ export class ControlPanelModel {
     }
     get filePath() {
         var _a;
-        return (_a = this._tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.context.localPath;
+        return (_a = this._tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model.filePath;
     }
     get jGISModel() {
         var _a;
-        return (_a = this._tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.context.model;
+        return (_a = this._tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model;
     }
     get sharedModel() {
         var _a;
-        return (_a = this._tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.context.model.sharedModel;
+        return (_a = this._tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model.sharedModel;
     }
     disconnect(f) {
         this._tracker.forEach(w => {
-            w.context.model.sharedLayersChanged.disconnect(f);
-            w.context.model.sharedSourcesChanged.disconnect(f);
-            w.context.model.sharedOptionsChanged.disconnect(f);
+            w.model.sharedLayersChanged.disconnect(f);
+            w.model.sharedSourcesChanged.disconnect(f);
+            w.model.sharedOptionsChanged.disconnect(f);
         });
-        this._tracker.forEach(w => w.context.model.themeChanged.disconnect(f));
-        this._tracker.forEach(w => w.context.model.clientStateChanged.disconnect(f));
+        this._tracker.forEach(w => w.model.themeChanged.disconnect(f));
+        this._tracker.forEach(w => w.model.clientStateChanged.disconnect(f));
     }
 }

package/lib/panelview/objectproperties.js

@@ -45,7 +45,7 @@ class ObjectPropertiesReact extends React.Component {
             }
         };
         this.state = {
-            context: (_a = props.tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.context,
+            model: (_a = props.tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model,
             clientId: null,
             id: uuid()
         };
@@ -55,14 +55,14 @@ class ObjectPropertiesReact extends React.Component {
             if (changed) {
                 this.props.cpModel.disconnect(this._sharedJGISModelChanged);
                 this.props.cpModel.disconnect(this._onClientSharedStateChanged);
-                changed.context.model.sharedLayersChanged.connect(this._sharedJGISModelChanged);
-                changed.context.model.sharedSourcesChanged.connect(this._sharedJGISModelChanged);
-                changed.context.model.clientStateChanged.connect(this._onClientSharedStateChanged);
-                this.setState(old => (Object.assign(Object.assign({}, old), { context: changed.context, filePath: changed.context.localPath, clientId: changed.context.model.getClientId() })));
+                changed.model.sharedLayersChanged.connect(this._sharedJGISModelChanged);
+                changed.model.sharedSourcesChanged.connect(this._sharedJGISModelChanged);
+                changed.model.clientStateChanged.connect(this._onClientSharedStateChanged);
+                this.setState(old => (Object.assign(Object.assign({}, old), { model: changed.model, filePath: changed.model.filePath, clientId: changed.model.getClientId() })));
             }
             else {
                 this.setState({
-                    context: undefined,
+                    model: undefined,
                     selectedObject: undefined
                 });
             }
@@ -71,22 +71,22 @@ class ObjectPropertiesReact extends React.Component {
     render() {
         var _a;
         const selectedObject = this.state.selectedObject;
-        if (!selectedObject || !this.state.context) {
+        if (!selectedObject || !this.state.model) {
             return React.createElement("div", null);
         }
         let layerId = undefined;
         let sourceId = undefined;
-        const layer = this.state.context.model.getLayer(selectedObject);
+        const layer = this.state.model.getLayer(selectedObject);
         if (layer) {
             layerId = selectedObject;
             sourceId = (_a = layer.parameters) === null || _a === void 0 ? void 0 : _a.source;
         }
         else {
-            const source = this.state.context.model.getSource(selectedObject);
+            const source = this.state.model.getSource(selectedObject);
             if (source) {
                 sourceId = selectedObject;
             }
         }
-        return (React.createElement(EditForm, { layer: layerId, source: sourceId, formSchemaRegistry: this.props.formSchemaRegistry, context: this.state.context }));
+        return (React.createElement(EditForm, { layer: layerId, source: sourceId, formSchemaRegistry: this.props.formSchemaRegistry, model: this.state.model }));
     }
 }

package/lib/panelview/rightpanel.d.ts

@@ -4,7 +4,7 @@ import { IControlPanelModel } from '../types';
 export declare class RightPanelWidget extends SidePanel {
     constructor(options: RightPanelWidget.IOptions);
     dispose(): void;
-    private _currentContext;
+    private _currentModel;
     private _model;
     private _annotationModel;
 }

package/lib/panelview/rightpanel.js

@@ -31,12 +31,12 @@ export class RightPanelWidget extends SidePanel {
         this.addWidget(identifyPanel);
         this._model.documentChanged.connect((_, changed) => {
             if (changed) {
-                if (changed.context.model.sharedModel.editable) {
-                    header.title.label = changed.context.localPath;
+                if (changed.model.sharedModel.editable) {
+                    header.title.label = changed.model.filePath;
                     properties.show();
                 }
                 else {
-                    header.title.label = `${changed.context.localPath} - Read Only`;
+                    header.title.label = `${changed.model.filePath} - Read Only`;
                     properties.hide();
                 }
             }
@@ -47,16 +47,16 @@ export class RightPanelWidget extends SidePanel {
         options.tracker.currentChanged.connect(async (_, changed) => {
             var _a;
             if (changed) {
-                this._currentContext = changed.context;
-                header.title.label = this._currentContext.localPath;
-                this._annotationModel.context =
-                    ((_a = options.tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.context) || undefined;
-                await changed.context.ready;
+                this._currentModel = changed.model;
+                header.title.label = this._currentModel.filePath;
+                this._annotationModel.model =
+                    ((_a = options.tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model) || undefined;
+                // await changed.context.ready;
             }
             else {
                 header.title.label = '-';
-                this._currentContext = null;
-                this._annotationModel.context = undefined;
+                this._currentModel = null;
+                this._annotationModel.model = undefined;
             }
         });
     }

package/lib/toolbar/widget.d.ts

@@ -1,5 +1,5 @@
 import { IJGISExternalCommand, JupyterGISModel } from '@jupytergis/schema';
-import { Toolbar, ReactiveToolbar } from '@jupyterlab/ui-components';
+import { ReactiveToolbar, Toolbar } from '@jupyterlab/ui-components';
 import { CommandRegistry } from '@lumino/commands';
 import { Widget } from '@lumino/widgets';
 export declare const TOOLBAR_SEPARATOR_CLASS = "jGIS-Toolbar-Separator";

package/lib/toolbar/widget.js

@@ -1,8 +1,9 @@
 import { CommandToolbarButton } from '@jupyterlab/apputils';
-import { ReactWidget, ReactiveToolbar, ToolbarButton, addIcon, redoIcon, undoIcon, terminalIcon } from '@jupyterlab/ui-components';
+import { MenuSvg, ReactWidget, ReactiveToolbar, ToolbarButton, addIcon, redoIcon, terminalIcon, undoIcon } from '@jupyterlab/ui-components';
 import { Menu, Widget } from '@lumino/widgets';
 import * as React from 'react';
 import { CommandIDs } from '../constants';
+import { rasterIcon } from '../icons';
 import { UsersItem } from './usertoolbaritem';
 export const TOOLBAR_SEPARATOR_CLASS = 'jGIS-Toolbar-Separator';
 export const TOOLBAR_GROUPNAME_CLASS = 'jGIS-Toolbar-GroupName';
@@ -55,52 +56,63 @@ export class ToolbarWidget extends ReactiveToolbar {
                 label: '',
                 commands: options.commands
             }));
-            const NewButton = new ToolbarButton({
+            // vector sub menu
+            const vectorSubMenu = new Menu({ commands: options.commands });
+            vectorSubMenu.title.label = 'Add Vector Layer';
+            vectorSubMenu.title.iconClass = 'fa fa-vector-square';
+            vectorSubMenu.id = 'jp-gis-toolbar-vector-menu';
+            vectorSubMenu.addItem({
+                type: 'command',
+                command: CommandIDs.newGeoJSONEntry
+            });
+            vectorSubMenu.addItem({
+                type: 'command',
+                command: CommandIDs.newShapefileLayer
+            });
+            //raster submenu
+            const rasterSubMenu = new Menu({ commands: options.commands });
+            rasterSubMenu.title.label = 'Add Raster Layer';
+            rasterSubMenu.title.icon = rasterIcon;
+            rasterSubMenu.id = 'jp-gis-toolbar-raster-menu';
+            rasterSubMenu.addItem({
+                type: 'command',
+                command: CommandIDs.newHillshadeEntry
+            });
+            rasterSubMenu.addItem({
+                type: 'command',
+                command: CommandIDs.newImageEntry
+            });
+            rasterSubMenu.addItem({
+                type: 'command',
+                command: CommandIDs.newGeoTiffEntry
+            });
+            const NewSubMenu = new MenuSvg({ commands: options.commands });
+            NewSubMenu.title.label = 'Add Layer';
+            NewSubMenu.addItem({ type: 'submenu', submenu: rasterSubMenu });
+            NewSubMenu.addItem({ type: 'submenu', submenu: vectorSubMenu });
+            const NewEntryButton = new ToolbarButton({
                 icon: addIcon,
                 noFocusOnClick: false,
                 onClick: () => {
                     if (!options.commands) {
                         return;
                     }
-                    const bbox = NewButton.node.getBoundingClientRect();
-                    const NewSubMenu = new Menu({ commands: options.commands });
-                    NewSubMenu.title.label = 'New Layer';
-                    NewSubMenu.addItem({
-                        type: 'command',
-                        command: CommandIDs.newHillshadeEntry
-                    });
-                    NewSubMenu.addItem({
-                        type: 'separator'
-                    });
-                    NewSubMenu.addItem({
-                        type: 'command',
-                        command: CommandIDs.newImageEntry
-                    });
-                    NewSubMenu.addItem({
-                        type: 'separator'
-                    });
-                    NewSubMenu.addItem({
-                        type: 'command',
-                        command: CommandIDs.newShapefileLayer
-                    });
-                    NewSubMenu.addItem({
-                        type: 'command',
-                        command: CommandIDs.newGeoTiffEntry
-                    });
-                    NewSubMenu.addItem({
-                        type: 'command',
-                        command: CommandIDs.newGeoJSONEntry
-                    });
+                    const bbox = NewEntryButton.node.getBoundingClientRect();
                     NewSubMenu.open(bbox.x, bbox.bottom);
                 }
             });
-            this.addItem('New', NewButton);
+            this.addItem('New', NewEntryButton);
             this.addItem('separator2', new Separator());
             this.addItem('identify', new CommandToolbarButton({
                 id: CommandIDs.identify,
                 label: '',
                 commands: options.commands
             }));
+            this.addItem('temporalController', new CommandToolbarButton({
+                id: CommandIDs.temporalController,
+                label: '',
+                commands: options.commands
+            }));
             this.addItem('spacer', ReactiveToolbar.createSpacerItem());
             // Users
             this.addItem('users', ReactWidget.create(React.createElement(UsersItem, { model: options.model })));

package/lib/tools.d.ts

@@ -1,4 +1,5 @@
 import { VectorTile } from '@mapbox/vector-tile';
+import { Contents } from '@jupyterlab/services';
 import { IDict, IJGISLayerBrowserRegistry, IJGISOptions, IJGISSource, IJupyterGISModel } from '@jupytergis/schema';
 export declare const debounce: (func: CallableFunction, timeout?: number) => CallableFunction;
 export declare function throttle<T extends (...args: any[]) => void>(callback: T, delay?: number): T;
@@ -22,7 +23,6 @@ export declare function deepCopy<T = IDict<any>>(value: T): T;
  */
 export declare function createDefaultLayerRegistry(layerBrowserRegistry: IJGISLayerBrowserRegistry): void;
 export declare function getLayerTileInfo(tileUrl: string, mapOptions: Pick<IJGISOptions, 'latitude' | 'longitude' | 'extent' | 'zoom'>, urlParameters?: IDict<string>): Promise<VectorTile>;
-export declare function getSourceLayerNames(tileUrl: string, urlParameters?: IDict<string>): Promise<string[]>;
 export interface IParsedStyle {
     fillColor: string;
     strokeColor: string;
@@ -46,24 +46,27 @@ export declare const openDatabase: () => Promise<IDBDatabase>;
  * @param metadata metadata of file.
  * @returns A promise that resolves once the data is successfully saved.
  */
-export declare const saveToIndexedDB: (key: string, file: Blob, metadata: any) => Promise<void>;
+export declare const saveToIndexedDB: (key: string, file: any, metadata?: any | undefined) => Promise<void>;
 /**
  * Retrieve a file and its metadata from the IndexedDB database.
  *
  * @param key fileID (sourceUrl).
  * @returns A promise that resolves to the stored data object or undefined.
  */
-export declare const getFromIndexedDB: (key: string) => Promise<any>;
+export declare const getFromIndexedDB: (key: string) => Promise<{
+    file: any;
+    metadata?: any | undefined;
+} | undefined>;
 /**
  * Load a GeoTIFF file from IndexedDB database cache or fetch it .
  *
  * @param sourceInfo object containing the URL of the GeoTIFF file.
  * @returns A promise that resolves to the file as a Blob, or undefined .
  */
-export declare const loadGeoTIFFWithCache: (sourceInfo: {
+export declare const loadGeoTiff: (sourceInfo: {
     url?: string | undefined;
-}) => Promise<{
-    file: Blob;
+}, file?: Contents.IModel | null) => Promise<{
+    file: any;
     metadata: any;
     sourceUrl: string;
 } | null>;
@@ -106,3 +109,4 @@ export declare const getMimeType: (filename: string) => string;
  * @returns An ArrayBuffer.
  */
 export declare const stringToArrayBuffer: (content: string) => Promise<ArrayBuffer>;
+export declare const getNumericFeatureAttributes: (featureProperties: Record<string, Set<any>>) => Record<string, Set<number>>;

package/lib/tools.js

@@ -1,9 +1,9 @@
 import Protobuf from 'pbf';
 import { VectorTile } from '@mapbox/vector-tile';
-import { URLExt } from '@jupyterlab/coreutils';
+import { PathExt, URLExt } from '@jupyterlab/coreutils';
 import { ServerConnection } from '@jupyterlab/services';
+import { showErrorMessage } from '@jupyterlab/apputils';
 import * as d3Color from 'd3-color';
-import { PathExt } from '@jupyterlab/coreutils';
 import shp from 'shpjs';
 import RASTER_LAYER_GALLERY from '../rasterlayer_gallery/raster_layer_gallery.json';
 import { getGdal } from './gdal';
@@ -215,11 +215,6 @@ export async function getLayerTileInfo(tileUrl, mapOptions, urlParameters) {
     const tile = new VectorTile(new Protobuf(arrayBuffer));
     return tile;
 }
-export async function getSourceLayerNames(tileUrl, urlParameters) {
-    const tile = await getLayerTileInfo(tileUrl, { latitude: 0, longitude: 0, zoom: 0, extent: [] }, urlParameters);
-    const layerNames = Object.keys(tile.layers);
-    return layerNames;
-}
 export function parseColor(type, style) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     if (!type || !style) {
@@ -312,23 +307,36 @@ export const getFromIndexedDB = async (key) => {
  * @param sourceInfo object containing the URL of the GeoTIFF file.
  * @returns A promise that resolves to the file as a Blob, or undefined .
  */
-export const loadGeoTIFFWithCache = async (sourceInfo) => {
+export const loadGeoTiff = async (sourceInfo, file) => {
     if (!(sourceInfo === null || sourceInfo === void 0 ? void 0 : sourceInfo.url)) {
         return null;
     }
+    const mimeType = getMimeType(sourceInfo.url);
+    if (!mimeType || !mimeType.startsWith('image/tiff')) {
+        throw new Error('Invalid file type. Expected GeoTIFF (image/tiff).');
+    }
     const cachedData = await getFromIndexedDB(sourceInfo.url);
     if (cachedData) {
         return {
-            file: new Blob([cachedData.file]),
+            file: cachedData.file,
             metadata: cachedData.metadata,
             sourceUrl: sourceInfo.url
         };
     }
-    const response = await fetch(sourceInfo.url);
-    const fileBlob = await response.blob();
-    const file = new File([fileBlob], 'loaded.tif');
+    let fileBlob;
+    if (!file) {
+        const response = await fetch(`/jupytergis_core/proxy?url=${sourceInfo.url}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch file. Status: ${response.status}`);
+        }
+        fileBlob = await response.blob();
+    }
+    else {
+        fileBlob = await base64ToBlob(file.content, mimeType);
+    }
+    const geotiff = new File([fileBlob], 'loaded.tif');
     const Gdal = await getGdal();
-    const result = await Gdal.open(file);
+    const result = await Gdal.open(geotiff);
     const tifDataset = result.datasets[0];
     const metadata = await Gdal.gdalinfo(tifDataset, ['-stats']);
     Gdal.close(tifDataset);
@@ -369,24 +377,58 @@ export const loadFile = async (fileInfo) => {
                 }
             }
             case 'ShapefileSource': {
+                const cached = await getFromIndexedDB(filepath);
+                if (cached) {
+                    return cached.file;
+                }
+                // First trying a direct fetch
+                try {
+                    const response = await fetch(filepath);
+                    const arrayBuffer = await response.arrayBuffer();
+                    const geojson = await shp(arrayBuffer);
+                    await saveToIndexedDB(filepath, geojson);
+                    return geojson;
+                }
+                catch (error) {
+                    console.warn('Cannot load shapefile from ${filepath}: ${error}');
+                }
+                // Trying through our proxy server
                 try {
                     const response = await fetch(`/jupytergis_core/proxy?url=${filepath}`);
                     const arrayBuffer = await response.arrayBuffer();
                     const geojson = await shp(arrayBuffer);
+                    await saveToIndexedDB(filepath, geojson);
                     return geojson;
                 }
                 catch (error) {
-                    console.error('Error loading remote shapefile:', error);
-                    throw error;
+                    console.warn('Cannot communicate with the JupyterGIS proxy server:', error);
                 }
+                // Trying through an external proxy server
+                try {
+                    const response = await fetch(`https://corsproxy.io/?url=${filepath}`);
+                    const arrayBuffer = await response.arrayBuffer();
+                    const geojson = await shp(arrayBuffer);
+                    await saveToIndexedDB(filepath, geojson);
+                    return geojson;
+                }
+                catch (error) {
+                    console.warn('Cannot communicate with external proxy server', error);
+                }
+                showErrorMessage('Network error', 'Failed to fetch ${filepath}');
+                throw new Error('Failed to fetch ${filepath}');
             }
             case 'GeoJSONSource': {
+                const cached = await getFromIndexedDB(filepath);
+                if (cached) {
+                    return cached.file;
+                }
                 try {
                     const response = await fetch(`/jupytergis_core/proxy?url=${filepath}`);
                     if (!response.ok) {
                         throw new Error(`Failed to fetch GeoJSON from URL: ${filepath}`);
                     }
                     const geojson = await response.json();
+                    await saveToIndexedDB(filepath, geojson);
                     return geojson;
                 }
                 catch (error) {
@@ -394,6 +436,16 @@ export const loadFile = async (fileInfo) => {
                     throw error;
                 }
             }
+            case 'GeoTiffSource': {
+                try {
+                    const tiff = loadGeoTiff({ url: filepath });
+                    return tiff;
+                }
+                catch (error) {
+                    console.error('Error loading remote GeoTIFF:', error);
+                    throw error;
+                }
+            }
             default: {
                 throw new Error(`Unsupported URL handling for source type: ${type}`);
             }
@@ -441,6 +493,15 @@ export const loadFile = async (fileInfo) => {
                     throw new Error('Invalid file format for image content.');
                 }
             }
+            case 'GeoTiffSource': {
+                if (typeof file.content === 'string') {
+                    const tiff = loadGeoTiff({ url: filepath }, file);
+                    return tiff;
+                }
+                else {
+                    throw new Error('Invalid file format for tiff content.');
+                }
+            }
             default: {
                 throw new Error(`Unsupported source type: ${type}`);
             }
@@ -645,3 +706,16 @@ export const stringToArrayBuffer = async (content) => {
     const base64Response = await fetch(`data:application/octet-stream;base64,${content}`);
     return await base64Response.arrayBuffer();
 };
+export const getNumericFeatureAttributes = (featureProperties) => {
+    // We only want number values here
+    const filteredRecord = {};
+    for (const [key, set] of Object.entries(featureProperties)) {
+        const firstValue = set.values().next().value;
+        // Check if the first value is a string that cannot be parsed as a number
+        const isInvalidString = typeof firstValue === 'string' && isNaN(Number(firstValue));
+        if (!isInvalidString) {
+            filteredRecord[key] = set;
+        }
+    }
+    return filteredRecord;
+};

package/lib/types.d.ts

@@ -1,8 +1,10 @@
 import { IDict, IJupyterGISDoc, IJupyterGISModel, IJupyterGISTracker, IJupyterGISWidget } from '@jupytergis/schema';
+import { WidgetTracker } from '@jupyterlab/apputils';
 import { ISignal } from '@lumino/signaling';
 import { Map } from 'ol';
 export { IDict };
 export type ValueOf<T> = T[keyof T];
+export type JupyterGISTracker = WidgetTracker<IJupyterGISWidget>;
 export interface IControlPanelModel {
     disconnect(f: any): void;
     documentChanged: ISignal<IJupyterGISTracker, IJupyterGISWidget | null>;

package/lib/widget.d.ts

@@ -1,25 +1,48 @@
-import { JSONValue } from '@lumino/coreutils';
-import { ISignal } from '@lumino/signaling';
-import { SplitPanel } from '@lumino/widgets';
+import { MainAreaWidget } from '@jupyterlab/apputils';
 import { ConsolePanel, IConsoleTracker } from '@jupyterlab/console';
 import { DocumentWidget } from '@jupyterlab/docregistry';
 import { IObservableMap, ObservableMap } from '@jupyterlab/observables';
-import { IJupyterGISModel, IJupyterGISWidget } from '@jupytergis/schema';
+import { JSONValue } from '@lumino/coreutils';
+import { ISignal } from '@lumino/signaling';
+import { SplitPanel } from '@lumino/widgets';
+import { IJupyterGISModel, IJupyterGISOutputWidget, IJupyterGISDocumentWidget } from '@jupytergis/schema';
 import { JupyterGISMainViewPanel } from './mainview';
 import { MainViewModel } from './mainview/mainviewmodel';
 import { ConsoleView } from './console';
-export declare class JupyterGISWidget extends DocumentWidget<JupyterGISPanel, IJupyterGISModel> implements IJupyterGISWidget {
+import { CommandRegistry } from '@lumino/commands';
+export type JupyterGISWidget = JupyterGISDocumentWidget | JupyterGISOutputWidget;
+export declare class JupyterGISDocumentWidget extends DocumentWidget<JupyterGISPanel, IJupyterGISModel> implements IJupyterGISDocumentWidget {
     constructor(options: DocumentWidget.IOptions<JupyterGISPanel, IJupyterGISModel>);
+    get model(): IJupyterGISModel;
     /**
      * Dispose of the resources held by the widget.
      */
     dispose(): void;
     onResize: (msg: any) => void;
 }
+/**
+ * A main area widget designed to be used as Notebook cell output widget, to ease the
+ * integration of toolbar and tracking.
+ */
+export declare class JupyterGISOutputWidget extends MainAreaWidget<JupyterGISPanel> implements IJupyterGISOutputWidget {
+    constructor(options: JupyterGISOutputWidget.IOptions);
+    /**
+     * Dispose of the resources held by the widget.
+     */
+    dispose(): void;
+    readonly model: IJupyterGISModel;
+    readonly resizeObserver: ResizeObserver;
+}
+export declare namespace JupyterGISOutputWidget {
+    interface IOptions extends MainAreaWidget.IOptions<JupyterGISPanel> {
+        model: IJupyterGISModel;
+    }
+}
 export declare class JupyterGISPanel extends SplitPanel {
     constructor(options: JupyterGISPanel.IOptions);
     _initModel(options: {
         model: IJupyterGISModel;
+        commandRegistry: CommandRegistry;
     }): void;
     _initView(): void;
     get jupyterGISMainViewPanel(): JupyterGISMainViewPanel;
@@ -44,6 +67,7 @@ export declare class JupyterGISPanel extends SplitPanel {
 export declare namespace JupyterGISPanel {
     interface IOptions extends Partial<ConsoleView.IOptions> {
         model: IJupyterGISModel;
+        commandRegistry: CommandRegistry;
         consoleTracker?: IConsoleTracker;
     }
 }