@jupytergis/base 0.1.1

package/lib/dialogs/components/symbology/StopRow.js

@@ -0,0 +1,58 @@
+import { faTrash } from '@fortawesome/free-solid-svg-icons';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { Button } from '@jupyterlab/ui-components';
+import React from 'react';
+const StopRow = ({ index, value, outputValue, stopRows, setStopRows, deleteRow }) => {
+    const rgbArrToHex = (rgbArr) => {
+        const hex = rgbArr
+            .slice(0, -1) // Color input doesn't support hex alpha values so cut that out
+            .map((val) => {
+            return val.toString(16).padStart(2, '0');
+        })
+            .join('');
+        return '#' + hex;
+    };
+    const hexToRgb = (hex) => {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        if (!result) {
+            console.warn('Unable to parse hex value, defaulting to black');
+            return [parseInt('0', 16), parseInt('0', 16), parseInt('0', 16)];
+        }
+        const rgbValues = [
+            parseInt(result[1], 16),
+            parseInt(result[2], 16),
+            parseInt(result[3], 16),
+            1 // TODO: Make alpha customizable?
+        ];
+        return rgbValues;
+    };
+    const handleValueChange = (event) => {
+        const newRows = [...stopRows];
+        newRows[index].value = +event.target.value;
+        setStopRows(newRows);
+    };
+    const handleBlur = () => {
+        const newRows = [...stopRows];
+        newRows.sort((a, b) => {
+            if (a.value < b.value) {
+                return -1;
+            }
+            if (a.value > b.value) {
+                return 1;
+            }
+            return 0;
+        });
+        setStopRows(newRows);
+    };
+    const handleColorChange = (event) => {
+        const newRows = [...stopRows];
+        newRows[index].color = hexToRgb(event.target.value);
+        setStopRows(newRows);
+    };
+    return (React.createElement("div", { className: "jp-gis-color-row" },
+        React.createElement("input", { id: `jp-gis-color-value-${index}`, type: "number", value: value, onChange: handleValueChange, onBlur: handleBlur, className: "jp-mod-styled" }),
+        React.createElement("input", { id: `jp-gis-color-color-${index}`, value: rgbArrToHex(outputValue), type: "color", onChange: handleColorChange, className: "jp-mod-styled" }),
+        React.createElement(Button, { id: `jp-gis-remove-color-${index}`, className: "jp-Button jp-gis-filter-icon" },
+            React.createElement(FontAwesomeIcon, { icon: faTrash, onClick: deleteRow }))));
+};
+export default StopRow;

package/lib/dialogs/formdialog.d.ts

@@ -0,0 +1,31 @@
+import { IDict } from '@jupytergis/schema';
+import { Dialog } from '@jupyterlab/apputils';
+import * as React from 'react';
+import { ICreationFormProps } from '../formbuilder';
+import { Signal } from '@lumino/signaling';
+import { PromiseDelegate } from '@lumino/coreutils';
+export interface ICreationFormWrapperProps extends ICreationFormProps {
+    /**
+     * A promise resolving when the dialog is ready.
+     * Return a signal emitting when OK button is pressed.
+     */
+    okSignalPromise: PromiseDelegate<Signal<Dialog<any>, number>>;
+    /**
+     * A promise resolving when the dialog is ready.
+     * Return a signal emitting when the form changed, with a boolean whether there are
+     * some extra errors or not.
+     */
+    formErrorSignalPromise?: PromiseDelegate<Signal<Dialog<any>, boolean>>;
+}
+export interface ICreationFormDialogOptions extends ICreationFormProps {
+    title: string;
+}
+export declare const CreationFormWrapper: (props: ICreationFormWrapperProps) => false | React.JSX.Element;
+/**
+ * Form for creating a source, a layer or both at the same time
+ */
+export declare class CreationFormDialog extends Dialog<IDict> {
+    constructor(options: ICreationFormDialogOptions);
+    resolve(index?: number): void;
+    private okSignal;
+}

package/lib/dialogs/formdialog.js

