@jupytergis/base 0.15.0 → 0.16.0-alpha.1

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;

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

@@ -0,0 +1,75 @@
+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";
+async function fetchNumericFieldNames(model, layerId) {
+    var _a, _b, _c, _d;
+    if (!layerId) {
+        return [];
+    }
+    const layer = 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 = model.getSource(layer.parameters.source);
+    if (!source || source.type !== 'GeoJSONSource') {
+        return [];
+    }
+    const sourceData = source.parameters;
+    const jsonData = (_b = sourceData === null || sourceData === void 0 ? void 0 : sourceData.data) !== null && _b !== void 0 ? _b : ((sourceData === null || sourceData === void 0 ? void 0 : sourceData.path)
+        ? await loadFile({
+            filepath: sourceData.path,
+            type: 'GeoJSONSource',
+            model,
+        })
+        : undefined);
+    if (!((_c = jsonData === null || jsonData === void 0 ? void 0 : jsonData.features) === null || _c === void 0 ? void 0 : _c.length)) {
+        return [];
+    }
+    // gdal_rasterize -a needs a numeric attribute. Filter accordingly.
+    const props = (_d = jsonData.features[0].properties) !== null && _d !== void 0 ? _d : {};
+    return Object.keys(props).filter(k => typeof props[k] === 'number');
+}
+export function RasterizeForm(props) {
+    const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, ok, } = props;
+    const { formData, setFormData, formContextValue, hasSchema, handleSubmitBase, } = useSchemaFormState({ sourceData, schemaProp, model, syncData });
+    const [features, setFeatures] = useState([]);
+    const submitButtonRef = useRef(null);
+    useEffect(() => {
+        fetchNumericFieldNames(model, formData === null || formData === void 0 ? void 0 : formData.inputLayer)
+            .then(setFeatures)
+            .catch(() => setFeatures([]));
+    }, [model, formData === null || formData === void 0 ? void 0 : formData.inputLayer]);
+    useEffect(() => {
+        if (!ok) {
+            return;
+        }
+        const handler = () => {
+            var _a;
+            (_a = submitButtonRef.current) === null || _a === void 0 ? void 0 : _a.click();
+        };
+        ok.connect(handler);
+        return () => {
+            ok.disconnect(handler);
+        };
+    }, [ok]);
+    const schema = useMemo(() => {
+        const schemaCopy = deepCopy(schemaProp !== null && schemaProp !== void 0 ? schemaProp : {});
+        if (schemaCopy.properties &&
+            schemaCopy.properties.attributeField) {
+            schemaCopy.properties.attributeField = Object.assign(Object.assign({}, schemaCopy.properties.attributeField), { enum: ['', ...features], enumNames: ['(use burn value)', ...features] });
+        }
+        return schemaCopy;
+    }, [schemaProp, features]);
+    const uiSchema = useMemo(() => {
+        const builtUiSchema = {};
+        const dataCopy = deepCopy(formData);
+        processBaseSchema(dataCopy, schema, builtUiSchema, formContext, removeFormEntry);
+        return builtUiSchema;
+    }, [schema, formData, formContext]);
+    if (!hasSchema) {
+        return null;
+    }
+    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/useMapExtent.d.ts

@@ -0,0 +1,22 @@
+import { IDict, IJupyterGISModel } from '@jupytergis/schema';
+export interface IUseMapExtentResult {
+    isActive: boolean;
+    extentRef: React.MutableRefObject<IDict>;
+    toggle: (checked: boolean) => IDict | null;
+}
+/**
+ * Reads the current map viewport from the model awareness and returns the
+ * bounding box in EPSG:4326, or null if the viewport is not yet available.
+ */
+export declare function getMapExtent(model: IJupyterGISModel): IDict | null;
+/**
+ * Manages the "Use current map extent" toggle state.
+ *
+ * Returns:
+ * - `isActive`: whether the map extent is currently locked in
+ * - `extentRef`: cached extent values (used to restore fields after rjsf re-renders)
+ * - `toggle(checked)`: call when the checkbox changes; returns the extent dict
+ *   when activating (so the caller can merge it into form state), or null when
+ *   deactivating or when the viewport is not yet ready.
+ */
+export declare function useMapExtent(model: IJupyterGISModel): IUseMapExtentResult;

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

