@jupytergis/base 0.15.0 → 0.16.0-alpha.0

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>;