@jupytergis/base 0.15.0 → 0.16.0-alpha.0

package/lib/panelview/leftpanel.js

@@ -1,139 +0,0 @@
-import * as React from 'react';
-import Draggable from 'react-draggable';
-import { CommandIDs } from '../constants';
-import { LayersBodyComponent } from './components/layers';
-import { PanelTabs, TabsContent, TabsList, TabsTrigger, } from '../shared/components/Tabs';
-import StacPanel from '../stacBrowser/components/StacPanel';
-export const LeftPanel = (props) => {
-    var _a;
-    const [options, setOptions] = React.useState(props.model.getOptions());
-    const storyMapPresentationMode = (_a = options.storyMapPresentationMode) !== null && _a !== void 0 ? _a : false;
-    const [layerTree, setLayerTree] = React.useState(props.model.getLayerTree());
-    const hasSyncedInitialSelectionRef = React.useRef(false);
-    const tabInfo = [
-        !props.settings.layersDisabled
-            ? { name: 'layers', title: 'Layers' }
-            : false,
-        !props.settings.stacBrowserDisabled && !storyMapPresentationMode
-            ? { name: 'stac', title: 'Stac Browser' }
-            : false,
-        !props.settings.storyMapsDisabled
-            ? { name: 'segments', title: 'Segments' }
-            : false,
-    ].filter(Boolean);
-    const [curTab, setCurTab] = React.useState(tabInfo.length > 0 ? tabInfo[0].name : undefined);
-    React.useEffect(() => {
-        const onOptionsChanged = () => {
-            setOptions(Object.assign({}, props.model.getOptions()));
-        };
-        const updateLayerTree = () => {
-            const freshTree = props.model.getLayerTree() || [];
-            setLayerTree(freshTree);
-            // Sync selected to top layer/group only the first time the tree has items
-            if (!hasSyncedInitialSelectionRef.current && freshTree.length > 0) {
-                hasSyncedInitialSelectionRef.current = true;
-                const lastItem = freshTree[freshTree.length - 1];
-                const lastId = typeof lastItem === 'string' ? lastItem : lastItem === null || lastItem === void 0 ? void 0 : lastItem.name;
-                const lastType = typeof lastItem === 'string' ? 'layer' : 'group';
-                if (lastId) {
-                    props.model.syncSelected({ [lastId]: { type: lastType } }, props.model.getClientId().toString());
-                }
-            }
-            // Need to let command know when segments get populated
-            props.commands.notifyCommandChanged(CommandIDs.toggleStoryPresentationMode);
-        };
-        const onSegmentAdded = (_sender, payload) => {
-            props.model.syncSelected({ [payload.storySegmentId]: { type: 'layer' } }, props.model.getClientId().toString());
-            setCurTab('segments');
-        };
-        props.model.sharedOptionsChanged.connect(onOptionsChanged);
-        props.model.sharedModel.layersChanged.connect(updateLayerTree);
-        props.model.sharedModel.layerTreeChanged.connect(updateLayerTree);
-        props.model.segmentAdded.connect(onSegmentAdded);
-        updateLayerTree();
-        return () => {
-            props.model.sharedOptionsChanged.disconnect(onOptionsChanged);
-            props.model.sharedModel.layersChanged.disconnect(updateLayerTree);
-            props.model.sharedModel.layerTreeChanged.disconnect(updateLayerTree);
-            props.model.segmentAdded.disconnect(onSegmentAdded);
-        };
-    }, [props.model]);
-    // Since story segments are technically layers they are stored in the layer tree, so we separate them
-    // from regular layers. Process the tree once to build both filtered and story segment trees.
-    const { filteredLayerTree, storySegmentLayerTree } = React.useMemo(() => {
-        const filtered = [];
-        const storySegments = [];
-        const processLayer = (layer) => {
-            if (typeof layer === 'string') {
-                const layerData = props.model.getLayer(layer);
-                const isStorySegment = (layerData === null || layerData === void 0 ? void 0 : layerData.type) === 'StorySegmentLayer';
-                return {
-                    filtered: isStorySegment ? null : layer,
-                    storySegment: isStorySegment ? layer : null,
-                };
-            }
-            // For layer groups, recursively process their layers
-            const filteredGroupLayers = [];
-            const storySegmentGroupLayers = [];
-            for (const groupLayer of layer.layers) {
-                const result = processLayer(groupLayer);
-                if (result.filtered !== null) {
-                    filteredGroupLayers.push(result.filtered);
-                }
-                if (result.storySegment !== null) {
-                    storySegmentGroupLayers.push(result.storySegment);
-                }
-            }
-            return {
-                filtered: filteredGroupLayers.length > 0
-                    ? Object.assign(Object.assign({}, layer), { layers: filteredGroupLayers }) : null,
-                storySegment: storySegmentGroupLayers.length > 0
-                    ? Object.assign(Object.assign({}, layer), { layers: storySegmentGroupLayers }) : null,
-            };
-        };
-        for (const layer of layerTree) {
-            const result = processLayer(layer);
-            if (result.filtered !== null) {
-                filtered.push(result.filtered);
-            }
-            if (result.storySegment !== null) {
-                storySegments.push(result.storySegment);
-            }
-        }
-        // Reverse filteredLayerTree before returning
-        filtered.reverse();
-        return {
-            filteredLayerTree: filtered,
-            storySegmentLayerTree: storySegments,
-        };
-    }, [layerTree]);
-    // Updates story segments array based on layer tree array
-    React.useEffect(() => {
-        const { storyId, story } = props.model.getSelectedStory();
-        if (!story) {
-            return;
-        }
-        props.model.sharedModel.updateStoryMap(storyId, Object.assign(Object.assign({}, story), { storySegments: storySegmentLayerTree }));
-    }, [storySegmentLayerTree]);
-    const allLeftTabsDisabled = props.settings.layersDisabled &&
-        props.settings.stacBrowserDisabled &&
-        props.settings.storyMapsDisabled;
-    const leftPanelVisible = !props.settings.leftPanelDisabled && !allLeftTabsDisabled;
-    return (React.createElement(Draggable, { handle: ".jgis-tabs-list", cancel: ".jgis-tabs-trigger", bounds: ".jGIS-Mainview-Container" },
-        React.createElement("div", { className: "jgis-left-panel-container", style: { display: leftPanelVisible ? 'block' : 'none' } },
-            React.createElement(PanelTabs, { curTab: curTab, className: "jgis-panel-tabs" },
-                React.createElement(TabsList, null, tabInfo.map(tab => (React.createElement(TabsTrigger, { className: "jGIS-layer-browser-category", key: tab.name, value: tab.name, onClick: () => {
-                        if (curTab !== tab.name) {
-                            setCurTab(tab.name);
-                        }
-                        else {
-                            setCurTab('');
-                        }
-                    } }, tab.title)))),
-                !props.settings.layersDisabled && (React.createElement(TabsContent, { value: "layers", className: "jgis-panel-tab-content jp-gis-layerPanel" },
-                    React.createElement(LayersBodyComponent, { model: props.model, commands: props.commands, state: props.state, layerTree: filteredLayerTree }))),
-                !props.settings.stacBrowserDisabled && (React.createElement(TabsContent, { value: "stac", className: "jgis-panel-tab-content jgis-panel-tab-content-stac-panel" },
-                    React.createElement(StacPanel, { model: props.model }))),
-                !props.settings.storyMapsDisabled && (React.createElement(TabsContent, { value: "segments", className: "jgis-panel-tab-content" },
-                    React.createElement(LayersBodyComponent, { model: props.model, commands: props.commands, state: props.state, layerTree: storySegmentLayerTree })))))));
-};

