@jupytergis/base 0.4.1 → 0.4.3

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

@@ -0,0 +1 @@
+export * from './dissolveProcessForm';

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

@@ -0,0 +1 @@
+export * from './dissolveProcessForm';

package/lib/formbuilder/objectform/{geojsonsource.d.ts → source/geojsonsource.d.ts}

@@ -1,12 +1,12 @@
 import { IDict } from '@jupytergis/schema';
-import { IBaseFormProps } from './baseform';
 import { PathBasedSourcePropertiesForm } from './pathbasedsource';
+import { ISourceFormProps } from './sourceform';
 /**
  * The form to modify a GeoJSON source.
  */
 export declare class GeoJSONSourcePropertiesForm extends PathBasedSourcePropertiesForm {
     private _validate;
-    constructor(props: IBaseFormProps);
+    constructor(props: ISourceFormProps);
     protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
     /**
      * Validate the path, to avoid invalid path or invalid GeoJSON.

package/lib/formbuilder/objectform/{geojsonsource.js → source/geojsonsource.js}

@@ -1,7 +1,7 @@
 import { Ajv } from 'ajv';
 import * as geojson from '@jupytergis/schema/src/schema/geojson.json';
 import { PathBasedSourcePropertiesForm } from './pathbasedsource';
-import { loadFile } from '../../tools';
+import { loadFile } from '../../../tools';
 /**
  * The form to modify a GeoJSON source.
  */

package/lib/formbuilder/objectform/{geotiffsource.d.ts → source/geotiffsource.d.ts}

@@ -1,12 +1,12 @@
 import { IDict } from '@jupytergis/schema';
 import { IChangeEvent, ISubmitEvent } from '@rjsf/core';
-import { BaseForm, IBaseFormProps } from './baseform';
+import { ISourceFormProps, SourcePropertiesForm } from './sourceform';
 /**
  * The form to modify a GeoTiff source.
  */
-export declare class GeoTiffSourcePropertiesForm extends BaseForm {
+export declare class GeoTiffSourcePropertiesForm extends SourcePropertiesForm {
     private _isSubmitted;
-    constructor(props: IBaseFormProps);
+    constructor(props: ISourceFormProps);
     protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
     protected onFormChange(e: IChangeEvent): void;
     protected onFormBlur(id: string, value: any): void;

package/lib/formbuilder/objectform/{geotiffsource.js → source/geotiffsource.js}

@@ -1,10 +1,11 @@
 import { showErrorMessage } from '@jupyterlab/apputils';
-import { BaseForm } from './baseform';
-import { getMimeType } from '../../tools';
+import { getMimeType } from '../../../tools';
+import { SourcePropertiesForm } from './sourceform';
+import { FileSelectorWidget } from '../fileselectorwidget';
 /**
  * The form to modify a GeoTiff source.
  */
-export class GeoTiffSourcePropertiesForm extends BaseForm {
+export class GeoTiffSourcePropertiesForm extends SourcePropertiesForm {
     constructor(props) {
         var _a, _b;
         super(props);
@@ -12,10 +13,22 @@ export class GeoTiffSourcePropertiesForm extends BaseForm {
         this._validateUrls((_b = (_a = props.sourceData) === null || _a === void 0 ? void 0 : _a.urls) !== null && _b !== void 0 ? _b : []);
     }
     processSchema(data, schema, uiSchema) {
+        var _a;
         super.processSchema(data, schema, uiSchema);
         if (!schema.properties || !data) {
             return;
         }
+        // Customize the widget for urls
+        if (schema.properties && schema.properties.urls) {
+            const docManager = (_a = this.props.formChangedSignal) === null || _a === void 0 ? void 0 : _a.sender.props.formSchemaRegistry.getDocManager();
+            uiSchema.urls = Object.assign(Object.assign({}, uiSchema.urls), { items: Object.assign(Object.assign({}, uiSchema.urls.items), { url: {
+                        'ui:widget': FileSelectorWidget,
+                        'ui:options': {
+                            docManager,
+                            formOptions: this.props
+                        }
+                    } }) });
+        }
         // This is not user-editable
         delete schema.properties.valid;
     }

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

@@ -0,0 +1,5 @@
+export * from './geojsonsource';
+export * from './geotiffsource';
+export * from './pathbasedsource';
+export * from './sourceform';
+export * from './tilesourceform';

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

@@ -0,0 +1,5 @@
+export * from './geojsonsource';
+export * from './geotiffsource';
+export * from './pathbasedsource';
+export * from './sourceform';
+export * from './tilesourceform';

package/lib/formbuilder/objectform/{pathbasedsource.d.ts → source/pathbasedsource.d.ts}

@@ -1,11 +1,11 @@
 import { IDict } from '@jupytergis/schema';
 import { IChangeEvent, ISubmitEvent } from '@rjsf/core';
-import { BaseForm, IBaseFormProps } from './baseform';
+import { ISourceFormProps, SourcePropertiesForm } from './sourceform';
 /**
  * The form to modify a PathBasedSource source.
  */
-export declare class PathBasedSourcePropertiesForm extends BaseForm {
-    constructor(props: IBaseFormProps);
+export declare class PathBasedSourcePropertiesForm extends SourcePropertiesForm {
+    constructor(props: ISourceFormProps);
     protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
     protected onFormBlur(id: string, value: any): void;
     protected onFormChange(e: IChangeEvent): void;

package/lib/formbuilder/objectform/{pathbasedsource.js → source/pathbasedsource.js}

@@ -1,11 +1,11 @@
 import { showErrorMessage } from '@jupyterlab/apputils';
-import { BaseForm } from './baseform';
-import { loadFile } from '../../tools';
-import { FileSelectorWidget } from './fileselectorwidget';
+import { loadFile } from '../../../tools';
+import { FileSelectorWidget } from '../fileselectorwidget';
+import { SourcePropertiesForm } from './sourceform';
 /**
  * The form to modify a PathBasedSource source.
  */
-export class PathBasedSourcePropertiesForm extends BaseForm {
+export class PathBasedSourcePropertiesForm extends SourcePropertiesForm {
     constructor(props) {
         var _a, _b;
         super(props);

package/lib/formbuilder/objectform/source/sourceform.d.ts

@@ -0,0 +1,24 @@
+import { IDict, SourceType } from '@jupytergis/schema';
+import { BaseForm, IBaseFormProps } from '../baseform';
+import { Signal } from '@lumino/signaling';
+import { IChangeEvent } from '@rjsf/core';
+export interface ISourceFormProps extends IBaseFormProps {
+    /**
+     * The source type for this form.
+     */
+    sourceType: SourceType;
+    /**
+     * The signal emitted when the source form has changed.
+     */
+    sourceFormChangedSignal?: Signal<any, IDict<any>>;
+    /**
+     * Configuration options for the dialog, including settings for source data and other parameters.
+     */
+    dialogOptions?: any;
+}
+export declare class SourcePropertiesForm extends BaseForm {
+    props: ISourceFormProps;
+    protected sourceFormChangedSignal: Signal<any, IDict<any>> | undefined;
+    constructor(props: ISourceFormProps);
+    protected onFormChange(e: IChangeEvent): void;
+}

package/lib/formbuilder/objectform/source/sourceform.js

@@ -0,0 +1,13 @@
+import { BaseForm } from '../baseform';
+export class SourcePropertiesForm extends BaseForm {
+    constructor(props) {
+        super(props);
+        this.sourceFormChangedSignal = props.sourceFormChangedSignal;
+    }
+    onFormChange(e) {
+        super.onFormChange(e);
+        if (this.props.dialogOptions) {
+            this.props.dialogOptions.sourceData = Object.assign({}, e.formData);
+        }
+    }
+}

package/lib/formbuilder/objectform/{tilesourceform.d.ts → source/tilesourceform.d.ts}

@@ -1,6 +1,6 @@
 import { IDict } from '@jupytergis/schema';
-import { BaseForm } from './baseform';
-export declare class TileSourcePropertiesForm extends BaseForm {
+import { SourcePropertiesForm } from './sourceform';
+export declare class TileSourcePropertiesForm extends SourcePropertiesForm {
     private _urlParameters;
     protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
     protected onFormBlur(id: string, value: any): void;

package/lib/formbuilder/objectform/{tilesourceform.js → source/tilesourceform.js}

@@ -1,5 +1,5 @@
-import { BaseForm } from './baseform';
-export class TileSourcePropertiesForm extends BaseForm {
+import { SourcePropertiesForm } from './sourceform';
+export class TileSourcePropertiesForm extends SourcePropertiesForm {
     constructor() {
         super(...arguments);
         this._urlParameters = [];

package/lib/index.d.ts

@@ -1,7 +1,7 @@
 export * from './classificationModes';
 export * from './commands';
 export * from './constants';
-export * from './dialogs/formdialog';
+export * from './dialogs/layerCreationFormDialog';
 export * from './formbuilder/objectform/baseform';
 export * from './icons';
 export * from './mainview';

package/lib/index.js

@@ -1,7 +1,7 @@
 export * from './classificationModes';
 export * from './commands';
 export * from './constants';
-export * from './dialogs/formdialog';
+export * from './dialogs/layerCreationFormDialog';
 export * from './formbuilder/objectform/baseform';
 export * from './icons';
 export * from './mainview';

package/lib/keybindings.json

@@ -14,6 +14,11 @@
         "keys": ["Escape"],
         "selector": ".data-jgis-keybinding"
     },
+    {
+        "command": "jupytergis:identify",
+        "keys": ["I"],
+        "selector": ".data-jgis-keybinding"
+    },
     {
         "command": "jupytergis:removeSource",
         "keys": ["Delete"],

package/lib/mainview/mainView.js

@@ -311,7 +311,7 @@ export class MainView extends React.Component {
                 if (this._model.getClientId() === clientId) {
                     return;
                 }
-                const clientPointers = this.state.clientPointers;
+                const clientPointers = Object.assign({}, this.state.clientPointers);
                 let currentClientPointer = clientPointers[clientId];
                 if (pointer) {
                     const pixel = this._Map.getPixelFromCoordinate([
@@ -320,7 +320,7 @@ export class MainView extends React.Component {
                     ]);
                     const lonLat = toLonLat([pointer.coordinates.x, pointer.coordinates.y]);
                     if (!currentClientPointer) {
-                        currentClientPointer = clientPointers[clientId] = {
+                        currentClientPointer = {
                             username: client.user.username,
                             displayName: client.user.display_name,
                             color: client.user.color,
@@ -328,14 +328,15 @@ export class MainView extends React.Component {
                             lonLat: { longitude: lonLat[0], latitude: lonLat[1] }
                         };
                     }
-                    currentClientPointer.coordinates.x = pixel[0];
-                    currentClientPointer.coordinates.y = pixel[1];
+                    else {
+                        currentClientPointer = Object.assign(Object.assign({}, currentClientPointer), { coordinates: { x: pixel[0], y: pixel[1] }, lonLat: { longitude: lonLat[0], latitude: lonLat[1] } });
+                    }
                     clientPointers[clientId] = currentClientPointer;
                 }
                 else {
                     delete clientPointers[clientId];
                 }
-                this.setState(old => (Object.assign(Object.assign({}, old), { clientPointers: clientPointers })));
+                this.setState(old => (Object.assign(Object.assign({}, old), { clientPointers })));
             });
             // Temporal controller bit
             // ? There's probably a better way to get changes in the model to trigger react rerenders
@@ -575,9 +576,6 @@ export class MainView extends React.Component {
      */
     async addSource(id, source) {
         var _a, _b;
-        const rasterSourceCommon = {
-            interpolate: false
-        };
         let newSource;
         switch (source.type) {
             case 'RasterSource': {
@@ -585,16 +583,32 @@ export class MainView extends React.Component {
                 const pmTiles = sourceParameters.url.endsWith('.pmtiles');
                 const url = this.computeSourceUrl(source);
                 if (!pmTiles) {
-                    newSource = new XYZSource(Object.assign(Object.assign({}, rasterSourceCommon), { attributions: sourceParameters.attribution, minZoom: sourceParameters.minZoom, maxZoom: sourceParameters.maxZoom, tileSize: 256, url: url }));
+                    newSource = new XYZSource({
+                        interpolate: sourceParameters.interpolate,
+                        attributions: sourceParameters.attribution,
+                        minZoom: sourceParameters.minZoom,
+                        maxZoom: sourceParameters.maxZoom,
+                        tileSize: 256,
+                        url: url
+                    });
                 }
                 else {
-                    newSource = new PMTilesRasterSource(Object.assign(Object.assign({}, rasterSourceCommon), { attributions: sourceParameters.attribution, tileSize: 256, url: url }));
+                    newSource = new PMTilesRasterSource({
+                        interpolate: sourceParameters.interpolate,
+                        attributions: sourceParameters.attribution,
+                        tileSize: 256,
+                        url: url
+                    });
                 }
                 break;
             }
             case 'RasterDemSource': {
                 const sourceParameters = source.parameters;
-                newSource = new ImageTileSource(Object.assign(Object.assign({}, rasterSourceCommon), { url: this.computeSourceUrl(source), attributions: sourceParameters.attribution }));
+                newSource = new ImageTileSource({
+                    interpolate: sourceParameters.interpolate,
+                    url: this.computeSourceUrl(source),
+                    attributions: sourceParameters.attribution
+                });
                 break;
             }
             case 'VectorTileSource': {
@@ -681,7 +695,12 @@ export class MainView extends React.Component {
                     type: 'ImageSource',
                     model: this._model
                 });
-                newSource = new Static(Object.assign(Object.assign({}, rasterSourceCommon), { imageExtent: extent, url: imageUrl, crossOrigin: '' }));
+                newSource = new Static({
+                    interpolate: sourceParameters.interpolate,
+                    imageExtent: extent,
+                    url: imageUrl,
+                    crossOrigin: ''
+                });
                 break;
             }
             case 'VideoSource': {
@@ -694,9 +713,27 @@ export class MainView extends React.Component {
                     return Object.assign(Object.assign({}, url), { nodata: 0 });
                 };
                 const sources = await Promise.all(sourceParameters.urls.map(async (sourceInfo) => {
-                    return Object.assign(Object.assign({}, addNoData(sourceInfo)), { min: sourceInfo.min, max: sourceInfo.max, url: sourceInfo.url });
+                    var _a, _b, _c;
+                    const isRemote = ((_a = sourceInfo.url) === null || _a === void 0 ? void 0 : _a.startsWith('http://')) ||
+                        ((_b = sourceInfo.url) === null || _b === void 0 ? void 0 : _b.startsWith('https://'));
+                    if (isRemote) {
+                        return Object.assign(Object.assign({}, addNoData(sourceInfo)), { min: sourceInfo.min, max: sourceInfo.max, url: sourceInfo.url });
+                    }
+                    else {
+                        const geotiff = await loadFile({
+                            filepath: (_c = sourceInfo.url) !== null && _c !== void 0 ? _c : '',
+                            type: 'GeoTiffSource',
+                            model: this._model
+                        });
+                        return Object.assign(Object.assign({}, addNoData(sourceInfo)), { min: sourceInfo.min, max: sourceInfo.max, geotiff, url: URL.createObjectURL(geotiff.file) });
+                    }
                 }));
-                newSource = new GeoTIFFSource(Object.assign(Object.assign({}, rasterSourceCommon), { sources, normalize: sourceParameters.normalize, wrapX: sourceParameters.wrapX }));
+                newSource = new GeoTIFFSource({
+                    interpolate: sourceParameters.interpolate,
+                    sources,
+                    normalize: sourceParameters.normalize,
+                    wrapX: sourceParameters.wrapX
+                });
                 break;
             }
         }
@@ -1382,7 +1419,7 @@ export class MainView extends React.Component {
             }),
             React.createElement("div", { className: "jGIS-Mainview-Container" },
                 this.state.displayTemporalController && (React.createElement(TemporalSlider, { model: this._model, filterStates: this.state.filterStates })),
-                React.createElement("div", { className: "jGIS-Mainview", style: {
+                React.createElement("div", { className: "jGIS-Mainview data-jgis-keybinding", tabIndex: -2, style: {
                         border: this.state.remoteUser
                             ? `solid 3px ${this.state.remoteUser.color}`
                             : 'unset'

package/lib/panelview/components/layers.js

@@ -12,7 +12,7 @@ const LAYER_ITEM_CLASS = 'jp-gis-layerItem';
 const LAYER_CLASS = 'jp-gis-layer';
 const LAYER_TITLE_CLASS = 'jp-gis-layerTitle';
 const LAYER_ICON_CLASS = 'jp-gis-layerIcon';
-const LAYER_TEXT_CLASS = 'jp-gis-layerText';
+const LAYER_TEXT_CLASS = 'jp-gis-layerText data-jgis-keybinding';
 /**
  * The layers panel widget.
  */
@@ -162,7 +162,7 @@ function LayerGroupComponent(props) {
     return (React.createElement("div", { className: `${LAYER_ITEM_CLASS} ${LAYER_GROUP_CLASS}`, draggable: true, onDragStart: Private.onDragStart, onDragEnd: Private.onDragEnd, "data-id": name },
         React.createElement("div", { onClick: handleExpand, onContextMenu: handleRightClick, className: `${LAYER_GROUP_HEADER_CLASS}${selected ? ' jp-mod-selected' : ''}`, onDragOver: Private.onDragOver, "data-id": name },
             React.createElement(LabIcon.resolveReact, { icon: caretDownIcon, className: `${LAYER_GROUP_COLLAPSER_CLASS}${open ? ' jp-mod-expanded' : ''}`, tag: 'span' }),
-            React.createElement("span", { id: id, className: LAYER_TEXT_CLASS }, name)),
+            React.createElement("span", { id: id, className: LAYER_TEXT_CLASS, tabIndex: -2 }, name)),
         open && (React.createElement("div", null, layers
             .slice()
             .reverse()
@@ -219,10 +219,10 @@ function LayerComponent(props) {
     };
     return (React.createElement("div", { className: `${LAYER_ITEM_CLASS} ${LAYER_CLASS}${selected ? ' jp-mod-selected' : ''}`, draggable: true, onDragStart: Private.onDragStart, onDragOver: Private.onDragOver, onDragEnd: Private.onDragEnd, "data-id": layerId },
         React.createElement("div", { className: LAYER_TITLE_CLASS, onClick: setSelection, onContextMenu: setSelection },
+            React.createElement(Button, { title: layer.visible ? 'Hide layer' : 'Show layer', onClick: toggleVisibility, minimal: true },
+                React.createElement(LabIcon.resolveReact, { icon: layer.visible ? visibilityIcon : nonVisibilityIcon, className: `${LAYER_ICON_CLASS}${layer.visible ? '' : ' jp-gis-mod-hidden'}`, tag: "span" })),
             icons.has(layer.type) && (React.createElement(LabIcon.resolveReact, Object.assign({}, icons.get(layer.type), { className: LAYER_ICON_CLASS }))),
-            React.createElement("span", { id: id, className: LAYER_TEXT_CLASS }, name)),
-        React.createElement(Button, { title: layer.visible ? 'Hide layer' : 'Show layer', onClick: toggleVisibility, minimal: true },
-            React.createElement(LabIcon.resolveReact, { icon: layer.visible ? visibilityIcon : nonVisibilityIcon, className: `${LAYER_ICON_CLASS}${layer.visible ? '' : ' jp-gis-mod-hidden'}`, tag: "span" }))));
+            React.createElement("span", { id: id, className: LAYER_TEXT_CLASS, tabIndex: -2 }, name))));
 }
 var Private;
 (function (Private) {

package/lib/panelview/leftpanel.d.ts

@@ -35,6 +35,7 @@ export declare class LeftPanelWidget extends SidePanel {
      */
     private _onSelect;
     resetSelected(type: SelectionType, nodeId?: string, item?: string): void;
+    private _notifyCommands;
     private _lastSelectedNodeId;
     private _model;
     private _state;

package/lib/panelview/leftpanel.js

@@ -51,10 +51,12 @@ 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._notifyCommands();
             }
         };
         this.addClass('jGIS-sidepanel-widget');
+        this.addClass('data-jgis-keybinding');
+        this.node.tabIndex = 0;
         this._model = options.model;
         this._state = options.state;
         this._commands = options.commands;
@@ -132,6 +134,11 @@ 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._notifyCommands();
+    }
+    _notifyCommands() {
+        // Notify commands that need updating
+        this._commands.notifyCommandChanged(CommandIDs.identify);
         this._commands.notifyCommandChanged(CommandIDs.temporalController);
     }
 }

package/lib/panelview/rightpanel.js

@@ -7,6 +7,8 @@ export class RightPanelWidget extends SidePanel {
     constructor(options) {
         super();
         this.addClass('jGIS-sidepanel-widget');
+        this.addClass('data-jgis-keybinding');
+        this.node.tabIndex = 0;
         this._model = options.model;
         this._annotationModel = options.annotationModel;
         const header = new ControlPanelHeader();

package/lib/processing.d.ts

@@ -0,0 +1,25 @@
+import { IDict, IJGISLayer, IJupyterGISModel, IJGISFormSchemaRegistry, LayerType } from '@jupytergis/schema';
+import { JupyterGISTracker } from './types';
+import { JupyterFrontEnd } from '@jupyterlab/application';
+/**
+ * Get the currently selected layer from the shared model. Returns null if there is no selection or multiple layer is selected.
+ */
+export declare function getSingleSelectedLayer(tracker: JupyterGISTracker): IJGISLayer | null;
+/**
+ * Check if the selected layer is of one of the specified types
+ */
+export declare function selectedLayerIsOfType(allowedTypes: LayerType[], tracker: JupyterGISTracker): boolean;
+/**
+ * Extract GeoJSON from selected layer's source
+ */
+export declare function getLayerGeoJSON(layer: IJGISLayer, sources: IDict, model: IJupyterGISModel): Promise<string | null>;
+export type GdalFunctions = 'ogr2ogr' | 'gdal_rasterize' | 'gdalwarp' | 'gdal_translate';
+/**
+ * Generalized processing function for Buffer & Dissolve
+ */
+export declare function processSelectedLayer(tracker: JupyterGISTracker, formSchemaRegistry: IJGISFormSchemaRegistry, processingType: 'Buffer' | 'Dissolve', processingOptions: {
+    sqlQueryFn: (layerName: string, param: any) => string;
+    gdalFunction: GdalFunctions;
+    options: (sqlQuery: string) => string[];
+}, app: JupyterFrontEnd): Promise<void>;
+export declare function executeSQLProcessing(model: IJupyterGISModel, geojsonString: string, gdalFunction: GdalFunctions, options: string[], layerNamePrefix: string, processingType: 'Buffer' | 'Dissolve', embedOutputLayer: boolean, tracker: JupyterGISTracker, app: JupyterFrontEnd): Promise<void>;

package/lib/processing.js

@@ -0,0 +1,177 @@
+import { getGdal } from './gdal';
+import { UUID } from '@lumino/coreutils';
+import { ProcessingFormDialog } from './dialogs/ProcessingFormDialog';
+import { getGeoJSONDataFromLayerSource } from './tools';
+/**
+ * Get the currently selected layer from the shared model. Returns null if there is no selection or multiple layer is selected.
+ */
+export function getSingleSelectedLayer(tracker) {
+    var _a, _b, _c;
+    const model = (_a = tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model;
+    if (!model) {
+        return null;
+    }
+    const localState = model.sharedModel.awareness.getLocalState();
+    if (!localState || !((_b = localState['selected']) === null || _b === void 0 ? void 0 : _b.value)) {
+        return null;
+    }
+    const selectedLayers = Object.keys(localState['selected'].value);
+    // Ensure only one layer is selected
+    if (selectedLayers.length !== 1) {
+        return null;
+    }
+    const selectedLayerId = selectedLayers[0];
+    const layers = (_c = model.sharedModel.layers) !== null && _c !== void 0 ? _c : {};
+    const selectedLayer = layers[selectedLayerId];
+    return selectedLayer && selectedLayer.parameters ? selectedLayer : null;
+}
+/**
+ * Check if the selected layer is of one of the specified types
+ */
+export function selectedLayerIsOfType(allowedTypes, tracker) {
+    const selectedLayer = getSingleSelectedLayer(tracker);
+    return selectedLayer ? allowedTypes.includes(selectedLayer.type) : false;
+}
+/**
+ * Extract GeoJSON from selected layer's source
+ */
+export async function getLayerGeoJSON(layer, sources, model) {
+    if (!layer.parameters || !layer.parameters.source) {
+        console.error('Selected layer does not have a valid source.');
+        return null;
+    }
+    const source = sources[layer.parameters.source];
+    if (!source || !source.parameters) {
+        console.error(`Source with ID ${layer.parameters.source} not found or missing path.`);
+        return null;
+    }
+    return await getGeoJSONDataFromLayerSource(source, model);
+}
+/**
+ * Generalized processing function for Buffer & Dissolve
+ */
+export async function processSelectedLayer(tracker, formSchemaRegistry, processingType, processingOptions, app) {
+    var _a, _b, _c;
+    const selected = getSingleSelectedLayer(tracker);
+    if (!selected || !tracker.currentWidget) {
+        return;
+    }
+    const model = tracker.currentWidget.model;
+    const sources = (_a = model === null || model === void 0 ? void 0 : model.sharedModel.sources) !== null && _a !== void 0 ? _a : {};
+    const geojsonString = await getLayerGeoJSON(selected, sources, model);
+    if (!geojsonString) {
+        return;
+    }
+    const schema = Object.assign({}, formSchemaRegistry.getSchemas().get(processingType));
+    const selectedLayerId = Object.keys(((_c = (_b = model === null || model === void 0 ? void 0 : model.sharedModel.awareness.getLocalState()) === null || _b === void 0 ? void 0 : _b.selected) === null || _c === void 0 ? void 0 : _c.value) || {})[0];
+    // Open ProcessingFormDialog
+    const formValues = await new Promise(resolve => {
+        const dialog = new ProcessingFormDialog({
+            title: processingType.charAt(0).toUpperCase() + processingType.slice(1),
+            schema,
+            model,
+            sourceData: {
+                inputLayer: selectedLayerId,
+                outputLayerName: selected.name
+            },
+            formContext: 'create',
+            processingType,
+            syncData: (props) => {
+                resolve(props);
+                dialog.dispose();
+            }
+        });
+        dialog.launch();
+    });
+    if (!formValues) {
+        return;
+    }
+    let processParam;
+    switch (processingType) {
+        case 'Buffer':
+            processParam = formValues.bufferDistance;
+            break;
+        case 'Dissolve':
+            processParam = formValues.dissolveField;
+            break;
+        default:
+            console.error(`Unsupported processing type: ${processingType}`);
+            return;
+    }
+    const embedOutputLayer = formValues.embedOutputLayer;
+    const fileBlob = new Blob([geojsonString], {
+        type: 'application/geo+json'
+    });
+    const geoFile = new File([fileBlob], 'data.geojson', {
+        type: 'application/geo+json'
+    });
+    const Gdal = await getGdal();
+    const result = await Gdal.open(geoFile);
+    const dataset = result.datasets[0];
+    const layerName = dataset.info.layers[0].name;
+    const sqlQuery = processingOptions.sqlQueryFn(layerName, processParam);
+    const fullOptions = processingOptions.options(sqlQuery);
+    await executeSQLProcessing(model, geojsonString, processingOptions.gdalFunction, fullOptions, formValues.outputLayerName, processingType, embedOutputLayer, tracker, app);
+}
+export async function executeSQLProcessing(model, geojsonString, gdalFunction, options, layerNamePrefix, processingType, embedOutputLayer, tracker, app) {
+    var _a;
+    const geoFile = new File([new Blob([geojsonString], { type: 'application/geo+json' })], 'data.geojson', { type: 'application/geo+json' });
+    const Gdal = await getGdal();
+    const result = await Gdal.open(geoFile);
+    if (result.datasets.length === 0) {
+        return;
+    }
+    const dataset = result.datasets[0];
+    const outputFilePath = await Gdal[gdalFunction](dataset, options);
+    const processedBytes = await Gdal.getFileBytes(outputFilePath);
+    const processedGeoJSONString = new TextDecoder().decode(processedBytes);
+    Gdal.close(dataset);
+    if (!embedOutputLayer) {
+        // Save the output as a file
+        const jgisFilePath = (_a = tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model.filePath;
+        const jgisDir = jgisFilePath
+            ? jgisFilePath.substring(0, jgisFilePath.lastIndexOf('/'))
+            : '';
+        const outputFileName = `${layerNamePrefix}_${processingType}.json`;
+        const savePath = jgisDir ? `${jgisDir}/${outputFileName}` : outputFileName;
+        await app.serviceManager.contents.save(savePath, {
+            type: 'file',
+            format: 'text',
+            content: processedGeoJSONString
+        });
+        const newSourceId = UUID.uuid4();
+        const sourceModel = {
+            type: 'GeoJSONSource',
+            name: outputFileName,
+            parameters: {
+                path: outputFileName
+            }
+        };
+        const layerModel = {
+            type: 'VectorLayer',
+            parameters: { source: newSourceId },
+            visible: true,
+            name: outputFileName
+        };
+        model.sharedModel.addSource(newSourceId, sourceModel);
+        model.addLayer(UUID.uuid4(), layerModel);
+    }
+    else {
+        // Embed the output directly into the model
+        const processedGeoJSON = JSON.parse(processedGeoJSONString);
+        const newSourceId = UUID.uuid4();
+        const sourceModel = {
+            type: 'GeoJSONSource',
+            name: `${layerNamePrefix} ${processingType.charAt(0).toUpperCase() + processingType.slice(1)}`,
+            parameters: { data: processedGeoJSON }
+        };
+        const layerModel = {
+            type: 'VectorLayer',
+            parameters: { source: newSourceId },
+            visible: true,
+            name: `${layerNamePrefix} ${processingType.charAt(0).toUpperCase() + processingType.slice(1)}`
+        };
+        model.sharedModel.addSource(newSourceId, sourceModel);
+        model.addLayer(UUID.uuid4(), layerModel);
+    }
+}