@mwater/visualization 5.0.0

package/lib/maps/MWaterServerLayer.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jquery_1 = __importDefault(require("jquery"));
+const Layer_1 = __importDefault(require("./Layer"));
+const react_1 = __importDefault(require("react"));
+const R = react_1.default.createElement;
+// TODO DEPRECATED. REPLACE WITH REAL MARKER AND BUFFER LAYERS
+// Layer defined on the mWater server
+// Design is:
+// type: type of layer on server
+// table: table to filter on (e.g. entities.water_point)
+// minZoom: optional minimum zoom
+// maxZoom: optional maximum zoom
+class MWaterServerLayer extends Layer_1.default {
+    // 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
+    //     filters: compiled filters to apply to the popup
+    //
+    // Returns:
+    //   null/undefined to do nothing
+    //   [table id, primary key] to open a default system popup if one is present
+    //   React element to put into a popup
+    onGridClick(ev, options) {
+        if (ev.data && ev.data.id) {
+            return {
+                row: { tableId: options.design.table, primaryKey: ev.data.id }
+            };
+        }
+        return null;
+    }
+    // Get min and max zoom levels
+    getMinZoom(design) {
+        return design.minZoom;
+    }
+    getMaxZoom(design) {
+        return design.maxZoom;
+    }
+    // Get the legend to be optionally displayed on the map. Returns
+    // a React element
+    getLegend(design, schema) {
+        // Create loading legend component
+        // TODO hardcoded
+        const apiUrl = "https://api.mwater.co/v3/";
+        return react_1.default.createElement(LoadingLegend, { url: `${apiUrl}maps/legend?type=${design.type}` });
+    }
+    // Get a list of table ids that can be filtered on
+    getFilterableTables(design, schema) {
+        if (design.table) {
+            return [design.table];
+        }
+        else {
+            return [];
+        }
+    }
+    // True if layer can be edited
+    isEditable() {
+        return false;
+    }
+    // Returns a cleaned design
+    cleanDesign(design, schema) {
+        return design;
+    }
+    // Validates design. Null if ok, message otherwise
+    validateDesign(design, schema) {
+        return null;
+    }
+}
+exports.default = MWaterServerLayer;
+// Simple class to load legend from server
+class LoadingLegend extends react_1.default.Component {
+    constructor(props) {
+        super(props);
+        this.state = { html: "Loading..." };
+    }
+    componentDidMount() {
+        return jquery_1.default.get(this.props.url).done((data) => {
+            return this.setState({ html: data });
+        });
+    }
+    componentWillReceiveProps(nextProps) {
+        if (nextProps.url !== this.props.url) {
+            return jquery_1.default.get(nextProps.url).done((data) => {
+                return this.setState({ html: data });
+            });
+        }
+    }
+    render() {
+        return R("div", {
+            style: { font: "14px/16px Arial, Helvetica, sans-serif", color: "#555" },
+            dangerouslySetInnerHTML: { __html: this.state.html }
+        });
+    }
+}

package/lib/maps/MapBoundsCalculator.d.ts

@@ -0,0 +1,16 @@
+import { DataSource, Schema } from "@mwater/expressions";
+import { JsonQLFilter } from "../JsonQLFilter";
+import { MapDesign } from "./MapDesign";
+/** Calculates map bounds given layers by unioning together */
+export default class MapBoundsCalculator {
+    schema: Schema;
+    dataSource: DataSource;
+    constructor(schema: Schema, dataSource: DataSource);
+    /** Gets the bounds for the map. Null for whole world. Callback as { n:, s:, w:, e: } */
+    getBounds(design: MapDesign, filters: JsonQLFilter[], callback: (error: any, bounds?: {
+        w: number;
+        n: number;
+        e: number;
+        s: number;
+    } | null) => void): void;
+}

package/lib/maps/MapBoundsCalculator.js