@@ -0,0 +1,68 @@
+import { Dialog } from '@jupyterlab/apputils';
+import * as React from 'react';
+import { CreationForm } from '../formbuilder';
+import { Signal } from '@lumino/signaling';
+import { PromiseDelegate } from '@lumino/coreutils';
+export const CreationFormWrapper = (props) => {
+    var _a;
+    const [ready, setReady] = React.useState(false);
+    const okSignal = React.useRef();
+    const formErrorSignal = React.useRef();
+    Promise.all([
+        props.okSignalPromise.promise,
+        (_a = props.formErrorSignalPromise) === null || _a === void 0 ? void 0 : _a.promise
+    ]).then(([ok, formChanged]) => {
+        okSignal.current = ok;
+        formErrorSignal.current = formChanged;
+        setReady(true);
+    });
+    return (ready && (React.createElement(CreationForm, { context: props.context, formSchemaRegistry: props.formSchemaRegistry, createLayer: props.createLayer, createSource: props.createSource, layerType: props.layerType, sourceType: props.sourceType, sourceData: props.sourceData, layerData: props.layerData, ok: okSignal.current, cancel: props.cancel, formErrorSignal: formErrorSignal.current })));
+};
+/**
+ * Form for creating a source, a layer or both at the same time
+ */
+export class CreationFormDialog extends Dialog {
+    constructor(options) {
+        const cancelCallback = () => {
+            this.resolve(0);
+        };
+        const okSignalPromise = new PromiseDelegate();
+        const formErrorSignalPromise = new PromiseDelegate();
+        const body = (React.createElement("div", { style: { overflow: 'auto' } },
+            React.createElement(CreationFormWrapper, { context: options.context, formSchemaRegistry: options.formSchemaRegistry, createLayer: options.createLayer, createSource: options.createSource, layerType: options.layerType, sourceType: options.sourceType, sourceData: options.sourceData, layerData: options.layerData, okSignalPromise: okSignalPromise, cancel: cancelCallback, formErrorSignalPromise: formErrorSignalPromise })));
+        super({
+            title: options.title,
+            body,
+            buttons: [Dialog.cancelButton(), Dialog.okButton()]
+        });
+        this.okSignal = new Signal(this);
+        const formErrorSignal = new Signal(this);
+        /**
+         * Disable the OK button if the form is invalid.
+         */
+        formErrorSignal.connect((_, extraErrors) => {
+            const invalid = extraErrors || !!this.node.querySelector(':invalid');
+            if (invalid) {
+                this.node
+                    .getElementsByClassName('jp-mod-accept')[0]
+                    .setAttribute('disabled', '');
+            }
+            else {
+                this.node
+                    .getElementsByClassName('jp-mod-accept')[0]
+                    .removeAttribute('disabled');
+            }
+        });
+        okSignalPromise.resolve(this.okSignal);
+        formErrorSignalPromise.resolve(formErrorSignal);
+        this.addClass('jGIS-layer-CreationFormDialog');
+    }
+    resolve(index) {
+        if (index === 0) {
+            super.resolve(index);
+        }
+        if (index === 1) {
+            this.okSignal.emit(1);
+        }
+    }
+}

package/lib/dialogs/layerBrowserDialog.d.ts

@@ -0,0 +1,25 @@
+import { IJGISFormSchemaRegistry, IJupyterGISModel, IRasterLayerGalleryEntry } from '@jupytergis/schema';
+import { Dialog } from '@jupyterlab/apputils';
+import { PromiseDelegate } from '@lumino/coreutils';
+import React from 'react';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { Signal } from '@lumino/signaling';
+interface ILayerBrowserDialogProps {
+    context: DocumentRegistry.IContext<IJupyterGISModel>;
+    registry: IRasterLayerGalleryEntry[];
+    formSchemaRegistry: IJGISFormSchemaRegistry;
+    okSignalPromise: PromiseDelegate<Signal<Dialog<any>, number>>;
+    cancel: () => void;
+}
+export declare const LayerBrowserComponent: ({ context, registry, formSchemaRegistry, okSignalPromise, cancel }: ILayerBrowserDialogProps) => React.JSX.Element;
+export interface ILayerBrowserOptions {
+    context: DocumentRegistry.IContext<IJupyterGISModel>;
+    registry: IRasterLayerGalleryEntry[];
+    formSchemaRegistry: IJGISFormSchemaRegistry;
+}
+export declare class LayerBrowserWidget extends Dialog<boolean> {
+    constructor(options: ILayerBrowserOptions);
+    resolve(index?: number): void;
+    private okSignal;
+}
+export {};

package/lib/dialogs/layerBrowserDialog.js