package/lib/panelview/story-maps/StoryViewerPanel.js

@@ -1,116 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import StoryContentSection from './components/StoryContentSection';
-import StoryImageSection from './components/StoryImageSection';
-import StoryNavBar from './components/StoryNavBar';
-import StorySubtitleSection from './components/StorySubtitleSection';
-import StoryTitleSection from './components/StoryTitleSection';
-/**
- * Returns which section should render the nav bar, or null if nav should be hidden.
- */
-function getStoryNavPlacement(isSpecta, hasImage, storyType, isMobile) {
-    if (isSpecta) {
-        return isMobile ? null : 'subtitle-specta';
-    }
-    if (storyType !== 'guided') {
-        return null;
-    }
-    return hasImage ? 'over-image' : 'below-title';
-}
-/**
- * Story viewer (presentational). Receives story state and callbacks from parent.
- * Desktop scroll/sentinel/imperative handle live in SpectaDesktopView.
- */
-function StoryViewerPanel({ model, isSpecta, isMobile = false, segmentContainerRef, storyData, currentIndex, activeSlide, layerName, handlePrev, handleNext, hasPrev, hasNext, setIndex, }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-    const [imageLoaded, setImageLoaded] = useState(false);
-    // Prefetch image when slide changes
-    useEffect(() => {
-        var _a;
-        const imageUrl = (_a = activeSlide === null || activeSlide === void 0 ? void 0 : activeSlide.content) === null || _a === void 0 ? void 0 : _a.image;
-        if (!imageUrl) {
-            setImageLoaded(false);
-            return;
-        }
-        // Reset state
-        setImageLoaded(false);
-        // Preload the image
-        const img = new Image();
-        img.onload = () => {
-            setImageLoaded(true);
-        };
-        img.onerror = () => {
-            setImageLoaded(false);
-        };
-        img.src = imageUrl;
-        // Cleanup: abort loading if component unmounts or slide changes
-        return () => {
-            img.onload = null;
-            img.onerror = null;
-        };
-    }, [(_a = activeSlide === null || activeSlide === void 0 ? void 0 : activeSlide.content) === null || _a === void 0 ? void 0 : _a.image]);
-    // ! TODO come back for this
-    // Listen for layer selection changes in unguided mode
-    useEffect(() => {
-        // ! TODO this logic (getting a single selected layer) is also in the processing index.ts, move to tools
-        const handleSelectedStorySegmentChange = () => {
-            var _a, _b;
-            // This is just to update the displayed content
-            // So bail early if we don't need to do that
-            if (!storyData || storyData.storyType !== 'unguided') {
-                return;
-            }
-            const localState = model.sharedModel.awareness.getLocalState();
-            if (!localState || !((_a = localState['selected']) === null || _a === void 0 ? void 0 : _a.value)) {
-                return;
-            }
-            const selectedLayers = Object.keys(localState['selected'].value);
-            // Ensure only one layer is selected
-            if (selectedLayers.length !== 1) {
-                return;
-            }
-            const selectedLayerId = selectedLayers[0];
-            const selectedLayer = model.getLayer(selectedLayerId);
-            if (!selectedLayer || selectedLayer.type !== 'StorySegmentLayer') {
-                return;
-            }
-            const index = (_b = storyData.storySegments) === null || _b === void 0 ? void 0 : _b.indexOf(selectedLayerId);
-            if (index === undefined || index === -1) {
-                return;
-            }
-            setIndex(index);
-        };
-        // ! TODO really only want to connect this un unguided mode
-        model.sharedModel.awareness.on('change', handleSelectedStorySegmentChange);
-        return () => {
-            model.sharedModel.awareness.off('change', handleSelectedStorySegmentChange);
-        };
-    }, [model, storyData, setIndex]);
-    if (!storyData || ((_b = storyData === null || storyData === void 0 ? void 0 : storyData.storySegments) === null || _b === void 0 ? void 0 : _b.length) === 0) {
-        return (React.createElement("div", { style: { padding: '1rem' } },
-            React.createElement("p", null, "No Segments available. Add one using the Add Layer menu.")));
-    }
-    const storyNavBarProps = {
-        onPrev: handlePrev,
-        onNext: handleNext,
-        hasPrev,
-        hasNext,
-    };
-    const hasImage = !!(((_c = activeSlide === null || activeSlide === void 0 ? void 0 : activeSlide.content) === null || _c === void 0 ? void 0 : _c.image) && imageLoaded);
-    const storyType = (_d = storyData.storyType) !== null && _d !== void 0 ? _d : 'guided';
-    const navPlacement = getStoryNavPlacement(isSpecta, hasImage, storyType, isMobile);
-    const navSlot = navPlacement !== null ? (React.createElement(StoryNavBar, Object.assign({ placement: navPlacement }, storyNavBarProps))) : null;
-    // Get transition time from current segment, default to 0.3s
-    const transitionTime = (_f = (_e = activeSlide === null || activeSlide === void 0 ? void 0 : activeSlide.transition) === null || _e === void 0 ? void 0 : _e.time) !== null && _f !== void 0 ? _f : 0.3;
-    return (React.createElement("div", { className: "jgis-story-viewer-panel" },
-        React.createElement("div", { ref: segmentContainerRef, key: currentIndex, className: "jgis-story-segment-container", style: {
-                animationDuration: `${transitionTime}s`,
-            } },
-            React.createElement("div", { id: "jgis-story-segment-header" },
-                React.createElement("h1", { className: "jgis-story-viewer-title" }, layerName !== null && layerName !== void 0 ? layerName : `Slide ${currentIndex + 1}`),
-                ((_g = activeSlide === null || activeSlide === void 0 ? void 0 : activeSlide.content) === null || _g === void 0 ? void 0 : _g.image) && imageLoaded ? (React.createElement(StoryImageSection, { imageUrl: activeSlide.content.image, imageLoaded: imageLoaded, layerName: layerName !== null && layerName !== void 0 ? layerName : '', slideNumber: currentIndex, navSlot: navPlacement === 'over-image' ? navSlot : null })) : (React.createElement(StoryTitleSection, { title: (_h = storyData.title) !== null && _h !== void 0 ? _h : '', navSlot: navPlacement === 'below-title' ? navSlot : null })),
-                React.createElement(StorySubtitleSection, { title: (_k = (_j = activeSlide === null || activeSlide === void 0 ? void 0 : activeSlide.content) === null || _j === void 0 ? void 0 : _j.title) !== null && _k !== void 0 ? _k : '', navSlot: navPlacement === 'subtitle-specta' ? navSlot : null })),
-            React.createElement("div", { id: "jgis-story-segment-content" },
-                React.createElement(StoryContentSection, { markdown: (_m = (_l = activeSlide === null || activeSlide === void 0 ? void 0 : activeSlide.content) === null || _l === void 0 ? void 0 : _l.markdown) !== null && _m !== void 0 ? _m : '' })))));
-}
-StoryViewerPanel.displayName = 'StoryViewerPanel';
-export default StoryViewerPanel;

