@jupytergis/base 0.1.1

package/lib/formbuilder/objectform/layerform.js

@@ -0,0 +1,17 @@
+import { BaseForm } from './baseform';
+export class LayerPropertiesForm extends BaseForm {
+    constructor(props) {
+        super(props);
+        this.sourceFormChangedSignal = props.sourceFormChangedSignal;
+    }
+    processSchema(data, schema, uiSchema) {
+        super.processSchema(data, schema, uiSchema);
+        if (!schema.properties.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);
+    }
+}

package/lib/formbuilder/objectform/tilesourceform.d.ts

@@ -0,0 +1,7 @@
+import { IDict } from '@jupytergis/schema';
+import { BaseForm } from './baseform';
+export declare class TileSourcePropertiesForm extends BaseForm {
+    private _urlParameters;
+    protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
+    protected onFormBlur(id: string, value: any): void;
+}

package/lib/formbuilder/objectform/tilesourceform.js

@@ -0,0 +1,60 @@
+import { BaseForm } from './baseform';
+export class TileSourcePropertiesForm extends BaseForm {
+    constructor() {
+        super(...arguments);
+        this._urlParameters = [];
+    }
+    processSchema(data, schema, uiSchema) {
+        super.processSchema(data, schema, uiSchema);
+        if (!schema.properties || !data) {
+            return;
+        }
+        // Grep all url-parameters from the url
+        const regex = /\{([^}]+)\}/g;
+        const matches = [];
+        let match;
+        while ((match = regex.exec(data.url)) !== null) {
+            if (['max_zoom', 'min_zoom', 'x', 'y', 'z'].includes(match[1])) {
+                continue;
+            }
+            matches.push(match[1]);
+        }
+        this._urlParameters = matches;
+        if (matches.length === 0) {
+            this.removeFormEntry('urlParameters', data, schema, uiSchema);
+            return;
+        }
+        // Dynamically inject url parameters schema based of the url
+        const propertiesSchema = {};
+        schema.properties.urlParameters = {
+            type: 'object',
+            required: this._urlParameters,
+            properties: propertiesSchema
+        };
+        for (const parameterName of this._urlParameters) {
+            switch (parameterName) {
+                // Special case for "time" where a date picker widget is nicer
+                case 'time':
+                    propertiesSchema[parameterName] = {
+                        type: 'string',
+                        format: 'date'
+                    };
+                    break;
+                default:
+                    propertiesSchema[parameterName] = {
+                        type: 'string'
+                    };
+                    break;
+            }
+        }
+    }
+    onFormBlur(id, value) {
+        super.onFormBlur(id, value);
+        // Is there a better way to spot the url text entry?
+        if (!id.endsWith('_url')) {
+            return;
+        }
+        // Force a rerender on url change, as it probably changes the schema
+        this.forceUpdate();
+    }
+}

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

@@ -0,0 +1,15 @@
+import { IDict, IVectorLayer } from '@jupytergis/schema';
+import { IChangeEvent } 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 sourceLayers;
+    private currentSourceId;
+    constructor(props: ILayerProps);
+    protected onFormChange(e: IChangeEvent): void;
+    protected processSchema(data: IVectorLayer | undefined, schema: IDict, uiSchema: IDict): void;
+    private fetchSourceLayers;
+}

package/lib/formbuilder/objectform/vectorlayerform.js

