@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/layers/layer-update.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.diffUpdateTriggers = diffUpdateTriggers;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/* eslint-disable guard-for-in */
+
+/**
+ *
+ * @param {Object} updateTriggers {getPosition: {column}, getData: {filteredIndex}}
+ * @param {Object} oldUpdateTriggers
+ * @returns {boolean|object} `false` if nothing changed, or `triggerChanged` as an object
+ */
+function diffUpdateTriggers(updateTriggers) {
+  var oldUpdateTriggers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var triggerChanged = {};
+  /** @type {boolean|object} */
+
+  var reason = false;
+
+  for (var triggerName in updateTriggers) {
+    var newTriggers = updateTriggers[triggerName] || {};
+    var oldTriggers = oldUpdateTriggers[triggerName] || {};
+    var diffReason = compareUpdateTrigger(newTriggers, oldTriggers, triggerName);
+
+    if (diffReason) {
+      triggerChanged[triggerName] = true;
+      reason = triggerChanged;
+    }
+  }
+
+  return reason;
+}
+
+function compareUpdateTrigger(newTriggers, oldTriggers, triggerName) {
+  if ((0, _typeof2["default"])(oldTriggers) !== 'object') {
+    return oldTriggers === newTriggers ? null : "".concat(triggerName, " changed shallowly");
+  }
+
+  for (var key in oldTriggers) {
+    if (!(key in newTriggers)) {
+      return "".concat(triggerName, ".").concat(key, " deleted");
+    } // shallow compare
+
+
+    if (oldTriggers[key] !== newTriggers[key]) {
+      return "".concat(triggerName, ".").concat(key, " changed shallowly");
+    }
+  }
+
+  for (var _key in newTriggers) {
+    if (!(_key in oldTriggers)) {
+      return "".concat(triggerName, ".").concat(_key, " added");
+    }
+  }
+
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/layers/line-layer/line-layer-icon.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _base = _interopRequireDefault(require("../../components/common/icons/base"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var LineLayerIcon = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(LineLayerIcon, _Component);
+
+  var _super = _createSuper(LineLayerIcon);
+
+  function LineLayerIcon() {
+    (0, _classCallCheck2["default"])(this, LineLayerIcon);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(LineLayerIcon, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react["default"].createElement(_base["default"], this.props, /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M57.8,58.3c-0.4,0-0.8-0.2-1.1-0.5L33.1,32.1c-0.6-0.6-0.5-1.6,0.1-2.1c0.6-0.6,1.6-0.5,2.1,0.1l23.7,25.8 c0.6,0.6,0.5,1.6-0.1,2.1C58.5,58.2,58.2,58.3,57.8,58.3z",
+        className: "cr1"
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M34.2,33.6c-0.6,0-1.2-0.2-1.7-0.6c-1-0.9-1.1-2.5-0.2-3.5l18.5-21c0.9-1,2.5-1.1,3.5-0.2c1,0.9,1.1,2.5,0.2,3.5L36,32.7 C35.5,33.3,34.9,33.6,34.2,33.6z",
+        className: "cr2"
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M34.2,32.6c-0.5,0-1-0.3-1.3-0.8L20.7,10.2c-0.4-0.7-0.1-1.6,0.6-2c0.7-0.4,1.6-0.1,2,0.6l12.1,21.6c0.4,0.7,0.1,1.6-0.6,2 C34.7,32.5,34.4,32.6,34.2,32.6z",
+        className: "cr3"
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M15.8,58.4c-0.3,0-0.6-0.1-0.9-0.3c-0.7-0.5-0.8-1.4-0.4-2.1l18.3-25.8c0.5-0.7,1.4-0.8,2.1-0.4s0.8,1.4,0.4,2.1L17.1,57.7 C16.8,58.2,16.3,58.4,15.8,58.4z",
+        className: "cr4"
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        d: "M34.2,32.1c-0.1,0-0.3,0-0.4-0.1l-28.5-14c-0.5-0.2-0.7-0.8-0.5-1.3c0.2-0.5,0.8-0.7,1.3-0.5l28.5,14 c0.5,0.2,0.7,0.8,0.5,1.3C34.9,31.9,34.5,32.1,34.2,32.1z",
+        className: "cr5"
+      }));
+    }
+  }]);
+  return LineLayerIcon;
+}(_react.Component);
+
+exports["default"] = LineLayerIcon;
+(0, _defineProperty2["default"])(LineLayerIcon, "propTypes", {
+  /** Set the height of the icon, ex. '16px' */
+  height: _propTypes["default"].string,
+  colors: _propTypes["default"].arrayOf(_propTypes["default"].string)
+});
+(0, _defineProperty2["default"])(LineLayerIcon, "defaultProps", {
+  height: '16px',
+  predefinedClassName: 'line-layer-icon',
+  totalColor: 5
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/layers/line-layer/line-layer.js

@@ -0,0 +1,209 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.lineVisConfigs = exports.lineColumnLabels = exports.lineOptionalColumns = exports.lineRequiredColumns = exports.linePosAccessor = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _extensions = require("@deck.gl/extensions");
+
+var _layerFactory = require("../layer-factory");
+
+var _lineLayerIcon = _interopRequireDefault(require("./line-layer-icon"));
+
+var _arcLayer = _interopRequireDefault(require("../arc-layer/arc-layer"));
+
+var _lineLayer = _interopRequireDefault(require("../../deckgl-layers/line-layer/line-layer"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var linePosAccessor = function linePosAccessor(_ref) {
+  var lat0 = _ref.lat0,
+      lng0 = _ref.lng0,
+      lat1 = _ref.lat1,
+      lng1 = _ref.lng1,
+      alt0 = _ref.alt0,
+      alt1 = _ref.alt1;
+  return function (dc) {
+    return function (d) {
+      return [dc.valueAt(d.index, lng0.fieldIdx), dc.valueAt(d.index, lat0.fieldIdx), (alt0 === null || alt0 === void 0 ? void 0 : alt0.fieldIdx) > -1 ? dc.valueAt(d.index, alt0.fieldIdx) : 0, dc.valueAt(d.index, lng1.fieldIdx), dc.valueAt(d.index, lat1.fieldIdx), (alt1 === null || alt1 === void 0 ? void 0 : alt1.fieldIdx) > -1 ? dc.valueAt(d.index, alt1.fieldIdx) : 0];
+    };
+  };
+};
+
+exports.linePosAccessor = linePosAccessor;
+var lineRequiredColumns = ['lat0', 'lng0', 'lat1', 'lng1'];
+exports.lineRequiredColumns = lineRequiredColumns;
+var lineOptionalColumns = ['alt0', 'alt1'];
+exports.lineOptionalColumns = lineOptionalColumns;
+var lineColumnLabels = {
+  lat0: 'arc.lat0',
+  lng0: 'arc.lng0',
+  lat1: 'arc.lat1',
+  lng1: 'arc.lng1',
+  alt0: 'line.alt0',
+  alt1: 'line.alt1'
+};
+exports.lineColumnLabels = lineColumnLabels;
+var lineVisConfigs = {
+  opacity: 'opacity',
+  thickness: 'thickness',
+  colorRange: 'colorRange',
+  sizeRange: 'strokeWidthRange',
+  targetColor: 'targetColor',
+  elevationScale: _objectSpread(_objectSpread({}, _layerFactory.LAYER_VIS_CONFIGS.elevationScale), {}, {
+    defaultValue: 1
+  })
+};
+exports.lineVisConfigs = lineVisConfigs;
+
+var LineLayer = /*#__PURE__*/function (_ArcLayer) {
+  (0, _inherits2["default"])(LineLayer, _ArcLayer);
+
+  var _super = _createSuper(LineLayer);
+
+  function LineLayer(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, LineLayer);
+    _this = _super.call(this, props);
+
+    _this.registerVisConfig(lineVisConfigs);
+
+    _this.getPositionAccessor = function (dataContainer) {
+      return linePosAccessor(_this.config.columns)(dataContainer);
+    };
+
+    return _this;
+  }
+
+  (0, _createClass2["default"])(LineLayer, [{
+    key: "type",
+    get: function get() {
+      return 'line';
+    }
+  }, {
+    key: "layerIcon",
+    get: function get() {
+      return _lineLayerIcon["default"];
+    }
+  }, {
+    key: "requiredLayerColumns",
+    get: function get() {
+      return lineRequiredColumns;
+    }
+  }, {
+    key: "optionalColumns",
+    get: function get() {
+      return lineOptionalColumns;
+    }
+  }, {
+    key: "columnLabels",
+    get: function get() {
+      return lineColumnLabels;
+    }
+  }, {
+    key: "visualChannels",
+    get: function get() {
+      var visualChannels = (0, _get2["default"])((0, _getPrototypeOf2["default"])(LineLayer.prototype), "visualChannels", this);
+      return _objectSpread(_objectSpread({}, visualChannels), {}, {
+        sourceColor: _objectSpread(_objectSpread({}, visualChannels.sourceColor), {}, {
+          accessor: 'getColor'
+        })
+      });
+    }
+  }, {
+    key: "renderLayer",
+    value: function renderLayer(opts) {
+      var data = opts.data,
+          gpuFilter = opts.gpuFilter,
+          objectHovered = opts.objectHovered,
+          interactionConfig = opts.interactionConfig;
+      var layerProps = {
+        widthScale: this.config.visConfig.thickness,
+        elevationScale: this.config.visConfig.elevationScale
+      };
+
+      var updateTriggers = _objectSpread({
+        getPosition: this.config.columns,
+        getFilterValue: gpuFilter.filterValueUpdateTriggers
+      }, this.getVisualChannelUpdateTriggers());
+
+      var defaultLayerProps = this.getDefaultDeckLayerProps(opts);
+      var hoveredObject = this.hasHoveredObject(objectHovered);
+      return [// base layer
+      new _lineLayer["default"](_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, defaultLayerProps), this.getBrushingExtensionProps(interactionConfig, 'source_target')), data), layerProps), {}, {
+        updateTriggers: updateTriggers,
+        extensions: [].concat((0, _toConsumableArray2["default"])(defaultLayerProps.extensions), [new _extensions.BrushingExtension()])
+      }))].concat((0, _toConsumableArray2["default"])(hoveredObject ? [new _lineLayer["default"](_objectSpread(_objectSpread(_objectSpread({}, this.getDefaultHoverLayerProps()), layerProps), {}, {
+        data: [hoveredObject],
+        getColor: this.config.highlightColor,
+        getTargetColor: this.config.highlightColor,
+        getWidth: data.getWidth
+      }))] : []));
+    }
+  }], [{
+    key: "findDefaultLayerProps",
+    value: function findDefaultLayerProps(_ref2) {
+      var _ref2$fieldPairs = _ref2.fieldPairs,
+          fieldPairs = _ref2$fieldPairs === void 0 ? [] : _ref2$fieldPairs;
+
+      if (fieldPairs.length < 2) {
+        return {
+          props: []
+        };
+      }
+
+      var props = {}; // connect the first two point layer with line
+
+      props.columns = {
+        lat0: fieldPairs[0].pair.lat,
+        lng0: fieldPairs[0].pair.lng,
+        alt0: {
+          value: null,
+          fieldIdx: -1,
+          optional: true
+        },
+        lat1: fieldPairs[1].pair.lat,
+        lng1: fieldPairs[1].pair.lng,
+        alt1: {
+          value: null,
+          fieldIdx: -1,
+          optional: true
+        }
+      };
+      props.label = "".concat(fieldPairs[0].defaultName, " -> ").concat(fieldPairs[1].defaultName, " line");
+      return {
+        props: [props]
+      };
+    }
+  }]);
+  return LineLayer;
+}(_arcLayer["default"]);
+
+exports["default"] = LineLayer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/layers/line-layer/line-layer.js"],"names":["linePosAccessor","lat0","lng0","lat1","lng1","alt0","alt1","dc","d","valueAt","index","fieldIdx","lineRequiredColumns","lineOptionalColumns","lineColumnLabels","lineVisConfigs","opacity","thickness","colorRange","sizeRange","targetColor","elevationScale","LAYER_VIS_CONFIGS","defaultValue","LineLayer","props","registerVisConfig","getPositionAccessor","dataContainer","config","columns","LineLayerIcon","visualChannels","sourceColor","accessor","opts","data","gpuFilter","objectHovered","interactionConfig","layerProps","widthScale","visConfig","updateTriggers","getPosition","getFilterValue","filterValueUpdateTriggers","getVisualChannelUpdateTriggers","defaultLayerProps","getDefaultDeckLayerProps","hoveredObject","hasHoveredObject","EnhancedLineLayer","getBrushingExtensionProps","extensions","BrushingExtension","getDefaultHoverLayerProps","getColor","highlightColor","getTargetColor","getWidth","fieldPairs","length","pair","lat","lng","value","optional","label","defaultName","ArcLayer"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {BrushingExtension} from '@deck.gl/extensions';\n\nimport {LAYER_VIS_CONFIGS} from 'layers/layer-factory';\nimport LineLayerIcon from './line-layer-icon';\nimport ArcLayer from '../arc-layer/arc-layer';\nimport EnhancedLineLayer from 'deckgl-layers/line-layer/line-layer';\n\nexport const linePosAccessor = ({lat0, lng0, lat1, lng1, alt0, alt1}) => dc => d => [\n  dc.valueAt(d.index, lng0.fieldIdx),\n  dc.valueAt(d.index, lat0.fieldIdx),\n  alt0?.fieldIdx > -1 ? dc.valueAt(d.index, alt0.fieldIdx) : 0,\n  dc.valueAt(d.index, lng1.fieldIdx),\n  dc.valueAt(d.index, lat1.fieldIdx),\n  alt1?.fieldIdx > -1 ? dc.valueAt(d.index, alt1.fieldIdx) : 0\n];\n\nexport const lineRequiredColumns = ['lat0', 'lng0', 'lat1', 'lng1'];\nexport const lineOptionalColumns = ['alt0', 'alt1'];\n\nexport const lineColumnLabels = {\n  lat0: 'arc.lat0',\n  lng0: 'arc.lng0',\n  lat1: 'arc.lat1',\n  lng1: 'arc.lng1',\n  alt0: 'line.alt0',\n  alt1: 'line.alt1'\n};\n\nexport const lineVisConfigs = {\n  opacity: 'opacity',\n  thickness: 'thickness',\n  colorRange: 'colorRange',\n  sizeRange: 'strokeWidthRange',\n  targetColor: 'targetColor',\n  elevationScale: {\n    ...LAYER_VIS_CONFIGS.elevationScale,\n    defaultValue: 1\n  }\n};\n\nexport default class LineLayer extends ArcLayer {\n  constructor(props) {\n    super(props);\n\n    this.registerVisConfig(lineVisConfigs);\n    this.getPositionAccessor = dataContainer => linePosAccessor(this.config.columns)(dataContainer);\n  }\n\n  get type() {\n    return 'line';\n  }\n\n  get layerIcon() {\n    return LineLayerIcon;\n  }\n\n  get requiredLayerColumns() {\n    return lineRequiredColumns;\n  }\n\n  get optionalColumns() {\n    return lineOptionalColumns;\n  }\n\n  get columnLabels() {\n    return lineColumnLabels;\n  }\n\n  get visualChannels() {\n    const visualChannels = super.visualChannels;\n    return {\n      ...visualChannels,\n      sourceColor: {\n        ...visualChannels.sourceColor,\n        accessor: 'getColor'\n      }\n    };\n  }\n\n  static findDefaultLayerProps({fieldPairs = []}) {\n    if (fieldPairs.length < 2) {\n      return {props: []};\n    }\n    const props = {};\n\n    // connect the first two point layer with line\n    props.columns = {\n      lat0: fieldPairs[0].pair.lat,\n      lng0: fieldPairs[0].pair.lng,\n      alt0: {value: null, fieldIdx: -1, optional: true},\n      lat1: fieldPairs[1].pair.lat,\n      lng1: fieldPairs[1].pair.lng,\n      alt1: {value: null, fieldIdx: -1, optional: true}\n    };\n    props.label = `${fieldPairs[0].defaultName} -> ${fieldPairs[1].defaultName} line`;\n\n    return {props: [props]};\n  }\n\n  renderLayer(opts) {\n    const {data, gpuFilter, objectHovered, interactionConfig} = opts;\n\n    const layerProps = {\n      widthScale: this.config.visConfig.thickness,\n      elevationScale: this.config.visConfig.elevationScale\n    };\n\n    const updateTriggers = {\n      getPosition: this.config.columns,\n      getFilterValue: gpuFilter.filterValueUpdateTriggers,\n      ...this.getVisualChannelUpdateTriggers()\n    };\n    const defaultLayerProps = this.getDefaultDeckLayerProps(opts);\n    const hoveredObject = this.hasHoveredObject(objectHovered);\n\n    return [\n      // base layer\n      new EnhancedLineLayer({\n        ...defaultLayerProps,\n        ...this.getBrushingExtensionProps(interactionConfig, 'source_target'),\n        ...data,\n        ...layerProps,\n        updateTriggers,\n        extensions: [...defaultLayerProps.extensions, new BrushingExtension()]\n      }),\n      // hover layer\n      ...(hoveredObject\n        ? [\n            new EnhancedLineLayer({\n              ...this.getDefaultHoverLayerProps(),\n              ...layerProps,\n              data: [hoveredObject],\n              getColor: this.config.highlightColor,\n              getTargetColor: this.config.highlightColor,\n              getWidth: data.getWidth\n            })\n          ]\n        : [])\n    ];\n  }\n}\n"]}

package/dist/layers/mapbox-utils.js

@@ -0,0 +1,204 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateMapboxLayers = generateMapboxLayers;
+exports.updateMapboxLayers = updateMapboxLayers;
+exports.geoJsonFromData = geoJsonFromData;
+exports.gpuFilterToMapboxFilter = gpuFilterToMapboxFilter;
+exports.prefixGpuField = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _baseLayer = require("./base-layer");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/** @typedef {import("geojson").FeatureCollection} FeatureCollection */
+
+/** @typedef {import("geojson").Feature} Feature */
+
+/**
+ * This function will convert layers to mapbox layers
+ * @param {Array<Object>} layers the layers to be converted
+ * @param {Array<Object>} layerData extra layer information
+ * @param {Array<Number>} layerOrder the order by which we should convert layers
+ * @param {Object} layersToRender {[id]: true | false} object whether each layer should be rendered
+ * @returns {Object} {[id]: layer}
+ */
+function generateMapboxLayers() {
+  var layers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var layerData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var layerOrder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var layersToRender = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+  if (layerData.length > 0) {
+    return layerOrder.slice().reverse().filter(function (idx) {
+      return layers[idx].overlayType === _baseLayer.OVERLAY_TYPE.mapboxgl && layersToRender[layers[idx].id];
+    }).reduce(function (accu, index) {
+      var layer = layers[index];
+      return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, layer.id, {
+        id: layer.id,
+        data: layerData[index].data,
+        isVisible: layer.config.isVisible,
+        config: layerData[index].config,
+        hidden: layer.config.hidden,
+        sourceId: layerData[index].config.source
+      }));
+    }, {});
+  }
+
+  return {};
+}
+/**
+ * Update mapbox layers on the given map
+ * @param {Object} map
+ * @param {Object} newLayers Map of new mapbox layers to be displayed
+ * @param {Object} oldLayers Map of the old layers to be compare with the current ones to detect deleted layers
+ *                  {layerId: sourceId}
+ */
+
+
+function updateMapboxLayers(map) {
+  var newLayers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var oldLayers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+  // delete no longer existed old layers
+  if (oldLayers) {
+    checkAndRemoveOldLayers(map, oldLayers, newLayers);
+  } // insert or update new layer
+
+
+  Object.values(newLayers).forEach(function (overlay) {
+    var layerId = overlay.id,
+        config = overlay.config,
+        data = overlay.data,
+        sourceId = overlay.sourceId,
+        isVisible = overlay.isVisible;
+
+    if (!data && !config) {
+      return;
+    }
+
+    var _ref = oldLayers && oldLayers[layerId] || {},
+        oldData = _ref.data,
+        oldConfig = _ref.config;
+
+    if (data && data !== oldData) {
+      updateSourceData(map, sourceId, data);
+    } // compare with previous configs
+
+
+    if (oldConfig !== config) {
+      updateLayerConfig(map, layerId, config, isVisible);
+    }
+  });
+}
+
+function checkAndRemoveOldLayers(map, oldLayers, newLayers) {
+  Object.keys(oldLayers).forEach(function (layerId) {
+    if (!newLayers[layerId]) {
+      map.removeLayer(layerId);
+    }
+  });
+}
+
+function updateLayerConfig(map, layerId, config, isVisible) {
+  var mapboxLayer = map.getLayer(layerId);
+
+  if (mapboxLayer) {
+    // check if layer already is set
+    // remove it if exists
+    map.removeLayer(layerId);
+  }
+
+  map.addLayer(config);
+  map.setLayoutProperty(layerId, 'visibility', isVisible ? 'visible' : 'none');
+}
+
+function updateSourceData(map, sourceId, data) {
+  var source = map.getSource(sourceId);
+
+  if (!source) {
+    map.addSource(sourceId, {
+      type: 'geojson',
+      data: data
+    });
+  } else {
+    source.setData(data);
+  }
+}
+/**
+ *
+ * @param filteredIndex
+ * @param getGeometry {({index: number}) => any}
+ * @param getProperties {({index: number}) => any}
+ * @returns FeatureCollection
+ */
+
+
+function geoJsonFromData() {
+  var filteredIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var getGeometry = arguments.length > 1 ? arguments[1] : undefined;
+  var getProperties = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (d) {};
+  var geojson = {
+    type: 'FeatureCollection',
+
+    /** @type {Feature[]} */
+    features: []
+  };
+
+  for (var i = 0; i < filteredIndex.length; i++) {
+    var index = filteredIndex[i];
+    var rowIndex = {
+      index: index
+    };
+    var geometry = getGeometry(rowIndex);
+
+    if (geometry) {
+      geojson.features.push({
+        type: 'Feature',
+        properties: _objectSpread({
+          index: index
+        }, getProperties(rowIndex)),
+        geometry: geometry
+      });
+    }
+  }
+
+  return geojson;
+}
+
+var prefixGpuField = function prefixGpuField(name) {
+  return "gpu:".concat(name);
+};
+
+exports.prefixGpuField = prefixGpuField;
+
+function gpuFilterToMapboxFilter(gpuFilter) {
+  var filterRange = gpuFilter.filterRange,
+      filterValueUpdateTriggers = gpuFilter.filterValueUpdateTriggers;
+  var hasFilter = Object.values(filterValueUpdateTriggers).filter(function (d) {
+    return d;
+  });
+
+  if (!hasFilter.length) {
+    return null;
+  }
+
+  var condition = ['all']; // [">=", key, value]
+  // ["<=", key, value]
+
+  var expressions = Object.values(filterValueUpdateTriggers).reduce(function (accu, name, i) {
+    return name ? [].concat((0, _toConsumableArray2["default"])(accu), [['>=', prefixGpuField(name), filterRange[i][0]], ['<=', prefixGpuField(name), filterRange[i][1]]]) : accu;
+  }, condition);
+  return expressions;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/layers/mapbox-utils.js"],"names":["generateMapboxLayers","layers","layerData","layerOrder","layersToRender","length","slice","reverse","filter","idx","overlayType","OVERLAY_TYPE","mapboxgl","id","reduce","accu","index","layer","data","isVisible","config","hidden","sourceId","source","updateMapboxLayers","map","newLayers","oldLayers","checkAndRemoveOldLayers","Object","values","forEach","overlay","layerId","oldData","oldConfig","updateSourceData","updateLayerConfig","keys","removeLayer","mapboxLayer","getLayer","addLayer","setLayoutProperty","getSource","addSource","type","setData","geoJsonFromData","filteredIndex","getGeometry","getProperties","d","geojson","features","i","rowIndex","geometry","push","properties","prefixGpuField","name","gpuFilterToMapboxFilter","gpuFilter","filterRange","filterValueUpdateTriggers","hasFilter","condition","expressions"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {OVERLAY_TYPE} from './base-layer';\n\n/** @typedef {import(\"geojson\").FeatureCollection} FeatureCollection */\n/** @typedef {import(\"geojson\").Feature} Feature */\n\n/**\n * This function will convert layers to mapbox layers\n * @param {Array<Object>} layers the layers to be converted\n * @param {Array<Object>} layerData extra layer information\n * @param {Array<Number>} layerOrder the order by which we should convert layers\n * @param {Object} layersToRender {[id]: true | false} object whether each layer should be rendered\n * @returns {Object} {[id]: layer}\n */\nexport function generateMapboxLayers(\n  layers = [],\n  layerData = [],\n  layerOrder = [],\n  layersToRender = {}\n) {\n  if (layerData.length > 0) {\n    return layerOrder\n      .slice()\n      .reverse()\n      .filter(\n        idx => layers[idx].overlayType === OVERLAY_TYPE.mapboxgl && layersToRender[layers[idx].id]\n      )\n      .reduce((accu, index) => {\n        const layer = layers[index];\n        return {\n          ...accu,\n          [layer.id]: {\n            id: layer.id,\n            data: layerData[index].data,\n            isVisible: layer.config.isVisible,\n            config: layerData[index].config,\n            hidden: layer.config.hidden,\n            sourceId: layerData[index].config.source\n          }\n        };\n      }, {});\n  }\n\n  return {};\n}\n\n/**\n * Update mapbox layers on the given map\n * @param {Object} map\n * @param {Object} newLayers Map of new mapbox layers to be displayed\n * @param {Object} oldLayers Map of the old layers to be compare with the current ones to detect deleted layers\n *                  {layerId: sourceId}\n */\nexport function updateMapboxLayers(map, newLayers = {}, oldLayers = null) {\n  // delete no longer existed old layers\n  if (oldLayers) {\n    checkAndRemoveOldLayers(map, oldLayers, newLayers);\n  }\n\n  // insert or update new layer\n  Object.values(newLayers).forEach(overlay => {\n    const {id: layerId, config, data, sourceId, isVisible} = overlay;\n    if (!data && !config) {\n      return;\n    }\n\n    const {data: oldData, config: oldConfig} = (oldLayers && oldLayers[layerId]) || {};\n\n    if (data && data !== oldData) {\n      updateSourceData(map, sourceId, data);\n    }\n\n    // compare with previous configs\n    if (oldConfig !== config) {\n      updateLayerConfig(map, layerId, config, isVisible);\n    }\n  });\n}\n\nfunction checkAndRemoveOldLayers(map, oldLayers, newLayers) {\n  Object.keys(oldLayers).forEach(layerId => {\n    if (!newLayers[layerId]) {\n      map.removeLayer(layerId);\n    }\n  });\n}\n\nfunction updateLayerConfig(map, layerId, config, isVisible) {\n  const mapboxLayer = map.getLayer(layerId);\n\n  if (mapboxLayer) {\n    // check if layer already is set\n    // remove it if exists\n    map.removeLayer(layerId);\n  }\n\n  map.addLayer(config);\n  map.setLayoutProperty(layerId, 'visibility', isVisible ? 'visible' : 'none');\n}\n\nfunction updateSourceData(map, sourceId, data) {\n  const source = map.getSource(sourceId);\n\n  if (!source) {\n    map.addSource(sourceId, {\n      type: 'geojson',\n      data\n    });\n  } else {\n    source.setData(data);\n  }\n}\n\n/**\n *\n * @param filteredIndex\n * @param getGeometry {({index: number}) => any}\n * @param getProperties {({index: number}) => any}\n * @returns FeatureCollection\n */\nexport function geoJsonFromData(filteredIndex = [], getGeometry, getProperties = d => {}) {\n  const geojson = {\n    type: 'FeatureCollection',\n    /** @type {Feature[]} */\n    features: []\n  };\n\n  for (let i = 0; i < filteredIndex.length; i++) {\n    const index = filteredIndex[i];\n    const rowIndex = {index};\n    const geometry = getGeometry(rowIndex);\n\n    if (geometry) {\n      geojson.features.push({\n        type: 'Feature',\n        properties: {\n          index,\n          ...getProperties(rowIndex)\n        },\n        geometry\n      });\n    }\n  }\n\n  return geojson;\n}\n\nexport const prefixGpuField = name => `gpu:${name}`;\n\nexport function gpuFilterToMapboxFilter(gpuFilter) {\n  const {filterRange, filterValueUpdateTriggers} = gpuFilter;\n\n  const hasFilter = Object.values(filterValueUpdateTriggers).filter(d => d);\n\n  if (!hasFilter.length) {\n    return null;\n  }\n\n  const condition = ['all'];\n\n  // [\">=\", key, value]\n  // [\"<=\", key, value]\n  const expressions = Object.values(filterValueUpdateTriggers).reduce(\n    (accu, name, i) =>\n      name\n        ? [\n            ...accu,\n            ['>=', prefixGpuField(name), filterRange[i][0]],\n            ['<=', prefixGpuField(name), filterRange[i][1]]\n          ]\n        : accu,\n    condition\n  );\n\n  return expressions;\n}\n"]}