@@ -0,0 +1,141 @@
+import { faCheck, faPlus } from '@fortawesome/free-solid-svg-icons';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { Dialog } from '@jupyterlab/apputils';
+import { PromiseDelegate, UUID } from '@lumino/coreutils';
+import React, { useEffect, useState } from 'react';
+import CUSTOM_RASTER_IMAGE from '../../rasterlayer_gallery/custom_raster.png';
+import { CreationFormWrapper } from './formdialog';
+import { Signal } from '@lumino/signaling';
+export const LayerBrowserComponent = ({ context, registry, formSchemaRegistry, okSignalPromise, cancel }) => {
+    const [searchTerm, setSearchTerm] = useState('');
+    const [activeLayers, setActiveLayers] = useState([]);
+    const [selectedCategory, setSelectedCategory] = useState();
+    const [creatingCustomRaster, setCreatingCustomRaster] = useState(false);
+    const [galleryWithCategory, setGalleryWithCategory] = useState(registry);
+    const providers = [...new Set(registry.map(item => item.source.provider))];
+    const filteredGallery = galleryWithCategory.filter(item => item.name.toLowerCase().includes(searchTerm));
+    useEffect(() => {
+        context.model.sharedModel.layersChanged.connect(handleLayerChange);
+        return () => {
+            context.model.sharedModel.layersChanged.disconnect(handleLayerChange);
+        };
+    }, []);
+    /**
+     * Track which layers are currently added to the map
+     */
+    const handleLayerChange = (_, change) => {
+        // The split is to get rid of the 'Layer' part of the name to match the names in the gallery
+        setActiveLayers(Object.values(context.model.sharedModel.layers).map(layer => layer.name.split(' ')[0]));
+    };
+    const handleSearchInput = (event) => {
+        setSearchTerm(event.target.value.toLowerCase());
+    };
+    const handleCategoryClick = (event) => {
+        const categoryTab = event.target;
+        const sameAsOld = categoryTab.innerText === (selectedCategory === null || selectedCategory === void 0 ? void 0 : selectedCategory.innerText);
+        categoryTab.classList.toggle('jGIS-layer-browser-category-selected');
+        selectedCategory === null || selectedCategory === void 0 ? void 0 : selectedCategory.classList.remove('jGIS-layer-browser-category-selected');
+        const filteredGallery = sameAsOld
+            ? registry
+            : registry.filter(item => { var _a; return (_a = item.source.provider) === null || _a === void 0 ? void 0 : _a.includes(categoryTab.innerText); });
+        setGalleryWithCategory(filteredGallery);
+        setSearchTerm('');
+        setSelectedCategory(sameAsOld ? null : categoryTab);
+    };
+    const handleCustomTileClick = () => {
+        setCreatingCustomRaster(true);
+    };
+    /**
+     * Add tile layer and source to model
+     * @param tile Tile to add
+     */
+    const handleTileClick = (tile) => {
+        const sourceId = UUID.uuid4();
+        const sourceModel = {
+            type: 'RasterSource',
+            name: tile.name,
+            parameters: tile.source
+        };
+        const layerModel = {
+            type: 'RasterLayer',
+            parameters: {
+                source: sourceId
+            },
+            visible: true,
+            name: tile.name + ' Layer'
+        };
+        context.model.sharedModel.addSource(sourceId, sourceModel);
+        context.model.addLayer(UUID.uuid4(), layerModel);
+    };
+    if (creatingCustomRaster) {
+        // Disconnect any previous handler
+        okSignalPromise.promise.then(value => {
+            value.disconnect(cancel, this);
+        });
+        return (React.createElement("div", { className: "jGIS-customlayer-form" },
+            React.createElement(CreationFormWrapper, { context: context, formSchemaRegistry: formSchemaRegistry, createLayer: true, createSource: true, layerType: 'RasterLayer', sourceType: 'RasterSource', layerData: {
+                    name: 'Custom Raster'
+                }, sourceData: {
+                    url: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
+                    maxZoom: 24,
+                    minZoom: 0,
+                    attribution: '(C) OpenStreetMap contributors'
+                }, okSignalPromise: okSignalPromise, cancel: cancel })));
+    }
+    // Ok is like cancel in the case of gallery item selections
+    okSignalPromise.promise.then(value => {
+        value.connect(cancel, this);
+    });
+    return (React.createElement("div", { className: "jGIS-layer-browser-container" },
+        React.createElement("div", { className: "jGIS-layer-browser-header-container" },
+            React.createElement("div", { className: "jGIS-layer-browser-header" },
+                React.createElement("h2", { className: "jGIS-layer-browser-header-text" }, "Layer Browser"),
+                React.createElement("div", { className: "jGIS-layer-browser-header-search-container" },
+                    React.createElement("input", { type: "text", placeholder: "Search...", value: searchTerm, onChange: handleSearchInput, className: "jGIS-layer-browser-header-search" }))),
+            React.createElement("div", { className: "jGIS-layer-browser-categories" }, providers.map(provider => (React.createElement("span", { className: "jGIS-layer-browser-category", onClick: handleCategoryClick }, provider))))),
+        React.createElement("div", { className: "jGIS-layer-browser-grid" },
+            React.createElement("div", { className: "jGIS-layer-browser-tile jGIS-layer-browser-custom-tile", onClick: () => handleCustomTileClick() },
+                React.createElement("div", { className: "jGIS-layer-browser-tile-img-container" },
+                    React.createElement("img", { className: "jGIS-layer-browser-img", src: CUSTOM_RASTER_IMAGE }),
+                    React.createElement("div", { className: "jGIS-layer-browser-icon" },
+                        React.createElement(FontAwesomeIcon, { style: { height: 20 }, icon: faPlus }))),
+                React.createElement("div", { className: "jGIS-layer-browser-text-container" },
+                    React.createElement("div", { className: "jGIS-layer-browser-text-info" },
+                        React.createElement("h3", { className: "jGIS-layer-browser-text-header jGIS-layer-browser-text-general" }, "Custom Raster Layer")),
+                    React.createElement("p", { className: "jGIS-layer-browser-text-general jGIS-layer-browser-text-source" }, "Create A Custom Raster Layer"))),
+            filteredGallery.map(tile => (React.createElement("div", { className: "jGIS-layer-browser-tile", onClick: () => handleTileClick(tile) },
+                React.createElement("div", { className: "jGIS-layer-browser-tile-img-container" },
+                    React.createElement("img", { className: "jGIS-layer-browser-img", src: tile.thumbnail }),
+                    activeLayers.indexOf(tile.name) === -1 ? (React.createElement("div", { className: "jGIS-layer-browser-icon" },
+                        React.createElement(FontAwesomeIcon, { style: { height: 20 }, icon: faPlus }))) : (React.createElement("div", { className: "jGIS-layer-browser-icon jGIS-layer-browser-added" },
+                        React.createElement(FontAwesomeIcon, { style: { height: 20 }, icon: faCheck }),
+                        React.createElement("p", { className: "jGIS-layer-browser-text-general" }, "Added!")))),
+                React.createElement("div", { className: "jGIS-layer-browser-text-container" },
+                    React.createElement("div", { className: "jGIS-layer-browser-text-info" },
+                        React.createElement("h3", { className: "jGIS-layer-browser-text-header jGIS-layer-browser-text-general" }, tile.name)),
+                    React.createElement("p", { className: "jGIS-layer-browser-text-general jGIS-layer-browser-text-source" }, tile.source.attribution))))))));
+};
+export class LayerBrowserWidget extends Dialog {
+    constructor(options) {
+        let cancelCallback = undefined;
+        cancelCallback = () => {
+            this.resolve(0);
+        };
+        const okSignalPromise = new PromiseDelegate();
+        const body = (React.createElement(LayerBrowserComponent, { context: options.context, registry: options.registry, formSchemaRegistry: options.formSchemaRegistry, okSignalPromise: okSignalPromise, cancel: cancelCallback }));
+        super({ body, buttons: [Dialog.cancelButton(), Dialog.okButton()] });
+        this.id = 'jupytergis::layerBrowser';
+        this.okSignal = new Signal(this);
+        okSignalPromise.resolve(this.okSignal);
+        // Override default dialog style
+        this.addClass('jGIS-layerbrowser-FormDialog');
+    }
+    resolve(index) {
+        if (index === 0) {
+            super.resolve(index);
+        }
+        if (index === 1) {
+            this.okSignal.emit(1);
+        }
+    }
+}