package/lib/panelview/story-maps/components/SpectaDesktopView.js

@@ -1,49 +0,0 @@
-import React, { useEffect, useImperativeHandle, useRef, } from 'react';
-import StoryViewerPanel from "../StoryViewerPanel";
-import SpectaPresentationProgressBar from "../../../statusbar/SpectaPresentationProgressBar";
-export function SpectaDesktopView({ model, isSpecta, containerRef, storyViewerPanelRef, segmentContainerRef, storyData, currentIndex, activeSlide, layerName, handlePrev, handleNext, hasPrev, hasNext, showGradient, setIndex, }) {
-    const scrollContainerRef = useRef(null);
-    const topSentinelRef = useRef(null);
-    const bottomSentinelRef = useRef(null);
-    const atTopRef = useRef(false);
-    const atBottomRef = useRef(false);
-    useEffect(() => {
-        const root = scrollContainerRef.current;
-        const topEl = topSentinelRef.current;
-        const bottomEl = bottomSentinelRef.current;
-        if (!root || !topEl || !bottomEl) {
-            return;
-        }
-        const observer = new IntersectionObserver((entries) => {
-            for (const entry of entries) {
-                if (entry.target === topEl) {
-                    atTopRef.current = entry.isIntersecting;
-                }
-                else if (entry.target === bottomEl) {
-                    atBottomRef.current = entry.isIntersecting;
-                }
-            }
-        }, { root, threshold: 0, rootMargin: '0px' });
-        observer.observe(topEl);
-        observer.observe(bottomEl);
-        return () => observer.disconnect();
-    }, [currentIndex]);
-    useImperativeHandle(storyViewerPanelRef, () => ({
-        handlePrev,
-        handleNext,
-        spectaMode: isSpecta,
-        hasPrev,
-        hasNext,
-        getAtTop: () => atTopRef.current,
-        getAtBottom: () => atBottomRef.current,
-        getScrollContainer: () => scrollContainerRef.current,
-    }), [handlePrev, handleNext, isSpecta, hasPrev, hasNext]);
-    return (React.createElement(React.Fragment, null,
-        React.createElement("div", { className: "jgis-specta-right-panel-container-mod jgis-right-panel-container", style: showGradient ? undefined : { width: '25%', borderRadius: 0 } },
-            React.createElement("div", { ref: containerRef, className: "jgis-specta-story-panel-container" },
-                React.createElement("div", { ref: scrollContainerRef, className: "jgis-story-viewer-panel-specta-mod", id: "jgis-story-segment-panel", style: showGradient ? undefined : { width: 'unset' } },
-                    React.createElement("div", { ref: topSentinelRef, "aria-hidden": true, "data-story-scroll-sentinel": "top", style: { height: 1, minHeight: 1, pointerEvents: 'none' } }),
-                    React.createElement(StoryViewerPanel, { model: model, isSpecta: isSpecta, segmentContainerRef: segmentContainerRef, storyData: storyData, currentIndex: currentIndex, activeSlide: activeSlide, layerName: layerName, handlePrev: handlePrev, handleNext: handleNext, hasPrev: hasPrev, hasNext: hasNext, setIndex: setIndex }),
-                    React.createElement("div", { ref: bottomSentinelRef, "aria-hidden": true, "data-story-scroll-sentinel": "bottom", style: { height: 1, minHeight: 1, pointerEvents: 'none' } })))),
-        React.createElement(SpectaPresentationProgressBar, { model: model })));
-}