@@ -0,0 +1,85 @@
+"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 });
+const lodash_1 = __importDefault(require("lodash"));
+const async_1 = __importDefault(require("async"));
+const LayerFactory_1 = __importDefault(require("./LayerFactory"));
+const MapUtils = __importStar(require("./MapUtils"));
+/** Calculates map bounds given layers by unioning together */
+class MapBoundsCalculator {
+    schema;
+    dataSource;
+    constructor(schema, dataSource) {
+        this.schema = schema;
+        this.dataSource = dataSource;
+    }
+    /** Gets the bounds for the map. Null for whole world. Callback as { n:, s:, w:, e: } */
+    getBounds(design, filters, callback) {
+        const allBounds = [];
+        // For each layer
+        return async_1.default.each(design.layerViews, (layerView, cb) => {
+            if (!layerView.visible) {
+                return cb(null);
+            }
+            // Create layer
+            const layer = LayerFactory_1.default.createLayer(layerView.type);
+            // Ensure that valid
+            const layerDesign = layer.cleanDesign(layerView.design, this.schema);
+            if (layer.validateDesign(layerDesign, this.schema)) {
+                return cb(null);
+            }
+            // Compile map filters
+            const allFilters = (filters || []).concat(MapUtils.getCompiledFilters(design, this.schema, MapUtils.getFilterableTables(design, this.schema)));
+            // Get bounds, including filters from map
+            return layer.getBounds(layerDesign, this.schema, this.dataSource, allFilters, (error, bounds) => {
+                if (error) {
+                    return cb(error);
+                }
+                if (bounds) {
+                    allBounds.push(bounds);
+                }
+                return cb(null);
+            });
+        }, (error) => {
+            if (error) {
+                return callback(error);
+            }
+            // Union bounds
+            if (allBounds.length === 0) {
+                return callback(null);
+            }
+            return callback(null, {
+                n: lodash_1.default.max(allBounds, "n").n,
+                e: lodash_1.default.max(allBounds, "e").e,
+                s: lodash_1.default.min(allBounds, "s").s,
+                w: lodash_1.default.min(allBounds, "w").w
+            });
+        });
+    }
+}
+exports.default = MapBoundsCalculator;

package/lib/maps/MapComponent.d.ts

@@ -0,0 +1,98 @@
+import PropTypes from "prop-types";
+import React, { ReactNode } from "react";
+import UndoStack from "../UndoStack";
+import { DataSource, Schema } from "@mwater/expressions";
+import { MapDataSource } from "./MapDataSource";
+import { MapDesign } from "./MapDesign";
+import { JsonQLFilter } from "../JsonQLFilter";
+export interface MapComponentProps {
+    schema: Schema;
+    dataSource: DataSource;
+    mapDataSource: MapDataSource;
+    design: MapDesign;
+    onDesignChange?: (design: MapDesign) => void;
+    /** Called with (tableId, rowId) when item is clicked */
+    onRowClick?: (tableId: string, rowId: any) => void;
+    /** Extra filters to apply to view */
+    extraFilters?: JsonQLFilter[];
+    /** Extra element to include in title at left */
+    titleElem?: ReactNode;
+    /** Extra elements to add to right */
+    extraTitleButtonsElem?: ReactNode;
+    /** True to enable quickfilters */
+    enableQuickfilters?: boolean;
+    /** Locked quickfilter values. See README in quickfilters */
+    quickfilterLocks?: any[];
+    /** Initial quickfilter values */
+    quickfiltersValues?: any[];
+    /** True to hide title bar and related controls */
+    hideTitleBar?: boolean;
+}
+interface MapComponentState {
+    undoStack: UndoStack;
+    transientDesign: MapDesign;
+    zoomLocked: boolean;
+    /** Values of quickfilters */
+    quickfiltersValues: any[] | null;
+    /** True to hide quickfilters */
+    hideQuickfilters: boolean;
+}
+/** Map with designer on right */
+export default class MapComponent extends React.Component<MapComponentProps, MapComponentState> {
+    static contextTypes: {
+        locale: PropTypes.Requireable<string>;
+    };
+    constructor(props: MapComponentProps);
+    componentDidUpdate(prevProps: MapComponentProps): void;
+    handleUndo: () => void;
+    handleRedo: () => void;
+    handleShowQuickfilters: () => void;
+    handleZoomLockClick: () => void;
+    renderActionLinks(): React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    renderHeader(): React.DetailedReactHTMLElement<{
+        style: {
+            padding: number;
+            borderBottom: string;
+            gridArea: "header";
+        };
+    }, HTMLElement>;
+    handleDesignChange: (design: any) => void;
+    getDesign(): MapDesign;
+    handleToggleDesignPanel: () => void;
+    getQuickfilterValues: () => any[];
+    renderView(): React.CElement<{
+        injectWidth: boolean;
+        injectHeight: boolean;
+    }, React.Component<{
+        injectWidth: boolean;
+        injectHeight: boolean;
+    }, any, any>>;
+    getCompiledFilters(): {
+        table: string;
+        jsonql: import("@mwater/jsonql").JsonQLExpr;
+    }[];
+    renderQuickfilter(): React.DetailedReactHTMLElement<{
+        style: {
+            gridArea: "quickfilters";
+            borderBottom: string;
+        };
+    }, HTMLElement>;
+    renderDesigner(): React.DetailedReactHTMLElement<{
+        style: {
+            gridArea: "designer";
+            borderLeft: string;
+            overflowY: "scroll";
+        };
+    }, HTMLElement>;
+    render(): React.DetailedReactHTMLElement<{
+        style: {
+            width: string;
+            height: string;
+            display: "grid";
+            gridTemplateColumns: string;
+            gridTemplateRows: string;
+            gridTemplateAreas: "\"header designer\" \"quickfilters designer\" \"view designer\"";
+        };
+    }, HTMLElement>;
+}
+export {};