@@ -0,0 +1,88 @@
+import { getSourceLayerNames } from '../../tools';
+import { LayerPropertiesForm } from './layerform';
+/**
+ * The form to modify a vector layer.
+ */
+export class VectorLayerPropertiesForm extends LayerPropertiesForm {
+    constructor(props) {
+        super(props);
+        this.sourceLayers = [];
+        this.fetchSourceLayers(this.props.sourceData);
+        // If there is a source form attached, we listen to its changes
+        if (this.sourceFormChangedSignal) {
+            this.sourceFormChangedSignal.connect((sender, sourceData) => {
+                if (this.props.sourceType === 'VectorTileSource') {
+                    this.fetchSourceLayers(this.currentFormData, sourceData);
+                }
+            });
+        }
+        props.model.clientStateChanged.connect(() => {
+            var _a;
+            if (!((_a = props.model.localState) === null || _a === void 0 ? void 0 : _a.selected.value)) {
+                return;
+            }
+            const l = this.props.model.getLayer(Object.keys(props.model.localState.selected.value)[0]);
+            const source = this.props.model.getSource(l === null || l === void 0 ? void 0 : l.parameters.source);
+            if (!source || source.type !== 'VectorTileSource') {
+                return;
+            }
+            const sourceData = source.parameters;
+            this.fetchSourceLayers(this.currentFormData, sourceData);
+        });
+    }
+    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;
+        }
+        this.fetchSourceLayers(this.currentFormData, source.parameters);
+    }
+    processSchema(data, schema, uiSchema) {
+        super.processSchema(data, schema, uiSchema);
+        uiSchema['color'] = {
+            'ui:widget': 'color'
+        };
+        if (!data) {
+            return;
+        }
+        // Show a dropdown for available sourceLayers if available
+        // And automatically select one
+        if (this.sourceLayers.length !== 0) {
+            if (!data.sourceLayer || !this.sourceLayers.includes(data.sourceLayer)) {
+                data.sourceLayer = this.sourceLayers[0];
+            }
+            schema.properties.sourceLayer.enum = this.sourceLayers;
+        }
+    }
+    async fetchSourceLayers(data, sourceData) {
+        if (data && data.source) {
+            this.currentSourceId = data.source;
+            if (!sourceData) {
+                const currentSource = this.props.model.getSource(data.source);
+                if (!currentSource || currentSource.type !== 'VectorTileSource') {
+                    this.sourceLayers = [];
+                    this.forceUpdate();
+                    return;
+                }
+                sourceData = currentSource.parameters;
+            }
+            try {
+                this.sourceLayers = await getSourceLayerNames(sourceData.url, sourceData.urlParameters);
+                this.forceUpdate();
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        else {
+            this.currentSourceId = '';
+            this.sourceLayers = [];
+            this.forceUpdate();
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+import { IDict } from '@jupytergis/schema';
+import { LayerPropertiesForm } from './layerform';
+/**
+ * The form to modify a hillshade layer.
+ */
+export declare class WebGlLayerPropertiesForm extends LayerPropertiesForm {
+    protected processSchema(data: IDict<any> | undefined, schema: IDict, uiSchema: IDict): void;
+}

package/lib/formbuilder/objectform/webGlLayerForm.js

@@ -0,0 +1,10 @@
+import { LayerPropertiesForm } from './layerform';
+/**
+ * The form to modify a hillshade layer.
+ */
+export class WebGlLayerPropertiesForm extends LayerPropertiesForm {
+    processSchema(data, schema, uiSchema) {
+        this.removeFormEntry('color', data, schema, uiSchema);
+        super.processSchema(data, schema, uiSchema);
+    }
+}

package/lib/icons.d.ts

@@ -0,0 +1,6 @@
+import { LabIcon } from '@jupyterlab/ui-components';
+export declare const rasterIcon: LabIcon;
+export declare const visibilityIcon: LabIcon;
+export declare const nonVisibilityIcon: LabIcon;
+export declare const geoJSONIcon: LabIcon;
+export declare const moundIcon: LabIcon;

package/lib/icons.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+// This file is based on iconimports.ts in @jupyterlab/ui-components, but is manually generated.
+import { LabIcon } from '@jupyterlab/ui-components';
+import rasterSvgStr from '../style/icons/raster.svg';
+import visibilitySvgStr from '../style/icons/visibility.svg';
+import nonVisibilitySvgStr from '../style/icons/nonvisibility.svg';
+import geoJsonSvgStr from '../style/icons/geojson.svg';
+import moundSvgStr from '../style/icons/mound.svg';
+export const rasterIcon = new LabIcon({
+    name: 'jupytergis::raster',
+    svgstr: rasterSvgStr
+});
+export const visibilityIcon = new LabIcon({
+    name: 'jupytergis::visibility',
+    svgstr: visibilitySvgStr
+});
+export const nonVisibilityIcon = new LabIcon({
+    name: 'jupytergis::nonVisibility',
+    svgstr: nonVisibilitySvgStr
+});
+export const geoJSONIcon = new LabIcon({
+    name: 'jupytergis::geoJSON',
+    svgstr: geoJsonSvgStr
+});
+export const moundIcon = new LabIcon({
+    name: 'jupytergis::mound',
+    svgstr: moundSvgStr
+});

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+export * from './commands';
+export * from './constants';
+export * from './dialogs/formdialog';
+export * from './mainview';
+export * from './tools';
+export * from './types';
+export * from './widget';
+export * from './formbuilder/objectform/baseform';
+export * from './panelview';
+export * from './toolbar';

package/lib/index.js

@@ -0,0 +1,10 @@
+export * from './commands';
+export * from './constants';
+export * from './dialogs/formdialog';
+export * from './mainview';
+export * from './tools';
+export * from './types';
+export * from './widget';
+export * from './formbuilder/objectform/baseform';
+export * from './panelview';
+export * from './toolbar';

package/lib/mainview/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mainView';
+export * from './mainviewwidget';
+export * from './mainviewmodel';

package/lib/mainview/index.js

@@ -0,0 +1,3 @@
+export * from './mainView';
+export * from './mainviewwidget';
+export * from './mainviewmodel';

package/lib/mainview/mainView.d.ts

@@ -0,0 +1,113 @@
+import { IJGISLayer, IJGISSource } from '@jupytergis/schema';
+import { User } from '@jupyterlab/services';
+import { FeatureLike } from 'ol/Feature';
+import BaseLayer from 'ol/layer/Base';
+import { Style } from 'ol/style';
+import * as React from 'react';
+import { MainViewModel } from './mainviewmodel';
+interface IProps {
+    viewModel: MainViewModel;
+}
+interface IStates {
+    id: string;
+    loading: boolean;
+    lightTheme: boolean;
+    remoteUser?: User.IIdentity | null;
+    firstLoad: boolean;
+}
+export declare class MainView extends React.Component<IProps, IStates> {
+    constructor(props: IProps);
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    generateScene(): Promise<void>;
+    /**
+     * Add a source in the map.
+     *
+     * @param id - the source id.
+     * @param source - the source object.
+     */
+    addSource(id: string, source: IJGISSource): Promise<void>;
+    private computeSourceUrl;
+    /**
+     * Update a source in the map.
+     *
+     * @param id - the source id.
+     * @param source - the source object.
+     */
+    updateSource(id: string, source: IJGISSource): Promise<void>;
+    /**
+     * Remove a source from the map.
+     *
+     * @param id - the source id.
+     */
+    removeSource(id: string): void;
+    /**
+     * Add or move the layers of the map.
+     *
+     * @param layerIds - the list of layers in the depth order (beneath first).
+     */
+    updateLayers(layerIds: string[]): void;
+    private _updateLayersImpl;
+    /**
+     * Add a layer to the map.
+     *
+     * @param id - id of the layer.
+     * @param layer - the layer object.
+     * @param index - expected index of the layer.
+     */
+    addLayer(id: string, layer: IJGISLayer, index: number): Promise<void>;
+    vectorLayerStyleFunc: (currentFeature: FeatureLike, layer: IJGISLayer) => Style | undefined;
+    /**
+     * Taken from https://openlayers.org/en/latest/examples/webgl-shaded-relief.html
+     * @returns
+     */
+    private hillshadeMath;
+    /**
+     * Move a layer in the stack.
+     *
+     * @param id - id of the layer.
+     * @param index - expected index of the layer.
+     */
+    moveLayer(id: string, index: number | undefined): void;
+    /**
+     * Update a layer of the map.
+     *
+     * @param id - id of the layer.
+     * @param layer - the layer object.
+     */
+    updateLayer(id: string, layer: IJGISLayer, mapLayer: BaseLayer): Promise<void>;
+    /**
+     * Remove a layer from the map.
+     *
+     * @param id - the id of the layer.
+     */
+    removeLayer(id: string): void;
+    private _onClientSharedStateChanged;
+    private _onSharedOptionsChanged;
+    private updateOptions;
+    private _onViewChanged;
+    /**
+     * Convenience method to get a specific layer from OpenLayers Map
+     * @param id Layer to retrieve
+     */
+    private getLayer;
+    /**
+     * Convenience method to get list layer IDs from the OpenLayers Map
+     */
+    private getLayers;
+    private _onLayersChanged;
+    private _onLayerTreeChange;
+    private _onSourcesChange;
+    private _handleThemeChange;
+    private _handleWindowResize;
+    render(): JSX.Element;
+    private _initializedPosition;
+    private divRef;
+    private _Map;
+    private _model;
+    private _mainViewModel;
+    private _ready;
+    private _sources;
+    private _sourceToLayerMap;
+}
+export {};