package/lib/dialogs/symbologyDialog.d.ts

@@ -0,0 +1,23 @@
+import { IJupyterGISModel } from '@jupytergis/schema';
+import { Dialog } from '@jupyterlab/apputils';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { IStateDB } from '@jupyterlab/statedb';
+import { PromiseDelegate } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+export interface ISymbologyDialogProps {
+    context: DocumentRegistry.IContext<IJupyterGISModel>;
+    state: IStateDB;
+    okSignalPromise: PromiseDelegate<Signal<SymbologyWidget, null>>;
+    cancel: () => void;
+    layerId?: string;
+}
+export interface ISymbologyWidgetOptions {
+    context: DocumentRegistry.IContext<IJupyterGISModel>;
+    state: IStateDB;
+}
+export declare class SymbologyWidget extends Dialog<boolean> {
+    private okSignal;
+    constructor(options: ISymbologyWidgetOptions);
+    resolve(index: number): void;
+}
+export default SymbologyWidget;

package/lib/dialogs/symbologyDialog.js

@@ -0,0 +1,68 @@
+import { Dialog } from '@jupyterlab/apputils';
+import { PromiseDelegate } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+import React, { useEffect, useState } from 'react';
+import BandRendering from './components/symbology/BandRendering';
+const SymbologyDialog = ({ context, state, okSignalPromise, cancel }) => {
+    const [selectedLayer, setSelectedLayer] = useState(null);
+    const [componentToRender, setComponentToRender] = useState(null);
+    let LayerSymbology;
+    useEffect(() => {
+        const handleClientStateChanged = () => {
+            var _a, _b;
+            if (!((_b = (_a = context.model.localState) === null || _a === void 0 ? void 0 : _a.selected) === null || _b === void 0 ? void 0 : _b.value)) {
+                return;
+            }
+            const currentLayer = Object.keys(context.model.localState.selected.value)[0];
+            setSelectedLayer(currentLayer);
+        };
+        // Initial state
+        handleClientStateChanged();
+        context.model.clientStateChanged.connect(handleClientStateChanged);
+        return () => {
+            context.model.clientStateChanged.disconnect(handleClientStateChanged);
+        };
+    }, []);
+    useEffect(() => {
+        if (!selectedLayer) {
+            return;
+        }
+        const layer = context.model.getLayer(selectedLayer);
+        if (!layer) {
+            return;
+        }
+        // TODO WebGlLayers can also be used for other layers, need a better way to determine source + layer combo
+        switch (layer.type) {
+            case 'WebGlLayer':
+                LayerSymbology = (React.createElement(BandRendering, { context: context, state: state, okSignalPromise: okSignalPromise, cancel: cancel, layerId: selectedLayer }));
+                break;
+            default:
+                LayerSymbology = React.createElement("div", null, "Layer Type Not Supported");
+        }
+        setComponentToRender(LayerSymbology);
+    }, [selectedLayer]);
+    return React.createElement(React.Fragment, null, componentToRender);
+};
+export class SymbologyWidget extends Dialog {
+    constructor(options) {
+        const cancelCallback = () => {
+            this.resolve(0);
+        };
+        const okSignalPromise = new PromiseDelegate();
+        const body = (React.createElement(SymbologyDialog, { context: options.context, okSignalPromise: okSignalPromise, cancel: cancelCallback, state: options.state }));
+        super({ title: 'Symbology', body });
+        this.id = 'jupytergis::symbologyWidget';
+        this.okSignal = new Signal(this);
+        okSignalPromise.resolve(this.okSignal);
+        this.addClass('jp-gis-symbology-dialog');
+    }
+    resolve(index) {
+        if (index === 0) {
+            super.resolve(index);
+        }
+        if (index === 1) {
+            this.okSignal.emit(null);
+        }
+    }
+}
+export default SymbologyWidget;