package/lib/maps/MapComponent.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prop_types_1 = __importDefault(require("prop-types"));
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importDefault(require("react"));
+const R = react_1.default.createElement;
+const MapViewComponent_1 = require("./MapViewComponent");
+const MapDesignerComponent_1 = __importDefault(require("./MapDesignerComponent"));
+const MapControlComponent_1 = __importDefault(require("./MapControlComponent"));
+const AutoSizeComponent_1 = __importDefault(require("@mwater/react-library/lib/AutoSizeComponent"));
+const UndoStack_1 = __importDefault(require("../UndoStack"));
+const PopoverHelpComponent_1 = __importDefault(require("@mwater/react-library/lib/PopoverHelpComponent"));
+const QuickfilterCompiler_1 = __importDefault(require("../quickfilter/QuickfilterCompiler"));
+const QuickfiltersComponent_1 = __importDefault(require("../quickfilter/QuickfiltersComponent"));
+const MapUtils_1 = require("./MapUtils");
+/** Map with designer on right */
+class MapComponent extends react_1.default.Component {
+    static contextTypes = { locale: prop_types_1.default.string };
+    constructor(props) {
+        super(props);
+        this.state = {
+            undoStack: new UndoStack_1.default().push(props.design),
+            transientDesign: props.design,
+            zoomLocked: true,
+            quickfiltersValues: props.quickfiltersValues ?? null,
+            hideQuickfilters: false
+        };
+    }
+    componentDidUpdate(prevProps) {
+        // If design changes, save on stack and update transient design
+        if (!lodash_1.default.isEqual(prevProps.design, this.props.design)) {
+            // Save on stack
+            this.setState({ undoStack: this.state.undoStack.push(this.props.design) });
+            // Update transient design
+            this.setState({ transientDesign: this.props.design });
+        }
+    }
+    handleUndo = () => {
+        const undoStack = this.state.undoStack.undo();
+        // We need to use callback as state is applied later
+        return this.setState({ undoStack }, () => this.props.onDesignChange(undoStack.getValue()));
+    };
+    handleRedo = () => {
+        const undoStack = this.state.undoStack.redo();
+        // We need to use callback as state is applied later
+        return this.setState({ undoStack }, () => this.props.onDesignChange(undoStack.getValue()));
+    };
+    handleShowQuickfilters = () => {
+        return this.setState({ hideQuickfilters: false });
+    };
+    handleZoomLockClick = () => {
+        return this.setState({ zoomLocked: !this.state.zoomLocked });
+    };
+    renderActionLinks() {
+        return R("div", null, this.props.onDesignChange != null
+            ? [
+                R("a", { key: "lock", className: "btn btn-link btn-sm", onClick: this.handleZoomLockClick }, R("span", {
+                    className: `fa ${this.state.zoomLocked ? "fa-lock red" : "fa-unlock green"}`,
+                    style: { marginRight: 5 }
+                }), R(PopoverHelpComponent_1.default, { placement: "bottom" }, "Changes to zoom level wont be saved in locked mode")),
+                R("a", {
+                    key: "undo",
+                    className: `btn btn-link btn-sm ${!this.state.undoStack.canUndo() ? "disabled" : ""}`,
+                    onClick: this.handleUndo
+                }, R("span", { className: "fas fa-caret-left" }), R("span", { className: "hide-600px" }, " Undo")),
+                " ",
+                R("a", {
+                    key: "redo",
+                    className: `btn btn-link btn-sm ${!this.state.undoStack.canRedo() ? "disabled" : ""}`,
+                    onClick: this.handleRedo
+                }, R("span", { className: "fas fa-caret-right" }), R("span", { className: "hide-600px" }, " Redo"))
+            ]
+            : undefined, this.state.hideQuickfilters && this.props.design.quickfilters && this.props.design.quickfilters.length > 0
+            ? R("a", { key: "showQuickfilters", className: "btn btn-link btn-sm", onClick: this.handleShowQuickfilters }, R("span", { className: "fa fa-filter" }), R("span", { className: "hide-600px" }, " Show Quickfilters"))
+            : undefined, this.props.extraTitleButtonsElem, R("a", { key: "toggleDesign", className: "btn btn-link btn-sm", onClick: this.handleToggleDesignPanel, alt: "Toggle design panel" }, this.getDesign().hideDesignPanel ?
+            R("span", { className: "fas fa-angle-double-left" })
+            : R("span", { className: "fas fa-angle-double-right" })));
+    }
+    renderHeader() {
+        return R("div", {
+            style: {
+                padding: 4,
+                borderBottom: "solid 1px #e8e8e8",
+                gridArea: "header"
+            }
+        }, R("div", { style: { float: "right" } }, this.renderActionLinks()), this.props.titleElem);
+    }
+    handleDesignChange = (design) => {
+        if (this.props.onDesignChange) {
+            return this.props.onDesignChange(design);
+        }
+        else {
+            return this.setState({ transientDesign: design });
+        }
+    };
+    getDesign() {
+        if (this.props.onDesignChange) {
+            return this.props.design;
+        }
+        else {
+            return this.state.transientDesign || this.props.design;
+        }
+    }
+    handleToggleDesignPanel = () => {
+        this.handleDesignChange({ ...this.getDesign(), hideDesignPanel: !this.getDesign().hideDesignPanel });
+    };
+    // Get the values of the quick filters
+    getQuickfilterValues = () => {
+        return this.state.quickfiltersValues || [];
+    };
+    renderView() {
+        let filters = this.props.extraFilters || [];
+        // Compile quickfilters
+        filters = filters.concat(new QuickfilterCompiler_1.default(this.props.schema).compile(this.props.design.quickfilters || [], this.state.quickfiltersValues, this.props.quickfilterLocks));
+        return react_1.default.createElement(AutoSizeComponent_1.default, { injectWidth: true, injectHeight: true }, (size) => {
+            return react_1.default.createElement(MapViewComponent_1.MapViewComponent, {
+                mapDataSource: this.props.mapDataSource,
+                schema: this.props.schema,
+                dataSource: this.props.dataSource,
+                design: this.getDesign(),
+                onDesignChange: this.handleDesignChange,
+                zoomLocked: this.state.zoomLocked,
+                onRowClick: this.props.onRowClick,
+                extraFilters: filters,
+                locale: this.context.locale,
+                width: size.width,
+                height: size.height
+            });
+        });
+    }
+    // Get filters from props filters combined with maps filters
+    getCompiledFilters() {
+        let compiledFilters = (0, MapUtils_1.getCompiledFilters)(this.props.design, this.props.schema, (0, MapUtils_1.getFilterableTables)(this.props.design, this.props.schema));
+        compiledFilters = compiledFilters.concat(this.props.extraFilters || []);
+        return compiledFilters;
+    }
+    renderQuickfilter() {
+        return R("div", { style: { gridArea: "quickfilters", borderBottom: "solid 1px #e8e8e8" } }, R(QuickfiltersComponent_1.default, {
+            design: this.props.design.quickfilters || [],
+            schema: this.props.schema,
+            dataSource: this.props.dataSource,
+            quickfiltersDataSource: this.props.mapDataSource.getQuickfiltersDataSource(),
+            values: this.state.quickfiltersValues || undefined,
+            onValuesChange: (values) => this.setState({ quickfiltersValues: values }),
+            locks: this.props.quickfilterLocks,
+            filters: this.getCompiledFilters(),
+            hideTopBorder: this.props.hideTitleBar,
+            onHide: () => this.setState({ hideQuickfilters: true })
+        }));
+    }
+    renderDesigner() {
+        return R("div", { style: { gridArea: "designer", borderLeft: "solid 2px #e8e8e8", overflowY: 'scroll' } }, this.props.onDesignChange ?
+            react_1.default.createElement(MapDesignerComponent_1.default, {
+                schema: this.props.schema,
+                dataSource: this.props.dataSource,
+                design: this.getDesign(),
+                onDesignChange: this.handleDesignChange,
+                enableQuickfilters: this.props.enableQuickfilters
+            })
+            :
+                react_1.default.createElement(MapControlComponent_1.default, {
+                    schema: this.props.schema,
+                    dataSource: this.props.dataSource,
+                    design: this.getDesign(),
+                    onDesignChange: this.handleDesignChange
+                }));
+    }
+    render() {
+        const designerVisible = !this.getDesign().hideDesignPanel;
+        console.log("designerVisible", designerVisible);
+        return R("div", {
+            style: {
+                width: "100%",
+                height: "100%",
+                display: "grid",
+                gridTemplateColumns: designerVisible ? "70% 30%" : "100%",
+                gridTemplateRows: "auto auto 1fr",
+                gridTemplateAreas: `"header designer" "quickfilters designer" "view designer"`
+            }
+        }, this.renderHeader(), this.state.hideQuickfilters ? null : this.renderQuickfilter(), R("div", { style: { width: "100%", height: "100%", gridArea: "view", overflow: "hidden" } }, this.renderView()), designerVisible ? this.renderDesigner() : null);
+    }
+}
+exports.default = MapComponent;

