@mwater/visualization 5.0.0

package/lib/maps/Layer.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const expressions_1 = require("@mwater/expressions");
+const expressions_2 = require("@mwater/expressions");
+const bbox_1 = __importDefault(require("@turf/bbox"));
+/** Defines a layer for a map which has all the logic for rendering the specific data to be viewed */
+class Layer {
+    /** Gets the type of layer definition */
+    getLayerDefinitionType() {
+        return "JsonQLCss";
+    }
+    /** Gets the layer definition as JsonQL + CSS for type "JsonQLCss"
+        arguments:
+          design: design of layer
+          schema: schema to use
+          filters: array of filters to apply. Each is { table: table id, jsonql: jsonql condition with {alias} for tableAlias. Use injectAlias to put in table alias
+     */
+    getJsonQLCss(design, schema, filters) {
+        throw new Error("Not implemented");
+    }
+    /** Gets the utf grid url for definition type "TileUrl" */
+    getUtfGridUrl(design, filters) {
+        throw new Error("Not implemented");
+    }
+    /** Gets the layer definition for "VectorTile" type
+     * @param sourceId id of the source. Should be prefixed to sublayers with a colon (prefix:id)
+     * @param opacity opacity of the layer, which MapBox does not allow to be implemented for a whole layer (https://github.com/mapbox/mapbox-gl-js/issues/4090)
+     */
+    getVectorTile(design, sourceId, schema, filters, opacity) {
+        throw new Error("Not implemented");
+    }
+    /**
+     * Called when the interactivity grid is clicked.
+     * arguments:
+     *   ev: { data: interactivty data e.g. `{ id: 123 }` }
+     *   options:
+     *     design: design of layer
+     *     schema: schema to use
+     *     dataSource: data source to use
+     *     layerDataSource: layer data source
+     *     scopeData: current scope data if layer is scoping
+     *     filters: compiled filters to apply to the popup
+     *
+     * Returns:
+     *   null/undefined
+     *   or
+     *   {
+     *     scope: scope to apply ({ name, filter, data })
+     *     row: { tableId:, primaryKey: }  # row that was selected
+     *     popup: React element to put into a popup
+     */
+    onGridClick(ev, options) {
+        return null;
+    }
+    onGridHoverOver(ev, options) {
+        return null;
+    }
+    /** Gets the bounds of the layer as GeoJSON */
+    getBounds(design, schema, dataSource, filters, callback) {
+        callback(null);
+    }
+    /** Get min zoom level */
+    getMinZoom(design) {
+        return null;
+    }
+    /** Get max zoom level */
+    getMaxZoom(design) {
+        return null;
+    }
+    /** Get the legend to be optionally displayed on the map. Returns a React element */
+    getLegend(design, schema, name, dataSource, locale, filters) {
+        return null;
+    }
+    /** Get a list of table ids that can be filtered on */
+    getFilterableTables(design, schema) {
+        return [];
+    }
+    /** True if layer can be edited */
+    isEditable() {
+        return false;
+    }
+    /** True if layer is incomplete (e.g. brand new) and should be editable immediately */
+    isIncomplete(design, schema) {
+        return this.validateDesign(this.cleanDesign(design, schema), schema) != null;
+    }
+    // Creates a design element with specified options.
+    // Design should be cleaned on the way in and on way out.
+    // options:
+    //   design: design of layer
+    //   schema: schema to use
+    //   dataSource: data source to use
+    //   onDesignChange: function called when design changes
+    createDesignerElement(options) {
+        throw new Error("Not implemented");
+    }
+    /** Returns a cleaned design */
+    cleanDesign(design, schema) {
+        return design;
+    }
+    /** Validates design. Null if ok, message otherwise */
+    validateDesign(design, schema) {
+        return null;
+    }
+    /** Convenience function to get the bounds of a geometry expression with filters */
+    getBoundsFromExpr(schema, dataSource, table, geometryExpr, filterExpr, filters, callback) {
+        const exprCompiler = new expressions_1.ExprCompiler(schema);
+        const compiledGeometryExpr = exprCompiler.compileExpr({ expr: geometryExpr, tableAlias: "main" });
+        // Create where clause from filters
+        let where = {
+            type: "op",
+            op: "and",
+            exprs: lodash_1.default.pluck(lodash_1.default.where(filters, { table }), "jsonql")
+        };
+        if (filterExpr) {
+            where.exprs.push(exprCompiler.compileExpr({ expr: filterExpr, tableAlias: "main" }));
+        }
+        // Compact and inject alias
+        where.exprs = lodash_1.default.compact(where.exprs);
+        where = (0, expressions_2.injectTableAlias)(where, "main");
+        // Get bounds
+        const boundsQuery = {
+            type: "query",
+            selects: [
+                {
+                    type: "select",
+                    expr: {
+                        type: "op",
+                        op: "::json",
+                        exprs: [
+                            {
+                                type: "op",
+                                op: "ST_AsGeoJSON",
+                                exprs: [
+                                    {
+                                        type: "op",
+                                        op: "ST_Transform",
+                                        exprs: [
+                                            {
+                                                type: "op",
+                                                op: "ST_SetSRID",
+                                                exprs: [{ type: "op", op: "ST_Extent", exprs: [compiledGeometryExpr] }, 3857]
+                                            },
+                                            4326
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    alias: "bounds"
+                }
+            ],
+            from: { type: "table", table, alias: "main" },
+            where
+        };
+        return dataSource.performQuery(boundsQuery, (err, results) => {
+            if (err) {
+                return callback(err);
+            }
+            else {
+                // Null if no bounds can be calculated
+                let bounds = null;
+                if (results[0].bounds) {
+                    const [w, s, e, n] = (0, bbox_1.default)(results[0].bounds);
+                    // Pad to 10km if point
+                    if (w === e && n === s) {
+                        bounds = {
+                            w: w - 0.1,
+                            s: s - 0.1,
+                            e: e + 0.1,
+                            n: n + 0.1
+                        };
+                        // Pad bounds to prevent too small box (10m)
+                    }
+                    else {
+                        bounds = {
+                            w: w - 0.001,
+                            s: s - 0.001,
+                            e: e + 0.001,
+                            n: n + 0.001
+                        };
+                    }
+                }
+                return callback(null, bounds);
+            }
+        });
+    }
+}
+exports.default = Layer;

package/lib/maps/LayerFactory.d.ts

@@ -0,0 +1,5 @@
+import Layer from "./Layer";
+/** Creates a layer */
+export default class LayerFactory {
+    static createLayer(type: string): Layer<any>;
+}

package/lib/maps/LayerFactory.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const MWaterServerLayer_1 = __importDefault(require("./MWaterServerLayer"));
+const MarkersLayer_1 = __importDefault(require("./MarkersLayer"));
+const BufferLayer_1 = __importDefault(require("./BufferLayer"));
+const ChoroplethLayer_1 = __importDefault(require("./ChoroplethLayer"));
+const ClusterLayer_1 = __importDefault(require("./ClusterLayer"));
+const TileUrlLayer_1 = __importDefault(require("./TileUrlLayer"));
+const SwitchableTileUrlLayer_1 = __importDefault(require("./SwitchableTileUrlLayer"));
+const GridLayer_1 = __importDefault(require("./GridLayer"));
+/** Creates a layer */
+class LayerFactory {
+    static createLayer(type) {
+        switch (type) {
+            case "MWaterServer":
+                return new MWaterServerLayer_1.default();
+                break;
+            case "Markers":
+                return new MarkersLayer_1.default();
+                break;
+            case "Buffer":
+                return new BufferLayer_1.default();
+                break;
+            // Uses a legacy type name
+            case "AdminChoropleth":
+                return new ChoroplethLayer_1.default();
+                break;
+            case "Cluster":
+                return new ClusterLayer_1.default();
+                break;
+            case "TileUrl":
+                return new TileUrlLayer_1.default();
+                break;
+            case "SwitchableTileUrl":
+                return new SwitchableTileUrlLayer_1.default();
+                break;
+            case "Grid":
+                return new GridLayer_1.default();
+                break;
+        }
+        throw new Error(`Unknown type ${type}`);
+    }
+}
+exports.default = LayerFactory;

package/lib/maps/LayerLegendComponent.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import LegendGroup from "./LegendGroup";
+import { Schema } from "@mwater/expressions";
+import { Axis } from "../axes/Axis";
+export interface LayerLegendComponentProps {
+    schema: Schema;
+    name: string;
+    radiusLayer?: boolean;
+    axis?: Axis | null;
+    symbol?: string;
+    markerSize?: number;
+    defaultColor?: string;
+    /** array of filters to apply. Each is { table: table id, jsonql: jsonql condition with {alias} for tableAlias. Use injectAlias to correct */
+    filters?: any;
+    locale?: string;
+}
+export default class LayerLegendComponent extends React.Component<LayerLegendComponentProps> {
+    static defaultProps: {
+        radiusLayer: boolean;
+    };
+    getCategories(): import("../axes/Axis").AxisCategory[] | undefined;
+    render(): React.CElement<import("./LegendGroup").LegendGroupProps, LegendGroup>;
+}

package/lib/maps/LayerLegendComponent.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const lodash_1 = __importDefault(require("lodash"));
+const R = react_1.default.createElement;
+const AxisBuilder_1 = __importDefault(require("../axes/AxisBuilder"));
+const LegendGroup_1 = __importDefault(require("./LegendGroup"));
+// wraps the legends for a layer
+class LayerLegendComponent extends react_1.default.Component {
+    static defaultProps = { radiusLayer: false };
+    getCategories() {
+        const axisBuilder = new AxisBuilder_1.default({ schema: this.props.schema });
+        if (!this.props.axis || !this.props.axis.colorMap) {
+            return;
+        }
+        // Get categories (value + label)
+        const categories = axisBuilder.getCategories(this.props.axis, null, { locale: this.props.locale });
+        // Just "None" and so doesn't count
+        if (lodash_1.default.any(categories, (category) => category.value != null)) {
+            return categories;
+        }
+        // Can't get values of aggregate axis
+        if (axisBuilder.isAxisAggr(this.props.axis)) {
+            return [];
+        }
+        // If no categories, use values from color map as input
+        return axisBuilder.getCategories(this.props.axis, lodash_1.default.pluck(this.props.axis.colorMap, "value"), { locale: this.props.locale });
+    }
+    render() {
+        let items;
+        const axisBuilder = new AxisBuilder_1.default({ schema: this.props.schema });
+        const categories = this.getCategories();
+        if (this.props.axis && this.props.axis.colorMap) {
+            items = lodash_1.default.map(categories || [], (category) => {
+                // Exclude if excluded
+                if (lodash_1.default.includes(this.props.axis.excludedValues || [], category.value)) {
+                    return null;
+                }
+                const label = axisBuilder.formatCategory(this.props.axis, category);
+                const color = lodash_1.default.find(this.props.axis.colorMap, { value: category.value });
+                if (color) {
+                    return { color: color.color, name: label };
+                }
+                else {
+                    // old color maps dont have null value
+                    return { color: this.props.defaultColor, name: label };
+                }
+            });
+            // Compact out nulls
+            items = lodash_1.default.compact(items);
+        }
+        else {
+            items = [];
+        }
+        return react_1.default.createElement(LegendGroup_1.default, {
+            symbol: this.props.symbol,
+            markerSize: this.props.markerSize,
+            items,
+            defaultColor: this.props.defaultColor,
+            name: this.props.name,
+            radiusLayer: this.props.radiusLayer
+        });
+    }
+}
+exports.default = LayerLegendComponent;

package/lib/maps/LayerSwitcherComponent.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { MapDesign } from "./MapDesign";
+/** Component to switch layers on a map */
+export declare function LayerSwitcherComponent(props: {
+    design: MapDesign;
+    onDesignChange: (design: MapDesign) => void;
+}): React.JSX.Element;

package/lib/maps/LayerSwitcherComponent.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayerSwitcherComponent = void 0;
+const immer_1 = __importDefault(require("immer"));
+const react_1 = __importStar(require("react"));
+/** Component to switch layers on a map */
+function LayerSwitcherComponent(props) {
+    const [dropdownOpen, setDropdownOpen] = (0, react_1.useState)(false);
+    const iconStyle = {
+        backgroundColor: "white",
+        paddingLeft: 5,
+        paddingRight: 5,
+        paddingTop: 3,
+        paddingBottom: 3,
+        borderRadius: 4,
+        border: "solid 1px #AAA",
+        color: "#666",
+        cursor: "pointer",
+        fontSize: 14,
+        display: "inline-block"
+    };
+    function toggleDropdown() {
+        setDropdownOpen(ddo => !ddo);
+    }
+    function renderLayerView(lv, index) {
+        function handleClick() {
+            props.onDesignChange((0, immer_1.default)(props.design, draft => {
+                draft.layerViews[index].visible = !lv.visible;
+                // Unselect any in same group if selected
+                if (lv.group && !lv.visible) {
+                    draft.layerViews.forEach((lv2, i) => {
+                        if (lv2.visible && i != index && lv2.group == lv.group) {
+                            lv2.visible = false;
+                        }
+                    });
+                }
+            }));
+        }
+        return (react_1.default.createElement("div", { key: index, style: { fontSize: 12, whiteSpace: "nowrap", cursor: "pointer" }, onClick: handleClick },
+            react_1.default.createElement("i", { className: lv.visible ? "fa fa-fw fa-check-square text-primary" : "fa fa-fw fa-square text-muted" }),
+            "\u00A0",
+            lv.name));
+    }
+    return (react_1.default.createElement("div", { style: { textAlign: "right" }, ref: useClickOutside(() => {
+            setDropdownOpen(false);
+        }) },
+        react_1.default.createElement("div", { style: iconStyle, onClick: toggleDropdown },
+            react_1.default.createElement("i", { className: "fas fa-layer-group fa-fw" })),
+        dropdownOpen ? (react_1.default.createElement("div", { style: { backgroundColor: "white", padding: 5 } }, props.design.layerViews.map(renderLayerView))) : null));
+}
+exports.LayerSwitcherComponent = LayerSwitcherComponent;
+/** Hook for click outside catching */
+function useClickOutside(onClickOut) {
+    const node = (0, react_1.useRef)(null);
+    const handleClick = (e) => {
+        const nodeRef = node.current;
+        // If inside click
+        if (nodeRef && nodeRef.contains(e.target)) {
+            return;
+        }
+        // If outside click
+        onClickOut();
+    };
+    (0, react_1.useEffect)(() => {
+        document.addEventListener("mousedown", handleClick);
+        return () => {
+            document.removeEventListener("mousedown", handleClick);
+        };
+    }, []);
+    return node;
+}

package/lib/maps/LeafletLoading.css

@@ -0,0 +1,24 @@
+.leaflet-control-loading:empty {
+  /* Spinner via ajaxload.info, base64-encoded */
+  background-image: url(data:image/gif;base64,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);
+  background-repeat: no-repeat;
+}
+
+.leaflet-control-loading,
+.leaflet-control-zoom a.leaflet-control-loading,
+.leaflet-control-zoomslider a.leaflet-control-loading {
+  display: none;
+}
+
+.leaflet-control-loading.is-loading,
+.leaflet-control-zoom a.leaflet-control-loading.is-loading,
+.leaflet-control-zoomslider a.leaflet-control-loading.is-loading {
+  display: block;
+}
+
+/* Necessary for display consistency in Leaflet >= 0.6 */
+.leaflet-bar-part-bottom {
+  border-bottom: medium none;
+  border-bottom-left-radius: 4px;
+  border-bottom-right-radius: 4px;
+}

package/lib/maps/LeafletLoading.d.ts

@@ -0,0 +1,42 @@
+import "./LeafletLoading.css";
+import L from "leaflet";
+declare const _default: (new (...args: any[]) => {
+    options: {
+        delayIndicator: null;
+        position: string;
+        separate: boolean;
+        zoomControl: null;
+        spinjs: boolean;
+        spin: {
+            lines: number;
+            length: number;
+            width: number;
+            radius: number;
+            rotate: number;
+            top: string;
+        };
+    };
+    initialize: (options: any) => void;
+    onAdd: (map: any) => any;
+    onRemove: (map: any) => void;
+    removeFrom: (map: any) => any | undefined;
+    addLoader: (id: any) => void;
+    removeLoader: (id: any) => void;
+    updateIndicator: () => void;
+    isLoading: () => boolean;
+    _countLoaders: () => number;
+    _showIndicator: () => void;
+    _hideIndicator: () => void;
+    _getLastControlButton: () => any;
+    _handleLoading: (e: any) => void;
+    _handleBaseLayerChange: (e: any) => void;
+    _handleLoad: (e: any) => void;
+    getEventId: (e: any) => any;
+    _layerAdd: (e: any) => void;
+    _layerRemove: (e: any) => void;
+    _addLayerListeners: (map: any) => void;
+    _removeLayerListeners: (map: any) => void;
+    _addMapListeners: (map: any) => void;
+    _removeMapListeners: (map: any) => void;
+}) & typeof L.Control;
+export default _default;