@jupytergis/base 0.4.1 → 0.4.3

package/lib/commands.js

@@ -1,10 +1,13 @@
 import { showErrorMessage } from '@jupyterlab/apputils';
 import { CommandIDs, icons } from './constants';
-import { CreationFormDialog } from './dialogs/formdialog';
+import { LayerCreationFormDialog } from './dialogs/layerCreationFormDialog';
 import { LayerBrowserWidget } from './dialogs/layerBrowserDialog';
 import { SymbologyWidget } from './dialogs/symbology/symbologyDialog';
 import keybindings from './keybindings.json';
 import { JupyterGISDocumentWidget } from './widget';
+import { getGeoJSONDataFromLayerSource, downloadFile } from './tools';
+import { ProcessingFormDialog } from './dialogs/ProcessingFormDialog';
+import { getSingleSelectedLayer, selectedLayerIsOfType, processSelectedLayer } from './processing';
 function loadKeybindings(commands, keybindings) {
     keybindings.forEach(binding => {
         commands.addKeyBinding({
@@ -67,12 +70,32 @@ export function addCommands(app, tracker, translator, formSchemaRegistry, layerB
             }
         } }, icons.get(CommandIDs.undo)));
     commands.addCommand(CommandIDs.identify, Object.assign({ label: trans.__('Identify'), isToggled: () => {
-            var _a;
-            return ((_a = tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model.isIdentifying) || false;
+            const current = tracker.currentWidget;
+            if (!current) {
+                return false;
+            }
+            const selectedLayer = getSingleSelectedLayer(tracker);
+            if (!selectedLayer) {
+                return false;
+            }
+            const canIdentify = [
+                'VectorLayer',
+                'ShapefileLayer',
+                'WebGlLayer'
+            ].includes(selectedLayer.type);
+            const isIdentifying = current.model.isIdentifying;
+            if (isIdentifying && !canIdentify) {
+                current.model.isIdentifying = false;
+                current.node.classList.remove('jGIS-identify-tool');
+                return false;
+            }
+            return isIdentifying;
         }, isEnabled: () => {
-            return tracker.currentWidget
-                ? tracker.currentWidget.model.sharedModel.editable
-                : false;
+            const selectedLayer = getSingleSelectedLayer(tracker);
+            if (!selectedLayer) {
+                return false;
+            }
+            return ['VectorLayer', 'ShapefileLayer', 'WebGlLayer'].includes(selectedLayer.type);
         }, execute: args => {
             const current = tracker.currentWidget;
             if (!current) {
@@ -172,6 +195,51 @@ export function addCommands(app, tracker, translator, formSchemaRegistry, layerB
             sourceType: 'VectorTileSource',
             layerType: 'VectorTileLayer'
         }) }, icons.get(CommandIDs.newVectorTileEntry)));
+    commands.addCommand(CommandIDs.buffer, {
+        label: trans.__('Buffer'),
+        isEnabled: () => selectedLayerIsOfType(['VectorLayer'], tracker),
+        execute: async () => {
+            await processSelectedLayer(tracker, formSchemaRegistry, 'Buffer', {
+                sqlQueryFn: (layerName, bufferDistance) => `
+          SELECT ST_Union(ST_Buffer(geometry, ${bufferDistance})) AS geometry, *
+          FROM "${layerName}"
+        `,
+                gdalFunction: 'ogr2ogr',
+                options: (sqlQuery) => [
+                    '-f',
+                    'GeoJSON',
+                    '-dialect',
+                    'SQLITE',
+                    '-sql',
+                    sqlQuery,
+                    'output.geojson'
+                ]
+            }, app);
+        }
+    });
+    commands.addCommand(CommandIDs.dissolve, {
+        label: trans.__('Dissolve'),
+        isEnabled: () => selectedLayerIsOfType(['VectorLayer'], tracker),
+        execute: async () => {
+            await processSelectedLayer(tracker, formSchemaRegistry, 'Dissolve', {
+                sqlQueryFn: (layerName, dissolveField) => `
+          SELECT ST_Union(geometry) AS geometry, ${dissolveField}
+          FROM "${layerName}"
+          GROUP BY ${dissolveField}
+        `,
+                gdalFunction: 'ogr2ogr',
+                options: (sqlQuery) => [
+                    '-f',
+                    'GeoJSON',
+                    '-dialect',
+                    'SQLITE',
+                    '-sql',
+                    sqlQuery,
+                    'output.geojson'
+                ]
+            }, app);
+        }
+    });
     commands.addCommand(CommandIDs.newGeoJSONEntry, Object.assign({ label: trans.__('New GeoJSON layer'), isEnabled: () => {
             return tracker.currentWidget
                 ? tracker.currentWidget.model.sharedModel.editable
@@ -729,6 +797,51 @@ export function addCommands(app, tracker, translator, formSchemaRegistry, layerB
             model.centerOnPosition(layerId);
         }
     });
+    commands.addCommand(CommandIDs.downloadGeoJSON, {
+        label: trans.__('Download as GeoJSON'),
+        isEnabled: () => {
+            const selectedLayer = getSingleSelectedLayer(tracker);
+            return selectedLayer
+                ? ['VectorLayer', 'ShapefileLayer'].includes(selectedLayer.type)
+                : false;
+        },
+        execute: async () => {
+            var _a, _b;
+            const selectedLayer = getSingleSelectedLayer(tracker);
+            if (!selectedLayer) {
+                return;
+            }
+            const model = (_a = tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model;
+            const sources = (_b = model.sharedModel.sources) !== null && _b !== void 0 ? _b : {};
+            const exportSchema = Object.assign({}, formSchemaRegistry.getSchemas().get('ExportGeoJSONSchema'));
+            const formValues = await new Promise(resolve => {
+                const dialog = new ProcessingFormDialog({
+                    title: 'Download GeoJSON',
+                    schema: exportSchema,
+                    model,
+                    sourceData: { exportFormat: 'GeoJSON' },
+                    formContext: 'create',
+                    processingType: 'Export',
+                    syncData: (props) => {
+                        resolve(props);
+                        dialog.dispose();
+                    }
+                });
+                dialog.launch();
+            });
+            if (!formValues || !selectedLayer.parameters) {
+                return;
+            }
+            const exportFileName = formValues.exportFileName;
+            const sourceId = selectedLayer.parameters.source;
+            const source = sources[sourceId];
+            const geojsonString = await getGeoJSONDataFromLayerSource(source, model);
+            if (!geojsonString) {
+                return;
+            }
+            downloadFile(geojsonString, `${exportFileName}.geojson`, 'application/geo+json');
+        }
+    });
     loadKeybindings(commands, keybindings);
 }
 var Private;
@@ -768,7 +881,7 @@ var Private;
             if (!current) {
                 return;
             }
-            const dialog = new CreationFormDialog({
+            const dialog = new LayerCreationFormDialog({
                 model: current.model,
                 title,
                 createLayer,

package/lib/constants.d.ts

@@ -17,6 +17,8 @@ export declare namespace CommandIDs {
     const newImageEntry = "jupytergis:newImageEntry";
     const newVideoEntry = "jupytergis:newVideoEntry";
     const newGeoTiffEntry = "jupytergis:newGeoTiffEntry";
+    const buffer = "jupytergis:buffer";
+    const dissolve = "jupytergis:dissolve";
     const newRasterSource = "jupytergis:newRasterSource";
     const newRasterDemSource = "jupytergis:newRasterDemSource";
     const newVectorSource = "jupytergis:newVectorSource";
@@ -48,6 +50,7 @@ export declare namespace CommandIDs {
     const selectCompleter = "jupytergis:selectConsoleCompleter";
     const addAnnotation = "jupytergis:addAnnotation";
     const zoomToLayer = "jupytergis:zoomToLayer";
+    const downloadGeoJSON = "jupytergis:downloadGeoJSON";
 }
 interface IRegisteredIcon {
     icon?: LabIcon;

package/lib/constants.js

@@ -21,6 +21,9 @@ export var CommandIDs;
     CommandIDs.newImageEntry = 'jupytergis:newImageEntry';
     CommandIDs.newVideoEntry = 'jupytergis:newVideoEntry';
     CommandIDs.newGeoTiffEntry = 'jupytergis:newGeoTiffEntry';
+    // Processing commands
+    CommandIDs.buffer = 'jupytergis:buffer';
+    CommandIDs.dissolve = 'jupytergis:dissolve';
     // Sources only commands
     CommandIDs.newRasterSource = 'jupytergis:newRasterSource';
     CommandIDs.newRasterDemSource = 'jupytergis:newRasterDemSource';
@@ -58,6 +61,7 @@ export var CommandIDs;
     // Map Commands
     CommandIDs.addAnnotation = 'jupytergis:addAnnotation';
     CommandIDs.zoomToLayer = 'jupytergis:zoomToLayer';
+    CommandIDs.downloadGeoJSON = 'jupytergis:downloadGeoJSON';
 })(CommandIDs || (CommandIDs = {}));
 const iconObject = {
     RasterSource: { icon: rasterIcon },

package/lib/dialogs/ProcessingFormDialog.d.ts

@@ -0,0 +1,30 @@
+import { IDict, IJupyterGISModel } from '@jupytergis/schema';
+import { Dialog } from '@jupyterlab/apputils';
+import { IBaseFormProps } from '../formbuilder/objectform/baseform';
+import { Signal } from '@lumino/signaling';
+import { PromiseDelegate } from '@lumino/coreutils';
+export interface IProcessingFormDialogOptions extends IBaseFormProps {
+    formContext: 'update' | 'create';
+    schema: IDict;
+    sourceData: IDict;
+    title: string;
+    syncData: (props: IDict) => void;
+    syncSelectedPropField?: (id: string | null, value: any, parentType: 'dialog' | 'panel') => void;
+    model: IJupyterGISModel;
+    processingType: 'Buffer' | 'Dissolve' | 'Export';
+}
+/**
+ * Wrapper component to handle OK button state
+ */
+export interface IProcessingFormWrapperProps extends IProcessingFormDialogOptions {
+    okSignalPromise: PromiseDelegate<Signal<Dialog<any>, number>>;
+    formErrorSignalPromise?: PromiseDelegate<Signal<Dialog<any>, boolean>>;
+}
+/**
+ * Dialog for processing operations
+ */
+export declare class ProcessingFormDialog extends Dialog<IDict> {
+    constructor(options: IProcessingFormDialogOptions);
+    resolve(index?: number): void;
+    private okSignal;
+}

package/lib/dialogs/ProcessingFormDialog.js

@@ -0,0 +1,109 @@
+import { Dialog } from '@jupyterlab/apputils';
+import * as React from 'react';
+import { BaseForm } from '../formbuilder/objectform/baseform';
+import { DissolveForm } from '../formbuilder/objectform/process';
+import { Signal } from '@lumino/signaling';
+import { PromiseDelegate } from '@lumino/coreutils';
+const ProcessingFormWrapper = (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);
+    });
+    let FormComponent;
+    switch (props.processingType) {
+        case 'Dissolve':
+            FormComponent = DissolveForm;
+            break;
+        case 'Buffer':
+        case 'Export':
+        default:
+            FormComponent = BaseForm;
+    }
+    return (ready && (React.createElement(FormComponent, { formContext: props.formContext, filePath: props.model.filePath, model: props.model, ok: okSignal.current, cancel: props.cancel, sourceData: props.sourceData, schema: props.schema, syncData: props.syncData })));
+};
+/**
+ * Dialog for processing operations
+ */
+export class ProcessingFormDialog extends Dialog {
+    constructor(options) {
+        var _a, _b, _c;
+        // Extract layers from the shared model
+        const layers = (_a = options.model.sharedModel.layers) !== null && _a !== void 0 ? _a : {};
+        const layerOptions = Object.keys(layers).map(layerId => ({
+            value: layerId,
+            label: layers[layerId].name
+        }));
+        // Modify schema to include layer options and layer name field
+        if (options.schema) {
+            if ((_b = options.schema.properties) === null || _b === void 0 ? void 0 : _b.inputLayer) {
+                options.schema.properties.inputLayer.enum = layerOptions.map(option => option.value);
+                options.schema.properties.inputLayer.enumNames = layerOptions.map(option => option.label);
+            }
+            // Ensure outputLayerName field exists in schema
+            if (!((_c = options.schema.properties) === null || _c === void 0 ? void 0 : _c.outputLayerName)) {
+                options.schema.properties.outputLayerName = {
+                    type: 'string',
+                    title: 'outputLayerName'
+                    // default: ''
+                };
+            }
+        }
+        const filePath = options.model.filePath;
+        const jgisModel = options.model;
+        const okSignalPromise = new PromiseDelegate();
+        const formErrorSignalPromise = new PromiseDelegate();
+        // Custom syncData function to update layer name in the model
+        const syncData = (props) => {
+            if (props.outputLayerName &&
+                props.inputLayer &&
+                layers[props.inputLayer]) {
+                layers[props.inputLayer].name = props.outputLayerName;
+            }
+            options.syncData(props);
+        };
+        const body = (React.createElement("div", { style: { overflow: 'hidden' } },
+            React.createElement(ProcessingFormWrapper, Object.assign({}, options, { filePath: filePath, model: jgisModel, okSignalPromise: okSignalPromise, formErrorSignalPromise: formErrorSignalPromise, syncData: syncData }))));
+        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-processing-FormDialog');
+    }
+    resolve(index) {
+        if (index === 0) {
+            super.resolve(index);
+        }
+        if (index === 1) {
+            this.okSignal.emit(1);
+        }
+    }
+}

package/lib/dialogs/layerBrowserDialog.js

@@ -5,7 +5,7 @@ import { PromiseDelegate, UUID } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import React, { useEffect, useState } from 'react';
 import CUSTOM_RASTER_IMAGE from '../../rasterlayer_gallery/custom_raster.png';
-import { CreationFormWrapper } from './formdialog';
+import { CreationFormWrapper } from './layerCreationFormDialog';
 export const LayerBrowserComponent = ({ model, registry, formSchemaRegistry, okSignalPromise, cancel }) => {
     const [searchTerm, setSearchTerm] = useState('');
     const [activeLayers, setActiveLayers] = useState([]);

package/lib/dialogs/{formdialog.d.ts → layerCreationFormDialog.d.ts}

@@ -29,7 +29,7 @@ export declare const CreationFormWrapper: (props: ICreationFormWrapperProps) =>
 /**
  * Form for creating a source, a layer or both at the same time
  */
-export declare class CreationFormDialog extends Dialog<IDict> {
+export declare class LayerCreationFormDialog extends Dialog<IDict> {
     constructor(options: ICreationFormDialogOptions);
     resolve(index?: number): void;
     private okSignal;

package/lib/dialogs/{formdialog.js → layerCreationFormDialog.js}

@@ -21,7 +21,7 @@ export const CreationFormWrapper = (props) => {
 /**
  * Form for creating a source, a layer or both at the same time
  */
-export class CreationFormDialog extends Dialog {
+export class LayerCreationFormDialog extends Dialog {
     constructor(options) {
         const cancelCallback = () => {
             this.resolve(0);

package/lib/dialogs/symbology/hooks/useGetBandInfo.js

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react';
-import { fromUrl } from 'geotiff';
+import { fromUrl, fromBlob } from 'geotiff';
+import { loadFile } from '../../../tools';
 const useGetBandInfo = (model, layer) => {
     const [bandRows, setBandRows] = useState([]);
     const [loading, setLoading] = useState(false);
@@ -17,8 +18,26 @@ const useGetBandInfo = (model, layer) => {
                 setLoading(false);
                 return;
             }
-            // TODO Get band names + get band stats
-            const tiff = await fromUrl(sourceInfo.url);
+            let tiff;
+            if (sourceInfo.url.startsWith('http') ||
+                sourceInfo.url.startsWith('https')) {
+                // Handle remote GeoTIFF file
+                tiff = await fromUrl(sourceInfo.url);
+            }
+            else {
+                // Handle local GeoTIFF file
+                const preloadedFile = await loadFile({
+                    filepath: sourceInfo.url,
+                    type: 'GeoTiffSource',
+                    model
+                });
+                if (!preloadedFile.file) {
+                    setError('Failed to load local file.');
+                    setLoading(false);
+                    return;
+                }
+                tiff = await fromBlob(preloadedFile.file);
+            }
             const image = await tiff.getImage();
             const numberOfBands = image.getSamplesPerPixel();
             for (let i = 0; i < numberOfBands; i++) {

package/lib/formbuilder/formselectors.d.ts

@@ -1,5 +1,5 @@
 import { LayerType, SourceType } from '@jupytergis/schema';
-import { BaseForm } from './objectform/baseform';
-import { LayerPropertiesForm } from './objectform/layerform';
+import { SourcePropertiesForm } from './objectform/source';
+import { LayerPropertiesForm } from './objectform/layer';
 export declare function getLayerTypeForm(layerType: LayerType): typeof LayerPropertiesForm;
-export declare function getSourceTypeForm(sourceType: SourceType): typeof BaseForm;
+export declare function getSourceTypeForm(sourceType: SourceType): typeof SourcePropertiesForm;

package/lib/formbuilder/formselectors.js

@@ -1,13 +1,5 @@
-import { BaseForm } from './objectform/baseform';
-import { GeoJSONSourcePropertiesForm } from './objectform/geojsonsource';
-import { GeoTiffSourcePropertiesForm } from './objectform/geotiffsource';
-import { HeatmapLayerPropertiesForm } from './objectform/heatmapLayerForm';
-import { HillshadeLayerPropertiesForm } from './objectform/hillshadeLayerForm';
-import { LayerPropertiesForm } from './objectform/layerform';
-import { PathBasedSourcePropertiesForm } from './objectform/pathbasedsource';
-import { TileSourcePropertiesForm } from './objectform/tilesourceform';
-import { VectorLayerPropertiesForm } from './objectform/vectorlayerform';
-import { WebGlLayerPropertiesForm } from './objectform/webGlLayerForm';
+import { GeoJSONSourcePropertiesForm, GeoTiffSourcePropertiesForm, PathBasedSourcePropertiesForm, TileSourcePropertiesForm, SourcePropertiesForm } from './objectform/source';
+import { HeatmapLayerPropertiesForm, HillshadeLayerPropertiesForm, LayerPropertiesForm, VectorLayerPropertiesForm, WebGlLayerPropertiesForm } from './objectform/layer';
 export function getLayerTypeForm(layerType) {
     let LayerForm = LayerPropertiesForm;
     switch (layerType) {
@@ -28,7 +20,7 @@ export function getLayerTypeForm(layerType) {
     return LayerForm;
 }
 export function getSourceTypeForm(sourceType) {
-    let SourceForm = BaseForm;
+    let SourceForm = SourcePropertiesForm;
     switch (sourceType) {
         case 'GeoJSONSource':
             SourceForm = GeoJSONSourcePropertiesForm;

package/lib/formbuilder/index.d.ts

@@ -1,6 +1,4 @@
 export * from './objectform/baseform';
-export * from './objectform/geojsonsource';
-export * from './objectform/layerform';
-export * from './objectform/tilesourceform';
-export * from './objectform/vectorlayerform';
+export * from './objectform/source';
+export * from './objectform/layer';
 export * from './creationform';

package/lib/formbuilder/index.js

@@ -1,6 +1,4 @@
 export * from './objectform/baseform';
-export * from './objectform/geojsonsource';
-export * from './objectform/layerform';
-export * from './objectform/tilesourceform';
-export * from './objectform/vectorlayerform';
+export * from './objectform/source';
+export * from './objectform/layer';
 export * from './creationform';

package/lib/formbuilder/objectform/baseform.d.ts

@@ -1,4 +1,4 @@
-import { IJupyterGISModel, SourceType } from '@jupytergis/schema';
+import { IJupyterGISModel } from '@jupytergis/schema';
 import { Dialog } from '@jupyterlab/apputils';
 import { Signal } from '@lumino/signaling';
 import { IChangeEvent, ISubmitEvent } from '@rjsf/core';
@@ -51,15 +51,6 @@ export interface IBaseFormProps {
      * extra errors or not.
      */
     formErrorSignal?: Signal<Dialog<any>, boolean>;
-    /**
-     * Configuration options for the dialog, including settings for layer data, source data,
-     * and other form-related parameters.
-     */
-    dialogOptions?: any;
-    /**
-     * Source type property
-     */
-    sourceType: SourceType;
 }
 /**
  * Generate a form to edit a layer/source type. This class is meant to be sub-classed to create more refined forms for specific layers/sources.

package/lib/formbuilder/objectform/baseform.js

@@ -186,7 +186,7 @@ export class BaseForm extends React.Component {
                             (_a = submitRef.current) === null || _a === void 0 ? void 0 : _a.click();
                         }
                     } },
-                    React.createElement(WrappedFormComponent, { schema: schema, uiSchema: uiSchema, formData: formData, onSubmit: this.onFormSubmit.bind(this), onChange: this.onFormChange.bind(this), onBlur: this.onFormBlur.bind(this), liveValidate: true, children: React.createElement("button", { ref: submitRef, type: "submit", style: { display: 'none' } }), extraErrors: this.state.extraErrors })),
+                    React.createElement(WrappedFormComponent, { schema: schema, uiSchema: uiSchema, formData: formData, onSubmit: this.onFormSubmit.bind(this), onChange: this.onFormChange.bind(this), onBlur: this.onFormBlur.bind(this), ok: this.props.ok, cancel: this.props.cancel, liveValidate: true, children: React.createElement("button", { ref: submitRef, type: "submit", style: { display: 'none' } }), extraErrors: this.state.extraErrors })),
                 !this.props.ok && (React.createElement("div", { className: "jGIS-property-buttons" },
                     React.createElement("button", { className: "jp-Dialog-button jp-mod-accept jp-mod-styled", onClick: () => { var _a; return (_a = submitRef.current) === null || _a === void 0 ? void 0 : _a.click(); } },
                         React.createElement("div", { className: "jp-Dialog-buttonLabel" }, "Ok"))))));

package/lib/formbuilder/objectform/fileselectorwidget.js

@@ -1,7 +1,7 @@
 import React, { useState, useEffect, useRef } from 'react';
 import { FileDialog } from '@jupyterlab/filebrowser';
 import { Dialog } from '@jupyterlab/apputils';
-import { CreationFormDialog } from '../../dialogs/formdialog';
+import { LayerCreationFormDialog } from '../../dialogs/layerCreationFormDialog';
 import { PathExt } from '@jupyterlab/coreutils';
 export const FileSelectorWidget = (props) => {
     const { options } = props;
@@ -53,13 +53,13 @@ export const FileSelectorWidget = (props) => {
                     else {
                         formOptions.dialogOptions.sourceData = Object.assign(Object.assign({}, formOptions.sourceData), { path: relativePath });
                     }
-                    const formDialog = new CreationFormDialog(Object.assign({}, formOptions.dialogOptions));
+                    const formDialog = new LayerCreationFormDialog(Object.assign({}, formOptions.dialogOptions));
                     await formDialog.launch();
                 }
             }
             else {
                 if (dialogElement) {
-                    const formDialog = new CreationFormDialog(Object.assign({}, formOptions.dialogOptions));
+                    const formDialog = new LayerCreationFormDialog(Object.assign({}, formOptions.dialogOptions));
                     await formDialog.launch();
                 }
             }

package/lib/formbuilder/objectform/{heatmapLayerForm.js → layer/heatmapLayerForm.js}

@@ -1,4 +1,4 @@
-import { loadFile } from '../../tools';
+import { loadFile } from '../../../tools';
 import { LayerPropertiesForm } from './layerform';
 export class HeatmapLayerPropertiesForm extends LayerPropertiesForm {
     constructor(props) {

package/lib/formbuilder/objectform/layer/index.d.ts

@@ -0,0 +1,5 @@
+export * from './heatmapLayerForm';
+export * from './hillshadeLayerForm';
+export * from './layerform';
+export * from './vectorlayerform';
+export * from './webGlLayerForm';

package/lib/formbuilder/objectform/layer/index.js

@@ -0,0 +1,5 @@
+export * from './heatmapLayerForm';
+export * from './hillshadeLayerForm';
+export * from './layerform';
+export * from './vectorlayerform';
+export * from './webGlLayerForm';

package/lib/formbuilder/objectform/{layerform.d.ts → layer/layerform.d.ts}

@@ -1,5 +1,5 @@
 import { IDict, SourceType } from '@jupytergis/schema';
-import { BaseForm, IBaseFormProps } from './baseform';
+import { BaseForm, IBaseFormProps } from '../baseform';
 import { Signal } from '@lumino/signaling';
 import { IChangeEvent } from '@rjsf/core';
 export interface ILayerProps extends IBaseFormProps {
@@ -11,6 +11,11 @@ export interface ILayerProps extends IBaseFormProps {
      * The signal emitted when the attached source form has changed, if it exists
      */
     sourceFormChangedSignal?: Signal<any, IDict<any>>;
+    /**
+     * Configuration options for the dialog, including settings for layer data, source data,
+     * and other form-related parameters.
+     */
+    dialogOptions?: any;
 }
 export declare class LayerPropertiesForm extends BaseForm {
     props: ILayerProps;

package/lib/formbuilder/objectform/{layerform.js → layer/layerform.js}

@@ -1,4 +1,4 @@
-import { BaseForm } from './baseform';
+import { BaseForm } from '../baseform';
 export class LayerPropertiesForm extends BaseForm {
     constructor(props) {
         super(props);

package/lib/formbuilder/objectform/process/dissolveProcessForm.d.ts

@@ -0,0 +1,20 @@
+import { BaseForm, IBaseFormProps } from '../baseform';
+import { IDict, IJupyterGISModel } from '@jupytergis/schema';
+import { IChangeEvent } from '@rjsf/core';
+interface IDissolveFormOptions extends IBaseFormProps {
+    schema: IDict;
+    sourceData: IDict;
+    title: string;
+    cancelButton: (() => void) | boolean;
+    syncData: (props: IDict) => void;
+    model: IJupyterGISModel;
+}
+export declare class DissolveForm extends BaseForm {
+    private model;
+    private features;
+    constructor(options: IDissolveFormOptions);
+    private fetchFieldNames;
+    handleFormChange(e: IChangeEvent): void;
+    private updateSchema;
+}
+export {};

package/lib/formbuilder/objectform/process/dissolveProcessForm.js

@@ -0,0 +1,62 @@
+import { BaseForm } from '../baseform'; // Ensure BaseForm imports states
+import { loadFile } from '../../../tools';
+export class DissolveForm extends BaseForm {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.features = [];
+        this.model = options.model;
+        // Ensure initial state matches IBaseFormStates
+        this.state = {
+            schema: (_a = options.schema) !== null && _a !== void 0 ? _a : {} // Ensure schema is never undefined
+        };
+        this.onFormChange = this.handleFormChange.bind(this);
+        this.fetchFieldNames(options.sourceData.inputLayer);
+    }
+    async fetchFieldNames(layerId) {
+        var _a, _b;
+        const layer = this.model.getLayer(layerId);
+        if (!((_a = layer === null || layer === void 0 ? void 0 : layer.parameters) === null || _a === void 0 ? void 0 : _a.source)) {
+            return;
+        }
+        const source = this.model.getSource(layer.parameters.source);
+        if (!source || source.type !== 'GeoJSONSource') {
+            return;
+        }
+        const sourceData = source.parameters;
+        if (!(sourceData === null || sourceData === void 0 ? void 0 : sourceData.path)) {
+            return;
+        }
+        try {
+            const jsonData = await loadFile({
+                filepath: sourceData.path,
+                type: 'GeoJSONSource',
+                model: this.model
+            });
+            if (!((_b = jsonData === null || jsonData === void 0 ? void 0 : jsonData.features) === null || _b === void 0 ? void 0 : _b.length)) {
+                return;
+            }
+            this.features = Object.keys(jsonData.features[0].properties);
+            this.updateSchema();
+        }
+        catch (error) {
+            console.error('Error loading GeoJSON:', error);
+        }
+    }
+    handleFormChange(e) {
+        super.onFormChange(e);
+        if (e.formData.inputLayer) {
+            this.fetchFieldNames(e.formData.inputLayer);
+        }
+    }
+    updateSchema() {
+        this.setState((prevState) => {
+            var _a, _b, _c;
+            return ({
+                schema: Object.assign(Object.assign({}, prevState.schema), { properties: Object.assign(Object.assign({}, (_a = prevState.schema) === null || _a === void 0 ? void 0 : _a.properties), { dissolveField: Object.assign(Object.assign({}, (_c = (_b = prevState.schema) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c.dissolveField), { enum: [...this.features] }) }) })
+            });
+        }, () => {
+            this.forceUpdate();
+        });
+    }
+}