package/lib/dialogs/terrainDialog.d.ts

@@ -0,0 +1,21 @@
+import { IJupyterGISModel } from '@jupytergis/schema';
+import { Dialog } from '@jupyterlab/apputils';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { PromiseDelegate } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+import React from 'react';
+interface ITerrainDialogProps {
+    context: DocumentRegistry.IContext<IJupyterGISModel>;
+    okSignalPromise: PromiseDelegate<Signal<TerrainDialogWidget, null>>;
+    cancel: () => void;
+}
+declare const TerrainDialog: ({ context, okSignalPromise, cancel }: ITerrainDialogProps) => React.JSX.Element;
+export interface ITerrainDialogOptions {
+    context: DocumentRegistry.IContext<IJupyterGISModel>;
+}
+export declare class TerrainDialogWidget extends Dialog<boolean> {
+    private okSignal;
+    constructor(options: ITerrainDialogOptions);
+    resolve(index?: number): void;
+}
+export default TerrainDialog;

package/lib/dialogs/terrainDialog.js

@@ -0,0 +1,60 @@
+import { Dialog } from '@jupyterlab/apputils';
+import { PromiseDelegate } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+import React, { useEffect, useRef, useState } from 'react';
+const TerrainDialog = ({ context, okSignalPromise, cancel }) => {
+    const rasterDemSources = context.model.getSourcesByType('RasterDemSource');
+    const [selectedSource, setSelectedSource] = useState(Object.keys(rasterDemSources)[0]);
+    const [exaggerationInput, setExaggerationInput] = useState(1);
+    const selectedSourceRef = useRef(selectedSource);
+    const exaggerationInputRef = useRef(exaggerationInput);
+    useEffect(() => {
+        selectedSourceRef.current = selectedSource;
+        exaggerationInputRef.current = exaggerationInput;
+    }, [selectedSource, exaggerationInput]);
+    // Handler for changing the selected option
+    const handleSourceChange = (event) => {
+        setSelectedSource(event.target.value);
+    };
+    // Handler for changing the number input
+    const handleExaggerationChange = (event) => {
+        setExaggerationInput(Number(event.target.value));
+    };
+    const handleOk = () => {
+        context.model.setTerrain({
+            source: selectedSourceRef.current,
+            exaggeration: exaggerationInputRef.current
+        });
+        cancel();
+    };
+    okSignalPromise.promise.then(okSignal => {
+        okSignal.connect(handleOk);
+    });
+    return (React.createElement("div", { className: "jp-gis-terrain-main" },
+        React.createElement("label", { className: "jp-gis-terrain-label", htmlFor: "source" }, "Source:"),
+        React.createElement("select", { id: "source", className: "jp-mod-styled", value: selectedSource, onChange: handleSourceChange, "aria-label": "Select source" }, Object.entries(rasterDemSources).map(([key, value]) => (React.createElement("option", { key: key, value: key }, value)))),
+        React.createElement("label", { className: "jp-gis-terrain-label", htmlFor: "exaggeration" }, "Exaggeration:"),
+        React.createElement("input", { id: "exaggeration", className: "jp-mod-styled", type: "number", min: 0, step: 0.1, value: exaggerationInput, onChange: handleExaggerationChange, placeholder: "Enter an exaggeration value", "aria-label": "Enter exaggeration value" })));
+};
+export class TerrainDialogWidget extends Dialog {
+    constructor(options) {
+        const cancelCallback = () => {
+            this.resolve(0);
+        };
+        const okSignalPromise = new PromiseDelegate();
+        const body = (React.createElement(TerrainDialog, { context: options.context, okSignalPromise: okSignalPromise, cancel: cancelCallback }));
+        super({ title: 'Add New Terrain', body });
+        this.id = 'jupytergis::terrain';
+        this.okSignal = new Signal(this);
+        okSignalPromise.resolve(this.okSignal);
+    }
+    resolve(index) {
+        if (index === 0) {
+            super.resolve(index);
+        }
+        if (index === 1) {
+            this.okSignal.emit(null);
+        }
+    }
+}
+export default TerrainDialog;

