@jupytergis/base 0.9.0 → 0.9.2

package/lib/dialogs/symbology/colorRampUtils.d.ts

@@ -0,0 +1,19 @@
+export interface IColorMap {
+    name: ColorRampName;
+    colors: string[];
+}
+export declare const COLOR_RAMP_NAMES: readonly ["jet", "hot", "cool", "spring", "summer", "autumn", "winter", "bone", "copper", "greys", "YiGnBu", "greens", "YiOrRd", "bluered", "RdBu", "rainbow", "portland", "blackbody", "earth", "electric", "viridis", "inferno", "magma", "plasma", "warm", "bathymetry", "cdom", "chlorophyll", "density", "freesurface-blue", "freesurface-red", "oxygen", "par", "phase", "salinity", "temperature", "turbidity", "velocity-blue", "velocity-green", "ice", "oxy", "matter", "amp", "tempo", "rain", "topo", "balance", "delta", "curl", "diff", "tarn"];
+export type ColorRampName = (typeof COLOR_RAMP_NAMES)[number];
+export declare const getColorMapList: () => IColorMap[];
+/**
+ * Hook that loads and sets color maps.
+ */
+export declare const useColorMapList: (setColorMaps: (maps: IColorMap[]) => void) => void;
+/**
+ * Ensure we always get a valid hex string from either an RGB(A) array or string.
+ */
+export declare const ensureHexColorCode: (color: number[] | string) => string;
+/**
+ * Convert hex to [r,g,b,a] array.
+ */
+export declare function hexToRgb(hex: string): [number, number, number, number];

package/lib/dialogs/symbology/colorRampUtils.js

@@ -0,0 +1,126 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import colormap from 'colormap';
+import colorScale from 'colormap/colorScale.js';
+import { useEffect } from 'react';
+import rawCmocean from "./components/color_ramp/cmocean.json";
+const { __license__: _ } = rawCmocean, cmocean = __rest(rawCmocean, ["__license__"]);
+Object.assign(colorScale, cmocean);
+export const COLOR_RAMP_NAMES = [
+    'jet',
+    // 'hsv', 11 steps min
+    'hot',
+    'cool',
+    'spring',
+    'summer',
+    'autumn',
+    'winter',
+    'bone',
+    'copper',
+    'greys',
+    'YiGnBu',
+    'greens',
+    'YiOrRd',
+    'bluered',
+    'RdBu',
+    // 'picnic', 11 steps min
+    'rainbow',
+    'portland',
+    'blackbody',
+    'earth',
+    'electric',
+    'viridis',
+    'inferno',
+    'magma',
+    'plasma',
+    'warm',
+    // 'rainbow-soft', 11 steps min
+    'bathymetry',
+    'cdom',
+    'chlorophyll',
+    'density',
+    'freesurface-blue',
+    'freesurface-red',
+    'oxygen',
+    'par',
+    'phase',
+    'salinity',
+    'temperature',
+    'turbidity',
+    'velocity-blue',
+    'velocity-green',
+    // 'cubehelix' 16 steps min
+    'ice',
+    'oxy',
+    'matter',
+    'amp',
+    'tempo',
+    'rain',
+    'topo',
+    'balance',
+    'delta',
+    'curl',
+    'diff',
+    'tarn',
+];
+export const getColorMapList = () => {
+    const colorMapList = [];
+    COLOR_RAMP_NAMES.forEach(name => {
+        const colorRamp = colormap({
+            colormap: name,
+            nshades: 255,
+            format: 'rgbaString',
+        });
+        colorMapList.push({ name, colors: colorRamp });
+    });
+    return colorMapList;
+};
+/**
+ * Hook that loads and sets color maps.
+ */
+export const useColorMapList = (setColorMaps) => {
+    useEffect(() => {
+        setColorMaps(getColorMapList());
+    }, [setColorMaps]);
+};
+/**
+ * Ensure we always get a valid hex string from either an RGB(A) array or string.
+ */
+export const ensureHexColorCode = (color) => {
+    if (typeof color === 'string') {
+        return color;
+    }
+    // color must be an RGBA array
+    const hex = color
+        .slice(0, -1) // Color input doesn't support hex alpha values so cut that out
+        .map((val) => {
+        return val.toString(16).padStart(2, '0');
+    })
+        .join('');
+    return '#' + hex;
+};
+/**
+ * Convert hex to [r,g,b,a] array.
+ */
+export function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    if (!result) {
+        console.warn('Unable to parse hex value, defaulting to black');
+        return [0, 0, 0, 255];
+    }
+    return [
+        parseInt(result[1], 16),
+        parseInt(result[2], 16),
+        parseInt(result[3], 16),
+        255, // TODO: Make alpha customizable?
+    ];
+}