package/lib/processing/index.js

@@ -1,200 +0,0 @@
-import { processingList, } from '@jupytergis/schema';
-import { UUID } from '@lumino/coreutils';
-import { ProcessingFormDialog } from '../dialogs/ProcessingFormDialog';
-import { getGdal } from '../gdal';
-import { processingFormToParam } from './processingFormToParam';
-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 processLayer(tracker, formSchemaRegistry, processingType, processingOptions, app, filePath, processingInputs) {
-    var _a, _b, _c, _d;
-    // Resolve widget
-    const widget = filePath
-        ? tracker.find(w => w.model.filePath === filePath)
-        : tracker.currentWidget;
-    if (!widget) {
-        return;
-    }
-    const model = widget.model;
-    const sources = (_a = model.sharedModel.sources) !== null && _a !== void 0 ? _a : {};
-    const layers = (_b = model.sharedModel.layers) !== null && _b !== void 0 ? _b : {};
-    // Resolve layer
-    let selected = null;
-    if (processingInputs === null || processingInputs === void 0 ? void 0 : processingInputs.inputLayer) {
-        selected = layers[processingInputs.inputLayer];
-    }
-    else {
-        selected = getSingleSelectedLayer(tracker);
-    }
-    if (!selected) {
-        return;
-    }
-    const geojsonString = await getLayerGeoJSON(selected, sources, model);
-    if (!geojsonString) {
-        return;
-    }
-    // Resolve params
-    let processParam;
-    let embedOutputLayer = true;
-    let outputLayerName = selected.name;
-    if (processingInputs) {
-        processParam = processingInputs;
-        outputLayerName = `${processingType} Layer`;
-    }
-    else {
-        const schema = Object.assign({}, formSchemaRegistry.getSchemas().get(processingType));
-        const selectedLayerId = Object.keys(((_d = (_c = model.sharedModel.awareness.getLocalState()) === null || _c === void 0 ? void 0 : _c.selected) === null || _d === void 0 ? void 0 : _d.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;
-        }
-        if (!processingList.includes(processingType)) {
-            console.error(`Unsupported processing type: ${processingType}`);
-            return;
-        }
-        processParam = processingFormToParam(formValues, processingType);
-        embedOutputLayer = formValues.embedOutputLayer;
-        outputLayerName = formValues.outputLayerName;
-    }
-    // GDAL pre-processing
-    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, 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);
-    const layerName = `${layerNamePrefix} ${processingType.charAt(0).toUpperCase() + processingType.slice(1)}`;
-    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: layerName,
-        };
-        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: `${layerName} Source`,
-            parameters: { data: processedGeoJSON },
-        };
-        const layerModel = {
-            type: 'VectorLayer',
-            parameters: { source: newSourceId },
-            visible: true,
-            name: layerName,
-        };
-        model.sharedModel.addSource(newSourceId, sourceModel);
-        model.addLayer(UUID.uuid4(), layerModel);
-    }
-}