package/lib/formbuilder/creationform.d.ts

@@ -0,0 +1,56 @@
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { IDict, IJGISFormSchemaRegistry, IJupyterGISModel, LayerType, SourceType } from '@jupytergis/schema';
+import { Dialog } from '@jupyterlab/apputils';
+import { Signal } from '@lumino/signaling';
+import * as React from 'react';
+export interface ICreationFormProps {
+    /**
+     * Whether or not to create a layer
+     */
+    createLayer: boolean;
+    /**
+     * Whether or not to create a source
+     */
+    createSource: boolean;
+    /**
+     * The type of layer to create.
+     */
+    layerType?: LayerType;
+    /**
+     * The type of source to create or to select in the case where we only create a layer.
+     */
+    sourceType: SourceType;
+    /**
+     * The initial layer data, if it applies.
+     */
+    layerData?: IDict;
+    /**
+     * The initial source data, if it applies.
+     */
+    sourceData?: IDict;
+    /**
+     * Ok signal. This is the signal sent by the parent dialog upon "Ok" button click. No ok button will be displayed if defined.
+     */
+    ok?: Signal<Dialog<any>, number>;
+    /**
+     * Cancel callback
+     */
+    cancel?: () => void;
+    formSchemaRegistry: IJGISFormSchemaRegistry;
+    context: DocumentRegistry.IContext<IJupyterGISModel>;
+    /**
+     * A signal emitting when the form changed, with a boolean whether there are some
+     * extra errors or not.
+     */
+    formErrorSignal?: Signal<Dialog<any>, boolean>;
+}
+/**
+ * Form for creating a source, a layer or both at the same time
+ */
+export declare class CreationForm extends React.Component<ICreationFormProps, any> {
+    constructor(props: ICreationFormProps);
+    render(): React.JSX.Element | undefined;
+    private jGISModel;
+    private filePath;
+    private sourceFormChangedSignal;
+}