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

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

@@ -0,0 +1,275 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.arcVisConfigs = exports.arcColumnLabels = exports.arcRequiredColumns = exports.arcPosAccessor = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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 _baseLayer = _interopRequireDefault(require("../base-layer"));
+
+var _extensions = require("@deck.gl/extensions");
+
+var _layers = require("@deck.gl/layers");
+
+var _colorUtils = require("../../utils/color-utils");
+
+var _arcLayerIcon = _interopRequireDefault(require("./arc-layer-icon"));
+
+var _defaultSettings = require("../../constants/default-settings");
+
+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; }
+
+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 arcPosAccessor = function arcPosAccessor(_ref) {
+  var lat0 = _ref.lat0,
+      lng0 = _ref.lng0,
+      lat1 = _ref.lat1,
+      lng1 = _ref.lng1;
+  return function (dc) {
+    return function (d) {
+      return [dc.valueAt(d.index, lng0.fieldIdx), dc.valueAt(d.index, lat0.fieldIdx), 0, dc.valueAt(d.index, lng1.fieldIdx), dc.valueAt(d.index, lat1.fieldIdx), 0];
+    };
+  };
+};
+
+exports.arcPosAccessor = arcPosAccessor;
+var arcRequiredColumns = ['lat0', 'lng0', 'lat1', 'lng1'];
+exports.arcRequiredColumns = arcRequiredColumns;
+var arcColumnLabels = {
+  lat0: 'arc.lat0',
+  lng0: 'arc.lng0',
+  lat1: 'arc.lat1',
+  lng1: 'arc.lng1'
+};
+exports.arcColumnLabels = arcColumnLabels;
+var arcVisConfigs = {
+  opacity: 'opacity',
+  thickness: 'thickness',
+  colorRange: 'colorRange',
+  sizeRange: 'strokeWidthRange',
+  targetColor: 'targetColor'
+};
+exports.arcVisConfigs = arcVisConfigs;
+
+var ArcLayer = /*#__PURE__*/function (_Layer) {
+  (0, _inherits2["default"])(ArcLayer, _Layer);
+
+  var _super = _createSuper(ArcLayer);
+
+  function ArcLayer(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, ArcLayer);
+    _this = _super.call(this, props);
+
+    _this.registerVisConfig(arcVisConfigs);
+
+    _this.getPositionAccessor = function (dataContainer) {
+      return arcPosAccessor(_this.config.columns)(dataContainer);
+    };
+
+    return _this;
+  }
+
+  (0, _createClass2["default"])(ArcLayer, [{
+    key: "type",
+    get: function get() {
+      return 'arc';
+    }
+  }, {
+    key: "isAggregated",
+    get: function get() {
+      return false;
+    }
+  }, {
+    key: "layerIcon",
+    get: function get() {
+      return _arcLayerIcon["default"];
+    }
+  }, {
+    key: "requiredLayerColumns",
+    get: function get() {
+      return arcRequiredColumns;
+    }
+  }, {
+    key: "columnLabels",
+    get: function get() {
+      return arcColumnLabels;
+    }
+  }, {
+    key: "columnPairs",
+    get: function get() {
+      return this.defaultLinkColumnPairs;
+    }
+  }, {
+    key: "visualChannels",
+    get: function get() {
+      return {
+        sourceColor: _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(ArcLayer.prototype), "visualChannels", this).color), {}, {
+          property: 'color',
+          key: 'sourceColor',
+          accessor: 'getSourceColor',
+          defaultValue: function defaultValue(config) {
+            return config.color;
+          }
+        }),
+        targetColor: _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(ArcLayer.prototype), "visualChannels", this).color), {}, {
+          property: 'targetColor',
+          key: 'targetColor',
+          accessor: 'getTargetColor',
+          defaultValue: function defaultValue(config) {
+            return config.visConfig.targetColor || config.color;
+          }
+        }),
+        size: _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(ArcLayer.prototype), "visualChannels", this).size), {}, {
+          accessor: 'getWidth',
+          property: 'stroke'
+        })
+      };
+    }
+  }, {
+    key: "calculateDataAttribute",
+    value: function calculateDataAttribute(_ref2, getPosition) {
+      var dataContainer = _ref2.dataContainer,
+          filteredIndex = _ref2.filteredIndex;
+      var data = [];
+
+      for (var i = 0; i < filteredIndex.length; i++) {
+        var index = filteredIndex[i];
+        var pos = getPosition({
+          index: index
+        }); // if doesn't have point lat or lng, do not add the point
+        // deck.gl can't handle position = null
+
+        if (pos.every(Number.isFinite)) {
+          data.push({
+            index: index,
+            sourcePosition: [pos[0], pos[1], pos[2]],
+            targetPosition: [pos[3], pos[4], pos[5]]
+          });
+        }
+      }
+
+      return data;
+    }
+  }, {
+    key: "formatLayerData",
+    value: function formatLayerData(datasets, oldLayerData) {
+      var _datasets$this$config = datasets[this.config.dataId],
+          gpuFilter = _datasets$this$config.gpuFilter,
+          dataContainer = _datasets$this$config.dataContainer;
+
+      var _this$updateData = this.updateData(datasets, oldLayerData),
+          data = _this$updateData.data;
+
+      var accessors = this.getAttributeAccessors({
+        dataContainer: dataContainer
+      });
+      return _objectSpread({
+        data: data,
+        getFilterValue: gpuFilter.filterValueAccessor(dataContainer)()
+      }, accessors);
+    }
+    /* eslint-enable complexity */
+
+  }, {
+    key: "updateLayerMeta",
+    value: function updateLayerMeta(dataContainer) {
+      // get bounds from arcs
+      var getPosition = this.getPositionAccessor(dataContainer);
+      var sBounds = this.getPointsBounds(dataContainer, function (d, i) {
+        var pos = getPosition(d);
+        return [pos[0], pos[1]];
+      });
+      var tBounds = this.getPointsBounds(dataContainer, function (d, i) {
+        var pos = getPosition(d);
+        return [pos[3], pos[4]];
+      });
+      var bounds = tBounds && sBounds ? [Math.min(sBounds[0], tBounds[0]), Math.min(sBounds[1], tBounds[1]), Math.max(sBounds[2], tBounds[2]), Math.max(sBounds[3], tBounds[3])] : sBounds || tBounds;
+      this.updateMeta({
+        bounds: bounds
+      });
+    }
+  }, {
+    key: "renderLayer",
+    value: function renderLayer(opts) {
+      var data = opts.data,
+          gpuFilter = opts.gpuFilter,
+          objectHovered = opts.objectHovered,
+          interactionConfig = opts.interactionConfig;
+
+      var updateTriggers = _objectSpread({
+        getPosition: this.config.columns,
+        getFilterValue: gpuFilter.filterValueUpdateTriggers
+      }, this.getVisualChannelUpdateTriggers());
+
+      var defaultLayerProps = this.getDefaultDeckLayerProps(opts);
+      var hoveredObject = this.hasHoveredObject(objectHovered);
+      return [new _layers.ArcLayer(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, defaultLayerProps), this.getBrushingExtensionProps(interactionConfig, 'source_target')), data), {}, {
+        widthScale: this.config.visConfig.thickness,
+        updateTriggers: updateTriggers,
+        extensions: [].concat((0, _toConsumableArray2["default"])(defaultLayerProps.extensions), [new _extensions.BrushingExtension()])
+      }))].concat((0, _toConsumableArray2["default"])(hoveredObject ? [new _layers.ArcLayer(_objectSpread(_objectSpread({}, this.getDefaultHoverLayerProps()), {}, {
+        data: [hoveredObject],
+        widthScale: this.config.visConfig.thickness,
+        getSourceColor: this.config.highlightColor,
+        getTargetColor: this.config.highlightColor,
+        getWidth: data.getWidth
+      }))] : []));
+    }
+  }], [{
+    key: "findDefaultLayerProps",
+    value: function findDefaultLayerProps(_ref3) {
+      var _ref3$fieldPairs = _ref3.fieldPairs,
+          fieldPairs = _ref3$fieldPairs === void 0 ? [] : _ref3$fieldPairs;
+
+      if (fieldPairs.length < 2) {
+        return {
+          props: []
+        };
+      }
+
+      var props = {
+        color: (0, _colorUtils.hexToRgb)(_defaultSettings.DEFAULT_LAYER_COLOR.tripArc)
+      }; // connect the first two point layer with arc
+
+      props.columns = {
+        lat0: fieldPairs[0].pair.lat,
+        lng0: fieldPairs[0].pair.lng,
+        lat1: fieldPairs[1].pair.lat,
+        lng1: fieldPairs[1].pair.lng
+      };
+      props.label = "".concat(fieldPairs[0].defaultName, " -> ").concat(fieldPairs[1].defaultName, " arc");
+      return {
+        props: [props]
+      };
+    }
+  }]);
+  return ArcLayer;
+}(_baseLayer["default"]);
+
+exports["default"] = ArcLayer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/layers/arc-layer/arc-layer.js"],"names":["arcPosAccessor","lat0","lng0","lat1","lng1","dc","d","valueAt","index","fieldIdx","arcRequiredColumns","arcColumnLabels","arcVisConfigs","opacity","thickness","colorRange","sizeRange","targetColor","ArcLayer","props","registerVisConfig","getPositionAccessor","dataContainer","config","columns","ArcLayerIcon","defaultLinkColumnPairs","sourceColor","color","property","key","accessor","defaultValue","visConfig","size","getPosition","filteredIndex","data","i","length","pos","every","Number","isFinite","push","sourcePosition","targetPosition","datasets","oldLayerData","dataId","gpuFilter","updateData","accessors","getAttributeAccessors","getFilterValue","filterValueAccessor","sBounds","getPointsBounds","tBounds","bounds","Math","min","max","updateMeta","opts","objectHovered","interactionConfig","updateTriggers","filterValueUpdateTriggers","getVisualChannelUpdateTriggers","defaultLayerProps","getDefaultDeckLayerProps","hoveredObject","hasHoveredObject","DeckArcLayer","getBrushingExtensionProps","widthScale","extensions","BrushingExtension","getDefaultHoverLayerProps","getSourceColor","highlightColor","getTargetColor","getWidth","fieldPairs","DEFAULT_LAYER_COLOR","tripArc","pair","lat","lng","label","defaultName","Layer"],"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 Layer from '../base-layer';\nimport {BrushingExtension} from '@deck.gl/extensions';\nimport {ArcLayer as DeckArcLayer} from '@deck.gl/layers';\n\nimport {hexToRgb} from 'utils/color-utils';\nimport ArcLayerIcon from './arc-layer-icon';\nimport {DEFAULT_LAYER_COLOR} from 'constants/default-settings';\n\nexport const arcPosAccessor = ({lat0, lng0, lat1, lng1}) => dc => d => [\n  dc.valueAt(d.index, lng0.fieldIdx),\n  dc.valueAt(d.index, lat0.fieldIdx),\n  0,\n  dc.valueAt(d.index, lng1.fieldIdx),\n  dc.valueAt(d.index, lat1.fieldIdx),\n  0\n];\n\nexport const arcRequiredColumns = ['lat0', 'lng0', 'lat1', 'lng1'];\nexport const arcColumnLabels = {\n  lat0: 'arc.lat0',\n  lng0: 'arc.lng0',\n  lat1: 'arc.lat1',\n  lng1: 'arc.lng1'\n};\n\nexport const arcVisConfigs = {\n  opacity: 'opacity',\n  thickness: 'thickness',\n  colorRange: 'colorRange',\n  sizeRange: 'strokeWidthRange',\n  targetColor: 'targetColor'\n};\n\nexport default class ArcLayer extends Layer {\n  constructor(props) {\n    super(props);\n\n    this.registerVisConfig(arcVisConfigs);\n    this.getPositionAccessor = dataContainer => arcPosAccessor(this.config.columns)(dataContainer);\n  }\n\n  get type() {\n    return 'arc';\n  }\n\n  get isAggregated() {\n    return false;\n  }\n\n  get layerIcon() {\n    return ArcLayerIcon;\n  }\n\n  get requiredLayerColumns() {\n    return arcRequiredColumns;\n  }\n\n  get columnLabels() {\n    return arcColumnLabels;\n  }\n  get columnPairs() {\n    return this.defaultLinkColumnPairs;\n  }\n\n  get visualChannels() {\n    return {\n      sourceColor: {\n        ...super.visualChannels.color,\n        property: 'color',\n        key: 'sourceColor',\n        accessor: 'getSourceColor',\n        defaultValue: config => config.color\n      },\n      targetColor: {\n        ...super.visualChannels.color,\n        property: 'targetColor',\n        key: 'targetColor',\n        accessor: 'getTargetColor',\n        defaultValue: config => config.visConfig.targetColor || config.color\n      },\n      size: {\n        ...super.visualChannels.size,\n        accessor: 'getWidth',\n        property: 'stroke'\n      }\n    };\n  }\n\n  static findDefaultLayerProps({fieldPairs = []}) {\n    if (fieldPairs.length < 2) {\n      return {props: []};\n    }\n\n    const props = {\n      color: hexToRgb(DEFAULT_LAYER_COLOR.tripArc)\n    };\n\n    // connect the first two point layer with arc\n    props.columns = {\n      lat0: fieldPairs[0].pair.lat,\n      lng0: fieldPairs[0].pair.lng,\n      lat1: fieldPairs[1].pair.lat,\n      lng1: fieldPairs[1].pair.lng\n    };\n    props.label = `${fieldPairs[0].defaultName} -> ${fieldPairs[1].defaultName} arc`;\n\n    return {props: [props]};\n  }\n\n  calculateDataAttribute({dataContainer, filteredIndex}, getPosition) {\n    const data = [];\n    for (let i = 0; i < filteredIndex.length; i++) {\n      const index = filteredIndex[i];\n      const pos = getPosition({index});\n\n      // if doesn't have point lat or lng, do not add the point\n      // deck.gl can't handle position = null\n      if (pos.every(Number.isFinite)) {\n        data.push({\n          index,\n          sourcePosition: [pos[0], pos[1], pos[2]],\n          targetPosition: [pos[3], pos[4], pos[5]]\n        });\n      }\n    }\n\n    return data;\n  }\n\n  formatLayerData(datasets, oldLayerData) {\n    const {gpuFilter, dataContainer} = datasets[this.config.dataId];\n    const {data} = this.updateData(datasets, oldLayerData);\n    const accessors = this.getAttributeAccessors({dataContainer});\n    return {\n      data,\n      getFilterValue: gpuFilter.filterValueAccessor(dataContainer)(),\n      ...accessors\n    };\n  }\n  /* eslint-enable complexity */\n\n  updateLayerMeta(dataContainer) {\n    // get bounds from arcs\n    const getPosition = this.getPositionAccessor(dataContainer);\n\n    const sBounds = this.getPointsBounds(dataContainer, (d, i) => {\n      const pos = getPosition(d);\n      return [pos[0], pos[1]];\n    });\n    const tBounds = this.getPointsBounds(dataContainer, (d, i) => {\n      const pos = getPosition(d);\n      return [pos[3], pos[4]];\n    });\n\n    const bounds =\n      tBounds && sBounds\n        ? [\n            Math.min(sBounds[0], tBounds[0]),\n            Math.min(sBounds[1], tBounds[1]),\n            Math.max(sBounds[2], tBounds[2]),\n            Math.max(sBounds[3], tBounds[3])\n          ]\n        : sBounds || tBounds;\n\n    this.updateMeta({bounds});\n  }\n\n  renderLayer(opts) {\n    const {data, gpuFilter, objectHovered, interactionConfig} = opts;\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    return [\n      new DeckArcLayer({\n        ...defaultLayerProps,\n        ...this.getBrushingExtensionProps(interactionConfig, 'source_target'),\n        ...data,\n        widthScale: this.config.visConfig.thickness,\n        updateTriggers,\n        extensions: [...defaultLayerProps.extensions, new BrushingExtension()]\n      }),\n      // hover layer\n      ...(hoveredObject\n        ? [\n            new DeckArcLayer({\n              ...this.getDefaultHoverLayerProps(),\n              data: [hoveredObject],\n              widthScale: this.config.visConfig.thickness,\n              getSourceColor: this.config.highlightColor,\n              getTargetColor: this.config.highlightColor,\n              getWidth: data.getWidth\n            })\n          ]\n        : [])\n    ];\n  }\n}\n"]}