package/lib/processing/processingCommands.js

@@ -1,67 +0,0 @@
-import { ProcessingMerge, ProcessingLogicType, } from '@jupytergis/schema';
-import { selectedLayerIsOfType, processLayer } from './index';
-export function replaceInSql(sql, keyToVal, layerName) {
-    const replaceTemplateString = (args) => args.template.replace(RegExp(`{${args.variableName}}`, 'g'), args.value);
-    let out = replaceTemplateString({
-        variableName: 'layerName',
-        template: sql,
-        value: layerName,
-    });
-    for (const [key, value] of Object.entries(keyToVal)) {
-        out = replaceTemplateString({
-            variableName: key,
-            template: out,
-            value: value,
-        });
-    }
-    return out;
-}
-export function addProcessingCommands(app, commands, tracker, trans, formSchemaRegistry, processingSchemas) {
-    for (const processingElement of ProcessingMerge) {
-        const schemaKey = Object.keys(processingSchemas).find(k => k.toLowerCase() === processingElement.name.toLowerCase());
-        if (!schemaKey) {
-            continue;
-        }
-        if (processingElement.type === ProcessingLogicType.vector) {
-            commands.addCommand(`jupytergis:${processingElement.name}`, {
-                label: trans.__(processingElement.label),
-                describedBy: {
-                    args: {
-                        type: 'object',
-                        properties: {
-                            filePath: {
-                                type: 'string',
-                                description: 'Path to the .jGIS file',
-                            },
-                            layerId: {
-                                type: 'string',
-                                description: 'Layer ID to process',
-                            },
-                            params: processingSchemas[schemaKey],
-                        },
-                    },
-                },
-                isEnabled: () => selectedLayerIsOfType(['VectorLayer'], tracker),
-                execute: async (args) => {
-                    await processLayer(tracker, formSchemaRegistry, processingElement.description, {
-                        sqlQueryFn: (layerName, keyToVal) => replaceInSql(processingElement.operations.sql, keyToVal, layerName),
-                        gdalFunction: processingElement.operations.gdalFunction,
-                        options: (sqlQuery) => [
-                            '-f',
-                            'GeoJSON',
-                            '-dialect',
-                            'SQLITE',
-                            '-sql',
-                            sqlQuery,
-                            'output.geojson',
-                        ],
-                    }, app, args === null || args === void 0 ? void 0 : args.filePath, args === null || args === void 0 ? void 0 : args.processingInputs);
-                },
-            });
-        }
-        else {
-            console.error('Unsupported process type');
-            return;
-        }
-    }
-}