@flowmap.gl/layers 8.0.0-alpha.12 → 8.0.0-alpha.13

package/dist-es5/FlowmapLayer.js

@@ -0,0 +1,476 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * 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.
+ *
+ */
+var core_1 = require("@deck.gl/core");
+var layers_1 = require("@deck.gl/layers");
+var data_1 = require("@flowmap.gl/data");
+var AnimatedFlowLinesLayer_1 = __importDefault(require("./AnimatedFlowLinesLayer"));
+var FlowCirclesLayer_1 = __importDefault(require("./FlowCirclesLayer"));
+var FlowLinesLayer_1 = __importDefault(require("./FlowLinesLayer"));
+var types_1 = require("./types");
+var HighlightType;
+(function (HighlightType) {
+    HighlightType["LOCATION"] = "location";
+    HighlightType["FLOW"] = "flow";
+})(HighlightType || (HighlightType = {}));
+var FlowmapLayer = /** @class */ (function (_super) {
+    __extends(FlowmapLayer, _super);
+    function FlowmapLayer(props) {
+        var _this = _super.call(this, __assign(__assign({}, props), { dataProvider: {
+                // To avoid deck.gl props diffing on comlink worker proxy causing an exception
+                dataProvider: props.dataProvider,
+            }, onHover: function (info, event) {
+                // TODO: if (lastHoverEventStartTimeRef > startTime) {
+                //   // Skipping, because this is not the latest hover event
+                //   return;
+                // }
+                _this.setState({ highlightedObject: _this._getHighlightedObject(info) });
+                var onHover = props.onHover;
+                if (onHover) {
+                    _this._getFlowmapLayerPickingInfo(info).then(function (info) {
+                        _this.setState({ pickingInfo: info });
+                        onHover(info, event);
+                    });
+                }
+            }, onClick: function (info, event) {
+                var onClick = props.onClick;
+                if (onClick) {
+                    _this._getFlowmapLayerPickingInfo(info).then(function (info) {
+                        _this.setState({ pickingInfo: info });
+                        if (info) {
+                            onClick(info, event);
+                        }
+                    });
+                }
+            } })) || this;
+        return _this;
+    }
+    FlowmapLayer.prototype.initializeState = function () {
+        this.state = {
+            accessors: new data_1.FlowmapAggregateAccessors(this.props),
+            dataProvider: this._getOrMakeDataProvider(),
+            layersData: undefined,
+            highlightedObject: undefined,
+            pickingInfo: undefined,
+        };
+    };
+    FlowmapLayer.prototype.getPickingInfo = function (_a) {
+        var _b, _c;
+        var info = _a.info;
+        // This is for onHover event handlers set on the <DeckGL> component
+        if (!info.object) {
+            var object = (_c = (_b = this.state) === null || _b === void 0 ? void 0 : _b.pickingInfo) === null || _c === void 0 ? void 0 : _c.object;
+            if (object) {
+                return __assign(__assign({}, info), { object: object, picked: true });
+            }
+        }
+        return info;
+    };
+    FlowmapLayer.prototype._updateAccessors = function () {
+        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 data_1.FlowmapAggregateAccessors(this.props) });
+    };
+    FlowmapLayer.prototype._getOrMakeDataProvider = function () {
+        var _a = this.props, data = _a.data, dataProvider = _a.dataProvider;
+        if ((0, data_1.isFlowmapDataProvider)(dataProvider === null || dataProvider === void 0 ? void 0 : dataProvider.dataProvider)) {
+            return dataProvider.dataProvider;
+        }
+        else if ((0, data_1.isFlowmapData)(data)) {
+            var dataProvider_1 = new data_1.LocalFlowmapDataProvider(this.props);
+            dataProvider_1.setFlowmapData(data);
+            return dataProvider_1;
+        }
+        throw new Error('FlowmapLayer: data must be a FlowmapDataProvider or FlowmapData');
+    };
+    FlowmapLayer.prototype._updateDataProvider = function () {
+        this.setState({ dataProvider: this._getOrMakeDataProvider() });
+    };
+    FlowmapLayer.prototype.shouldUpdateState = function (params) {
+        var changeFlags = params.changeFlags;
+        // if (this._viewportChanged()) {
+        //   return true;
+        // }
+        if (changeFlags.viewportChanged) {
+            return true;
+        }
+        return _super.prototype.shouldUpdateState.call(this, params);
+        // TODO: be smarter on when to update
+        // (e.g. ignore viewport changes when adaptiveScalesEnabled and clustering are false)
+    };
+    FlowmapLayer.prototype.updateState = function (_a) {
+        var _this = this;
+        var oldProps = _a.oldProps, props = _a.props, changeFlags = _a.changeFlags;
+        var _b = this.state || {}, dataProvider = _b.dataProvider, highlightedObject = _b.highlightedObject;
+        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 // TODO can we ignore accessor props changes?
+        ) {
+            dataProvider.setFlowmapState(this._getFlowmapState());
+            (function () { return __awaiter(_this, void 0, void 0, function () {
+                var layersData;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, dataProvider.getLayersData()];
+                        case 1:
+                            layersData = _a.sent();
+                            this.setState({ layersData: layersData });
+                            return [2 /*return*/];
+                    }
+                });
+            }); })();
+        }
+    };
+    FlowmapLayer.prototype._getSettingsState = function () {
+        var _a = this.props, locationTotalsEnabled = _a.locationTotalsEnabled, adaptiveScalesEnabled = _a.adaptiveScalesEnabled, animationEnabled = _a.animationEnabled, clusteringEnabled = _a.clusteringEnabled, clusteringLevel = _a.clusteringLevel, fadeEnabled = _a.fadeEnabled, fadeOpacityEnabled = _a.fadeOpacityEnabled, clusteringAuto = _a.clusteringAuto, darkMode = _a.darkMode, fadeAmount = _a.fadeAmount, colorScheme = _a.colorScheme, highlightColor = _a.highlightColor, maxTopFlowsDisplayNum = _a.maxTopFlowsDisplayNum;
+        return {
+            locationTotalsEnabled: locationTotalsEnabled,
+            adaptiveScalesEnabled: adaptiveScalesEnabled,
+            animationEnabled: animationEnabled,
+            clusteringEnabled: clusteringEnabled,
+            clusteringLevel: clusteringLevel,
+            fadeEnabled: fadeEnabled,
+            fadeOpacityEnabled: fadeOpacityEnabled,
+            clusteringAuto: clusteringAuto,
+            darkMode: darkMode,
+            fadeAmount: fadeAmount,
+            colorScheme: colorScheme,
+            highlightColor: highlightColor,
+            maxTopFlowsDisplayNum: maxTopFlowsDisplayNum,
+        };
+    };
+    FlowmapLayer.prototype._getFlowmapState = function () {
+        return {
+            viewport: pickViewportProps(this.context.viewport),
+            filterState: {
+                selectedLocations: undefined,
+                locationFilterMode: data_1.LocationFilterMode.ALL,
+                selectedTimeRange: undefined,
+            },
+            settingsState: this._getSettingsState(),
+        };
+    };
+    FlowmapLayer.prototype._getFlowmapLayerPickingInfo = function (info) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var index, sourceLayer, _b, dataProvider, accessors, commonInfo, flow, _c, origin_1, dest, location_1, _d, id, name_1, totals, circleAttributes, circleRadius;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        index = info.index, sourceLayer = info.sourceLayer;
+                        _b = this.state || {}, dataProvider = _b.dataProvider, accessors = _b.accessors;
+                        if (!dataProvider || !accessors) {
+                            return [2 /*return*/, undefined];
+                        }
+                        commonInfo = __assign(__assign({}, info), { picked: info.picked, layer: info.layer, index: info.index, x: info.x, y: info.y, coordinate: info.coordinate, event: info.event });
+                        if (!(sourceLayer instanceof FlowLinesLayer_1.default ||
+                            sourceLayer instanceof AnimatedFlowLinesLayer_1.default)) return [3 /*break*/, 7];
+                        if (!(index === -1)) return [3 /*break*/, 1];
+                        _c = undefined;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, dataProvider.getFlowByIndex(index)];
+                    case 2:
+                        _c = _e.sent();
+                        _e.label = 3;
+                    case 3:
+                        flow = _c;
+                        if (!flow) return [3 /*break*/, 6];
+                        return [4 /*yield*/, dataProvider.getLocationById(accessors.getFlowOriginId(flow))];
+                    case 4:
+                        origin_1 = _e.sent();
+                        return [4 /*yield*/, dataProvider.getLocationById(accessors.getFlowDestId(flow))];
+                    case 5:
+                        dest = _e.sent();
+                        if (origin_1 && dest) {
+                            return [2 /*return*/, __assign(__assign({}, commonInfo), { object: {
+                                        type: types_1.PickingType.FLOW,
+                                        flow: flow,
+                                        origin: origin_1,
+                                        dest: dest,
+                                        count: accessors.getFlowMagnitude(flow),
+                                    } })];
+                        }
+                        _e.label = 6;
+                    case 6: return [3 /*break*/, 12];
+                    case 7:
+                        if (!(sourceLayer instanceof FlowCirclesLayer_1.default)) return [3 /*break*/, 12];
+                        if (!(index === -1)) return [3 /*break*/, 8];
+                        _d = undefined;
+                        return [3 /*break*/, 10];
+                    case 8: return [4 /*yield*/, dataProvider.getLocationByIndex(index)];
+                    case 9:
+                        _d = _e.sent();
+                        _e.label = 10;
+                    case 10:
+                        location_1 = _d;
+                        if (!location_1) return [3 /*break*/, 12];
+                        id = accessors.getLocationId(location_1);
+                        name_1 = accessors.getLocationName(location_1);
+                        return [4 /*yield*/, dataProvider.getTotalsForLocation(id)];
+                    case 11:
+                        totals = _e.sent();
+                        circleAttributes = (((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) || {}).circleAttributes;
+                        if (totals && circleAttributes) {
+                            circleRadius = (0, data_1.getOuterCircleRadiusByIndex)(circleAttributes, info.index);
+                            return [2 /*return*/, __assign(__assign({}, commonInfo), { object: {
+                                        type: types_1.PickingType.LOCATION,
+                                        location: location_1,
+                                        id: id,
+                                        name: name_1,
+                                        totals: totals,
+                                        circleRadius: circleRadius,
+                                    } })];
+                        }
+                        _e.label = 12;
+                    case 12: return [2 /*return*/, undefined];
+                }
+            });
+        });
+    };
+    FlowmapLayer.prototype._getHighlightedObject = function (info) {
+        var _a, _b;
+        var index = info.index, sourceLayer = info.sourceLayer;
+        if (index < 0)
+            return undefined;
+        if (sourceLayer instanceof FlowLinesLayer_1.default ||
+            sourceLayer instanceof AnimatedFlowLinesLayer_1.default) {
+            var lineAttributes = (((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) || {}).lineAttributes;
+            if (lineAttributes) {
+                var attrs = (0, data_1.getFlowLineAttributesByIndex)(lineAttributes, index);
+                if (this.props.fadeOpacityEnabled) {
+                    attrs = __assign(__assign({}, attrs), { attributes: __assign(__assign({}, attrs.attributes), { getColor: __assign(__assign({}, attrs.attributes.getColor), { value: new Uint8Array(__spreadArray(__spreadArray([], __read(attrs.attributes.getColor.value.slice(0, 3)), false), [
+                                    255, // the highlight color should be always opaque
+                                ], false)) }) }) });
+                }
+                return {
+                    type: HighlightType.FLOW,
+                    lineAttributes: attrs,
+                };
+            }
+        }
+        else if (sourceLayer instanceof FlowCirclesLayer_1.default) {
+            var circleAttributes = (((_b = this.state) === null || _b === void 0 ? void 0 : _b.layersData) || {}).circleAttributes;
+            if (circleAttributes) {
+                return {
+                    type: HighlightType.LOCATION,
+                    coords: (0, data_1.getLocationCoordsByIndex)(circleAttributes, index),
+                    radius: (0, data_1.getOuterCircleRadiusByIndex)(circleAttributes, index),
+                };
+            }
+        }
+        return undefined;
+    };
+    FlowmapLayer.prototype.renderLayers = function () {
+        var _a;
+        var layers = [];
+        if ((_a = this.state) === null || _a === void 0 ? void 0 : _a.layersData) {
+            var _b = this.state, layersData = _b.layersData, highlightedObject = _b.highlightedObject;
+            var _c = layersData || {}, circleAttributes = _c.circleAttributes, lineAttributes = _c.lineAttributes;
+            if (circleAttributes && lineAttributes) {
+                var flowmapColors = (0, data_1.getFlowmapColors)(this._getSettingsState());
+                var outlineColor = (0, data_1.colorAsRgba)(flowmapColors.outlineColor || (this.props.darkMode ? '#000' : '#fff'));
+                var commonLineLayerProps = {
+                    data: lineAttributes,
+                    parameters: __assign(__assign({}, this.props.parameters), { 
+                        // prevent z-fighting at non-zero bearing/pitch
+                        depthTest: false }),
+                };
+                if (this.props.animationEnabled) {
+                    layers.push(
+                    // @ts-ignore
+                    new AnimatedFlowLinesLayer_1.default(__assign({}, this.getSubLayerProps(__assign(__assign({}, commonLineLayerProps), { id: 'animated-flow-lines', drawOutline: false, thicknessUnit: 20 })))));
+                }
+                else {
+                    layers.push(new FlowLinesLayer_1.default(__assign({}, this.getSubLayerProps(__assign(__assign({}, commonLineLayerProps), { id: 'flow-lines', drawOutline: true, outlineColor: outlineColor })))));
+                }
+                layers.push(new FlowCirclesLayer_1.default(this.getSubLayerProps({
+                    id: 'circles',
+                    data: circleAttributes,
+                    emptyColor: this.props.darkMode
+                        ? [0, 0, 0, 255]
+                        : [255, 255, 255, 255],
+                    outlineEmptyMix: 0.4,
+                })));
+                if (highlightedObject) {
+                    switch (highlightedObject.type) {
+                        case HighlightType.LOCATION:
+                            layers.push(new layers_1.ScatterplotLayer(__assign({}, this.getSubLayerProps({
+                                id: 'location-highlight',
+                                data: [highlightedObject],
+                                pickable: false,
+                                antialiasing: true,
+                                stroked: true,
+                                filled: false,
+                                lineWidthUnits: 'pixels',
+                                getLineWidth: 2,
+                                radiusUnits: 'pixels',
+                                getRadius: function (d) { return d.radius; },
+                                getLineColor: (0, data_1.colorAsRgba)(this.props.highlightColor),
+                                getPosition: function (d) { return d.coords; },
+                            }))));
+                            break;
+                        case HighlightType.FLOW:
+                            layers.push(new FlowLinesLayer_1.default(__assign({}, this.getSubLayerProps({
+                                id: 'flow-highlight',
+                                data: highlightedObject.lineAttributes,
+                                drawOutline: true,
+                                pickable: false,
+                                outlineColor: (0, data_1.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,
+    };
+    return FlowmapLayer;
+}(core_1.CompositeLayer));
+exports.default = FlowmapLayer;
+function pickViewportProps(viewport) {
+    var width = viewport.width, height = viewport.height, longitude = viewport.longitude, latitude = viewport.latitude, zoom = viewport.zoom, pitch = viewport.pitch, bearing = viewport.bearing;
+    return {
+        width: width,
+        height: height,
+        longitude: longitude,
+        latitude: latitude,
+        zoom: zoom,
+        pitch: pitch,
+        bearing: bearing,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowmapLayer.js","sourceRoot":"","sources":["../src/FlowmapLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;GAeG;AACH,sCAA6C;AAC7C,0CAAiD;AACjD,yCAiB0B;AAC1B,oFAA8D;AAC9D,wEAAkD;AAClD,oEAA8C;AAC9C,iCAKiB;AA0BjB,IAAK,aAGJ;AAHD,WAAK,aAAa;IAChB,sCAAqB,CAAA;IACrB,8BAAa,CAAA;AACf,CAAC,EAHI,aAAa,KAAb,aAAa,QAGjB;AAyBD;IAAgD,gCAAc;IAkB5D,sBAAmB,KAA8B;QAAjD,YACE,wCACK,KAAK,KACR,YAAY,EAAE;gBACZ,8EAA8E;gBAC9E,YAAY,EAAE,KAAK,CAAC,YAAY;aACjC,EACD,OAAO,EAAE,UAAC,IAAsB,EAAE,KAAkB;gBAClD,sDAAsD;gBACtD,4DAA4D;gBAC5D,YAAY;gBACZ,IAAI;gBACJ,KAAI,CAAC,QAAQ,CAAC,EAAC,iBAAiB,EAAE,KAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAC,CAAC,CAAC;gBAC9D,IAAA,OAAO,GAAI,KAAK,QAAT,CAAU;gBACxB,IAAI,OAAO,EAAE;oBACX,KAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAC,IAAI;wBAC/C,KAAI,CAAC,QAAQ,CAAC,EAAC,WAAW,EAAE,IAAI,EAAC,CAAC,CAAC;wBACnC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;oBACvB,CAAC,CAAC,CAAC;iBACJ;YACH,CAAC,EACD,OAAO,EAAE,UAAC,IAAsB,EAAE,KAAkB;gBAC3C,IAAA,OAAO,GAAI,KAAK,QAAT,CAAU;gBACxB,IAAI,OAAO,EAAE;oBACX,KAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAC,IAAI;wBAC/C,KAAI,CAAC,QAAQ,CAAC,EAAC,WAAW,EAAE,IAAI,EAAC,CAAC,CAAC;wBACnC,IAAI,IAAI,EAAE;4BACR,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;yBACtB;oBACH,CAAC,CAAC,CAAC;iBACJ;YACH,CAAC,IACD,SACH;;IAAD,CAAC;IAED,sCAAe,GAAf;QACE,IAAI,CAAC,KAAK,GAAG;YACX,SAAS,EAAE,IAAI,gCAAyB,CAAO,IAAI,CAAC,KAAK,CAAC;YAC1D,YAAY,EAAE,IAAI,CAAC,sBAAsB,EAAE;YAC3C,UAAU,EAAE,SAAS;YACrB,iBAAiB,EAAE,SAAS;YAC5B,WAAW,EAAE,SAAS;SACvB,CAAC;IACJ,CAAC;IAED,qCAAc,GAAd,UAAe,EAA2B;;YAA1B,IAAI,UAAA;QAClB,mEAAmE;QACnE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,IAAM,MAAM,GAAG,MAAA,MAAA,IAAI,CAAC,KAAK,0CAAE,WAAW,0CAAE,MAAM,CAAC;YAC/C,IAAI,MAAM,EAAE;gBACV,6BACK,IAAI,KACP,MAAM,QAAA,EACN,MAAM,EAAE,IAAI,IACZ;aACH;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,uCAAgB,GAAxB;;QACE,MAAA,MAAA,IAAI,CAAC,KAAK,0CAAE,YAAY,0CAAE,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnD,IAAI,CAAC,QAAQ,CAAC,EAAC,SAAS,EAAE,IAAI,gCAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAC,CAAC,CAAC;IACxE,CAAC;IAEO,6CAAsB,GAA9B;QACQ,IAAA,KAAuB,IAAI,CAAC,KAAK,EAAhC,IAAI,UAAA,EAAE,YAAY,kBAAc,CAAC;QACxC,IAAI,IAAA,4BAAqB,EAAO,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,YAAY,CAAC,EAAE;YAC3D,OAAO,YAAY,CAAC,YAAY,CAAC;SAClC;aAAM,IAAI,IAAA,oBAAa,EAAO,IAAI,CAAC,EAAE;YACpC,IAAM,cAAY,GAAG,IAAI,+BAAwB,CAAO,IAAI,CAAC,KAAK,CAAC,CAAC;YACpE,cAAY,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;YAClC,OAAO,cAAY,CAAC;SACrB;QACD,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAC;IACJ,CAAC;IAEO,0CAAmB,GAA3B;QACE,IAAI,CAAC,QAAQ,CAAC,EAAC,YAAY,EAAE,IAAI,CAAC,sBAAsB,EAAE,EAAC,CAAC,CAAC;IAC/D,CAAC;IAED,wCAAiB,GAAjB,UAAkB,MAA2B;QACpC,IAAA,WAAW,GAAI,MAAM,YAAV,CAAW;QAC7B,iCAAiC;QACjC,iBAAiB;QACjB,IAAI;QACJ,IAAI,WAAW,CAAC,eAAe,EAAE;YAC/B,OAAO,IAAI,CAAC;SACb;QACD,OAAO,iBAAM,iBAAiB,YAAC,MAAM,CAAC,CAAC;QACvC,qCAAqC;QACrC,qFAAqF;IACvF,CAAC;IAED,kCAAW,GAAX,UAAY,EAAmD;QAA/D,iBA4BC;YA5BY,QAAQ,cAAA,EAAE,KAAK,WAAA,EAAE,WAAW,iBAAA;QACjC,IAAA,KAAoC,IAAI,CAAC,KAAK,IAAI,EAAE,EAAnD,YAAY,kBAAA,EAAE,iBAAiB,uBAAoB,CAAC;QAC3D,IAAI,CAAC,YAAY,EAAE;YACjB,OAAO;SACR;QAED,IAAI,WAAW,CAAC,YAAY,EAAE;YAC5B,2BAA2B;SAC5B;QACD,IAAI,WAAW,CAAC,WAAW,EAAE;YAC3B,IAAI,CAAC,mBAAmB,EAAE,CAAC;SAC5B;QACD,IAAI,WAAW,CAAC,eAAe,IAAI,WAAW,CAAC,WAAW,EAAE;YAC1D,IAAI,CAAC,QAAQ,CAAC;gBACZ,iBAAiB,EAAE,SAAS;aAC7B,CAAC,CAAC;SACJ;QAED,IACE,WAAW,CAAC,eAAe;YAC3B,WAAW,CAAC,kBAAkB,CAAC,6CAA6C;UAC5E;YACA,YAAY,CAAC,eAAe,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;YACtD,CAAC;;;;gCACoB,qBAAM,YAAY,CAAC,aAAa,EAAE,EAAA;;4BAA/C,UAAU,GAAG,SAAkC;4BACrD,IAAI,CAAC,QAAQ,CAAC,EAAC,UAAU,YAAA,EAAC,CAAC,CAAC;;;;iBAC7B,CAAC,EAAE,CAAC;SACN;IACH,CAAC;IAEO,wCAAiB,GAAzB;QACQ,IAAA,KAcF,IAAI,CAAC,KAAK,EAbZ,qBAAqB,2BAAA,EACrB,qBAAqB,2BAAA,EACrB,gBAAgB,sBAAA,EAChB,iBAAiB,uBAAA,EACjB,eAAe,qBAAA,EACf,WAAW,iBAAA,EACX,kBAAkB,wBAAA,EAClB,cAAc,oBAAA,EACd,QAAQ,cAAA,EACR,UAAU,gBAAA,EACV,WAAW,iBAAA,EACX,cAAc,oBAAA,EACd,qBAAqB,2BACT,CAAC;QACf,OAAO;YACL,qBAAqB,uBAAA;YACrB,qBAAqB,uBAAA;YACrB,gBAAgB,kBAAA;YAChB,iBAAiB,mBAAA;YACjB,eAAe,iBAAA;YACf,WAAW,aAAA;YACX,kBAAkB,oBAAA;YAClB,cAAc,gBAAA;YACd,QAAQ,UAAA;YACR,UAAU,YAAA;YACV,WAAW,aAAA;YACX,cAAc,gBAAA;YACd,qBAAqB,uBAAA;SACtB,CAAC;IACJ,CAAC;IAEO,uCAAgB,GAAxB;QACE,OAAO;YACL,QAAQ,EAAE,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;YAClD,WAAW,EAAE;gBACX,iBAAiB,EAAE,SAAS;gBAC5B,kBAAkB,EAAE,yBAAkB,CAAC,GAAG;gBAC1C,iBAAiB,EAAE,SAAS;aAC7B;YACD,aAAa,EAAE,IAAI,CAAC,iBAAiB,EAAE;SACxC,CAAC;IACJ,CAAC;IAEa,kDAA2B,GAAzC,UACE,IAAyB;;;;;;;wBAElB,KAAK,GAAiB,IAAI,MAArB,EAAE,WAAW,GAAI,IAAI,YAAR,CAAS;wBAC5B,KAA4B,IAAI,CAAC,KAAK,IAAI,EAAE,EAA3C,YAAY,kBAAA,EAAE,SAAS,eAAA,CAAqB;wBACnD,IAAI,CAAC,YAAY,IAAI,CAAC,SAAS,EAAE;4BAC/B,sBAAO,SAAS,EAAC;yBAClB;wBACK,UAAU,yBACX,IAAI,KACP,MAAM,EAAE,IAAI,CAAC,MAAM,EACnB,KAAK,EAAE,IAAI,CAAC,KAAK,EACjB,KAAK,EAAE,IAAI,CAAC,KAAK,EACjB,CAAC,EAAE,IAAI,CAAC,CAAC,EACT,CAAC,EAAE,IAAI,CAAC,CAAC,EACT,UAAU,EAAE,IAAI,CAAC,UAAU,EAC3B,KAAK,EAAE,IAAI,CAAC,KAAK,GAClB,CAAC;6BAEA,CAAA,WAAW,YAAY,wBAAc;4BACrC,WAAW,YAAY,gCAAsB,CAAA,EAD7C,wBAC6C;6BAG3C,CAAA,KAAK,KAAK,CAAC,CAAC,CAAA,EAAZ,wBAAY;wBAAG,KAAA,SAAS,CAAA;;4BAAG,qBAAM,YAAY,CAAC,cAAc,CAAC,KAAK,CAAC,EAAA;;wBAAxC,KAAA,SAAwC,CAAA;;;wBAD/D,IAAI,KAC2D;6BACjE,IAAI,EAAJ,wBAAI;wBACS,qBAAM,YAAY,CAAC,eAAe,CAC/C,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC,CAChC,EAAA;;wBAFK,WAAS,SAEd;wBACY,qBAAM,YAAY,CAAC,eAAe,CAC7C,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,CAC9B,EAAA;;wBAFK,IAAI,GAAG,SAEZ;wBACD,IAAI,QAAM,IAAI,IAAI,EAAE;4BAClB,4CACK,UAAU,KACb,MAAM,EAAE;wCACN,IAAI,EAAE,mBAAW,CAAC,IAAI;wCACtB,IAAI,MAAA;wCACJ,MAAM,EAAE,QAAM;wCACd,IAAI,EAAE,IAAI;wCACV,KAAK,EAAE,SAAS,CAAC,gBAAgB,CAAC,IAAI,CAAC;qCACxC,KACD;yBACH;;;;6BAEM,CAAA,WAAW,YAAY,0BAAgB,CAAA,EAAvC,yBAAuC;6BAE9C,CAAA,KAAK,KAAK,CAAC,CAAC,CAAA,EAAZ,wBAAY;wBAAG,KAAA,SAAS,CAAA;;4BAAG,qBAAM,YAAY,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAA;;wBAA5C,KAAA,SAA4C,CAAA;;;wBADnE,eACmE;6BAErE,UAAQ,EAAR,yBAAQ;wBACJ,EAAE,GAAG,SAAS,CAAC,aAAa,CAAC,UAAQ,CAAC,CAAC;wBACvC,SAAO,SAAS,CAAC,eAAe,CAAC,UAAQ,CAAC,CAAC;wBAClC,qBAAM,YAAY,CAAC,oBAAoB,CAAC,EAAE,CAAC,EAAA;;wBAApD,MAAM,GAAG,SAA2C;wBACnD,gBAAgB,GAAI,CAAA,CAAA,MAAA,IAAI,CAAC,KAAK,0CAAE,UAAU,KAAI,EAAE,CAAA,iBAAhC,CAAiC;wBACxD,IAAI,MAAM,IAAI,gBAAgB,EAAE;4BACxB,YAAY,GAAG,IAAA,kCAA2B,EAC9C,gBAAgB,EAChB,IAAI,CAAC,KAAK,CACX,CAAC;4BACF,4CACK,UAAU,KACb,MAAM,EAAE;wCACN,IAAI,EAAE,mBAAW,CAAC,QAAQ;wCAC1B,QAAQ,YAAA;wCACR,EAAE,IAAA;wCACF,IAAI,QAAA;wCACJ,MAAM,QAAA;wCACN,YAAY,EAAE,YAAY;qCAC3B,KACD;yBACH;;6BAIL,sBAAO,SAAS,EAAC;;;;KAClB;IAEO,4CAAqB,GAA7B,UACE,IAAyB;;QAElB,IAAA,KAAK,GAAiB,IAAI,MAArB,EAAE,WAAW,GAAI,IAAI,YAAR,CAAS;QAClC,IAAI,KAAK,GAAG,CAAC;YAAE,OAAO,SAAS,CAAC;QAChC,IACE,WAAW,YAAY,wBAAc;YACrC,WAAW,YAAY,gCAAsB,EAC7C;YACO,IAAA,cAAc,GAAI,CAAA,CAAA,MAAA,IAAI,CAAC,KAAK,0CAAE,UAAU,KAAI,EAAE,CAAA,eAAhC,CAAiC;YACtD,IAAI,cAAc,EAAE;gBAClB,IAAI,KAAK,GAAG,IAAA,mCAA4B,EAAC,cAAc,EAAE,KAAK,CAAC,CAAC;gBAChE,IAAI,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE;oBACjC,KAAK,yBACA,KAAK,KACR,UAAU,wBACL,KAAK,CAAC,UAAU,KACnB,QAAQ,wBACH,KAAK,CAAC,UAAU,CAAC,QAAQ,KAC5B,KAAK,EAAE,IAAI,UAAU,wCAChB,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;oCAC9C,GAAG,EAAE,8CAA8C;0CACnD,SAGP,CAAC;iBACH;gBACD,OAAO;oBACL,IAAI,EAAE,aAAa,CAAC,IAAI;oBACxB,cAAc,EAAE,KAAK;iBACtB,CAAC;aACH;SACF;aAAM,IAAI,WAAW,YAAY,0BAAgB,EAAE;YAC3C,IAAA,gBAAgB,GAAI,CAAA,CAAA,MAAA,IAAI,CAAC,KAAK,0CAAE,UAAU,KAAI,EAAE,CAAA,iBAAhC,CAAiC;YACxD,IAAI,gBAAgB,EAAE;gBACpB,OAAO;oBACL,IAAI,EAAE,aAAa,CAAC,QAAQ;oBAC5B,MAAM,EAAE,IAAA,+BAAwB,EAAC,gBAAgB,EAAE,KAAK,CAAC;oBACzD,MAAM,EAAE,IAAA,kCAA2B,EAAC,gBAAgB,EAAE,KAAK,CAAC;iBAC7D,CAAC;aACH;SACF;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,mCAAY,GAAZ;;QACE,IAAM,MAAM,GAAG,EAAE,CAAC;QAClB,IAAI,MAAA,IAAI,CAAC,KAAK,0CAAE,UAAU,EAAE;YACpB,IAAA,KAAkC,IAAI,CAAC,KAAK,EAA3C,UAAU,gBAAA,EAAE,iBAAiB,uBAAc,CAAC;YAC7C,IAAA,KAAqC,UAAU,IAAI,EAAE,EAApD,gBAAgB,sBAAA,EAAE,cAAc,oBAAoB,CAAC;YAC5D,IAAI,gBAAgB,IAAI,cAAc,EAAE;gBACtC,IAAM,aAAa,GAAG,IAAA,uBAAgB,EAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC;gBACjE,IAAM,YAAY,GAAG,IAAA,kBAAW,EAC9B,aAAa,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CACtE,CAAC;gBACF,IAAM,oBAAoB,GAAG;oBAC3B,IAAI,EAAE,cAAc;oBACpB,UAAU,wBACL,IAAI,CAAC,KAAK,CAAC,UAAU;wBACxB,+CAA+C;wBAC/C,SAAS,EAAE,KAAK,GACjB;iBACF,CAAC;gBACF,IAAI,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE;oBAC/B,MAAM,CAAC,IAAI;oBACT,aAAa;oBACb,IAAI,gCAAsB,cACrB,IAAI,CAAC,gBAAgB,uBACnB,oBAAoB,KACvB,EAAE,EAAE,qBAAqB,EACzB,WAAW,EAAE,KAAK,EAClB,aAAa,EAAE,EAAE,IACjB,EACF,CACH,CAAC;iBACH;qBAAM;oBACL,MAAM,CAAC,IAAI,CACT,IAAI,wBAAc,cACb,IAAI,CAAC,gBAAgB,uBACnB,oBAAoB,KACvB,EAAE,EAAE,YAAY,EAChB,WAAW,EAAE,IAAI,EACjB,YAAY,EAAE,YAAY,IAC1B,EACF,CACH,CAAC;iBACH;gBACD,MAAM,CAAC,IAAI,CACT,IAAI,0BAAgB,CAClB,IAAI,CAAC,gBAAgB,CAAC;oBACpB,EAAE,EAAE,SAAS;oBACb,IAAI,EAAE,gBAAgB;oBACtB,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;wBAC7B,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC;wBAChB,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;oBACxB,eAAe,EAAE,GAAG;iBACrB,CAAC,CACH,CACF,CAAC;gBACF,IAAI,iBAAiB,EAAE;oBACrB,QAAQ,iBAAiB,CAAC,IAAI,EAAE;wBAC9B,KAAK,aAAa,CAAC,QAAQ;4BACzB,MAAM,CAAC,IAAI,CACT,IAAI,yBAAgB,cACf,IAAI,CAAC,gBAAgB,CAAC;gCACvB,EAAE,EAAE,oBAAoB;gCACxB,IAAI,EAAE,CAAC,iBAAiB,CAAC;gCACzB,QAAQ,EAAE,KAAK;gCACf,YAAY,EAAE,IAAI;gCAClB,OAAO,EAAE,IAAI;gCACb,MAAM,EAAE,KAAK;gCACb,cAAc,EAAE,QAAQ;gCACxB,YAAY,EAAE,CAAC;gCACf,WAAW,EAAE,QAAQ;gCACrB,SAAS,EAAE,UAAC,CAA4B,IAAK,OAAA,CAAC,CAAC,MAAM,EAAR,CAAQ;gCACrD,YAAY,EAAE,IAAA,kBAAW,EAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;gCACpD,WAAW,EAAE,UAAC,CAA4B,IAAK,OAAA,CAAC,CAAC,MAAM,EAAR,CAAQ;6BACxD,CAAC,EACF,CACH,CAAC;4BACF,MAAM;wBACR,KAAK,aAAa,CAAC,IAAI;4BACrB,MAAM,CAAC,IAAI,CACT,IAAI,wBAAc,cACb,IAAI,CAAC,gBAAgB,CAAC;gCACvB,EAAE,EAAE,gBAAgB;gCACpB,IAAI,EAAE,iBAAiB,CAAC,cAAc;gCACtC,WAAW,EAAE,IAAI;gCACjB,QAAQ,EAAE,KAAK;gCACf,YAAY,EAAE,IAAA,kBAAW,EAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;gCACpD,gBAAgB,EAAE,CAAC;6BACpB,CAAC,EACF,CACH,CAAC;4BACF,MAAM;qBACT;iBACF;aACF;SACF;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IArZM,yBAAY,GAAG;QACpB,QAAQ,EAAE,IAAI;QACd,UAAU,EAAE,EAAE;QACd,qBAAqB,EAAE,IAAI;QAC3B,gBAAgB,EAAE,KAAK;QACvB,iBAAiB,EAAE,IAAI;QACvB,WAAW,EAAE,IAAI;QACjB,kBAAkB,EAAE,KAAK;QACzB,cAAc,EAAE,IAAI;QACpB,eAAe,EAAE,SAAS;QAC1B,qBAAqB,EAAE,IAAI;QAC3B,WAAW,EAAE,MAAM;QACnB,cAAc,EAAE,QAAQ;QACxB,qBAAqB,EAAE,IAAI;KAC5B,CAAC;IAwYJ,mBAAC;CAAA,AAvZD,CAAgD,qBAAc,GAuZ7D;kBAvZoB,YAAY;AAyZjC,SAAS,iBAAiB,CAAC,QAA6B;IAC/C,IAAA,KAAK,GAAuD,QAAQ,MAA/D,EAAE,MAAM,GAA+C,QAAQ,OAAvD,EAAE,SAAS,GAAoC,QAAQ,UAA5C,EAAE,QAAQ,GAA0B,QAAQ,SAAlC,EAAE,IAAI,GAAoB,QAAQ,KAA5B,EAAE,KAAK,GAAa,QAAQ,MAArB,EAAE,OAAO,GAAI,QAAQ,QAAZ,CAAa;IAC5E,OAAO;QACL,KAAK,OAAA;QACL,MAAM,QAAA;QACN,SAAS,WAAA;QACT,QAAQ,UAAA;QACR,IAAI,MAAA;QACJ,KAAK,OAAA;QACL,OAAO,SAAA;KACR,CAAC;AACJ,CAAC","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  getLocationCoordsByIndex,\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>;\n  dataProvider?: 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 | string[];\n  highlightColor?: string | number[];\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  coords: [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  pickingInfo: FlowmapLayerPickingInfo<L, F> | 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      dataProvider: {\n        // To avoid deck.gl props diffing on comlink worker proxy causing an exception\n        dataProvider: props.dataProvider,\n      },\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            this.setState({pickingInfo: 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            this.setState({pickingInfo: 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._getOrMakeDataProvider(),\n      layersData: undefined,\n      highlightedObject: undefined,\n      pickingInfo: undefined,\n    };\n  }\n\n  getPickingInfo({info}: Record<string, any>) {\n    // This is for onHover event handlers set on the <DeckGL> component\n    if (!info.object) {\n      const object = this.state?.pickingInfo?.object;\n      if (object) {\n        return {\n          ...info,\n          object,\n          picked: true,\n        };\n      }\n    }\n    return info;\n  }\n\n  private _updateAccessors() {\n    this.state?.dataProvider?.setAccessors(this.props);\n    this.setState({accessors: new FlowmapAggregateAccessors(this.props)});\n  }\n\n  private _getOrMakeDataProvider() {\n    const {data, dataProvider} = this.props;\n    if (isFlowmapDataProvider<L, F>(dataProvider?.dataProvider)) {\n      return dataProvider.dataProvider;\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._getOrMakeDataProvider()});\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 (\n      changeFlags.viewportChanged ||\n      changeFlags.propsOrDataChanged // TODO can we ignore accessor props changes?\n    ) {\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: pickViewportProps(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      picked: info.picked,\n      layer: info.layer,\n      index: info.index,\n      x: info.x,\n      y: info.y,\n      coordinate: info.coordinate,\n      event: info.event,\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            object: {\n              type: PickingType.FLOW,\n              flow,\n              origin: origin,\n              dest: dest,\n              count: accessors.getFlowMagnitude(flow),\n            },\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            object: {\n              type: PickingType.LOCATION,\n              location,\n              id,\n              name,\n              totals,\n              circleRadius: circleRadius,\n            },\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          coords: getLocationCoordsByIndex(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: this.props.darkMode\n                ? [0, 0, 0, 255]\n                : [255, 255, 255, 255],\n              outlineEmptyMix: 0.4,\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                    antialiasing: true,\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.coords,\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 pickViewportProps(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-es5/index.d.ts

@@ -0,0 +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 * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist-es5/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,IAAI,sBAAsB,EAAC,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,gBAAgB,CAAC;AACvD,YAAY,EAAC,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAEtD,cAAc,SAAS,CAAC"}

package/dist-es5/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowmapLayer = exports.FlowCirclesLayer = exports.FlowLinesLayer = exports.AnimatedFlowLinesLayer = void 0;
+var AnimatedFlowLinesLayer_1 = require("./AnimatedFlowLinesLayer");
+Object.defineProperty(exports, "AnimatedFlowLinesLayer", { enumerable: true, get: function () { return __importDefault(AnimatedFlowLinesLayer_1).default; } });
+var FlowLinesLayer_1 = require("./FlowLinesLayer");
+Object.defineProperty(exports, "FlowLinesLayer", { enumerable: true, get: function () { return __importDefault(FlowLinesLayer_1).default; } });
+var FlowCirclesLayer_1 = require("./FlowCirclesLayer");
+Object.defineProperty(exports, "FlowCirclesLayer", { enumerable: true, get: function () { return __importDefault(FlowCirclesLayer_1).default; } });
+var FlowmapLayer_1 = require("./FlowmapLayer");
+Object.defineProperty(exports, "FlowmapLayer", { enumerable: true, get: function () { return __importDefault(FlowmapLayer_1).default; } });
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1FQUEyRTtBQUFuRSxpSkFBQSxPQUFPLE9BQTBCO0FBQ3pDLG1EQUEyRDtBQUFuRCxpSUFBQSxPQUFPLE9BQWtCO0FBQ2pDLHVEQUErRDtBQUF2RCxxSUFBQSxPQUFPLE9BQW9CO0FBQ25DLCtDQUF1RDtBQUEvQyw2SEFBQSxPQUFPLE9BQWdCO0FBRy9CLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7ZGVmYXVsdCBhcyBBbmltYXRlZEZsb3dMaW5lc0xheWVyfSBmcm9tICcuL0FuaW1hdGVkRmxvd0xpbmVzTGF5ZXInO1xuZXhwb3J0IHtkZWZhdWx0IGFzIEZsb3dMaW5lc0xheWVyfSBmcm9tICcuL0Zsb3dMaW5lc0xheWVyJztcbmV4cG9ydCB7ZGVmYXVsdCBhcyBGbG93Q2lyY2xlc0xheWVyfSBmcm9tICcuL0Zsb3dDaXJjbGVzTGF5ZXInO1xuZXhwb3J0IHtkZWZhdWx0IGFzIEZsb3dtYXBMYXllcn0gZnJvbSAnLi9GbG93bWFwTGF5ZXInO1xuZXhwb3J0IHR5cGUge0Zsb3dtYXBMYXllclByb3BzfSBmcm9tICcuL0Zsb3dtYXBMYXllcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19

package/dist-es5/types.d.ts

@@ -0,0 +1,36 @@
+import { AggregateFlow, ClusterNode, LocationTotals } from '@flowmap.gl/data';
+export declare type LayerProps = Record<string, unknown>;
+export declare enum PickingType {
+    LOCATION = "location",
+    FLOW = "flow"
+}
+export declare type DeckGLLayer = Record<string, any>;
+export interface PickingInfo<T> {
+    layer: DeckGLLayer;
+    index: number;
+    picked: boolean;
+    object: T | undefined;
+    x: number;
+    y: number;
+    coordinate: [number, number];
+    event: MouseEvent | undefined;
+}
+export interface LocationPickingInfoObject<L> {
+    id: string;
+    type: PickingType.LOCATION;
+    location: L | ClusterNode;
+    name: string;
+    totals: LocationTotals;
+    circleRadius: number;
+}
+export declare type LocationPickingInfo<L> = PickingInfo<LocationPickingInfoObject<L>>;
+export interface FlowPickingInfoObject<L, F> {
+    type: PickingType.FLOW;
+    flow: F | AggregateFlow;
+    origin: L | ClusterNode;
+    dest: L | ClusterNode;
+    count: number;
+}
+export declare type FlowPickingInfo<L, F> = PickingInfo<FlowPickingInfoObject<L, F>>;
+export declare type FlowmapLayerPickingInfo<L, F> = LocationPickingInfo<L> | FlowPickingInfo<L, F>;
+//# sourceMappingURL=types.d.ts.map

package/dist-es5/types.d.ts.map

@@ -0,0 +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,OAAO,CAAC;IAChB,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;IAC7B,KAAK,EAAE,UAAU,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,yBAAyB,CAAC,CAAC;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC;IAC3B,QAAQ,EAAE,CAAC,GAAG,WAAW,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,cAAc,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,oBAAY,mBAAmB,CAAC,CAAC,IAAI,WAAW,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/E,MAAM,WAAW,qBAAqB,CAAC,CAAC,EAAE,CAAC;IACzC,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC;IACvB,IAAI,EAAE,CAAC,GAAG,aAAa,CAAC;IACxB,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC;IACxB,IAAI,EAAE,CAAC,GAAG,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,oBAAY,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,WAAW,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAO7E,oBAAY,uBAAuB,CAAC,CAAC,EAAE,CAAC,IACpC,mBAAmB,CAAC,CAAC,CAAC,GAEtB,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}