package/lib/dialogs/symbology/components/color_ramp/CanvasSelectComponent.js

@@ -1,69 +1,12 @@
 import { Button } from '@jupyterlab/ui-components';
-import colormap from 'colormap';
 import React, { useEffect, useRef, useState } from 'react';
+import { useColorMapList } from "../../colorRampUtils";
 import ColorRampEntry from './ColorRampEntry';
 const CanvasSelectComponent = ({ selectedRamp, setSelected, }) => {
-    const colorRampNames = [
-        'jet',
-        // 'hsv', 11 steps min
-        'hot',
-        'cool',
-        'spring',
-        'summer',
-        'autumn',
-        'winter',
-        'bone',
-        'copper',
-        'greys',
-        'YiGnBu',
-        'greens',
-        'YiOrRd',
-        'bluered',
-        'RdBu',
-        // 'picnic', 11 steps min
-        'rainbow',
-        'portland',
-        'blackbody',
-        'earth',
-        'electric',
-        'viridis',
-        'inferno',
-        'magma',
-        'plasma',
-        'warm',
-        // 'rainbow-soft', 11 steps min
-        'bathymetry',
-        'cdom',
-        'chlorophyll',
-        'density',
-        'freesurface-blue',
-        'freesurface-red',
-        'oxygen',
-        'par',
-        'phase',
-        'salinity',
-        'temperature',
-        'turbidity',
-        'velocity-blue',
-        'velocity-green',
-        // 'cubehelix' 16 steps min
-    ];
     const containerRef = useRef(null);
     const [isOpen, setIsOpen] = useState(false);
     const [colorMaps, setColorMaps] = useState([]);
-    useEffect(() => {
-        const colorMapList = [];
-        colorRampNames.forEach(name => {
-            const colorRamp = colormap({
-                colormap: name,
-                nshades: 255,
-                format: 'rgbaString',
-            });
-            const colorMap = { name: name, colors: colorRamp };
-            colorMapList.push(colorMap);
-            setColorMaps(colorMapList);
-        });
-    }, []);
+    useColorMapList(setColorMaps);
     useEffect(() => {
         if (colorMaps.length > 0) {
             updateCanvas(selectedRamp);

package/lib/dialogs/symbology/components/color_ramp/ColorRamp.js

@@ -9,9 +9,11 @@ const ColorRamp = ({ layerParams, modeOptions, classifyFunc, showModeRow, showRa
     const [numberOfShades, setNumberOfShades] = useState('');
     const [isLoading, setIsLoading] = useState(false);
     useEffect(() => {
-        populateOptions();
+        if (selectedRamp === '' && selectedMode === '' && numberOfShades === '') {
+            populateOptions();
+        }
     }, [layerParams]);
-    const populateOptions = async () => {
+    const populateOptions = () => {
         let nClasses, singleBandMode, colorRamp;
         if (layerParams.symbologyState) {
             nClasses = layerParams.symbologyState.nClasses;

package/lib/dialogs/symbology/components/color_ramp/cmocean.json

@@ -0,0 +1,459 @@
+{
+    "__license__": "The MIT License (MIT) Copyright (c) 2015 Kristen M. Thyng Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in alL copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
+    "ice": [
+        {
+            "index": 0.0,
+            "rgb": [3, 5, 18]
+        },
+        {
+            "index": 0.125,
+            "rgb": [33, 32, 65]
+        },
+        {
+            "index": 0.25,
+            "rgb": [56, 56, 116]
+        },
+        {
+            "index": 0.375,
+            "rgb": [62, 87, 163]
+        },
+        {
+            "index": 0.5,
+            "rgb": [66, 122, 183]
+        },
+        {
+            "index": 0.625,
+            "rgb": [88, 157, 195]
+        },
+        {
+            "index": 0.75,
+            "rgb": [122, 190, 208]
+        },
+        {
+            "index": 0.875,
+            "rgb": [176, 221, 225]
+        },
+        {
+            "index": 1.0,
+            "rgb": [234, 252, 253]
+        }
+    ],
+    "oxy": [
+        {
+            "index": 0.0,
+            "rgb": [63, 5, 5]
+        },
+        {
+            "index": 0.125,
+            "rgb": [118, 5, 15]
+        },
+        {
+            "index": 0.25,
+            "rgb": [91, 91, 90]
+        },
+        {
+            "index": 0.375,
+            "rgb": [122, 121, 121]
+        },
+        {
+            "index": 0.5,
+            "rgb": [154, 154, 153]
+        },
+        {
+            "index": 0.625,
+            "rgb": [190, 189, 188]
+        },
+        {
+            "index": 0.75,
+            "rgb": [229, 229, 228]
+        },
+        {
+            "index": 0.875,
+            "rgb": [232, 224, 50]
+        },
+        {
+            "index": 1.0,
+            "rgb": [220, 174, 25]
+        }
+    ],
+    "matter": [
+        {
+            "index": 0.0,
+            "rgb": [253, 237, 176]
+        },
+        {
+            "index": 0.125,
+            "rgb": [249, 192, 135]
+        },
+        {
+            "index": 0.25,
+            "rgb": [241, 148, 102]
+        },
+        {
+            "index": 0.375,
+            "rgb": [229, 105, 83]
+        },
+        {
+            "index": 0.5,
+            "rgb": [206, 67, 86]
+        },
+        {
+            "index": 0.625,
+            "rgb": [171, 41, 96]
+        },
+        {
+            "index": 0.75,
+            "rgb": [130, 27, 98]
+        },
+        {
+            "index": 0.875,
+            "rgb": [87, 22, 86]
+        },
+        {
+            "index": 1.0,
+            "rgb": [47, 15, 61]
+        }
+    ],
+    "amp": [
+        {
+            "index": 0.0,
+            "rgb": [241, 236, 236]
+        },
+        {
+            "index": 0.125,
+            "rgb": [226, 199, 190]
+        },
+        {
+            "index": 0.25,
+            "rgb": [215, 162, 144]
+        },
+        {
+            "index": 0.375,
+            "rgb": [204, 125, 99]
+        },
+        {
+            "index": 0.5,
+            "rgb": [191, 88, 58]
+        },
+        {
+            "index": 0.625,
+            "rgb": [174, 46, 36]
+        },
+        {
+            "index": 0.75,
+            "rgb": [142, 16, 40]
+        },
+        {
+            "index": 0.875,
+            "rgb": [100, 14, 35]
+        },
+        {
+            "index": 1.0,
+            "rgb": [60, 9, 17]
+        }
+    ],
+    "tempo": [
+        {
+            "index": 0.0,
+            "rgb": [254, 245, 244]
+        },
+        {
+            "index": 0.125,
+            "rgb": [210, 217, 198]
+        },
+        {
+            "index": 0.25,
+            "rgb": [161, 193, 161]
+        },
+        {
+            "index": 0.375,
+            "rgb": [105, 171, 137]
+        },
+        {
+            "index": 0.5,
+            "rgb": [42, 147, 127]
+        },
+        {
+            "index": 0.625,
+            "rgb": [17, 118, 118]
+        },
+        {
+            "index": 0.75,
+            "rgb": [26, 88, 103]
+        },
+        {
+            "index": 0.875,
+            "rgb": [26, 59, 84]
+        },
+        {
+            "index": 1.0,
+            "rgb": [20, 29, 67]
+        }
+    ],
+    "rain": [
+        {
+            "index": 0.0,
+            "rgb": [238, 237, 242]
+        },
+        {
+            "index": 0.125,
+            "rgb": [218, 203, 187]
+        },
+        {
+            "index": 0.25,
+            "rgb": [181, 178, 138]
+        },
+        {
+            "index": 0.375,
+            "rgb": [125, 160, 119]
+        },
+        {
+            "index": 0.5,
+            "rgb": [60, 142, 109]
+        },
+        {
+            "index": 0.625,
+            "rgb": [5, 116, 109]
+        },
+        {
+            "index": 0.75,
+            "rgb": [20, 86, 102]
+        },
+        {
+            "index": 0.875,
+            "rgb": [36, 56, 79]
+        },
+        {
+            "index": 1.0,
+            "rgb": [33, 26, 56]
+        }
+    ],
+    "topo": [
+        {
+            "index": 0.0,
+            "rgb": [39, 26, 44]
+        },
+        {
+            "index": 0.125,
+            "rgb": [64, 77, 139]
+        },
+        {
+            "index": 0.25,
+            "rgb": [72, 142, 157]
+        },
+        {
+            "index": 0.375,
+            "rgb": [121, 206, 162]
+        },
+        {
+            "index": 0.5,
+            "rgb": [13, 37, 19]
+        },
+        {
+            "index": 0.625,
+            "rgb": [59, 89, 38]
+        },
+        {
+            "index": 0.75,
+            "rgb": [144, 129, 63]
+        },
+        {
+            "index": 0.875,
+            "rgb": [210, 182, 118]
+        },
+        {
+            "index": 1.0,
+            "rgb": [248, 253, 228]
+        }
+    ],
+    "balance": [
+        {
+            "index": 0.0,
+            "rgb": [23, 28, 66]
+        },
+        {
+            "index": 0.125,
+            "rgb": [36, 72, 175]
+        },
+        {
+            "index": 0.25,
+            "rgb": [56, 135, 185]
+        },
+        {
+            "index": 0.375,
+            "rgb": [151, 185, 197]
+        },
+        {
+            "index": 0.5,
+            "rgb": [240, 236, 235]
+        },
+        {
+            "index": 0.625,
+            "rgb": [214, 161, 143]
+        },
+        {
+            "index": 0.75,
+            "rgb": [191, 87, 58]
+        },
+        {
+            "index": 0.875,
+            "rgb": [141, 15, 40]
+        },
+        {
+            "index": 1.0,
+            "rgb": [60, 9, 17]
+        }
+    ],
+    "delta": [
+        {
+            "index": 0.0,
+            "rgb": [16, 31, 63]
+        },
+        {
+            "index": 0.125,
+            "rgb": [28, 81, 156]
+        },
+        {
+            "index": 0.25,
+            "rgb": [51, 144, 169]
+        },
+        {
+            "index": 0.375,
+            "rgb": [151, 197, 190]
+        },
+        {
+            "index": 0.5,
+            "rgb": [254, 252, 203]
+        },
+        {
+            "index": 0.625,
+            "rgb": [200, 185, 67]
+        },
+        {
+            "index": 0.75,
+            "rgb": [93, 145, 12]
+        },
+        {
+            "index": 0.875,
+            "rgb": [11, 94, 44]
+        },
+        {
+            "index": 1.0,
+            "rgb": [23, 35, 18]
+        }
+    ],
+    "curl": [
+        {
+            "index": 0.0,
+            "rgb": [20, 29, 67]
+        },
+        {
+            "index": 0.125,
+            "rgb": [26, 89, 103]
+        },
+        {
+            "index": 0.25,
+            "rgb": [44, 148, 127]
+        },
+        {
+            "index": 0.375,
+            "rgb": [163, 194, 162]
+        },
+        {
+            "index": 0.5,
+            "rgb": [253, 245, 243]
+        },
+        {
+            "index": 0.625,
+            "rgb": [225, 166, 142]
+        },
+        {
+            "index": 0.75,
+            "rgb": [194, 88, 96]
+        },
+        {
+            "index": 0.875,
+            "rgb": [131, 31, 95]
+        },
+        {
+            "index": 1.0,
+            "rgb": [51, 13, 53]
+        }
+    ],
+    "diff": [
+        {
+            "index": 0.0,
+            "rgb": [7, 34, 63]
+        },
+        {
+            "index": 0.125,
+            "rgb": [49, 87, 113]
+        },
+        {
+            "index": 0.25,
+            "rgb": [116, 136, 151]
+        },
+        {
+            "index": 0.375,
+            "rgb": [184, 191, 197]
+        },
+        {
+            "index": 0.5,
+            "rgb": [245, 241, 239]
+        },
+        {
+            "index": 0.625,
+            "rgb": [193, 185, 166]
+        },
+        {
+            "index": 0.75,
+            "rgb": [140, 128, 91]
+        },
+        {
+            "index": 0.875,
+            "rgb": [86, 79, 32]
+        },
+        {
+            "index": 1.0,
+            "rgb": [28, 34, 6]
+        }
+    ],
+    "tarn": [
+        {
+            "index": 0.0,
+            "rgb": [22, 35, 13]
+        },
+        {
+            "index": 0.125,
+            "rgb": [79, 84, 19]
+        },
+        {
+            "index": 0.25,
+            "rgb": [169, 118, 49]
+        },
+        {
+            "index": 0.375,
+            "rgb": [221, 177, 141]
+        },
+        {
+            "index": 0.5,
+            "rgb": [252, 247, 245]
+        },
+        {
+            "index": 0.625,
+            "rgb": [180, 193, 161]
+        },
+        {
+            "index": 0.75,
+            "rgb": [84, 144, 132]
+        },
+        {
+            "index": 0.875,
+            "rgb": [25, 89, 110]
+        },
+        {
+            "index": 1.0,
+            "rgb": [15, 30, 79]
+        }
+    ]
+}

package/lib/dialogs/symbology/components/color_stops/StopContainer.js

@@ -21,7 +21,7 @@ const StopContainer = ({ selectedMethod, stopRows, setStopRows, }) => {
             React.createElement("div", { className: "jp-gis-stop-labels", style: { display: 'flex', gap: 6 } },
                 React.createElement("span", { style: { flex: '0 0 18%' } }, "Value"),
                 React.createElement("span", null, "Output Value")),
-            stopRows.map((stop, index) => (React.createElement(StopRow, { key: `${index}-${stop.output}`, index: index, value: stop.stop, outputValue: stop.output, stopRows: stopRows, setStopRows: setStopRows, deleteRow: () => deleteStopRow(index), useNumber: selectedMethod === 'radius' ? true : false })))),
+            stopRows.map((stop, index) => (React.createElement(StopRow, { key: `${index}-${stop.output}`, index: index, dataValue: stop.stop, symbologyValue: stop.output, stopRows: stopRows, setStopRows: setStopRows, deleteRow: () => deleteStopRow(index), useNumber: selectedMethod === 'radius' ? true : false })))),
         React.createElement("div", { className: "jp-gis-symbology-button-container" },
             React.createElement(Button, { className: "jp-Dialog-button jp-mod-accept jp-mod-styled", onClick: addStopRow }, "Add Stop"))));
 };

package/lib/dialogs/symbology/components/color_stops/StopRow.d.ts

@@ -1,9 +1,10 @@
 import React from 'react';
 import { IStopRow } from "../../symbologyDialog";
+import { SymbologyValue } from "../../../../types";
 declare const StopRow: React.FC<{
     index: number;
-    value: number;
-    outputValue: number | number[];
+    dataValue: number;
+    symbologyValue: SymbologyValue;
     stopRows: IStopRow[];
     setStopRows: (stopRows: IStopRow[]) => void;
     deleteRow: () => void;

package/lib/dialogs/symbology/components/color_stops/StopRow.js

@@ -2,7 +2,8 @@ import { faTrash } from '@fortawesome/free-solid-svg-icons';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { Button } from '@jupyterlab/ui-components';
 import React, { useEffect, useRef } from 'react';
-const StopRow = ({ index, value, outputValue, stopRows, setStopRows, deleteRow, useNumber, }) => {
+import { ensureHexColorCode, hexToRgb, } from "../../colorRampUtils";
+const StopRow = ({ index, dataValue, symbologyValue, stopRows, setStopRows, deleteRow, useNumber, }) => {
     const inputRef = useRef(null);
     useEffect(() => {
         var _a;
@@ -10,32 +11,6 @@ const StopRow = ({ index, value, outputValue, stopRows, setStopRows, deleteRow,
             (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
         }
     }, [stopRows]);
-    const rgbArrToHex = (rgbArr) => {
-        if (!Array.isArray(rgbArr)) {
-            return;
-        }
-        const hex = rgbArr
-            .slice(0, -1) // Color input doesn't support hex alpha values so cut that out
-            .map((val) => {
-            return val.toString(16).padStart(2, '0');
-        })
-            .join('');
-        return '#' + hex;
-    };
-    const hexToRgb = (hex) => {
-        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-        if (!result) {
-            console.warn('Unable to parse hex value, defaulting to black');
-            return [parseInt('0', 16), parseInt('0', 16), parseInt('0', 16)];
-        }
-        const rgbValues = [
-            parseInt(result[1], 16),
-            parseInt(result[2], 16),
-            parseInt(result[3], 16),
-            1, // TODO: Make alpha customizable?
-        ];
-        return rgbValues;
-    };
     const handleStopChange = (event) => {
         const newRows = [...stopRows];
         newRows[index].stop = +event.target.value;
@@ -62,8 +37,8 @@ const StopRow = ({ index, value, outputValue, stopRows, setStopRows, deleteRow,
         setStopRows(newRows);
     };
     return (React.createElement("div", { className: "jp-gis-color-row" },
-        React.createElement("input", { id: `jp-gis-color-value-${index}`, type: "number", value: value, onChange: handleStopChange, onBlur: handleBlur, className: "jp-mod-styled jp-gis-color-row-value-input" }),
-        useNumber ? (React.createElement("input", { type: "number", ref: inputRef, value: outputValue, onChange: handleOutputChange, className: "jp-mod-styled jp-gis-color-row-output-input" })) : (React.createElement("input", { id: `jp-gis-color-color-${index}`, ref: inputRef, value: rgbArrToHex(outputValue), type: "color", onChange: handleOutputChange, className: "jp-mod-styled jp-gis-color-row-output-input" })),
+        React.createElement("input", { id: `jp-gis-color-value-${index}`, type: "number", value: dataValue, onChange: handleStopChange, onBlur: handleBlur, className: "jp-mod-styled jp-gis-color-row-value-input" }),
+        useNumber ? (React.createElement("input", { type: "number", ref: inputRef, value: symbologyValue, onChange: handleOutputChange, className: "jp-mod-styled jp-gis-color-row-output-input" })) : (React.createElement("input", { id: `jp-gis-color-color-${index}`, ref: inputRef, value: ensureHexColorCode(symbologyValue), type: "color", onChange: handleOutputChange, className: "jp-mod-styled jp-gis-color-row-output-input" })),
         React.createElement(Button, { id: `jp-gis-remove-color-${index}`, className: "jp-Button jp-gis-filter-icon" },
             React.createElement(FontAwesomeIcon, { icon: faTrash, onClick: deleteRow }))));
 };

package/lib/dialogs/symbology/symbologyDialog.d.ts

@@ -3,7 +3,7 @@ import { Dialog } from '@jupyterlab/apputils';
 import { IStateDB } from '@jupyterlab/statedb';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
-import { SymbologyTab } from "../../types";
+import { SymbologyTab, SymbologyValue } from "../../types";
 export interface ISymbologyDialogProps {
     model: IJupyterGISModel;
     state: IStateDB;
@@ -24,7 +24,7 @@ export interface ISymbologyWidgetOptions {
 }
 export interface IStopRow {
     stop: number;
-    output: number | number[];
+    output: SymbologyValue;
 }
 export declare class SymbologyWidget extends Dialog<boolean> {
     private okSignal;

package/lib/dialogs/symbology/symbologyUtils.js

@@ -1,4 +1,5 @@
 import colormap from 'colormap';
+const COLOR_EXPR_STOPS_START = 3;
 export var VectorUtils;
 (function (VectorUtils) {
     VectorUtils.buildColorInfo = (layer) => {
@@ -25,7 +26,7 @@ export var VectorUtils;
                     // Second element is type of interpolation (ie linear)
                     // Third is input value that stop values are compared with
                     // Fourth and on is value:color pairs
-                    for (let i = 3; i < color[key].length; i += 2) {
+                    for (let i = COLOR_EXPR_STOPS_START; i < color[key].length; i += 2) {
                         const pairKey = `${color[key][i]}-${color[key][i + 1]}`;
                         if (!seenPairs.has(pairKey)) {
                             valueColorPairs.push({
@@ -63,10 +64,15 @@ export var VectorUtils;
             return [];
         }
         const stopOutputPairs = [];
-        for (let i = 3; i < color['circle-radius'].length; i += 2) {
+        const circleRadius = color['circle-radius'];
+        if (!Array.isArray(circleRadius) ||
+            circleRadius.length <= COLOR_EXPR_STOPS_START) {
+            return [];
+        }
+        for (let i = COLOR_EXPR_STOPS_START; i < circleRadius.length; i += 2) {
             const obj = {
-                stop: color['circle-radius'][i],
-                output: color['circle-radius'][i + 1],
+                stop: circleRadius[i],
+                output: circleRadius[i + 1],
             };
             stopOutputPairs.push(obj);
         }

package/lib/dialogs/symbology/tiff_layer/types/SingleBandPseudoColor.js

@@ -282,7 +282,7 @@ const SingleBandPseudoColor = ({ model, okSignalPromise, cancel, layerId, }) =>
                             ? '='
                             : ''),
                 React.createElement("span", null, "Output Value")),
-            stopRows.map((stop, index) => (React.createElement(StopRow, { key: `${index}-${stop.output}`, index: index, value: stop.stop, outputValue: stop.output, stopRows: stopRows, setStopRows: setStopRows, deleteRow: () => deleteStopRow(index) })))),
+            stopRows.map((stop, index) => (React.createElement(StopRow, { key: `${index}-${stop.output}`, index: index, dataValue: stop.stop, symbologyValue: stop.output, stopRows: stopRows, setStopRows: setStopRows, deleteRow: () => deleteStopRow(index) })))),
         React.createElement("div", { className: "jp-gis-symbology-button-container" },
             React.createElement(Button, { className: "jp-Dialog-button jp-mod-accept jp-mod-styled", onClick: addStopRow }, "Add Stop"))));
 };

package/lib/mainview/mainView.d.ts

@@ -201,5 +201,6 @@ export declare class MainView extends React.Component<IProps, IStates> {
     private _state?;
     private _formSchemaRegistry?;
     private _annotationModel?;
+    private _featurePropertyCache;
 }
 export {};

package/lib/mainview/mainView.js

@@ -1,3 +1,14 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { JupyterGISModel, } from '@jupytergis/schema';
 import { showErrorMessage } from '@jupyterlab/apputils';
 import { CommandRegistry } from '@lumino/commands';
@@ -441,6 +452,7 @@ export class MainView extends React.Component {
         this._ready = false;
         this._sourceToLayerMap = new Map();
         this._originalFeatures = {};
+        this._featurePropertyCache = new Map();
         this._state = props.state;
         this._formSchemaRegistry = props.formSchemaRegistry;
         this._annotationModel = props.annotationModel;
@@ -1592,24 +1604,45 @@ export class MainView extends React.Component {
             case 'VectorTileLayer': {
                 const geometries = [];
                 const features = [];
+                let foundAny = false;
                 this._Map.forEachFeatureAtPixel(e.pixel, (feature) => {
+                    var _a, _b;
+                    foundAny = true;
                     let geom;
+                    let props = {};
                     if (feature instanceof RenderFeature) {
                         geom = toGeometry(feature);
                     }
                     else if ('getGeometry' in feature) {
                         geom = feature.getGeometry();
                     }
-                    const props = feature.getProperties();
+                    const rawProps = feature.getProperties();
+                    const fid = (_b = (_a = feature.getId) === null || _a === void 0 ? void 0 : _a.call(feature)) !== null && _b !== void 0 ? _b : rawProps === null || rawProps === void 0 ? void 0 : rawProps.fid;
+                    if (rawProps && Object.keys(rawProps).length > 1) {
+                        const { geometry } = rawProps, clean = __rest(rawProps, ["geometry"]);
+                        props = clean;
+                        if (fid !== null) {
+                            // TODO Clean the cache under some condition?
+                            this._featurePropertyCache.set(fid, props);
+                        }
+                    }
+                    else if (fid !== null && this._featurePropertyCache.has(fid)) {
+                        props = this._featurePropertyCache.get(fid);
+                    }
                     if (geom) {
                         geometries.push(geom);
                     }
-                    features.push(Object.assign({}, props));
+                    if (props && Object.keys(props).length > 0) {
+                        features.push(props);
+                    }
                     return true;
                 });
                 if (features.length > 0) {
                     this._model.syncIdentifiedFeatures(features, this._mainViewModel.id);
                 }
+                else if (!foundAny) {
+                    this._model.syncIdentifiedFeatures([], this._mainViewModel.id);
+                }
                 if (geometries.length > 0) {
                     for (const geom of geometries) {
                         this._model.highlightFeatureSignal.emit(geom);

package/lib/panelview/components/identify-panel/IdentifyPanel.js

@@ -67,34 +67,36 @@ export const IdentifyPanelComponent = ({ model, }) => {
             border: ((_a = model === null || model === void 0 ? void 0 : model.localState) === null || _a === void 0 ? void 0 : _a.remoteUser)
                 ? `solid 3px ${remoteUser === null || remoteUser === void 0 ? void 0 : remoteUser.color}`
                 : 'unset',
-        } }, features &&
-        Object.values(features).map((feature, featureIndex) => (React.createElement("div", { key: featureIndex, className: "jgis-identify-grid-item" },
-            React.createElement("div", { className: "jgis-identify-grid-item-header" },
-                React.createElement("span", { onClick: () => toggleFeatureVisibility(featureIndex) },
-                    React.createElement(LabIcon.resolveReact, { icon: caretDownIcon, className: `jp-gis-layerGroupCollapser${visibleFeatures[featureIndex] ? ' jp-mod-expanded' : ''}`, tag: 'span' }),
-                    React.createElement("span", null, getFeatureNameOrId(feature, featureIndex))),
-                (() => {
-                    const isRasterFeature = !feature.geometry &&
-                        !feature._geometry &&
-                        typeof (feature === null || feature === void 0 ? void 0 : feature.x) !== 'number' &&
-                        typeof (feature === null || feature === void 0 ? void 0 : feature.y) !== 'number';
-                    return (React.createElement("button", { className: "jgis-highlight-button", onClick: e => {
-                            e.stopPropagation();
-                            highlightFeatureOnMap(feature);
-                        }, title: isRasterFeature
-                            ? 'Highlight not available for raster features'
-                            : 'Highlight feature on map', disabled: isRasterFeature },
-                        React.createElement(FontAwesomeIcon, { icon: faMagnifyingGlass })));
-                })()),
-            visibleFeatures[featureIndex] && (React.createElement(React.Fragment, null, Object.entries(feature)
-                .filter(([key, value]) => typeof value !== 'object' || value === null)
-                .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
-                .map(([key, value]) => (React.createElement("div", { key: key, className: "jgis-identify-grid-body" },
-                React.createElement("strong", null,
-                    key,
-                    ":"),
-                typeof value === 'string' &&
-                    /<\/?[a-z][\s\S]*>/i.test(value) ? (React.createElement("span", { dangerouslySetInnerHTML: {
-                        __html: `${value}`,
-                    } })) : (React.createElement("span", null, String(value)))))))))))));
+        } },
+        !Object.keys(features !== null && features !== void 0 ? features : {}).length && (React.createElement("div", { style: { textAlign: 'center' } }, "Please select a layer from the layer list, then \"i\" from the toolbar to start identifying features.")),
+        features &&
+            Object.values(features).map((feature, featureIndex) => (React.createElement("div", { key: featureIndex, className: "jgis-identify-grid-item" },
+                React.createElement("div", { className: "jgis-identify-grid-item-header" },
+                    React.createElement("span", { onClick: () => toggleFeatureVisibility(featureIndex) },
+                        React.createElement(LabIcon.resolveReact, { icon: caretDownIcon, className: `jp-gis-layerGroupCollapser${visibleFeatures[featureIndex] ? ' jp-mod-expanded' : ''}`, tag: 'span' }),
+                        React.createElement("span", null, getFeatureNameOrId(feature, featureIndex))),
+                    (() => {
+                        const isRasterFeature = !feature.geometry &&
+                            !feature._geometry &&
+                            typeof (feature === null || feature === void 0 ? void 0 : feature.x) !== 'number' &&
+                            typeof (feature === null || feature === void 0 ? void 0 : feature.y) !== 'number';
+                        return (React.createElement("button", { className: "jgis-highlight-button", onClick: e => {
+                                e.stopPropagation();
+                                highlightFeatureOnMap(feature);
+                            }, title: isRasterFeature
+                                ? 'Highlight not available for raster features'
+                                : 'Highlight feature on map', disabled: isRasterFeature },
+                            React.createElement(FontAwesomeIcon, { icon: faMagnifyingGlass })));
+                    })()),
+                visibleFeatures[featureIndex] && (React.createElement(React.Fragment, null, Object.entries(feature)
+                    .filter(([key, value]) => typeof value !== 'object' || value === null)
+                    .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+                    .map(([key, value]) => (React.createElement("div", { key: key, className: "jgis-identify-grid-body" },
+                    React.createElement("strong", null,
+                        key,
+                        ":"),
+                    typeof value === 'string' &&
+                        /<\/?[a-z][\s\S]*>/i.test(value) ? (React.createElement("span", { dangerouslySetInnerHTML: {
+                            __html: `${value}`,
+                        } })) : (React.createElement("span", null, String(value)))))))))))));
 };

package/lib/types.d.ts

@@ -5,6 +5,12 @@ export { IDict };
 export type ValueOf<T> = T[keyof T];
 export type JupyterGISTracker = WidgetTracker<IJupyterGISWidget>;
 export type SymbologyTab = 'color' | 'radius';
+type RgbColorValue = [number, number, number] | [number, number, number, number];
+type HexColorValue = string;
+type InternalRgbArray = number[];
+export type ColorValue = RgbColorValue | HexColorValue;
+export type SizeValue = number;
+export type SymbologyValue = SizeValue | ColorValue | InternalRgbArray;
 export type VectorRenderType = 'Single Symbol' | 'Canonical' | 'Graduated' | 'Categorized' | 'Heatmap';
 /**
  * Add jupytergisMaps object to the global variables.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupytergis/base",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "A JupyterLab extension for 3D modelling.",
   "keywords": [
     "jupyter",
@@ -44,7 +44,7 @@
     "@jupyter/collaboration": "^3.1.0",
     "@jupyter/react-components": "^0.16.6",
     "@jupyter/ydoc": "^2.0.0 || ^3.0.0",
-    "@jupytergis/schema": "^0.9.0",
+    "@jupytergis/schema": "^0.9.2",
     "@jupyterlab/application": "^4.3.0",
     "@jupyterlab/apputils": "^4.3.0",
     "@jupyterlab/completer": "^4.3.0",