@jupytergis/base 0.2.1 → 0.4.0

package/lib/tools.d.ts

@@ -1,5 +1,6 @@
 import { VectorTile } from '@mapbox/vector-tile';
-import { IDict, IJGISLayerBrowserRegistry, IJGISOptions } from '@jupytergis/schema';
+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;
 export declare function getElementFromProperty(filePath?: string | null, prop?: string | null): HTMLElement | undefined | null;
@@ -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,67 @@ 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>;
+/**
+ * Generalized file reader for different source types.
+ *
+ * @param fileInfo - Object containing the file path and source type.
+ * @returns A promise that resolves to the file content.
+ */
+export declare const loadFile: (fileInfo: {
+    filepath: string;
+    type: IJGISSource["type"];
+    model: IJupyterGISModel;
+}) => Promise<any>;
+/**
+ * Converts a base64-encoded string to a Blob.
+ *
+ * @param base64 - The base64-encoded string representing the file data.
+ * @param mimeType - The MIME type of the data.
+ * @returns A promise that resolves to a Blob representing the decoded data.
+ */
+export declare const base64ToBlob: (base64: string, mimeType: string) => Promise<Blob>;
+/**
+ * A mapping of file extensions to their corresponding MIME types.
+ */
+export declare const MIME_TYPES: {
+    [ext: string]: string;
+};
+/**
+ * Determine the MIME type based on the file extension.
+ *
+ * @param filename - The name of the file.
+ * @returns A string representing the MIME type.
+ */
+export declare const getMimeType: (filename: string) => string;
+/**
+ * Helper to convert a string (base64) to ArrayBuffer.
+ *
+ * @param content - File content as a base64 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,8 +1,10 @@
 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 shp from 'shpjs';
 import RASTER_LAYER_GALLERY from '../rasterlayer_gallery/raster_layer_gallery.json';
 import { getGdal } from './gdal';
 export const debounce = (func, timeout = 100) => {
@@ -213,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) {
@@ -310,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);
@@ -337,3 +347,375 @@ export const loadGeoTIFFWithCache = async (sourceInfo) => {
         sourceUrl: sourceInfo.url
     };
 };
+/**
+ * Generalized file reader for different source types.
+ *
+ * @param fileInfo - Object containing the file path and source type.
+ * @returns A promise that resolves to the file content.
+ */
+export const loadFile = async (fileInfo) => {
+    const { filepath, type, model } = fileInfo;
+    if (filepath.startsWith('http://') || filepath.startsWith('https://')) {
+        switch (type) {
+            case 'ImageSource': {
+                try {
+                    const response = await fetch(filepath);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch image from URL: ${filepath}`);
+                    }
+                    const contentType = response.headers.get('Content-Type');
+                    if (!contentType || !contentType.startsWith('image/')) {
+                        throw new Error(`Invalid image URL. Content-Type: ${contentType}`);
+                    }
+                    // load the image to verify it's not corrupted
+                    await validateImage(await response.blob());
+                    return filepath;
+                }
+                catch (error) {
+                    console.error('Error validating remote image:', error);
+                    throw error;
+                }
+            }
+            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.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) {
+                    console.error('Error loading remote GeoJSON:', error);
+                    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}`);
+            }
+        }
+    }
+    if (!model.contentsManager || !model.filePath) {
+        throw new Error('ContentsManager or filePath is not initialized.');
+    }
+    const absolutePath = PathExt.resolve(PathExt.dirname(model.filePath), filepath);
+    try {
+        const file = await model.contentsManager.get(absolutePath, {
+            content: true
+        });
+        if (!file.content) {
+            throw new Error(`File at ${absolutePath} is empty or inaccessible.`);
+        }
+        switch (type) {
+            case 'GeoJSONSource': {
+                return typeof file.content === 'string'
+                    ? JSON.parse(file.content)
+                    : file.content;
+            }
+            case 'ShapefileSource': {
+                const arrayBuffer = await stringToArrayBuffer(file.content);
+                const geojson = await shp(arrayBuffer);
+                return geojson;
+            }
+            case 'ImageSource': {
+                if (typeof file.content === 'string') {
+                    const mimeType = getMimeType(filepath);
+                    if (!mimeType.startsWith('image/')) {
+                        throw new Error(`Invalid image file. MIME type: ${mimeType}`);
+                    }
+                    // Attempt to decode the base64 data
+                    try {
+                        await validateImage(await base64ToBlob(file.content, mimeType));
+                        return `data:${mimeType};base64,${file.content}`;
+                    }
+                    catch (error) {
+                        console.error('Error image content failed to decode.:', error);
+                        throw error;
+                    }
+                }
+                else {
+                    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}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error(`Error reading file '${filepath}':`, error);
+        throw error;
+    }
+};
+/**
+ * Validates whether a given Blob represents a valid image.
+ *
+ * @param blob - The Blob to validate.
+ * @returns A promise that resolves if the Blob is a valid image, or rejects with an error otherwise.
+ */
+const validateImage = async (blob) => {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => resolve(); // Valid image
+        img.onerror = () => reject(new Error('Invalid image content.'));
+        img.src = URL.createObjectURL(blob);
+    });
+};
+/**
+ * Converts a base64-encoded string to a Blob.
+ *
+ * @param base64 - The base64-encoded string representing the file data.
+ * @param mimeType - The MIME type of the data.
+ * @returns A promise that resolves to a Blob representing the decoded data.
+ */
+export const base64ToBlob = async (base64, mimeType) => {
+    const response = await fetch(`data:${mimeType};base64,${base64}`);
+    return await response.blob();
+};
+/**
+ * A mapping of file extensions to their corresponding MIME types.
+ */
+export const MIME_TYPES = {
+    // from https://github.com/python/cpython/blob/3.9/Lib/mimetypes.py
+    '.a': 'application/octet-stream',
+    '.ai': 'application/postscript',
+    '.aif': 'audio/x-aiff',
+    '.aifc': 'audio/x-aiff',
+    '.aiff': 'audio/x-aiff',
+    '.au': 'audio/basic',
+    '.avi': 'video/x-msvideo',
+    '.bat': 'text/plain',
+    '.bcpio': 'application/x-bcpio',
+    '.bin': 'application/octet-stream',
+    '.bmp': 'image/bmp',
+    '.c': 'text/plain',
+    '.cdf': 'application/x-netcdf',
+    '.cpio': 'application/x-cpio',
+    '.csh': 'application/x-csh',
+    '.css': 'text/css',
+    '.csv': 'text/csv',
+    '.dll': 'application/octet-stream',
+    '.doc': 'application/msword',
+    '.dot': 'application/msword',
+    '.dvi': 'application/x-dvi',
+    '.eml': 'message/rfc822',
+    '.eps': 'application/postscript',
+    '.etx': 'text/x-setext',
+    '.exe': 'application/octet-stream',
+    '.gif': 'image/gif',
+    '.gtar': 'application/x-gtar',
+    '.h': 'text/plain',
+    '.hdf': 'application/x-hdf',
+    '.htm': 'text/html',
+    '.html': 'text/html',
+    '.ico': 'image/vnd.microsoft.icon',
+    '.ief': 'image/ief',
+    '.jpe': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpg',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.ksh': 'text/plain',
+    '.latex': 'application/x-latex',
+    '.m1v': 'video/mpeg',
+    '.m3u': 'application/vnd.apple.mpegurl',
+    '.m3u8': 'application/vnd.apple.mpegurl',
+    '.man': 'application/x-troff-man',
+    '.me': 'application/x-troff-me',
+    '.mht': 'message/rfc822',
+    '.mhtml': 'message/rfc822',
+    '.mid': 'audio/midi',
+    '.midi': 'audio/midi',
+    '.mif': 'application/x-mif',
+    '.mjs': 'application/javascript',
+    '.mov': 'video/quicktime',
+    '.movie': 'video/x-sgi-movie',
+    '.mp2': 'audio/mpeg',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.mpa': 'video/mpeg',
+    '.mpe': 'video/mpeg',
+    '.mpeg': 'video/mpeg',
+    '.mpg': 'video/mpeg',
+    '.ms': 'application/x-troff-ms',
+    '.nc': 'application/x-netcdf',
+    '.nws': 'message/rfc822',
+    '.o': 'application/octet-stream',
+    '.obj': 'application/octet-stream',
+    '.oda': 'application/oda',
+    '.p12': 'application/x-pkcs12',
+    '.p7c': 'application/pkcs7-mime',
+    '.pbm': 'image/x-portable-bitmap',
+    '.pct': 'image/pict',
+    '.pdf': 'application/pdf',
+    '.pfx': 'application/x-pkcs12',
+    '.pgm': 'image/x-portable-graymap',
+    '.pic': 'image/pict',
+    '.pict': 'image/pict',
+    '.pl': 'text/plain',
+    '.png': 'image/png',
+    '.pnm': 'image/x-portable-anymap',
+    '.pot': 'application/vnd.ms-powerpoint',
+    '.ppa': 'application/vnd.ms-powerpoint',
+    '.ppm': 'image/x-portable-pixmap',
+    '.pps': 'application/vnd.ms-powerpoint',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.ps': 'application/postscript',
+    '.pwz': 'application/vnd.ms-powerpoint',
+    '.py': 'text/x-python',
+    '.pyc': 'application/x-python-code',
+    '.pyo': 'application/x-python-code',
+    '.qt': 'video/quicktime',
+    '.ra': 'audio/x-pn-realaudio',
+    '.ram': 'application/x-pn-realaudio',
+    '.ras': 'image/x-cmu-raster',
+    '.rdf': 'application/xml',
+    '.rgb': 'image/x-rgb',
+    '.roff': 'application/x-troff',
+    '.rtf': 'application/rtf',
+    '.rtx': 'text/richtext',
+    '.sgm': 'text/x-sgml',
+    '.sgml': 'text/x-sgml',
+    '.sh': 'application/x-sh',
+    '.shar': 'application/x-shar',
+    '.snd': 'audio/basic',
+    '.so': 'application/octet-stream',
+    '.src': 'application/x-wais-source',
+    '.sv4cpio': 'application/x-sv4cpio',
+    '.sv4crc': 'application/x-sv4crc',
+    '.svg': 'image/svg+xml',
+    '.swf': 'application/x-shockwave-flash',
+    '.t': 'application/x-troff',
+    '.tar': 'application/x-tar',
+    '.tcl': 'application/x-tcl',
+    '.tex': 'application/x-tex',
+    '.texi': 'application/x-texinfo',
+    '.texinfo': 'application/x-texinfo',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+    '.tr': 'application/x-troff',
+    '.tsv': 'text/tab-separated-values',
+    '.txt': 'text/plain',
+    '.ustar': 'application/x-ustar',
+    '.vcf': 'text/x-vcard',
+    '.wasm': 'application/wasm',
+    '.wav': 'audio/x-wav',
+    '.webm': 'video/webm',
+    '.webmanifest': 'application/manifest+json',
+    '.wiz': 'application/msword',
+    '.wsdl': 'application/xml',
+    '.xbm': 'image/x-xbitmap',
+    '.xlb': 'application/vnd.ms-excel',
+    '.xls': 'application/vnd.ms-excel',
+    '.xml': 'text/xml',
+    '.xpdl': 'application/xml',
+    '.xpm': 'image/x-xpixmap',
+    '.xsl': 'application/xml',
+    '.xul': 'text/xul',
+    '.xwd': 'image/x-xwindowdump',
+    '.zip': 'application/zip',
+    '.ipynb': 'application/json'
+};
+/**
+ * Determine the MIME type based on the file extension.
+ *
+ * @param filename - The name of the file.
+ * @returns A string representing the MIME type.
+ */
+export const getMimeType = (filename) => {
+    var _a;
+    const extension = `.${((_a = filename.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || ''}`;
+    if (MIME_TYPES[extension]) {
+        return MIME_TYPES[extension];
+    }
+    console.warn(`Unknown file extension: ${extension}, defaulting to 'application/octet-stream'.`);
+    return 'application/octet-stream';
+};
+/**
+ * Helper to convert a string (base64) to ArrayBuffer.
+ *
+ * @param content - File content as a base64 string.
+ * @returns An ArrayBuffer.
+ */
+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;
     }
 }