package/lib/maps/MapControlComponent.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { DataSource, Schema } from "@mwater/expressions";
+export interface MapControlComponentProps {
+    /** Schema to use */
+    schema: Schema;
+    dataSource: DataSource;
+    /** See Map Design.md */
+    design: any;
+    onDesignChange: any;
+}
+export default class MapControlComponent extends React.Component<MapControlComponentProps> {
+    render(): React.DetailedReactHTMLElement<{
+        style: {
+            padding: number;
+        };
+    }, HTMLElement>;
+}

package/lib/maps/MapControlComponent.js

@@ -0,0 +1,25 @@
+"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 R = react_1.default.createElement;
+const MapLayersDesignerComponent_1 = __importDefault(require("./MapLayersDesignerComponent"));
+const BaseLayerDesignerComponent_1 = __importDefault(require("./BaseLayerDesignerComponent"));
+// Allows controlling readonly map
+class MapControlComponent extends react_1.default.Component {
+    render() {
+        return R("div", { style: { padding: 5 } }, R(MapLayersDesignerComponent_1.default, {
+            schema: this.props.schema,
+            dataSource: this.props.dataSource,
+            design: this.props.design,
+            onDesignChange: this.props.onDesignChange,
+            allowEditingLayers: false
+        }), R("br"), R("div", { className: "mb-3" }, R("label", { className: "text-muted" }, "Map Style"), R(BaseLayerDesignerComponent_1.default, {
+            design: this.props.design,
+            onDesignChange: this.props.onDesignChange
+        })));
+    }
+}
+exports.default = MapControlComponent;

