@jupytergis/base 0.13.3 → 0.14.0

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

@@ -1,64 +1,96 @@
-import { loadFile } from "../../../tools";
-import { LayerPropertiesForm } from './layerform';
-export class HeatmapLayerPropertiesForm extends LayerPropertiesForm {
-    constructor(props) {
-        super(props);
-        this.features = [];
-        this.fetchFeatureNames(this.props.sourceData);
-        if (this.sourceFormChangedSignal) {
-            this.sourceFormChangedSignal.connect((sender, sourceData) => {
-                if (this.props.sourceType === 'GeoJSONSource') {
-                    this.fetchFeatureNames(this.currentFormData, sourceData);
-                }
-            });
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { deepCopy, loadFile } from "../../../tools";
+import { SchemaForm } from '../SchemaForm';
+import { processBaseSchema, removeFormEntry } from '../schemaUtils';
+import { useSchemaFormState } from '../useSchemaFormState';
+async function fetchFeatureNames(model, layerData, sourceData) {
+    var _a, _b, _c, _d;
+    let resolvedSource = sourceData;
+    if ((layerData === null || layerData === void 0 ? void 0 : layerData.source) && !resolvedSource) {
+        const currentSource = model.getSource(layerData.source);
+        if (!currentSource || currentSource.type !== 'GeoJSONSource') {
+            return [];
         }
+        resolvedSource = currentSource.parameters;
     }
-    onFormSubmit(e) {
-        e.formData.symbologyState = {};
-        return super.onFormSubmit(e);
+    const source = model.getSource(layerData === null || layerData === void 0 ? void 0 : layerData.source);
+    if (!((_a = source === null || source === void 0 ? void 0 : source.parameters) === null || _a === void 0 ? void 0 : _a.path)) {
+        return [];
     }
-    onFormChange(e) {
-        super.onFormChange(e);
-        const source = this.props.model.getSource(e.formData.source);
-        if (!source || source.type !== 'GeoJSONSource') {
-            return;
-        }
-        this.fetchFeatureNames(this.currentFormData, source.parameters);
-    }
-    processSchema(data, schema, uiSchema) {
-        this.removeFormEntry('color', data, schema, uiSchema);
-        this.removeFormEntry('symbologyState', data, schema, uiSchema);
-        this.removeFormEntry('blur', data, schema, uiSchema);
-        this.removeFormEntry('radius', data, schema, uiSchema);
-        super.processSchema(data, schema, uiSchema);
-        uiSchema['feature'] = { enum: this.features };
-        if (!data) {
+    const jsonData = await loadFile({
+        filepath: source.parameters.path,
+        type: 'GeoJSONSource',
+        model,
+    });
+    const featureProps = (_d = (_c = (_b = jsonData === null || jsonData === void 0 ? void 0 : jsonData.features) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.properties) !== null && _d !== void 0 ? _d : {};
+    return Object.keys(featureProps);
+}
+export function HeatmapLayerPropertiesForm(props) {
+    const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, sourceType, dialogOptions, formErrorSignal, sourceFormChangedSignal, } = props;
+    const { formData, schema, formContextValue, hasSchema, handleChangeBase, handleSubmitBase, } = useSchemaFormState({
+        sourceData,
+        schemaProp,
+        model,
+        syncData,
+        cancel: props.cancel,
+        onAfterChange: dialogOptions
+            ? (data) => {
+                dialogOptions.layerData = Object.assign({}, data);
+            }
+            : undefined,
+    });
+    const [features, setFeatures] = useState([]);
+    const formDataRef = useRef(formData);
+    formDataRef.current = formData;
+    useEffect(() => {
+        let cancelled = false;
+        fetchFeatureNames(model, formData)
+            .then(names => {
+            if (!cancelled) {
+                setFeatures(names);
+            }
+        })
+            .catch(() => {
+            if (!cancelled) {
+                setFeatures([]);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [model, formData === null || formData === void 0 ? void 0 : formData.source]);
+    useEffect(() => {
+        if (sourceType !== 'GeoJSONSource' || !sourceFormChangedSignal) {
             return;
         }
-    }
-    async fetchFeatureNames(data, sourceData) {
+        const handler = (_sender, sourceDataPayload) => {
+            fetchFeatureNames(model, formDataRef.current, sourceDataPayload).then(setFeatures);
+        };
+        sourceFormChangedSignal.connect(handler);
+        return () => {
+            sourceFormChangedSignal.disconnect(handler);
+        };
+    }, [sourceType, sourceFormChangedSignal, model]);
+    const uiSchema = useMemo(() => {
         var _a;
-        if (data && data.source) {
-            if (!sourceData) {
-                const currentSource = this.props.model.getSource(data.source);
-                if (!currentSource || currentSource.type !== 'GeoJSONSource') {
-                    this.features = [];
-                    return;
-                }
-                sourceData = currentSource.parameters;
-            }
+        const builtUiSchema = {};
+        const dataCopy = deepCopy(formData);
+        removeFormEntry('color', formData, schema, builtUiSchema);
+        removeFormEntry('symbologyState', formData, schema, builtUiSchema);
+        removeFormEntry('blur', dataCopy, schema, builtUiSchema);
+        removeFormEntry('radius', dataCopy, schema, builtUiSchema);
+        processBaseSchema(dataCopy, schema, builtUiSchema, formContext, removeFormEntry);
+        if ((_a = schema.properties) === null || _a === void 0 ? void 0 : _a.source) {
+            const availableSources = model.getSourcesByType(sourceType);
+            schema.properties.source.enumNames =
+                Object.values(availableSources);
+            schema.properties.source.enum = Object.keys(availableSources);
         }
-        const source = this.props.model.getSource(data.source);
-        if (!((_a = source === null || source === void 0 ? void 0 : source.parameters) === null || _a === void 0 ? void 0 : _a.path)) {
-            return;
-        }
-        const jsonData = await loadFile({
-            filepath: source.parameters.path,
-            type: 'GeoJSONSource',
-            model: this.props.model,
-        });
-        const featureProps = jsonData.features[0].properties;
-        this.features = Object.keys(featureProps);
-        this.forceUpdate();
+        builtUiSchema.feature = { enum: features };
+        return builtUiSchema;
+    }, [schema, formData, formContext, model, sourceType, features]);
+    if (!hasSchema) {
+        return null;
     }
+    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: handleChangeBase, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, formErrorSignal: formErrorSignal }));
 }

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

@@ -1,8 +1,3 @@
-import { IDict } from '@jupytergis/schema';
-import { LayerPropertiesForm } from './layerform';
-/**
- * The form to modify a hillshade layer.
- */
-export declare class HillshadeLayerPropertiesForm extends LayerPropertiesForm {
-    protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
-}
+import React from 'react';
+import type { ILayerProps } from './layerform';
+export declare function HillshadeLayerPropertiesForm(props: ILayerProps): React.ReactElement | null;

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

@@ -1,12 +1,38 @@
-import { LayerPropertiesForm } from './layerform';
-/**
- * The form to modify a hillshade layer.
- */
-export class HillshadeLayerPropertiesForm extends LayerPropertiesForm {
-    processSchema(data, schema, uiSchema) {
-        super.processSchema(data, schema, uiSchema);
-        uiSchema['shadowColor'] = {
-            'ui:widget': 'color',
-        };
+import React, { useMemo } from 'react';
+import { deepCopy } from "../../../tools";
+import { SchemaForm } from '../SchemaForm';
+import { processBaseSchema, removeFormEntry } from '../schemaUtils';
+import { useSchemaFormState } from '../useSchemaFormState';
+export function HillshadeLayerPropertiesForm(props) {
+    const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, sourceType, dialogOptions, formErrorSignal, } = props;
+    const { formData, schema, formContextValue, hasSchema, handleChangeBase, handleSubmitBase, } = useSchemaFormState({
+        sourceData,
+        schemaProp,
+        model,
+        syncData,
+        cancel: props.cancel,
+        onAfterChange: dialogOptions
+            ? (data) => {
+                dialogOptions.layerData = Object.assign({}, data);
+            }
+            : undefined,
+    });
+    const uiSchema = useMemo(() => {
+        var _a;
+        const builtUiSchema = {};
+        const dataCopy = deepCopy(formData);
+        processBaseSchema(dataCopy, schema, builtUiSchema, formContext, removeFormEntry);
+        if ((_a = schema.properties) === null || _a === void 0 ? void 0 : _a.source) {
+            const availableSources = model.getSourcesByType(sourceType);
+            schema.properties.source.enumNames =
+                Object.values(availableSources);
+            schema.properties.source.enum = Object.keys(availableSources);
+        }
+        builtUiSchema.shadowColor = { 'ui:widget': 'color' };
+        return builtUiSchema;
+    }, [schema, formData, formContext, model, sourceType]);
+    if (!hasSchema) {
+        return null;
     }
+    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: handleChangeBase, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, formErrorSignal: formErrorSignal }));
 }

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

@@ -1,7 +1,11 @@
+/**
+ * Base (default) layer form and props.
+ * Used for RasterLayer and any layer type without a dedicated form.
+ */
 import { IDict, SourceType } from '@jupytergis/schema';
 import { Signal } from '@lumino/signaling';
-import { IChangeEvent } from '@rjsf/core';
-import { BaseForm, IBaseFormProps } from "../baseform";
+import React from 'react';
+import type { IBaseFormProps } from "../../../types";
 export interface ILayerProps extends IBaseFormProps {
     /**
      * The source type for the layer
@@ -17,10 +21,4 @@ export interface ILayerProps extends IBaseFormProps {
      */
     dialogOptions?: any;
 }
-export declare class LayerPropertiesForm extends BaseForm {
-    props: ILayerProps;
-    protected sourceFormChangedSignal: Signal<any, IDict<any>> | undefined;
-    constructor(props: ILayerProps);
-    protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
-    protected onFormChange(e: IChangeEvent): void;
-}
+export declare function LayerPropertiesForm(props: ILayerProps): React.ReactElement | null;

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

@@ -1,24 +1,37 @@
-import { BaseForm, } from "../baseform";
-export class LayerPropertiesForm extends BaseForm {
-    constructor(props) {
-        super(props);
-        this.sourceFormChangedSignal = props.sourceFormChangedSignal;
-    }
-    processSchema(data, schema, uiSchema) {
+import React, { useMemo } from 'react';
+import { deepCopy } from "../../../tools";
+import { SchemaForm } from '../SchemaForm';
+import { processBaseSchema, removeFormEntry } from '../schemaUtils';
+import { useSchemaFormState } from '../useSchemaFormState';
+export function LayerPropertiesForm(props) {
+    const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, sourceType, dialogOptions, formErrorSignal, } = props;
+    const { formData, schema, formContextValue, hasSchema, handleChangeBase, handleSubmitBase, } = useSchemaFormState({
+        sourceData,
+        schemaProp,
+        model,
+        syncData,
+        cancel: props.cancel,
+        onAfterChange: dialogOptions
+            ? (data) => {
+                dialogOptions.layerData = Object.assign({}, data);
+            }
+            : undefined,
+    });
+    const uiSchema = useMemo(() => {
         var _a;
-        super.processSchema(data, schema, uiSchema);
-        if (!((_a = schema.properties) === null || _a === void 0 ? void 0 : _a.source)) {
-            return;
-        }
-        // Replace the source text box by a dropdown menu
-        const availableSources = this.props.model.getSourcesByType(this.props.sourceType);
-        schema.properties.source.enumNames = Object.values(availableSources);
-        schema.properties.source.enum = Object.keys(availableSources);
-    }
-    onFormChange(e) {
-        super.onFormChange(e);
-        if (this.props.dialogOptions) {
-            this.props.dialogOptions.layerData = Object.assign({}, e.formData);
+        const builtUiSchema = {};
+        const dataCopy = deepCopy(formData);
+        processBaseSchema(dataCopy, schema, builtUiSchema, formContext, removeFormEntry);
+        if ((_a = schema.properties) === null || _a === void 0 ? void 0 : _a.source) {
+            const availableSources = model.getSourcesByType(sourceType);
+            schema.properties.source.enumNames =
+                Object.values(availableSources);
+            schema.properties.source.enum = Object.keys(availableSources);
         }
+        return builtUiSchema;
+    }, [schema, formData, formContext, model, sourceType]);
+    if (!hasSchema) {
+        return null;
     }
+    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: handleChangeBase, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, formErrorSignal: formErrorSignal }));
 }

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

@@ -1,5 +1,3 @@
-import { IDict, IStorySegmentLayer } from '@jupytergis/schema';
-import { LayerPropertiesForm } from './layerform';
-export declare class StorySegmentLayerPropertiesForm extends LayerPropertiesForm {
-    protected processSchema(data: IStorySegmentLayer | undefined, schema: IDict, uiSchema: IDict): void;
-}
+import React from 'react';
+import type { ILayerProps } from './layerform';
+export declare function StorySegmentLayerPropertiesForm(props: ILayerProps): React.ReactElement | null;

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

@@ -1,35 +1,75 @@
-import * as React from 'react';
-import { LayerPropertiesForm } from './layerform';
+import React, { useMemo } from 'react';
+import { deepCopy } from "../../../tools";
+import { SchemaForm } from '../SchemaForm';
 import { ArrayFieldTemplate } from '../components/SegmentFormSymbology';
+import { SourcePropertiesField } from '../components/SourcePropertiesField';
 import StorySegmentReset from '../components/StorySegmentReset';
-export class StorySegmentLayerPropertiesForm extends LayerPropertiesForm {
-    processSchema(data, schema, uiSchema) {
-        var _a, _b, _c;
-        super.processSchema(data, schema, uiSchema);
-        if (!this.props.model.selected) {
-            return;
+import { processBaseSchema, removeFormEntry } from '../schemaUtils';
+import { useSchemaFormState } from '../useSchemaFormState';
+function getFirstSelectedStorySegmentLayerId(model) {
+    const selected = model.selected;
+    if (!selected) {
+        return undefined;
+    }
+    for (const key of Object.keys(selected)) {
+        const layer = model.getLayer(key);
+        if ((layer === null || layer === void 0 ? void 0 : layer.type) === 'StorySegmentLayer') {
+            return key;
         }
-        let layerId = undefined;
-        const selectedKeys = Object.keys(this.props.model.selected);
-        // Find the first selected story segment
-        // ! TODO we still need to handle selections better, like there should at least be a getFirstSelected
-        for (const key of selectedKeys) {
-            const layer = this.props.model.getLayer(key);
-            if (layer && layer.type === 'StorySegmentLayer') {
-                layerId = key;
-                break;
+    }
+    return undefined;
+}
+const StorySegmentResetField = (props) => {
+    const ctx = props.formContext;
+    return React.createElement(StorySegmentReset, { model: ctx === null || ctx === void 0 ? void 0 : ctx.model, layerId: ctx === null || ctx === void 0 ? void 0 : ctx.layerId });
+};
+export function StorySegmentLayerPropertiesForm(props) {
+    const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, sourceType, dialogOptions, formErrorSignal, formSchemaRegistry, } = props;
+    const { formData, schema, formContextValue: baseFormContext, hasSchema, handleChangeBase, handleSubmitBase, } = useSchemaFormState({
+        sourceData,
+        schemaProp,
+        model,
+        syncData,
+        cancel: props.cancel,
+        onAfterChange: dialogOptions
+            ? (data) => {
+                dialogOptions.layerData = Object.assign({}, data);
             }
+            : undefined,
+    });
+    const layerId = useMemo(() => getFirstSelectedStorySegmentLayerId(model), [model, model.selected]);
+    const formContextValue = useMemo(() => (Object.assign(Object.assign({}, baseFormContext), { layerId, formSchemaRegistry })), [baseFormContext, layerId]);
+    const uiSchema = useMemo(() => {
+        var _a, _b;
+        const builtUiSchema = {};
+        const dataCopy = deepCopy(formData);
+        processBaseSchema(dataCopy, schema, builtUiSchema, formContext, removeFormEntry);
+        if ((_a = schema.properties) === null || _a === void 0 ? void 0 : _a.source) {
+            const availableSources = model.getSourcesByType(sourceType);
+            schema.properties.source.enumNames =
+                Object.values(availableSources);
+            schema.properties.source.enum = Object.keys(availableSources);
+        }
+        removeFormEntry('zoom', dataCopy, schema, builtUiSchema);
+        const layerOverrideItems = (_b = schema.properties) === null || _b === void 0 ? void 0 : _b.layerOverride;
+        const itemsProps = layerOverrideItems === null || layerOverrideItems === void 0 ? void 0 : layerOverrideItems.items;
+        const itemsProperties = itemsProps === null || itemsProps === void 0 ? void 0 : itemsProps.properties;
+        if (itemsProperties) {
+            delete itemsProperties.color;
+            delete itemsProperties.symbologyState;
         }
-        uiSchema['extent'] = {
-            'ui:field': (props) => React.createElement(StorySegmentReset, Object.assign(Object.assign({}, props), { model: this.props.model, layerId })),
-        };
-        uiSchema['content'] = Object.assign(Object.assign({}, uiSchema['content']), { markdown: {
+        if (model.selected) {
+            builtUiSchema.extent = {
+                'ui:field': 'storySegmentReset',
+            };
+        }
+        builtUiSchema.content = Object.assign(Object.assign({}, builtUiSchema.content), { markdown: {
                 'ui:widget': 'textarea',
                 'ui:options': {
                     rows: 10,
                 },
             } });
-        uiSchema['layerOverride'] = Object.assign(Object.assign({}, uiSchema['layerOverride']), { items: {
+        builtUiSchema.layerOverride = Object.assign(Object.assign({}, builtUiSchema.layerOverride), { items: {
                 'ui:title': '',
                 targetLayer: {
                     'ui:field': 'layerSelect',
@@ -37,15 +77,19 @@ export class StorySegmentLayerPropertiesForm extends LayerPropertiesForm {
                 opacity: {
                     'ui:field': 'opacity',
                 },
+                sourceProperties: {
+                    'ui:field': SourcePropertiesField,
+                },
             }, 'ui:options': {
                 orderable: false,
             }, 'ui:ArrayFieldTemplate': ArrayFieldTemplate });
-        // Remove properties that should not be displayed in the form
-        const layerOverrideItems = (_c = (_b = (_a = schema.properties) === null || _a === void 0 ? void 0 : _a.layerOverride) === null || _b === void 0 ? void 0 : _b.items) === null || _c === void 0 ? void 0 : _c.properties;
-        if (layerOverrideItems) {
-            delete layerOverrideItems.color;
-            delete layerOverrideItems.symbologyState;
-        }
-        this.removeFormEntry('zoom', data, schema, uiSchema);
+        return builtUiSchema;
+    }, [schema, formData, formContext, model, sourceType]);
+    const additionalFields = useMemo(() => ({
+        storySegmentReset: StorySegmentResetField,
+    }), []);
+    if (!hasSchema) {
+        return null;
     }
+    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: handleChangeBase, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, additionalFields: additionalFields, formErrorSignal: formErrorSignal }));
 }

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

@@ -1,14 +1,3 @@
-import { IDict, IVectorLayer } from '@jupytergis/schema';
-import { IChangeEvent, ISubmitEvent } from '@rjsf/core';
-import { ILayerProps, LayerPropertiesForm } from './layerform';
-/**
- * The form to modify a vector layer.
- */
-export declare class VectorLayerPropertiesForm extends LayerPropertiesForm {
-    protected currentFormData: IVectorLayer;
-    private currentSourceId;
-    constructor(props: ILayerProps);
-    protected onFormSubmit(e: ISubmitEvent<any>): void;
-    protected onFormChange(e: IChangeEvent): void;
-    protected processSchema(data: IVectorLayer | undefined, schema: IDict, uiSchema: IDict): void;
-}
+import React from 'react';
+import type { ILayerProps } from './layerform';
+export declare function VectorLayerPropertiesForm(props: ILayerProps): React.ReactElement | null;

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

@@ -1,32 +1,39 @@
-import { LayerPropertiesForm } from './layerform';
-/**
- * The form to modify a vector layer.
- */
-export class VectorLayerPropertiesForm extends LayerPropertiesForm {
-    constructor(props) {
-        super(props);
-    }
-    onFormSubmit(e) {
-        e.formData.symbologyState = {};
-        return super.onFormSubmit(e);
-    }
-    onFormChange(e) {
-        super.onFormChange(e);
-        // We only force update if we just updated the source
-        if (this.currentSourceId === e.formData.source) {
-            return;
-        }
-        const source = this.props.model.getSource(e.formData.source);
-        if (!source || source.type !== 'VectorTileSource') {
-            return;
-        }
-    }
-    processSchema(data, schema, uiSchema) {
-        this.removeFormEntry('color', data, schema, uiSchema);
-        this.removeFormEntry('symbologyState', data, schema, uiSchema);
-        super.processSchema(data, schema, uiSchema);
-        if (!data) {
-            return;
+import React, { useMemo } from 'react';
+import { deepCopy } from "../../../tools";
+import { SchemaForm } from '../SchemaForm';
+import { processBaseSchema, removeFormEntry } from '../schemaUtils';
+import { useSchemaFormState } from '../useSchemaFormState';
+export function VectorLayerPropertiesForm(props) {
+    const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, sourceType, dialogOptions, formErrorSignal, } = props;
+    const { formData, schema, formContextValue, hasSchema, handleChangeBase, handleSubmitBase, } = useSchemaFormState({
+        sourceData,
+        schemaProp,
+        model,
+        syncData,
+        cancel: props.cancel,
+        onAfterChange: dialogOptions
+            ? (data) => {
+                dialogOptions.layerData = Object.assign({}, data);
+            }
+            : undefined,
+    });
+    const uiSchema = useMemo(() => {
+        var _a;
+        const builtUiSchema = {};
+        const dataCopy = deepCopy(formData);
+        removeFormEntry('color', formData, schema, builtUiSchema);
+        removeFormEntry('symbologyState', formData, schema, builtUiSchema);
+        processBaseSchema(dataCopy, schema, builtUiSchema, formContext, removeFormEntry);
+        if ((_a = schema.properties) === null || _a === void 0 ? void 0 : _a.source) {
+            const availableSources = model.getSourcesByType(sourceType);
+            schema.properties.source.enumNames =
+                Object.values(availableSources);
+            schema.properties.source.enum = Object.keys(availableSources);
         }
+        return builtUiSchema;
+    }, [schema, formData, formContext, model, sourceType]);
+    if (!hasSchema) {
+        return null;
     }
+    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: handleChangeBase, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, formErrorSignal: formErrorSignal }));
 }

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

@@ -1,10 +1,3 @@
-import { IDict } from '@jupytergis/schema';
-import { ISubmitEvent } from '@rjsf/core';
-import { LayerPropertiesForm } from './layerform';
-/**
- * The form to modify a hillshade layer.
- */
-export declare class WebGlLayerPropertiesForm extends LayerPropertiesForm {
-    protected onFormSubmit(e: ISubmitEvent<any>): void;
-    protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
-}
+import React from 'react';
+import type { ILayerProps } from './layerform';
+export declare function WebGlLayerPropertiesForm(props: ILayerProps): React.ReactElement | null;

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

@@ -1,15 +1,39 @@
-import { LayerPropertiesForm } from './layerform';
-/**
- * The form to modify a hillshade layer.
- */
-export class WebGlLayerPropertiesForm extends LayerPropertiesForm {
-    onFormSubmit(e) {
-        e.formData.symbologyState = {};
-        return super.onFormSubmit(e);
-    }
-    processSchema(data, schema, uiSchema) {
-        this.removeFormEntry('color', data, schema, uiSchema);
-        this.removeFormEntry('symbologyState', data, schema, uiSchema);
-        super.processSchema(data, schema, uiSchema);
+import React, { useMemo } from 'react';
+import { deepCopy } from "../../../tools";
+import { SchemaForm } from '../SchemaForm';
+import { processBaseSchema, removeFormEntry } from '../schemaUtils';
+import { useSchemaFormState } from '../useSchemaFormState';
+export function WebGlLayerPropertiesForm(props) {
+    const { schema: schemaProp, sourceData, syncData, model, filePath, formContext, sourceType, dialogOptions, formErrorSignal, } = props;
+    const { formData, schema, formContextValue, hasSchema, handleChangeBase, handleSubmitBase, } = useSchemaFormState({
+        sourceData,
+        schemaProp,
+        model,
+        syncData,
+        cancel: props.cancel,
+        onAfterChange: dialogOptions
+            ? (data) => {
+                dialogOptions.layerData = Object.assign({}, data);
+            }
+            : undefined,
+    });
+    const uiSchema = useMemo(() => {
+        var _a;
+        const builtUiSchema = {};
+        const dataCopy = deepCopy(formData);
+        removeFormEntry('color', formData, schema, builtUiSchema);
+        removeFormEntry('symbologyState', formData, schema, builtUiSchema);
+        processBaseSchema(dataCopy, schema, builtUiSchema, formContext, removeFormEntry);
+        if ((_a = schema.properties) === null || _a === void 0 ? void 0 : _a.source) {
+            const availableSources = model.getSourcesByType(sourceType);
+            schema.properties.source.enumNames =
+                Object.values(availableSources);
+            schema.properties.source.enum = Object.keys(availableSources);
+        }
+        return builtUiSchema;
+    }, [schema, formData, formContext, model, sourceType]);
+    if (!hasSchema) {
+        return null;
     }
+    return (React.createElement(SchemaForm, { schema: schema, formData: formData, onChange: handleChangeBase, onSubmit: handleSubmitBase, formContext: formContextValue, filePath: filePath, uiSchema: uiSchema, formErrorSignal: formErrorSignal }));
 }

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

@@ -1,20 +1,10 @@
-import { IDict, IJupyterGISModel } from '@jupytergis/schema';
-import { IChangeEvent } from '@rjsf/core';
-import { BaseForm, IBaseFormProps } from "../baseform";
-interface IDissolveFormOptions extends IBaseFormProps {
-    schema: IDict;
-    sourceData: IDict;
-    title: string;
-    cancelButton: (() => void) | boolean;
-    syncData: (props: IDict) => void;
+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 IDissolveFormProps extends IBaseFormProps {
+    ok?: Signal<Dialog<any>, number>;
     model: IJupyterGISModel;
 }
-export declare class DissolveForm extends BaseForm {
-    private model;
-    private features;
-    constructor(options: IDissolveFormOptions);
-    private fetchFieldNames;
-    handleFormChange(e: IChangeEvent): void;
-    private updateSchema;
-}
-export {};
+export declare function DissolveForm(props: IDissolveFormProps): React.ReactElement | null;