@@ -0,0 +1,57 @@
+import { transformExtent } from 'ol/proj';
+import { useRef, useState } from 'react';
+/**
+ * Reads the current map viewport from the model awareness and returns the
+ * bounding box in EPSG:4326, or null if the viewport is not yet available.
+ */
+export function getMapExtent(model) {
+    var _a, _b, _c, _d;
+    const viewport = (_b = (_a = model.sharedModel.awareness.getLocalState()) === null || _a === void 0 ? void 0 : _a.viewportState) === null || _b === void 0 ? void 0 : _b.value;
+    if (!(viewport === null || viewport === void 0 ? void 0 : viewport.extent)) {
+        return null;
+    }
+    const mapProjection = (_d = (_c = model.sharedModel.options) === null || _c === void 0 ? void 0 : _c.projection) !== null && _d !== void 0 ? _d : 'EPSG:3857';
+    let [xMin, yMin, xMax, yMax] = viewport.extent;
+    if (mapProjection !== 'EPSG:4326') {
+        [xMin, yMin, xMax, yMax] = transformExtent(viewport.extent, mapProjection, 'EPSG:4326');
+    }
+    const round = (v) => Math.round(v * 1e6) / 1e6;
+    return {
+        xMin: round(xMin),
+        yMin: round(yMin),
+        xMax: round(xMax),
+        yMax: round(yMax),
+    };
+}
+/**
+ * Manages the "Use current map extent" toggle state.
+ *
+ * Returns:
+ * - `isActive`: whether the map extent is currently locked in
+ * - `extentRef`: cached extent values (used to restore fields after rjsf re-renders)
+ * - `toggle(checked)`: call when the checkbox changes; returns the extent dict
+ *   when activating (so the caller can merge it into form state), or null when
+ *   deactivating or when the viewport is not yet ready.
+ */
+export function useMapExtent(model) {
+    const [isActive, setIsActive] = useState(false);
+    const extentRef = useRef({});
+    const toggle = (checked) => {
+        if (checked) {
+            const extent = getMapExtent(model);
+            if (extent) {
+                extentRef.current = extent;
+                setIsActive(true);
+                return extent;
+            }
+            // Viewport not ready — leave checkbox unchecked, fields stay required
+            return null;
+        }
+        else {
+            setIsActive(false);
+            extentRef.current = {};
+            return null;
+        }
+    };
+    return { isActive, extentRef, toggle };
+}

package/lib/{processing → features/processing}/index.d.ts

@@ -1,6 +1,6 @@
 import { IDict, IJGISLayer, IJupyterGISModel, IJGISFormSchemaRegistry, LayerType, ProcessingType } from '@jupytergis/schema';
 import { JupyterFrontEnd } from '@jupyterlab/application';
-import { JupyterGISTracker } from '../types';
+import { JupyterGISTracker } from '../../types';
 /**
  * Get the currently selected layer from the shared model. Returns null if there is no selection or multiple layer is selected.
  */
@@ -22,4 +22,21 @@ export declare function processLayer(tracker: JupyterGISTracker, formSchemaRegis
     gdalFunction: GdalFunctions;
     options: (sqlQuery: string) => string[];
 }, app: JupyterFrontEnd, filePath?: string, processingInputs?: Record<string, any>): Promise<void>;
-export declare function executeSQLProcessing(model: IJupyterGISModel, geojsonString: string, gdalFunction: GdalFunctions, options: string[], layerNamePrefix: string, processingType: ProcessingType, embedOutputLayer: boolean, tracker: JupyterGISTracker, app: JupyterFrontEnd): Promise<void>;
+/**
+ * Rasterize a vector layer to a GeoTIFF on disk and add it as a WebGlLayer.
+ */
+export declare function rasterizeLayer(tracker: JupyterGISTracker, formSchemaRegistry: IJGISFormSchemaRegistry, processingType: ProcessingType, gdalFunction: GdalFunctions, app: JupyterFrontEnd, filePath?: string, processingInputs?: Record<string, any>): Promise<void>;
+/**
+ * Clip a GeoTiff raster layer to a bounding-box extent using gdal_translate -projwin.
+ */
+export declare function clipRasterByExtent(tracker: JupyterGISTracker, formSchemaRegistry: IJGISFormSchemaRegistry, app: JupyterFrontEnd, filePath?: string, processingInputs?: Record<string, any>): Promise<void>;
+/**
+ * Clip a GeoTiff raster layer using a vector layer as the cutline.
+ * Uses gdalwarp with -cutline (and optionally -crop_to_cutline).
+ */
+export declare function clipRasterByVector(tracker: JupyterGISTracker, formSchemaRegistry: IJGISFormSchemaRegistry, app: JupyterFrontEnd, filePath?: string, processingInputs?: Record<string, any>): Promise<void>;
+/**
+ * Clip a vector layer by another vector layer using ST_Intersection.
+ */
+export declare function clipVectorByMaskLayer(tracker: JupyterGISTracker, formSchemaRegistry: IJGISFormSchemaRegistry, app: JupyterFrontEnd, filePath?: string, processingInputs?: Record<string, any>): Promise<void>;
+export declare function executeSQLProcessing(model: IJupyterGISModel, geojsonString: string, gdalFunction: GdalFunctions, options: string[], layerNamePrefix: string, processingType: ProcessingType, embedOutputLayer: boolean, tracker: JupyterGISTracker, app: JupyterFrontEnd, exactLayerName?: string): Promise<void>;