@jupytergis/base 0.15.0 → 0.16.0-alpha.0

package/lib/{dialogs → features/layers}/symbology/symbologyDialog.d.ts

@@ -3,7 +3,7 @@ import { Dialog } from '@jupyterlab/apputils';
 import { IStateDB } from '@jupyterlab/statedb';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
-import { SymbologyTab, SymbologyValue } from "../../types";
+import { SymbologyTab, SymbologyValue } from "../../../types";
 export interface ISymbologyDialogProps {
     model: IJupyterGISModel;
     okSignalPromise: PromiseDelegate<Signal<SymbologyWidget, null>>;

package/lib/{dialogs → features/layers}/symbology/symbologyDialog.js

@@ -2,14 +2,14 @@ import { Dialog } from '@jupyterlab/apputils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import React, { useEffect, useState } from 'react';
-import TiffRendering from './tiff_layer/TiffRendering';
-import VectorRendering from './vector_layer/VectorRendering';
+import Grammar from './Grammar';
+import Heatmap from './Heatmap';
 const SymbologyDialog = ({ model, okSignalPromise, isStorySegmentOverride, segmentId, }) => {
     const [selectedLayer, setSelectedLayer] = useState(null);
     const [componentToRender, setComponentToRender] = useState(null);
     let LayerSymbology;
     useEffect(() => {
-        const handleClientStateChanged = () => {
+        const handleSelectedChanged = () => {
             var _a, _b;
             if (!((_b = (_a = model.localState) === null || _a === void 0 ? void 0 : _a.selected) === null || _b === void 0 ? void 0 : _b.value)) {
                 return;
@@ -18,10 +18,10 @@ const SymbologyDialog = ({ model, okSignalPromise, isStorySegmentOverride, segme
             setSelectedLayer(currentLayer);
         };
         // Initial state
-        handleClientStateChanged();
-        model.clientStateChanged.connect(handleClientStateChanged);
+        handleSelectedChanged();
+        model.selectedChanged.connect(handleSelectedChanged);
         return () => {
-            model.clientStateChanged.disconnect(handleClientStateChanged);
+            model.selectedChanged.disconnect(handleSelectedChanged);
         };
     }, []);
     useEffect(() => {
@@ -32,15 +32,15 @@ const SymbologyDialog = ({ model, okSignalPromise, isStorySegmentOverride, segme
         if (!layer) {
             return;
         }
-        // TODO WebGlLayers can also be used for other layers, need a better way to determine source + layer combo
+        // TODO GeoTiffLayers can also be used for other layers, need a better way to determine source + layer combo
         switch (layer.type) {
-            case 'VectorLayer':
-            case 'VectorTileLayer':
             case 'HeatmapLayer':
-                LayerSymbology = (React.createElement(VectorRendering, { model: model, okSignalPromise: okSignalPromise, layerId: selectedLayer, isStorySegmentOverride: isStorySegmentOverride, segmentId: segmentId }));
+                LayerSymbology = (React.createElement(Heatmap, { model: model, okSignalPromise: okSignalPromise, layerId: selectedLayer, isStorySegmentOverride: isStorySegmentOverride, segmentId: segmentId }));
                 break;
-            case 'WebGlLayer':
-                LayerSymbology = (React.createElement(TiffRendering, { model: model, okSignalPromise: okSignalPromise, layerId: selectedLayer, isStorySegmentOverride: isStorySegmentOverride, segmentId: segmentId }));
+            case 'VectorLayer':
+            case 'VectorTileLayer':
+            case 'GeoTiffLayer':
+                LayerSymbology = (React.createElement(Grammar, { model: model, okSignalPromise: okSignalPromise, layerId: selectedLayer, isStorySegmentOverride: isStorySegmentOverride, segmentId: segmentId }));
                 break;
             default:
                 LayerSymbology = React.createElement("div", null, "Layer Type Not Supported");

package/lib/{dialogs → features/layers}/symbology/symbologyUtils.d.ts

@@ -1,10 +1,22 @@
-import { IJGISLayer, IJupyterGISModel, IVectorLayer, IWebGlLayer } from '@jupytergis/schema';
+import { IJGISLayer, IJupyterGISModel, IVectorLayer, IGeoTiffLayer } from '@jupytergis/schema';
 import { IColorMap } from './colorRampUtils';
 import { IStopRow } from './symbologyDialog';
-/** Payload when saving symbology; shape matches vector or WebGl layer params. */
+/**
+ * Payload when saving symbology. As of #698, only `symbologyState` is persisted
+ * for vector layers — the OpenLayers FlatStyle is derived at render time from
+ * `symbologyState` via `styleBuilder.buildVectorFlatStyle`. GeoTiff layers still
+ * accept an optional `color` because their `color` field is used for band-math
+ * expressions, not symbology duplication.
+ */
 export interface ISymbologyPayload {
-    symbologyState: IVectorLayer['symbologyState'] | IWebGlLayer['symbologyState'];
-    color?: IVectorLayer['color'] | IWebGlLayer['color'];
+    symbologyState: IVectorLayer['symbologyState'] | IGeoTiffLayer['symbologyState'];
+    /**
+     * Only used by GeoTiff band-math (`IGeoTiffLayer['color']`); never set for
+     * vector layers. Typed as `unknown` because the GeoTiff schema's color type
+     * is a nested numeric-array expression that doesn't round-trip cleanly
+     * through the JSON-schema generator.
+     */
+    color?: unknown;
 }
 export interface ISaveSymbologyOptions {
     model: IJupyterGISModel;
@@ -15,19 +27,15 @@ export interface ISaveSymbologyOptions {
     mutateLayerBeforeSave?: (layer: any) => void;
 }
 export type VectorSymbologyParams = Pick<IVectorLayer, 'symbologyState' | 'color'>;
-export type WebGlSymbologyParams = Pick<IWebGlLayer, 'symbologyState' | 'color'>;
+export type GeoTiffSymbologyParams = Pick<IGeoTiffLayer, 'symbologyState' | 'color'>;
 /** Params-shaped object used for reading symbology (layer.parameters or segment override). */
-export type IEffectiveSymbologyParams = VectorSymbologyParams | WebGlSymbologyParams;
+export type IEffectiveSymbologyParams = VectorSymbologyParams | GeoTiffSymbologyParams;
 /**
  * Resolve the effective symbology params for this dialog: either the layer's
  * parameters or the matching segment override when editing a story-segment override.
  */
 export declare function getEffectiveSymbologyParams(model: IJupyterGISModel, layerId: string, layer: IJGISLayer | null | undefined, isStorySegmentOverride?: boolean, segmentId?: string): IEffectiveSymbologyParams | null;
 export declare function saveSymbology(options: ISaveSymbologyOptions): void;
-export declare namespace VectorUtils {
-    const buildColorInfo: (layerParamers: VectorSymbologyParams) => IStopRow[];
-    const buildRadiusInfo: (layer: IJGISLayer) => IStopRow[];
-}
 export declare namespace Utils {
     const getValueColorPairs: (stops: number[], colorRamp: IColorMap, nClasses: number, reverse?: boolean) => IStopRow[];
 }

package/lib/{dialogs → features/layers}/symbology/symbologyUtils.js

@@ -1,7 +1,5 @@
 import { UUID } from '@lumino/coreutils';
 import colormap from 'colormap';
-import { findExprNode } from './colorRampUtils';
-const COLOR_EXPR_STOPS_START = 3;
 /**
  * Resolve the effective symbology params for this dialog: either the layer's
  * parameters or the matching segment override when editing a story-segment override.
@@ -73,88 +71,6 @@ export function saveSymbology(options) {
     }
     model.sharedModel.updateLayer(segmentId, segment);
 }
-export var VectorUtils;
-(function (VectorUtils) {
-    VectorUtils.buildColorInfo = (layerParamers) => {
-        // This it to parse a color object on the layer
-        if (!(layerParamers === null || layerParamers === void 0 ? void 0 : layerParamers.color)) {
-            return [];
-        }
-        const color = layerParamers.color;
-        // If color is a string we don't need to parse
-        if (typeof color === 'string') {
-            return [];
-        }
-        const keys = ['fill-color', 'circle-fill-color'];
-        const valueColorPairs = [];
-        const seenPairs = new Set();
-        for (const key of keys) {
-            if (!color[key]) {
-                continue;
-            }
-            const interpolate = findExprNode(color[key], 'interpolate');
-            if (interpolate) {
-                // Graduated: value:color pairs starting at index 3
-                for (let i = COLOR_EXPR_STOPS_START; i < interpolate.length; i += 2) {
-                    const pairKey = `${interpolate[i]}-${interpolate[i + 1]}`;
-                    if (!seenPairs.has(pairKey)) {
-                        valueColorPairs.push({
-                            id: UUID.uuid4(),
-                            stop: interpolate[i],
-                            output: interpolate[i + 1],
-                        });
-                        seenPairs.add(pairKey);
-                    }
-                }
-            }
-            else {
-                const caseExpr = findExprNode(color[key], 'case');
-                if (caseExpr) {
-                    // Categorized: alternating [condition, color] pairs, last element is fallback
-                    for (let i = 1; i < caseExpr.length - 1; i += 2) {
-                        const condition = caseExpr[i];
-                        const pairKey = `${condition[2]}-${caseExpr[i + 1]}`;
-                        if (!seenPairs.has(pairKey)) {
-                            valueColorPairs.push({
-                                id: UUID.uuid4(),
-                                stop: condition[2],
-                                output: caseExpr[i + 1],
-                            });
-                            seenPairs.add(pairKey);
-                        }
-                    }
-                }
-            }
-        }
-        return valueColorPairs;
-    };
-    VectorUtils.buildRadiusInfo = (layer) => {
-        var _a;
-        if (!((_a = layer.parameters) === null || _a === void 0 ? void 0 : _a.color)) {
-            return [];
-        }
-        const color = layer.parameters.color;
-        // If color is a string we don't need to parse
-        if (typeof color === 'string') {
-            return [];
-        }
-        const stopOutputPairs = [];
-        const circleRadius = color['circle-radius'];
-        if (!Array.isArray(circleRadius) ||
-            circleRadius.length <= COLOR_EXPR_STOPS_START) {
-            return [];
-        }
-        for (let i = COLOR_EXPR_STOPS_START; i < circleRadius.length; i += 2) {
-            const obj = {
-                id: UUID.uuid4(),
-                stop: circleRadius[i],
-                output: circleRadius[i + 1],
-            };
-            stopOutputPairs.push(obj);
-        }
-        return stopOutputPairs;
-    };
-})(VectorUtils || (VectorUtils = {}));
 export var Utils;
 (function (Utils) {
     Utils.getValueColorPairs = (stops, colorRamp, nClasses, reverse = false) => {

package/lib/{panelview/objectproperties.d.ts → features/objectproperties/index.d.ts}

@@ -16,7 +16,7 @@ interface IProps {
 export declare class ObjectPropertiesReact extends React.Component<IProps, IStates> {
     constructor(props: IProps);
     private _sharedJGISModelChanged;
-    private _onClientSharedStateChanged;
+    private _onSelectedChanged;
     render(): React.ReactNode;
 }
 export {};

package/lib/{panelview/objectproperties.js → features/objectproperties/index.js}

@@ -1,6 +1,6 @@
 import { UUID } from '@lumino/coreutils';
 import * as React from 'react';
-import { EditForm } from "../formbuilder/editform";
+import { EditForm } from "../../shared/formbuilder/editform";
 export class ObjectPropertiesReact extends React.Component {
     constructor(props) {
         var _a, _b;
@@ -8,19 +8,14 @@ export class ObjectPropertiesReact extends React.Component {
         this._sharedJGISModelChanged = () => {
             this.forceUpdate();
         };
-        this._onClientSharedStateChanged = (sender, clients) => {
+        this._onSelectedChanged = () => {
             var _a, _b;
-            let newState;
-            const clientId = this.state.clientId;
-            const localState = clientId ? clients.get(clientId) : null;
+            const localState = this.props.model.localState;
             if (localState &&
                 ((_a = localState.selected) === null || _a === void 0 ? void 0 : _a.emitter) &&
                 localState.selected.emitter !== this.state.id &&
                 ((_b = localState.selected) === null || _b === void 0 ? void 0 : _b.value)) {
-                newState = localState;
-            }
-            if (newState) {
-                const selection = newState.selected.value;
+                const selection = localState.selected.value;
                 const selectedObjectIds = Object.keys(selection || {});
                 // Only show object properties if ONE object is selected
                 if (selection === undefined || selectedObjectIds.length !== 1) {
@@ -42,7 +37,7 @@ export class ObjectPropertiesReact extends React.Component {
             selectedObject: props.selectedObject,
             setSelectedObject: props.setSelectedObject,
         };
-        this.props.model.clientStateChanged.connect(this._onClientSharedStateChanged);
+        this.props.model.selectedChanged.connect(this._onSelectedChanged);
         (_a = this.props.model) === null || _a === void 0 ? void 0 : _a.sharedLayersChanged.connect(this._sharedJGISModelChanged);
         (_b = this.props.model) === null || _b === void 0 ? void 0 : _b.sharedSourcesChanged.connect(this._sharedJGISModelChanged);
     }

package/lib/{dialogs → features/processing}/ProcessingFormDialog.d.ts

@@ -2,7 +2,7 @@ import { ProcessingType, IDict, IJupyterGISModel } from '@jupytergis/schema';
 import { Dialog } from '@jupyterlab/apputils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
-import type { IBaseFormProps } from "../types";
+import type { IBaseFormProps } from "../../types";
 export interface IProcessingFormDialogOptions extends IBaseFormProps {
     formContext: 'update' | 'create';
     schema: IDict;

package/lib/{dialogs → features/processing}/ProcessingFormDialog.js

@@ -2,8 +2,10 @@ import { Dialog } from '@jupyterlab/apputils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import * as React from 'react';
-import { DissolveForm } from "../formbuilder/objectform/process";
-import { DefaultProcessingForm } from "../formbuilder/objectform/processingForm";
+import { ClipRasterByExtentForm } from './forms/clipRasterByExtentForm';
+import { DissolveForm } from './forms/dissolveProcessForm';
+import { DefaultProcessingForm } from './forms/processingForm';
+import { RasterizeForm } from './forms/rasterizeForm';
 const ProcessingFormWrapper = props => {
     var _a;
     const [ready, setReady] = React.useState(false);
@@ -22,6 +24,12 @@ const ProcessingFormWrapper = props => {
         case 'Dissolve':
             FormComponent = DissolveForm;
             break;
+        case 'Rasterize':
+            FormComponent = RasterizeForm;
+            break;
+        case 'ClipRasterByExtent':
+            FormComponent = ClipRasterByExtentForm;
+            break;
         default:
             FormComponent = DefaultProcessingForm;
     }
@@ -32,25 +40,37 @@ const ProcessingFormWrapper = props => {
  */
 export class ProcessingFormDialog extends Dialog {
     constructor(options) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
         // 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,
         }));
+        const vectorLayerOptions = Object.keys(layers)
+            .filter(layerId => layers[layerId].type === 'VectorLayer')
+            .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)) {
+            if ((_c = options.schema.properties) === null || _c === void 0 ? void 0 : _c.clipLayer) {
+                const selectedInputLayer = (_d = options.sourceData) === null || _d === void 0 ? void 0 : _d.inputLayer;
+                const clipLayerOptions = selectedInputLayer
+                    ? vectorLayerOptions.filter(o => o.value !== selectedInputLayer)
+                    : vectorLayerOptions;
+                options.schema.properties.clipLayer.enum = clipLayerOptions.map(option => option.value);
+                options.schema.properties.clipLayer.enumNames = clipLayerOptions.map(option => option.label);
+            }
+            // Ensure outputLayerName field exists in schema. Skip if the schema
+            // already produces a file output (e.g. raster outputs use outputFileName).
+            if (!((_e = options.schema.properties) === null || _e === void 0 ? void 0 : _e.outputLayerName) &&
+                !((_f = options.schema.properties) === null || _f === void 0 ? void 0 : _f.outputFileName)) {
                 options.schema.properties.outputLayerName = {
                     type: 'string',
-                    title: 'outputLayerName',
-                    // default: ''
+                    title: 'Output Layer Name',
                 };
             }
         }
@@ -58,16 +78,10 @@ export class ProcessingFormDialog extends Dialog {
         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' } },
+        const body = (React.createElement("div", { style: { overflowX: 'hidden', overflowY: 'auto' } },
             React.createElement(ProcessingFormWrapper, Object.assign({}, options, { filePath: filePath, model: jgisModel, okSignalPromise: okSignalPromise, formErrorSignalPromise: formErrorSignalPromise, syncData: syncData }))));
         super({
             title: options.title,

package/lib/features/processing/forms/MapExtentToggle.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface IMapExtentToggleProps {
+    isActive: boolean;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    children: React.ReactNode;
+}
+/**
+ * Checkbox that locks the extent fields to the current map viewport.
+ * When active, the children (extent fields) are visually dimmed and
+ * pointer-events are disabled so the user cannot edit them.
+ */
+export declare function MapExtentToggle({ isActive, onChange, children, }: IMapExtentToggleProps): React.ReactElement;
+export {};

package/lib/features/processing/forms/MapExtentToggle.js

@@ -0,0 +1,20 @@
+import React from 'react';
+/**
+ * Checkbox that locks the extent fields to the current map viewport.
+ * When active, the children (extent fields) are visually dimmed and
+ * pointer-events are disabled so the user cannot edit them.
+ */
+export function MapExtentToggle({ isActive, onChange, children, }) {
+    return (React.createElement(React.Fragment, null,
+        React.createElement("label", { style: {
+                display: 'flex',
+                alignItems: 'center',
+                gap: '6px',
+                margin: '4px 0 8px',
+                cursor: 'pointer',
+                fontSize: 'var(--jp-ui-font-size1)',
+            } },
+            React.createElement("input", { type: "checkbox", checked: isActive, onChange: onChange }),
+            "Use current map extent"),
+        React.createElement("div", { style: isActive ? { pointerEvents: 'none', opacity: 0.4 } : undefined }, children)));
+}

package/lib/features/processing/forms/clipRasterByExtentForm.d.ts

@@ -0,0 +1,10 @@
+import { IJupyterGISModel } from '@jupytergis/schema';
+import { Dialog } from '@jupyterlab/apputils';
+import { Signal } from '@lumino/signaling';
+import React from 'react';
+import type { IBaseFormProps } from "../../../types";
+export interface IClipRasterByExtentFormProps extends IBaseFormProps {
+    ok?: Signal<Dialog<any>, number>;
+    model: IJupyterGISModel;
+}
+export declare function ClipRasterByExtentForm(props: IClipRasterByExtentFormProps): React.ReactElement | null;

package/lib/features/processing/forms/clipRasterByExtentForm.js

@@ -0,0 +1,99 @@
+import React, { useCallback, useEffect, useMemo, useRef } from 'react';
+import { SchemaForm } from "../../../shared/formbuilder/objectform/SchemaForm";
+import { useSchemaFormState } from "../../../shared/formbuilder/objectform/useSchemaFormState";
+import { MapExtentToggle } from './MapExtentToggle';
+import { useMapExtent } from './useMapExtent';
+export function ClipRasterByExtentForm(props) {
+    const { schema: schemaProp, sourceData, syncData, model, filePath, ok, } = props;
+    const { formData, setFormData, schema, hasSchema } = useSchemaFormState({
+        sourceData,
+        schemaProp,
+        model,
+    });
+    const submitButtonRef = useRef(null);
+    const { isActive: mapExtentActive, extentRef, toggle } = useMapExtent(model);
+    useEffect(() => {
+        if (!ok) {
+            return;
+        }
+        const handler = () => { var _a; return (_a = submitButtonRef.current) === null || _a === void 0 ? void 0 : _a.click(); };
+        ok.connect(handler);
+        return () => {
+            ok.disconnect(handler);
+        };
+    }, [ok]);
+    const formContextValue = useMemo(() => ({ model, formData }), [model, formData]);
+    // Schema for the top section: inputLayer only
+    const schemaTop = useMemo(() => {
+        var _a;
+        return ((_a = schema === null || schema === void 0 ? void 0 : schema.properties) === null || _a === void 0 ? void 0 : _a.inputLayer)
+            ? {
+                type: 'object',
+                properties: { inputLayer: schema.properties.inputLayer },
+                required: [],
+                additionalProperties: false,
+            }
+            : null;
+    }, [schema]);
+    // Schema for the extent section: xMin/yMin/xMax/yMax
+    // Required only when the user is entering them manually
+    const schemaExtent = useMemo(() => (schema === null || schema === void 0 ? void 0 : schema.properties)
+        ? {
+            type: 'object',
+            properties: {
+                xMin: schema.properties.xMin,
+                yMin: schema.properties.yMin,
+                xMax: schema.properties.xMax,
+                yMax: schema.properties.yMax,
+            },
+            required: mapExtentActive
+                ? []
+                : ['xMin', 'yMin', 'xMax', 'yMax'],
+            additionalProperties: false,
+        }
+        : null, [schema, mapExtentActive]);
+    // Schema for the bottom section: output options
+    const schemaBottom = useMemo(() => (schema === null || schema === void 0 ? void 0 : schema.properties)
+        ? {
+            type: 'object',
+            properties: {
+                outputFileName: schema.properties.outputFileName,
+                embedOutputLayer: schema.properties.embedOutputLayer,
+            },
+            required: [],
+            additionalProperties: false,
+        }
+        : null, [schema]);
+    const handleTopChange = useCallback((data) => setFormData(prev => (Object.assign(Object.assign({}, prev), data))), [setFormData]);
+    const handleExtentChange = useCallback((data) => {
+        // When using map extent, rjsf may strip disabled-looking fields on some
+        // browsers; always restore the cached extent values to be safe.
+        setFormData(prev => (Object.assign(Object.assign(Object.assign({}, prev), data), (mapExtentActive ? extentRef.current : {}))));
+    }, [setFormData, mapExtentActive, extentRef]);
+    const handleBottomChange = useCallback((data) => setFormData(prev => (Object.assign(Object.assign({}, prev), data))), [setFormData]);
+    const handleSubmit = useCallback((data) => {
+        syncData === null || syncData === void 0 ? void 0 : syncData(Object.assign(Object.assign({}, formData), data));
+    }, [syncData, formData]);
+    const handleCheckboxChange = useCallback((e) => {
+        const extent = toggle(e.target.checked);
+        if (extent) {
+            setFormData(prev => (Object.assign(Object.assign({}, prev), extent)));
+        }
+    }, [toggle, setFormData]);
+    if (!hasSchema || !schemaTop || !schemaExtent || !schemaBottom) {
+        return null;
+    }
+    return (React.createElement("div", null,
+        React.createElement(SchemaForm, { schema: schemaTop, formData: { inputLayer: formData.inputLayer }, onChange: handleTopChange, onSubmit: () => undefined, formContext: formContextValue, filePath: filePath, liveValidate: false }),
+        React.createElement(MapExtentToggle, { isActive: mapExtentActive, onChange: handleCheckboxChange },
+            React.createElement(SchemaForm, { schema: schemaExtent, formData: {
+                    xMin: formData.xMin,
+                    yMin: formData.yMin,
+                    xMax: formData.xMax,
+                    yMax: formData.yMax,
+                }, onChange: handleExtentChange, onSubmit: () => undefined, formContext: formContextValue, filePath: filePath })),
+        React.createElement(SchemaForm, { schema: schemaBottom, formData: {
+                outputFileName: formData.outputFileName,
+                embedOutputLayer: formData.embedOutputLayer,
+            }, onChange: handleBottomChange, onSubmit: handleSubmit, formContext: formContextValue, filePath: filePath, submitButtonRef: submitButtonRef, liveValidate: false })));
+}

package/lib/{formbuilder/objectform/process → features/processing/forms}/dissolveProcessForm.js

@@ -1,8 +1,8 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { SchemaForm } from "../../../shared/formbuilder/objectform/SchemaForm";
+import { processBaseSchema, removeFormEntry, } from "../../../shared/formbuilder/objectform/schemaUtils";
+import { useSchemaFormState } from "../../../shared/formbuilder/objectform/useSchemaFormState";
 import { deepCopy, loadFile } from "../../../tools";
-import { SchemaForm } from '../SchemaForm';
-import { processBaseSchema, removeFormEntry } from '../schemaUtils';
-import { useSchemaFormState } from '../useSchemaFormState';
 async function fetchFieldNames(model, layerId) {
     var _a, _b, _c;
     if (!layerId) {
@@ -32,7 +32,7 @@ async function fetchFieldNames(model, layerId) {
 }
 export function DissolveForm(props) {
     const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, ok, } = props;
-    const { formData, formContextValue, hasSchema, handleChangeBase, handleSubmitBase, } = useSchemaFormState({ sourceData, schemaProp, model, syncData });
+    const { formData, setFormData, formContextValue, hasSchema, handleSubmitBase, } = useSchemaFormState({ sourceData, schemaProp, model, syncData });
     const [features, setFeatures] = useState([]);
     const submitButtonRef = useRef(null);
     useEffect(() => {
@@ -70,5 +70,5 @@ export function DissolveForm(props) {
     if (!hasSchema) {
         return null;
     }
-    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: handleChangeBase, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, submitButtonRef: submitButtonRef }));
+    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: setFormData, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, submitButtonRef: submitButtonRef }));
 }

package/lib/{formbuilder/objectform → features/processing/forms}/processingForm.d.ts

@@ -4,7 +4,7 @@
 import { Dialog } from '@jupyterlab/apputils';
 import { Signal } from '@lumino/signaling';
 import React from 'react';
-import type { IBaseFormProps } from "../../types";
+import type { IBaseFormProps } from "../../../types";
 export interface IProcessingFormWrapperProps extends IBaseFormProps {
     /** Signal emitted by the dialog when OK is clicked; form submits when this fires. */
     ok?: Signal<Dialog<any>, number>;

package/lib/{formbuilder/objectform → features/processing/forms}/processingForm.js

@@ -1,11 +1,11 @@
 import React, { useEffect, useMemo, useRef } from 'react';
-import { deepCopy } from "../../tools";
-import { SchemaForm } from './SchemaForm';
-import { processBaseSchema, removeFormEntry } from './schemaUtils';
-import { useSchemaFormState } from './useSchemaFormState';
+import { SchemaForm } from "../../../shared/formbuilder/objectform/SchemaForm";
+import { processBaseSchema, removeFormEntry, } from "../../../shared/formbuilder/objectform/schemaUtils";
+import { useSchemaFormState } from "../../../shared/formbuilder/objectform/useSchemaFormState";
+import { deepCopy } from "../../../tools";
 export function DefaultProcessingForm(props) {
     const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, ok, } = props;
-    const { formData, schema, formContextValue, hasSchema, handleChangeBase, handleSubmitBase, } = useSchemaFormState({ sourceData, schemaProp, model, syncData });
+    const { formData, setFormData, schema, formContextValue, hasSchema, handleSubmitBase, } = useSchemaFormState({ sourceData, schemaProp, model, syncData });
     const submitButtonRef = useRef(null);
     useEffect(() => {
         if (!ok) {
@@ -29,5 +29,5 @@ export function DefaultProcessingForm(props) {
     if (!hasSchema) {
         return null;
     }
-    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: handleChangeBase, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, submitButtonRef: submitButtonRef }));
+    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: setFormData, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, submitButtonRef: submitButtonRef }));
 }

package/lib/features/processing/forms/rasterizeForm.d.ts

@@ -0,0 +1,10 @@
+import { IJupyterGISModel } from '@jupytergis/schema';
+import { Dialog } from '@jupyterlab/apputils';
+import { Signal } from '@lumino/signaling';
+import React from 'react';
+import type { IBaseFormProps } from "../../../types";
+export interface IRasterizeFormProps extends IBaseFormProps {
+    ok?: Signal<Dialog<any>, number>;
+    model: IJupyterGISModel;
+}
+export declare function RasterizeForm(props: IRasterizeFormProps): React.ReactElement | null;