package/lib/maps/MapDataSource.d.ts

@@ -0,0 +1,18 @@
+import { JsonQLFilter } from "../JsonQLFilter";
+import { MapLayerDataSource } from "./MapLayerDataSource";
+import { MapDesign } from "./MapDesign";
+import { QuickfiltersDataSource } from "../quickfilter/QuickfiltersDataSource";
+/** Map data source gives data sources for layers */
+export interface MapDataSource {
+    /** Gets the data source for a layer */
+    getLayerDataSource: (layerId: string) => MapLayerDataSource;
+    /** Gets the quickfilters data source */
+    getQuickfiltersDataSource(): QuickfiltersDataSource;
+    /** Gets the bounds for the map. Null for no opinion. Callback as { n:, s:, w:, e: } */
+    getBounds(design: MapDesign, filters: JsonQLFilter[], callback: (error: any, bounds?: {
+        w: number;
+        n: number;
+        e: number;
+        s: number;
+    } | null) => void): void;
+}

package/lib/maps/MapDataSource.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/maps/MapDesign.d.ts

@@ -0,0 +1,77 @@
+import { Expr, LiteralType } from "@mwater/expressions";
+import { Quickfilter } from "../quickfilter/Quickfilter";
+/** Maps are stored as a base layer, a series of layers and filters. */
+export interface MapDesign {
+    /** "bing_road"/"bing_aerial"/"cartodb_positron"/"cartodb_dark_matter"/"blank" */
+    baseLayer: "bing_road" | "bing_aerial" | "cartodb_positron" | "cartodb_dark_matter" | "blank";
+    /** 0-1 opacity. null/undefined = 1 */
+    baseLayerOpacity?: number | null;
+    /** [ see layer view below ] */
+    layerViews: MapLayerView[];
+    /** filter expression indexed by table. e.g. { sometable: logical expression, etc. } */
+    filters: {
+        [tableId: string]: Expr;
+    };
+    /** bounds as { w:, n:, e:, s: } */
+    bounds: MapBounds;
+    /** User defined attribution string, added with other required attributions to the map */
+    attribution?: string;
+    /** true to automatically zoom to bounds of data */
+    autoBounds?: boolean;
+    /** maximum allowed zoom level */
+    maxZoom?: number | null;
+    /** array of global filters. See below. */
+    globalFilters?: GlobalFilter[];
+    /** array of quick filters (user-selectable filters). See quickfilter/README.md
+     * Note: these are not available when the map is a widget in a dashboard
+     */
+    quickfilters?: Quickfilter[];
+    /** True to display layer switcher */
+    showLayerSwitcher?: boolean;
+    /** Mode of initial legend display. Default is "open" */
+    initialLegendDisplay?: "open" | "closed" | "closedIfSmall";
+    /** optional locale (e.g. "fr") to use for display */
+    locale?: string;
+    /** True if design panel is hidden */
+    hideDesignPanel?: boolean;
+}
+/** bounds as { w:, n:, e:, s: } */
+export interface MapBounds {
+    w: number;
+    n: number;
+    e: number;
+    s: number;
+}
+/** Is a view of a layer including whether visible, opacity. */
+export interface MapLayerView {
+    /** unique id */
+    id: string;
+    /** string name */
+    name: string;
+    /** string description (not currently shown used) */
+    desc?: string;
+    /** type of the layer. Pass this to layer factory with design */
+    type: string;
+    /** design of the layer. Layer-type specific */
+    design: any;
+    /** true/false */
+    visible: boolean;
+    /** 0.0-1.0 */
+    opacity: number;
+    /** optional group. layers in the same group act as radio buttons */
+    group?: string | null;
+    /** true to hide legend */
+    hideLegend?: boolean;
+}
+/** Global filters apply to multiple tables at once if a certain column is present. User-interface to set them is application-specific
+and the default (non-mWater) dashboard applies them but does not allow editing. */
+export interface GlobalFilter {
+    /** id of column to filter */
+    columnId: string;
+    /** type of column to filter (to ensure that consistent) */
+    columnType: LiteralType;
+    /** op of expression for filtering */
+    op: string;
+    /** array of expressions to use for filtering. field expression for column will be injected as expression 0 in the resulting filter expression */
+    exprs: Expr[];
+}

package/lib/maps/MapDesign.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });