@flowmap.gl/layers 8.0.0-alpha.4 → 8.0.0-alpha.5

package/dist/{FlowMapLayer.d.ts → FlowmapLayer.d.ts}

@@ -1,8 +1,8 @@
 import { CompositeLayer } from '@deck.gl/core';
-import { FlowLinesLayerAttributes, FlowMapData, FlowMapDataAccessors, FlowMapDataProvider, LayersData, FlowMapAggregateAccessors } from '@flowmap.gl/data';
-import { FlowLayerPickingInfo, LayerProps } from './types';
-export declare type FlowMapLayerProps<L, F> = {
-    data: FlowMapData<L, F> | FlowMapDataProvider<L, F>;
+import { FlowLinesLayerAttributes, FlowmapData, FlowmapDataAccessors, FlowmapDataProvider, LayersData, FlowmapAggregateAccessors } from '@flowmap.gl/data';
+import { FlowmapLayerPickingInfo, LayerProps } from './types';
+export declare type FlowmapLayerProps<L, F> = {
+    data: FlowmapData<L, F> | FlowmapDataProvider<L, F>;
     locationTotalsEnabled?: boolean;
     adaptiveScalesEnabled?: boolean;
     animationEnabled?: boolean;
@@ -15,9 +15,10 @@ export declare type FlowMapLayerProps<L, F> = {
     fadeAmount?: number;
     colorScheme?: string;
     highlightColor?: string;
-    onHover?: (info: FlowLayerPickingInfo<L, F> | undefined, event: SourceEvent) => void;
-    onClick?: (info: FlowLayerPickingInfo<L, F>, event: SourceEvent) => void;
-} & Partial<FlowMapDataAccessors<L, F>> & LayerProps;
+    maxTopFlowsDisplayNum?: number;
+    onHover?: (info: FlowmapLayerPickingInfo<L, F> | undefined, event: SourceEvent) => void;
+    onClick?: (info: FlowmapLayerPickingInfo<L, F>, event: SourceEvent) => void;
+} & Partial<FlowmapDataAccessors<L, F>> & LayerProps;
 declare enum HighlightType {
     LOCATION = "location",
     FLOW = "flow"
@@ -33,15 +34,15 @@ declare type HighlightedFlowObject = {
 };
 declare type HighlightedObject = HighlightedLocationObject | HighlightedFlowObject;
 declare type State<L, F> = {
-    accessors: FlowMapAggregateAccessors<L, F>;
-    dataProvider: FlowMapDataProvider<L, F>;
+    accessors: FlowmapAggregateAccessors<L, F>;
+    dataProvider: FlowmapDataProvider<L, F>;
     layersData: LayersData | undefined;
     highlightedObject: HighlightedObject | undefined;
 };
 export declare type SourceEvent = {
     srcEvent: MouseEvent;
 };
-export default class FlowMapLayer<L, F> extends CompositeLayer {
+export default class FlowmapLayer<L, F> extends CompositeLayer {
     static defaultProps: {
         darkMode: boolean;
         fadeAmount: number;
@@ -55,9 +56,10 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
         adaptiveScalesEnabled: boolean;
         colorScheme: string;
         highlightColor: string;
+        maxTopFlowsDisplayNum: number;
     };
     state: State<L, F> | undefined;
-    constructor(props: FlowMapLayerProps<L, F>);
+    constructor(props: FlowmapLayerProps<L, F>);
     initializeState(): void;
     private _updateAccessors;
     private _makeDataProvider;
@@ -65,10 +67,10 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
     shouldUpdateState(params: Record<string, any>): boolean;
     updateState({ oldProps, props, changeFlags }: Record<string, any>): void;
     private _getSettingsState;
-    private _getFlowMapState;
-    private _getFlowLayerPickingInfo;
+    private _getFlowmapState;
+    private _getFlowmapLayerPickingInfo;
     private _getHighlightedObject;
     renderLayers(): Array<any>;
 }
 export {};
-//# sourceMappingURL=FlowMapLayer.d.ts.map
+//# sourceMappingURL=FlowmapLayer.d.ts.map

package/dist/FlowmapLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowmapLayer.d.ts","sourceRoot":"","sources":["../src/FlowmapLayer.ts"],"names":[],"mappings":"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"}

package/dist/FlowmapLayer.js

@@ -0,0 +1,323 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/*
+ * Copyright 2022 FlowmapBlue
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import { CompositeLayer } from '@deck.gl/core';
+import { ScatterplotLayer } from '@deck.gl/layers';
+import { colorAsRgba, getFlowLineAttributesByIndex, getFlowmapColors, getOuterCircleRadiusByIndex, getLocationCentroidByIndex, isFlowmapData, isFlowmapDataProvider, LocalFlowmapDataProvider, LocationFilterMode, FlowmapAggregateAccessors, } from '@flowmap.gl/data';
+import AnimatedFlowLinesLayer from './AnimatedFlowLinesLayer';
+import FlowCirclesLayer from './FlowCirclesLayer';
+import FlowLinesLayer from './FlowLinesLayer';
+import { PickingType, } from './types';
+var HighlightType;
+(function (HighlightType) {
+    HighlightType["LOCATION"] = "location";
+    HighlightType["FLOW"] = "flow";
+})(HighlightType || (HighlightType = {}));
+export default class FlowmapLayer extends CompositeLayer {
+    constructor(props) {
+        super(Object.assign(Object.assign({}, props), { onHover: (info, event) => {
+                // TODO: if (lastHoverEventStartTimeRef > startTime) {
+                //   // Skipping, because this is not the latest hover event
+                //   return;
+                // }
+                this.setState({ highlightedObject: this._getHighlightedObject(info) });
+                const { onHover } = props;
+                if (onHover) {
+                    this._getFlowmapLayerPickingInfo(info).then((info) => onHover(info, event));
+                }
+            }, onClick: (info, event) => {
+                const { onClick } = props;
+                if (onClick) {
+                    this._getFlowmapLayerPickingInfo(info).then((info) => {
+                        if (info) {
+                            onClick(info, event);
+                        }
+                    });
+                }
+            } }));
+    }
+    initializeState() {
+        this.state = {
+            accessors: new FlowmapAggregateAccessors(this.props),
+            dataProvider: this._makeDataProvider(),
+            layersData: undefined,
+            highlightedObject: undefined,
+        };
+    }
+    _updateAccessors() {
+        var _a, _b;
+        (_b = (_a = this.state) === null || _a === void 0 ? void 0 : _a.dataProvider) === null || _b === void 0 ? void 0 : _b.setAccessors(this.props);
+        this.setState({ accessors: new FlowmapAggregateAccessors(this.props) });
+    }
+    _makeDataProvider() {
+        const { data } = this.props;
+        if (isFlowmapDataProvider(data)) {
+            return data;
+        }
+        else if (isFlowmapData(data)) {
+            const dataProvider = new LocalFlowmapDataProvider(this.props);
+            dataProvider.setFlowmapData(data);
+            return dataProvider;
+        }
+        throw new Error('FlowmapLayer: data must be a FlowmapDataProvider or FlowmapData');
+    }
+    _updateDataProvider() {
+        this.setState({ dataProvider: this._makeDataProvider() });
+    }
+    shouldUpdateState(params) {
+        const { changeFlags } = params;
+        // if (this._viewportChanged()) {
+        //   return true;
+        // }
+        if (changeFlags.viewportChanged) {
+            return true;
+        }
+        return super.shouldUpdateState(params);
+        // TODO: be smarter on when to update
+        // (e.g. ignore viewport changes when adaptiveScalesEnabled and clustering are false)
+    }
+    updateState({ oldProps, props, changeFlags }) {
+        const { dataProvider, highlightedObject } = this.state || {};
+        if (!dataProvider) {
+            return;
+        }
+        if (changeFlags.propsChanged) {
+            this._updateAccessors();
+        }
+        if (changeFlags.dataChanged) {
+            this._updateDataProvider();
+        }
+        if (changeFlags.viewportChanged || changeFlags.dataChanged) {
+            this.setState({
+                highlightedObject: undefined,
+            });
+        }
+        if (changeFlags.viewportChanged || changeFlags.propsOrDataChanged) {
+            dataProvider.setFlowmapState(this._getFlowmapState());
+            (() => __awaiter(this, void 0, void 0, function* () {
+                const layersData = yield dataProvider.getLayersData();
+                this.setState({ layersData });
+            }))();
+        }
+    }
+    _getSettingsState() {
+        const { locationTotalsEnabled, adaptiveScalesEnabled, animationEnabled, clusteringEnabled, clusteringLevel, fadeEnabled, fadeOpacityEnabled, clusteringAuto, darkMode, fadeAmount, colorScheme, highlightColor, maxTopFlowsDisplayNum, } = this.props;
+        return {
+            locationTotalsEnabled,
+            adaptiveScalesEnabled,
+            animationEnabled,
+            clusteringEnabled,
+            clusteringLevel,
+            fadeEnabled,
+            fadeOpacityEnabled,
+            clusteringAuto,
+            darkMode,
+            fadeAmount,
+            colorScheme,
+            highlightColor,
+            maxTopFlowsDisplayNum,
+        };
+    }
+    _getFlowmapState() {
+        return {
+            viewport: asViewState(this.context.viewport),
+            filterState: {
+                selectedLocations: undefined,
+                locationFilterMode: LocationFilterMode.ALL,
+                selectedTimeRange: undefined,
+            },
+            settingsState: this._getSettingsState(),
+        };
+    }
+    _getFlowmapLayerPickingInfo(info) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { index, sourceLayer } = info;
+            const { dataProvider, accessors } = this.state || {};
+            if (!dataProvider || !accessors) {
+                return undefined;
+            }
+            const commonInfo = {
+                // ...info,
+                layer: info.layer,
+                index: info.index,
+                x: info.x,
+                y: info.y,
+                coordinate: info.coordinate,
+            };
+            if (sourceLayer instanceof FlowLinesLayer ||
+                sourceLayer instanceof AnimatedFlowLinesLayer) {
+                const flow = index === -1 ? undefined : yield dataProvider.getFlowByIndex(index);
+                if (flow) {
+                    const origin = yield dataProvider.getLocationById(accessors.getFlowOriginId(flow));
+                    const dest = yield dataProvider.getLocationById(accessors.getFlowDestId(flow));
+                    if (origin && dest) {
+                        return Object.assign(Object.assign({}, commonInfo), { type: PickingType.FLOW, object: flow, origin: origin, dest: dest, count: accessors.getFlowMagnitude(flow) });
+                    }
+                }
+            }
+            else if (sourceLayer instanceof FlowCirclesLayer) {
+                const location = index === -1 ? undefined : yield dataProvider.getLocationByIndex(index);
+                if (location) {
+                    const id = accessors.getLocationId(location);
+                    const name = accessors.getLocationName(location);
+                    const totals = yield dataProvider.getTotalsForLocation(id);
+                    const { circleAttributes } = ((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) || {};
+                    if (totals && circleAttributes) {
+                        const circleRadius = getOuterCircleRadiusByIndex(circleAttributes, info.index);
+                        return Object.assign(Object.assign({}, commonInfo), { type: PickingType.LOCATION, object: location, id,
+                            name,
+                            totals, circleRadius: circleRadius, event: undefined });
+                    }
+                }
+            }
+            return undefined;
+        });
+    }
+    _getHighlightedObject(info) {
+        var _a, _b;
+        const { index, sourceLayer } = info;
+        if (index < 0)
+            return undefined;
+        if (sourceLayer instanceof FlowLinesLayer ||
+            sourceLayer instanceof AnimatedFlowLinesLayer) {
+            const { lineAttributes } = ((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) || {};
+            if (lineAttributes) {
+                let attrs = getFlowLineAttributesByIndex(lineAttributes, index);
+                if (this.props.fadeOpacityEnabled) {
+                    attrs = Object.assign(Object.assign({}, attrs), { attributes: Object.assign(Object.assign({}, attrs.attributes), { getColor: Object.assign(Object.assign({}, attrs.attributes.getColor), { value: new Uint8Array([
+                                    ...attrs.attributes.getColor.value.slice(0, 3),
+                                    255, // the highlight color should be always opaque
+                                ]) }) }) });
+                }
+                return {
+                    type: HighlightType.FLOW,
+                    lineAttributes: attrs,
+                };
+            }
+        }
+        else if (sourceLayer instanceof FlowCirclesLayer) {
+            const { circleAttributes } = ((_b = this.state) === null || _b === void 0 ? void 0 : _b.layersData) || {};
+            if (circleAttributes) {
+                return {
+                    type: HighlightType.LOCATION,
+                    centroid: getLocationCentroidByIndex(circleAttributes, index),
+                    radius: getOuterCircleRadiusByIndex(circleAttributes, index),
+                };
+            }
+        }
+        return undefined;
+    }
+    renderLayers() {
+        var _a;
+        const layers = [];
+        if ((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) {
+            const { layersData, highlightedObject } = this.state;
+            const { circleAttributes, lineAttributes } = layersData || {};
+            if (circleAttributes && lineAttributes) {
+                const flowmapColors = getFlowmapColors(this._getSettingsState());
+                const outlineColor = colorAsRgba(flowmapColors.outlineColor || (this.props.darkMode ? '#000' : '#fff'));
+                const commonLineLayerProps = {
+                    data: lineAttributes,
+                    parameters: Object.assign(Object.assign({}, this.props.parameters), { 
+                        // prevent z-fighting at non-zero bearing/pitch
+                        depthTest: false }),
+                };
+                if (this.props.animationEnabled) {
+                    layers.push(
+                    // @ts-ignore
+                    new AnimatedFlowLinesLayer(Object.assign({}, this.getSubLayerProps(Object.assign(Object.assign({}, commonLineLayerProps), { id: 'animated-flow-lines', drawOutline: false, thicknessUnit: 20 })))));
+                }
+                else {
+                    layers.push(new FlowLinesLayer(Object.assign({}, this.getSubLayerProps(Object.assign(Object.assign({}, commonLineLayerProps), { id: 'flow-lines', drawOutline: true, outlineColor: outlineColor })))));
+                }
+                layers.push(new FlowCirclesLayer(this.getSubLayerProps({
+                    id: 'circles',
+                    data: circleAttributes,
+                    emptyColor: [0, 0, 0, 255],
+                    emptyOutlineColor: [0, 0, 0, 255],
+                })));
+                if (highlightedObject) {
+                    switch (highlightedObject.type) {
+                        case HighlightType.LOCATION:
+                            layers.push(new ScatterplotLayer(Object.assign({}, this.getSubLayerProps({
+                                id: 'location-highlight',
+                                data: [highlightedObject],
+                                pickable: false,
+                                stroked: true,
+                                filled: false,
+                                lineWidthUnits: 'pixels',
+                                getLineWidth: 2,
+                                radiusUnits: 'pixels',
+                                getRadius: (d) => d.radius,
+                                getLineColor: colorAsRgba(this.props.highlightColor),
+                                getPosition: (d) => d.centroid,
+                            }))));
+                            break;
+                        case HighlightType.FLOW:
+                            layers.push(new FlowLinesLayer(Object.assign({}, this.getSubLayerProps({
+                                id: 'flow-highlight',
+                                data: highlightedObject.lineAttributes,
+                                drawOutline: true,
+                                pickable: false,
+                                outlineColor: colorAsRgba(this.props.highlightColor),
+                                outlineThickness: 1,
+                            }))));
+                            break;
+                    }
+                }
+            }
+        }
+        return layers;
+    }
+}
+FlowmapLayer.defaultProps = {
+    darkMode: true,
+    fadeAmount: 50,
+    locationTotalsEnabled: true,
+    animationEnabled: false,
+    clusteringEnabled: true,
+    fadeEnabled: true,
+    fadeOpacityEnabled: false,
+    clusteringAuto: true,
+    clusteringLevel: undefined,
+    adaptiveScalesEnabled: true,
+    colorScheme: 'Teal',
+    highlightColor: 'orange',
+    maxTopFlowsDisplayNum: 5000,
+};
+function asViewState(viewport) {
+    const { width, height, longitude, latitude, zoom, pitch, bearing } = viewport;
+    return {
+        width,
+        height,
+        longitude,
+        latitude,
+        zoom,
+        pitch,
+        bearing,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowmapLayer.js","sourceRoot":"","sources":["../src/FlowmapLayer.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2022 FlowmapBlue\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\nimport {CompositeLayer} from '@deck.gl/core';\nimport {ScatterplotLayer} from '@deck.gl/layers';\nimport {\n  colorAsRgba,\n  FlowLinesLayerAttributes,\n  FlowmapData,\n  FlowmapDataAccessors,\n  FlowmapDataProvider,\n  getFlowLineAttributesByIndex,\n  getFlowmapColors,\n  getOuterCircleRadiusByIndex,\n  getLocationCentroidByIndex,\n  isFlowmapData,\n  isFlowmapDataProvider,\n  LayersData,\n  LocalFlowmapDataProvider,\n  LocationFilterMode,\n  ViewportProps,\n  FlowmapAggregateAccessors,\n} from '@flowmap.gl/data';\nimport AnimatedFlowLinesLayer from './AnimatedFlowLinesLayer';\nimport FlowCirclesLayer from './FlowCirclesLayer';\nimport FlowLinesLayer from './FlowLinesLayer';\nimport {\n  FlowmapLayerPickingInfo,\n  LayerProps,\n  PickingInfo,\n  PickingType,\n} from './types';\n\nexport type FlowmapLayerProps<L, F> = {\n  data: FlowmapData<L, F> | FlowmapDataProvider<L, F>;\n  locationTotalsEnabled?: boolean;\n  adaptiveScalesEnabled?: boolean;\n  animationEnabled?: boolean;\n  clusteringEnabled?: boolean;\n  clusteringLevel?: number;\n  fadeEnabled?: boolean;\n  fadeOpacityEnabled?: boolean;\n  clusteringAuto?: boolean;\n  darkMode?: boolean;\n  fadeAmount?: number;\n  colorScheme?: string;\n  highlightColor?: string;\n  maxTopFlowsDisplayNum?: number;\n  onHover?: (\n    info: FlowmapLayerPickingInfo<L, F> | undefined,\n    event: SourceEvent,\n  ) => void;\n  onClick?: (info: FlowmapLayerPickingInfo<L, F>, event: SourceEvent) => void;\n} & Partial<FlowmapDataAccessors<L, F>> &\n  LayerProps;\n\nenum HighlightType {\n  LOCATION = 'location',\n  FLOW = 'flow',\n}\n\ntype HighlightedLocationObject = {\n  type: HighlightType.LOCATION;\n  centroid: [number, number];\n  radius: number;\n};\n\ntype HighlightedFlowObject = {\n  type: HighlightType.FLOW;\n  lineAttributes: FlowLinesLayerAttributes;\n};\n\ntype HighlightedObject = HighlightedLocationObject | HighlightedFlowObject;\n\ntype State<L, F> = {\n  accessors: FlowmapAggregateAccessors<L, F>;\n  dataProvider: FlowmapDataProvider<L, F>;\n  layersData: LayersData | undefined;\n  highlightedObject: HighlightedObject | undefined;\n};\n\nexport type SourceEvent = {srcEvent: MouseEvent};\n\nexport default class FlowmapLayer<L, F> extends CompositeLayer {\n  static defaultProps = {\n    darkMode: true,\n    fadeAmount: 50,\n    locationTotalsEnabled: true,\n    animationEnabled: false,\n    clusteringEnabled: true,\n    fadeEnabled: true,\n    fadeOpacityEnabled: false,\n    clusteringAuto: true,\n    clusteringLevel: undefined,\n    adaptiveScalesEnabled: true,\n    colorScheme: 'Teal',\n    highlightColor: 'orange',\n    maxTopFlowsDisplayNum: 5000,\n  };\n  state: State<L, F> | undefined;\n\n  public constructor(props: FlowmapLayerProps<L, F>) {\n    super({\n      ...props,\n      onHover: (info: PickingInfo<any>, event: SourceEvent) => {\n        // TODO: if (lastHoverEventStartTimeRef > startTime) {\n        //   // Skipping, because this is not the latest hover event\n        //   return;\n        // }\n        this.setState({highlightedObject: this._getHighlightedObject(info)});\n        const {onHover} = props;\n        if (onHover) {\n          this._getFlowmapLayerPickingInfo(info).then((info) =>\n            onHover(info, event),\n          );\n        }\n      },\n      onClick: (info: PickingInfo<any>, event: SourceEvent) => {\n        const {onClick} = props;\n        if (onClick) {\n          this._getFlowmapLayerPickingInfo(info).then((info) => {\n            if (info) {\n              onClick(info, event);\n            }\n          });\n        }\n      },\n    });\n  }\n\n  initializeState() {\n    this.state = {\n      accessors: new FlowmapAggregateAccessors<L, F>(this.props),\n      dataProvider: this._makeDataProvider(),\n      layersData: undefined,\n      highlightedObject: undefined,\n    };\n  }\n\n  private _updateAccessors() {\n    this.state?.dataProvider?.setAccessors(this.props);\n    this.setState({accessors: new FlowmapAggregateAccessors(this.props)});\n  }\n\n  private _makeDataProvider() {\n    const {data} = this.props;\n    if (isFlowmapDataProvider<L, F>(data)) {\n      return data;\n    } else if (isFlowmapData<L, F>(data)) {\n      const dataProvider = new LocalFlowmapDataProvider<L, F>(this.props);\n      dataProvider.setFlowmapData(data);\n      return dataProvider;\n    }\n    throw new Error(\n      'FlowmapLayer: data must be a FlowmapDataProvider or FlowmapData',\n    );\n  }\n\n  private _updateDataProvider() {\n    this.setState({dataProvider: this._makeDataProvider()});\n  }\n\n  shouldUpdateState(params: Record<string, any>): boolean {\n    const {changeFlags} = params;\n    // if (this._viewportChanged()) {\n    //   return true;\n    // }\n    if (changeFlags.viewportChanged) {\n      return true;\n    }\n    return super.shouldUpdateState(params);\n    // TODO: be smarter on when to update\n    // (e.g. ignore viewport changes when adaptiveScalesEnabled and clustering are false)\n  }\n\n  updateState({oldProps, props, changeFlags}: Record<string, any>): void {\n    const {dataProvider, highlightedObject} = this.state || {};\n    if (!dataProvider) {\n      return;\n    }\n\n    if (changeFlags.propsChanged) {\n      this._updateAccessors();\n    }\n    if (changeFlags.dataChanged) {\n      this._updateDataProvider();\n    }\n    if (changeFlags.viewportChanged || changeFlags.dataChanged) {\n      this.setState({\n        highlightedObject: undefined,\n      });\n    }\n\n    if (changeFlags.viewportChanged || changeFlags.propsOrDataChanged) {\n      dataProvider.setFlowmapState(this._getFlowmapState());\n      (async () => {\n        const layersData = await dataProvider.getLayersData();\n        this.setState({layersData});\n      })();\n    }\n  }\n\n  private _getSettingsState() {\n    const {\n      locationTotalsEnabled,\n      adaptiveScalesEnabled,\n      animationEnabled,\n      clusteringEnabled,\n      clusteringLevel,\n      fadeEnabled,\n      fadeOpacityEnabled,\n      clusteringAuto,\n      darkMode,\n      fadeAmount,\n      colorScheme,\n      highlightColor,\n      maxTopFlowsDisplayNum,\n    } = this.props;\n    return {\n      locationTotalsEnabled,\n      adaptiveScalesEnabled,\n      animationEnabled,\n      clusteringEnabled,\n      clusteringLevel,\n      fadeEnabled,\n      fadeOpacityEnabled,\n      clusteringAuto,\n      darkMode,\n      fadeAmount,\n      colorScheme,\n      highlightColor,\n      maxTopFlowsDisplayNum,\n    };\n  }\n\n  private _getFlowmapState() {\n    return {\n      viewport: asViewState(this.context.viewport),\n      filterState: {\n        selectedLocations: undefined,\n        locationFilterMode: LocationFilterMode.ALL,\n        selectedTimeRange: undefined,\n      },\n      settingsState: this._getSettingsState(),\n    };\n  }\n\n  private async _getFlowmapLayerPickingInfo(\n    info: Record<string, any>,\n  ): Promise<FlowmapLayerPickingInfo<L, F> | undefined> {\n    const {index, sourceLayer} = info;\n    const {dataProvider, accessors} = this.state || {};\n    if (!dataProvider || !accessors) {\n      return undefined;\n    }\n    const commonInfo = {\n      // ...info,\n      layer: info.layer,\n      index: info.index,\n      x: info.x,\n      y: info.y,\n      coordinate: info.coordinate,\n    };\n    if (\n      sourceLayer instanceof FlowLinesLayer ||\n      sourceLayer instanceof AnimatedFlowLinesLayer\n    ) {\n      const flow =\n        index === -1 ? undefined : await dataProvider.getFlowByIndex(index);\n      if (flow) {\n        const origin = await dataProvider.getLocationById(\n          accessors.getFlowOriginId(flow),\n        );\n        const dest = await dataProvider.getLocationById(\n          accessors.getFlowDestId(flow),\n        );\n        if (origin && dest) {\n          return {\n            ...commonInfo,\n            type: PickingType.FLOW,\n            object: flow,\n            origin: origin,\n            dest: dest,\n            count: accessors.getFlowMagnitude(flow),\n          };\n        }\n      }\n    } else if (sourceLayer instanceof FlowCirclesLayer) {\n      const location =\n        index === -1 ? undefined : await dataProvider.getLocationByIndex(index);\n\n      if (location) {\n        const id = accessors.getLocationId(location);\n        const name = accessors.getLocationName(location);\n        const totals = await dataProvider.getTotalsForLocation(id);\n        const {circleAttributes} = this.state?.layersData || {};\n        if (totals && circleAttributes) {\n          const circleRadius = getOuterCircleRadiusByIndex(\n            circleAttributes,\n            info.index,\n          );\n          return {\n            ...commonInfo,\n            type: PickingType.LOCATION,\n            object: location,\n            id,\n            name,\n            totals,\n            circleRadius: circleRadius,\n            event: undefined,\n          };\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  private _getHighlightedObject(\n    info: Record<string, any>,\n  ): HighlightedObject | undefined {\n    const {index, sourceLayer} = info;\n    if (index < 0) return undefined;\n    if (\n      sourceLayer instanceof FlowLinesLayer ||\n      sourceLayer instanceof AnimatedFlowLinesLayer\n    ) {\n      const {lineAttributes} = this.state?.layersData || {};\n      if (lineAttributes) {\n        let attrs = getFlowLineAttributesByIndex(lineAttributes, index);\n        if (this.props.fadeOpacityEnabled) {\n          attrs = {\n            ...attrs,\n            attributes: {\n              ...attrs.attributes,\n              getColor: {\n                ...attrs.attributes.getColor,\n                value: new Uint8Array([\n                  ...attrs.attributes.getColor.value.slice(0, 3),\n                  255, // the highlight color should be always opaque\n                ]),\n              },\n            },\n          };\n        }\n        return {\n          type: HighlightType.FLOW,\n          lineAttributes: attrs,\n        };\n      }\n    } else if (sourceLayer instanceof FlowCirclesLayer) {\n      const {circleAttributes} = this.state?.layersData || {};\n      if (circleAttributes) {\n        return {\n          type: HighlightType.LOCATION,\n          centroid: getLocationCentroidByIndex(circleAttributes, index),\n          radius: getOuterCircleRadiusByIndex(circleAttributes, index),\n        };\n      }\n    }\n    return undefined;\n  }\n\n  renderLayers(): Array<any> {\n    const layers = [];\n    if (this.state?.layersData) {\n      const {layersData, highlightedObject} = this.state;\n      const {circleAttributes, lineAttributes} = layersData || {};\n      if (circleAttributes && lineAttributes) {\n        const flowmapColors = getFlowmapColors(this._getSettingsState());\n        const outlineColor = colorAsRgba(\n          flowmapColors.outlineColor || (this.props.darkMode ? '#000' : '#fff'),\n        );\n        const commonLineLayerProps = {\n          data: lineAttributes,\n          parameters: {\n            ...this.props.parameters,\n            // prevent z-fighting at non-zero bearing/pitch\n            depthTest: false,\n          },\n        };\n        if (this.props.animationEnabled) {\n          layers.push(\n            // @ts-ignore\n            new AnimatedFlowLinesLayer({\n              ...this.getSubLayerProps({\n                ...commonLineLayerProps,\n                id: 'animated-flow-lines',\n                drawOutline: false,\n                thicknessUnit: 20,\n              }),\n            }),\n          );\n        } else {\n          layers.push(\n            new FlowLinesLayer({\n              ...this.getSubLayerProps({\n                ...commonLineLayerProps,\n                id: 'flow-lines',\n                drawOutline: true,\n                outlineColor: outlineColor,\n              }),\n            }),\n          );\n        }\n        layers.push(\n          new FlowCirclesLayer(\n            this.getSubLayerProps({\n              id: 'circles',\n              data: circleAttributes,\n              emptyColor: [0, 0, 0, 255],\n              emptyOutlineColor: [0, 0, 0, 255],\n            }),\n          ),\n        );\n        if (highlightedObject) {\n          switch (highlightedObject.type) {\n            case HighlightType.LOCATION:\n              layers.push(\n                new ScatterplotLayer({\n                  ...this.getSubLayerProps({\n                    id: 'location-highlight',\n                    data: [highlightedObject],\n                    pickable: false,\n                    stroked: true,\n                    filled: false,\n                    lineWidthUnits: 'pixels',\n                    getLineWidth: 2,\n                    radiusUnits: 'pixels',\n                    getRadius: (d: HighlightedLocationObject) => d.radius,\n                    getLineColor: colorAsRgba(this.props.highlightColor),\n                    getPosition: (d: HighlightedLocationObject) => d.centroid,\n                  }),\n                }),\n              );\n              break;\n            case HighlightType.FLOW:\n              layers.push(\n                new FlowLinesLayer({\n                  ...this.getSubLayerProps({\n                    id: 'flow-highlight',\n                    data: highlightedObject.lineAttributes,\n                    drawOutline: true,\n                    pickable: false,\n                    outlineColor: colorAsRgba(this.props.highlightColor),\n                    outlineThickness: 1,\n                  }),\n                }),\n              );\n              break;\n          }\n        }\n      }\n    }\n\n    return layers;\n  }\n}\n\nfunction asViewState(viewport: Record<string, any>): ViewportProps {\n  const {width, height, longitude, latitude, zoom, pitch, bearing} = viewport;\n  return {\n    width,\n    height,\n    longitude,\n    latitude,\n    zoom,\n    pitch,\n    bearing,\n  };\n}\n"]}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { default as AnimatedFlowLinesLayer } from './AnimatedFlowLinesLayer';
 export { default as FlowLinesLayer } from './FlowLinesLayer';
 export { default as FlowCirclesLayer } from './FlowCirclesLayer';
-export { default as FlowMapLayer } from './FlowMapLayer';
-export type { FlowMapLayerProps } from './FlowMapLayer';
+export { default as FlowmapLayer } from './FlowmapLayer';
+export type { FlowmapLayerProps } from './FlowmapLayer';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,6 @@
 export { default as AnimatedFlowLinesLayer } from './AnimatedFlowLinesLayer';
 export { default as FlowLinesLayer } from './FlowLinesLayer';
 export { default as FlowCirclesLayer } from './FlowCirclesLayer';
-export { default as FlowMapLayer } from './FlowMapLayer';
+export { default as FlowmapLayer } from './FlowmapLayer';
 export * from './types';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLE9BQU8sSUFBSSxzQkFBc0IsRUFBQyxNQUFNLDBCQUEwQixDQUFDO0FBQzNFLE9BQU8sRUFBQyxPQUFPLElBQUksY0FBYyxFQUFDLE1BQU0sa0JBQWtCLENBQUM7QUFDM0QsT0FBTyxFQUFDLE9BQU8sSUFBSSxnQkFBZ0IsRUFBQyxNQUFNLG9CQUFvQixDQUFDO0FBQy9ELE9BQU8sRUFBQyxPQUFPLElBQUksWUFBWSxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFHdkQsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge2RlZmF1bHQgYXMgQW5pbWF0ZWRGbG93TGluZXNMYXllcn0gZnJvbSAnLi9BbmltYXRlZEZsb3dMaW5lc0xheWVyJztcbmV4cG9ydCB7ZGVmYXVsdCBhcyBGbG93TGluZXNMYXllcn0gZnJvbSAnLi9GbG93TGluZXNMYXllcic7XG5leHBvcnQge2RlZmF1bHQgYXMgRmxvd0NpcmNsZXNMYXllcn0gZnJvbSAnLi9GbG93Q2lyY2xlc0xheWVyJztcbmV4cG9ydCB7ZGVmYXVsdCBhcyBGbG93TWFwTGF5ZXJ9IGZyb20gJy4vRmxvd01hcExheWVyJztcbmV4cG9ydCB0eXBlIHtGbG93TWFwTGF5ZXJQcm9wc30gZnJvbSAnLi9GbG93TWFwTGF5ZXInO1xuXG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLE9BQU8sSUFBSSxzQkFBc0IsRUFBQyxNQUFNLDBCQUEwQixDQUFDO0FBQzNFLE9BQU8sRUFBQyxPQUFPLElBQUksY0FBYyxFQUFDLE1BQU0sa0JBQWtCLENBQUM7QUFDM0QsT0FBTyxFQUFDLE9BQU8sSUFBSSxnQkFBZ0IsRUFBQyxNQUFNLG9CQUFvQixDQUFDO0FBQy9ELE9BQU8sRUFBQyxPQUFPLElBQUksWUFBWSxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFHdkQsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge2RlZmF1bHQgYXMgQW5pbWF0ZWRGbG93TGluZXNMYXllcn0gZnJvbSAnLi9BbmltYXRlZEZsb3dMaW5lc0xheWVyJztcbmV4cG9ydCB7ZGVmYXVsdCBhcyBGbG93TGluZXNMYXllcn0gZnJvbSAnLi9GbG93TGluZXNMYXllcic7XG5leHBvcnQge2RlZmF1bHQgYXMgRmxvd0NpcmNsZXNMYXllcn0gZnJvbSAnLi9GbG93Q2lyY2xlc0xheWVyJztcbmV4cG9ydCB7ZGVmYXVsdCBhcyBGbG93bWFwTGF5ZXJ9IGZyb20gJy4vRmxvd21hcExheWVyJztcbmV4cG9ydCB0eXBlIHtGbG93bWFwTGF5ZXJQcm9wc30gZnJvbSAnLi9GbG93bWFwTGF5ZXInO1xuXG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/dist/types.d.ts

@@ -27,5 +27,5 @@ export interface FlowPickingInfo<L, F> extends PickingInfo<F | AggregateFlow> {
     dest: L | ClusterNode;
     count: number;
 }
-export declare type FlowLayerPickingInfo<L, F> = LocationPickingInfo<L> | FlowPickingInfo<L, F>;
+export declare type FlowmapLayerPickingInfo<L, F> = LocationPickingInfo<L> | FlowPickingInfo<L, F>;
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAEb,WAAW,EACX,cAAc,EACf,MAAM,kBAAkB,CAAC;AAE1B,oBAAY,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,oBAAY,WAAW;IACrB,QAAQ,aAAa;IACrB,IAAI,SAAS;CAEd;AAED,oBAAY,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE9C,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,CAAC,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,GAAG,WAAW,CAAC;IAC1E,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,cAAc,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,UAAU,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,GAAG,aAAa,CAAC;IAC3E,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC;IACvB,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC;IACxB,IAAI,EAAE,CAAC,GAAG,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAOD,oBAAY,oBAAoB,CAAC,CAAC,EAAE,CAAC,IACjC,mBAAmB,CAAC,CAAC,CAAC,GAEtB,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAEb,WAAW,EACX,cAAc,EACf,MAAM,kBAAkB,CAAC;AAE1B,oBAAY,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,oBAAY,WAAW;IACrB,QAAQ,aAAa;IACrB,IAAI,SAAS;CAEd;AAED,oBAAY,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE9C,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,CAAC,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,GAAG,WAAW,CAAC;IAC1E,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,cAAc,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,UAAU,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,GAAG,aAAa,CAAC;IAC3E,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC;IACvB,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC;IACxB,IAAI,EAAE,CAAC,GAAG,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAOD,oBAAY,uBAAuB,CAAC,CAAC,EAAE,CAAC,IACpC,mBAAmB,CAAC,CAAC,CAAC,GAEtB,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/types.js

@@ -17,4 +17,4 @@ export var PickingType;
 //       .type === 'FeatureCollection'
 //   );
 // }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowmap.gl/layers",
-  "version": "8.0.0-alpha.4",
+  "version": "8.0.0-alpha.5",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
     "@luma.gl/constants": "^8.5.10",
     "@luma.gl/core": "^8.5.10"
   },
-  "gitHead": "ffa382b66f9ec865cb834c3d6d13672dc0540784",
+  "gitHead": "301087551f76980d8d366ec6cdc39d8ad6fef2f2",
   "publishConfig": {
     "access": "public"
   }

package/src/{FlowMapLayer.ts → FlowmapLayer.ts}

@@ -19,35 +19,33 @@ import {ScatterplotLayer} from '@deck.gl/layers';
 import {
   colorAsRgba,
   FlowLinesLayerAttributes,
-  FlowMapData,
-  FlowMapDataAccessors,
-  FlowMapDataProvider,
+  FlowmapData,
+  FlowmapDataAccessors,
+  FlowmapDataProvider,
   getFlowLineAttributesByIndex,
-  getFlowMapColors,
+  getFlowmapColors,
   getOuterCircleRadiusByIndex,
   getLocationCentroidByIndex,
-  isFlowMapData,
-  isFlowMapDataProvider,
+  isFlowmapData,
+  isFlowmapDataProvider,
   LayersData,
-  LocalFlowMapDataProvider,
+  LocalFlowmapDataProvider,
   LocationFilterMode,
   ViewportProps,
-  FlowMapAggregateAccessors,
-  ClusterNode,
-  AggregateFlow,
+  FlowmapAggregateAccessors,
 } from '@flowmap.gl/data';
 import AnimatedFlowLinesLayer from './AnimatedFlowLinesLayer';
 import FlowCirclesLayer from './FlowCirclesLayer';
 import FlowLinesLayer from './FlowLinesLayer';
 import {
-  FlowLayerPickingInfo,
+  FlowmapLayerPickingInfo,
   LayerProps,
   PickingInfo,
   PickingType,
 } from './types';
 
-export type FlowMapLayerProps<L, F> = {
-  data: FlowMapData<L, F> | FlowMapDataProvider<L, F>;
+export type FlowmapLayerProps<L, F> = {
+  data: FlowmapData<L, F> | FlowmapDataProvider<L, F>;
   locationTotalsEnabled?: boolean;
   adaptiveScalesEnabled?: boolean;
   animationEnabled?: boolean;
@@ -60,12 +58,13 @@ export type FlowMapLayerProps<L, F> = {
   fadeAmount?: number;
   colorScheme?: string;
   highlightColor?: string;
+  maxTopFlowsDisplayNum?: number;
   onHover?: (
-    info: FlowLayerPickingInfo<L, F> | undefined,
+    info: FlowmapLayerPickingInfo<L, F> | undefined,
     event: SourceEvent,
   ) => void;
-  onClick?: (info: FlowLayerPickingInfo<L, F>, event: SourceEvent) => void;
-} & Partial<FlowMapDataAccessors<L, F>> &
+  onClick?: (info: FlowmapLayerPickingInfo<L, F>, event: SourceEvent) => void;
+} & Partial<FlowmapDataAccessors<L, F>> &
   LayerProps;
 
 enum HighlightType {
@@ -87,15 +86,15 @@ type HighlightedFlowObject = {
 type HighlightedObject = HighlightedLocationObject | HighlightedFlowObject;
 
 type State<L, F> = {
-  accessors: FlowMapAggregateAccessors<L, F>;
-  dataProvider: FlowMapDataProvider<L, F>;
+  accessors: FlowmapAggregateAccessors<L, F>;
+  dataProvider: FlowmapDataProvider<L, F>;
   layersData: LayersData | undefined;
   highlightedObject: HighlightedObject | undefined;
 };
 
 export type SourceEvent = {srcEvent: MouseEvent};
 
-export default class FlowMapLayer<L, F> extends CompositeLayer {
+export default class FlowmapLayer<L, F> extends CompositeLayer {
   static defaultProps = {
     darkMode: true,
     fadeAmount: 50,
@@ -109,10 +108,11 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
     adaptiveScalesEnabled: true,
     colorScheme: 'Teal',
     highlightColor: 'orange',
+    maxTopFlowsDisplayNum: 5000,
   };
   state: State<L, F> | undefined;
 
-  public constructor(props: FlowMapLayerProps<L, F>) {
+  public constructor(props: FlowmapLayerProps<L, F>) {
     super({
       ...props,
       onHover: (info: PickingInfo<any>, event: SourceEvent) => {
@@ -123,7 +123,7 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
         this.setState({highlightedObject: this._getHighlightedObject(info)});
         const {onHover} = props;
         if (onHover) {
-          this._getFlowLayerPickingInfo(info).then((info) =>
+          this._getFlowmapLayerPickingInfo(info).then((info) =>
             onHover(info, event),
           );
         }
@@ -131,7 +131,7 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
       onClick: (info: PickingInfo<any>, event: SourceEvent) => {
         const {onClick} = props;
         if (onClick) {
-          this._getFlowLayerPickingInfo(info).then((info) => {
+          this._getFlowmapLayerPickingInfo(info).then((info) => {
             if (info) {
               onClick(info, event);
             }
@@ -143,7 +143,7 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
 
   initializeState() {
     this.state = {
-      accessors: new FlowMapAggregateAccessors<L, F>(this.props),
+      accessors: new FlowmapAggregateAccessors<L, F>(this.props),
       dataProvider: this._makeDataProvider(),
       layersData: undefined,
       highlightedObject: undefined,
@@ -152,20 +152,20 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
 
   private _updateAccessors() {
     this.state?.dataProvider?.setAccessors(this.props);
-    this.setState({accessors: new FlowMapAggregateAccessors(this.props)});
+    this.setState({accessors: new FlowmapAggregateAccessors(this.props)});
   }
 
   private _makeDataProvider() {
     const {data} = this.props;
-    if (isFlowMapDataProvider<L, F>(data)) {
+    if (isFlowmapDataProvider<L, F>(data)) {
       return data;
-    } else if (isFlowMapData<L, F>(data)) {
-      const dataProvider = new LocalFlowMapDataProvider<L, F>(this.props);
-      dataProvider.setFlowMapData(data);
+    } else if (isFlowmapData<L, F>(data)) {
+      const dataProvider = new LocalFlowmapDataProvider<L, F>(this.props);
+      dataProvider.setFlowmapData(data);
       return dataProvider;
     }
     throw new Error(
-      'FlowMapLayer: data must be a FlowMapDataProvider or FlowMapData',
+      'FlowmapLayer: data must be a FlowmapDataProvider or FlowmapData',
     );
   }
 
@@ -205,7 +205,7 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
     }
 
     if (changeFlags.viewportChanged || changeFlags.propsOrDataChanged) {
-      dataProvider.setFlowMapState(this._getFlowMapState());
+      dataProvider.setFlowmapState(this._getFlowmapState());
       (async () => {
         const layersData = await dataProvider.getLayersData();
         this.setState({layersData});
@@ -226,6 +226,8 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
       darkMode,
       fadeAmount,
       colorScheme,
+      highlightColor,
+      maxTopFlowsDisplayNum,
     } = this.props;
     return {
       locationTotalsEnabled,
@@ -239,10 +241,12 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
       darkMode,
       fadeAmount,
       colorScheme,
+      highlightColor,
+      maxTopFlowsDisplayNum,
     };
   }
 
-  private _getFlowMapState() {
+  private _getFlowmapState() {
     return {
       viewport: asViewState(this.context.viewport),
       filterState: {
@@ -254,9 +258,9 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
     };
   }
 
-  private async _getFlowLayerPickingInfo(
+  private async _getFlowmapLayerPickingInfo(
     info: Record<string, any>,
-  ): Promise<FlowLayerPickingInfo<L, F> | undefined> {
+  ): Promise<FlowmapLayerPickingInfo<L, F> | undefined> {
     const {index, sourceLayer} = info;
     const {dataProvider, accessors} = this.state || {};
     if (!dataProvider || !accessors) {
@@ -376,9 +380,9 @@ export default class FlowMapLayer<L, F> extends CompositeLayer {
       const {layersData, highlightedObject} = this.state;
       const {circleAttributes, lineAttributes} = layersData || {};
       if (circleAttributes && lineAttributes) {
-        const flowMapColors = getFlowMapColors(this._getSettingsState());
+        const flowmapColors = getFlowmapColors(this._getSettingsState());
         const outlineColor = colorAsRgba(
-          flowMapColors.outlineColor || (this.props.darkMode ? '#000' : '#fff'),
+          flowmapColors.outlineColor || (this.props.darkMode ? '#000' : '#fff'),
         );
         const commonLineLayerProps = {
           data: lineAttributes,

package/src/index.ts

@@ -1,7 +1,7 @@
 export {default as AnimatedFlowLinesLayer} from './AnimatedFlowLinesLayer';
 export {default as FlowLinesLayer} from './FlowLinesLayer';
 export {default as FlowCirclesLayer} from './FlowCirclesLayer';
-export {default as FlowMapLayer} from './FlowMapLayer';
-export type {FlowMapLayerProps} from './FlowMapLayer';
+export {default as FlowmapLayer} from './FlowmapLayer';
+export type {FlowmapLayerProps} from './FlowmapLayer';
 
 export * from './types';

package/src/types.ts

@@ -45,7 +45,7 @@ export interface FlowPickingInfo<L, F> extends PickingInfo<F | AggregateFlow> {
 //   object: FlowLocation;
 // }
 
-export type FlowLayerPickingInfo<L, F> =
+export type FlowmapLayerPickingInfo<L, F> =
   | LocationPickingInfo<L>
   // | LocationAreaPickingInfo
   | FlowPickingInfo<L, F>;

package/dist/FlowMapLayer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FlowMapLayer.d.ts","sourceRoot":"","sources":["../src/FlowMapLayer.ts"],"names":[],"mappings":"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"}

package/dist/FlowMapLayer.js

@@ -1,320 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-/*
- * Copyright 2022 FlowmapBlue
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-import { CompositeLayer } from '@deck.gl/core';
-import { ScatterplotLayer } from '@deck.gl/layers';
-import { colorAsRgba, getFlowLineAttributesByIndex, getFlowMapColors, getOuterCircleRadiusByIndex, getLocationCentroidByIndex, isFlowMapData, isFlowMapDataProvider, LocalFlowMapDataProvider, LocationFilterMode, FlowMapAggregateAccessors, } from '@flowmap.gl/data';
-import AnimatedFlowLinesLayer from './AnimatedFlowLinesLayer';
-import FlowCirclesLayer from './FlowCirclesLayer';
-import FlowLinesLayer from './FlowLinesLayer';
-import { PickingType, } from './types';
-var HighlightType;
-(function (HighlightType) {
-    HighlightType["LOCATION"] = "location";
-    HighlightType["FLOW"] = "flow";
-})(HighlightType || (HighlightType = {}));
-export default class FlowMapLayer extends CompositeLayer {
-    constructor(props) {
-        super(Object.assign(Object.assign({}, props), { onHover: (info, event) => {
-                // TODO: if (lastHoverEventStartTimeRef > startTime) {
-                //   // Skipping, because this is not the latest hover event
-                //   return;
-                // }
-                this.setState({ highlightedObject: this._getHighlightedObject(info) });
-                const { onHover } = props;
-                if (onHover) {
-                    this._getFlowLayerPickingInfo(info).then((info) => onHover(info, event));
-                }
-            }, onClick: (info, event) => {
-                const { onClick } = props;
-                if (onClick) {
-                    this._getFlowLayerPickingInfo(info).then((info) => {
-                        if (info) {
-                            onClick(info, event);
-                        }
-                    });
-                }
-            } }));
-    }
-    initializeState() {
-        this.state = {
-            accessors: new FlowMapAggregateAccessors(this.props),
-            dataProvider: this._makeDataProvider(),
-            layersData: undefined,
-            highlightedObject: undefined,
-        };
-    }
-    _updateAccessors() {
-        var _a, _b;
-        (_b = (_a = this.state) === null || _a === void 0 ? void 0 : _a.dataProvider) === null || _b === void 0 ? void 0 : _b.setAccessors(this.props);
-        this.setState({ accessors: new FlowMapAggregateAccessors(this.props) });
-    }
-    _makeDataProvider() {
-        const { data } = this.props;
-        if (isFlowMapDataProvider(data)) {
-            return data;
-        }
-        else if (isFlowMapData(data)) {
-            const dataProvider = new LocalFlowMapDataProvider(this.props);
-            dataProvider.setFlowMapData(data);
-            return dataProvider;
-        }
-        throw new Error('FlowMapLayer: data must be a FlowMapDataProvider or FlowMapData');
-    }
-    _updateDataProvider() {
-        this.setState({ dataProvider: this._makeDataProvider() });
-    }
-    shouldUpdateState(params) {
-        const { changeFlags } = params;
-        // if (this._viewportChanged()) {
-        //   return true;
-        // }
-        if (changeFlags.viewportChanged) {
-            return true;
-        }
-        return super.shouldUpdateState(params);
-        // TODO: be smarter on when to update
-        // (e.g. ignore viewport changes when adaptiveScalesEnabled and clustering are false)
-    }
-    updateState({ oldProps, props, changeFlags }) {
-        const { dataProvider, highlightedObject } = this.state || {};
-        if (!dataProvider) {
-            return;
-        }
-        if (changeFlags.propsChanged) {
-            this._updateAccessors();
-        }
-        if (changeFlags.dataChanged) {
-            this._updateDataProvider();
-        }
-        if (changeFlags.viewportChanged || changeFlags.dataChanged) {
-            this.setState({
-                highlightedObject: undefined,
-            });
-        }
-        if (changeFlags.viewportChanged || changeFlags.propsOrDataChanged) {
-            dataProvider.setFlowMapState(this._getFlowMapState());
-            (() => __awaiter(this, void 0, void 0, function* () {
-                const layersData = yield dataProvider.getLayersData();
-                this.setState({ layersData });
-            }))();
-        }
-    }
-    _getSettingsState() {
-        const { locationTotalsEnabled, adaptiveScalesEnabled, animationEnabled, clusteringEnabled, clusteringLevel, fadeEnabled, fadeOpacityEnabled, clusteringAuto, darkMode, fadeAmount, colorScheme, } = this.props;
-        return {
-            locationTotalsEnabled,
-            adaptiveScalesEnabled,
-            animationEnabled,
-            clusteringEnabled,
-            clusteringLevel,
-            fadeEnabled,
-            fadeOpacityEnabled,
-            clusteringAuto,
-            darkMode,
-            fadeAmount,
-            colorScheme,
-        };
-    }
-    _getFlowMapState() {
-        return {
-            viewport: asViewState(this.context.viewport),
-            filterState: {
-                selectedLocations: undefined,
-                locationFilterMode: LocationFilterMode.ALL,
-                selectedTimeRange: undefined,
-            },
-            settingsState: this._getSettingsState(),
-        };
-    }
-    _getFlowLayerPickingInfo(info) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const { index, sourceLayer } = info;
-            const { dataProvider, accessors } = this.state || {};
-            if (!dataProvider || !accessors) {
-                return undefined;
-            }
-            const commonInfo = {
-                // ...info,
-                layer: info.layer,
-                index: info.index,
-                x: info.x,
-                y: info.y,
-                coordinate: info.coordinate,
-            };
-            if (sourceLayer instanceof FlowLinesLayer ||
-                sourceLayer instanceof AnimatedFlowLinesLayer) {
-                const flow = index === -1 ? undefined : yield dataProvider.getFlowByIndex(index);
-                if (flow) {
-                    const origin = yield dataProvider.getLocationById(accessors.getFlowOriginId(flow));
-                    const dest = yield dataProvider.getLocationById(accessors.getFlowDestId(flow));
-                    if (origin && dest) {
-                        return Object.assign(Object.assign({}, commonInfo), { type: PickingType.FLOW, object: flow, origin: origin, dest: dest, count: accessors.getFlowMagnitude(flow) });
-                    }
-                }
-            }
-            else if (sourceLayer instanceof FlowCirclesLayer) {
-                const location = index === -1 ? undefined : yield dataProvider.getLocationByIndex(index);
-                if (location) {
-                    const id = accessors.getLocationId(location);
-                    const name = accessors.getLocationName(location);
-                    const totals = yield dataProvider.getTotalsForLocation(id);
-                    const { circleAttributes } = ((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) || {};
-                    if (totals && circleAttributes) {
-                        const circleRadius = getOuterCircleRadiusByIndex(circleAttributes, info.index);
-                        return Object.assign(Object.assign({}, commonInfo), { type: PickingType.LOCATION, object: location, id,
-                            name,
-                            totals, circleRadius: circleRadius, event: undefined });
-                    }
-                }
-            }
-            return undefined;
-        });
-    }
-    _getHighlightedObject(info) {
-        var _a, _b;
-        const { index, sourceLayer } = info;
-        if (index < 0)
-            return undefined;
-        if (sourceLayer instanceof FlowLinesLayer ||
-            sourceLayer instanceof AnimatedFlowLinesLayer) {
-            const { lineAttributes } = ((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) || {};
-            if (lineAttributes) {
-                let attrs = getFlowLineAttributesByIndex(lineAttributes, index);
-                if (this.props.fadeOpacityEnabled) {
-                    attrs = Object.assign(Object.assign({}, attrs), { attributes: Object.assign(Object.assign({}, attrs.attributes), { getColor: Object.assign(Object.assign({}, attrs.attributes.getColor), { value: new Uint8Array([
-                                    ...attrs.attributes.getColor.value.slice(0, 3),
-                                    255, // the highlight color should be always opaque
-                                ]) }) }) });
-                }
-                return {
-                    type: HighlightType.FLOW,
-                    lineAttributes: attrs,
-                };
-            }
-        }
-        else if (sourceLayer instanceof FlowCirclesLayer) {
-            const { circleAttributes } = ((_b = this.state) === null || _b === void 0 ? void 0 : _b.layersData) || {};
-            if (circleAttributes) {
-                return {
-                    type: HighlightType.LOCATION,
-                    centroid: getLocationCentroidByIndex(circleAttributes, index),
-                    radius: getOuterCircleRadiusByIndex(circleAttributes, index),
-                };
-            }
-        }
-        return undefined;
-    }
-    renderLayers() {
-        var _a;
-        const layers = [];
-        if ((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) {
-            const { layersData, highlightedObject } = this.state;
-            const { circleAttributes, lineAttributes } = layersData || {};
-            if (circleAttributes && lineAttributes) {
-                const flowMapColors = getFlowMapColors(this._getSettingsState());
-                const outlineColor = colorAsRgba(flowMapColors.outlineColor || (this.props.darkMode ? '#000' : '#fff'));
-                const commonLineLayerProps = {
-                    data: lineAttributes,
-                    parameters: Object.assign(Object.assign({}, this.props.parameters), { 
-                        // prevent z-fighting at non-zero bearing/pitch
-                        depthTest: false }),
-                };
-                if (this.props.animationEnabled) {
-                    layers.push(
-                    // @ts-ignore
-                    new AnimatedFlowLinesLayer(Object.assign({}, this.getSubLayerProps(Object.assign(Object.assign({}, commonLineLayerProps), { id: 'animated-flow-lines', drawOutline: false, thicknessUnit: 20 })))));
-                }
-                else {
-                    layers.push(new FlowLinesLayer(Object.assign({}, this.getSubLayerProps(Object.assign(Object.assign({}, commonLineLayerProps), { id: 'flow-lines', drawOutline: true, outlineColor: outlineColor })))));
-                }
-                layers.push(new FlowCirclesLayer(this.getSubLayerProps({
-                    id: 'circles',
-                    data: circleAttributes,
-                    emptyColor: [0, 0, 0, 255],
-                    emptyOutlineColor: [0, 0, 0, 255],
-                })));
-                if (highlightedObject) {
-                    switch (highlightedObject.type) {
-                        case HighlightType.LOCATION:
-                            layers.push(new ScatterplotLayer(Object.assign({}, this.getSubLayerProps({
-                                id: 'location-highlight',
-                                data: [highlightedObject],
-                                pickable: false,
-                                stroked: true,
-                                filled: false,
-                                lineWidthUnits: 'pixels',
-                                getLineWidth: 2,
-                                radiusUnits: 'pixels',
-                                getRadius: (d) => d.radius,
-                                getLineColor: colorAsRgba(this.props.highlightColor),
-                                getPosition: (d) => d.centroid,
-                            }))));
-                            break;
-                        case HighlightType.FLOW:
-                            layers.push(new FlowLinesLayer(Object.assign({}, this.getSubLayerProps({
-                                id: 'flow-highlight',
-                                data: highlightedObject.lineAttributes,
-                                drawOutline: true,
-                                pickable: false,
-                                outlineColor: colorAsRgba(this.props.highlightColor),
-                                outlineThickness: 1,
-                            }))));
-                            break;
-                    }
-                }
-            }
-        }
-        return layers;
-    }
-}
-FlowMapLayer.defaultProps = {
-    darkMode: true,
-    fadeAmount: 50,
-    locationTotalsEnabled: true,
-    animationEnabled: false,
-    clusteringEnabled: true,
-    fadeEnabled: true,
-    fadeOpacityEnabled: false,
-    clusteringAuto: true,
-    clusteringLevel: undefined,
-    adaptiveScalesEnabled: true,
-    colorScheme: 'Teal',
-    highlightColor: 'orange',
-};
-function asViewState(viewport) {
-    const { width, height, longitude, latitude, zoom, pitch, bearing } = viewport;
-    return {
-        width,
-        height,
-        longitude,
-        latitude,
-        zoom,
-        pitch,
-        bearing,
-    };
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowMapLayer.js","sourceRoot":"","sources":["../src/FlowMapLayer.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2022 FlowmapBlue\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\nimport {CompositeLayer} from '@deck.gl/core';\nimport {ScatterplotLayer} from '@deck.gl/layers';\nimport {\n  colorAsRgba,\n  FlowLinesLayerAttributes,\n  FlowMapData,\n  FlowMapDataAccessors,\n  FlowMapDataProvider,\n  getFlowLineAttributesByIndex,\n  getFlowMapColors,\n  getOuterCircleRadiusByIndex,\n  getLocationCentroidByIndex,\n  isFlowMapData,\n  isFlowMapDataProvider,\n  LayersData,\n  LocalFlowMapDataProvider,\n  LocationFilterMode,\n  ViewportProps,\n  FlowMapAggregateAccessors,\n  ClusterNode,\n  AggregateFlow,\n} from '@flowmap.gl/data';\nimport AnimatedFlowLinesLayer from './AnimatedFlowLinesLayer';\nimport FlowCirclesLayer from './FlowCirclesLayer';\nimport FlowLinesLayer from './FlowLinesLayer';\nimport {\n  FlowLayerPickingInfo,\n  LayerProps,\n  PickingInfo,\n  PickingType,\n} from './types';\n\nexport type FlowMapLayerProps<L, F> = {\n  data: FlowMapData<L, F> | FlowMapDataProvider<L, F>;\n  locationTotalsEnabled?: boolean;\n  adaptiveScalesEnabled?: boolean;\n  animationEnabled?: boolean;\n  clusteringEnabled?: boolean;\n  clusteringLevel?: number;\n  fadeEnabled?: boolean;\n  fadeOpacityEnabled?: boolean;\n  clusteringAuto?: boolean;\n  darkMode?: boolean;\n  fadeAmount?: number;\n  colorScheme?: string;\n  highlightColor?: string;\n  onHover?: (\n    info: FlowLayerPickingInfo<L, F> | undefined,\n    event: SourceEvent,\n  ) => void;\n  onClick?: (info: FlowLayerPickingInfo<L, F>, event: SourceEvent) => void;\n} & Partial<FlowMapDataAccessors<L, F>> &\n  LayerProps;\n\nenum HighlightType {\n  LOCATION = 'location',\n  FLOW = 'flow',\n}\n\ntype HighlightedLocationObject = {\n  type: HighlightType.LOCATION;\n  centroid: [number, number];\n  radius: number;\n};\n\ntype HighlightedFlowObject = {\n  type: HighlightType.FLOW;\n  lineAttributes: FlowLinesLayerAttributes;\n};\n\ntype HighlightedObject = HighlightedLocationObject | HighlightedFlowObject;\n\ntype State<L, F> = {\n  accessors: FlowMapAggregateAccessors<L, F>;\n  dataProvider: FlowMapDataProvider<L, F>;\n  layersData: LayersData | undefined;\n  highlightedObject: HighlightedObject | undefined;\n};\n\nexport type SourceEvent = {srcEvent: MouseEvent};\n\nexport default class FlowMapLayer<L, F> extends CompositeLayer {\n  static defaultProps = {\n    darkMode: true,\n    fadeAmount: 50,\n    locationTotalsEnabled: true,\n    animationEnabled: false,\n    clusteringEnabled: true,\n    fadeEnabled: true,\n    fadeOpacityEnabled: false,\n    clusteringAuto: true,\n    clusteringLevel: undefined,\n    adaptiveScalesEnabled: true,\n    colorScheme: 'Teal',\n    highlightColor: 'orange',\n  };\n  state: State<L, F> | undefined;\n\n  public constructor(props: FlowMapLayerProps<L, F>) {\n    super({\n      ...props,\n      onHover: (info: PickingInfo<any>, event: SourceEvent) => {\n        // TODO: if (lastHoverEventStartTimeRef > startTime) {\n        //   // Skipping, because this is not the latest hover event\n        //   return;\n        // }\n        this.setState({highlightedObject: this._getHighlightedObject(info)});\n        const {onHover} = props;\n        if (onHover) {\n          this._getFlowLayerPickingInfo(info).then((info) =>\n            onHover(info, event),\n          );\n        }\n      },\n      onClick: (info: PickingInfo<any>, event: SourceEvent) => {\n        const {onClick} = props;\n        if (onClick) {\n          this._getFlowLayerPickingInfo(info).then((info) => {\n            if (info) {\n              onClick(info, event);\n            }\n          });\n        }\n      },\n    });\n  }\n\n  initializeState() {\n    this.state = {\n      accessors: new FlowMapAggregateAccessors<L, F>(this.props),\n      dataProvider: this._makeDataProvider(),\n      layersData: undefined,\n      highlightedObject: undefined,\n    };\n  }\n\n  private _updateAccessors() {\n    this.state?.dataProvider?.setAccessors(this.props);\n    this.setState({accessors: new FlowMapAggregateAccessors(this.props)});\n  }\n\n  private _makeDataProvider() {\n    const {data} = this.props;\n    if (isFlowMapDataProvider<L, F>(data)) {\n      return data;\n    } else if (isFlowMapData<L, F>(data)) {\n      const dataProvider = new LocalFlowMapDataProvider<L, F>(this.props);\n      dataProvider.setFlowMapData(data);\n      return dataProvider;\n    }\n    throw new Error(\n      'FlowMapLayer: data must be a FlowMapDataProvider or FlowMapData',\n    );\n  }\n\n  private _updateDataProvider() {\n    this.setState({dataProvider: this._makeDataProvider()});\n  }\n\n  shouldUpdateState(params: Record<string, any>): boolean {\n    const {changeFlags} = params;\n    // if (this._viewportChanged()) {\n    //   return true;\n    // }\n    if (changeFlags.viewportChanged) {\n      return true;\n    }\n    return super.shouldUpdateState(params);\n    // TODO: be smarter on when to update\n    // (e.g. ignore viewport changes when adaptiveScalesEnabled and clustering are false)\n  }\n\n  updateState({oldProps, props, changeFlags}: Record<string, any>): void {\n    const {dataProvider, highlightedObject} = this.state || {};\n    if (!dataProvider) {\n      return;\n    }\n\n    if (changeFlags.propsChanged) {\n      this._updateAccessors();\n    }\n    if (changeFlags.dataChanged) {\n      this._updateDataProvider();\n    }\n    if (changeFlags.viewportChanged || changeFlags.dataChanged) {\n      this.setState({\n        highlightedObject: undefined,\n      });\n    }\n\n    if (changeFlags.viewportChanged || changeFlags.propsOrDataChanged) {\n      dataProvider.setFlowMapState(this._getFlowMapState());\n      (async () => {\n        const layersData = await dataProvider.getLayersData();\n        this.setState({layersData});\n      })();\n    }\n  }\n\n  private _getSettingsState() {\n    const {\n      locationTotalsEnabled,\n      adaptiveScalesEnabled,\n      animationEnabled,\n      clusteringEnabled,\n      clusteringLevel,\n      fadeEnabled,\n      fadeOpacityEnabled,\n      clusteringAuto,\n      darkMode,\n      fadeAmount,\n      colorScheme,\n    } = this.props;\n    return {\n      locationTotalsEnabled,\n      adaptiveScalesEnabled,\n      animationEnabled,\n      clusteringEnabled,\n      clusteringLevel,\n      fadeEnabled,\n      fadeOpacityEnabled,\n      clusteringAuto,\n      darkMode,\n      fadeAmount,\n      colorScheme,\n    };\n  }\n\n  private _getFlowMapState() {\n    return {\n      viewport: asViewState(this.context.viewport),\n      filterState: {\n        selectedLocations: undefined,\n        locationFilterMode: LocationFilterMode.ALL,\n        selectedTimeRange: undefined,\n      },\n      settingsState: this._getSettingsState(),\n    };\n  }\n\n  private async _getFlowLayerPickingInfo(\n    info: Record<string, any>,\n  ): Promise<FlowLayerPickingInfo<L, F> | undefined> {\n    const {index, sourceLayer} = info;\n    const {dataProvider, accessors} = this.state || {};\n    if (!dataProvider || !accessors) {\n      return undefined;\n    }\n    const commonInfo = {\n      // ...info,\n      layer: info.layer,\n      index: info.index,\n      x: info.x,\n      y: info.y,\n      coordinate: info.coordinate,\n    };\n    if (\n      sourceLayer instanceof FlowLinesLayer ||\n      sourceLayer instanceof AnimatedFlowLinesLayer\n    ) {\n      const flow =\n        index === -1 ? undefined : await dataProvider.getFlowByIndex(index);\n      if (flow) {\n        const origin = await dataProvider.getLocationById(\n          accessors.getFlowOriginId(flow),\n        );\n        const dest = await dataProvider.getLocationById(\n          accessors.getFlowDestId(flow),\n        );\n        if (origin && dest) {\n          return {\n            ...commonInfo,\n            type: PickingType.FLOW,\n            object: flow,\n            origin: origin,\n            dest: dest,\n            count: accessors.getFlowMagnitude(flow),\n          };\n        }\n      }\n    } else if (sourceLayer instanceof FlowCirclesLayer) {\n      const location =\n        index === -1 ? undefined : await dataProvider.getLocationByIndex(index);\n\n      if (location) {\n        const id = accessors.getLocationId(location);\n        const name = accessors.getLocationName(location);\n        const totals = await dataProvider.getTotalsForLocation(id);\n        const {circleAttributes} = this.state?.layersData || {};\n        if (totals && circleAttributes) {\n          const circleRadius = getOuterCircleRadiusByIndex(\n            circleAttributes,\n            info.index,\n          );\n          return {\n            ...commonInfo,\n            type: PickingType.LOCATION,\n            object: location,\n            id,\n            name,\n            totals,\n            circleRadius: circleRadius,\n            event: undefined,\n          };\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  private _getHighlightedObject(\n    info: Record<string, any>,\n  ): HighlightedObject | undefined {\n    const {index, sourceLayer} = info;\n    if (index < 0) return undefined;\n    if (\n      sourceLayer instanceof FlowLinesLayer ||\n      sourceLayer instanceof AnimatedFlowLinesLayer\n    ) {\n      const {lineAttributes} = this.state?.layersData || {};\n      if (lineAttributes) {\n        let attrs = getFlowLineAttributesByIndex(lineAttributes, index);\n        if (this.props.fadeOpacityEnabled) {\n          attrs = {\n            ...attrs,\n            attributes: {\n              ...attrs.attributes,\n              getColor: {\n                ...attrs.attributes.getColor,\n                value: new Uint8Array([\n                  ...attrs.attributes.getColor.value.slice(0, 3),\n                  255, // the highlight color should be always opaque\n                ]),\n              },\n            },\n          };\n        }\n        return {\n          type: HighlightType.FLOW,\n          lineAttributes: attrs,\n        };\n      }\n    } else if (sourceLayer instanceof FlowCirclesLayer) {\n      const {circleAttributes} = this.state?.layersData || {};\n      if (circleAttributes) {\n        return {\n          type: HighlightType.LOCATION,\n          centroid: getLocationCentroidByIndex(circleAttributes, index),\n          radius: getOuterCircleRadiusByIndex(circleAttributes, index),\n        };\n      }\n    }\n    return undefined;\n  }\n\n  renderLayers(): Array<any> {\n    const layers = [];\n    if (this.state?.layersData) {\n      const {layersData, highlightedObject} = this.state;\n      const {circleAttributes, lineAttributes} = layersData || {};\n      if (circleAttributes && lineAttributes) {\n        const flowMapColors = getFlowMapColors(this._getSettingsState());\n        const outlineColor = colorAsRgba(\n          flowMapColors.outlineColor || (this.props.darkMode ? '#000' : '#fff'),\n        );\n        const commonLineLayerProps = {\n          data: lineAttributes,\n          parameters: {\n            ...this.props.parameters,\n            // prevent z-fighting at non-zero bearing/pitch\n            depthTest: false,\n          },\n        };\n        if (this.props.animationEnabled) {\n          layers.push(\n            // @ts-ignore\n            new AnimatedFlowLinesLayer({\n              ...this.getSubLayerProps({\n                ...commonLineLayerProps,\n                id: 'animated-flow-lines',\n                drawOutline: false,\n                thicknessUnit: 20,\n              }),\n            }),\n          );\n        } else {\n          layers.push(\n            new FlowLinesLayer({\n              ...this.getSubLayerProps({\n                ...commonLineLayerProps,\n                id: 'flow-lines',\n                drawOutline: true,\n                outlineColor: outlineColor,\n              }),\n            }),\n          );\n        }\n        layers.push(\n          new FlowCirclesLayer(\n            this.getSubLayerProps({\n              id: 'circles',\n              data: circleAttributes,\n              emptyColor: [0, 0, 0, 255],\n              emptyOutlineColor: [0, 0, 0, 255],\n            }),\n          ),\n        );\n        if (highlightedObject) {\n          switch (highlightedObject.type) {\n            case HighlightType.LOCATION:\n              layers.push(\n                new ScatterplotLayer({\n                  ...this.getSubLayerProps({\n                    id: 'location-highlight',\n                    data: [highlightedObject],\n                    pickable: false,\n                    stroked: true,\n                    filled: false,\n                    lineWidthUnits: 'pixels',\n                    getLineWidth: 2,\n                    radiusUnits: 'pixels',\n                    getRadius: (d: HighlightedLocationObject) => d.radius,\n                    getLineColor: colorAsRgba(this.props.highlightColor),\n                    getPosition: (d: HighlightedLocationObject) => d.centroid,\n                  }),\n                }),\n              );\n              break;\n            case HighlightType.FLOW:\n              layers.push(\n                new FlowLinesLayer({\n                  ...this.getSubLayerProps({\n                    id: 'flow-highlight',\n                    data: highlightedObject.lineAttributes,\n                    drawOutline: true,\n                    pickable: false,\n                    outlineColor: colorAsRgba(this.props.highlightColor),\n                    outlineThickness: 1,\n                  }),\n                }),\n              );\n              break;\n          }\n        }\n      }\n    }\n\n    return layers;\n  }\n}\n\nfunction asViewState(viewport: Record<string, any>): ViewportProps {\n  const {width, height, longitude, latitude, zoom, pitch, bearing} = viewport;\n  return {\n    width,\n    height,\n    longitude,\n    latitude,\n    zoom,\n    pitch,\n    bearing,\n  };\n}\n"]}